Add meta flags to allow redefining Vars and to disable warnings on redef (#292)

* Add meta flags to allow redefining Vars and to disable warnings on redef

* Remove unused debug code

Author: chrisrink10

src/basilisp/core/__init__.lpy

@@ -46,11 +46,11 @@
   (fn* with-meta [o meta]
        (.with-meta o meta)))
 
-(def ^:macro let
+(def ^:macro ^:redef let
   (fn* let [&form & decl]
        (cons 'let* decl)))
 
-(def ^:macro fn
+(def ^:macro ^:redef fn
   (fn* fn [&form & decl]
        (with-meta
          (cons 'fn* decl)
@@ -236,7 +236,7 @@
                                 {:found (first body)})))
                     (rest body)))]
       `(def ~fname
-         (fn* ~fname
+         (fn ~fname
               ~@body)))))
 
 (defn nth

src/basilisp/lang/compiler.py

@@ -433,6 +433,8 @@ def _meta_kwargs_ast(ctx: CompilerContext,  # pylint:disable=inconsistent-return
 
 _SYM_DYNAMIC_META_KEY = kw.keyword("dynamic")
 _SYM_MACRO_META_KEY = kw.keyword("macro")
+_SYM_NO_WARN_ON_REDEF_META_KEY = kw.keyword("no-warn-on-redef")
+_SYM_REDEF_META_KEY = kw.keyword("redef")
 
 
 def _is_dynamic(v: Var) -> bool:
@@ -458,6 +460,17 @@ def _is_macro(v: Var) -> bool:
         return False
 
 
+def _is_redefable(v: Var) -> bool:
+    """Return True if the Var can be redefined."""
+    try:
+        return Maybe(v.meta).map(
+            lambda m: m.get(_SYM_REDEF_META_KEY, None)  # type: ignore
+        ).or_else_get(
+            False)
+    except (KeyError, AttributeError):
+        return False
+
+
 def _def_ast(ctx: CompilerContext, form: llist.List) -> ASTStream:
     """Return a Python AST Node for a `def` expression."""
     assert form.first == _DEF
@@ -486,8 +499,12 @@ def _def_ast(ctx: CompilerContext, form: llist.List) -> ASTStream:
     yield from meta_nodes
     yield from def_nodes
 
-    if safe_name in ctx.current_ns.module.__dict__:
-        logger.warning(f"redefining local Python name '{safe_name}' in module '{ctx.current_ns.module.__name__}'")
+    if safe_name in ctx.current_ns.module.__dict__ or form[1] in ctx.current_ns.interns:
+        no_warn_on_redef = (Maybe(form[1].meta)
+            .map(lambda m: m.get(_SYM_NO_WARN_ON_REDEF_META_KEY, False))  # type: ignore
+            .or_else_get(False))
+        if not no_warn_on_redef:
+            logger.warning(f"redefining local Python name '{safe_name}' in module '{ctx.current_ns.module.__name__}'")
 
     yield _dependency(ast.Assign(targets=[ast.Name(id=safe_name, ctx=ast.Store())],
                                  value=Maybe(def_value).map(_unwrap_node).or_else_get(ast.NameConstant(None))))
@@ -1487,11 +1504,11 @@ def _kw_ast(_: CompilerContext, form: kw.Keyword) -> ASTStream:
 def _resolve_sym_var(ctx: CompilerContext, v: Var) -> Optional[str]:
     """Resolve a Basilisp var down to a Python Name (or Attribute).
 
-    If the Var is marked as :dynamic, do not compile to a direct access.
-    If the corresponding function name is not defined in a Python module,
-    no direct variable access is possible and Var.find indirection must
-    be used."""
-    if _is_dynamic(v):
+    If the Var is marked as :dynamic or :redef, do not compile to a direct
+    access. If the corresponding function name is not defined in a Python
+    module, no direct variable access is possible and Var.find indirection
+    must be used."""
+    if _is_dynamic(v) or _is_redefable(v):
         return None
 
     safe_name = munge(v.name.name)

tests/basilisp/compiler_test.py

@@ -4,6 +4,7 @@
 import uuid
 from fractions import Fraction
 from typing import Optional
+from unittest import mock
 from unittest.mock import Mock
 
 import dateutil.parser as dateparser
@@ -167,6 +168,33 @@ def test_def(ns: runtime.Namespace):
     assert lcompile("beep") == "a sound a robot makes"
 
 
+def test_def_no_warn_on_redef(ns: runtime.Namespace):
+    with mock.patch('basilisp.lang.compiler.logger') as logger:
+        lcompile("""
+        (def unique-zhddkd :a)
+        (def ^:no-warn-on-redef unique-zhddkd :b)
+        """)
+
+        logger.warning.assert_not_called()
+
+    with mock.patch('basilisp.lang.compiler.logger') as logger:
+        lcompile("""
+        (def unique-djhvyz :a)
+        (def unique-djhvyz :b)
+        """)
+
+        logger.warning.assert_called_with(f"redefining local Python name 'unique_djhvyz' in module '{ns.name}'")
+
+
+def test_redef_vars(ns: runtime.Namespace):
+    assert kw.keyword('b') == lcompile("""
+    (def ^:redef orig :a)
+    (def redef-check (fn* [] orig))
+    (def orig :b)
+    (redef-check)
+    """)
+
+
 def test_def_dynamic(ns: runtime.Namespace):
     v: Var = lcompile("(def ^:dynamic *a-dynamic-var* 1)")
     assert v.dynamic is True