Intern Deftypes as Vars and resolve static and class methods (#539)

* Intern Deftypes as Vars and resolve static and class methods

* d o a t e s t

* Dewit

* Changelog

Author: chrisrink10

CHANGELOG.md

@@ -16,6 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  * Fixed a bug where `defonce` would throw a Python SyntaxError due to a superfluous `global` statement in the generated Python (#525)
  * Fixed a bug where Basilisp would throw an exception when comparing seqs by `=` to non-seqable values (#530)
  * Fixed a bug where aliased Python submodule imports referred to the top-level module rather than the submodule (#533)
+ * Fixed a bug where static methods and class methods on types created by `deftype` could not be referred to directly (defeating the purpose of the static or class method) (#537)
 
 ## [v0.1.dev13] - 2020-03-16
 ### Added

src/basilisp/lang/compiler/analyzer.py

@@ -2731,7 +2731,7 @@ def _resolve_nested_symbol(ctx: AnalyzerContext, form: sym.Symbol) -> HostField:
     parent_node = __resolve_namespaced_symbol(ctx, parent)
 
     return HostField(
-        form,
+        form=form,
         field=form.name,
         target=parent_node,
         is_assignable=True,
@@ -2810,7 +2810,7 @@ def __resolve_namespaced_symbol_in_ns(  # pylint: disable=too-many-branches
     return None
 
 
-def __resolve_namespaced_symbol(  # pylint: disable=too-many-branches
+def __resolve_namespaced_symbol(  # pylint: disable=too-many-branches  # noqa: MC0001
     ctx: AnalyzerContext, form: sym.Symbol
 ) -> Union[Const, HostField, MaybeClass, MaybeHostForm, VarRef]:
     """Resolve a namespaced symbol into a Python name or Basilisp Var."""
@@ -2873,11 +2873,37 @@ def __resolve_namespaced_symbol(  # pylint: disable=too-many-branches
             ) from None
     elif ctx.should_allow_unresolved_symbols:
         return _const_node(ctx, form)
-    else:
-        raise AnalyzerException(
-            f"unable to resolve symbol '{form}' in this context", form=form
+
+    # Static and class methods on types in the current namespace can be referred
+    # to as `Type/static-method`. In these casess, we will try to resolve the
+    # namespace portion of the symbol as a Var within the current namespace.
+    maybe_type_or_class = current_ns.find(sym.symbol(form.ns))
+    if maybe_type_or_class is not None:
+        safe_name = munge(form.name)
+        member = getattr(maybe_type_or_class.value, safe_name, None)
+
+        if member is None:
+            raise AnalyzerException(
+                f"unable to resolve static or class member '{form}' in this context",
+                form=form,
+            )
+
+        return HostField(
+            form=form,
+            field=safe_name,
+            target=VarRef(
+                form=form,
+                var=maybe_type_or_class,
+                env=ctx.get_node_env(pos=ctx.syntax_position),
+            ),
+            is_assignable=False,
+            env=ctx.get_node_env(pos=ctx.syntax_position),
         )
 
+    raise AnalyzerException(
+        f"unable to resolve symbol '{form}' in this context", form=form
+    )
+
 
 def __resolve_bare_symbol(
     ctx: AnalyzerContext, form: sym.Symbol

src/basilisp/lang/compiler/generator.py

@@ -1336,7 +1336,20 @@ def _deftype_to_py_ast(  # pylint: disable=too-many-branches
                             keywords=[],
                             body=type_nodes,
                             decorator_list=[decorator],
-                        )
+                        ),
+                        ast.Call(
+                            func=_INTERN_VAR_FN_NAME,
+                            args=[
+                                _load_attr(_NS_VAR_VALUE),
+                                ast.Call(
+                                    func=_NEW_SYM_FN_NAME,
+                                    args=[ast.Constant(type_name)],
+                                    keywords=[],
+                                ),
+                                ast.Name(id=type_name, ctx=ast.Load()),
+                            ],
+                            keywords=[],
+                        ),
                     ],
                 )
             ),

tests/basilisp/compiler_test.py

@@ -3618,82 +3618,48 @@ def test_multi_arity_recur(self, lcompile: CompileFn):
         assert 10 == lcompile("(+++ 1 2 3 4)")
         assert 15 == lcompile("(+++ 1 2 3 4 5)")
 
-    def test_disallow_recur_in_special_forms(self, lcompile: CompileFn):
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (def b (recur "a")))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (import* (recur "a")))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (.join "" (recur "a")))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (.-p (recur "a")))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (throw (recur "a"))))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (var (recur "a"))))')
-
-    def test_disallow_recur_outside_tail(self, lcompile: CompileFn):
-        with pytest.raises(compiler.CompilerException):
-            lcompile("(recur)")
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile("(do (recur))")
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile("(if true (recur) :b)")
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (do (recur "a") :b))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (if (recur "a") :a :b))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (if (recur "a") :a))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (let [a (recur "a")] a))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (let [a (do (recur "a"))] a))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (let [a (do :b (recur "a"))] a))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (let [a (do (recur "a") :c)] a))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (let [a "a"] (recur a) a))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (loop* [a (recur "a")] a))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (loop* [a (do (recur "a"))] a))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (loop* [a (do :b (recur "a"))] a))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (loop* [a (do (recur "a") :c)] a))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(fn [a] (loop* [a "a"] (recur a) a))')
-
-        with pytest.raises(compiler.CompilerException):
-            lcompile("(fn [a] (try (do (recur a) :b) (catch AttributeError _ nil)))")
-
+    @pytest.mark.parametrize(
+        "code",
+        [
+            '(fn [a] (def b (recur "a")))',
+            '(fn [a] (import* (recur "a")))',
+            '(fn [a] (.join "" (recur "a")))',
+            '(fn [a] (.-p (recur "a")))',
+            '(fn [a] (throw (recur "a"))))',
+            '(fn [a] (var (recur "a"))))',
+        ],
+    )
+    def test_disallow_recur_in_special_forms(self, lcompile: CompileFn, code: str):
         with pytest.raises(compiler.CompilerException):
