ruby-lint 0.0.2 → 0.0.3

data/lib/ruby-lint/parser.rb

@@ -1,47 +1,34 @@
 module RubyLint
   ##
-  # {RubyLint::Parser} uses Ripper to parse Ruby source code and turn it into an
-  # AST. Instead of returning arrays (the Ripper default) this class uses the
-  # various token classes such as {RubyLint::Token::Token} and
-  # {RubyLint::Token::VariableToken}. It also takes care of a few more things such
-  # as saving the associated line of code and setting method visibility.
+  # {RubyLint::Parser} parses Ruby code and returns a clean and usable AST
+  # instead of the rather raw AST returned by Ripper itself. Each node in the
+  # AST is an instance of {RubyLint::Node}.
   #
-  # Parsing Ruby code requires two steps:
+  # ## Example
   #
-  # 1. Create a new instance of this class and pass a string containing source
-  #    code to the constructor method.
-  # 2. Call the method {RubyLint::Parser#parse} and do something with the returned
-  #    AST.
-  #
-  # For example, to parse a simple "Hello World" example you'd use this parser
-  # as following:
-  #
-  #     require 'pp'
-  #
-  #     parser = RubyLint::Parser.new('puts "Hello, world!"')
-  #
-  #     pp parser.parse
-  #
-  # This outputs the following AST:
-  #
-  #     [#<RubyLint::Token::MethodToken:0x000000012f04d0
-  #       @code="puts \"Hello, world!\"",
-  #       @column=0,
-  #       @event=:method,
-  #       @line=1,
-  #       @name="puts",
-  #       @parameters=
-  #        [#<RubyLint::Token::Token:0x000000012e9fb8
-  #          @code="puts \"Hello, world!\"",
-  #          @column=6,
-  #          @event=:string,
-  #          @line=1,
-  #          @name="Hello, world!",
-  #          @type=:string,
-  #          @value="Hello, world!">],
-  #       @type=:method>]
+  #     RubyLint::Parser.new('[10, 20]').parse
+  #       # => (root (array (integer "10") (integer "20")))
   #
   class Parser < Ripper::SexpBuilderPP
+    ##
+    # Hash containing various Ripper types and the RubyLint types to use
+    # instead.
+    #
+    # @return [Hash]
+    #
+    TYPE_MAPPING = {
+      :ident           => :identifier,
+      :gvar            => :global_variable,
+      :ivar            => :instance_variable,
+      :cvar            => :class_variable,
+      :const           => :constant,
+      :int             => :integer,
+      :float           => :float,
+      :tstring_content => :string,
+      :label           => :symbol,
+      :kw              => :keyword
+    }
+
     ##
     # Array containing all the event names of which the methods should simply
     # returned the passed argument.
@@ -49,29 +36,21 @@ module RubyLint
     # @return [Array]
     #
     RETURN_FIRST_ARG_EVENTS = [
-      :program,
-      :var_field,
-      :args_add_block,
+      :arg_paren,
       :assoclist_from_args,
-      :symbol_literal,
       :begin,
-      :mrhs_new_from_args,
-      :blockarg,
-      :rest_param,
-      :arg_paren,
       :block_var,
+      :blockarg,
       :const_ref,
+      :mlhs_paren,
+      :mrhs_new_from_args,
+      :rest_param,
+      :symbol_literal,
       :top_const_ref,
-      :mlhs_paren
+      :var_field,
+      :paren
     ]
 
-    ##
-    # Array of events of which the callback method should simply return nil.
-    #
-    # @return [Array]
-    #
-    RETURN_NIL_EVENTS = [:void_stmt]
-
     ##
     # Array of event names that should return an instance of
     # {RubyLint::Token::MethodToken}.
@@ -81,8 +60,8 @@ module RubyLint
     RETURN_METHOD_EVENTS = [:fcall, :vcall]
 
     ##
-    # Hash containing the names of various event callbacks that should return
-    # a token class containing details about a single line statement.
+    # List of modified statements, used to dynamically define the callback
+    # methods.
     #
     # @return [Hash]
     #
@@ -94,32 +73,83 @@ module RubyLint
     }
 
     ##
-    # Array containing the three method calls that set the visibility of a
-    # method.
+    # Collection of Ripper events of which the callbacks all share similar
+    # code. The corresponding methods are defined on the fly.
+    #
+    # @return [Hash]
+    #
+    BASIC_EVENTS = {
+      :bodystmt         => :body,
+      :class            => :class,
+      :module           => :module,
+      :binary           => :binary,
+      :unary            => :unary,
+      :return           => :return,
+      :else             => :else,
+      :unless           => :unless,
+      :until            => :until,
+      :while            => :while,
+      :dot2             => :dot2,
+      :dot3             => :dot3,
+      :assoc_new        => :key_value,
+      :hash             => :hash,
+      :aref             => :aref,
+      :string_concat    => :string_concat,
+      :string_embexpr   => :embed,
+      :begin            => :begin,
+      :ensure           => :ensure,
+      :defined          => :defined,
+      :super            => :super,
+      :yield0           => :yield,
+      :yield            => :yield,
+      :sclass           => :sclass
+    }
+
+    ##
+    # Hash containing various Ripper event names and the methods these events
+    # should execute.
+    #
+    # @return [Hash]
+    #
+    EVENT_ALIASES = {
+      :dyna_symbol     => :on_symbol,
+      :aref_field      => :on_aref,
+      :bare_assoc_hash => :on_hash,
+      :do_block        => :on_brace_block
+    }
+
+    ##
+    # Array of events (the ones used by ruby-lint) of which the child nodes
+    # should be stripped of `nil` values.
     #
     # @return [Array]
     #
-    METHOD_VISIBILITY = ['public', 'protected', 'private']
+    COMPACT_EVENT_ARGS = [:body, :unless]
 
     ##
-    # Symbol containing the default method visibility.
+    # Array of events of which the first callback parameter should be used for
+    # the child nodes of a callback.
     #
-    # @return [Symbol]
+    # @return [Array]
     #
-    DEFAULT_VISIBILITY = :public
-
-    # Return an RubyLint::Token::Token instance for each scanner event instead of
-    # an array with multiple indexes.
-    SCANNER_EVENTS.each do |event|
-      define_method("on_#{event}") do |token|
-        return Token::Token.new(
-          :name   => token,
-          :type   => event,
-          :value  => token,
-          :line   => lineno,
-          :column => column,
-          :code   => code(lineno)
-        )
+    UNPACK_EVENT_ARGS = [:else, :hash, :embed, :ensure]
+
+    ##
+    # Hash containing parameter indexes and the node types.
+    #
+    # @return [Hash]
+    #
+    PARAMETER_INDEX_TYPES = {
+      0 => :argument,
+      1 => :optional_argument,
+      2 => :rest_argument,
+      3 => :more_argument,
+      4 => :block_argument
+    }
+
+    SCANNER_EVENTS.each do |type|
+      define_method("on_#{type}") do |value|
+        return Node.new(readable_type_name(type), [value], metadata)
       end
     end
 
@@ -127,1327 +157,670 @@ module RubyLint
       define_method("on_#{event}") { |*args| return args[0] }
     end
 
-    RETURN_NIL_EVENTS.each do |event|
-      define_method("on_#{event}") { |*args| return nil }
+    RETURN_METHOD_EVENTS.each do |event|
+      define_method("on_#{event}") do |node|
+        return Node.new(
+          :method,
+          [node.children[0], on_params, nil, nil], metadata(node)
+        )
+      end
     end
 
