Allow file, line and context to be dynamically set on quote, closes #9721

Author: josevalim

lib/elixir/src/elixir.hrl

@@ -16,17 +16,6 @@
   stacktrace=nil           %% holds information about the stacktrace variable
 }).
 
--record(elixir_quote, {
-  line=false,
-  file=nil,
-  context=nil,
-  vars_hygiene=true,
-  aliases_hygiene=true,
-  imports_hygiene=true,
-  unquote=true,
-  generated=false
-}).
-
 -record(elixir_tokenizer, {
   file=(<<"nofile">>),
   terminators=[],

lib/elixir/src/elixir_expand.erl

@@ -156,31 +156,16 @@ expand({quote, Meta, [Opts, Do]}, E) when is_list(Do) ->
   ValidOpts = [context, location, line, file, unquote, bind_quoted, generated],
   {EOpts, ET} = expand_opts(Meta, quote, ValidOpts, Opts, E),
 
-  Context = case lists:keyfind(context, 1, EOpts) of
-    {context, Ctx} when is_atom(Ctx) and (Ctx /= nil) ->
-      Ctx;
-    {context, Ctx} ->
-      form_error(Meta, E, ?MODULE, {invalid_context_for_quote, Ctx});
-    false ->
-      case ?key(E, module) of
-        nil -> 'Elixir';
-        Mod -> Mod
-      end
-  end,
+  Context = proplists:get_value(context, EOpts, case ?key(E, module) of
+    nil -> 'Elixir';
+    Mod -> Mod
+  end),
 
   {File, Line} = case lists:keyfind(location, 1, EOpts) of
     {location, keep} ->
       {elixir_utils:relative_to_cwd(?key(E, file)), false};
     false ->
-      { case lists:keyfind(file, 1, EOpts) of
-          {file, F} -> F;
-          false -> nil
-        end,
-
-        case lists:keyfind(line, 1, EOpts) of
-          {line, L} -> L;
-          false -> false
-        end }
+      {proplists:get_value(file, EOpts, nil), proplists:get_value(line, EOpts, false)}
   end,
 
   {Binding, DefaultUnquote} = case lists:keyfind(bind_quoted, 1, EOpts) of
@@ -191,20 +176,14 @@ expand({quote, Meta, [Opts, Do]}, E) when is_list(Do) ->
         false -> form_error(Meta, E, ?MODULE, {invalid_bind_quoted_for_quote, BQ})
       end;
     false ->
-      {nil, true}
+      {[], true}
   end,
 
-  Unquote = case lists:keyfind(unquote, 1, EOpts) of
-    {unquote, U} when is_boolean(U) -> U;
-    false -> DefaultUnquote
-  end,
-
-  Generated = lists:keyfind(generated, 1, EOpts) == {generated, true},
-
-  Q = #elixir_quote{line=Line, file=File, unquote=Unquote,
-                    context=Context, generated=Generated},
+  Unquote = proplists:get_value(unquote, EOpts, DefaultUnquote),
+  Generated = proplists:get_value(generated, EOpts, false),
 
-  Quoted = elixir_quote:quote(Meta, Exprs, Binding, Q, ET),
+  {Q, Prelude} = elixir_quote:build(Meta, Line, File, Context, Unquote, Generated),
+  Quoted = elixir_quote:quote(Meta, Exprs, Binding, Q, Prelude, ET),
   expand(Quoted, ET);
 
 expand({quote, Meta, [_, _]}, E) ->
@@ -1133,9 +1112,6 @@ format_error({expected_compile_time_module, Kind, GivenTerm}) ->
 format_error({unquote_outside_quote, Unquote}) ->
   %% Unquote can be "unquote" or "unquote_splicing".
   io_lib:format("~p called outside quote", [Unquote]);
-format_error({invalid_context_for_quote, Context}) ->
-  io_lib:format("invalid :context for quote, expected non-nil compile time atom or alias, got: ~ts",
-                ['Elixir.Macro':to_string(Context)]);
 format_error({invalid_bind_quoted_for_quote, BQ}) ->
   io_lib:format("invalid :bind_quoted for quote, expected a keyword list of variable names, got: ~ts",
                 ['Elixir.Macro':to_string(BQ)]);

lib/elixir/src/elixir_quote.erl

@@ -1,12 +1,71 @@
 -module(elixir_quote).
--export([escape/3, linify/3, linify_with_context_counter/3, quote/5, has_unquotes/1]).
--export([dot/5, tail_list/3, list/2]). %% Quote callbacks
+-export([escape/3, linify/3, linify_with_context_counter/3, build/6, quote/6, has_unquotes/1]).
+-export([dot/5, tail_list/3, list/2, validate_runtime/2]). %% Quote callbacks
 
 -include("elixir.hrl").
 -define(defs(Kind), Kind == def; Kind == defp; Kind == defmacro; Kind == defmacrop; Kind == '@').
 -define(lexical(Kind), Kind == import; Kind == alias; Kind == require).
 -compile({inline, [keyfind/2, keystore/3, keydelete/2, keynew/3, do_tuple_linify/5]}).
 
+-record(elixir_quote, {
+  line=false,
+  file=nil,
+  context=nil,
+  vars_hygiene=true,
+  aliases_hygiene=true,
+  imports_hygiene=true,
+  unquote=true,
+  generated=false
+}).
+
+build(Meta, Line, File, Context, Unquote, Generated) ->
+  Acc0 = [],
+  {ELine, Acc1} = validate_compile(Meta, line, Line, Acc0),
+  {EFile, Acc2} = validate_compile(Meta, file, File, Acc1),
+  {EContext, Acc3} = validate_compile(Meta, context, Context, Acc2),
+  validate_runtime(unquote, Unquote),
+  validate_runtime(generated, Generated),
+
+  Q = #elixir_quote{
+    line=ELine,
+    file=EFile,
+    unquote=Unquote,
+    context=EContext,
+    generated=Generated
+  },
+
+  {Q, Acc3}.
+
+validate_compile(Meta, Key, Value, Acc) ->
+  case is_valid(Key, Value) of
+    true ->
+      {Value, Acc};
+    false ->
+      Var = {Key, Meta, ?MODULE},
+      Call = {{'.', Meta, [?MODULE, validate_runtime]}, Meta, [Key, Value]},
+      {Var, [{'=', Meta, [Var, Call]} | Acc]}
+  end.
+
+validate_runtime(Key, Value) ->
+  case is_valid(Key, Value) of
+    true ->
+      Value;
+
+    false ->
+      erlang:error(
+        'Elixir.ArgumentError':exception(
+          <<"invalid value for option :", (erlang:atom_to_binary(Key, utf8))/binary,
+            "in quote, got: ", ('Elixir.Kernel':inspect(Value))/binary>>
+        )
+      )
+  end.
+
+is_valid(line, Line) -> is_integer(Line) orelse is_boolean(Line);
+is_valid(file, File) -> is_binary(File) orelse (File == nil);
+is_valid(context, Context) -> is_atom(Context) andalso (Context /= nil);
+is_valid(generated, Generated) -> is_boolean(Generated);
+is_valid(unquote, Unquote) -> is_boolean(Unquote).
+
 %% Apply the line from site call on quoted contents.
 %% Receives a Key to look for the default line as argument.
 linify(0, _Key, Exprs) ->
