Only add quoted: true to required ast nodes

Author: José Valim

lib/elixir/include/elixir.hrl

@@ -44,6 +44,9 @@
   mark=true
 }).
 
+%% Introspection
+-define(defs(Kind), Kind == def; Kind == defp; Kind == defmacro; Kind == defmacrop).
+
 %% Used in tokenization and interpolation
 
 %% Numbers

lib/elixir/lib/kernel/special_forms.ex

@@ -359,24 +359,22 @@ defmodule Kernel.SpecialForms do
   ## Examples
 
       iex> quote do: sum(1, 2, 3)
-      { :sum, [quoted: true], [1, 2, 3] }
+      { :sum, [], [1, 2, 3] }
 
   ## Explanation
 
   Any Elixir code can be represented using Elixir data structures.
-  The building block of Elixir homoiconicity is a tuple with three
-  elements, for example:
+  The building block of Elixir macros is a tuple with three elements,
+  for example:
 
-      { :sum, , [1, 2, 3] }
+      { :sum, [], [1, 2, 3] }
 
   The tuple above represents a function call to sum passing 1, 2 and
   3 as arguments. The tuple elements are:
 
   * The first element of the tuple is always an atom or
     another tuple in the same representation;
-  * The second element of the tuple represents metadata.
-    For example, quoted expressions contain [quoted: true]
-    to represent the element was generated from a quote.
+  * The second element of the tuple represents metadata;
   * The third element of the tuple are the arguments for the
     function call. The third argument may be an atom, which is
     usually a variable (or a local call);
@@ -420,7 +418,7 @@ defmodule Kernel.SpecialForms do
       end
 
       ContextSample.hello
-      #=> {:world,[quoted: true],ContextSample}
+      #=> {:world,[],ContextSample}
 
   Notice how the third element of the returned tuple is the
   module name. This means that the variable is associated to the
@@ -714,7 +712,7 @@ defmodule Kernel.SpecialForms do
   and should not be invoked directly:
 
       iex> quote do: (1; 2; 3)
