parser 1.1.0 → 1.2.0

data/lib/parser/builders/default.rb

@@ -9,85 +9,128 @@ module Parser
 
     # Singletons
 
-    def nil(token);   t(token, :nil);   end
-    def true(token);  t(token, :true);  end
-    def false(token); t(token, :false); end
+    def nil(nil_t)
+      n0(:nil,
+        token_map(nil_t))
+    end
+
+    def true(true_t)
+      n0(:true,
+        token_map(true_t))
+    end
+
+    def false(false_t)
+      n0(:false,
+        token_map(false_t))
+    end
 
     # Numerics
 
-    def integer(token, negate=false)
-      val = value(token)
+    def integer(integer_t, negate=false)
+      val = value(integer_t)
       val = -val if negate
 
-      t(token, :int, val)
+      n(:int, [ val ],
+        numeric_map(integer_t, negate))
     end
 
-    def __LINE__(token)
-      t(token, :__LINE__)
+    def __LINE__(__LINE__t)
+      n0(:__LINE__,
+        token_map(__LINE__t))
     end
 
-    def float(token, negate=false)
-      val = value(token)
+    def float(float_t, negate=false)
+      val = value(float_t)
       val = -val if negate
 
-      t(token, :float, val)
+      n(:float, [ val ],
+        numeric_map(float_t, negate))
     end
 
     # Strings
 
-    def string(token)
-      t(token, :str, value(token))
+    def string(string_t)
+      n(:str, [ value(string_t) ],
+        string_part_map(string_t))
     end
 
     def string_compose(begin_t, parts, end_t)
       if collapse_string_parts?(parts)
-        parts.first
+        if begin_t.nil? && end_t.nil?
+          parts.first
+        else
+          n(:str, parts.first.children,
+            collection_map(begin_t, parts, end_t))
+        end
       else
-        s(:dstr, *parts)
+        n(:dstr, [ *parts ],
+          collection_map(begin_t, parts, end_t))
       end
     end
 
-    def __FILE__(token)
-      t(token, :__FILE__)
+    def __FILE__(__FILE__t)
+      n0(:__FILE__,
+        token_map(__FILE__t))
     end
 
     # Symbols
 
-    def symbol(token)
-      t(token, :sym, value(token).to_sym)
+    def symbol(symbol_t)
+      n(:sym, [ value(symbol_t).to_sym ],
+        unquoted_symbol_map(symbol_t))
     end
 
     def symbol_compose(begin_t, parts, end_t)
-      s(:dsym, *parts)
+      if collapse_string_parts?(parts)
+        str = parts.first
+
+        n(:sym, [ str.children.first.to_sym ],
+          collection_map(begin_t, str.src.expression, end_t))
+      elsif @parser.version == 18 && parts.empty?
+        diagnostic(:error, ERRORS[:empty_symbol], loc(begin_t).join(loc(end_t)))
+      else
+        n(:dsym, [ *parts ],
+          collection_map(begin_t, parts, end_t))
+      end
     end
 
     # Executable strings
 
     def xstring_compose(begin_t, parts, end_t)
-      s(:xstr, *parts)
+      n(:xstr, [ *parts ],
+        collection_map(begin_t, parts, end_t))
     end
 
     # Regular expressions
 
-    def regexp_options(token)
-      t(token, :regopt, *value(token).each_char.sort.uniq.map(&:to_sym))
+    def regexp_options(regopt_t)
+      options = value(regopt_t).
+        each_char.sort.uniq.
+        map(&:to_sym)
+
+      n(:regopt, options,
+        token_map(regopt_t))
     end
 
     def regexp_compose(begin_t, parts, end_t, options)
-      s(:regexp, *(parts << options))
+      n(:regexp, (parts << options),
+        regexp_map(begin_t, end_t, options))
     end
 
     # Arrays
 
     def array(begin_t, elements, end_t)
-      s(:array, *elements)
+      n(:array, elements,
+        collection_map(begin_t, elements, end_t))
     end
 
     def splat(star_t, arg=nil)
       if arg.nil?
-        s(:splat)
+        n0(:splat,
+          unary_op_map(star_t))
       else
-        s(:splat, arg)
+        n(:splat, [ arg ],
+          unary_op_map(star_t, arg))
       end
     end
 
@@ -95,12 +138,14 @@ module Parser
       if collapse_string_parts?(parts)
         parts.first
       else
-        s(:dstr, *parts)
+        n(:dstr, [ *parts ],
+          collection_map(nil, parts, nil))
       end
     end
 
     def words_compose(begin_t, parts, end_t)
-      s(:array, *parts)
+      n(:array, [ *parts ],
+        collection_map(begin_t, parts, end_t))
     end
 
     def symbols_compose(begin_t, parts, end_t)
@@ -116,82 +161,104 @@ module Parser
         end
       end
 
-      s(:array, *parts)
+      n(:array, [ *parts ],
+        collection_map(begin_t, parts, end_t))
     end
 
     # Hashes
 
     def pair(key, assoc_t, value)