-    RETURN_METHOD_EVENTS.each do |event|
-      define_method("on_#{event}") do |token|
-        if METHOD_VISIBILITY.include?(token.name)
-          @visibility = token.name.to_sym
+    BASIC_EVENTS.each do |original, new|
+      define_method("on_#{original}") do |*args|
+        if COMPACT_EVENT_ARGS.include?(new)
+          args = args.map { |arg| arg.compact rescue arg }.compact
         end
 
-        return Token::MethodToken.new(
-          :name   => token.name,
-          :line   => token.line,
-          :column => token.column,
-          :value  => token.name,
-          :code   => code(token.line)
-        )
+        args = args[0] if UNPACK_EVENT_ARGS.include?(new)
+
+        return Node.new(new, args, metadata)
       end
     end
 
-    MOD_STATEMENT_EVENTS.each do |ripper_event, ruby_lint_event|
-      define_method("on_#{ripper_event}") do |statement, value|
+    MOD_STATEMENT_EVENTS.each do |mod, normal|
+      define_method("on_#{mod}") do |statement, value|
         value = [value] unless value.is_a?(Array)
 
-        return Token::StatementToken.new(
-          :type      => ruby_lint_event,
-          :statement => statement,
-          :value     => value,
-          :line      => lineno,
-          :column    => column,
-          :code      => code(lineno)
-        )
+        return send("on_#{normal}", statement, value)
+      end
+    end
+
+    EVENT_ALIASES.each do |event, method|
+      define_method("on_#{event}") do |*args|
+        return send(method, *args)
       end
     end
 
     ##
-    # Creates a new instance of the parser and pre-defines various instance
-    # variables.
-    #
     # @see Ripper::SexpBuilderPP#initialize
     #
     def initialize(code, file = '(ruby-lint)', line = 1)
       super
 
-      @file       = file
-      @visibility = DEFAULT_VISIBILITY
-      @lines      = []
+      @file = file
+    end
 
-      code.each_line do |code_line|
-        @lines << code_line.chomp
-      end
+    ##
+    # @return [NilClass]
+    #
+    def on_void_stmt
+      return nil
     end
 
     ##
-    # Called when a parser error was encountered.
+    # Called at the start of a Ruby program.
     #
-    # @param [String] message The error message.
-    # @raise [RubyLint::ParserError]
+    # @param  [Array] nodes The various nodes of the program.
+    # @return [RubyLint::Node]
     #
-    def on_parse_error(message)
-      raise ParserError.new(message, lineno, column, @file)
+    def on_program(nodes)
+      nodes = [nodes] unless nodes.is_a?(Array)
+
+      return Node.new(:root, nodes, :line => 1, :column => 0, :file => @file)
     end
 
     ##
-    # Called when a string literal was found.
-    #
-    # @param  [Array] token Array containing details about the string.
-    # @return [RubyLint::Token::Token]
+    # @param [String] message The error message.
+    # @raise [RubyLint::ParserError]
     #
-    def on_string_literal(token)
-      if token and token[1]
-        return token[1]
-      else
-        return Token::Token.new(
-          :name   => '',
-          :value  => '',
-          :line   => lineno,
-          :column => column,
-          :type   => :string
-        )
-      end
+    def on_parse_error(message)
+      raise ParserError.new(message, lineno, column, @file)
     end
 
     ##
     # Called when a symbol is found.
     #
-    # @param  [RubyLint::Token::Token] token The symbol token.
-    # @return [RubyLint::Token::Token]
+    # @param  [RubyLint::Node|Array] node The value of the symbol. This
+    #  parameter is set to an Array when parsing code such as `:"hello"`.
+    # @return [RubyLint::Node]
     #
-    def on_symbol(token)
-      token.type = :symbol
+    def on_symbol(node)
+      node = node[0] if node.is_a?(Array)
 
-      return token
+      return Node.new(:symbol, node.children, metadata(node))
     end
 
     ##
-    # Called when a symbol using quotes was found.
-    #
-    # @see RubyLint::Parser#on_symbol
+    # @param  [Array] content The contents of the string.
+    # @return [RubyLint::Node]
     #
-    def on_dyna_symbol(token)
-      return on_symbol(token[0])
+    def on_string_literal(content)
+      return content[1] || Node.new(:string, [], metadata)
     end
 
     ##
-    # Called when an expression is embedded in a string.
+    # Called when a piece of code is embedded using `#expressions` (e.g.
+    # `#$foo`).
     #
-    # @param  [Array] exp The embedded expressions.
-    # @return [RubyLint::Token::Token]
+    # @param [RubyLint::Node] node
+    # @return [RubyLint::Node]
     #
-    def on_string_embexpr(exp)
-      return exp[0]
+    def on_string_dvar(node)
+      return Node.new(:embed, [node], metadata(node))
     end
 
     ##
-    # Called when an array is found.
-    #
     # @param  [Array] values The values of the array.
-    # @return [RubyLint::Token::Token]
+    # @return [RubyLint::Node]
     #
     def on_array(values)
       values ||= []
+      values   = [values] unless values.is_a?(Array)
+      children = values.flatten
 
-      return Token::Token.new(
-        :type   => :array,
-        :value  => values.map { |v| v.is_a?(Array) ? v[0] : v },
-        :line   => lineno,
-        :column => column,
-        :code   => code(lineno)
-      )
+      return Node.new(:array, children, metadata)
     end
 
     ##
-    # Called when a reference to a particular array index is found.
-    #
-    # @param  [RubyLint::Token::Token] array The array that was referenced.
-    # @param  [RubyLint::Token::Token] index The index that was referenced.
-    # @return [RubyLint::Token::Token]
+    # @param  [Array] regexp Array containing the regular expression's body.
+    # @return [RubyLint::Node] mode The mode for the regular expression.
+    # @return [RubyLint::Node]
     #
-    def on_aref(array, index)
-      array.key = index
-
-      return array
-    end
-
-    ##
-    # Called when a value is assigned to an array index.
-    #
-    # @param [RubyLint::Token::Token] array The array that was referenced.
-    # @param [RubyLint::Token::Token] index The index of the array that was
-    #  referenced.
-    # @return [RubyLint::Token::Token]
-    #
-    def on_aref_field(array, index)
-      array.key = index
-
-      return Token::AssignmentToken.new(
-        :receiver => array,
-        :line     => lineno,
-        :column   => column,
-        :type     => array.type,
-        :code     => code(lineno)
-      )
+    def on_regexp_literal(regexp, mode)
+      return Node.new(:regexp, [regexp[0], mode], metadata)
     end
 
     ##
-    # Called when a Hash is found.
+    # @param  [RubyLint::Node] params The parameters of the lamda.
+    # @param  [Array] body The body of the lambda.
+    # @return [RubyLint::Node]
     #
-    # @param  [Array] pairs An array of key/value pairs of the hash.
-    # @return [RubyLint::Token::Token]
-    #
-    def on_hash(pairs)
-      # column() is set to the column number of the very end of the hash.
-      col = pairs[0].column rescue column
-
-      return Token::Token.new(
-        :type   => :hash,
-        :value  => pairs,
-        :line   => lineno,
-        :column => col,
-        :code   => code(lineno)
-      )
+    def on_lambda(params, body)
+      return on_brace_block(params, body).updated(:lambda)
     end
 
     ##
