Support binding/2 that goes across all contexts

Author: José Valim

lib/elixir/lib/file.ex

@@ -56,7 +56,7 @@ end
 
 defmodule File do
   @moduledoc """
-  This module contains function to manipulate files.
+  This module contains functions to manipulate files.
 
   Some of those functions are low-level, allowing the user
   to interact with the file or IO devices, like `File.open/2`,

lib/elixir/lib/kernel.ex

@@ -2467,6 +2467,26 @@ defmodule Kernel do
   """
   defmacro binding(list)
 
+  @doc """
+  Receives a list of tuples at compilation time containing the
+  variable name and its scope and returns the binding of the given
+  variables as a keyword list with the variable name and scope pair
+  as key and the variable value as value.
+
+  In case a variable in the list does not exist in the binding,
+  it is not included in the returned result.
+
+  ## Examples
+
+      iex> var!(x, :foo) = 1
+      iex> binding([x: nil], true)
+      []
+      iex> binding([x: :foo], true)
+      [{ { :x, :foo }, 1 }]
+
+  """
+  defmacro binding(list, true)
+
   @doc """
   Provides an `if` macro. This macro expects the first argument to
   be a condition and the rest are keyword arguments.

lib/elixir/src/elixir_dispatch.erl

@@ -449,6 +449,7 @@ in_erlang_macros() ->
     {apply,3},
     {binding,0},
     {binding,1},
+    {binding,2},
     {'case',2},
     {def,1},
     {def,2},

lib/elixir/src/elixir_macros.erl

@@ -133,12 +133,17 @@ translate({'@', Meta, [{ Name, _, Args }]}, S) ->
 %% Binding
 
 translate({ 'binding', Meta, [] }, S) ->
+  translate({ 'binding', Meta, [false] }, S);
+
+translate({ 'binding', Meta, [false] }, S) ->
   Line = ?line(Meta),
   { elixir_tree_helpers:list_to_cons(Line,
-    [ { tuple, Line, [
-      { atom, Line, Name },
-      { var, Line, Var }
-    ] } || { { Name, nil }, Var } <- S#elixir_scope.vars]), S };
+    [ to_var_value_tuple(Line, Name, Var) || { { Name, nil }, Var } <- S#elixir_scope.vars]), S };
+
+translate({ 'binding', Meta, [true] }, S) ->
+  Line = ?line(Meta),
+  { elixir_tree_helpers:list_to_cons(Line,
+    [ to_var_value_tuple(Line, Name, Kind, Var) || { { Name, Kind }, Var } <- S#elixir_scope.vars]), S };
 
 translate({ 'binding', Meta, [List] }, #elixir_scope{vars=Vars} = S) when is_list(List) ->
   Line = ?line(Meta),
@@ -155,10 +160,24 @@ translate({ 'binding', Meta, [List] }, #elixir_scope{vars=Vars} = S) when is_lis
         "at compilation time, got: ~ts", ['Elixir.Macro':to_string(Name)])
   end, [], List),
   { elixir_tree_helpers:list_to_cons(Line,
-    [ { tuple, Line, [
-      { atom, Line, Name },
-      { var, Line, Var }
-    ] } || { Name, Var } <- Dict]), S };
+    [ to_var_value_tuple(Line, Name, Var) || { Name, Var } <- Dict]), S };
+
+translate({ 'binding', Meta, [List, true] }, #elixir_scope{vars=Vars} = S) when is_list(List) ->
+  Line = ?line(Meta),
+  Dict = lists:foldl(fun
+    (Tuple, Acc) when is_tuple(Tuple) ->
+      case orddict:find(Tuple, Vars) of
+        { ok, Var } ->
+          orddict:store(Tuple, Var, Acc);
+        error ->
+          Acc
+      end;
+    (Tuple, _Acc) ->
+      elixir_errors:syntax_error(Line, S#elixir_scope.file, "binding/2 expects a list of tuples "
+        "at compilation time, got: ~ts", ['Elixir.Macro':to_string(Tuple)])
+  end, [], List),
+  { elixir_tree_helpers:list_to_cons(Line,
+    [ to_var_value_tuple(Line, Name, Kind, Var) || { { Name, Kind }, Var } <- Dict]), S };
 
 %% Case
 
@@ -382,6 +401,19 @@ is_reserved_data(moduledoc) -> true;
 is_reserved_data(doc)       -> true;
 is_reserved_data(_)         -> false.
 
+to_var_value_tuple(Line, Name, Var) ->
+  { tuple, Line,
+    [ { atom, Line, Name },
+      { var, Line, Var } ] }.
+
+to_var_value_tuple(Line, Name, Kind, Var) ->
+  { tuple, Line,
+    [ { tuple, Line, [
+        { atom, Line, Name },
+        { atom, Line, Kind }
+      ] },
+      { var, Line, Var } ] }.
+
 spec_to_macro(type)     -> deftype;
 spec_to_macro(typep)    -> deftypep;
 spec_to_macro(opaque)   -> defopaque;

lib/elixir/test/elixir/kernel_test.exs

@@ -94,6 +94,15 @@ defmodule KernelTest do
     assert binding == [x: 2, y: 3]
   end
 
+  test :binding_with_all_contexts do
+    x = 1
+    assert { { :x, nil }, 1 } in binding(true)
+
+    var!(x, :foo) = 2
+    assert { { :x, :foo }, 2 } in binding(true)
+    assert binding([x: :foo], true) == [{ { :x, :foo }, 2 }]
+  end
+
   defp x(value) when value in [1, 2, 3], do: true
   defp x(_),                             do: false