-      s(:pair, key, value)
+      n(:pair, [ key, value ],
+        binary_op_map(key, assoc_t, value))
     end
 
     def pair_list_18(list)
       if list.size % 2 != 0
-        # TODO better location info here
         message = ERRORS[:odd_hash]
         diagnostic :error, message, list.last.src.expression
       else
         list.
           each_slice(2).map do |key, value|
-            s(:pair, key, value)
+            n(:pair, [ key, value ],
+              binary_op_map(key, nil, value))
           end
       end
     end
 
     def associate(begin_t, pairs, end_t)
-      s(:hash, *pairs)
+      n(:hash, [ *pairs ],
+        collection_map(begin_t, pairs, end_t))
     end
 
     def kwsplat(dstar_t, arg)
-      s(:kwsplat, arg)
+      n(:kwsplat, [ arg ],
+        unary_op_map(dstar_t, arg))
     end
 
     # Ranges
 
-    def range_inclusive(lhs, token, rhs)
-      s(:irange, lhs, rhs)
+    def range_inclusive(lhs, dot2_t, rhs)
+      n(:irange, [ lhs, rhs ],
+        binary_op_map(lhs, dot2_t, rhs))
     end
 
-    def range_exclusive(lhs, token, rhs)
-      s(:erange, lhs, rhs)
+    def range_exclusive(lhs, dot3_t, rhs)
+      n(:erange, [ lhs, rhs ],
+        binary_op_map(lhs, dot3_t, rhs))
     end
 
     #
-    # Expression grouping
+    # Access
     #
 
-    def parenthesize(begin_t, expr, end_t)
-      if expr.nil?
-        s(:nil)
-      else
-        expr
-      end
+    def self(token)
+      n0(:self,
+        token_map(token))
     end
 
-    #
-    # Access
-    #
+    def ident(token)
+      n(:ident, [ value(token).to_sym ],
+        variable_map(token))
+    end
+
+    def ivar(token)
+      n(:ivar, [ value(token).to_sym ],
+        variable_map(token))
+    end
 
-    def self(token);  t(token, :self); end
+    def gvar(token)
+      n(:gvar, [ value(token).to_sym ],
+        variable_map(token))
+    end
+
+    def cvar(token)
+      n(:cvar, [ value(token).to_sym ],
+        variable_map(token))
+    end
 
-    def ident(token); t(token, :ident, value(token).to_sym); end
-    def ivar(token);  t(token, :ivar,  value(token).to_sym); end
-    def gvar(token);  t(token, :gvar,  value(token).to_sym); end
-    def cvar(token);  t(token, :cvar,  value(token).to_sym); end
+    def back_ref(token)
+      n(:back_ref, [ value(token).to_sym ],
+        token_map(token))
+    end
 
-    def back_ref(token); t(token, :back_ref, value(token).to_sym); end
-    def nth_ref(token);  t(token, :nth_ref,  value(token));        end
+    def nth_ref(token)
+      n(:nth_ref, [ value(token) ],
+        token_map(token))
+    end
 
     def accessible(node)
       case node.type
       when :__FILE__
-        node.updated(:str, [ node.src.expression.source_buffer.name ])
+        n(:str, [ node.src.expression.source_buffer.name ],
+          node.src)
 
       when :__LINE__
-        node.updated(:int, [ node.src.expression.line ])
+        n(:int, [ node.src.expression.line ],
+          node.src)
 
       when :__ENCODING__
-        s(:const, s(:const, nil, :Encoding), :UTF_8)
+        n(:const, [ n(:const, [ nil, :Encoding], nil), :UTF_8 ],
+          node.src)
 
       when :ident
         name, = *node
@@ -200,7 +267,8 @@ module Parser
           node.updated(:lvar)
         else
           name, = *node
-          node.updated(:send, [ nil, name ])
+          n(:send, [ nil, name ],
+            var_send_map(node))
         end
 
       else
@@ -208,20 +276,26 @@ module Parser
       end
     end
 
-    def const(token)
-      t(token, :const, nil, value(token).to_sym)
+    def const(name_t)
+      n(:const, [ nil, value(name_t).to_sym ],
+        constant_map(nil, nil, name_t))
     end
 
-    def const_global(t_colon3, token)
-      s(:const, s(:cbase), value(token).to_sym)
+    def const_global(t_colon3, name_t)
+      cbase = n0(:cbase, token_map(t_colon3))
+
+      n(:const, [ cbase, value(name_t).to_sym ],
+        constant_map(cbase, t_colon3, name_t))
     end
 
-    def const_fetch(scope, t_colon2, token)
-      s(:const, scope, value(token).to_sym)
+    def const_fetch(scope, t_colon2, name_t)
+      n(:const, [ scope, value(name_t).to_sym ],
+        constant_map(scope, t_colon2, name_t))
     end
 
