Validate that dynamic interfaces are abstract for deftypes (#546)

* Validate that dynamic interfaces are abstract for deftypes

* Please our linting overlords

* Extra required cases

Author: chrisrink10

CHANGELOG.md

@@ -17,8 +17,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  * 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)
- * Fixed a bug where `defftype` forms could not be declared without at least one field (#540)
+ * Fixed a bug where `deftype` forms could not be declared without at least one field (#540)
  * Fixed a bug where not all builtin Basilisp types could be pickled (#518)
+ * Fixed a bug where `deftype` forms could not be created interfaces declared not at the top-level of a code block in a namespace (#376)
 
 ## [v0.1.dev13] - 2020-03-16
 ### Added

src/basilisp/lang/compiler/analyzer.py

@@ -1,7 +1,6 @@
 import builtins
 import collections
 import contextlib
-import inspect
 import logging
 import re
 import sys
@@ -50,7 +49,6 @@
     LINE_KW,
     NAME_KW,
     NS_KW,
-    OBJECT_DUNDER_METHODS,
     SYM_ASYNC_META_KEY,
     SYM_CLASSMETHOD_META_KEY,
     SYM_DEFAULT_META_KEY,
@@ -129,7 +127,8 @@
 from basilisp.lang.interfaces import IMeta, IRecord, ISeq, IType, IWithMeta
 from basilisp.lang.runtime import Var
 from basilisp.lang.typing import CompilerOpts, LispForm, ReaderForm
-from basilisp.lang.util import count, genname, munge
+from basilisp.lang.util import OBJECT_DUNDER_METHODS, count, genname, is_abstract, munge
+from basilisp.logconfig import TRACE
 from basilisp.util import Maybe, partition
 
 # Analyzer logging
@@ -1467,41 +1466,45 @@ def __deftype_impls(  # pylint: disable=too-many-branches,too-many-locals  # noq
     return interfaces, members
 
 
-def __is_abstract(tp: Type) -> bool:
-    """Return True if tp is an abstract class.
-
-    The builtin inspect.isabstract returns False for marker abstract classes
-    which do not define any abstract members."""
-    if inspect.isabstract(tp):
-        return True
-    return (
-        inspect.isclass(tp)
-        and hasattr(tp, "__abstractmethods__")
-        and tp.__abstractmethods__ == frozenset()
-    )
-
-
-def __assert_deftype_impls_are_abstract(  # pylint: disable=too-many-branches,too-many-locals
+def __deftype_impls_are_all_abstract(  # pylint: disable=too-many-branches,too-many-locals
     fields: Iterable[str],
     interfaces: Iterable[DefTypeBase],
     members: Iterable[DefTypeMember],
-) -> None:
+) -> bool:
+    """Return True if all `deftype*` super-types can be verified abstract statically.
+    Return False otherwise.
+
+    In certain cases, such as in macro definitions and potentially inside of functions,
+    the compiler will be unable to resolve the named super-type as an object during
+    compilation and these checks will need to be deferred to runtime. In these cases,
+    the compiler will wrap the emitted class in a decorator that performs the checks
+    when the class is compiled by the Python compiler.
+
+    For normal compile-time errors, an `AnalyzerException` will be raised."""
     field_names = frozenset(fields)
     member_names = frozenset(munge(member.name) for member in members)
     all_member_names = field_names.union(member_names)
     all_interface_methods: Set[str] = set()
     for interface in interfaces:
         if isinstance(interface, (MaybeClass, MaybeHostForm)):
             interface_type = interface.target
-        elif isinstance(interface, VarRef):
+        else:
+            assert isinstance(
+                interface, VarRef
+            ), "Interface must be MaybeClass, MaybeHostForm, or VarRef"
+            if not interface.var.is_bound:
+                logger.log(
+                    TRACE,
+                    f"deftype* interface Var '{interface.form}' is not bound and "
+                    "cannot be checked for abstractness; deferring to runtime",
+                )
+                return False
             interface_type = interface.var.value
-        else:  # pragma: no cover
-            assert False, "Interface must be MaybeClass, MaybeHostForm, or VarRef"
 
         if interface_type is object:
             continue
 
-        if not __is_abstract(interface_type):
+        if not is_abstract(interface_type):
             raise AnalyzerException(
                 "deftype* interface must be Python abstract class or object",
                 form=interface.form,
@@ -1542,6 +1545,8 @@ def __assert_deftype_impls_are_abstract(  # pylint: disable=too-many-branches,to
             f"defined interfaces: {extra_method_str}"
         )
 
+    return True
+
 
 __DEFTYPE_DEFAULT_SENTINEL = object()
 
@@ -1620,7 +1625,7 @@ def _deftype_ast(  # pylint: disable=too-many-branches
             ctx.put_new_symbol(field, binding, warn_if_unused=False)
 
         interfaces, members = __deftype_impls(ctx, runtime.nthrest(form, 3))
-        __assert_deftype_impls_are_abstract(
+        verified_abstract = __deftype_impls_are_all_abstract(
             map(lambda f: f.name, fields), interfaces, members
         )
         return DefType(
@@ -1629,6 +1634,7 @@ def _deftype_ast(  # pylint: disable=too-many-branches
             interfaces=vec.vector(interfaces),
             fields=vec.vector(param_nodes),
             members=vec.vector(members),
+            verified_abstract=verified_abstract,
             is_frozen=is_frozen,
             env=ctx.get_node_env(pos=ctx.syntax_position),
         )

src/basilisp/lang/compiler/constants.py

@@ -30,111 +30,6 @@ class SpecialForm:
 
 DEFAULT_COMPILER_FILE_PATH = "NO_SOURCE_PATH"
 
-# Trimmed list of __dunder__ methods generated by using this command:
-#
-#     find "$(pipenv --venv)/lib/python3.6" \
-#          -name '*.py' \
-#          -exec egrep \
-#          -oh '__[A-Za-z_][A-Za-z_0-9]*__' '{}' \; \
-#          | sort | uniq
-OBJECT_DUNDER_METHODS = frozenset(
-    {
-        "__abs__",
-        "__add__",
-        "__aenter__",
-        "__aexit__",
-        "__aiter__",
-        "__await__",
-        "__bytes__",
-        "__call__",
-        "__complex__",
-        "__contains__",
-        "__del__",
-        "__delattr__",
-        "__delitem__",
-        "__delslice__",
-        "__dict__",
-        "__dir__",
-        "__div__",
-        "__divmod__",
-        "__enter__",
-        "__eq__",
-        "__exit__",
-        "__float__",
-        "__floordiv__",
-        "__ge__",
-        "__getattr__",
-        "__getattribute__",
-        "__getitem__",
-        "__getslice__",
-        "__getstate__",
-        "__gt__",
-        "__hash__",
-        "__iadd__",
-        "__iand__",
-        "__idiv__",
-        "__ifloordiv__",
-        "__ilshift__",
-        "__imatmul__",
-        "__imod__",
-        "__imul__",
-        "__init__",
-        "__instancecheck__",
-        "__int__",
-        "__invert__",
-        "__ior__",
-        "__ipow__",
-        "__isub__",
-        "__iter__",
-        "__itruediv__",
-        "__ixor__",
-        "__le__",
-        "__len__",
-        "__lshift__",
-        "__matmul__",
-        "__mod__",
-        "__mul__",
-        "__ne__",
-        "__neg__",
-        "__new__",
-        "__not__",
-        "__pos__",
-        "__pow__",
-        "__radd__",
-        "__rand__",
-        "__rcmp__",
-        "__rdiv__",
-        "__rdivmod__",
-        "__reduce__",
-        "__reduce_ex__",
-        "__repr__",
-        "__rfloordiv__",
-        "__rlshift__",
-        "__rmatmul__",
-        "__rmod__",
-        "__rmul__",
-        "__rne__",
-        "__ror__",
-        "__round__",
-        "__rpow__",
-        "__rrshift__",
-        "__rshift__",
-        "__rsub__",
-        "__rtruediv__",
-        "__rxor__",
-        "__setattr__",
-        "__setitem__",
-        "__setslice__",
-        "__setstate__",
-        "__str__",
-        "__sub__",
-        "__subclasscheck__",
-        "__subclasshook__",
-        "__truediv__",
-        "__xor__",
-    }
-)
-
 SYM_ASYNC_META_KEY = kw.keyword("async")
 SYM_KWARGS_META_KEY = kw.keyword("kwargs")
 SYM_PRIVATE_META_KEY = kw.keyword("private")

src/basilisp/lang/compiler/generator.py

@@ -554,6 +554,7 @@ def _var_ns_as_python_sym(name: str) -> str:
 _COERCE_SEQ_FN_NAME = _load_attr(f"{_RUNTIME_ALIAS}.to_seq")
 _BASILISP_FN_FN_NAME = _load_attr(f"{_RUNTIME_ALIAS}._basilisp_fn")
 _FN_WITH_ATTRS_FN_NAME = _load_attr(f"{_RUNTIME_ALIAS}._with_attrs")
+_BASILISP_TYPE_FN_NAME = _load_attr(f"{_RUNTIME_ALIAS}._basilisp_type")
 _BUILTINS_IMPORT_FN_NAME = _load_attr("builtins.__import__")
 _IMPORTLIB_IMPORT_MODULE_FN_NAME = _load_attr("importlib.import_module")
 _LISP_FN_APPLY_KWARGS_FN_NAME = _load_attr(f"{_RUNTIME_ALIAS}._lisp_fn_apply_kwargs")
@@ -1268,7 +1269,7 @@ def __deftype_member_to_py_ast(
 
 
 @_with_ast_loc
-def _deftype_to_py_ast(  # pylint: disable=too-many-branches
+def _deftype_to_py_ast(  # pylint: disable=too-many-branches,too-many-locals
     ctx: GeneratorContext, node: DefType
 ) -> GeneratedPyAST:
     """Return a Python AST Node for a `deftype*` expression."""
@@ -1284,17 +1285,8 @@ def _deftype_to_py_ast(  # pylint: disable=too-many-branches
         ), "Class and host form nodes do not have dependencies"
         bases.append(base_node.node)
 
-    decorator = ast.Call(
-        func=_ATTR_CLASS_DECORATOR_NAME,
-        args=[],
-        keywords=_ATTR_CMP_KWARGS
-        + [
-            ast.keyword(arg="frozen", value=ast.Constant(node.is_frozen)),
-            ast.keyword(arg="slots", value=ast.Constant(True)),
-        ],
-    )
-
     with ctx.new_symbol_table(node.name):
+        fields, members = [], []
         type_nodes: List[ast.AST] = []
         type_deps: List[ast.AST] = []
         for field in node.fields:
@@ -1318,11 +1310,13 @@ def _deftype_to_py_ast(  # pylint: disable=too-many-branches
                 )
             )
             ctx.symbol_table.new_symbol(sym.symbol(field.name), safe_field, field.local)
+            fields.append(safe_field)
 
         for member in node.members:
             type_ast = __deftype_member_to_py_ast(ctx, member, node)
             type_nodes.append(type_ast.node)
             type_nodes.extend(type_ast.dependencies)
+            members.append(munge(member.name))
 
         return GeneratedPyAST(
             node=ast.Name(id=type_name, ctx=ast.Load()),
@@ -1335,7 +1329,64 @@ def _deftype_to_py_ast(  # pylint: disable=too-many-branches
                             bases=bases,
                             keywords=[],
                             body=type_nodes or [ast.Pass()],
-                            decorator_list=[decorator],
+                            decorator_list=list(
+                                chain(
+                                    []
+                                    if node.verified_abstract
+                                    else [
+                                        ast.Call(
+                                            func=_BASILISP_TYPE_FN_NAME,
+                                            args=[],
+                                            keywords=[
+                                                ast.keyword(
+                                                    arg="fields",
+                                                    value=ast.Tuple(
+                                                        elts=[
+                                                            ast.Constant(e)
+                                                            for e in fields
+                                                        ],
+                                                        ctx=ast.Load(),
+                                                    ),
+                                                ),
+                                                ast.keyword(
+                                                    arg="interfaces",
+                                                    value=ast.Tuple(
+                                                        elts=list(bases),
+                                                        ctx=ast.Load(),
+                                                    ),
+                                                ),
+                                                ast.keyword(
+                                                    arg="members",
+                                                    value=ast.Tuple(
+                                                        elts=[
+                                                            ast.Constant(e)
+                                                            for e in members
+                                                        ],
+                                                        ctx=ast.Load(),
+                                                    ),
+                                                ),
+                                            ],
+                                        )
+                                    ],
+                                    [
+                                        ast.Call(
+                                            func=_ATTR_CLASS_DECORATOR_NAME,
+                                            args=[],
+                                            keywords=_ATTR_CMP_KWARGS
+                                            + [
+                                                ast.keyword(
+                                                    arg="frozen",
+                                                    value=ast.Constant(node.is_frozen),
+                                                ),
+                                                ast.keyword(
+                                                    arg="slots",
+                                                    value=ast.Constant(True),
+                                                ),
+                                            ],
+                                        ),
+                                    ],
+                                )
+                            ),
                         ),
                         ast.Call(
                             func=_INTERN_VAR_FN_NAME,

src/basilisp/lang/compiler/nodes.py

@@ -380,6 +380,7 @@ class DefType(Node[SpecialForm]):
     fields: Iterable[Binding]
     members: Iterable["DefTypeMember"]
     env: NodeEnv
+    verified_abstract: bool = False
     is_frozen: bool = True
     meta: NodeMeta = None
     children: Sequence[kw.Keyword] = vec.v(FIELDS, MEMBERS)