-            lcompile("(fn [a] (try :b (catch AttributeError _ (do (recur :a) :c))))")
+            lcompile(code)
 
+    @pytest.mark.parametrize(
+        "code",
+        [
+            "(recur)",
+            "(do (recur))",
+            "(if true (recur) :b)",
+            '(fn [a] (do (recur "a") :b))',
+            '(fn [a] (if (recur "a") :a :b))',
+            '(fn [a] (if (recur "a") :a))',
+            '(fn [a] (let [a (recur "a")] a))',
+            '(fn [a] (let [a (do (recur "a"))] a))',
+            '(fn [a] (let [a (do :b (recur "a"))] a))',
+            '(fn [a] (let [a (do (recur "a") :c)] a))',
+            '(fn [a] (let [a "a"] (recur a) a))',
+            '(fn [a] (loop* [a (recur "a")] a))',
+            '(fn [a] (loop* [a (do (recur "a"))] a))',
+            '(fn [a] (loop* [a (do :b (recur "a"))] a))',
+            '(fn [a] (loop* [a (do (recur "a") :c)] a))',
+            '(fn [a] (loop* [a "a"] (recur a) a))',
+            "(fn [a] (try (do (recur a) :b) (catch AttributeError _ nil)))",
+            "(fn [a] (try :b (catch AttributeError _ (do (recur :a) :c))))",
+            "(fn [a] (try :b (finally (do (recur :a) :c))))",
+        ],
+    )
+    def test_disallow_recur_outside_tail(self, lcompile: CompileFn, code: str):
         with pytest.raises(compiler.CompilerException):
-            lcompile("(fn [a] (try :b (finally (do (recur :a) :c))))")
+            lcompile(code)
 
     def test_single_arity_named_anonymous_fn_recursion(self, lcompile: CompileFn):
         code = """
@@ -4106,6 +4072,53 @@ def test_nested_bare_sym_will_not_resolve(self, lcompile: CompileFn):
         with pytest.raises(compiler.CompilerException):
             lcompile("basilisp.lang.map.MapEntry.of")
 
+    def test_local_deftype_classmethod_resolves(self, lcompile: CompileFn):
+        Point = lcompile(
+            """
+            (import* abc)
+            (def WithCls
+              (python/type "WithCls"
+                             #py (abc/ABC)
+                             #py {"create"
+                                  (python/classmethod
+                                   (abc/abstractmethod
+                                    (fn [cls])))}))
+            (deftype* Point [x y z]
+              :implements [WithCls]
+              (^:classmethod create [cls x y z]
+                [cls x y z]))
+            """
+        )
+
+        assert vec.v(Point, 1, 2, 3) == lcompile("(Point/create 1 2 3)")
+
+        with pytest.raises(compiler.CompilerException):
+            lcompile("(Point/make 1 2 3)")
+
+    def test_local_deftype_staticmethod_resolves(self, lcompile: CompileFn):
+        Point = lcompile(
+            """
+            (import* abc)
+            (def WithStatic
+              (python/type "WithStatic"
+                             #py (abc/ABC)
+                             #py {"dostatic"
+                                  (python/staticmethod
+                                   (abc/abstractmethod
+                                    (fn [])))}))
+            (deftype* Point [x y z]
+              :implements [WithStatic]
+              (^:staticmethod dostatic [arg1 arg2]
+                [arg1 arg2]))
+            """
+        )
+
+        assert Point.dostatic is lcompile("Point/dostatic")
+        assert vec.v(kw.keyword("a"), 2) == lcompile("(Point/dostatic :a 2)")
+
+        with pytest.raises(compiler.CompilerException):
+            lcompile("(Point/do-non-static 1 2)")
+
     def test_aliased_namespace_not_hidden_by_python_module(
         self, lcompile: CompileFn, monkeypatch: MonkeyPatch
     ):