The AST now allows metadata to be attached to each node

This means the second item in the AST is no longer an integer
(representing the line), but a keywords list. Code that relies
on the line information from AST or that manually generate AST
nodes need to be properly updated.

Author: José Valim

CHANGELOG.md

@@ -25,6 +25,9 @@
   * [String] `String.rstrip` and `String.lstrip` now verify if argument is a binary
   * [Typespec] Support `...` inside typespec's lists
 
+* backwards incompatible changes
+  * [Kernel] The AST now allows metadata to be attached to each node. This means the second item in the AST is no longer an integer (representing the line), but a keywords list. Code that relies on the line information from AST or that manually generate AST nodes need to be properly updated
+
 * deprecations
   * [Dict] Deprecate `Binary.Dict` and `OrdDict` in favor of `HashDict` and `List.Dict`
   * [File] Deprecate path related functions in favor of the module `Path`

lib/eex/lib/eex.ex

@@ -189,7 +189,7 @@ defmodule EEx do
 
   @doc false
   def function_from_quoted(module, kind, name, args, source, info) do
-    args  = Enum.map args, fn arg -> { arg, 0, nil } end
+    args  = Enum.map args, fn arg -> { arg, [], nil } end
     quote = quote do
       unquote(kind).(unquote(name).(unquote_splicing(args)), do: unquote(source))
     end

lib/eex/lib/eex/compiler.ex

@@ -90,7 +90,7 @@ defmodule EEx.Compiler do
 
   defp maybe_block([]),    do: nil
   defp maybe_block([h]),   do: h
-  defp maybe_block(other), do: { :__block__, 0, other }
+  defp maybe_block(other), do: { :__block__, [], other }
 
   # Changes placeholder to real expression
 

lib/elixir/include/elixir.hrl

@@ -1,11 +1,12 @@
--define(ELIXIR_WRAP_CALL(Line, Module, Function, Args),
+-define(wrap_call(Line, Module, Function, Args),
   { call, Line,
     { remote, Line, { atom, Line, Module }, { atom, Line, Function } },
     Args
   }).
 
--define(ELIXIR_ATOM_CONCAT(Atoms), list_to_atom(lists:concat(Atoms))).
--define(ELIXIR_MACRO(Macro), list_to_atom(lists:concat(['MACRO-',Macro]))).
+-define(atom_concat(Atoms), list_to_atom(lists:concat(Atoms))).
+-define(elixir_macro(Macro), list_to_atom(lists:concat(['MACRO-',Macro]))).
+-define(line(Opts), elixir_tree_helpers:get_line(Opts)).
 
 -record(elixir_scope, {
   context=nil,                                   %% can be assign, guards or nil
@@ -37,7 +38,7 @@
   unquote=true
 }).
 
-%% used in tokinization and interpolation
+%% Used in tokenization and interpolation
 
 -define(is_digit(S), S >= $0 andalso S =< $9).
 -define(is_hex(S), ?is_digit(S) orelse (S >= $A andalso S =< $F) orelse (S >= $a andalso S =< $f)).

lib/elixir/lib/code.ex

@@ -182,7 +182,7 @@ defmodule Code do
 
   defp unpack_ast(_line, []),                              do: nil
   defp unpack_ast(_line, [forms]) when not is_list(forms), do: forms
-  defp unpack_ast(line, forms),                            do: { :__block__, line, forms }
+  defp unpack_ast(line, forms),                            do: { :__block__, [line: line], forms }
 
   @doc """
   Loads the given `file`. Accepts `relative_to` as an argument

lib/elixir/lib/kernel.ex

@@ -2584,7 +2584,7 @@ defmodule Kernel do
 
   """
   defmacro left <> right do
-    concats = extract_concatenations({ :<>, 0, [left, right] })
+    concats = extract_concatenations({ :<>, [], [left, right] })
     quote do: << unquote_splicing(concats) >>
   end
 
@@ -2601,7 +2601,7 @@ defmodule Kernel do
 
   """
   defmacro first .. last do
-    { :{}, 0, [Elixir.Range, first, last] }
+    { :{}, [], [Elixir.Range, first, last] }
   end
 
   @doc """
@@ -2759,7 +2759,7 @@ defmodule Kernel do
   end
 
   defp pipeline_op(left, atom) when is_atom(atom) do
-    { { :., 0, [left, atom] }, 0, [] }
+    { { :., [], [left, atom] }, [], [] }
   end
 
   defp pipeline_op(_, other) do
@@ -3180,7 +3180,7 @@ defmodule Kernel do
   end
 
   defp wrap_concatenation(other) do
-    { :::, 0, [other, { :binary, 0, nil }] }
+    { :::, [], [other, { :binary, [], nil }] }
   end
 
   # Builds cond clauses by nesting them recursively.

lib/elixir/lib/kernel/special_forms.ex

@@ -326,7 +326,7 @@ defmodule Kernel.SpecialForms do
   ## Examples
 
       quote do: sum(1, 2, 3)
-      #=> { :sum, 0, [1, 2, 3] }
+      #=> { :sum, [], [1, 2, 3] }
 
   ## Explanation
 
@@ -486,8 +486,8 @@ defmodule Kernel.SpecialForms do
 
   One of Elixir goals is to provide proper stacktrace whenever there is an
   exception. In order to work properly with macros, the default behavior
-  in quote is to set the line to 0. When a macro is invoked and the quoted
-  expressions is expanded, 0 is replaced by the line of the call site.
+  in quote is to not set a line. When a macro is invoked and the quoted
+  expressions is expanded, the call site line is inserted.
 
   This is a good behavior for the majority of the cases, except if the macro
   is defining new functions. Consider this example:
@@ -549,13 +549,13 @@ defmodule Kernel.SpecialForms do
 
   Which would then return:
 
-      { :sum, 0, [1, { :value, 0, quoted }, 3] }
+      { :sum, [], [1, { :value, [], quoted }, 3] }
 
   Which is not the expected result. For this, we use unquote:
 
       value = 13
       quote do: sum(1, unquote(value), 3)
-      #=> { :sum, 0, [1, 13, 3] }
+      #=> { :sum, [], [1, 13, 3] }
 
   """
   defmacro unquote(expr)
@@ -568,7 +568,7 @@ defmodule Kernel.SpecialForms do
 
       values = [2,3,4]
       quote do: sum(1, unquote_splicing(values), 5)
-      #=> { :sum, 0, [1, 2, 3, 4, 5] }
+      #=> { :sum, [], [1, 2, 3, 4, 5] }
 
   """
   defmacro unquote_splicing(expr)
@@ -634,7 +634,7 @@ defmodule Kernel.SpecialForms do
   and should not be invoked directly:
 
       quote do: (1; 2; 3)
-      #=> { :__block__, 0, [1,2,3] }
+      #=> { :__block__, [], [1,2,3] }
 
   """
   defmacro __block__(args)
@@ -657,13 +657,13 @@ defmodule Kernel.SpecialForms do
   It is usually compiled to an atom:
 
       quote do: Foo.Bar
-      { :__aliases__, 0, [: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
-      {{:.,0,[{:__aliases__,0,[:Foo]},:bar]},0,[]}
+      {{:.,[],[{:__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
@@ -680,7 +680,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__,0,[{:some_var,0,:quoted},:Bar]}
+        {:__aliases__,[],[{:some_var,[],:quoted},:Bar]}
 
      Since `some_var` is not available at compilation time, the compiler
      expands such expression to: