riml 0.2.3 → 0.2.4

data/lib/lexer.rb

@@ -225,7 +225,7 @@ module Riml
           @token_buf << [value, value]
         end
         @i += 1
-        if value == ']' || value == ')' && chunk[1, 1] == '.'
+        if value == ']' || value == ')' && (chunk[1, 1] == '.' && chunk[3, 1] != ':')
           parse_dict_vals!
         end
       end
@@ -256,7 +256,7 @@ module Riml
     def parse_dict_vals!
       # dict.key OR dict.key.other_key
       new_chunk = get_new_chunk
-      if vals = new_chunk[/\A\.([\w.]+)/, 1]
+      if vals = new_chunk[/\A\.([\w.]+)(?!:)/, 1]
         parts = vals.split('.')
         @i += vals.size + 1
         if @in_function_declaration

data/lib/nodes.rb

@@ -2,908 +2,918 @@ require File.expand_path('../constants', __FILE__)
 require File.expand_path('../errors', __FILE__)
 require 'set'
 
-module Visitable
-  def accept(visitor)
-    visitor.visit(self)
-  end
+module Riml
+  module Visitable
+    def accept(visitor)
+      visitor.visit(self)
+    end
 
-  attr_accessor :parent_node, :scope, :force_newline
-  alias parent parent_node
-  alias parent= parent_node=
+    attr_accessor :parent_node, :scope, :force_newline
+    alias parent parent_node
+    alias parent= parent_node=
 
-  attr_writer :compiled_output
-  def compiled_output
-    @compiled_output ||= ''
-  end
+    attr_writer :compiled_output
+    def compiled_output
+      @compiled_output ||= ''
+    end
 
-  # catches "descendant_of_#{some_class}?" methods
-  # def descendant_of_call_node?
-  #   CallNode === self.parent_node
-  # end
-  DESCENDANT_OF_REGEX = /\Adescendant_of_(.*?)\?/
-  def method_missing(method, *args, &blk)
-    if method =~ DESCENDANT_OF_REGEX
-      parent_node_name = $1.split('_').map(&:capitalize).join
-      parent_node = self.class.const_get parent_node_name
-      parent_node === self.parent_node
-    else
-      super
+    # catches "descendant_of_#{some_class}?" methods
+    # def descendant_of_call_node?
+    #   CallNode === self.parent_node
+    # end
+    DESCENDANT_OF_REGEX = /\Adescendant_of_(.*?)\?/
+    def method_missing(method, *args, &blk)
+      if method =~ DESCENDANT_OF_REGEX
+        parent_node_name = $1.split('_').map(&:capitalize).join
+        parent_node = Riml.const_get parent_node_name
+        parent_node === self.parent_node
+      else
+        super
+      end
+    end
+    def respond_to?(method, include_private = false)
+      super || method =~ DESCENDANT_OF_REGEX
     end
   end
-  def respond_to?(method, include_private = false)
-    super || method =~ DESCENDANT_OF_REGEX
-  end
-end
 
-module Walkable
-  include Enumerable
+  module Walkable
+    include Enumerable
 
-  def each(&block)
-    children.each(&block)
-  end
-  alias walk each
+    def each(&block)
+      children.each(&block)
+    end
+    alias walk each
 
-  def previous
-    idx = index
-    return unless idx
-    parent.children.fetch(idx - 1)
-  end
+    def previous
+      idx = index
+      return unless idx
+      parent.children.fetch(idx - 1)
+    end
 
-  def child_previous_to(node)
-    idx = children.find_index(node)
-    return unless idx
-    children.fetch(idx - 1)
-  end
+    def child_previous_to(node)
+      idx = children.find_index(node)
+      return unless idx
+      children.fetch(idx - 1)
+    end
 
-  def insert_before(node, new_node)
-    idx = children.find_index(node)
-    return unless idx
-    children.insert(idx-1, new_node)
-  end
+    def insert_before(node, new_node)
+      idx = children.find_index(node)
+      return unless idx
+      children.insert(idx-1, new_node)
+    end
 
-  def next
-    idx = index
-    return unless idx
-    parent.children.fetch(idx + 1)
-  end
+    def next
+      idx = index
+      return unless idx
+      parent.children.fetch(idx + 1)
+    end
 
-  def child_after(node)
-    idx = children.find_index(node)
-    return unless idx
-    children.fetch(idx + 1)
-  end
+    def child_after(node)
+      idx = children.find_index(node)
+      return unless idx
+      children.fetch(idx + 1)
+    end
 
-  def insert_after(node, new_node)
-    idx = children.find_index(node)
-    return unless idx
-    children.insert(idx+1, new_node)
-  end
+    def insert_after(node, new_node)
+      idx = children.find_index(node)
+      return unless idx
+      children.insert(idx+1, new_node)
+    end
 
-  def index
-    parent.children.find_index(self)
-  end
+    def index
+      parent.children.find_index(self)
+    end
 
-  def remove
-    idx = index
-    parent.children.slice!(idx) if idx
-  end
+    def remove
+      idx = index
+      parent.children.slice!(idx) if idx
+    end
 