-    # Called when a bare Hash is found. A bare Hash is a hash that's declared
-    # without the curly braces.
-    #
-    # @see RubyLint::Parser#on_hash
+    # @param  [RubyLint::Node] params The parameters of the block.
+    # @param  [Array] body The body of the block.
+    # @return [RubyLint::Node]
     #
-    def on_bare_assoc_hash(pairs)
-      return on_hash(pairs)
+    def on_brace_block(params, body)
+      return Node.new(:block, [params || on_params, on_bodystmt(body)], metadata)
     end
 
     ##
-    # Called when a new key/value pair of a Hash is found.
-    #
-    # @param  [RubyLint::Token::Token] key The key of the pair.
-    # @param  [RubyLint::Token::Token] value The value of the pair.
-    # @return [RubyLint::Token::Token]
+    # @param [RubyLint::Node] left
+    # @param [RubyLint::Node] right
+    # @return [RubyLint::Node]
     #
-    def on_assoc_new(key, value)
-      key.name  = key.value
-      key.value = value
+    def on_const_path_ref(left, right)
+      left = left.type == :constant_path ? left.children : left
 
-      return key
-    end
-
-    ##
-    # Called when a block is created using curly braces.
-    #
-    # @param [RubyLint::Token::ParametersToken] params The parameters of the
-    #  block.
-    # @param  [Array] body Array containing the tokens of the block.
-    # @return [RubyLint::Token::BlockToken]
-    #
-    def on_brace_block(params, body)
-      return Token::BlockToken.new(
-        :parameters => params,
-        :value      => body,
-        :line       => lineno,
-        :column     => column,
-        :type       => :block,
-        :code       => code(lineno)
-      )
+      return Node.new(:constant_path, [left, right].flatten, metadata)
     end
 
     ##
-    # Called when a block is created using the do/end statements.
-    #
-    # @see RubyLint::Parser#on_brace_block
+    # @see #on_constant_path_ref
     #
-    def on_do_block(params, body)
-      return on_brace_block(params, body)
+    def on_const_path_field(left, right)
+      return on_const_path_ref(left, right)
     end
 
     ##
-    # Called when a lambda is found.
+    # Called when a variable is assigned to a start (`*`).
     #
-    # @see RubyLint::Parser#on_brace_block
+    # @param [Array|RubyLint::Node] left The variable(s) to the left of the
+    #  star.
+    # @param [Array|RubyLint::Node] right The variable(s) to the right of the
+    #  star.
+    # @return [RubyLint::Node]
     #
-    def on_lambda(params, body)
-      token      = on_brace_block(params, body)
-      token.type = :lambda
-
-      return token
-    end
-
-    ##
-    # Called when a Range is found.
-    #
-    # @param  [RubyLint::Token::Token] start The start value of the range.
-    # @param  [RubyLint::Token::Token] stop The end value of the range.
-    # @return [RubyLint::Token::Token]
-    #
-    def on_dot2(start, stop)
-      return Token::Token.new(
-        :type   => :range,
-        :line   => start.line,
-        :column => start.line,
-        :value  => [start, stop],
-        :code   => code(start.line)
-      )
-    end
+    def on_mlhs_add_star(left, right)
+      if right
+        left << right.updated(nil, [*right.children, true])
+      # Add a placeholder for the expander token.
+      else
+        left << nil
+      end
 
-    ##
-    # Called when a range using 3 dots is found.
-    #
-    # @see  RubyLint::Parser#on_dot2
-    # @todo There's a difference between ranges created using two and three
-    #  dots, this method should return a different token in the future.
-    #
-    def on_dot3(start, stop)
-      return on_dot2(start, stop)
+      return left
     end
 
     ##
-    # Called when a regular expression is found.
-    #
-    # @param [Array] regexp The regular expression's value.
-    # @param [RubyLint::Token::Token] modes The modes of the regular expression.
-    # @return [RubyLint::Token::RegexpToken]
+    # @param [RubyLint::Node] variable The data to assign the value to.
+    # @param [RubyLint::Node] value The value to assign.
+    # @return [RubyLint::Node]
     #
-    def on_regexp_literal(regexp, modes)
-      regexp      = regexp[0]
-      modes_array = []
-
-      value = regexp.respond_to?(:value)  ? regexp.value  : nil
-      line  = regexp.respond_to?(:line)   ? regexp.line   : lineno
-      col   = regexp.respond_to?(:column) ? regexp.column : column
+    def on_assign(variable, value)
+      variable = variable.updated(:local_variable) if variable.identifier?
 
-      if modes
-        modes_array = modes.value.split('').select { |c| c =~ /\w/ }
+      # When assigning values to array indexes or hash keys the value should
+      # always be an array. This makes it easier to assign values without
+      # having to check the type of data we're dealing with.
+      if variable.type == :aref and !value.is_a?(Array)
+        value = [value]
       end
 
-      return Token::RegexpToken.new(
-        :type   => :regexp,
-        :value  => value,
-        :line   => line,
-        :column => col,
-        :modes  => modes_array,
-        :code   => code(line)
-      )
+      return Node.new(:assign, [variable, value], metadata(variable))
     end
 
     ##
-    # Called when a value is assigned to a variable.
+    # Called when a conditional assignment is found.
     #
-    # @param  [RubyLint::Token::Token] variable The variable that is assigned.
-    # @param  [RubyLint::Token::Token] value The value to assign.
-    # @return [RubyLint::Token::VariableToken]
+    # @see RubyLint::Parser#on_assign
     #
-    def on_assign(variable, value)
-      if variable.class == RubyLint::Token::AssignmentToken
-        variable.value = value
-
-        return variable
-      end
-
-      if variable.is_a?(Array)
-        line = variable[-1].line
-        col  = variable[-1].column
-        type = variable[-1].type
-        name = variable
-      else
-        line = variable.line
-        col  = variable.column
-        type = variable.type
-        name = variable.name
-      end
-
-      return Token::AssignmentToken.new(
-        :line   => line,
-        :column => col,
-        :name   => name,
-        :type   => type,
-        :value  => value,
-        :code   => code(line)
-      )
+    def on_opassign(variable, operator, value)
+      return on_assign(variable, value).updated(:op_assign)
     end
 
     ##
-    # Called when a set of values is assigned to multiple variables.
-    #
-    # @param [Array] variables The variables that are being assigned values.
-    # @param [Array|RubyLint::Token::Token] values The values to assign.
-    # @return [RubyLint::Token::AssignmentToken]
+    # @param [Array] variables The variables that are being assigned.
+    # @param [Array|RubyLint::Node] values The values to assign.
+    # @return [RubyLint::Node]
     #
     def on_massign(variables, values)
-      assignments = []
-      variables   = variables.flatten
-      assigned    = []
-      expander    = nil
-      value_index = 0
-
-      variables.each_with_index do |variable, var_index|
-        if variable.expand
-          expander = var_index
-          value    = Token::Token.new(
-            :type   => :array,
-            :line   => variable.line,
-            :column => variable.column,
-            :code   => variable.code,
-            :value  => []
-          )
-        else
-          value = nil
-        end
-
-        assignments << Token::AssignmentToken.new(
-          :name   => variable.name,
-          :line   => variable.line,
-          :column => variable.column,
-          :code   => variable.code,
-          :type   => variable.type,
-          :expand => variable.expand,
-          :value  => value
-        )
-      end
+      nodes     = []
+      variables = variables.flatten
+      before    = 0
 