-    def __ENCODING__(token)
-      t(token, :__ENCODING__)
+    def __ENCODING__(__ENCODING__t)
+      n0(:__ENCODING__,
+        token_map(__ENCODING__t))
     end
 
     #
@@ -271,35 +345,31 @@ module Parser
       end
     end
 
-    def assign(lhs, token, rhs)
-      case lhs.type
-      when :lvasgn, :masgn, :gvasgn, :ivasgn, :cvdecl,
-           :cvasgn, :cdecl,
-           :send
-        lhs << rhs
-
-      when :const
-        (lhs << rhs).updated(:cdecl)
-
-      else
-        raise NotImplementedError, "build assign #{lhs.inspect}"
-      end
+    def assign(lhs, eql_t, rhs)
+      (lhs << rhs).updated(nil, nil,
+        :source_map => lhs.src.
+          with_operator(loc(eql_t)).
+          with_expression(join_exprs(lhs, rhs)))
     end
 
-    def op_assign(lhs, operator_t, rhs)
+    def op_assign(lhs, op_t, rhs)
       case lhs.type
       when :gvasgn, :ivasgn, :lvasgn, :cvasgn, :cvdecl,
            :cdecl,
            :send
-        operator = value(operator_t)[0..-1].to_sym
+
+        operator   = value(op_t)[0..-1].to_sym
+        source_map = lhs.src.
+                        with_operator(loc(op_t)).
+                        with_expression(join_exprs(lhs, rhs))
 
         case operator
         when :'&&'
-          s(:and_asgn, lhs, rhs)
+          n(:and_asgn, [ lhs, rhs ], source_map)
         when :'||'
-          s(:or_asgn, lhs, rhs)
+          n(:or_asgn, [ lhs, rhs ], source_map)
         else
-          s(:op_asgn, lhs, operator, rhs)
+          n(:op_asgn, [ lhs, operator, rhs ], source_map)
         end
 
       when :back_ref, :nth_ref
@@ -312,11 +382,13 @@ module Parser
     end
 
     def multi_lhs(begin_t, items, end_t)
-      s(:mlhs, *items)
+      n(:mlhs, [ *items ],
+        collection_map(begin_t, items, end_t))
     end
 
     def multi_assign(lhs, eql_t, rhs)
-      s(:masgn, lhs, rhs)
+      n(:masgn, [ lhs, rhs ],
+        binary_op_map(lhs, eql_t, rhs))
     end
 
     #
@@ -326,68 +398,56 @@ module Parser
     def def_class(class_t, name,
                   lt_t, superclass,
                   body, end_t)
-      s(:class, name, superclass, body)
+      n(:class, [ name, superclass, body ],
+        definition_map(class_t, lt_t, nil, end_t))
     end
 
     def def_sclass(class_t, lshft_t, expr,
                    body, end_t)
-      s(:sclass, expr, body)
+      n(:sclass, [ expr, body ],
+        definition_map(class_t, lshft_t, nil, end_t))
     end
 
     def def_module(module_t, name,
                    body, end_t)
-      s(:module, name, body)
+      n(:module, [ name, body ],
+        definition_map(module_t, nil, nil, end_t))
     end
 
     #
     # Method (un)definition
     #
 