-  def replace_with(new_node)
-    idx = index
-    return unless idx
-    parent.children.insert(idx, new_node)
-    parent.children.slice!(idx+1)
-    new_node
+    def replace_with(new_node)
+      idx = index
+      return unless idx
+      parent.children.insert(idx, new_node)
+      parent.children.slice!(idx+1)
+      new_node
+    end
   end
-end
 
-module Indentable
-  def indent
-    @indent ||= ' ' * 2
-  end
-  def indented?
-    indent.size > 0
-  end
-  def outdent
-    size = indent.size
-    return '' unless size > 0
-    ' ' * (size - 2)
+  module Indentable
+    def indent
+      @indent ||= ' ' * 2
+    end
+    def indented?
+      indent.size > 0
+    end
+    def outdent
+      size = indent.size
+      return '' unless size > 0
+      ' ' * (size - 2)
+    end
   end
-end
 
-module NotNestedUnder
-  def non_nested?(klass = not_nested_under_class)
-    n = self
-    while (n = n.parent) != nil
-      return false if n.is_a?(klass)
+  module NotNestedUnder
+    def non_nested?(klass = not_nested_under_class)
+      n = self
+      while (n = n.parent) != nil
+        return false if n.is_a?(klass)
+      end
+      true
     end
-    true
-  end
 
-  # override if applicable
-  def not_nested_under_class
-    self.class
+    # override if applicable
+    def not_nested_under_class
+      self.class
+    end
   end
-end
 
-# Collection of nodes each one representing an expression.
-class Nodes < Struct.new(:nodes)
-  include Visitable
-  include Walkable
+  # Collection of nodes each one representing an expression.
+  class Nodes < Struct.new(:nodes)
+    include Visitable
+    include Walkable
 
-  def <<(node)
-    nodes << node
-    self
-  end
+    def <<(node)
+      nodes << node
+      self
+    end
 
-  def [](idx)
-    nodes[idx]
-  end
+    def [](idx)
+      nodes[idx]
+    end
 
-  def concat(list_of_nodes)
-    nodes.concat(list_of_nodes)
-    self
-  end
+    def concat(list_of_nodes)
+      nodes.concat(list_of_nodes)
+      self
+    end
 
-  # forward missing methods to `nodes` array
-  def method_missing(method, *args, &block)
-    if nodes.respond_to?(method)
-      nodes.send(method, *args, &block)
-    else
-      super
+    # forward missing methods to `nodes` array
+    def method_missing(method, *args, &block)
+      if nodes.respond_to?(method)
+        nodes.send(method, *args, &block)
+      else
+        super
+      end
     end
-  end
 
-  def respond_to?(method, include_private = false)
-    super || nodes.respond_to?(method, include_private)
-  end
+    def respond_to?(method, include_private = false)
+      super || nodes.respond_to?(method, include_private)
+    end
 
-  def children
-    nodes
+    def children
+      nodes
+    end
   end
-end
 
-class SublistNode < Nodes; end
+  class SublistNode < Nodes; end
 
-# Literals are static values that have a Ruby representation, eg.: a string, number, list,
-# true, false, nil, etc.
-class LiteralNode < Struct.new(:value)
-  include Visitable
-end
+  # Literals are static values that have a Ruby representation, eg.: a string, number, list,
+  # true, false, nil, etc.
+  class LiteralNode < Struct.new(:value)
+    include Visitable
+  end
 
-class KeywordNode < Struct.new(:value)
-  include Visitable
-end
+  class KeywordNode < Struct.new(:value)
+    include Visitable
+  end
 
-class NumberNode < LiteralNode; end
+  class NumberNode < LiteralNode; end
 
-class StringNode < Struct.new(:value, :type) # type: :d or :s for double- or single-quoted
-  include Visitable
-end
+  class StringNode < Struct.new(:value, :type) # type: :d or :s for double- or single-quoted
+    include Visitable
+  end
 
-class StringLiteralConcatNode < Struct.new(:string_nodes)
-  include Visitable
-  include Walkable
+  class StringLiteralConcatNode < Struct.new(:string_nodes)
+    include Visitable
+    include Walkable
 
-  def initialize(*string_nodes)
-    super(string_nodes)
-  end
-  alias nodes string_nodes
+    def initialize(*string_nodes)
+      super(string_nodes)
+    end
+    alias nodes string_nodes
 
-  def children
-    string_nodes
+    def children
+      string_nodes
+    end
   end
-end
 
-class RegexpNode < LiteralNode; end
+  class RegexpNode < LiteralNode; end
 
-class ListNode < LiteralNode
-  include Walkable
-  def self.wrap(value)
-    val = Array === value ? value : [value]
-    new(val)
-  end
+  class ListNode < LiteralNode
+    include Walkable
+    def self.wrap(value)
+      val = Array === value ? value : [value]
+      new(val)
+    end
 
-  def children
-    value
+    def children
+      value
+    end
   end
-end
 
-class ListUnpackNode < ListNode
-  def rest
-    value.last
+  class ListUnpackNode < ListNode
+    def rest
+      value.last
+    end
   end
-end
 
-class DictionaryNode < LiteralNode; end
-class ScopeModifierLiteralNode < LiteralNode; end
+  class DictionaryNode < LiteralNode; end
+  class ScopeModifierLiteralNode < LiteralNode; end
 