@@ -164,26 +223,31 @@ escape(Expr, Kind, Unquote) ->
 
 %% Quotes an expression and return its quoted Elixir AST.
 
-quote(_Meta, {unquote_splicing, _, [_]}, _Binding, #elixir_quote{unquote=true}, _) ->
+quote(_Meta, {unquote_splicing, _, [_]}, _Binding, #elixir_quote{unquote=true}, _, _) ->
   argument_error(<<"unquote_splicing only works inside arguments and block contexts, "
     "wrap it in parens if you want it to work with one-liners">>);
 
-quote(_Meta, Expr, nil, Q, E) ->
-  do_quote(Expr, Q, E);
-
-quote(Meta, Expr, Binding, Q, E) ->
+quote(Meta, Expr, Binding, Q, Prelude, E) ->
   Context = Q#elixir_quote.context,
-  VarMeta = [Pair || {K, _} = Pair <- Meta, K == counter],
 
-  Vars = [ {'{}', [],
-    [ '=', [], [
-      {'{}', [], [K, VarMeta, Context]},
+  Vars = [{'{}', [],
+    ['=', [], [
+      {'{}', [], [K, Meta, Context]},
       V
-    ] ]
+    ]]
   } || {K, V} <- Binding],
 
-  TExprs = do_quote(Expr, Q, E),
-  {'{}', [], ['__block__', [], Vars ++ [TExprs]]}.
+  Quoted = do_quote(Expr, Q, E),
+
+  WithVars = case Vars of
+    [] -> Quoted;
+    _ -> {'{}', [], ['__block__', [], Vars ++ [Quoted]]}
+  end,
+
+  case Prelude of
+    [] -> WithVars;
+    _ -> {'__block__', [], Prelude ++ [WithVars]}
+  end.
 
 %% Actual quoting and helpers
 
@@ -224,11 +288,12 @@ do_quote({'__aliases__', Meta, [H | T]} = Alias, #elixir_quote{aliases_hygiene=t
 
 %% Vars
 
-do_quote({Left, Meta, nil}, #elixir_quote{vars_hygiene=true, imports_hygiene=true} = Q, E) when is_atom(Left) ->
-  do_quote_import(Left, Meta, Q#elixir_quote.context, Q, E);
+do_quote({Name, Meta, nil}, #elixir_quote{vars_hygiene=true, imports_hygiene=true} = Q, E) when is_atom(Name) ->
+  ImportMeta = import_meta(Meta, Name, 0, Q, E),
+  {'{}', [], [Name, meta(ImportMeta, Q), Q#elixir_quote.context]};
 
-do_quote({Left, Meta, nil}, #elixir_quote{vars_hygiene=true} = Q, E) when is_atom(Left) ->
-  do_quote_tuple(Left, Meta, Q#elixir_quote.context, Q, E);
+do_quote({Name, Meta, nil}, #elixir_quote{vars_hygiene=true} = Q, _E) when is_atom(Name) ->
+  {'{}', [], [Name, meta(Meta, Q), Q#elixir_quote.context]};
 
 %% Unquote
 
@@ -244,8 +309,11 @@ do_quote({'&', Meta, [{'/', _, [{F, _, C}, A]}] = Args},
          #elixir_quote{imports_hygiene=true} = Q, E) when is_atom(F), is_integer(A), is_atom(C) ->
   do_quote_fa('&', Meta, Args, F, A, Q, E);
 
-do_quote({Name, Meta, ArgsOrAtom}, #elixir_quote{imports_hygiene=true} = Q, E) when is_atom(Name) ->
-  do_quote_import(Name, Meta, ArgsOrAtom, Q, E);
+do_quote({Name, Meta, Args}, #elixir_quote{imports_hygiene=true} = Q, E) when is_atom(Name), is_list(Args) ->
+  do_quote_import(Meta, Name, length(Args), Args, Q, E);
+
+do_quote({Name, Meta, Context}, #elixir_quote{imports_hygiene=true} = Q, E) when is_atom(Name), is_atom(Context) ->
+  do_quote_import(Meta, Name, 0, Context, Q, E);
 
 %% Two-element tuples
 
@@ -341,15 +409,8 @@ bad_escape(Arg) ->
                    "The supported values are: lists, tuples, maps, atoms, numbers, bitstrings, ",
                    "PIDs and remote functions in the format &Mod.fun/arity">>).
 
-%% do_quote_*
-
-do_quote_import(Name, Meta, ArgsOrAtom, #elixir_quote{imports_hygiene=true} = Q, E) ->
-  Arity = case is_atom(ArgsOrAtom) of
-    true  -> 0;
-    false -> length(ArgsOrAtom)
-  end,
-
-  NewMeta = case (keyfind(import, Meta) == false) andalso
+import_meta(Meta, Name, Arity, Q, E) ->
+  case (keyfind(import, Meta) == false) andalso
       elixir_dispatch:find_import(Meta, Name, Arity, E) of
     false ->
       case (Arity == 1) andalso keyfind(ambiguous_op, Meta) of
@@ -358,9 +419,13 @@ do_quote_import(Name, Meta, ArgsOrAtom, #elixir_quote{imports_hygiene=true} = Q,
       end;
     Receiver ->
       keystore(import, keystore(context, Meta, Q#elixir_quote.context), Receiver)
-  end,
+  end.
+
+%% do_quote_*
 
-  Annotated = annotate({Name, NewMeta, ArgsOrAtom}, Q#elixir_quote.context),
+do_quote_import(Meta, Name, Arity, ArgsOrAtom, Q, E) ->
+  ImportMeta = import_meta(Meta, Name, Arity, Q, E),
+  Annotated = annotate({Name, ImportMeta, ArgsOrAtom}, Q#elixir_quote.context),
   do_quote_tuple(Annotated, Q, E).
 
 do_quote_call(Left, Meta, Expr, Args, Q, E) ->

lib/elixir/test/elixir/kernel/expansion_test.exs

@@ -548,16 +548,6 @@ defmodule Kernel.ExpansionTest do
       assert expand(quote(do: quote(do: hello))) == {:{}, [], [:hello, [], __MODULE__]}
     end
 
-    test "raises if the :context option is invalid" do
-      assert_raise CompileError, ~r"invalid :context for quote, .*, got: :erlang\.self\(\)", fn ->
-        expand(quote(do: quote(context: self(), do: :ok)))
-      end
-
-      assert_raise CompileError, ~r"invalid :context for quote, .*, got: nil", fn ->
-        expand(quote(do: quote(context: nil, do: :ok)))
-      end
-    end
-
     test "raises if the :bind_quoted option is invalid" do
       assert_raise CompileError, ~r"invalid :bind_quoted for quote", fn ->
         expand(quote(do: quote(bind_quoted: self(), do: :ok)))

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

@@ -12,19 +12,39 @@ defmodule Kernel.QuoteTest do
   end
 
   test "keep line" do
-    # DO NOT MOVE THIS LINE
+    line = __ENV__.line + 2
+
     assert quote(location: :keep, do: bar(1, 2, 3)) ==
-             {:bar, [keep: {Path.relative_to_cwd(__ENV__.file), 16}], [1, 2, 3]}
+             {:bar, [keep: {Path.relative_to_cwd(__ENV__.file), line}], [1, 2, 3]}
   end
 
   test "fixed line" do
     assert quote(line: 3, do: bar(1, 2, 3)) == {:bar, [line: 3], [1, 2, 3]}
   end
 
   test "quote line var" do
-    # DO NOT MOVE THIS LINE
     line = __ENV__.line
-    assert quote(line: line, do: bar(1, 2, 3)) == {:bar, [line: 26], [1, 2, 3]}
+    assert quote(line: line, do: bar(1, 2, 3)) == {:bar, [line: line], [1, 2, 3]}
+
+    assert_raise ArgumentError, fn ->
+      line = "oops"
+      quote(line: line, do: bar(1, 2, 3))
+    end
+  end
+
+  test "quote context var" do
+    context = :dynamic
+    assert quote(context: context, do: bar) == {:bar, [], :dynamic}
+
+    assert_raise ArgumentError, fn ->
+      context = "oops"
+      quote(context: context, do: bar)
+    end
+
+    assert_raise ArgumentError, fn ->
+      context = nil
+      quote(context: context, do: bar)
+    end
   end
 
   test "operator precedence" do
@@ -185,7 +205,7 @@ defmodule Kernel.QuoteTest do
 
   test "bind quoted" do
     args = [
-      {:=, [], [{:foo, [], Kernel.QuoteTest}, 3]},
+      {:=, [], [{:foo, [line: __ENV__.line + 4], Kernel.QuoteTest}, 3]},
       {:foo, [], Kernel.QuoteTest}
     ]
 
@@ -276,6 +296,8 @@ end
 
 # DO NOT MOVE THIS LINE
 defmodule Kernel.QuoteTest.Errors do
+  def line, do: __ENV__.line + 4
+
   defmacro defraise do
     quote location: :keep do
       def will_raise(_a, _b), do: raise("oops")
@@ -294,27 +316,29 @@ defmodule Kernel.QuoteTest.ErrorsTest do
   # Defines the add function
   defraise()
 
+  @line line()
   test "inside function error" do
     try do
       will_raise(:a, :b)
     rescue
       RuntimeError ->
         mod = Kernel.QuoteTest.ErrorsTest
         file = __ENV__.file |> Path.relative_to_cwd() |> String.to_charlist()
-        assert [{^mod, :will_raise, 2, [file: ^file, line: 281]} | _] = __STACKTRACE__
+        assert [{^mod, :will_raise, 2, [file: ^file, line: @line]} | _] = __STACKTRACE__
     else
       _ -> flunk("expected failure")
     end
   end
 
+  @line __ENV__.line + 3
   test "outside function error" do
     try do
       will_raise()
     rescue
       RuntimeError ->
         mod = Kernel.QuoteTest.ErrorsTest
         file = __ENV__.file |> Path.relative_to_cwd() |> String.to_charlist()
-        assert [{^mod, _, _, [file: ^file, line: 312]} | _] = __STACKTRACE__
+        assert [{^mod, _, _, [file: ^file, line: @line]} | _] = __STACKTRACE__
     else
       _ -> flunk("expected failure")
     end