-    def def_method(def_t, name, args,
+    def def_method(def_t, name_t, args,
                    body, end_t, comments)
-      s(:def, value(name).to_sym, args, body)
+      n(:def, [ value(name_t).to_sym, args, body ],
+        definition_map(def_t, nil, name_t, end_t))
     end
 
     def def_singleton(def_t, definee, dot_t,
-                      name, args,
+                      name_t, args,
                       body, end_t, comments)
       case definee.type
       when :int, :str, :dstr, :sym, :dsym,
            :regexp, :array, :hash
 
         message = ERRORS[:singleton_literal]
-        diagnostic :error, message, nil # TODO definee.src.expression
+        diagnostic :error, message, definee.src.expression
 
       else
-        s(:defs, definee, value(name).to_sym, args, body)
+        n(:defs, [ definee, value(name_t).to_sym, args, body ],
+          definition_map(def_t, dot_t, name_t, end_t))
       end
     end
 
-    def undef_method(token, names)
-      s(:undef, *names)
-    end
-
-    #
-    # Aliasing
-    #
-
-    def alias(token, to, from)
-      t(token, :alias, to, from)
+    def undef_method(undef_t, names)
+      n(:undef, [ *names ],
+        keyword_map(undef_t, nil, names, nil))
     end
 
-    def keyword_cmd(type, token, lparen_t=nil, args=[], rparen_t=nil)
-      case type
-      when :return,
-           :break, :next, :redo,
-           :retry,
-           :super, :zsuper, :yield,
-           :defined?
-
-        t(token, type, *args)
-
-      else
-        raise NotImplementedError, "build_keyword_cmd #{type} #{args.inspect}"
-      end
+    def alias(alias_t, to, from)
+      n(:alias, [ to, from ],
+        keyword_map(alias_t, nil, [to, from], nil))
     end
 
     #
@@ -395,47 +455,60 @@ module Parser
     #
 
     def args(begin_t, args, end_t)
-      s(:args, *check_duplicate_args(args))
+      n(:args, [ *check_duplicate_args(args) ],
+        collection_map(begin_t, args, end_t))
     end
 
     def arg(name_t)
-      t(name_t, :arg, value(name_t).to_sym)
+      n(:arg, [ value(name_t).to_sym ],
+        variable_map(name_t))
     end
 
     def optarg(name_t, eql_t, value)
-      s(:optarg, value(name_t).to_sym, value)
+      n(:optarg, [ value(name_t).to_sym, value ],
+        variable_map(name_t).
+          with_operator(loc(eql_t)).
+          with_expression(loc(name_t).join(value.src.expression)))
     end
 
     def restarg(star_t, name_t=nil)
       if name_t
-        s(:restarg, value(name_t).to_sym)
+        n(:restarg, [ value(name_t).to_sym ],
+          arg_prefix_map(star_t, name_t))
       else
-        t(star_t, :restarg)
+        n0(:restarg,
+          arg_prefix_map(star_t))
       end
     end
 
     def kwarg(name_t)
-      s(:kwarg, value(name_t).to_sym)
+      n(:kwarg, [ value(name_t).to_sym ],
+        kwarg_map(name_t))
     end
 
     def kwoptarg(name_t, value)
-      s(:kwoptarg, value(name_t).to_sym, value)
+      n(:kwoptarg, [ value(name_t).to_sym, value ],
+        kwarg_map(name_t, value))
     end
 
     def kwrestarg(dstar_t, name_t=nil)
       if name_t
-        s(:kwrestarg, value(name_t).to_sym)
+        n(:kwrestarg, [ value(name_t).to_sym ],
+          arg_prefix_map(dstar_t, name_t))
       else
-        t(dstar_t, :kwrestarg)
+        n0(:kwrestarg,
+          arg_prefix_map(dstar_t))
       end
     end
 
-    def shadowarg(token)
-      s(:shadowarg, value(token).to_sym)
+    def shadowarg(name_t)
+      n(:shadowarg, [ value(name_t).to_sym ],
+        variable_map(name_t))
     end
 
-    def blockarg(amper_t, token)
-      s(:blockarg, value(token).to_sym)
+    def blockarg(amper_t, name_t)
+      n(:blockarg, [ value(name_t).to_sym ],
+        arg_prefix_map(amper_t, name_t))
     end
 
     # Ruby 1.8 block arguments
@@ -444,17 +517,19 @@ module Parser
       if expr.type == :lvasgn
         expr.updated(:arg)
       else
-        s(:arg_expr, expr)
+        n(:arg_expr, [ expr ],
+          expr.src)
       end
     end
 
     def restarg_expr(star_t, expr=nil)
       if expr.nil?
-        t(star_t, :restarg)
+        n0(:restarg, token_map(star_t))
       elsif expr.type == :lvasgn
         expr.updated(:restarg)
       else
-        s(:restarg_expr, expr)
+        n(:restarg_expr, [ expr ],
+          expr.src)
       end
     end
 
@@ -462,7 +537,8 @@ module Parser
       if expr.type == :lvasgn
         expr.updated(:blockarg)
       else
-        s(:blockarg_expr, expr)
+        n(:blockarg_expr, [ expr ],
+          expr.src)
       end
     end
 
@@ -471,16 +547,19 @@ module Parser
     #
 
     def call_method(receiver, dot_t, selector_t,
-                    begin_t=nil, args=[], end_t=nil)
+                    lparen_t=nil, args=[], rparen_t=nil)
       if selector_t.nil?
-        s(:send, receiver, :call, *args)
+        n(:send, [ receiver, :call, *args ],
+          send_map(receiver, nil, lparen_t, args, rparen_t))
       else
-        s(:send, receiver, value(selector_t).to_sym, *args)
+        n(:send, [ receiver, value(selector_t).to_sym, *args ],
+          send_map(receiver, selector_t, lparen_t, args, rparen_t))
       end
     end
 
     def call_lambda(lambda_t)
-      s(:send, nil, :lambda)
+      n(:send, [ nil, :lambda ],
+        send_map(nil, lambda_t))
     end
 
     def block(method_call, begin_t, args, body, end_t)
@@ -488,68 +567,83 @@ module Parser
       last_arg = call_args.last
 
       if last_arg && last_arg.type == :block_pass
-        # TODO uncomment when source maps are ready
-        # diagnostic :error, :block_and_blockarg,
-        #            last_arg.src.expression
-
         diagnostic :error, ERRORS[:block_and_blockarg],
-                   last_arg.children.last.src.expression
+                   last_arg.src.expression
       end
 
-      s(:block, method_call, args, body)
+      n(:block, [ method_call, args, body ],
+        block_map(method_call.src.expression, begin_t, end_t))
     end
 
     def block_pass(amper_t, arg)