-      { :__block__, [quoted: true], [1,2,3] }
+      { :__block__, [], [1,2,3] }
 
   """
   defmacro __block__(args)
@@ -737,13 +735,13 @@ defmodule Kernel.SpecialForms do
   It is usually compiled to an atom:
 
       quote do: Foo.Bar #=>
-      { :__aliases__, [quoted: true], [:Foo,:Bar] }
+      { :__aliases__, [], [:Foo,:Bar] }
 
   Elixir represents `Foo.Bar` as `__aliases__` so calls can be
   unambiguously identified by the operator `:.`. For example:
 
       quote do: Foo.bar #=>
-      {{:.,[quoted: true],[{:__aliases__,[quoted: true],[:Foo]},:bar]},[],[]}
+      {{:.,[],[{:__aliases__,[],[:Foo]},:bar]},[],[]}
 
   Whenever an expression iterator sees a `:.` as the tuple key,
   it can be sure that it represents a call and the second argument
@@ -760,7 +758,7 @@ defmodule Kernel.SpecialForms do
   4) When the head element of aliases is not an atom, it is expanded at runtime:
 
         quote do: some_var.Foo
-        {:__aliases__,[quoted: true],[{:some_var,[quoted: true],:quoted},:Bar]}
+        {:__aliases__,[],[{:some_var,[],:quoted},:Bar]}
 
      Since `some_var` is not available at compilation time, the compiler
      expands such expression to:

lib/elixir/src/elixir_aliases.erl

@@ -1,9 +1,25 @@
 -module(elixir_aliases).
 -export([nesting_alias/2, last/1, concat/1, safe_concat/1,
-  format_error/1, ensure_loaded/3, expand/3]).
+  format_error/1, ensure_loaded/3, expand/3, store/4]).
 -include("elixir.hrl").
 -compile({parse_transform, elixir_transform}).
 
+%% Store an alias in the given scope
+store(_Meta, New, New, S) -> S;
+store(Meta, New, Old, S) ->
+  SA = S#elixir_scope{
+    aliases=orddict:store(New, Old, S#elixir_scope.aliases)
+  },
+
+  case lists:keymember(context, 1, Meta) of
+    true ->
+      SA#elixir_scope{
+        macro_aliases=orddict:store(New, Old, S#elixir_scope.macro_aliases)
+      };
+    false ->
+      SA
+  end.
+
 %% Expand an alias. It returns an atom (meaning that there
 %% was an expansion) or a list of atoms.
 

lib/elixir/src/elixir_import.erl

@@ -36,7 +36,7 @@ record_warn(Meta, Ref, Opts, S) ->
     case keyfind(warn, Opts) of
       { warn, false } -> false;
       { warn, true } -> true;
-      false -> lists:keyfind(quoted, 1, Meta) /= { quoted, true }
+      false -> not lists:keymember(context, 1, Meta)
     end,
 
   Warn andalso ets:insert(Table, { Ref, ?line(Meta) }).

lib/elixir/src/elixir_macros.erl

@@ -6,11 +6,9 @@
 -import(elixir_scope, [umergec/2]).
 -import(elixir_errors, [syntax_error/3, syntax_error/4,
   assert_no_function_scope/3, assert_module_scope/3, assert_no_match_or_guard_scope/3]).
--include("elixir.hrl").
-
--define(FUNS(Kind), Kind == def; Kind == defp; Kind == defmacro; Kind == defmacrop).
--define(IN_TYPES(Kind), Kind == atom orelse Kind == integer orelse Kind == float).
 
+-include("elixir.hrl").
+-define(opt_in_types(Kind), Kind == atom orelse Kind == integer orelse Kind == float).
 -compile({parse_transform, elixir_transform}).
 
 %% Operators
@@ -201,12 +199,8 @@ translate({defmodule, Meta, [Ref, KV]}, S) ->
       FullModule = expand_module(Ref, Module, S),
 
       RS = case elixir_aliases:nesting_alias(S#elixir_scope.module, FullModule) of
-        { New, Old } ->
-          S#elixir_scope{
-            aliases=orddict:store(New, Old, S#elixir_scope.aliases),
-            macro_aliases=orddict:store(New, Old, S#elixir_scope.macro_aliases)};
-        false ->
-          S
+        { New, Old } -> elixir_aliases:store(Meta, New, Old, S);
+        false -> S
       end,
 
       {
@@ -220,19 +214,19 @@ translate({defmodule, Meta, [Ref, KV]}, S) ->
   MS = FS#elixir_scope{local=nil},
   { elixir_module:translate(Meta, FRef, Block, MS), FS };
 
-translate({Kind, Meta, [Call]}, S) when ?FUNS(Kind) ->
+translate({Kind, Meta, [Call]}, S) when ?defs(Kind) ->
   translate({Kind, Meta, [Call, nil]}, S);
 
-translate({Kind, Meta, [Call, Expr]}, S) when ?FUNS(Kind) ->
+translate({Kind, Meta, [Call, Expr]}, S) when ?defs(Kind) ->
   assert_module_scope(Meta, Kind, S),
   assert_no_function_scope(Meta, Kind, S),
   { TCall, QC, SC } = elixir_quote:erl_escape(Call, true, S),
   { TExpr, QE, SE } = elixir_quote:erl_escape(Expr, true, SC),
-  CheckClauses = (lists:keyfind(quoted, 1, Meta) /= { quoted, true }) andalso
+  CheckClauses = (not lists:keymember(context, 1, Meta)) andalso
                    (not QC#elixir_quote.unquoted) andalso (not QE#elixir_quote.unquoted),
   { elixir_def:wrap_definition(Kind, Meta, TCall, TExpr, CheckClauses, SE), SE };
 
-translate({Kind, Meta, [Name, Args, Guards, Expr]}, S) when ?FUNS(Kind) ->
+translate({Kind, Meta, [Name, Args, Guards, Expr]}, S) when ?defs(Kind) ->
   assert_module_scope(Meta, Kind, S),
   assert_no_function_scope(Meta, Kind, S),
   { TName, SN }   = translate_each(Name, S),
@@ -287,9 +281,9 @@ translate_in(Meta, Left, Right, S) ->
       { Cache, Expr };
     { tuple, _, [{ atom, _, 'Elixir.Range' }, Start, End] } ->
       Expr = case { Start, End } of
-        { { K1, _, StartInt }, { K2, _, EndInt } } when ?IN_TYPES(K1), ?IN_TYPES(K2), StartInt =< EndInt ->
+        { { K1, _, StartInt }, { K2, _, EndInt } } when ?opt_in_types(K1), ?opt_in_types(K2), StartInt =< EndInt ->
           increasing_compare(Line, Var, Start, End);
-        { { K1, _, _ }, { K2, _, _ } } when ?IN_TYPES(K1), ?IN_TYPES(K2) ->
+        { { K1, _, _ }, { K2, _, _ } } when ?opt_in_types(K1), ?opt_in_types(K2) ->
           decreasing_compare(Line, Var, Start, End);
         _ ->
           { op, Line, 'orelse',

lib/elixir/src/elixir_quote.erl

@@ -81,13 +81,17 @@ do_quote({ quote, _, Args } = Tuple, #elixir_quote{unquote=true} = Q, S) when le
 do_quote({ unquote, _Meta, [Expr] }, #elixir_quote{unquote=true} = Q, _) ->
   { Expr, Q#elixir_quote{unquoted=true} };
 
-do_quote({ function, Meta, [{ '/', _, [{F, _, C}, A]}] = Args },
-    #elixir_quote{imports_hygiene=true} = Q, S) when is_atom(F), is_integer(A), is_atom(C) ->
-  do_quote_fa(function, Meta, Args, F, A, Q, S);
+%% Context mark
 
-do_quote({ { '.', _, [_, function] } = Target, Meta, [{ '/', _, [{F, _, C}, A]}] = Args },
-    #elixir_quote{imports_hygiene=true} = Q, S) when is_atom(F), is_integer(A), is_atom(C) ->
-  do_quote_fa(Target, Meta, Args, F, A, Q, S);
+do_quote({ Def, Meta, Args }, #elixir_quote{mark=true} = Q, S) when ?defs(Def); Def == defmodule; Def == alias; Def == import ->
+  NewMeta = lists:keystore(context, 1, Meta, { context, Q#elixir_quote.context }),
+  do_quote_tuple({ Def, NewMeta, Args }, Q, S);
+
+do_quote({ { '.', _, [_, Def] } = Target, Meta, Args }, #elixir_quote{mark=true} = Q, S) when ?defs(Def); Def == defmodule; Def == alias; Def == import ->
+  NewMeta = lists:keystore(context, 1, Meta, { context, Q#elixir_quote.context }),
+  do_quote_tuple({ Target, NewMeta, Args }, Q, S);
+
+%% Aliases
 
 do_quote({ 'alias!', _Meta, [Expr] }, #elixir_quote{aliases_hygiene=true} = Q, S) ->
   { TExpr, TQ } = do_quote(Expr, Q#elixir_quote{aliases_hygiene=false}, S),
@@ -98,21 +102,31 @@ do_quote({ '__aliases__', Meta, [H|T] } = Alias, #elixir_quote{aliases_hygiene=t
     Atom when is_atom(Atom) -> Atom;
     Aliases when is_list(Aliases) -> false
   end,
-  NewMeta = lists:keystore(alias, 1, Meta, { alias, Annotation }),
-  do_quote_tuple({ '__aliases__', NewMeta, [H|T] }, Q, S);
+  AliasMeta = lists:keystore(alias, 1, Meta, { alias, Annotation }),
+  do_quote_tuple({ '__aliases__', AliasMeta, [H|T] }, Q, S);
+
+%% Vars
+
+do_quote({ Left, Meta, nil }, #elixir_quote{vars_hygiene=true} = Q, S) when is_atom(Left) ->
+  do_quote_tuple({ Left, Meta, Q#elixir_quote.context }, Q, S);
+
+%% Unquote
 
 do_quote({ { { '.', Meta, [Left, unquote] }, _, [Expr] }, _, Args }, #elixir_quote{unquote=true} = Q, S) ->
   do_quote_call(Left, Meta, Expr, Args, Q, S);
 
 do_quote({ { '.', Meta, [Left, unquote] }, _, [Expr] }, #elixir_quote{unquote=true} = Q, S) ->
   do_quote_call(Left, Meta, Expr, nil, Q, S);
 
-do_quote({ Left, Meta, nil }, #elixir_quote{vars_hygiene=true} = Q, S) when is_atom(Left) ->
-  do_quote_tuple({ Left, Meta, Q#elixir_quote.context }, Q, S);
+%% Imports
+
+do_quote({ function, Meta, [{ '/', _, [{F, _, C}, A]}] = Args },
+    #elixir_quote{imports_hygiene=true} = Q, S) when is_atom(F), is_integer(A), is_atom(C) ->
+  do_quote_fa(function, Meta, Args, F, A, Q, S);
 
-do_quote({ import, Meta, Args }, #elixir_quote{imports_hygiene=true} = Q, S) ->
-  ImportMeta = lists:keystore(import, 1, Meta, { context, Q#elixir_quote.context }),
-  do_quote_tuple({ import, ImportMeta, Args }, Q, S);
+do_quote({ { '.', _, [_, function] } = Target, Meta, [{ '/', _, [{F, _, C}, A]}] = Args },
+    #elixir_quote{imports_hygiene=true} = Q, S) when is_atom(F), is_integer(A), is_atom(C) ->
+  do_quote_fa(Target, Meta, Args, F, A, Q, S);
 
 do_quote({ Name, Meta, ArgsOrAtom } = Tuple, #elixir_quote{imports_hygiene=true} = Q, S) when is_atom(Name) ->
   Arity = case is_atom(ArgsOrAtom) of
@@ -133,6 +147,8 @@ do_quote({ Name, Meta, ArgsOrAtom } = Tuple, #elixir_quote{imports_hygiene=true}
 do_quote({ _, _, _ } = Tuple, Q, S) ->
   do_quote_tuple(Tuple, Q, S);
 
+%% Literals
+
 do_quote({ Left, Right }, #elixir_quote{unquote=true} = Q, S) when
     is_tuple(Left)  andalso (element(1, Left) == unquote_splicing);
     is_tuple(Right) andalso (element(1, Right) == unquote_splicing) ->
@@ -174,18 +190,11 @@ do_quote_tuple({ Left, Meta, Right }, Q, S) ->
   { TRight, RQ } = do_quote(Right, LQ, S),
   { { '{}', [], [TLeft, meta(Meta, Q), TRight] }, RQ }.
 
-meta(Meta, Q) -> mark_meta(line_meta(Meta, Q), Q).
-
-mark_meta(Meta, #elixir_quote{mark=true}) ->
-  lists:keystore(quoted, 1, Meta, { quoted, true });
-mark_meta(Meta, #elixir_quote{mark=false}) ->
-  Meta.
-
-line_meta(Meta, #elixir_quote{line=keep}) ->
+meta(Meta, #elixir_quote{line=keep}) ->
   Meta;
-line_meta(Meta, #elixir_quote{line=nil}) ->
+meta(Meta, #elixir_quote{line=nil}) ->
   lists:keydelete(line, 1, Meta);
-line_meta(Meta, #elixir_quote{line=Line}) ->
+meta(Meta, #elixir_quote{line=Line}) ->
   lists:keystore(line, 1, Meta, { line, Line }).
 
 %% Quote splicing

lib/elixir/src/elixir_translator.erl

@@ -101,32 +101,15 @@ translate_each({ alias, Meta, [Ref, KV] }, S) ->
 
   case TRef of
     { atom, _, Old } ->
-      { New, SF } = expand_alias_as(Meta, Old, KV, SR),
+      { New, _ } = expand_alias_as(Meta, Old, KV, SR),
 
-      %% Avoid creating aliases if first == last
-      %% unecessarily polluting the aliases dict
-      case New == Old of
-        true  -> { { atom, ?line(Meta), nil }, SF };
-        false ->
-          case string:tokens(atom_to_list(New), "-") of
-            [_,_] -> [];
-            _ -> syntax_error(Meta, S#elixir_scope.file,
+      case (New == Old) orelse (length(string:tokens(atom_to_list(New), "-")) == 2) of
+        true  -> ok;
+        false -> syntax_error(Meta, S#elixir_scope.file,
                    "invalid args for alias, cannot create nested alias ~s", [elixir_errors:inspect(New)])
-          end,
-
-          SA = SF#elixir_scope{
-            aliases=orddict:store(New, Old, S#elixir_scope.aliases)
-          },
-
-          SM = case lists:keyfind(quoted, 1, Meta) of
-            { quoted, true } -> SA#elixir_scope{
-                macro_aliases=orddict:store(New, Old, S#elixir_scope.macro_aliases)
-              };
-            _ -> SA
-          end,
+      end,
 
-          { { atom, ?line(Meta), nil }, SM }
-      end;
+      { { atom, ?line(Meta), nil }, elixir_aliases:store(Meta, New, Old, SR) };
     _ ->
       syntax_error(Meta, S#elixir_scope.file, "invalid args for alias, expected an atom or alias as argument")
   end;

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

@@ -21,29 +21,29 @@ defmodule Kernel.QuoteTest do
 
   test :keep_line do
     ## DO NOT MOVE THIS LINE
-    assert quote(line: :keep, do: bar(1,2,3)) == { :bar, [line: 24, quoted: true], [1,2,3] }
+    assert quote(line: :keep, do: bar(1,2,3)) == { :bar, [line: 24], [1,2,3] }
   end
 
   test :fixed_line do
-    assert quote(line: 3, do: bar(1,2,3)) == { :bar, [line: 3, quoted: true], [1,2,3] }
+    assert quote(line: 3, do: bar(1,2,3)) == { :bar, [line: 3], [1,2,3] }
   end
 
   test :keep_location do
     ## DO NOT MOVE THIS LINE
     assert quote(location: :keep, do: bar(1,2,3)) == {
       :__scope__,
-      [line: 33, quoted: true],
+      [line: 33],
       [
         [file: __FILE__],
-        [do: { :bar, [line: 33, quoted: true], [1,2,3] }]
+        [do: { :bar, [line: 33], [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: 45, quoted: true], [1,2,3] }
+    assert quote(line: line, do: bar(1,2,3)) == { :bar, [line: 45], [1,2,3] }
   end
 
   test :unquote_call do
@@ -202,10 +202,10 @@ defmodule Kernel.QuoteTest.AliasHygieneTest do
   alias Dict, as: SuperDict
 
   test :annotate_aliases do
-    assert quote(do: Foo.Bar) == { :__aliases__, [alias: false, quoted: true], [:Foo, :Bar] }
-    assert quote(do: Dict.Bar) == { :__aliases__, [alias: false, quoted: true], [:Dict, :Bar] }
-    assert quote(do: SuperDict.Bar) == { :__aliases__, [alias: Dict.Bar, quoted: true], [:SuperDict, :Bar] }
-    assert quote(do: alias!(SuperDict.Bar)) == { :__aliases__, [quoted: true], [:SuperDict, :Bar] }
+    assert quote(do: Foo.Bar) == { :__aliases__, [alias: false], [:Foo, :Bar] }
+    assert quote(do: Dict.Bar) == { :__aliases__, [alias: false], [:Dict, :Bar] }
+    assert quote(do: SuperDict.Bar) == { :__aliases__, [alias: Dict.Bar], [:SuperDict, :Bar] }
+    assert quote(do: alias!(SuperDict.Bar)) == { :__aliases__, [], [:SuperDict, :Bar] }
   end
 
   test :expand_aliases do

lib/elixir/test/elixir/macro_test.exs

@@ -41,7 +41,7 @@ defmodule MacroTest do
     assert Macro.escape_quoted(contents) == 1
 
     contents = quote unquote: false, do: unquote(x)
-    assert Macro.escape_quoted(contents) == { :x, [quoted: true], MacroTest }
+    assert Macro.escape_quoted(contents) == { :x, [], MacroTest }
   end
 
   defp eval_escaped(contents) do

lib/elixir/test/elixir/typespec_test.exs

@@ -377,8 +377,8 @@ defmodule Typespec.TypeTest do
                     ],
                     []}
     assert Kernel.Typespec.type_to_ast(record_type) ==
-      { :::,[quoted: true], [
-        { :my_record,[quoted: true],[] },
+      { :::,[], [
+        { :my_record,[],[] },
         { :{},[], [:my_record,
           { :::, [line: 0], [
             {:field1,0,nil},
@@ -395,7 +395,7 @@ defmodule Typespec.TypeTest do
   test "type_to_ast for paren_type" do
     type = {:my_type, {:paren_type, 0, [{:type, 0, :integer, []}]}, []}
     assert Kernel.Typespec.type_to_ast(type) ==
-      { :::, [quoted: true], [{:my_type,[quoted: true],[]}, {:integer,[line: 0],[]}] }
+      { :::, [], [{:my_type,[],[]}, {:integer,[line: 0],[]}] }
   end
 
   test "spec_to_ast" do