-      # Unpack array based values and ensure that `values` is always an array.
-      if values.is_a?(Token::Token) and values.type == :array
-        values = values.value
-      elsif values.is_a?(Token::Token)
+      if values.is_a?(Node) and values.type == :array
+        values = values.children.dup
+      elsif !values.is_a?(Array)
         values = [values]
       end
 
-      equal_length = assignments.length == values.length
+      var_length = variables.length
+      val_length = values.length
+
+      variables.each_with_index do |variable, index|
+        if !variable
+          values.shift
+          next
+        end
+
+        variable = variable.updated(:local_variable) if variable.identifier?
+
+        # Extract the values for the expander variable based on the amount of
+        # variables, values and the amount of variables that were assigned
+        # before the expander.
+        if variable.children[1]
+          slice_length = val_length - (var_length - 1)
 
-      # Assign the values to each variable. The remaining values will be
-      # assigned to the expanding variable.
-      assignments.each do |assignment|
-        if !assignment.expand and values[value_index]
-          assignment.value = values[value_index]
+          value = Node.new(
+            :array,
+            values.slice!(index - before, slice_length),
+            metadata(variable)
+          )
 
-          assigned    << values[value_index]
-          value_index += 1
+          variable = variable.updated(nil, [variable.children[0]])
+        else
+          before += 1
+          value   = values.shift
         end
 
-        # THINK: I really wonder if this is the way to make sure the expander
-        # value is assigned correctly.
-        if assignment.expand and equal_length
-          value_index += 1
+        unless value
+          value = Node.new(
+            :keyword,
+            ['nil'],
+            metadata(variable)
+          )
         end
-      end
 
-      # Assign the remaining values to the expander variable.
-      if expander
-        assignments[expander].value.value = values - assigned
+        nodes << Node.new(:assign, [variable, value], metadata(variable))
       end
 
-      return assignments
+      return Node.new(:mass_assign, nodes, metadata)
     end
 
     ##
-    # Called when a expand assignment is found.
-    #
-    # @param [Array] left The variables assigned on the left hand side of the
-    #  expand operator.
-    # @param [RubyLint::Token::Token|NilClass] right The variable assigned on
-    #  the right hand side of the operator.
+    # @param  [RubyLint::Node] variable The variable that was referenced.
+    # @return [RubyLint::Node]
     #
-    def on_mlhs_add_star(left, right)
-      variables = left || []
-
-      if right and right.name != '*'
-        right.expand = true
-
-        variables << right
-      end
+    def on_var_ref(variable)
+      variable = variable.updated(:local_variable) if variable.identifier?
 
-      return variables
+      return variable
     end
 
     ##
-    # @see RubyLint::Parser#on_mlhs_add_star
+    # @param [RubyLint::Node] object The object of the field.
+    # @param [Symbol] operator The operator used to separate the object and
+    #  field.
+    # @param [RubyLint::Node] field The field that was referenced.
+    # @return [RubyLint::Node]
     #
-    def on_mrhs_add_star(left, right)
-      return on_mlhs_add_star(left, right)
+    def on_field(object, operator, field)
+      return Node.new(:field, [object, field], metadata)
     end
 
     ##
-    # Called when a method call was prefixed with a `*` to indicate that the
-    # values it returns should be expanded.
+    # Called when a method without parenthesis is called.
     #
-    # @param  [Array] left The variables to the left.
-    # @param  [RubyLint::Token::Token] right The variable to expand.
-    # @return [Array]
+    # @see RubyLint::Parser#on_method_add_arg
     #