-      s(:block_pass, arg)
+      n(:block_pass, [ arg ],
+        unary_op_map(amper_t, arg))
     end
 
     def attr_asgn(receiver, dot_t, selector_t)
       method_name = (value(selector_t) + '=').to_sym
 
       # Incomplete method call.
-      s(:send, receiver, method_name)
+      n(:send, [ receiver, method_name ],
+        send_map(receiver, selector_t))
     end
 
     def index(receiver, lbrack_t, indexes, rbrack_t)
-      s(:send, receiver, :[], *indexes)
+      n(:send, [ receiver, :[], *indexes ],
+        send_index_map(receiver, lbrack_t, rbrack_t))
     end
 
     def index_asgn(receiver, lbrack_t, indexes, rbrack_t)
       # Incomplete method call.
-      s(:send, receiver, :[]=, *indexes)
+      n(:send, [ receiver, :[]=, *indexes ],
+        send_index_map(receiver, lbrack_t, rbrack_t))
     end
 
-    def binary_op(receiver, token, arg)
+    def binary_op(receiver, operator_t, arg)
+      source_map = send_binary_op_map(receiver, operator_t, arg)
+
       if @parser.version == 18
-        if value(token) == '!='
-          return s(:not, s(:send, receiver, :==, arg))
-        elsif value(token) == '!~'
-          return s(:not, s(:send, receiver, :=~, arg))
+        operator = value(operator_t)
+
+        if operator == '!='
+          method_call = n(:send, [ receiver, :==, arg ], source_map)
+        elsif operator == '!~'
+          method_call = n(:send, [ receiver, :=~, arg ], source_map)
+        end
+
+        if %w(!= !~).include?(operator)
+          return n(:not, [ method_call ],
+                   expr_map(source_map.expression))
         end
       end
 
-      s(:send, receiver, value(token).to_sym, arg)
+      n(:send, [ receiver, value(operator_t).to_sym, arg ],
+        source_map)
     end
 
-    def unary_op(token, receiver)
-      case value(token)
+    def unary_op(op_t, receiver)
+      case value(op_t)
       when '+', '-'
-        method = value(token) + '@'
+        method = value(op_t) + '@'
       else
-        method = value(token)
+        method = value(op_t)
       end
 
-      s(:send, receiver, method.to_sym)
+      n(:send, [ receiver, method.to_sym ],
+        send_unary_op_map(op_t, receiver))
     end
 
-    def not_op(token, receiver=nil)
+    def not_op(not_t, receiver=nil)
       if @parser.version == 18
-        s(:not, receiver)
+        n(:not, [ receiver ],
+          unary_op_map(not_t, receiver))
       else
         if receiver.nil?
-          s(:send, s(:nil), :'!')
+          n(:send, [ n0(:nil, nil), :'!' ],
+            send_unary_op_map(not_t, nil))
         else
-          s(:send, receiver, :'!')
+          n(:send, [ receiver, :'!' ],
+            send_unary_op_map(not_t, receiver))
         end
       end
     end
@@ -560,60 +654,87 @@ module Parser
 
     # Logical operations: and, or
 
-    def logical_op(type, lhs, token, rhs)
-      s(type, check_condition(lhs), check_condition(rhs))
+    def logical_op(type, lhs, op_t, rhs)
+      n(type, [ check_condition(lhs), check_condition(rhs) ],
+        binary_op_map(lhs, op_t, rhs))
     end
 
     # Conditionals
 
     def condition(cond_t, cond, then_t,
                   if_true, else_t, if_false, end_t)
-      s(:if, check_condition(cond), if_true, if_false)
+      n(:if, [ check_condition(cond), if_true, if_false ],
+        condition_map(cond_t, then_t, if_true, else_t, if_false, end_t))
     end
 
     def condition_mod(if_true, if_false, cond_t, cond)
-      s(:if, check_condition(cond), if_true, if_false)
+      n(:if, [ check_condition(cond), if_true, if_false ],
+        keyword_mod_map(if_true || if_false, cond_t, cond))
     end
 
     def ternary(cond, question_t, if_true, colon_t, if_false)
-      s(:if, check_condition(cond), if_true, if_false)
+      n(:if, [ check_condition(cond), if_true, if_false ],
+        ternary_map(cond, question_t, if_true, colon_t, if_false))
     end
 
     # Case matching
 
     def when(when_t, patterns, then_t, body)
-      s(:when, *(patterns << body))
+      children = patterns << body
+      n(:when, children,
+        keyword_map(when_t, then_t, children, nil))
     end
 
-    def case(case_t, expr, body, end_t)
-      s(:case, expr, *body)
+    def case(case_t, expr, when_bodies, else_t, else_body, end_t)
+      n(:case, [ expr, *(when_bodies << else_body)],
+        condition_map(case_t, nil, nil, else_t, else_body, end_t))
     end
 
     # Loops
 