-class TrueNode < LiteralNode
-  def initialize() super(true) end
-end
+  class TrueNode < LiteralNode
+    def initialize() super(true) end
+  end
 
-class FalseNode < LiteralNode
-  def initialize() super(false) end
-end
+  class FalseNode < LiteralNode
+    def initialize() super(false) end
+  end
 
-class NilNode < LiteralNode
-  def initialize() super(nil) end
-end
+  class NilNode < LiteralNode
+    def initialize() super(nil) end
+  end
 
-class NewlineNode < LiteralNode
-  def initialize() super("\n") end
-end
+  class NewlineNode < LiteralNode
+    def initialize() super("\n") end
+  end
 
-class ExLiteralNode < LiteralNode
-  def initialize(*)
-    super
-    self.force_newline = true
+  class ExLiteralNode < LiteralNode
+    def initialize(*)
+      super
+      self.force_newline = true
+    end
   end
-end
 
-class FinishNode < KeywordNode
-  def initialize() super("finish\n") end
-end
+  class FinishNode < KeywordNode
+    def initialize() super("finish\n") end
+  end
 
-class BreakNode < KeywordNode
-  def initialize() super("break\n") end
-end
+  class BreakNode < KeywordNode
+    def initialize() super("break\n") end
+  end
 
-class ContinueNode < KeywordNode
-  def initialize() super("continue\n") end
-end
+  class ContinueNode < KeywordNode
+    def initialize() super("continue\n") end
+  end
 
-class ReturnNode < Struct.new(:expression)
-  include Visitable
-  include Walkable
+  class ReturnNode < Struct.new(:expression)
+    include Visitable
+    include Walkable
 
-  def children
-    [expression]
+    def children
+      [expression]
+    end
   end
-end
 
-class WrapInParensNode < Struct.new(:expression)
-  include Visitable
-  include Walkable
+  class WrapInParensNode < Struct.new(:expression)
+    include Visitable
+    include Walkable
 
-  def children
-    [expression]
+    def children
+      [expression]
+    end
   end
-end
 
-module FullyNameable
-  def self.included(base)
-    base.class_eval do
-      raise "#{base} must define method 'name'" unless method_defined?(:name)
+  module FullyNameable
+    def self.included(base)
+      base.class_eval do
+        raise "#{base} must define method 'name'" unless method_defined?(:name)
+      end
     end
-  end
 
-  def full_name
-    if respond_to?(:scope_modifier)
-      "#{scope_modifier}#{name}"
-    elsif respond_to?(:prefix)
-      "#{prefix}#{name}"
+    def full_name
+      if respond_to?(:scope_modifier)
+        "#{scope_modifier}#{name}"
+      elsif respond_to?(:prefix)
+        "#{prefix}#{name}"
+      end
     end
   end
-end
 
-# Node of a method call, can take any of these forms:
-#
-#   Method()
-#   s:Method(argument1, argument2)
-class CallNode < Struct.new(:scope_modifier, :name, :arguments)
-  include Riml::Constants
-  include Visitable
-  include FullyNameable
-  include Walkable
+  # Node of a method call, can take any of these forms:
+  #
+  #   Method()
+  #   s:Method(argument1, argument2)
+  class CallNode < Struct.new(:scope_modifier, :name, :arguments)
+    include Riml::Constants
+    include Visitable
+    include FullyNameable
+    include Walkable
 
-  ALL_BUILTIN_FUNCTIONS = BUILTIN_FUNCTIONS + BUILTIN_COMMANDS
-  ALL_BUILTIN_COMMANDS  = BUILTIN_COMMANDS  + RIML_COMMANDS + VIML_COMMANDS
+    ALL_BUILTIN_FUNCTIONS = BUILTIN_FUNCTIONS + BUILTIN_COMMANDS
+    ALL_BUILTIN_COMMANDS  = BUILTIN_COMMANDS  + RIML_COMMANDS + VIML_COMMANDS
 
-  def initialize(scope_modifier, name, arguments)
-    super
-    remove_parens_wrapper if builtin_command?
-  end
+    def initialize(scope_modifier, name, arguments)
+      super
+      remove_parens_wrapper if builtin_command?
+    end
 
-  # TODO: find way to remove this hack
-  def remove_parens_wrapper
-    return unless WrapInParensNode === arguments.first
-    arguments[0] = arguments[0].expression
-  end
+    # TODO: find way to remove this hack
+    def remove_parens_wrapper
+      return unless WrapInParensNode === arguments.first
+      arguments[0] = arguments[0].expression
+    end
 
-  def builtin_function?
-    return false unless name.is_a?(String)
-    scope_modifier.nil? and ALL_BUILTIN_FUNCTIONS.include?(name)
-  end
+    def builtin_function?
+      return false unless name.is_a?(String)
+      scope_modifier.nil? and ALL_BUILTIN_FUNCTIONS.include?(name)
+    end
 
-  def builtin_command?
-    return false unless name.is_a?(String)
-    scope_modifier.nil? and ALL_BUILTIN_COMMANDS.include?(name)
-  end
+    def builtin_command?
+      return false unless name.is_a?(String)
+      scope_modifier.nil? and ALL_BUILTIN_COMMANDS.include?(name)
+    end
 
