Make require more flexible about target module

This change allows `require` to be called without a target module, in which case
it will use the caller's globals.  The compiler now produces Python AST that
calls `require` without a target module, with the intention that macros are to
be loaded into the namespace in which its AST is `eval`ed.

Additionally, a test was added that targets this functionality.

hy/compiler.py

@@ -1216,24 +1216,32 @@ def compile_import_or_require(self, expr, root, entries):
 
                     ast_prefix = ast_str(prefix) if prefix else prefix
                     ast_prefix = asty.Str(expr, s=ast_prefix)
-                    call = asty.Call(expr,
-                                     func=asty.Name(expr, id='require', ctx=ast.Load()),
-                                     args=[asty.Str(expr, s=ast_module),
-                                           asty.Str(expr, s=self.module_name)],
-                                     keywords=[
-                                         asty.keyword(expr,
-                                                      arg='assignments',
-                                                      value=names),
-                                         asty.keyword(expr,
-                                                      arg='prefix',
-                                                      value=ast_prefix)])
+                    call = asty.Call(
+                        expr,
+                        func=asty.Name(expr, id='require', ctx=ast.Load()),
+                        args=[
+                            asty.Str(expr, s=ast_module),
+                            # Don't be too specific about the destination of
+                            # the macros from `ast_module`; wherever this
+                            # compiled AST is run is where the macros will be
+                            # added!
+                            asty.Name(expr, id='None', ctx=ast.Load())
+                            # This work in Python 3.x, but not 2.7
+                            # asty.NameConstant(expr, value=None)
+                        ],
+                        keywords=[
+                            asty.keyword(expr,
+                                         arg='assignments',
+                                         value=names),
+                            asty.keyword(expr,
+                                         arg='prefix',
+                                         value=ast_prefix)])
 
                     require_expr = asty.Expr(expr, value=call)
                     ret += require_expr
 
-                if self.module:
-                    require(ast_module, self.module_name,
-                            assignments=assignments, prefix=prefix)
+                require(ast_module, self.module,
+                        assignments=assignments, prefix=prefix)
 
         return ret
 

hy/importer.py

@@ -31,6 +31,15 @@
                         __future__.CO_FUTURE_PRINT_FUNCTION)
 
 
+def calling_module(n=1):
+    frame_up = inspect.stack(0)[n + 1][0]
+    module = inspect.getmodule(frame_up)
+    if module is None:
+        module_name = frame_up.f_globals.get('__name__')
+        module = importlib.import_module(module_name)
+    return module
+
+
 def ast_compile(ast, filename, mode):
     """Compile AST.
 
@@ -108,7 +117,7 @@ def hy_eval(hytree, locals=None, module=None, ast_callback=None):
 
     """
     if module is None:
-        module = inspect.getmodule(inspect.stack()[1][0])
+        module = calling_module()
 
     if isinstance(module, string_types):
         module = importlib.import_module(ast_str(module, piecewise=True))
@@ -336,7 +345,7 @@ def __getattr__(self, item):
             elif item == 'name':
                 return self.fullname
             else:
-                return self[item]
+                super(HyLoader, self).__getattr__(item)
 
         def exec_module(self, module, fullname=None):
             fullname = self._fix_name(fullname)
@@ -449,7 +458,7 @@ def get_code(self, fullname=None):
                     self.code = self.byte_compile_hy(fullname)
 
             if self.code is None:
-              super(HyLoader, self).get_code(fullname=fullname)
+                super(HyLoader, self).get_code(fullname=fullname)
 
             return self.code
 

hy/macros.py

@@ -6,7 +6,7 @@
 import importlib
 import inspect
 
-from hy._compat import PY3
+from hy._compat import PY3, string_types
 import hy.inspect
 from hy.models import replace_hy_obj, HyExpression, HySymbol, wrap_value
 from hy.lex import mangle
@@ -77,8 +77,10 @@ def require(source_module, target_module, assignments, prefix=""):
     source_module: str or types.ModuleType
         The module from which macros are to be imported.
 
-    target_module: str or types.ModuleType
-        The module into which the macros will be loaded.
+    target_module: str, types.ModuleType or None
+        The module into which the macros will be loaded.  If `None`, then
+        the caller's namespace.
+        The latter is useful during evaluation of generated AST/bytecode.
 
     assignments: str or list of tuples of strs
         The string "ALL" or a dict of macro names to aliases.
@@ -102,10 +104,20 @@ def require(source_module, target_module, assignments, prefix=""):
         raise ImportError('Module {} does not contain any macros or tags'.format(
             source_module))
 
-    if not inspect.ismodule(target_module):
+    if target_module is None:
+        parent_frame = inspect.stack()[1][0]
+        target_namespace = parent_frame.f_globals
+    elif isinstance(target_module, string_types):
         target_module = importlib.import_module(target_module)
-    target_macros = target_module.__dict__.setdefault('__macros__', {})
-    target_tags = target_module.__dict__.setdefault('__tags__', {})
+        target_namespace = target_module.__dict__
+    elif inspect.ismodule(target_module):
+        target_namespace = target_module.__dict__
+    else:
+        raise TypeError('`target_module` is not a recognized type: {}'.format(
+            type(target_module)))
+
+    target_macros = target_namespace.setdefault('__macros__', {})
+    target_tags = target_namespace.setdefault('__tags__', {})
 
     if prefix:
         prefix += "."

tests/test_bin.py

@@ -388,3 +388,22 @@ def test_bin_hy_file_no_extension():
     """Confirm that a file with no extension is processed as Hy source"""
     output, _ = run_cmd("hy tests/resources/no_extension")
     assert "This Should Still Work" in output
+
+
+def test_bin_hy_macro_require():
+    """Confirm that a `require` will load macros into the non-module namespace
+    (i.e. `exec(code, locals)`) used by `runpy.run_path`.
+    In other words, this confirms that the AST generated for a `require` will
+    load macros into the unnamed namespace its run in."""
+
+    # First, with no bytecode
+    test_file = "tests/resources/bin/require_and_eval.hy"
+    rm(cache_from_source(test_file))
+    assert not os.path.exists(cache_from_source(test_file))
+    output, _ = run_cmd("hy {}".format(test_file))
+    assert "abc" == output.strip()
+
+    # Now, with bytecode
+    assert os.path.exists(cache_from_source(test_file))
+    output, _ = run_cmd("hy {}".format(test_file))
+    assert "abc" == output.strip()