-    def on_args_add_star(left, right)
-      variables = left || []
-
-      if right
-        right.expand = true
-
-        variables << right
-      end
-
-      return variables
-    end
-
-    ##
-    # Called when a value is assigned to an object attribute.
-    #
-    # @param [RubyLint::Token::VariableToken] receiver The receiver of the
-    #  assignment.
-    # @param [Symbol] operator The operator that was used to separate the
-    #  object and attribute.
-    # @param [RubyLint::Token::Token] attribute The attribute to which the value
-    #  is assigned.
-    # @return [RubyLint::Token::VariableToken]
-    #
-    def on_field(receiver, operator, attribute)
-      return Token::AssignmentToken.new(
-        :name     => attribute.value,
-        :line     => attribute.line,
-        :column   => attribute.column,
-        :type     => attribute.type,
-        :receiver => receiver,
-        :operator => operator,
-        :code     => code(attribute.line)
-      )
-    end
-
-    ##
-    # Called when a (binary) operator operation is performed.
-    #
-    # @param  [RubyLint::Token::Token] left The left hand side of the operator.
-    # @param  [Symbol] op The operator that was used.
-    # @param  [RubyLint::Token::Token] right The right hand side of the operator.
-    # @return [RubyLint::Token::Token]
-    #
-    def on_binary(left, op, right)
-      return Token::Token.new(
-        :type   => :binary,
-        :value  => [left, op, right],
-        :line   => lineno,
-        :column => column,
-        :code   => code(lineno)
-      )
-    end
-
-    ##
-    # Called when an unary operator/operation is found.
-    #
-    # @param [Symbol] operator The unary operator.
-    # @param [RubyLint::Token::Token] token The token after the unary operator.
-    # @return [RubyLint::Token::Token]
-    #
-    def on_unary(operator, token)
-      return Token::Token.new(
-        :type   => :unary,
-        :value  => [operator, token],
-        :line   => lineno,
-        :column => column,
-        :code   => code(lineno)
+    def on_command(name, params)
+      return Node.new(
+        :method,
+        [name.children[0], on_params(params), nil, nil],
+        metadata(name)
       )
     end
 
     ##
-    # Called when a set of parenthesis is found.
+    # Called when a method is invoked on an object.
     #
-    # @param  [Array] value The data inside the parenthesis.
-    # @return [RubyLint::Token::Token]
+    # @param  [RubyLint::Node] object The object the method was invoked on.
+    # @param  [Symbol] operator The operator used for the method call.
+    # @param  [RubyLint::Node] name The name of the method.
+    # @return [RubyLint::Node]
     #
-    def on_paren(value)
-      if value.is_a?(Array)
-        return value[0]
-      else
-        return value
-      end
+    def on_call(object, operator, name)
+      return Node.new(
+        :method,
+        [name.children[0], on_params, nil, object],
+        metadata(name)
+      )
     end
 
     ##
-    # Called when a return statement is found.
+    # Called when a method is invoked on an object without the use of
+    # parenthesis.
     #
-    # @param  [Array] values The return values of the statement.
-    # @return [RubyLint::Token::StatementToken]
+    # @see RubyLint::Parser#on_call
     #
-    def on_return(values)
-      source = code(lineno)
-      col    = calculate_column(source, 'return')
-
-      return Token::StatementToken.new(
-        :type   => :return,
-        :line   => lineno,
-        :column => col,
-        :value  => values,
-        :code   => source
-      )
-    end
+    def on_command_call(object, operator, name, params)
+      node        = on_call(object, operator, name)
+      children    = node.children.dup
+      children[1] = on_params(params)
 
-    ##
-    # Called when a while loop is found.
-    #
-    # @param  [RubyLint::Token::Token|Array] statement The statement to
-    #  evaluate.
-    # @param  [RubyLint::Token::Token] value The body of the while loop.
-    # @return [RubyLint::Token::StatementToken]
-    #
-    def on_while(statement, value)
-      line   = statement.is_a?(Array) ? statement[0].line : statement.line
-      source = code(line)
-      col    = calculate_column(source, 'while')
-
-      return Token::StatementToken.new(
-        :type      => :while,
-        :statement => statement,
-        :value     => value,
-        :line      => line,
-        :column    => col,
-        :code      => source
-      )
+      return node.updated(nil, children)
     end
 
     ##
-    # Called when a for loop is found.
-    #
-    # @param  [Array|RubyLint::Token::Token] variables A single token or array
-    #  of tokens for the variables to create for each iteration.
-    # @param  [RubyLint::Token::Token] enumerable The enumerable to iterate.
-    # @param  [Array] value The body of the for loop.
-    # @return [RubyLint::Token::StatementToken]
+    # @param  [RubyLint::Node] method The method that is called.
+    # @param  [RubyLint::Node|Array] params Array of parameters passed to the
+    #  method.
+    # @return [RubyLint::Node]
     #
-    def on_for(variables, enumerable, value)
-      variables = [variables] unless variables.is_a?(Array)
-      source    = code(variables[0].line)
-      col       = calculate_column(source, 'for')
-
-      return Token::StatementToken.new(
-        :type      => :for,
-        :statement => [variables, enumerable],
-        :value     => value,
-        :column    => col,
-        :line      => variables[0].line,
-        :code      => source
-      )
-    end
+    def on_method_add_arg(method, params)
+      children = method.children.dup
 
-    ##
-    # Called when an if statement is found.
-    #
-    # @param  [RubyLint::Token::Token] statement The if statement to evaluate.
-    # @param  [Array] value Array containing the tokens of the code that will
-    #  be executed if the if statement evaluates to true.
-    # @param  [Array] rest Array containing the tokens for the elsif and else
-    #  statements (if any).
-    # @return [RubyLint::Token::StatementToken]
-    #
-    def on_if(statement, value, rest)
-      source = code(statement.line)
-      col    = calculate_column(source, 'if')
-
-      else_statement   = nil
-      elsif_statements = []
-
-      if rest and rest.respond_to?(:each)
-        rest.each do |token|
-          next if token.nil?
-
-          if token.type == :elsif
-            elsif_statements << token
-          else
-            else_statement = token
-          end
-        end
+      if !params.is_a?(Array)
+        children[1] = params
       end
 
-      return Token::StatementToken.new(
-        :type      => :if,
-        :statement => statement,
-        :value     => value,
-        :line      => statement.line,
-        :column    => col,
-        :else      => else_statement,
-        :elsif     => elsif_statements.reverse,
-        :code      => source
-      )
+      return method.updated(nil, children)
     end
 
     ##
-    # Called whne a tenary operator is found.
-    #
-    # @see RubyLint::Parser#on_if
+    # @param [Mixed] arguments
+    # @param [Mixed] block
     #
-    def on_ifop(statement, value, else_statement)
-      else_statement = Token::StatementToken.new(
-        :type   => :else,
-        :value  => [else_statement],
-        :line   => else_statement.line,
-        :column => else_statement.column,
-        :code   => code(else_statement.line)
-      )
-
-      return Token::StatementToken.new(
-        :type      => :if,
-        :statement => statement,
-        :value     => [value],
-        :line      => statement.line,
-        :column    => statement.column,
-        :code      => code(statement.line),
-        :else      => else_statement
-      )
+    def on_args_add_block(arguments, block)
+      return on_params(arguments, nil, nil, nil, block)
     end
 
     ##
-    # Called when an else statement is found.
-    #
-    # @param  [Array] value The value of the statement.
-    # @return [RubyLint::Token::StatementToken]
-    #
-    def on_else(value)
-      return Token::StatementToken.new(
-        :type   => :else,
-        :value  => value,
-        :column => column,
-        :line   => lineno,
-        :code   => code(lineno)
-      )
-    end
-
-    ##
-    # Called when an elsif statement is found.
-    #
-    # @param [RubyLint::Token::Token] statement The statement to evaluate.
-    # @param [Array] value The value of the elsif statement.
-    # @param [Array|RubyLint::Token::Token] list A list of else and elsif
-    #  statements.
+    # @param [Mixed] arguments
+    # @param [Mixed] splat
     # @return [Array]
     #
-    def on_elsif(statement, value, list)
-      source = code(statement.line)
-      col    = calculate_column(source, 'elsif')
-
-      token = Token::StatementToken.new(
-        :type      => :elsif,
-        :statement => statement,
-        :value     => value,
-        :line      => statement.line,
-        :column    => col,
-        :code      => source
-      )
-
-      unless list.is_a?(Array)
-        list = [list]
-      end
-
-      list << token
-    end
+    def on_args_add_star(arguments, splat)
+      # Ripper isn't exactly consistent with its output. In certain cases, such
+      # `*(foo = something_else)` splat will be set to an Array instead of the
+      # assignment node.
+      splat = splat[0] if splat.is_a?(Array)
 
-    ##
-    # Called when the body of a block of Ruby code is found (e.g. a method
-    # definition or a begin/rescue block).
-    #
-    # @param [Array] value Array containing the tokens of the body/statement.
-    # @param [Array] rescues An array of rescue statements.
-    # @param [RubyLint::Token::StatementToken] else_statement The else statement
-    #  of the block.
-    # @param [RubyLint::Token::StatementToken] ensure_statement The ensure
-    #  statement of the block.
-    # @return [RubyLint::Token::BeginRescueToken]
-    #
-    def on_bodystmt(value, rescues, else_statement, ensure_statement)
-      if rescues.nil? and else_statement.nil? and ensure_statement.nil?
-        return value
-      end
-
-      return Token::BeginRescueToken.new(
-        :type   => :begin,
-        :value  => value,
-        :rescue => (rescues || []).reverse.select { |t| !t.nil? },
-        :ensure => ensure_statement,
-        :else   => else_statement,
-        :line   => lineno,
-        :column => column,
-        :code   => code(lineno)
-      )
+      return arguments << Node.new(:splat_argument, [splat], metadata(splat))
     end
 
     ##
-    # Called when a rescue statement is found.
-    #
-    # @param [Array] exceptions An array of exceptions to catch.
-    # @param [RubyLint::Token::Token] variable The variable in which to store
-    #  the exception details.
-    # @param  [Array] value The value of the rescue statement.
-    # @param  [Array|RubyLint::Token::Token] list A set of all the rescue tokens.
-    # @return [RubyLint::Token::StatementToken]
-    #
-    def on_rescue(exceptions, variable, value, list)
-      source = code(lineno)
-      col    = calculate_column(source, 'rescue')
-
-      token = Token::StatementToken.new(
-        :type      => :rescue,
-        :statement => [exceptions, variable],
-        :line      => lineno,
-        :column    => col,
-        :value     => value,
-        :code      => source
-      )
-
-      unless list.is_a?(Array)
-        list = [list]
-      end
-
-      list << token
-    end
+    # @param  [RubyLint::Node] method The method node.
+    # @param  [RubyLint::Node] block The block passed to the method.
+    # @return [RubyLint::Node]
+    #
+    def on_method_add_block(method, block)
+      children        = method.children.dup
+      index           = method.type == :super ? 1 : -2
+      children[index] = block
 
-    ##
-    # Called when a single line rescue statement (in the form of `[VALUE]
-    # rescue [RESCUE VALUE]`) is found.
-    #
-    # @param [RubyLint::Token::Token|Array] value The body of the begin/rescue
-    #  statement.
-    # @param [RubyLint::Token::Token] statement The statement to evaluate when the
-    #  data in `value` raised an exception.
-    # @return [RubyLint::Token::BeginRescueToken]
-    #
-    def on_rescue_mod(value, statement)
-      value     = [value]     unless value.is_a?(Array)
-      statement = [statement] unless statement.is_a?(Array)
-
-      return Token::BeginRescueToken.new(
-        :type   => :rescue,
-        :rescue => statement,
-        :value  => value,
-        :line   => lineno,
-        :column => column,
-        :code   => code(lineno)
-      )
+      return method.updated(nil, children)
     end
 
     ##
-    # Called when an ensure statement is found.
-    #
-    # @param  [Array] value The value of the statement.
-    # @return [RubyLint::Token::StatementToken]
-    #
-    def on_ensure(value)
-      return Token::StatementToken.new(
-        :type   => :ensure,
-        :value  => value,
-        :line   => lineno,
-        :column => column,
-        :code   => code(lineno)
+    # @param  [RubyLint::Node] name The name of the method.
+    # @param  [Array] params The parameters of the method.
+    # @param  [Array] body The body of the method.
+    # @return [RubyLint::Node]
+    #
+    def on_def(name, params, body)
+      return Node.new(
+        :method_definition,
+        [name.children[0], params, nil, body],
+        metadata(name)
       )
     end
 
     ##
-    # Called for an entire case/when/else block.
+    # Called when a method definition using a receiver is found.
     #
-    # @param [RubyLint::Token::Token] statement The statement of the `case`
-    #  statement itself.
-    # @param [Array] list Array containing the various when statements and
-    #  optionally an else statement.
-    # @return [RubyLint::Token::CaseToken]
+    # @see RubyLint::Parser#on_def
     #
-    def on_case(statement, list)
-      when_statements = []
-      else_statement  = nil
-      list            = list.reject(&:nil?)
-
-      line   = statement.respond_to?(:line) ? statement.line : list[0].line
-      source = code(line)
-      col    = calculate_column(source, 'case')
-
-      if list and list.respond_to?(:each)
-        list.each do |token|
-          if token.type == :when
-            when_statements << token
-          else
-            else_statement = token
-          end
-        end
-      end
-
-      return Token::CaseToken.new(
-        :type      => :case,
-        :statement => statement,
-        :else      => else_statement,
-        :when      => when_statements.reverse,
-        :line      => line,
-        :column    => col,
-        :code      => source
+    def on_defs(receiver, operator, name, params, body)
+      return Node.new(
+        :method_definition,
+        [name.children[0], params, receiver, body],
+        metadata(name)
       )
     end
 
     ##
-    # Called when a `when` statement is found.
+    # Called when a set of method parameters if found.
     #
-    # @param  [Array] statement Array of statements to evaluate.
-    # @param  [Array] body Array containing the tokens of the statement's body.
-    # @param  [Array] list The list of `when` tokens.
+    # @param  [Array] params The specified parameters.
     # @return [Array]
     #
-    def on_when(statement, body, list)
-      source = code(statement[0].line)
-      col    = calculate_column(source, 'when')
-
-      token = Token::StatementToken.new(
-        :type      => :when,
-        :statement => statement,
-        :value     => body,
-        :line      => statement[0].line,
-        :column    => col,
-        :code      => source
-      )
+    def on_params(*params)
+      if params[0].is_a?(Node) and params[0].type == :arguments
+        return params[0]
+      end
 
-      unless list.is_a?(Array)
-        list = [list]
+      if params[1]
+        params[1] = remap_optional_arguments(params[1])
       end
 
-      list << token
-    end
+      params = group_arguments(params)
 
-    ##
-    # Called when a unless statement is found.
-    #
-    # @param [RubyLint::Token::Token] statement The statement to evaluate.
-    # @param [Array] body The body of the unless statement.
-    # @param [RubyLint::Token::StatementToken] else_token An optional else
-    #  statement.
-    # @return [RubyLint::Token::StatementToken]
-    #
-    def on_unless(statement, body, else_token)
-      source = code(statement.line)
-      col    = calculate_column(source, 'unless')
-
-      return Token::StatementToken.new(
-        :type      => :unless,
-        :statement => statement,
-        :else      => else_token,
-        :value     => body,
-        :line      => statement.line,
-        :column    => col,
-        :code      => source
-      )
+      return Node.new(:arguments, params, metadata)
     end
 
     ##
-    # Called when an until statement is found.
-    #
-    # @see RubyLint::Parser#on_unless
+    # @param [RubyLint::Node] statement The statement to evaluate.
+    # @param [Array] body The body of the if statement.
+    # @param [Array|NilClass] rest The rest of the statement, includes the
+    #  elsif and else statements.
+    # @return [RubyLint::Node]
     #
-    def on_until(statement, body)
-      source = code(statement.line)
-      col    = calculate_column(source, 'until')
+    def on_if(statement, body, rest = nil)
+      elsif_stmts = []
+      else_stmt   = nil
 
-      return Token::StatementToken.new(
-        :type      => :until,
-        :statement => statement,
-        :value     => body,
-        :line      => statement.line,
-        :column    => col,
-        :code      => source
-      )
-    end
+      rest ||= []
+      rest   = [rest] unless rest.is_a?(Array)
 
-    ##
-    # Called when a call to `defined?()` is found.
-    #
-    # @param  [RubyLint::Token::Token] token The token which is being checked.
-    # @return [RubyLint::Token::StatementToken]
-    #
-    def on_defined(token)
-      return Token::KeywordToken.new(
-        :name       => 'defined?',
-        :parameters => [token],
-        :line       => token.line,
-        :column     => token.column,
-        :code       => token.code
+      rest.compact.each do |node|
+        if node.type == :else
+          else_stmt = node
+        else
+          elsif_stmts << node
+        end
+      end
+
+      return Node.new(
+        :if,
+        [statement, body, elsif_stmts.reverse, else_stmt],
+        metadata
       )
     end
 
     ##
-    # Called when a call to `super` without parameters is found.
+    # Called when a ternary operator is found.
     #
-    # @return [RubyLint::Token::MethodToken]
+    # @param [RubyLint::Node] statement The statement to evaluate.
+    # @param [RubyLint::Node] true_val The value to use when the statement
+    #  evaluates to true.
+    # @param [RubyLint::Node] false_val The value to use when the statement
+    #  evaluates to false.
+    # @return [RubyLint::Node]
     #
-    def on_zsuper
-      return Token::KeywordToken.new(
-        :name   => 'super',
-        :line   => lineno,
-        :column => column,
-        :code   => code(lineno)
+    def on_ifop(statement, true_val, false_val)
+      return Node.new(
+        :ternary,
+        [statement, true_val, false_val],
+        metadata
       )
     end
 
     ##
-    # Called when a call to `super` with parameters is found.
-    #
-    # @param  [Array] params An array of parameters passed to the keyword.
-    # @return [RubyLint::Token::KeywordToken]
+    # @param [RubyLint::Node] statement The statement to evaluate.
+    # @param [Array] body The body of the statement.
+    # @param [Array] list Array containing the rest of the if statement.
+    # @return [RubyLint::Node]
     #
-    def on_super(params)
-      token            = on_zsuper
-      token.parameters = params
+    def on_elsif(statement, body, list)
+      node = Node.new(:elsif, [statement, body], metadata)
+      list = [list] unless list.is_a?(Array)
 
-      return token
+      list << node
     end
 
     ##
-    # Called when a `yield` keyword without parameters is found.
-    #
-    # @return [RubyLint::Token::KeywordToken]
+    # @param [Array|RubyLint::Node] variables The variables to create for each
+    #  iteration.
+    # @param [RubyLint::Node] enumerator The value to iterate over.
+    # @param [Array] body The body of the statement.
+    # @return [RubyLint::Node]
     #
-    def on_yield0
-      return Token::KeywordToken.new(
-        :name   => 'yield',
-        :line   => lineno,
-        :column => column,
-        :code   => code(lineno)
+    def on_for(variables, enumerator, body)
+      variables = [variables] unless variables.is_a?(Array)
+      variables.map! { |n| n.updated(:local_variable) if n.identifier? }
+
+      return Node.new(
+        :for,
+        [variables, enumerator, body],
+        metadata(variables[0])
       )
     end
 
     ##
-    # Called when a `yield` keyword *with* parameters is found.
-    #
-    # @param [Array] params The parameters of the keyword.
+    # @param [Array] exceptions A list of exceptions to catch.
+    # @param [RubyLint::Variable|NilClass] variable The variable to store
+    #  information in about the exception.
+    # @param [Array] body The body of the statement.
+    # @param [Array] list Array containing all the rescue, else and ensure
+    #  statements.
+    # @return [RubyLint::Node]
     #
-    def on_yield(params)
-      token            = on_yield0
-      token.parameters = params
+    def on_rescue(exceptions, variable, body, list)
+      list = list.is_a?(Array) ? list : [list].compact
 
-      return token
-    end
-
-    ##
-    # Called when a variable is referenced.
-    #
-    # @param  [RubyLint::Token::Token] variable The variable that was referenced.
-    # @return [RubyLint::Token::VariableToken]
-    #
-    def on_var_ref(variable)
-      return Token::VariableToken.new(
-        :line   => variable.line,
-        :column => variable.column,
-        :name   => variable.value,
-        :type   => variable.type,
-        :code   => code(variable.line)
-      )
-    end
+      if variable and variable.identifier?
+        variable = variable.updated(:local_variable)
+      end
 
-    ##
-    # Called when a constant path reference is found.
-    #
-    # @param  [Array] segments The path segments.
-    # @return [Array]
-    #
-    def on_const_path_ref(*segments)
-      return Token::VariableToken.new(
-        :name   => segments.map { |t| t.name }.flatten,
-        :type   => :constant_path,
-        :line   => segments[0].line,
-        :column => segments[0].column,
-        :code   => code(segments[-1].line)
+      list.unshift(
+        Node.new(:rescue, [nil, exceptions, variable, body], metadata)
       )
     end
 
     ##
-    # Called when a constant path is assigned.
-    #
-    # @see RubyLint::Parser#on_const_path_ref
-    #
-    def on_const_path_field(*segments)
-      return on_const_path_ref(*segments)
-    end
-
-    ##
-    # Called when a new method is defined.
+    # @param [RubyLint::Node] statement The statement for which to catch
+    #  errors.
+    # @param [RubyLint::Node] body The code to execute when an error was
+    #  raised.
+    # @return [RubyLint::Node]
     #
-    # @param [RubyLint::Token::Token] name Token containing details about the
-    #  method name.
-    # @param [RubyLint::Token::ParametersToken] params Token containing details
-    #  about the method parameters.
-    # @param [Array] body Array containing the tokens of the method's body.
-    # @return [RubyLint::Token::MethodDefinitionToken]
-    #
-    def on_def(name, params, body)
-      body = [body] unless body.is_a?(Array)
-
-      return Token::MethodDefinitionToken.new(
-        :name       => name.value,
-        :line       => name.line,
-        :column     => name.column,
-        :parameters => params,
-        :visibility => @visibility,
-        :value      => body.select { |t| !t.nil? },
-        :code       => code(name.line)
-      )
+    def on_rescue_mod(statement, body)
+      return Node.new(:rescue, [statement, nil, nil, body], metadata)
     end
 
     ##
-    # Called when a method is defined on a specific constant/location
-    # (e.g. `self`).
-    #
-    # @param [RubyLint::Token::Token] receiver The object that the method was
-    #  defined on.
-    # @param [RubyLint::Token::Token] operator The operator that was used to
-    #  separate the receiver and method name.
-    # @param [RubyLint::Token::Token] name The name of the method.
-    # @param [RubyLint::Token::ParametersToken] params The method parameters.
-    # @param [Array] body The body of the method.
-    # @return [RubyLint::Token::MethodDefinitionToken]
+    # @param [RubyLint::Node] statement The statement to evaluate.
+    # @param [Array] body The body of the case block such as all the when
+    #  statements.
+    # @return [RubyLint::Node]
     #
-    def on_defs(receiver, operator, name, params, body)
-      token          = on_def(name, params, body)
-      token.receiver = receiver
-      token.operator = operator
-
-      return token
-    end
+    def on_case(statement, body)
+      when_statements = []
+      else_statement  = nil
 
-    ##
-    # Called when a set of method parameters is found. The order of the `args`
-    # parameter is the following:
-    #
-    # * 0: array of required parameters
-    # * 1: array of optional parameters
-    # * 2: the rest parameter (if any)
-    # * 3: array of "more" parameters (parameters set after the rest parameter)
-    # * 4: the block parameter (if any)
-    #
-    # @param  [Array] args Array containing all the passed method parameters.
-    # @return [RubyLint::Token::ParametersToken]
-    #
-    def on_params(*args)
-      # Convert all the arguments from regular Token instances to VariableToken
-      # instances.
-      args.each_with_index do |arg, index|
-        # Required, optional and more parameters.
-        if arg.is_a?(Array)
-          args[index] = arg.map do |token|
-            value = nil
-
-            if token.is_a?(Array)
-              value = token[1]
-              token = token[0]
-            end
-
-            Token::VariableToken.new(
-              :name   => token.value,
-              :value  => value,
-              :line   => token.line,
-              :column => token.column,
-              :type   => token.type,
-              :code   => code(token.line)
-            )
-          end
-        # Rest and block parameters.
-        elsif !arg.nil?
-          args[index] = Token::VariableToken.new(
-            :name   => arg.value,
-            :line   => arg.line,
-            :column => arg.column,
-            :type   => arg.type,
-            :code   => code(arg.line)
-          )
+      body.each do |node|
+        if node.type == :when
+          when_statements << node
+        else
+          else_statement = node
         end
       end
 
-      return Token::ParametersToken.new(
-        :value    => args[0],
-        :optional => args[1],
-        :rest     => args[2],
-        :more     => args[3],
-        :block    => args[4]
+      return Node.new(
+        :case,
+        [statement, when_statements, else_statement],
+        metadata
       )
     end
 
     ##
-    # Called when a method call using parenthesis is found.
-    #
-    # @param [RubyLint::Token::Token] name The name of the method that was called.
-    # @param [Array] params The parameters of the method call.
-    # @return [RubyLint::Token::MethodToken]
+    # @param [RubyLint::Node|Array] values The values to match on.
+    # @param [RubyLint::Node] body The body of the statement.
+    # @param [RubyLint::Node|Array] list The list of other when and else nodes.
+    # @return [RubyLint::Node]
     #
-    def on_method_add_arg(name, params)
-      if name.class == RubyLint::Token::MethodToken
-        name.parameters = params
+    def on_when(values, body, list)
+      list   = [list].compact unless list.is_a?(Array)
+      values = [values] unless values.is_a?(Array)
 
-        return name
-      end
+      node = Node.new(:when, [values, body], metadata)
 
-      return Token::MethodToken.new(
-        :name       => name.value,
-        :parameters => params,
-        :line       => name.line,
-        :column     => name.column,
-        :code       => code(name.line)
-      )
+      list.unshift(node)
     end
 
     ##
-    # Called when a block is passed to a method call.
+    # @return [RubyLint::Node]
     #
-    # @param [RubyLint::Token::MethodToken] method Token class for the method that
-    #  the block is passed to.
-    # @param [RubyLint::Token::BlockToken] block The block that was passed to the
-    #  method.
-    # @return [RubyLint::Token::MethodToken]
-    #
-    def on_method_add_block(method, block)
-      method.block = block
-
-      return method
+    def on_zsuper
+      return on_super(nil)
     end
 
+    private
+
     ##
-    # Called when a class declaration is found.
+    # Returns a more readable version of a Ripper type name.
     #
-    # @param  [Array|RubyLint::Token::Token] name The name of the class.
-    # @param  [Array|NilClass] parent The name of the parent class.
-    # @param  [Array] body The body of the class.
-    # @return [RubyLint::Token::ClassToken]
+    # @param  [Symbol] type The type to convert.
+    # @return [Symbol]
     #
-    def on_class(name, parent, body)
-      name_segments   = name.name.is_a?(Array) ? name.name : [name.name]
-      parent_segments = []
-
-      if parent
-        parent_segments = parent.name.is_a?(Array) ? parent.name : [parent.name]
-      end
-
-      body = body.is_a?(Array) ? body.flatten.select { |t| !t.nil? } : []
-
-      @visibility = DEFAULT_VISIBILITY
-
-      return Token::ClassToken.new(
-        :name   => name_segments,
-        :parent => parent_segments,
-        :type   => :class,
-        :value  => body,
-        :line   => name.line,
-        :column => name.column,
-        :code   => name.code
-      )
+    def readable_type_name(type)
+      return TYPE_MAPPING.fetch(type, type)
     end
 
     ##
-    # Called when a set of class methods are added using a `class << self`
-    # block.
+    # Returns a Hash containing metadata such as the line number and the file.
     #
-    # @param [RubyLint::Token::VariableToken] receiver The receiver for all the
-    #  methods.
-    # @param  [Array] value The body of the block.
-    # @return [Array]
+    # @param [RubyLint::Node] node When set the line and column number will be
+    #  extracted from this node.
+    # @return [Hash]
     #
-    def on_sclass(receiver, value)
-      value.each_with_index do |token, index|
-        if token.respond_to?(:receiver)
-          token.receiver = receiver
-        end
-
-        value[index] = token
-      end
-
-      return value
-    end
+    def metadata(node = nil)
+      line = node ? node.line   : lineno
+      col  = node ? node.column : column
 
-    ##
-    # Called when a module definition is found.
-    #
-    # @param [RubyLint::Token::Token|Array] name The name of the module, either a
-    #  single token class or an array of token classes.
-    # @param [Array|NilClass] body The body of the module.
-    # @return [RubyLint::Token::Token]
-    #
-    def on_module(name, body)
-      name_segments = name.name.is_a?(Array) ? name.name : [name.name]
-
-      return Token::Token.new(
-        :type   => :module,
-        :name   => name_segments,
-        :value  => body,
-        :line   => name.line,
-        :column => name.column,
-        :code   => name.code
-      )
+      return {:line => line, :column => col, :file => @file}
     end
 
     ##
-    # Called when a method call without parenthesis was found.
+    # Groups a set of parameters into nodes based on the indexes.
     #
-    # @see RubyLint::Parser#on_method_add_arg
+    # @param [Array] nodes
+    # @return [Array]
     #
-    def on_command(name, params)
-      return on_method_add_arg(name, params)
-    end
+    def group_arguments(nodes)
+      new_nodes = []
 
-    ##
-    # Called when a method was invoked on an object.
-    #
-    # @param [RubyLint::Token::Token] receiver The object that the method was
-    #  invoked on.
-    # @param [Symbol] operator The operator that was used to separate the
-    #  receiver and method name.
-    # @param [RubyLint::Token::Token] name Token containing details about the
-    #  method name.
-    # @return [RubyLint::Token::MethodToken]
-    #
-    def on_call(receiver, operator, name)
-      return Token::MethodToken.new(
-        :name     => name.value,
-        :line     => name.line,
-        :column   => name.column,
-        :receiver => receiver,
-        :operator => operator,
-        :code     => code(name.line)
-      )
-    end
+      nodes.each_with_index do |node, index|
+        if !node or (node.is_a?(Array) and node.empty?)
+          next
+        end
 
-    ##
-    # Called when a method was invoked on an object without using parenthesis.
-    #
-    # @see RubyLint::Parser#on_call
-    # @param  [Array] params The parameters passed to the method.
-    # @return [RubyLint::Token::MethodToken]
-    #
-    def on_command_call(receiver, operator, name, params)
-      return Token::MethodToken.new(
-        :name       => name.value,
-        :line       => name.line,
-        :column     => name.column,
-        :receiver   => receiver,
-        :operator   => operator,
-        :parameters => params,
-        :code       => code(name.line)
-      )
-    end
+        new_nodes << convert_argument_node(node, index)
+      end
 
-    private
+      return new_nodes.flatten
+    end
 
     ##
-    # Returns a string containing the code for the specified line number.
+    # Remaps variable/value pairs of optional arguments into single nodes.
     #
-    # @param  [Fixnum|Bignum] line The line number.
-    # @return [String]
+    # @param [Array] nodes
+    # @return [Array]
     #
-    def code(line)
-      return @lines[line - 1]
+    def remap_optional_arguments(nodes)
+      return nodes.map do |node|
+        node[0].updated(nil, [node[0].children[0], node[1]])
+      end
     end
 
     ##
-    # Calculates the column position based on a given line and a stop string.
+    # Converts a parameter node to a type based on its index.
     #
-    # @param [String] line The line of code to use for calculating the column
-    #  number.
-    # @param [String] stop The string that indicates the start of the token.
-    # @return [Fixnum]
+    # @param [RubyLint::Node|Array] node
+    # @param [Numeric] index
+    # @return [Mixed]
     #
-    def calculate_column(line, stop)
-      matches = line.match(/^(.+)#{stop}/)
-      number  = 0
+    def convert_argument_node(node, index)
+      if node.is_a?(Array)
+        node = node.map { |n| convert_argument_node(n, index) }
+      else
+        if node.identifier?
+          node = node.updated(:local_variable)
+        end
 
-      if matches and matches[1]
-        number = matches[1].to_i
+        if node.type != :splat_argument
+          node = Node.new(PARAMETER_INDEX_TYPES[index], [node])
+        end
       end
 
-      return number
+      return node
     end
   end # Parser
 end # RubyLint