-  def must_be_explicit_call?
-    return false if builtin_command?
-    return true  if parent.instance_of?(Nodes)
-    false
-  end
+    def must_be_explicit_call?
+      return false if builtin_command?
+      return true  if parent.instance_of?(Nodes)
+      false
+    end
 
-  def autoload?
-    name.include?('#')
-  end
+    def autoload?
+      name.include?('#')
+    end
 
-  def children
-    if name.is_a?(String)
-      arguments
-    else
-      [name] + arguments
+    def children
+      if name.is_a?(String)
+        arguments
+      else
+        [name] + arguments
+      end
     end
   end
-end
 
-# Node of an explicitly called method, can take any of these forms:
-#
-#   call Method()
-#   call s:Method(argument1, argument2)
-class ExplicitCallNode < CallNode; end
-class RimlCommandNode  < CallNode
+  # Node of an explicitly called method, can take any of these forms:
+  #
+  #   call Method()
+  #   call s:Method(argument1, argument2)
+  class ExplicitCallNode < CallNode; end
+  class RimlCommandNode  < CallNode
 
-  def initialize(*)
-    super
-    if arguments.empty? || !arguments.all? { |arg| arg.is_a?(StringNode) }
-      raise Riml::UserArgumentError, "#{name.inspect} error: must pass string(s) (name of file(s))"
+    def initialize(*)
+      super
+      if arguments.empty? || !arguments.all? { |arg| arg.is_a?(StringNode) }
+        raise Riml::UserArgumentError, "#{name.inspect} error: must pass string(s) (name of file(s))"
+      end
     end
-  end
 
-  def each_existing_file!
-    files = []
-    arguments.map(&:value).each do |file|
-      if File.exists?(File.join(Riml.source_path, file))
-        files << file
-      else
-        raise Riml::FileNotFound, "#{file.inspect} could not be found in " \
-          "source path (#{Riml.source_path.inspect})"
+    def each_existing_file!
+      files = []
+      arguments.map(&:value).each do |file|
+        if File.exists?(File.join(Riml.source_path, file))
+          files << file
+        else
+          raise Riml::FileNotFound, "#{file.inspect} could not be found in " \
+            "source path (#{Riml.source_path.inspect})"
+        end
       end
-    end
-    return unless block_given?
-    # all files exist
-    files.each do |f|
-      begin
-        yield f
-      rescue Riml::IncludeFileLoop
-        arguments.delete_if { |arg| arg.value == f }
+      return unless block_given?
+      # all files exist
+      files.each do |f|
+        begin
+          yield f
+        rescue Riml::IncludeFileLoop
+          arguments.delete_if { |arg| arg.value == f }
+        end
       end
     end
   end
-end
 
-class OperatorNode < Struct.new(:operator, :operands)
-  include Visitable
-  include Walkable
+  class OperatorNode < Struct.new(:operator, :operands)
+    include Visitable
+    include Walkable
 
-  def children
-    operands
+    def children
+      operands
+    end
   end
-end
 
-class BinaryOperatorNode < OperatorNode
-  include Riml::Constants
+  class BinaryOperatorNode < OperatorNode
+    include Riml::Constants
 
-  def operand1() operands[0] end
-  def operand1=(val) operands[0] = val end
+    def operand1() operands[0] end
+    def operand1=(val) operands[0] = val end
 
-  def operand2() operands[1] end
-  def operand2=(val) operands[1] = val end
+    def operand2() operands[1] end
+    def operand2=(val) operands[1] = val end
 
-  def ignorecase_capable_operator?(operator)
-    IGNORECASE_CAPABLE_OPERATORS.include?(operator)
+    def ignorecase_capable_operator?(operator)
+      IGNORECASE_CAPABLE_OPERATORS.include?(operator)
+    end
   end
-end
 
-class UnaryOperatorNode < OperatorNode
-  alias operand operands
-end
-
-# operator = :ternary
-# operands = [condition, if_expr, else_expr]
-class TernaryOperatorNode < OperatorNode
-  def initialize(operands, operator=:ternary)
-    super(operator, operands)
+  class UnaryOperatorNode < OperatorNode
+    alias operand operands
   end
 
-  def condition() operands[0] end
+  # operator = :ternary
+  # operands = [condition, if_expr, else_expr]
+  class TernaryOperatorNode < OperatorNode
+    def initialize(operands, operator=:ternary)
+      super(operator, operands)
+    end
 
-  def if_expr() operands[1] end
+    def condition() operands[0] end
 
-  def else_expr() operands[2] end
-end
+    def if_expr() operands[1] end
+
+    def else_expr() operands[2] end
+  end
 
-# let var = 2
-# let s:var = 4
-class AssignNode < Struct.new(:operator, :lhs, :rhs)
-  include Visitable
-  include Walkable
+  # let var = 2
+  # let s:var = 4
+  class AssignNode < Struct.new(:operator, :lhs, :rhs)
+    include Visitable
+    include Walkable
 
-  def children
-    [lhs, rhs]
+    def children
+      [lhs, rhs]
+    end
   end
-end
 
