Create Python literals using #py reader tag (#337)

* Create Python literals using #py reader tag

* Testing

* Fix MyPy error

* Some lrepr tests

* Support all Python collection literals

* Formatting

* More tests

* More tests

Author: chrisrink10

src/basilisp/lang/compiler/__init__.py

@@ -25,7 +25,7 @@
     WARN_ON_SHADOWED_VAR,
     WARN_ON_UNUSED_NAMES,
 )
-from basilisp.lang.typing import LispForm
+from basilisp.lang.typing import ReaderForm
 from basilisp.lang.util import genname
 
 _DEFAULT_FN = "__lisp_expr__"
@@ -67,7 +67,7 @@ def py_ast_optimizer(self) -> PythonASTOptimizer:
 
 
 def compile_and_exec_form(  # pylint: disable= too-many-arguments
-    form: LispForm,
+    form: ReaderForm,
     ctx: CompilerContext,
     module: types.ModuleType,
     wrapped_fn_name: str = _DEFAULT_FN,
@@ -164,7 +164,7 @@ def _bootstrap_module(
 
 
 def compile_module(
-    forms: Iterable[LispForm],
+    forms: Iterable[ReaderForm],
     ctx: CompilerContext,
     module: types.ModuleType,
     collect_bytecode: Optional[BytecodeCollector] = None,

src/basilisp/lang/compiler/generator.py

@@ -79,6 +79,10 @@
     Binding,
     NodeEnv,
     Catch,
+    PyList,
+    PySet,
+    PyTuple,
+    PyDict,
 )
 from basilisp.lang.runtime import Var
 from basilisp.lang.typing import LispForm
@@ -1752,6 +1756,51 @@ def _vec_to_py_ast(
     )
 
 
+#####################
+# Python Collections
+#####################
+
+
+@_with_ast_loc
+def _py_dict_to_py_ast(ctx: GeneratorContext, node: PyDict) -> GeneratedPyAST:
+    assert node.op == NodeOp.PY_DICT
+
+    key_deps, keys = _chain_py_ast(*map(partial(gen_py_ast, ctx), node.keys))
+    val_deps, vals = _chain_py_ast(*map(partial(gen_py_ast, ctx), node.vals))
+    return GeneratedPyAST(
+        node=ast.Dict(keys=list(keys), values=list(vals)),
+        dependencies=list(chain(key_deps, val_deps)),
+    )
+
+
+@_with_ast_loc
+def _py_list_to_py_ast(ctx: GeneratorContext, node: PyList) -> GeneratedPyAST:
+    assert node.op == NodeOp.PY_LIST
+
+    elem_deps, elems = _chain_py_ast(*map(partial(gen_py_ast, ctx), node.items))
+    return GeneratedPyAST(
+        node=ast.List(elts=list(elems), ctx=ast.Load()), dependencies=list(elem_deps)
+    )
+
+
+@_with_ast_loc
+def _py_set_to_py_ast(ctx: GeneratorContext, node: PySet) -> GeneratedPyAST:
+    assert node.op == NodeOp.PY_SET
+
+    elem_deps, elems = _chain_py_ast(*map(partial(gen_py_ast, ctx), node.items))
+    return GeneratedPyAST(node=ast.Set(elts=list(elems)), dependencies=list(elem_deps))
+
+
+@_with_ast_loc
+def _py_tuple_to_py_ast(ctx: GeneratorContext, node: PyTuple) -> GeneratedPyAST:
+    assert node.op == NodeOp.PY_TUPLE
+
+    elem_deps, elems = _chain_py_ast(*map(partial(gen_py_ast, ctx), node.items))
+    return GeneratedPyAST(
+        node=ast.Tuple(elts=list(elems), ctx=ast.Load()), dependencies=list(elem_deps)
+    )
+
+
 ############
 # With Meta
 ############
@@ -1871,6 +1920,34 @@ def _uuid_to_py_ast(_: GeneratorContext, form: uuid.UUID) -> ast.AST:
     return ast.Call(func=_NEW_UUID_FN_NAME, args=[ast.Str(str(form))], keywords=[])
 
 
+def _const_py_dict_to_py_ast(ctx: GeneratorContext, node: dict) -> GeneratedPyAST:
+    key_deps, keys = _chain_py_ast(*_collection_literal_to_py_ast(ctx, node.keys()))
+    val_deps, vals = _chain_py_ast(*_collection_literal_to_py_ast(ctx, node.values()))
+    return GeneratedPyAST(
+        node=ast.Dict(keys=list(keys), values=list(vals)),
+        dependencies=list(chain(key_deps, val_deps)),
+    )
+
+
+def _const_py_list_to_py_ast(ctx: GeneratorContext, node: list) -> GeneratedPyAST:
+    elem_deps, elems = _chain_py_ast(*_collection_literal_to_py_ast(ctx, node))
+    return GeneratedPyAST(
+        node=ast.List(elts=list(elems), ctx=ast.Load()), dependencies=list(elem_deps)
+    )
+
+
+def _const_py_set_to_py_ast(ctx: GeneratorContext, node: set) -> GeneratedPyAST:
+    elem_deps, elems = _chain_py_ast(*_collection_literal_to_py_ast(ctx, node))
+    return GeneratedPyAST(node=ast.Set(elts=list(elems)), dependencies=list(elem_deps))
+
+
+def _const_py_tuple_to_py_ast(ctx: GeneratorContext, node: tuple) -> GeneratedPyAST:
+    elem_deps, elems = _chain_py_ast(*_collection_literal_to_py_ast(ctx, node))
+    return GeneratedPyAST(
+        node=ast.Tuple(elts=list(elems), ctx=ast.Load()), dependencies=list(elem_deps)
+    )
+
+
 def _const_map_to_py_ast(ctx: GeneratorContext, form: lmap.Map) -> GeneratedPyAST:
     key_deps, keys = _chain_py_ast(*_collection_literal_to_py_ast(ctx, form.keys()))
     val_deps, vals = _chain_py_ast(*_collection_literal_to_py_ast(ctx, form.values()))
@@ -1951,17 +2028,21 @@ def _const_vec_to_py_ast(ctx: GeneratorContext, form: vec.Vector) -> GeneratedPy
     complex: _num_to_py_ast,
     datetime: _inst_to_py_ast,
     Decimal: _decimal_to_py_ast,
+    dict: _const_py_dict_to_py_ast,
     float: _num_to_py_ast,
     Fraction: _fraction_to_py_ast,
     int: _num_to_py_ast,
     kw.Keyword: _kw_to_py_ast,
+    list: _const_py_list_to_py_ast,
     llist.List: _const_seq_to_py_ast,
     lmap.Map: _const_map_to_py_ast,
     lset.Set: _const_set_to_py_ast,
     lseq.Seq: _const_seq_to_py_ast,
     type(re.compile("")): _regex_to_py_ast,
+    set: _const_py_set_to_py_ast,
     sym.Symbol: _const_sym_to_py_ast,
     str: _str_to_py_ast,
+    tuple: _const_py_tuple_to_py_ast,
     type(None): _name_const_to_py_ast,
     uuid.UUID: _uuid_to_py_ast,
     vec.Vector: _const_vec_to_py_ast,
@@ -2008,6 +2089,10 @@ def _collection_literal_to_py_ast(
     ConstType.STRING: _str_to_py_ast,
     ConstType.NIL: _name_const_to_py_ast,
     ConstType.UUID: _uuid_to_py_ast,
+    ConstType.PY_DICT: _const_py_dict_to_py_ast,
+    ConstType.PY_LIST: _const_py_list_to_py_ast,
+    ConstType.PY_SET: _const_py_set_to_py_ast,
+    ConstType.PY_TUPLE: _const_py_tuple_to_py_ast,
     ConstType.VECTOR: _const_vec_to_py_ast,
 }
 
@@ -2044,6 +2129,10 @@ def _const_node_to_py_ast(ctx: GeneratorContext, lisp_ast: Const) -> GeneratedPy
     NodeOp.MAP: _map_to_py_ast,
     NodeOp.MAYBE_CLASS: _maybe_class_to_py_ast,
     NodeOp.MAYBE_HOST_FORM: _maybe_host_form_to_py_ast,
+    NodeOp.PY_DICT: _py_dict_to_py_ast,
+    NodeOp.PY_LIST: _py_list_to_py_ast,
+    NodeOp.PY_SET: _py_set_to_py_ast,
+    NodeOp.PY_TUPLE: _py_tuple_to_py_ast,
     NodeOp.QUOTE: _quote_to_py_ast,
     NodeOp.RECUR: _recur_to_py_ast,
     NodeOp.SET: _set_to_py_ast,

src/basilisp/lang/compiler/nodes.py

@@ -15,14 +15,12 @@
 import attr
 
 import basilisp.lang.keyword as kw
-import basilisp.lang.list as llist
 import basilisp.lang.map as lmap
-import basilisp.lang.seq as lseq
 import basilisp.lang.set as lset
 import basilisp.lang.symbol as sym
 import basilisp.lang.vector as vec
 from basilisp.lang.runtime import Namespace, Var
-from basilisp.lang.typing import LispForm
+from basilisp.lang.typing import LispForm, ReaderForm as ReaderLispForm, SpecialForm
 from basilisp.lang.util import munge
 
 BODY = kw.keyword("body")
@@ -71,6 +69,10 @@ class NodeOp(Enum):
     MAP = kw.keyword("map")
     MAYBE_CLASS = kw.keyword("maybe-class")
     MAYBE_HOST_FORM = kw.keyword("maybe-host-form")
+    PY_DICT = kw.keyword("py-dict")
+    PY_LIST = kw.keyword("py-list")
+    PY_SET = kw.keyword("py-set")
+    PY_TUPLE = kw.keyword("py-tuple")
     QUOTE = kw.keyword("quote")
     RECUR = kw.keyword("recur")
     SET = kw.keyword("set")
@@ -204,12 +206,14 @@ class ConstType(Enum):
     CLASS = kw.keyword("class")
     INST = kw.keyword("inst")
     UUID = kw.keyword("uuid")
+    PY_DICT = kw.keyword("py-dict")
+    PY_LIST = kw.keyword("py-list")
+    PY_SET = kw.keyword("py-set")
+    PY_TUPLE = kw.keyword("py-tuple")
     UNKNOWN = kw.keyword("unknown")
 
 
 NodeMeta = Union[None, "Const", "Map"]
-ReaderLispForm = Union[LispForm, lseq.Seq]
-SpecialForm = Union[llist.List, lseq.Seq]
 LoopID = str
 
 
@@ -491,6 +495,51 @@ class MaybeHostForm(Node[sym.Symbol]):
     raw_forms: Collection[LispForm] = vec.Vector.empty()
 
 
+@attr.s(auto_attribs=True, cmp=False, frozen=True, slots=True)
+class PyDict(Node[dict]):
+    form: dict
+    keys: Iterable[Node]
+    vals: Iterable[Node]
+    env: NodeEnv
+    children: Collection[kw.Keyword] = vec.v(KEYS, VALS)
+    op: NodeOp = NodeOp.PY_DICT
+    top_level: bool = False
+    raw_forms: Collection[LispForm] = vec.Vector.empty()
+
+
+@attr.s(auto_attribs=True, cmp=False, frozen=True, slots=True)
+class PyList(Node[list]):
+    form: list
+    items: Iterable[Node]
+    env: NodeEnv
+    children: Collection[kw.Keyword] = vec.v(ITEMS)
+    op: NodeOp = NodeOp.PY_LIST
+    top_level: bool = False
+    raw_forms: Collection[LispForm] = vec.Vector.empty()
+
+
+@attr.s(auto_attribs=True, cmp=False, frozen=True, slots=True)
+class PySet(Node[Union[frozenset, set]]):
+    form: Union[frozenset, set]
+    items: Iterable[Node]
+    env: NodeEnv
+    children: Collection[kw.Keyword] = vec.v(ITEMS)
+    op: NodeOp = NodeOp.PY_SET
+    top_level: bool = False
+    raw_forms: Collection[LispForm] = vec.Vector.empty()
+
+
+@attr.s(auto_attribs=True, frozen=True, slots=True)
+class PyTuple(Node[tuple]):
+    form: tuple
+    items: Iterable[Node]
+    env: NodeEnv
+    children: Collection[kw.Keyword] = vec.v(ITEMS)
+    op: NodeOp = NodeOp.PY_TUPLE
+    top_level: bool = False
+    raw_forms: Collection[LispForm] = vec.Vector.empty()
+
+
 @attr.s(auto_attribs=True, frozen=True, slots=True)
 class Quote(Node[SpecialForm]):
     form: SpecialForm
@@ -617,6 +666,10 @@ class WithMeta(Node[LispForm]):
     Map,
     MaybeClass,
     MaybeHostForm,
+    PyDict,
+    PyList,
+    PySet,
+    PyTuple,
     Quote,
     Set,
     SetBang,