-    def loop(loop_t, cond, do_t, body, end_t)
-      s(value(loop_t).to_sym, check_condition(cond), body)
+    def loop(type, keyword_t, cond, do_t, body, end_t)
+      n(type, [ check_condition(cond), body ],
+        keyword_map(keyword_t, do_t, nil, end_t))
     end
 
-    def loop_mod(body, loop_t, cond)
-      s(value(loop_t).to_sym, check_condition(cond), body)
+    def loop_mod(type, body, keyword_t, cond)
+      n(type, [ check_condition(cond), body ],
+        keyword_mod_map(body, keyword_t, cond))
     end
 
     def for(for_t, iterator, in_t, iteratee,
             do_t, body, end_t)
-      s(:for, iterator, iteratee, body)
+      n(:for, [ iterator, iteratee, body ],
+        for_map(for_t, in_t, do_t, end_t))
     end
 
-    # Exception handling
+    # Keywords
 
-    def begin(begin_t, body, end_t)
-      body
+    def keyword_cmd(type, keyword_t, lparen_t=nil, args=[], rparen_t=nil)
+      n(type, args,
+        keyword_map(keyword_t, lparen_t, args, rparen_t))
+    end
+
+    # BEGIN, END
+
+    def preexe(preexe_t, lbrace_t, compstmt, rbrace_t)
+      n(:preexe, [ compstmt ],
+        block_map(loc(preexe_t), lbrace_t, rbrace_t))
+    end
+
+    def postexe(postexe_t, lbrace_t, compstmt, rbrace_t)
+      n(:postexe, [ compstmt ],
+        block_map(loc(postexe_t), lbrace_t, rbrace_t))
     end
 
+    # Exception handling
+
     def rescue_body(rescue_t,
                     exc_list, assoc_t, exc_var,
                     then_t, compound_stmt)
-      s(:resbody, exc_list, exc_var, compound_stmt)
+      n(:resbody, [ exc_list, exc_var, compound_stmt ],
+        rescue_body_map(rescue_t, exc_list, assoc_t,
+                        exc_var, then_t, compound_stmt))
     end
 
     def begin_body(compound_stmt, rescue_bodies=[],
@@ -621,49 +742,75 @@ module Parser
                    ensure_t=nil,  ensure_=nil)
       if rescue_bodies.any?
         if else_t
-          compound_stmt = s(:rescue, compound_stmt,
-                            *(rescue_bodies << else_))
+          compound_stmt =
+            n(:rescue,
+              [ compound_stmt, *(rescue_bodies + [ else_ ]) ],
+              eh_keyword_map(compound_stmt, nil, rescue_bodies, else_t, else_))
         else
-          compound_stmt = s(:rescue, compound_stmt,
-                            *(rescue_bodies << nil))
+          compound_stmt =
+            n(:rescue,
+              [ compound_stmt, *(rescue_bodies + [ nil ]) ],
+              eh_keyword_map(compound_stmt, nil, rescue_bodies, nil, nil))
         end
       end
 
       if ensure_t
-        compound_stmt = s(:ensure, compound_stmt, ensure_)
+        compound_stmt =
+          n(:ensure,
+            [ compound_stmt, ensure_ ],
+            eh_keyword_map(compound_stmt, ensure_t, [ ensure_ ], nil, nil))
       end
 
       compound_stmt
     end
 
+    #
+    # Expression grouping
+    #
+
     def compstmt(statements)
       case
       when statements.one?
         statements.first
       when statements.none?
-        s(:nil)
+        n0(:nil, expr_map(nil))
       else
-        s(:begin, *statements)
+        n(:begin, statements,
+          collection_map(nil, statements, nil))
       end
     end
 
-    # BEGIN, END
-
-    def preexe(preexe_t, lbrace_t, compstmt, rbrace_t)
-      s(:preexe, compstmt)
+    def begin(begin_t, body, end_t)
+      if body.nil? || synthesized_nil?(body)
+        # A nil expression, or a synthesized (nil) from compstmt
+        # without any inner statements.
+        n0(:nil,
+          expr_map(loc(begin_t).join(loc(end_t))))
+      elsif body.type == :mlhs  ||
+           (body.type == :begin &&
+            body.src.begin.nil? && body.src.end.nil?)
+        # Synthesized (begin) from compstmt "a; b" or (mlhs)
+        # from multi_lhs "(a, b) = *foo".
+        n(body.type, body.children,
+          collection_map(begin_t, body.children, end_t))
+      else
+        n(:begin, [ body ],
+          collection_map(begin_t, [ body ], end_t))
+      end
     end
 
-    def postexe(postexe_t, lbrace_t, compstmt, rbrace_t)
-      s(:postexe, compstmt)
-    end
+    private
 
-    protected
+    #
+    # VERIFICATION
+    #
 
     def check_condition(cond)
       if cond.type == :masgn
-        # TODO source maps
         diagnostic :error, ERRORS[:masgn_as_condition],
-                   nil #cond.src.expression
+                   cond.src.expression
+      elsif cond.type == :begin
+        check_condition(cond.children.last)
       end
 
       cond