-module QuestionVariableExistence
-  def self.included(base)
-    base.class_eval do
-      raise "#{base} must define method 'name'" unless method_defined?(:name)
-      alias name_with_question_mark name
-      def name_without_question_mark
-        if question_existence?
-          name_with_question_mark[0...-1]
-        else
-          name_with_question_mark
+  module QuestionVariableExistence
+    def self.included(base)
+      base.class_eval do
+        raise "#{base} must define method 'name'" unless method_defined?(:name)
+        alias name_with_question_mark name
+        def name_without_question_mark
+          if question_existence?
+            name_with_question_mark[0...-1]
+          else
+            name_with_question_mark
+          end
         end
+        alias name name_without_question_mark
       end
-      alias name name_without_question_mark
     end
-  end
 
-  def question_existence?
-    name_with_question_mark[-1] == ??
+    def question_existence?
+      name_with_question_mark[-1] == ??
+    end
   end
-end
 
-# s:var
-# var
-class GetVariableNode < Struct.new(:scope_modifier, :name)
-  include Visitable
-  include FullyNameable
-  include QuestionVariableExistence
-end
+  # s:var
+  # var
+  class GetVariableNode < Struct.new(:scope_modifier, :name)
+    include Visitable
+    include FullyNameable
+    include QuestionVariableExistence
+  end
 
-# &autoindent
-# @q
-class GetSpecialVariableNode < Struct.new(:prefix, :name)
-  include Visitable
-  include FullyNameable
-end
+  # &autoindent
+  # @q
+  class GetSpecialVariableNode < Struct.new(:prefix, :name)
+    include Visitable
+    include FullyNameable
+  end
 
-class GetCurlyBraceNameNode < Struct.new(:scope_modifier, :variable)
-  include Visitable
-  include Walkable
+  class GetCurlyBraceNameNode < Struct.new(:scope_modifier, :variable)
+    include Visitable
+    include Walkable
 
-  def children
-    [variable]
+    def children
+      [variable]
+    end
   end
-end
 
-class CurlyBraceVariable < Struct.new(:parts)
-  include Visitable
-  include Walkable
+  class CurlyBraceVariable < Struct.new(:parts)
+    include Visitable
+    include Walkable
 
-  def <<(part)
-    parts << part
-    self
-  end
+    def <<(part)
+      parts << part
+      self
+    end
 
-  def children
-    parts
+    def children
+      parts
+    end
   end
-end
 
-class CurlyBracePart < Struct.new(:value)
-  include Visitable
-  include Walkable
+  class CurlyBracePart < Struct.new(:value)
+    include Visitable
+    include Walkable
 
-  def interpolated?
-    GetVariableNode === value || GetSpecialVariableNode === value || nested?
-  end
+    def interpolated?
+      GetVariableNode === value || GetSpecialVariableNode === value || nested?
+    end
 
-  def nested?
-    value.is_a?(Array) && value.detect {|part| part.is_a?(CurlyBracePart)}
-  end
+    def nested?
+      value.is_a?(Array) && value.detect {|part| part.is_a?(CurlyBracePart)}
+    end
 
-  def children
-    return [] unless interpolated?
-    return value if nested?
-    [value]
+    def children
+      return [] unless interpolated?
+      return value if nested?
+      [value]
+    end
   end
-end
 
-class UnletVariableNode < Struct.new(:bang, :variables)
-  include Visitable
-  include Walkable
+  class UnletVariableNode < Struct.new(:bang, :variables)
+    include Visitable
+    include Walkable
 
-  def <<(variable)
-    variables << variable
-    self
-  end
+    def <<(variable)
+      variables << variable
+      self
+    end
 
-  def children
-    variables
+    def children
+      variables
+    end
   end
-end
 
-# Method definition.
-class DefNode < Struct.new(:bang, :scope_modifier, :name, :parameters, :keywords, :expressions)
-  include Visitable
-  include Indentable
-  include FullyNameable
-  include Walkable
+  # Method definition.
+  class DefNode < Struct.new(:bang, :scope_modifier, :name, :parameters, :keywords, :expressions)
+    include Visitable
+    include Indentable
+    include FullyNameable
+    include Walkable
 
-  def initialize(*args)
-    super
-    # max number of arguments in viml
-    if parameters.reject(&DEFAULT_PARAMS).size > 20
-      raise Riml::UserArgumentError, "can't have more than 20 parameters for #{full_name}"
+    def initialize(*args)
+      super
+      # max number of arguments in viml
+      if parameters.reject(&DEFAULT_PARAMS).size > 20
+        raise Riml::UserArgumentError, "can't have more than 20 parameters for #{full_name}"
+      end
+      expressions.nodes.select { |node| DefNode === node}.each do |nested_func|
+        nested_func.nested_within.unshift(self)
+      end
     end
-    expressions.nodes.select { |node| DefNode === node}.each do |nested_func|
-      nested_func.nested_within.unshift(self)
+
+    SPLAT = lambda {|arg| arg == Riml::Constants::SPLAT_LITERAL || arg[0] == "*"}
+    DEFAULT_PARAMS = lambda {|p| DefaultParamNode === p}
+
+    def original_name
+      @original_name ||= name
     end
-  end
+    attr_writer :original_name
 
