Move interop functionality to compiler (#308)

* Move interop functionality to compiler

* Remove unused reader branch

* One other test

Author: chrisrink10

src/basilisp/lang/compiler.py

@@ -810,7 +810,7 @@ def _assert_recur_is_tail(ctx: CompilerContext, form: lseq.Seq) -> None:  # noqa
             }:
                 _assert_no_recur(ctx, child)
             else:
-                _assert_recur_is_tail(ctx, child)
+                _assert_no_recur(ctx, child)
         else:
             if isinstance(child, lseq.Seqable):
                 _assert_no_recur(ctx, child.seq())
@@ -1664,7 +1664,9 @@ def _resolve_macro_sym(ctx: CompilerContext, form: sym.Symbol) -> Optional[Var]:
     return ctx.current_ns.find(form)
 
 
-def _list_ast(ctx: CompilerContext, form: llist.List) -> ASTStream:
+def _list_ast(  # pylint: disable=too-many-locals
+    ctx: CompilerContext, form: llist.List
+) -> ASTStream:
     """Generate a stream of Python AST nodes for a source code list.
 
     Being the basis of any Lisp language, Lists have a lot of special cases
@@ -1722,6 +1724,24 @@ def _list_ast(ctx: CompilerContext, form: llist.List) -> ASTStream:
                 ) from e
             return
 
+        # Handle interop calls and properties generated dynamically (e.g.
+        # by a macro)
+        if first.name.startswith(".-"):
+            assert first.ns is None, "Interop property symbols may not have a namespace"
+            prop_name = sym.symbol(first.name[2:])
+            target = runtime.nth(form, 1)
+            yield from _interop_prop_ast(ctx, llist.l(_INTEROP_PROP, target, prop_name))
+            return
+        elif first.name.startswith("."):
+            assert first.ns is None, "Interop call symbols may not have a namespace"
+            attr_name = sym.symbol(first.name[1:])
+            rest = form.rest
+            target = rest.first
+            args = rest.rest
+            interop_form = llist.l(_INTEROP_CALL, target, attr_name, *args)
+            yield from _interop_call_ast(ctx, interop_form)
+            return
+
     elems_nodes, elems = _collection_literal_ast(ctx, form)
 
     # Quoted list
@@ -2083,16 +2103,10 @@ def _to_ast(  # pylint: disable=too-many-branches
     elif isinstance(form, str):
         yield _node(ast.Str(form))
         return
-    elif isinstance(form, bool):
+    elif isinstance(form, (bool, type(None))):
         yield _node(ast.NameConstant(form))
         return
-    elif isinstance(form, type(None)):
-        yield _node(ast.NameConstant(None))
-        return
-    elif isinstance(form, float):
-        yield _node(ast.Num(form))
-        return
-    elif isinstance(form, (complex, int)):
+    elif isinstance(form, (complex, float, int)):
         yield _node(ast.Num(form))
         return
     elif isinstance(form, datetime):

src/basilisp/lang/reader.py

@@ -38,7 +38,7 @@
 from basilisp.lang.typing import LispForm, IterableLispForm
 from basilisp.util import Maybe
 
-ns_name_chars = re.compile(r"\w|-|\+|\*|\?|/|\=|\\|!|&|%|>|<|\$")
+ns_name_chars = re.compile(r"\w|-|\+|\*|\?|/|\=|\\|!|&|%|>|<|\$|\.")
 alphanumeric_chars = re.compile(r"\w")
 begin_num_chars = re.compile(r"[0-9\-]")
 num_chars = re.compile("[0-9]")
@@ -319,9 +319,6 @@ def _read_namespaced(
         elif allowed_suffix is not None and token == allowed_suffix:
             reader.next_token()
             name.append(token)
-        elif not has_ns and token == ".":
-            reader.next_token()
-            name.append(token)
         else:
             break
 
@@ -370,96 +367,11 @@ def _consume_whitespace(reader: StreamReader) -> None:
         token = reader.advance()
 
 
-def _read_interop(ctx: ReaderContext, end_token: str) -> llist.List:
-    """Read a Python interop call or property access.
-
-    The instance member access syntax permits the following iterations:
-
-      (. instance member & args)
-      (.member instance & args)
-
-      (. instance -property)
-      (.-property instance)
-
-    This function always dynamically rewrites everything into one of two
-    canonical formats:
-
-      (. instance member & args)
-      (.- instance property)
-
-    By using just two canonical forms, it will be much easier to parse
-    and compile Python interop code."""
-    reader = ctx.reader
-    start = reader.advance()
-    assert start == "."
-    seq: List[LispForm] = []
-
-    token = reader.peek()
-    if whitespace_chars.match(token):
-        instance = _read_next_consuming_comment(ctx)
-        member = _read_next_consuming_comment(ctx)
-
-        # There are cases (particularly with macros) where we may
-        # not have a symbol in this spot. In those cases, we need
-        # to expect the author used the correct form in the first
-        # place.
-        if isinstance(member, symbol.Symbol) and member.name.startswith("-"):
-            seq.append(_INTEROP_PROP)
-            member = symbol.symbol(member.name[1:])
-        else:
-            seq.append(_INTEROP_CALL)
-
-        seq.append(instance)
-        seq.append(member)
-    elif token == "-":
-        reader.advance()
-        seq.append(_INTEROP_PROP)
-
-        # If whitespace immediately follows, this is the form
-        # (.- object member ...), otherwise it is (.-member object ...).
-        # We need to support both, as the former is more commonly
-        # the format which will appear in macros.
-        if whitespace_chars.match(reader.peek()):
-            instance = _read_next_consuming_comment(ctx)
-            member = _read_next_consuming_comment(ctx)
-        else:
-            member = _read_next_consuming_comment(ctx)
-            if not isinstance(member, symbol.Symbol):
-                raise SyntaxError(f"Expected Symbol; found {type(member)}")
-            instance = _read_next_consuming_comment(ctx)
-
-        seq.append(instance)
-        seq.append(member)
-    else:
-        assert not whitespace_chars.match(token)
-        seq.append(_INTEROP_CALL)
-        member = _read_next_consuming_comment(ctx)
-        instance = _read_next_consuming_comment(ctx)
-        if not isinstance(member, symbol.Symbol):
-            raise SyntaxError(f"Expected Symbol; found {type(member)}")
-        seq.append(instance)
-        seq.append(member)
-
-    while True:
-        token = reader.peek()
-        if token == "":
-            raise SyntaxError(f"Unexpected EOF in list")
-        if token == end_token:
-            reader.next_token()
-            return llist.list(seq)
-        elem = _read_next(ctx)
-        if elem is COMMENT or isinstance(elem, Comment):
-            continue
-        seq.append(elem)
-
-
 @_with_loc
 def _read_list(ctx: ReaderContext) -> llist.List:
     """Read a list element from the input stream."""
     start = ctx.reader.advance()
     assert start == "("
-    if ctx.reader.peek() == ".":
-        return _read_interop(ctx, ")")
     return _read_coll(ctx, llist.list, ")", "list")
 
 
@@ -661,6 +573,14 @@ def _read_sym(ctx: ReaderContext) -> MaybeSymbol:
     ns, name = _read_namespaced(ctx, allowed_suffix="#")
     if not ctx.is_syntax_quoted and name.endswith("#"):
         raise SyntaxError("Gensym may not appear outside syntax quote")
+    if ns is not None:
+        if any(map(lambda s: len(s) == 0, ns.split("."))):
+            raise SyntaxError(
+                "All '.' separated segments of a namespace "
+                "must contain at least one character."
+            )
+    if name.startswith(".") and ns is not None:
+        raise SyntaxError("Symbols starting with '.' may not have a namespace")
     if ns is None:
         if name == "nil":
             return None

tests/basilisp/compiler_test.py

@@ -568,9 +568,9 @@ def test_interop_call(ns: runtime.Namespace):
 
 def test_interop_prop(ns: runtime.Namespace):
     assert lcompile("(.-ns 'some.ns/sym)") == "some.ns"
-    assert lcompile("(. 'some.ns/sym -ns)") == "some.ns"
+    assert lcompile("(.- 'some.ns/sym ns)") == "some.ns"
     assert lcompile("(.-name 'some.ns/sym)") == "sym"
-    assert lcompile("(. 'some.ns/sym -name)") == "sym"
+    assert lcompile("(.- 'some.ns/sym name)") == "sym"
 
     with pytest.raises(AttributeError):
         lcompile("(.-fake 'some.ns/sym)")

tests/basilisp/core_macros_test.lpy

@@ -30,7 +30,9 @@
   (is (= :a (-> :a)))
   (is (= 2 (-> 1 inc)))
   (is (= 1 (-> 1 inc dec)))
-  (is (= 4 (-> 10 inc (- 7)))))
+  (is (= 4 (-> 10 inc (- 7))))
+  (is (= "HI" (-> "hi" .upper)))
+  (is (= "Hi" (-> "HI" .lower .capitalize))))
 
 (deftest ->>-test
   (is (= :a (->> :a)))

tests/basilisp/reader_test.py

@@ -268,6 +268,8 @@ def test_symbol():
     assert sym.symbol("<body>") == read_str_first("<body>")
     assert sym.symbol("*muffs*") == read_str_first("*muffs*")
     assert sym.symbol("yay!") == read_str_first("yay!")
+    assert sym.symbol(".interop") == read_str_first(".interop")
+    assert sym.symbol("ns.name") == read_str_first("ns.name")
 
     assert sym.symbol("sym", ns="ns") == read_str_first("ns/sym")
     assert sym.symbol("sym", ns="qualified.ns") == read_str_first("qualified.ns/sym")
@@ -290,6 +292,15 @@ def test_symbol():
     with pytest.raises(reader.SyntaxError):
         read_str_first("/sym")
 
+    with pytest.raises(reader.SyntaxError):
+        read_str_first(".second.ns/name")
+
+    with pytest.raises(reader.SyntaxError):
+        read_str_first("ns..third/name")
+
+    with pytest.raises(reader.SyntaxError):
+        read_str_first("ns.second/.interop")
+
     with pytest.raises(reader.SyntaxError):
         # This will raise because the default pushback depth of the
         # reader.StreamReader instance used by the reader is 5, so
@@ -658,50 +669,6 @@ def test_var():
     )
 
 
-def test_interop_call():
-    assert llist.l(sym.symbol("."), "STRING", sym.symbol("lower")) == read_str_first(
-        '(. "STRING" lower)'
-    )
-    assert llist.l(sym.symbol("."), "STRING", sym.symbol("lower")) == read_str_first(
-        '(.lower "STRING")'
-    )
-    assert llist.l(
-        sym.symbol("."), "www.google.com", sym.symbol("split"), "."
-    ) == read_str_first('(.split "www.google.com" ".")')
-    assert llist.l(
-        sym.symbol("."), "www.google.com", sym.symbol("split"), "."
-    ) == read_str_first('(. "www.google.com" split ".")')
-
-    assert llist.l(
-        sym.symbol("."),
-        sym.symbol("obj"),
-        llist.l(
-            sym.symbol("unquote"), llist.l(sym.symbol("quote"), sym.symbol("method"))
-        ),
-    ) == read_str_first("(. obj (unquote (quote method)))")
-
-    with pytest.raises(reader.SyntaxError):
-        read_str_first('(."non-symbol" symbol)')
-
-
-def test_interop_prop():
-    assert llist.l(
-        sym.symbol(".-"), sym.symbol("sym"), sym.symbol("name")
-    ) == read_str_first("(. sym -name)")
-    assert llist.l(
-        sym.symbol(".-"), sym.symbol("encoder"), sym.symbol("algorithm")
-    ) == read_str_first("(.-algorithm encoder)")
-    assert llist.l(
-        sym.symbol(".-"), sym.symbol("name"), sym.symbol("sym")
-    ) == read_str_first("(.- name sym)")
-    assert llist.l(sym.symbol(".-"), sym.symbol("name"), "string") == read_str_first(
-        '(.- name "string")'
-    )
-
-    with pytest.raises(reader.SyntaxError):
-        read_str_first('(.-"string" sym)')
-
-
 def test_meta():
     def issubmap(m, sub):
         for k, subv in sub.items():