@@ -684,9 +831,8 @@ module Parser
           if that_arg.nil?
             map[this_name] = this_arg
           elsif arg_name_collides?(this_name, that_name)
-            # TODO reenable when source maps are done
             diagnostic :error, ERRORS[:duplicate_argument],
-                       nil # this_arg.src.expression, [ that_arg.src.expression ]
+                       this_arg.src.name, [ that_arg.src.name ]
           end
 
         when :mlhs
@@ -710,31 +856,283 @@ module Parser
       end
     end
 
-    def collapse_string_parts?(parts)
-      parts.one? &&
-          [:str, :dstr].include?(parts.first.type)
+    #
+    # SOURCE MAPS
+    #
+
+    def n(type, children, map)
+      AST::Node.new(type, children, :source_map => map)
     end
 
-    def t(token, type, *args)
-      s(type, *(args << { :source_map => Source::Map.new(location(token)) }))
+    def n0(type, map)
+      n(type, [], map)
     end
 
-    def value(token)
-      token[0]
+    def join_exprs(left_expr, right_expr)
+      left_expr.src.expression.
+        join(right_expr.src.expression)
+    end
+
+    def token_map(token)
+      Source::Map.new(loc(token))
+    end
+
+    def numeric_map(num_t, negate)
+      if negate
+        num_range = loc(num_t)
+        range = Source::Range.new(num_range.source_buffer,
+                                  num_range.begin_pos - 1,
+                                  num_range.end_pos)
+
+        Source::Map.new(range)
+      else
+        token_map(num_t)
+      end
+    end
+
+    def string_part_map(string_t)
+      Source::Map::Collection.new(loc(string_t).begin, loc(string_t).end,
+                                  loc(string_t))
     end
 
-    def location(token)
-      token[1]
+    def unquoted_symbol_map(symbol_t)
+      Source::Map::Collection.new(nil, nil,
+                                  loc(symbol_t))
     end
 
-    def s(type, *args)
-      if Hash === args.last
-        metadata = args.pop
+    def expr_map(loc)
+      Source::Map.new(loc)
+    end
+
+    def collection_map(begin_t, parts, end_t)
+      if begin_t.nil? || end_t.nil?
+        if parts.any?
+          expr_l = join_exprs(parts.first, parts.last)
+        end
+      else
+        expr_l = loc(begin_t).join(loc(end_t))
+      end
+
+      Source::Map::Collection.new(loc(begin_t), loc(end_t), expr_l)
+    end
+
+    def regexp_map(begin_t, end_t, options_e)
+      Source::Map::Collection.new(loc(begin_t), loc(end_t),
+                                  loc(begin_t).join(options_e.src.expression))
+    end
+
+    def constant_map(scope, colon2_t, name_t)
+      if scope.nil?
+        expr_l = loc(name_t)
+      else
+        expr_l = scope.src.expression.join(loc(name_t))
+      end
+
+      Source::Map::Constant.new(loc(colon2_t), loc(name_t), expr_l)
+    end
+
+    def variable_map(name_t)
+      Source::Map::Variable.new(loc(name_t))
+    end
+
+    def binary_op_map(left_e, op_t, right_e)
+      Source::Map::Operator.new(loc(op_t), join_exprs(left_e, right_e))
+    end
+
+    def unary_op_map(op_t, arg_e=nil)
+      if arg_e.nil?
+        expr_l = loc(op_t)
+      else
+        expr_l = loc(op_t).join(arg_e.src.expression)
+      end
+
+      Source::Map::Operator.new(loc(op_t), expr_l)
+    end
+
+    def arg_prefix_map(op_t, name_t=nil)
+      if name_t.nil?
+        expr_l = loc(op_t)
       else
-        metadata = {}
+        expr_l = loc(op_t).join(loc(name_t))
       end
 