-  SPLAT = lambda {|arg| arg == Riml::Constants::SPLAT_LITERAL || arg[0] == "*"}
-  DEFAULT_PARAMS = lambda {|p| DefaultParamNode === p}
+    # ["arg1", "arg2"}
+    def argument_variable_names
+      parameters.reject(&SPLAT)
+    end
 
-  def original_name
-    @original_name ||= name
-  end
-  attr_writer :original_name
+    def shadowed_argument?(var_name)
+      shadowed_argument_variable_names.include?(var_name)
+    end
 
-  # ["arg1", "arg2"}
-  def argument_variable_names
-    parameters.reject(&SPLAT)
-  end
+    def shadowed_argument_variable_names
+      @shadowed_argument_variable_names ||= Set.new
+    end
 
-  def nested_within
-    @nested_within ||= []
-  end
+    def nested_within
+      @nested_within ||= []
+    end
 
-  def nested_function?
-    not nested_within.empty?
-  end
+    def nested_function?
+      not nested_within.empty?
+    end
 
-  # returns the splat argument or nil
-  def splat
-    parameters.detect(&SPLAT)
-  end
+    # returns the splat argument or nil
+    def splat
+      parameters.detect(&SPLAT)
+    end
 
-  def keywords
-    if name.include?('.')
-      (super.to_a + ['dict']).uniq
-    else
-      super.to_a
+    def keywords
+      if name.include?('.')
+        (super.to_a + ['dict']).uniq
+      else
+        super.to_a
+      end
     end
-  end
 
-  def defined_on_dictionary?
-    keywords.include?('dict')
-  end
+    def defined_on_dictionary?
+      keywords.include?('dict')
+    end
 
-  def autoload?
-    name.include?('#')
-  end
+    def autoload?
+      name.include?('#')
+    end
 
-  def super_node
-    expressions.nodes.detect {|n| SuperNode === n}
-  end
+    def super_node
+      expressions.nodes.detect {|n| SuperNode === n}
+    end
 
-  def to_scope
-    ScopeNode.new.tap do |scope|
-      scope.argument_variable_names += argument_variable_names
-      scope.function = self
+    def to_scope
+      ScopeNode.new.tap do |scope|
+        scope.argument_variable_names += argument_variable_names
+        scope.function = self
+      end
     end
-  end
 
-  def default_param_nodes
-    parameters.select(&DEFAULT_PARAMS)
-  end
+    def default_param_nodes
+      parameters.select(&DEFAULT_PARAMS)
+    end
 
-  def children
-    children = [expressions]
-    children.concat(default_param_nodes)
-  end
+    def children
+      children = [expressions]
+      children.concat(default_param_nodes)
+    end
 
-  def method_missing(method, *args, &blk)
-    if children.respond_to?(method)
-      children.send(method, *args, &blk)
-    else
-      super
+    def method_missing(method, *args, &blk)
+      if children.respond_to?(method)
+        children.send(method, *args, &blk)
+      else
+        super
+      end
     end
   end
-end
 
-class DefaultParamNode < Struct.new(:parameter, :expression)
-  include Visitable
-  include Walkable
+  class DefaultParamNode < Struct.new(:parameter, :expression)
+    include Visitable
+    include Walkable
 
-  def children
-    [parameter, expression]
+    def children
+      [parameter, expression]
+    end
   end
-end
 
-class ScopeNode
-  attr_writer :for_node_variable_names, :argument_variable_names
-  attr_accessor :function
+  class ScopeNode
+    attr_writer :for_node_variable_names, :argument_variable_names
+    attr_accessor :function
 
-  def for_node_variable_names
-    @for_node_variable_names ||= Set.new
-  end
+    def for_node_variable_names
+      @for_node_variable_names ||= Set.new
+    end
 
-  def argument_variable_names
-    @argument_variable_names ||= Set.new
-  end
+    def argument_variable_names
+      @argument_variable_names ||= Set.new
+    end
 
-  alias function? function
+    alias function? function
 
-  def initialize_copy(source)
-    super
-    self.for_node_variable_names = for_node_variable_names.dup
-    self.argument_variable_names = argument_variable_names.dup
-    self.function = source.function
-  end
+    def initialize_copy(source)
+      super
+      self.for_node_variable_names = for_node_variable_names.dup
+      self.argument_variable_names = argument_variable_names.dup
+      self.function = source.function
+    end
 
-  def merge(other)
-    dup.merge! other
-  end
+    def merge(other)
+      dup.merge! other
+    end
 
-  def merge!(other)
-    unless other.is_a?(ScopeNode)
-      raise ArgumentError, "other must be ScopeNode, is #{other.class}"
+    def merge!(other)
+      unless other.is_a?(ScopeNode)
+        raise ArgumentError, "other must be ScopeNode, is #{other.class}"
+      end
+      self.for_node_variable_names += other.for_node_variable_names
+      self.argument_variable_names -= for_node_variable_names
+      self.function = other.function
+      self
     end
-    self.for_node_variable_names += other.for_node_variable_names
-    self.argument_variable_names -= for_node_variable_names
-    self.function = other.function
-    self
   end
-end
 
