Add hygienic imports to macros

Author: José Valim

CHANGELOG.md

@@ -12,6 +12,7 @@
   * [Kernel] More optimizations were added to Record handling
   * [Kernel] `?\x` and `?\` are now supported ways to retrieve a codepoint
   * [Kernel] Octal numbers can now be defined as `0777`
+  * [Kernel] Improve macros hygiene regarding variables, aliases and imports
   * [Mix] Mix now starts the current application before run, iex, test and friends
   * [Mix] Mix now provides basic support for compiling `.erl` files
   * [Mix] `mix escriptize` only generates escript if necessary and accept `--force` and `--no-compile` as options

lib/elixir/include/elixir.hrl

@@ -9,26 +9,27 @@
 -define(line(Opts), elixir_tree_helpers:get_line(Opts)).
 
 -record(elixir_scope, {
-  context=nil,                                   %% can be assign, guards or nil
-  noname=false,                                  %% when true, don't add new names (used by try)
-  check_clauses=true,                            %% when true, check def clauses ordering
-  super=false,                                   %% when true, it means super was invoked
-  caller=false,                                  %% when true, it means caller was invoked
-  name_args=false,                               %% when true, it means arguments should be named
-  module=nil,                                    %% the current module
-  function=nil,                                  %% the current function
-  vars=[],                                       %% a dict of defined variables and their alias
-  temp_vars=[],                                  %% a dict of all variables defined in a particular assign
-  clause_vars=nil,                               %% a dict of all variables defined in a particular clause
-  extra_guards=nil,                              %% extra guards from args expansion
-  counter=[],                                    %% a counter for the variables defined
-  local=nil,                                     %% the scope to evaluate local functions against
-  scheduled=[],                                  %% scheduled modules to be loaded
-  file,                                          %% the current scope filename
-  aliases,                                       %% an orddict with aliases by new -> old names
-  requires,                                      %% a set with modules required
-  macros,                                        %% a list with macros imported by module
-  functions}).                                   %% a list with functions imported by module
+  context=nil,             %% can be assign, guards or nil
+  noname=false,            %% when true, don't add new names (used by try)
+  check_requires=true,     %% when true, check requires
+  check_clauses=true,      %% when true, check def clauses ordering
+  super=false,             %% when true, it means super was invoked
+  caller=false,            %% when true, it means caller was invoked
+  name_args=false,         %% when true, it means arguments should be named
+  module=nil,              %% the current module
+  function=nil,            %% the current function
+  vars=[],                 %% a dict of defined variables and their alias
+  temp_vars=[],            %% a dict of all variables defined in a particular assign
+  clause_vars=nil,         %% a dict of all variables defined in a particular clause
+  extra_guards=nil,        %% extra guards from args expansion
+  counter=[],              %% a counter for the variables defined
+  local=nil,               %% the scope to evaluate local functions against
+  scheduled=[],            %% scheduled modules to be loaded
+  file,                    %% the current scope filename
+  aliases,                 %% an orddict with aliases by new -> old names
+  requires,                %% a set with modules required
+  macros,                  %% a list with macros imported by module
+  functions}).             %% a list with functions imported by module
 
 -record(elixir_quote, {
   line=0,

lib/elixir/lib/kernel/special_forms.ex

@@ -356,6 +356,7 @@ defmodule Kernel.SpecialForms do
   * `:location` - When set to `:keep`, keeps the current line and file on quotes.
                   Read the Stacktrace information section below for more information;
   * `:expand_aliases` - When false, do not expand aliases;
+  * `:expand_imports` - When false, do not expand imports;
   * `:var_context` - The context for quoted variables. Defaults to the current module;
 
   ## Macro literals
@@ -482,6 +483,55 @@ defmodule Kernel.SpecialForms do
       require NoHygiene
       NoHygiene.interference #=> UndefinedFunctionError
 
+  ## Hygiene in imports
+
+  Similar to aliases, imports in Elixir hygienic. Consider the
+  following code:
+
+      defmodule Hygiene do
+        defmacrop get_size do
+          quote do
+            size("hello")
+          end
+        end
+
+        def return_size do
+          import Kernel, except: [size: 1]
+          get_size
+        end
+      end
+
+      Hygiene.return_size #=> 5
+
+  Notice how `return_size` returns 5 even though the `size/1`
+  function is not imported.
+
+  Elixir is smart enough to delay the resolution to the latest
+  moment possible. So, if you call `size("hello")` inside quote,
+  but no `size/1` function is available, it is then expanded on
+  the caller:
+
+      defmodule Lazy do
+        defmacrop get_size do
+          import Kernel, except: [size: 1]
+
+          quote do
+            size([a: 1, b: 2])
+          end
+        end
+
+        def return_size do
+          import Kernel, except: [size: 1]
+          import Dict, only: [size: 1]
+          get_size
+        end
+      end
+
+      Lazy.return_size #=> 2
+
+  As in aliases, imports expansion can be explicitly disabled
+  via the `expand_imports` option.
+
   ## Stacktrace information
 
   One of Elixir goals is to provide proper stacktrace whenever there is an

lib/elixir/src/elixir_quote.erl

@@ -83,11 +83,17 @@ do_quote({ Left, Meta, nil }, Q, S) when is_atom(Left) ->
   ] },
   { Tuple, S };
 
-% do_quote({ Name, Line, Args } = Tuple, #elixir_quote{expand_imports=true} = Q, S) when is_atom(Name), is_list(Args) ->
-%   case elixir_dispatch:find_import(Line, Name, length(Args), S) of
-%     false -> do_quote_tuple(Tuple, Q, S);
-%     Receiver -> do_quote_tuple({ { '.', Line, [Receiver, Name] }, Line, Args }, Q, S)
-%   end;
+do_quote({ Name, Meta, ArgsOrAtom } = Tuple, #elixir_quote{expand_imports=true} = Q, S) when is_atom(Name) ->
+  Arity = case is_atom(ArgsOrAtom) of
+    true  -> 0;
+    false -> length(ArgsOrAtom)
+  end,
+
+  case (lists:keyfind(import, 1, Meta) == false) andalso
+      elixir_dispatch:find_import(Meta, Name, Arity, S) of
+    false    -> do_quote_tuple(Tuple, Q, S);
+    Receiver -> do_quote_tuple({ Name, [{import,Receiver}|Meta], ArgsOrAtom }, Q, S)
+  end;
 
 do_quote({ _, _, _ } = Tuple, Q, S) ->
   do_quote_tuple(Tuple, Q, S);

lib/elixir/src/elixir_translator.erl

@@ -413,19 +413,28 @@ translate_each({ Atom, Meta, Args } = Original, S) when is_atom(Atom) ->
     false ->
       case elixir_partials:handle(Original, S) of
         error ->
-          Callback = fun() ->
-            case S#elixir_scope.context of
-              guard ->
-                Arity = length(Args),
-                File  = S#elixir_scope.file,
-                case Arity of
-                  0 -> syntax_error(Meta, File, "unknown variable ~s or cannot invoke local ~s/~B inside guard", [Atom, Atom, Arity]);
-                  _ -> syntax_error(Meta, File, "cannot invoke local ~s/~B inside guard", [Atom, Arity])
-                end;
-              _ -> translate_local(Meta, Atom, Args, S)
-            end
-          end,
-          elixir_dispatch:dispatch_import(Meta, Atom, Args, S, Callback);
+          case lists:keyfind(import, 1, Meta) of
+            { import, Receiver } ->
+              { TRes, TS } = translate_each({ { '.', Meta, [Receiver, Atom] }, Meta, Args },
+                S#elixir_scope{check_requires=false}),
+              { TRes, TS#elixir_scope{check_requires=S#elixir_scope.check_requires} };
+            false ->
+              Callback = fun() ->
+                case S#elixir_scope.context of
+                  guard ->
+                    Arity = length(Args),
+                    File  = S#elixir_scope.file,
+                    case Arity of
+                      0 -> syntax_error(Meta, File, "unknown variable ~s or cannot invoke local ~s/~B inside guard", [Atom, Atom, Arity]);
+                      _ -> syntax_error(Meta, File, "cannot invoke local ~s/~B inside guard", [Atom, Arity])
+                    end;
+                  _ ->
+                    translate_local(Meta, Atom, Args, S)
+                end
+              end,
+
+              elixir_dispatch:dispatch_import(Meta, Atom, Args, S, Callback)
+          end;
         Else  -> Else
       end;
     Else -> Else

lib/elixir/test/elixir/code_test.exs

@@ -61,8 +61,8 @@ defmodule CodeTest do
   end
 
   test :string_to_ast do
-    assert { :ok, quote line: 1, do: 1 + 2 } = Code.string_to_ast("1 + 2")
-    assert { :ok, quote line: 1, do: (1 + 2; 3 + 4) } = Code.string_to_ast("1 + 2; 3 + 4")
+    assert Code.string_to_ast("1 + 2") == { :ok, quote hygiene: false, line: 1, do: 1 + 2 }
+    assert Code.string_to_ast("1 + 2; 3 + 4") == { :ok, quote hygiene: false, line: 1, do: (1 + 2; 3 + 4) }
     assert { :error, _ } = Code.string_to_ast("a.1")
   end
 
@@ -72,7 +72,7 @@ defmodule CodeTest do
   end
 
   test :string_to_ast! do
-    assert Code.string_to_ast!("1 + 2") == quote line: 1, do: 1 + 2
+    assert Code.string_to_ast!("1 + 2") == quote hygiene: false, line: 1, do: 1 + 2
 
     assert_raise SyntaxError, fn ->
       Code.string_to_ast!("a.1")

lib/elixir/test/elixir/kernel/quote_test.exs

@@ -152,3 +152,32 @@ defmodule Kernel.QuoteTest.AliasHygieneTest do
     assert Code.eval_quoted(quote expand_aliases: false, do: Foo.Bar)  == { Foo.Bar, [] }
   end
 end
+
+defmodule Kernel.QuoteTest.ImportsHygieneTest do
+  use ExUnit.Case, async: true
+
+  defmacrop get_bin_size do
+    quote do
+      size("hello")
+    end
+  end
+
+  test :expand_imports do
+    import Kernel, except: [size: 1]
+    assert get_bin_size == 5
+  end
+
+  defmacrop get_dict_size do
+    import Kernel, except: [size: 1]
+
+    quote do
+      size([a: 1, b: 2])
+    end
+  end
+
+  test :lazy_expand_imports do
+    import Kernel, except: [size: 1]
+    import Dict, only: [size: 1]
+    assert get_dict_size == 2
+  end
+end

lib/elixir/test/erlang/module_test.erl

@@ -34,7 +34,7 @@ dynamic_function_test() ->
 
 quote_unquote_test() ->
   F = fun() ->
-    eval("defmodule Foo.Bar.Baz do\ndefmacro sum(a, b), do: quote(do: unquote(a) + unquote(b))\nend"),
+    eval("defmodule Foo.Bar.Baz do\ndefmacro sum(a, b), do: quote(hygiene: false, do: unquote(a) + unquote(b))\nend"),
     {'+',[],[1,2]} = 'Elixir.Foo.Bar.Baz':'MACRO-sum'(nil, 1, 2)
   end,
   test_helper:run_and_remove(F, ['Elixir.Foo.Bar.Baz']).
@@ -44,7 +44,7 @@ quote_unquote_splicing_test() ->
 
 operator_macro_test() ->
   F = fun() ->
-    eval("defmodule Foo.Bar.Baz do\ndefmacro :+.(a, b), do: quote(do: unquote(a) - unquote(b))\nend"),
+    eval("defmodule Foo.Bar.Baz do\ndefmacro :+.(a, b), do: quote(hygiene: false, do: unquote(a) - unquote(b))\nend"),
     {'-',[],[1,2]} = 'Elixir.Foo.Bar.Baz':'MACRO-+'(nil, 1, 2)
   end,
   test_helper:run_and_remove(F, ['Elixir.Foo.Bar.Baz']).