-      AST::Node.new(type, args, metadata)
+      Source::Map::Variable.new(loc(name_t), expr_l)
+    end
+
+    def kwarg_map(name_t, value_e=nil)
+      label_range = loc(name_t)
+      name_range  = Source::Range.new(label_range.source_buffer,
+                                      label_range.begin_pos,
+                                      label_range.end_pos - 1)
+
+      if value_e
+        expr_l = loc(name_t).join(value_e.src.expression)
+      else
+        expr_l = loc(name_t)
+      end
+
+      Source::Map::Variable.new(name_range, expr_l)
+    end
+
+    def definition_map(keyword_t, operator_t, name_t, end_t)
+      Source::Map::Definition.new(loc(keyword_t),
+                                  loc(operator_t), loc(name_t),
+                                  loc(end_t))
+    end
+
+    def send_map(receiver_e, selector_t, begin_t=nil, args=[], end_t=nil)
+      if receiver_e
+        begin_l = receiver_e.src.expression
+      elsif selector_t
+        begin_l = loc(selector_t)
+      end
+
+      if end_t
+        end_l   = loc(end_t)
+      elsif args.any?
+        end_l   = args.last.src.expression
+      elsif selector_t
+        end_l   = loc(selector_t)
+      end
+
+      Source::Map::Send.new(loc(selector_t), loc(begin_t), loc(end_t),
+                            begin_l.join(end_l))
+    end
+
+    def var_send_map(variable_e)
+      Source::Map::Send.new(variable_e.src.expression, nil, nil,
+                            variable_e.src.expression)
+    end
+
+    def send_binary_op_map(lhs_e, selector_t, rhs_e)
+      Source::Map::Send.new(loc(selector_t), nil, nil,
+                            join_exprs(lhs_e, rhs_e))
+    end
+
+    def send_unary_op_map(selector_t, arg_e)
+      if arg_e.nil?
+        expr_l = loc(selector_t)
+      else
+        expr_l = loc(selector_t).join(arg_e.src.expression)
+      end
+
+      Source::Map::Send.new(loc(selector_t), nil, nil,
+                            expr_l)
+    end
+
+    def send_index_map(receiver_e, lbrack_t, rbrack_t)
+      Source::Map::Send.new(loc(lbrack_t).join(loc(rbrack_t)), nil, nil,
+                            receiver_e.src.expression.join(loc(rbrack_t)))
+    end
+
+    def block_map(receiver_l, begin_t, end_t)
+      Source::Map::Block.new(loc(begin_t), loc(end_t),
+                             receiver_l.join(loc(end_t)))
+    end
+
+    def keyword_map(keyword_t, begin_t, args, end_t)
+      args ||= []
+
+      if end_t
+        end_l = loc(end_t)
+      elsif args.any? && !synthesized_nil?(args.last)
+        end_l = args.last.src.expression
+      elsif args.any? && args.count > 1
+        end_l = args[-2].src.expression
+      else
+        end_l = loc(keyword_t)
+      end
+
+      Source::Map::Keyword.new(loc(keyword_t), loc(begin_t), loc(end_t),
+                               loc(keyword_t).join(end_l))
+    end
+
+    def keyword_mod_map(pre_e, keyword_t, post_e)
+      Source::Map::Keyword.new(loc(keyword_t), nil, nil,
+                               join_exprs(pre_e, post_e))
+    end
+
+    def condition_map(keyword_t, begin_t, body_e, else_t, else_e, end_t)
+      if end_t
+        end_l = loc(end_t)
+      elsif else_e && else_e.src.expression
+        end_l = else_e.src.expression
+      elsif else_t
+        end_l = loc(else_t)
+      elsif body_e.src.expression
+        end_l = body_e.src.expression
+      else
+        end_l = loc(begin_t)
+      end
+
+      Source::Map::Condition.new(loc(keyword_t),
+                                 loc(begin_t), loc(else_t), loc(end_t),
+                                 loc(keyword_t).join(end_l))
+    end
+
+    def ternary_map(begin_e, question_t, mid_e, colon_t, end_e)
+      Source::Map::Ternary.new(loc(question_t), loc(colon_t),
+                               join_exprs(begin_e, end_e))
+    end
+
+    def for_map(keyword_t, in_t, begin_t, end_t)
+      Source::Map::For.new(loc(keyword_t), loc(in_t),
+                           loc(begin_t), loc(end_t),
+                           loc(keyword_t).join(loc(end_t)))
+    end
+
+    def rescue_body_map(keyword_t, exc_list_e, assoc_t,
+                        exc_var_e, then_t,
+                        compstmt_e)
+      end_l = compstmt_e.src.expression ||
+              loc(then_t) ||
+              exc_var_e.src.expression  ||
+              exc_list_e.src.expression ||
+              loc(keyword_t)
+
+      Source::Map::RescueBody.new(loc(keyword_t), loc(assoc_t), loc(then_t),
+                                  loc(keyword_t).join(end_l))
+    end
+
+    def eh_keyword_map(compstmt_e, keyword_t, body_es,
+                       else_t, else_e)
+      if synthesized_nil?(compstmt_e)
+        begin_l = loc(keyword_t)
+      else
+        begin_l = compstmt_e.src.expression
+      end
+
+      if else_t
+        end_l = else_e.src.expression
+      elsif !synthesized_nil?(body_es.last)
+        end_l = body_es.last.src.expression
+      else
+        end_l = loc(keyword_t)
+      end
+
+      Source::Map::Condition.new(loc(keyword_t), nil, loc(else_t), nil,
+                                 begin_l.join(end_l))
+    end
+
+    #
+    # HELPERS
+    #
+
+    def collapse_string_parts?(parts)
+      parts.one? &&
+          [:str, :dstr].include?(parts.first.type)
+    end
+
+    def synthesized_nil?(node)
+      node.type == :nil && node.src.expression.nil?
+    end
+
+    def value(token)
+      token[0]
+    end
+
+    def loc(token)
+      token[1] if token
     end
 
     def diagnostic(type, message, location, highlights=[])