-class DefMethodNode < DefNode
-  def to_def_node
-    def_node = DefNode.new(bang, 'g:', name, parameters, ['dict'], expressions)
-    def_node.parent = parent
-    def_node
+  class DefMethodNode < DefNode
+    def to_def_node
+      def_node = DefNode.new(bang, 'g:', name, parameters, ['dict'], expressions)
+      def_node.parent = parent
+      def_node
+    end
   end
-end
 
-# abstract control structure
-class ControlStructure < Struct.new(:condition, :body)
-  include Visitable
-  include Indentable
-  include Walkable
+  # abstract control structure
+  class ControlStructure < Struct.new(:condition, :body)
+    include Visitable
+    include Indentable
+    include Walkable
 
-  def children
-    [condition, body]
-  end
+    def children
+      [condition, body]
+    end
 
-  def wrap_condition_in_parens!
-    return if WrapInParensNode === condition
-    _parent = condition.parent
-    self.condition = WrapInParensNode.new(condition)
-    self.condition.parent = _parent
+    def wrap_condition_in_parens!
+      return if WrapInParensNode === condition
+      _parent = condition.parent
+      self.condition = WrapInParensNode.new(condition)
+      self.condition.parent = _parent
+    end
   end
-end
 
-class IfNode < ControlStructure
-  include NotNestedUnder
-end
-class WhileNode < ControlStructure; end
+  class IfNode < ControlStructure
+    include NotNestedUnder
+  end
+  class WhileNode < ControlStructure; end
 
-class UnlessNode < ControlStructure
-  def initialize(*)
-    super
-    wrap_condition_in_parens!
+  class UnlessNode < ControlStructure
+    def initialize(*)
+      super
+      wrap_condition_in_parens!
+    end
   end
-end
-class UntilNode < ControlStructure
-  def initialize(*)
-    super
-    wrap_condition_in_parens!
+  class UntilNode < ControlStructure
+    def initialize(*)
+      super
+      wrap_condition_in_parens!
+    end
   end
-end
 
-class ElseNode < Struct.new(:expressions)
-  include Visitable
-  include Walkable
-  alias body expressions
+  class ElseNode < Struct.new(:expressions)
+    include Visitable
+    include Walkable
+    alias body expressions
 
-  def <<(expr)
-    expressions << expr
-    self
-  end
+    def <<(expr)
+      expressions << expr
+      self
+    end
 
-  def pop
-    expressions.pop
-  end
+    def pop
+      expressions.pop
+    end
 
-  def last
-    expressions.last
-  end
+    def last
+      expressions.last
+    end
 
-  def children
-    [expressions]
+    def children
+      [expressions]
+    end
   end
-end
 
-class ElseifNode < ControlStructure
-  include Visitable
-  include Walkable
-  alias expressions body
+  class ElseifNode < ControlStructure
+    include Visitable
+    include Walkable
+    alias expressions body
 
-  def <<(expr)
-    expressions << expr
-    self
-  end
+    def <<(expr)
+      expressions << expr
+      self
+    end
 
-  def pop
-    expressions.pop
-  end
+    def pop
+      expressions.pop
+    end
 
-  def last
-    expressions.last
-  end
+    def last
+      expressions.last
+    end
 
-  def children
-    [expressions]
+    def children
+      [expressions]
+    end
   end
-end
 
-# for variable in someFunction(1,2,3)
-#   echo variable
-# end
-#
-# OR
-#
-# for variable in [1,2,3]
-#   echo variable
-# end
-class ForNode < Struct.new(:variable, :in_expression, :expressions)
-  include Visitable
-  include Indentable
-  include Walkable
-
-  alias for_variable variable
-
-  def variables
-    variable if ListNode === variable
-  end
-
-  def for_node_variable_names
-    if ListNode === variable
-      variable.value.map(&:name)
-    else
-      [variable]
+  # for variable in someFunction(1,2,3)
+  #   echo variable
+  # end
+  #
+  # OR
+  #
+  # for variable in [1,2,3]
+  #   echo variable
+  # end
+  class ForNode < Struct.new(:variable, :in_expression, :expressions)
+    include Visitable
+    include Indentable
+    include Walkable
+
+    alias for_variable variable
+
+    def variables
+      variable if ListNode === variable
     end
-  end
 
-  def to_scope
-    ScopeNode.new.tap {|s| s.for_node_variable_names += for_node_variable_names}
-  end
+    def for_node_variable_names
+      if ListNode === variable
+        variable.value.map(&:name)
+      else
+        [variable]
+      end
+    end
 
-  def children
-    [variable, in_expression, expressions]
+    def to_scope
+      ScopeNode.new.tap {|s| s.for_node_variable_names += for_node_variable_names}
+    end
+
+    def children
+      [variable, in_expression, expressions]
+    end
   end
-end
 
-class DictGetNode < Struct.new(:dict, :keys)
-  include Visitable
-  include Walkable
+  class DictGetNode < Struct.new(:dict, :keys)
+    include Visitable
+    include Walkable
 
-  def children
-    [dict] + keys
+    def children
+      [dict] + keys
+    end
   end
-end
 
-# dict['key']
-# dict['key1']['key2']
-class DictGetBracketNode < DictGetNode; end
+  # dict['key']
+  # dict['key1']['key2']
+  class DictGetBracketNode < DictGetNode; end
 
