parser 0.9.alpha1 → 0.9.0

data/README.md

@@ -2,8 +2,9 @@
 
 [![Build Status](https://travis-ci.org/whitequark/parser.png?branch=master)](https://travis-ci.org/whitequark/parser)
 [![Code Climate](https://codeclimate.com/github/whitequark/parser.png)](https://codeclimate.com/github/whitequark/parser)
+[![Coverage Status](https://coveralls.io/repos/whitequark/parser/badge.png?branch=master)](https://coveralls.io/r/whitequark/parser)
 
-Parser is a Ruby parser written in pure Ruby.
+_Parser_ is a Ruby parser written in pure Ruby.
 
 ## Installation
 
@@ -11,11 +12,65 @@ Parser is a Ruby parser written in pure Ruby.
 
 ## Usage
 
-TODO: Write usage instructions here
+Parse a chunk of code:
+``` ruby
+require 'parser/ruby19'
+
+p Parser::Ruby19.parse("2 + 2")
+# (send
+#   (int 2) :+
+#   (int 2))
+```
+
+Parse a chunk of code and display all diagnostics:
+``` ruby
+parser = Parser::Ruby19.new
+parser.diagnostics.consumer = lambda do |diag|
+  puts diag.render
+end
+
+buffer = Parser::Source::Buffer.new('(string)')
+buffer.source = "foo *bar"
+
+p parser.parse(buffer)
+# (string):1:5: warning: `*' interpreted as argument prefix
+# foo *bar
+#     ^
+# (send nil :foo
+#   (splat
+#     (send nil :bar)))
+```
+
+## Features
+
+ * Precise source location reporting.
+ * [Documented](AST_FORMAT.md) AST format which is convenient to work with.
+ * A simple interface and a powerful, tweakable one.
+ * Parses 1.8, 1.9 and 2.0 syntax with backwards-compatible AST formats (WIP, only 1.8 & 1.9 yet).
+ * Parsing error recovery.
+ * Improved [clang-like][] diagnostic messages with location information.
+ * Written in pure Ruby, runs on MRI 1.8.7 or >=1.9.2, JRuby and Rubinius in 1.8 and 1.9 mode.
+ * Single runtime dependency: the [ast][] gem.
+ * RubyParser compatibility (WIP, no, not really yet).
+ * [Insane][insane-lexer] Ruby lexer rewritten from scratch in Ragel.
+ * 100% test coverage for Bison grammars (except error recovery).
+ * Readable, commented source code.
+
+  [clang-like]: http://clang.llvm.org/diagnostics.html
+  [ast]: http://rubygems.org/gems/ast
+  [insane-lexer]: http://whitequark.org/blog/2013/04/01/ruby-hacking-guide-ch-11-finite-state-lexer/
+
+## Contributors
+
+ * Peter Zotov ([whitequark][])
+ * Magnus Holm ([judofyr][])
+
+ [whitequark]: https://github.com/whitequark
+ [judofyr]:    https://github.com/judofyr
 
 ## Acknowledgements
 
-The lexer testsuite is derived from [ruby_parser](http://github.com/seattlerb/ruby_parser).
+The lexer testsuite and ruby_parser compatibility testsuite are derived from [ruby_parser](http://github.com/seattlerb/ruby_parser).
 
 The Bison parser rules are derived from [Ruby MRI](http://github.com/ruby/ruby) parse.y.
 

data/Rakefile

@@ -1,25 +1,45 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rake/clean'
 
 task :default => [:generate, :test]
 
-task :test do
-  $LOAD_PATH << File.expand_path('../lib/', __FILE__)
-  Dir["test/test_*.rb"].each do |file|
-    load file
-  end
+Rake::TestTask.new do |t|
+  t.libs       = %w(test/ lib/)
+  t.test_files = FileList["test/**/test_*.rb"]
 end
 
-desc "Generate the Ragel lexer and Bison parser."
-task :generate => %w(lib/parser/lexer.rb)
-                    #lib/parser/ruby18.rb
-                    #lib/parser/ruby19.rb)
+task :build => :generate_release
 
-task :build => :generate
+GENERATED_FILES = %w(lib/parser/lexer.rb
+                     lib/parser/ruby18.rb
+                     lib/parser/ruby19.rb)
+
+CLEAN.include(GENERATED_FILES)
+
+desc 'Generate the Ragel lexer and Bison parser.'
+task :generate => GENERATED_FILES
+
+task :regenerate => [:clean, :generate]
+
+desc 'Generate the Ragel lexer and Bison parser in release mode.'
+task :generate_release => [:clean_env, :regenerate]
+
+task :clean_env do
+  ENV.delete 'RACC_DEBUG'
+end
 
 rule '.rb' => '.rl' do |t|
   sh "ragel -R #{t.source} -o #{t.name}"
 end
 
 rule '.rb' => '.y' do |t|
-  sh "racc #{t.source} -o #{t.name} -O"
+  opts = [ "--superclass=Parser::Base",
+           t.source,
+           "-o", t.name
+         ]
+  opts << "--debug" if ENV['RACC_DEBUG']
+
+  sh "racc", *opts
 end
+

data/bin/benchmark

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+require 'benchmark'
+require 'ruby_parser'
+
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'parser/all'
+
+def measure(what)
+  rp_failures = 0
+  p_failures  = 0
+
+  Benchmark.bm(10) do |x|
+    x.report "ruby_parser" do
+      what.each do |file, src|
+        begin
+          Ruby18Parser.new.parse(src)
+        rescue Exception => e
+          puts file
+          puts "RP: #{e.class}: #{e.message}"
+          rp_failures += 1
+        end
+      end
+    end
+
+    x.report "parser" do
+      what.each do |file, src|
+        begin
+          Parser::Ruby18.parse(src, file)
+        rescue Parser::SyntaxError
+          p_failures += 1
+        rescue Exception => e
+          puts file
+          puts "P:  #{e.class}: #{e.message}"
+          puts e.backtrace
+          p_failures += 1
+        end
+      end
+    end
+  end
+
+  puts
+  puts "Failures: RP: #{rp_failures} P: #{p_failures}"
+end
+
+files = Hash[ARGV.map { |f| [f, File.read(f)] }]
+measure(files)

data/bin/explain-parse

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'parser/all'
+
+ENV['RACC_DEBUG'] = '1'
+
+class Parser::Base
+  def next_token
+    @lexer.advance_and_explain
+  end
+end
+
+Parser::Ruby18.parse(ARGF.read)

data/bin/parse

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'parser/all'
+
+p Parser::Ruby18.parse(ARGF.read)

data/lib/parser.rb

@@ -1,4 +1,88 @@
+require 'set'
+require 'racc/parser'
+
+require 'ast'
+
+if RUBY_VERSION < '1.9'
+  require 'parser/compatibility/ruby1_8'
+end
+
+# Library namespace
 module Parser
+  require 'parser/ast/node'
+  require 'parser/ast/processor'
+
+  require 'parser/source/buffer'
+  require 'parser/source/range'
+
+  require 'parser/source/map'
+  require 'parser/source/map/operator'
+  require 'parser/source/map/variable_assignment'
+
+  require 'parser/syntax_error'
+  require 'parser/diagnostic'
+  require 'parser/diagnostic/engine'
+
   require 'parser/static_environment'
+
   require 'parser/lexer'
+  require 'parser/lexer/literal'
+  require 'parser/lexer/stack_state'
+  require 'parser/lexer/explanation'
+
+  module Builders
+    require 'parser/builders/default'
+  end
+
+  require 'parser/base'
+
+  ERRORS = {
+    # Lexer errors
+    :unicode_point_too_large => "invalid Unicode codepoint (too large)",
+    :invalid_escape          => "invalid escape character syntax",
+    :invalid_escape_use      => "invalid character syntax; use ?%{escape}",
+    :incomplete_escape       => "incomplete character syntax",
+    :invalid_hex_escape      => "invalid hex escape",
+    :invalid_unicode_escape  => "invalid Unicode escape",
+    :unterminated_unicode    => "unterminated Unicode escape",
+    :escape_eof              => "escape sequence meets end of file",
+    :string_eof              => "unterminated string meets end of file",
+    :regexp_options          => "unknown regexp options: %{options}",
+    :cvar_name               => "`%{name}' is not allowed as a class variable name",
+    :ivar_name               => "`%{name}' is not allowed as an instance variable name",
+    :ambiguous_literal       => "ambiguous first argument; parenthesize arguments or add whitespace to the right",
+    :ambiguous_prefix        => "`%{prefix}' interpreted as argument prefix",
+    :trailing_underscore     => "trailing `_' in number",
+    :empty_numeric           => "numeric literal without digits",
+    :invalid_octal           => "invalid octal digit",
+    :no_dot_digit_literal    => "no .<digit> floating literal anymore; put 0 before dot",
+    :bare_backslash          => "bare backslash only allowed before newline",
+    :unexpected              => "unexpected %{character}",
+    :embedded_document       => "embedded document meats end of file (and they embark on a romantic journey)",
+
+    # Parser errors
+    :nth_ref_alias           => "cannot define an alias for a back-reference variable",
+    :begin_in_method         => "BEGIN in method",
+    :end_in_method           => "END in method; use at_exit",
+    :backref_assignment      => "cannot assign to a back-reference variable",
+    :invalid_assignment      => "cannot assign to a keyword",
+    :module_name_const       => "class or module name must be a constant literal",
+    :unexpected_token        => "unexpected token %{token}",
+    :argument_const          => "formal argument cannot be a constant",
+    :argument_ivar           => "formal argument cannot be an instance variable",
+    :argument_gvar           => "formal argument cannot be a global variable",
+    :argument_cvar           => "formal argument cannot be a class variable",
+    :empty_symbol            => "empty symbol literal",
+    :odd_hash                => "odd number of entries for a hash",
+    :singleton_literal       => "cannot define a singleton method for a literal",
+    :dynamic_const           => "dynamic constant assignment",
+    :module_in_def           => "module definition in method body",
+    :class_in_def            => "class definition in method body",
+    :grouped_expression      => "(...) interpreted as grouped expression",
+    :space_before_lparen     => "don't put space before argument parentheses",
+    :unexpected_percent_str  => "%{type}: unknown type of percent-literal",
+    :useless_else            => "else without rescue is useless",
+    :block_and_blockarg      => "both block argument and literal block are passed",
+    :masgn_as_condition      => "multiple assignment in conditional context",
+  }.freeze
 end

data/lib/parser/all.rb

@@ -0,0 +1,2 @@
+require 'parser/ruby18'
+require 'parser/ruby19'

data/lib/parser/ast/node.rb

@@ -0,0 +1,11 @@
+module Parser
+  module AST
+
+    class Node < ::AST::Node
+      attr_reader :source_map
+
+      alias src source_map
+    end
+
+  end
+end

data/lib/parser/ast/processor.rb

@@ -0,0 +1,8 @@
+module Parser
+  module AST
+
+    class Processor < ::AST::Processor
+    end
+
+  end
+end

data/lib/parser/base.rb

@@ -0,0 +1,116 @@
+module Parser
+
+  class Base < Racc::Parser
+    def self.parse(string, file='(string)', line=1)
+      parser = new
+
+      parser.diagnostics.all_errors_are_fatal = true
+      parser.diagnostics.ignore_warnings      = true
+
+      # Temporary, for manual testing convenience
+      parser.diagnostics.consumer = lambda do |diagnostic|
+        $stderr.puts(diagnostic.render)
+      end
+
+      source_buffer = Source::Buffer.new(file, line)
+      source_buffer.source = string
+
+      parser.parse(source_buffer)
+    end
+
+    def self.parse_file(filename)
+      parse(File.read(filename), filename)
+    end
+
+    attr_reader :diagnostics
+    attr_reader :static_env
+
+    # The source file currently being parsed.
+    attr_reader :source_buffer
+
+    def initialize(builder=Parser::Builders::Default.new)
+      @diagnostics = Diagnostic::Engine.new
+
+      @static_env  = StaticEnvironment.new
+
+      @comments    = []
+
+      @lexer = Lexer.new(version)
+      @lexer.diagnostics = @diagnostics
+      @lexer.static_env  = @static_env
+
+      @builder = builder
+      @builder.parser = self
+
+      if self.class::Racc_debug_parser && ENV['RACC_DEBUG']
+        @yydebug = true
+      end
+
+      reset
+    end
+
+    def reset
+      @source_buffer = nil
+      @def_level   = 0 # count of nested def's.
+
+      @lexer.reset
+      @static_env.reset
+
+      self
+    end
+
+    def parse(source_buffer)
+      @source_buffer       = source_buffer
+      @lexer.source_buffer = source_buffer
+
+      do_parse
+    ensure
+      # Don't keep references to the source file.
+      @source_buffer       = nil
+      @lexer.source_buffer = nil
+    end
+
+    def in_def?
+      @def_level > 0
+    end
+
+    protected
+
+    def value_expr(v)
+      #p 'value_expr', v
+      v
+    end
+
+    def next_token
+      @lexer.advance
+    end
+
+    def diagnostic(level, kind, location_tok, highlights_tok=[])
+      _, location = location_tok
+
+      highlights = highlights_tok.map do |token|
+        _, range = token
+        range
+      end
+
+      message = ERRORS[kind]
+      @diagnostics.process(
+          Diagnostic.new(level, message, location, highlights))
+
+      if level == :error
+        yyerror
+      end
+    end
+
+    def on_error(error_token_id, error_value, value_stack)
+      token_name = token_to_str(error_token_id)
+      _, location = error_value
+
+      # TODO add "expected: ..." here
+      message = ERRORS[:unexpected_token] % { :token => token_name }
+      @diagnostics.process(
+          Diagnostic.new(:error, message, location))
+    end
+  end
+
+end

data/lib/parser/builders/default.rb

@@ -0,0 +1,654 @@
+module Parser
+
+  class Builders::Default
+    attr_accessor :parser
+
+    #
+    # Literals
+    #
+
+    # Singletons
+
+    def nil(token);   t(token, :nil);   end
+    def true(token);  t(token, :true);  end
+    def false(token); t(token, :false); end
+
+    # Numerics
+
+    def integer(token, negate=false)
+      val = value(token)
+      val = -val if negate
+
+      t(token, :int, val)
+    end
+
+    def __LINE__(token)
+      t(token, :__LINE__)
+    end
+
+    def float(token, negate=false)
+      val = value(token)
+      val = -val if negate
+
+      t(token, :float, val)
+    end
+
+    # Strings
+
+    def string(token)
+      t(token, :str, value(token))
+    end
+
+    def string_compose(begin_t, parts, end_t)
+      if parts.one?
+        parts.first
+      else
+        s(:dstr, *parts)
+      end
+    end
+
+    def __FILE__(token)
+      t(token, :__FILE__)
+    end
+
+    # Symbols
+
+    def symbol(token)
+      t(token, :sym, value(token).to_sym)
+    end
+
+    def symbol_compose(begin_t, parts, end_t)
+      s(:dsym, *parts)
+    end
+
+    # Executable strings
+
+    def xstring_compose(begin_t, parts, end_t)
+      s(:xstr, *parts)
+    end
+
+    # Regular expressions
+
+    def regexp_options(token)
+      t(token, :regopt, *value(token).each_char.sort.uniq.map(&:to_sym))
+    end
+
+    def regexp_compose(begin_t, parts, end_t, options)
+      s(:regexp, *(parts << options))
+    end
+
+    # Arrays
+
+    def array(begin_t, elements, end_t)
+      s(:array, *elements)
+    end
+
+    def splat(star_t, arg=nil)
+      if arg.nil?
+        s(:splat)
+      else
+        s(:splat, arg)
+      end
+    end
+
+    def words_compose(begin_t, parts, end_t)
+      s(:array, *parts)
+    end
+
+    # Hashes
+
+    def pair(key, assoc_t, value)
+      s(:pair, key, 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)
+          end
+      end
+    end
+
+    def associate(begin_t, pairs, end_t)
+      s(:hash, *pairs)
+    end
+
+    # Ranges
+
+    def range_inclusive(lhs, token, rhs)
+      s(:irange, lhs, rhs)
+    end
+
+    def range_exclusive(lhs, token, rhs)
+      s(:erange, lhs, rhs)
+    end
+
+    #
+    # Expression grouping
+    #
+
+    def parenthesize(begin_t, expr, end_t)
+      expr
+    end
+
+    #
+    # Access
+    #
+
+    def self(token);  t(token, :self); 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); t(token, :back_ref, value(token).to_sym); end
+    def nth_ref(token);  t(token, :nth_ref,  value(token));        end
+
+    def accessible(node)
+      case node.type
+      when :__FILE__
+        node.updated(:str, [ node.src.expression.source_buffer.name ])
+
+      when :__LINE__
+        node.updated(:int, [ node.src.expression.line ])
+
+      when :__ENCODING__
+        s(:const, s(:const, nil, :Encoding), :UTF_8)
+
+      when :ident
+        name, = *node
+
+        if @parser.static_env.declared?(name)
+          node.updated(:lvar)
+        else
+          name, = *node
+          node.updated(:send, [ nil, name ])
+        end
+
+      else
+        node
+      end
+    end
+
+    def const(token)
+      t(token, :const, nil, value(token).to_sym)
+    end
+
+    def const_global(t_colon3, token)
+      s(:const, s(:cbase), value(token).to_sym)
+    end
+
+    def const_fetch(scope, t_colon2, token)
+      s(:const, scope, value(token).to_sym)
+    end
+
+    def __ENCODING__(token)
+      t(token, :__ENCODING__)
+    end
+
+    #
+    # Assignment
+    #
+
+    def assignable(node)
+      case node.type
+      when :cvar
+        if @parser.in_def?
+          node.updated(:cvasgn)
+        else
+          node.updated(:cvdecl)
+        end
+
+      when :ivar
+        node.updated(:ivasgn)
+
+      when :gvar
+        node.updated(:gvasgn)
+
+      when :const
+        if @parser.in_def?
+          message = ERRORS[:dynamic_const]
+          diagnostic :error, message, node.src.expression
+        end
+
+        node.updated(:cdecl)
+
+      when :ident
+        name, = *node
+        @parser.static_env.declare(name)
+
+        node.updated(:lvasgn)
+
+      when :nil, :self, :true, :false,
+           :__FILE__, :__LINE__, :__ENCODING__
+        message = ERRORS[:invalid_assignment]
+        diagnostic :error, message, node.src.expression
+
+      when :back_ref, :nth_ref
+        message = ERRORS[:backref_assignment]
+        diagnostic :error, message, node.src.expression
+
+      else
+        raise NotImplementedError, "build_assignable #{node.inspect}"
+      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
+    end
+
+    def op_assign(lhs, operator_t, rhs)
+      case lhs.type
+      when :gvasgn, :ivasgn, :lvasgn, :cvasgn, :cvdecl, :send
+        operator = value(operator_t)[0..-1].to_sym
+
+        case operator
+        when :'&&'
+          s(:and_asgn, lhs, rhs)
+        when :'||'
+          s(:or_asgn, lhs, rhs)
+        else
+          s(:op_asgn, lhs, operator, rhs)
+        end
+
+      when :back_ref, :nth_ref
+        message = ERRORS[:backref_assignment]
+        diagnostic :error, message, lhs.src.expression
+
+      else
+        raise NotImplementedError, "build op_assign #{lhs.inspect}"
+      end
+    end
+
+    def multi_lhs(begin_t, items, end_t)
+      s(:mlhs, *items)
+    end
+
+    def multi_assign(lhs, eql_t, rhs)
+      s(:masgn, lhs, rhs)
+    end
+
+    #
+    # Class and module definition
+    #
+
+    def def_class(class_t, name,
+                  lt_t, superclass,
+                  body, end_t)
+      s(:class, name, superclass, body)
+    end
+
+    def def_sclass(class_t, lshft_t, expr,
+                   body, end_t)
+      s(:sclass, expr, body)
+    end
+
+    def def_module(module_t, name,
+                   body, end_t)
+      s(:module, name, body)
+    end
+
+    #
+    # Method (un)definition
+    #
+
+    def def_method(def_t, name, args,
+                   body, end_t, comments)
+      s(:def, value(name).to_sym, args, body)
+    end
+
+    def def_singleton(def_t, definee, dot_t,
+                      name, 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
+
+      else
+        s(:defs, definee, value(name).to_sym, args, body)
+      end
+    end
+
+    def undef_method(token, names)
+      s(:undef, *names)
+    end
+
+    #
+    # Aliasing
+    #
+
+    def alias(token, to, from)
+      t(token, :alias, to, from)
+    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
+    end
+
+    #
+    # Formal arguments
+    #
+
+    def args(begin_t, args, end_t)
+      s(:args, *args)
+    end
+
+    def arg(token)
+      t(token, :arg, value(token).to_sym)
+    end
+
+    def optarg(token, eql_t, value)
+      s(:optarg, value(token).to_sym, value)
+    end
+
+    def splatarg(star_t, token=nil)
+      if token
+        s(:splatarg, value(token).to_sym)
+      else
+        t(star_t, :splatarg)
+      end
+    end
+
+    def shadowarg(token)
+      s(:shadowarg, value(token).to_sym)
+    end
+
+    def blockarg(amper_t, token)
+      s(:blockarg, value(token).to_sym)
+    end
+
+    # Ruby 1.8 block arguments
+
+    def arg_expr(expr)
+      if expr.type == :lvasgn
+        expr.updated(:arg)
+      else
+        s(:arg_expr, expr)
+      end
+    end
+
+    def splatarg_expr(star_t, expr=nil)
+      if expr.nil?
+        t(star_t, :splatarg)
+      elsif expr.type == :lvasgn
+        expr.updated(:splatarg)
+      else
+        s(:splatarg_expr, expr)
+      end
+    end
+
+    def blockarg_expr(amper_t, expr)
+      if expr.type == :lvasgn
+        expr.updated(:blockarg)
+      else
+        s(:blockarg_expr, expr)
+      end
+    end
+
+    #
+    # Method calls
+    #
+
+    def call_method(receiver, dot_t, selector_t,
+                    begin_t=nil, args=[], end_t=nil)
+      if selector_t.nil?
+        s(:send, receiver, :call, *args)
+      else
+        s(:send, receiver, value(selector_t).to_sym, *args)
+      end
+    end
+
+    def call_lambda(lambda_t)
+      s(:send, nil, :lambda)
+    end
+
+    def block(method_call, begin_t, args, body, end_t)
+      receiver, selector, *call_args = *method_call
+      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
+      end
+
+      s(:block, method_call, args, body)
+    end
+
+    def block_pass(amper_t, arg)
+      s(:block_pass, 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)
+    end
+
+    def index(receiver, lbrack_t, indexes, rbrack_t)
+      s(:send, receiver, :[], *indexes)
+    end
+
+    def index_asgn(receiver, lbrack_t, indexes, rbrack_t)
+      # Incomplete method call.
+      s(:send, receiver, :[]=, *indexes)
+    end
+
+    def binary_op(receiver, token, 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))
+        end
+      end
+
+      s(:send, receiver, value(token).to_sym, arg)
+    end
+
+    def unary_op(token, receiver)
+      case value(token)
+      when '+', '-'
+        method = value(token) + '@'
+      else
+        method = value(token)
+      end
+
+      s(:send, receiver, method.to_sym)
+    end
+
+    def not_op(token, receiver=nil)
+      if @parser.version == 18
+        s(:not, receiver)
+      else
+        if receiver.nil?
+          s(:send, s(:nil), :'!')
+        else
+          s(:send, receiver, :'!')
+        end
+      end
+    end
+
+    #
+    # Control flow
+    #
+
+    # Logical operations: and, or
+
+    def logical_op(type, lhs, token, rhs)
+      s(type, lhs, 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)
+    end
+
+    def condition_mod(if_true, if_false, cond_t, cond)
+      s(:if, check_condition(cond), if_true, if_false)
+    end
+
+    def ternary(cond, question_t, if_true, colon_t, if_false)
+      s(:if, check_condition(cond), if_true, if_false)
+    end
+
+    # Case matching
+
+    def when(when_t, patterns, then_t, body)
+      s(:when, *(patterns << body))
+    end
+
+    def case(case_t, expr, body, end_t)
+      s(:case, expr, *body)
+    end
+
+    # Loops
+
+    def loop(loop_t, cond, do_t, body, end_t)
+      s(value(loop_t).to_sym, check_condition(cond), body)
+    end
+
+    def loop_mod(body, loop_t, cond)
+      s(value(loop_t).to_sym, check_condition(cond), body)
+    end
+
+    def for(for_t, iterator, in_t, iteratee,
+            do_t, body, end_t)
+      s(:for, iterator, iteratee, body)
+    end
+
+    # Exception handling
+
+    def begin(begin_t, body, end_t)
+      body
+    end
+
+    def rescue_body(rescue_t,
+                    exc_list, assoc_t, exc_var,
+                    then_t, compound_stmt)
+      s(:resbody, exc_list, exc_var, compound_stmt)
+    end
+
+    def begin_body(compound_stmt, rescue_bodies=[],
+                   else_t=nil,    else_=nil,
+                   ensure_t=nil,  ensure_=nil)
+      if rescue_bodies.any?
+        if else_t
+          compound_stmt = s(:rescue, compound_stmt,
+                            *(rescue_bodies << else_))
+        else
+          compound_stmt = s(:rescue, compound_stmt,
+                            *(rescue_bodies << nil))
+        end
+      end
+
+      if ensure_t
+        compound_stmt = s(:ensure, compound_stmt, ensure_)
+      end
+
+      compound_stmt
+    end
+
+    def compstmt(statements)
+      case
+      when statements.one?
+        statements.first
+      when statements.none?
+        s(:nil)
+      else
+        s(:begin, *statements)
+      end
+    end
+
+    # BEGIN, END
+
+    def preexe(preexe_t, lbrace_t, compstmt, rbrace_t)
+      s(:preexe, compstmt)
+    end
+
+    def postexe(postexe_t, lbrace_t, compstmt, rbrace_t)
+      s(:postexe, compstmt)
+    end
+
+    protected
+
+    def check_condition(cond)
+      if cond.type == :masgn
+        # TODO source maps
+        diagnostic :error, ERRORS[:masgn_as_condition],
+                   nil #cond.src.expression
+      end
+
+      cond
+    end
+
+    def t(token, type, *args)
+      s(type, *(args << { :source_map => Source::Map.new(location(token)) }))
+    end
+
+    def value(token)
+      token[0]
+    end
+
+    def location(token)
+      token[1]
+    end
+
+    def s(type, *args)
+      if Hash === args.last
+        metadata = args.pop
+      else
+        metadata = {}
+      end
+
+      AST::Node.new(type, args, metadata)
+    end
+
+    def diagnostic(type, message, location, highlights=[])
+      @parser.diagnostics.process(
+          Diagnostic.new(type, message, location, highlights))
+
+      if type == :error
+        @parser.send :yyerror
+      end
+    end
+  end
+
+end