-# dict.key
-# dict.key.key2
-class DictGetDotNode < DictGetNode; end
+  # dict.key
+  # dict.key.key2
+  class DictGetDotNode < DictGetNode; end
 
 
-# list_or_dict[0]
-# function()[identifier]
-class ListOrDictGetNode < Struct.new(:list_or_dict, :keys)
-  include Visitable
-  include Walkable
+  # list_or_dict[0]
+  # function()[identifier]
+  class ListOrDictGetNode < Struct.new(:list_or_dict, :keys)
+    include Visitable
+    include Walkable
 
-  alias list list_or_dict
-  alias dict list_or_dict
-  def children
-    [list_or_dict] + keys
+    alias list list_or_dict
+    alias dict list_or_dict
+    def children
+      [list_or_dict] + keys
+    end
   end
-end
 
-class GetVariableByScopeAndDictNameNode < Struct.new(:scope_modifier, :keys)
-  include Visitable
-  include Walkable
+  class GetVariableByScopeAndDictNameNode < Struct.new(:scope_modifier, :keys)
+    include Visitable
+    include Walkable
 
-  def children
-    [scope_modifier] + keys
+    def children
+      [scope_modifier] + keys
+    end
   end
-end
 
-class TryNode < Struct.new(:try_block, :catch_nodes, :finally_block)
-  include Visitable
-  include Indentable
-  include Walkable
+  class TryNode < Struct.new(:try_block, :catch_nodes, :finally_block)
+    include Visitable
+    include Indentable
+    include Walkable
 
-  def children
-    [try_block] + catch_nodes.to_a + [finally_block].compact
+    def children
+      [try_block] + catch_nodes.to_a + [finally_block].compact
+    end
   end
-end
 
-class CatchNode < Struct.new(:regexp, :expressions)
-  include Visitable
-  include Walkable
-  include NotNestedUnder
+  class CatchNode < Struct.new(:regexp, :expressions)
+    include Visitable
+    include Walkable
+    include NotNestedUnder
 
-  def children
-    [expressions]
-  end
+    def children
+      [expressions]
+    end
 
-end
+  end
 
-class ClassDefinitionNode < Struct.new(:name, :superclass_name, :expressions)
-  include Visitable
-  include Walkable
+  class ClassDefinitionNode < Struct.new(:name, :superclass_name, :expressions)
+    include Visitable
+    include Walkable
 
-  FUNCTIONS = lambda {|expr| DefNode === expr}
+    FUNCTIONS = lambda {|expr| DefNode === expr}
 
-  def superclass?
-    not superclass_name.nil?
-  end
+    def superclass?
+      not superclass_name.nil?
+    end
 
-  def constructor
-    expressions.nodes.detect do |n|
-      next(false) unless DefNode === n && (n.name == 'initialize' || n.name == constructor_name)
-      if n.instance_of?(DefMethodNode)
-        Riml.warn("class #{name.inspect} has an initialize function declared with 'defm'. Please use 'def'.")
-        new_node = n.to_def_node
-        new_node.keywords = nil
-        n.replace_with(new_node)
+    def constructor
+      expressions.nodes.detect do |n|
+        next(false) unless DefNode === n && (n.name == 'initialize' || n.name == constructor_name)
+        if n.instance_of?(DefMethodNode)
+          Riml.warn("class #{name.inspect} has an initialize function declared with 'defm'. Please use 'def'.")
+          new_node = n.to_def_node
+          new_node.keywords = nil
+          n.replace_with(new_node)
+        end
+        true
       end
-      true
     end
-  end
-  alias constructor? constructor
+    alias constructor? constructor
 
-  def find_function(scope_modifier, name)
-    expressions.nodes.select(&FUNCTIONS).detect do |def_node|
-      def_node.name == name && def_node.scope_modifier == scope_modifier
+    def find_function(scope_modifier, name)
+      expressions.nodes.select(&FUNCTIONS).detect do |def_node|
+        def_node.name == name && def_node.scope_modifier == scope_modifier
+      end
     end
-  end
-  alias has_function? find_function
+    alias has_function? find_function
 
-  def constructor_name
-    "#{name}Constructor"
-  end
+    def constructor_name
+      "#{name}Constructor"
+    end
 
-  def constructor_obj_name
-    name[0].downcase + name[1..-1] + "Obj"
-  end
+    def constructor_obj_name
+      name[0].downcase + name[1..-1] + "Obj"
+    end
 
-  def children
-    [expressions]
+    def children
+      [expressions]
+    end
   end
-end
 
-class SuperNode < Struct.new(:arguments, :with_parens)
-  include Visitable
-  include Walkable
+  class SuperNode < Struct.new(:arguments, :with_parens)
+    include Visitable
+    include Walkable
 
-  def use_all_arguments?
-    arguments.empty? && !with_parens
-  end
+    def use_all_arguments?
+      arguments.empty? && !with_parens
+    end
 
-  def children
-    arguments
+    def children
+      arguments
+    end
   end
-end
 
-class ObjectInstantiationNode < Struct.new(:call_node)
-  include Visitable
-  include Walkable
+  class ObjectInstantiationNode < Struct.new(:call_node)
+    include Visitable
+    include Walkable
 
-  def children
-    [call_node]
+    def children
+      [call_node]
+    end
   end
 end