ruby-lint 0.0.4 → 0.0.5

data/lib/ruby-lint/parser.rb

@@ -12,6 +12,8 @@ module RubyLint
     def initialize
       builder          = AST::Builder.new
       @internal_parser = ::Parser::CurrentRuby.new(builder)
+
+      internal_parser.diagnostics.all_errors_are_fatal = false
     end
 
     ##
@@ -24,21 +26,24 @@ module RubyLint
     end
 
     ##
-    # Parses a block of Ruby code and wraps the resulting AST in a root node.
+    # Parses a block of Ruby code and returns the AST and a mapping of each AST
+    # node and their comments (if there are any). This mapping is returned as a
+    # Hash.
     #
     # @param [String] code
     # @param [String] file
     # @param [Numeric] line
-    # @return [RubyLint::AST::Node]
+    # @return [Array]
     #
     def parse(code, file = '(ruby-lint)', line = 1)
       buffer        = ::Parser::Source::Buffer.new(file, line)
       buffer.source = code
-      ast           = internal_parser.parse(buffer)
+      ast, comments = internal_parser.parse_with_comments(buffer)
+      associator    = ::Parser::Source::Comment::Associator.new(comments, ast)
 
       internal_parser.reset
 
-      return AST::Node.new(:root, [ast])
+      return AST::Node.new(:root, [ast]), associator.associate
     end
   end # Parser
 end # RubyLint

data/lib/ruby-lint/presenter/text.rb

@@ -10,7 +10,8 @@ module RubyLint
       #
       # @return [String]
       #
-      FORMAT = '%{file}: %{level}: line %{line}, column %{column}: %{message}'
+      FORMAT = '%{filename}: %{level}: line %{line}, column %{column}: ' \
+        '%{message}'
 
       ##
       # @param [String] format The format to use for each entry.

data/lib/ruby-lint/report.rb

@@ -15,28 +15,22 @@ module RubyLint
   # * info
   #
   # Unless other levels are specified when creating an instance these levels
-  # are used for each new instance.
-  #
-  # Adding available levels can be done as following:
-  #
-  #     RubyLint::Report.add_level(:pedantic)
-  #
-  # Retrieving a list of available levels in turn is done as following:
-  #
-  #     RubyLint::Report.levels # => [:error, :warning, :info, :pedantic]
-  #
-  # Each level is a Symbol and will be cased to one automatically.
+  # are used for each new instance. Extra levels can be specified in the
+  # constructor of this class.
   #
   # ## Adding Entries
   #
-  # Adding entries can be done by either calling {RubyLint::Report#add} or a
-  # method for the corresponding reporting level:
+  # Adding entries can be done by either calling {RubyLint::Report#add}:
   #
   #     report = RubyLint::Report.new
   #
-  #     # Both these calls do the same.
-  #     report.add(:info, 'informational message', 1, 2, 'file.rb')
-  #     report.info('informational message', 1, 2, 'file.rb')
+  #     report.add(
+  #       :level   => :info,
+  #       :message => 'informational message',
+  #       :line    => 1,
+  #       :column  => 2,
+  #       :file    => 'file.rb'
+  #     )
   #
   # When using {RubyLint::Report#add} any invalid/disabled reporting levels
   # will be silently ignored. This makes it easier for code to add entries of a
@@ -44,6 +38,7 @@ module RubyLint
   #
   # @!attribute [r] entries
   #  @return [Array] The entries of the report.
+  #
   # @!attribute [r] levels
   #  @return [Array] The enabled levels of the report.
   #
@@ -68,34 +63,16 @@ module RubyLint
     ##
     # Adds a new entry to the report.
     #
-    # @param [#to_sym] level
-    # @param [String] message
-    # @param [Numeric] line
-    # @param [Numeric] column
-    # @param [String] file
+    # @param [Hash] attributes
+    # @option attributes [Symbol] :level The level of the message.
+    #
+    # @see RubyLint::Report::Entry#initialize
     #
-    def add(level, message, line, column, file)
-      level = level.to_sym
+    def add(attributes)
+      level = attributes[:level].to_sym
 
       if valid_level?(level)
-        @entries << Entry.new(level, message, line, column, file)
-      end
-    end
-
-    ##
-    # Makes it easier to add entries to a report by calling methods such as
-    # `#info` instead of `add(:info, ...)`.
-    #
-    # @param [Symbol] name
-    # @param [Array] args
-    # @param [Proc] block
-    # @raise [NoMethodError] Raised when an invalid method was called.
-    #
-    def method_missing(name, *args, &block)
-      if valid_level?(name)
-        return add(name, *args, &block)
-      else
-        raise NoMethodError, 'undefined method "%s" for %s' % [name, inspect]
+        entries << Entry.new(attributes)
       end
     end
 
@@ -106,7 +83,7 @@ module RubyLint
     # @return [TrueClass|FalseClass]
     #
     def valid_level?(level)
-      return @levels.include?(level)
+      return levels.include?(level)
     end
   end # Report
 end # RubyLint

data/lib/ruby-lint/report/entry.rb

@@ -6,31 +6,32 @@ module RubyLint
     #
     # @!attribute [r] level
     #  @return [Symbol]
+    #
     # @!attribute [r] message
     #  @return [String]
+    #
     # @!attribute [r] line
     #  @return [Numeric]
+    #
     # @!attribute [r] column
     #  @return [Numeric]
+    #
     # @!attribute [r] file
     #  @return [String]
     #
+    # @!attribute [r] node
+    #  @return [RubyLint::AST::Node]
+    #
     class Entry
-      attr_reader :level, :message, :line, :column, :file
+      attr_reader :level, :message, :line, :column, :file, :node
 
       ##
-      # @param [Symbol] level
-      # @param [String] message
-      # @param [Numeric] line
-      # @param [Numeric] column
-      # @param [String] file
+      # @param [Hash] attributes
       #
-      def initialize(level, message, line, column, file)
-        @level   = level
-        @message = message
-        @line    = line
-        @column  = column
-        @file    = file
+      def initialize(attributes = {})
+        attributes.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
       end
 
       ##
@@ -47,11 +48,13 @@ module RubyLint
       #
       def attributes
         return {
-          :level   => level,
-          :message => message,
-          :line    => line,
-          :column  => column,
-          :file    => file
+          :level    => level,
+          :message  => message,
+          :line     => line,
+          :column   => column,
+          :file     => file,
+          :filename => filename,
+          :node     => node
         }
       end
 

data/lib/ruby-lint/runner.rb

@@ -14,7 +14,7 @@ module RubyLint
     # @param [RubyLint::Configuration] configuration
     #
     def initialize(configuration)
-      @configuration = configuration
+      @configuration   = configuration
     end
 
     ##
@@ -39,13 +39,7 @@ module RubyLint
       end
 
       files.each do |file|
-        code = File.read(file)
-        ast  = parser.parse(code, file)
-        vm   = RubyLint::VirtualMachine.new
-
-        vm.run(ast)
-
-        run_analysis(ast, vm, report)
+        analyze_file(file, parser, report)
       end
 
       return presenter.present(report)
@@ -53,15 +47,102 @@ module RubyLint
 
     private
 
+    ##
+    # @param [String] file
+    # @param [RubyLint::Parser] parser
+    # @param [RubyLint::Report] report
+    #
+    def analyze_file(file, parser, report)
+      ast, comments = parse_file(parser, file)
+
+      extra_ast, extra_comments = process_external_files(ast)
+
+      extra_ast.push(ast)
+
+      comments.merge!(extra_comments)
+
+      autoload_constants(extra_ast)
+
+      vm = run_vm(extra_ast, comments)
+
+      run_analysis(ast, vm, report)
+    end
+
+    ##
+    # Parses the given file and returns an Array containing all the associated
+    # AST nodes and comments.
+    #
+    # @param [RubyLint::Parser] parser
+    # @param [String] file
+    # @return [Array]
+    #
+    def parse_file(parser, file)
+      return parser.parse(File.read(file), file)
+    end
+
+    ##
+    # Automatically loads definitions using {RubyLint::ConstantLoader}.
+    #
+    # @param [Array] nodes
+    #
+    def autoload_constants(nodes)
+      nodes.each { |node| GlobalScope.constant_loader.iterate(node) }
+    end
+
+    ##
+    # Processes external Ruby files using {RubyLint::FileLoader}. The return
+    # value is a collection of AST nodes and a Hash containing all the
+    # associated comments.
+    #
+    # @param [RubyLint::AST::Node] root_ast
+    # @return [Array]
+    #
+    def process_external_files(root_ast)
+      loader = FileLoader.new(
+        :directories  => configuration.directories,
+        :ignore_paths => configuration.ignore_paths,
+        :debug        => configuration.debug
+      )
+
+      nodes    = []
+      comments = {}
+
+      loader.iterate(root_ast)
+
+      loader.nodes.each do |(ast, cmts)|
+        nodes << ast
+
+        comments.merge!(cmts)
+      end
+
+      return nodes, comments
+    end
+
     ##
     # @param [Parser::Diagnostic] diagnostic
     # @param [RubyLint::Report] report
     #
     def report_diagnostic(diagnostic, report)
-      loc    = diagnostic.location
-      buffer = loc.source_buffer
+      report.add(
+        :level   => :error,
+        :message => diagnostic.message,
+        :line    => diagnostic.location.line,
+        :column  => diagnostic.location.column,
+        :file    => diagnostic.location.source_buffer.name
+      )
+    end
+
+    ##
+    # @param [Array] nodes
+    # @param [Hash] comments
+    # @return [RubyLint::VirtualMachine]
+    #
+    def run_vm(nodes, comments)
+      vm = RubyLint::VirtualMachine.new(:comments => comments)
+
+      vm.run(nodes)
 
-      report.error(diagnostic.message, loc.line, loc.column, buffer.name)
+      return vm
     end
 
     ##

data/lib/ruby-lint/template/definition.erb

@@ -5,9 +5,9 @@
 # Platform: <%= RUBY_ENGINE %> <%= Rubinius::VERSION rescue RUBY_VERSION %>
 
 <% @constants.each do |constant| %>
-RubyLint::VirtualMachine.global_scope.define_constant('<%= constant.name %>') do |klass|
+RubyLint::GlobalScope.definitions.define_constant('<%= constant.name %>') do |klass|
   <%- if constant.superclass -%>
-  klass.inherits(RubyLint::VirtualMachine.constant_proxy('<%= constant.superclass %>'))
+  klass.inherits(RubyLint::GlobalScope.constant_proxy('<%= constant.superclass %>'))
   <%- end -%>
 
   <%- constant.methods.each do |type, collection| -%>

data/lib/ruby-lint/variable_predicates.rb

@@ -4,20 +4,14 @@ module RubyLint
   # types.
   #
   module VariablePredicates
-    ##
-    # Array containing various Ruby types that are considered to be scalar
-    # values.
-    #
-    # @return [Array]
-    #
-    SCALAR_TYPES = [:int, :float, :str, :sym]
-
     ##
     # Array containing various predicate methods to create.
     #
     # @return [Array]
     #
-    PREDICATE_METHODS = [:array, :class, :const, :hash, :module, :self, :block]
+    PREDICATE_METHODS = [
+      :array, :class, :const, :hash, :module, :self, :block, :gvar
+    ]
 
     ##
     # Hash containing various Node types and the associated Ruby classes.
@@ -34,7 +28,10 @@ module RubyLint
       :hash   => 'Hash',
       :irange => 'Range',
       :erange => 'Range',
-      :lambda => 'Proc'
+      :lambda => 'Proc',
+      :true   => 'TrueClass',
+      :false  => 'FalseClass',
+      :nil    => 'NilClass'
     }
 
     PREDICATE_METHODS.each do |type|

data/lib/ruby-lint/version.rb

@@ -1,3 +1,3 @@
 module RubyLint
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end # RubyLint

data/lib/ruby-lint/virtual_machine.rb

@@ -42,38 +42,44 @@ module RubyLint
   # {RubyLint::VirtualMachine#associations} with the keys set to the nodes and
   # the values to the corresponding definitions.
   #
+  # ## Options
+  #
+  # The following extra options can be set in the constructor:
+  #
+  # * `:comments`: a Hash containing the comments for various AST nodes.
+  #
   # @!attribute [r] associations
   #  @return [Hash]
+  #
+  # @!attribute [r] comments
+  #  @return [Hash]
+  #
   # @!attribute [r] definitions
   #  @return [RubyLint::Definition::RubyObject]
+  #
+  # @!attribute [r] extra_definitions
+  #  @return [Array]
+  #
   # @!attribute [r] value_stack
   #  @return [RubyLint::NestedStack]
+  #
   # @!attribute [r] variable_stack
   #  @return [RubyLint::NestedStack]
   #
+  # @!attribute [r] docstring_tags
+  #  @return [RubyLint::Docstring::Mapping]
+  #
   class VirtualMachine < Iterator
     include Helper::ConstantPaths
 
-    attr_reader :associations, :definitions, :value_stack, :variable_stack
-
-    private :value_stack, :variable_stack
+    attr_reader :associations,
+      :comments,
+      :definitions,
+      :docstring_tags,
+      :value_stack,
+      :variable_stack
 
-    ##
-    # Hash containing the definition types to copy when including/extending a
-    # module.
-    #
-    # @return [Hash]
-    #
-    INCLUDE_CALLS = {
-      'include' => {
-        :const           => :const,
-        :instance_method => :instance_method
-      },
-      'extend' => {
-        :const           => :const,
-        :instance_method => :method
-      }
-    }
+    private :value_stack, :variable_stack, :docstring_tags
 
     ##
     # Hash containing variable assignment types and the corresponding variable
@@ -93,24 +99,32 @@ module RubyLint
     #
     # @return [Array]
     #
-    PRIMITIVES = [:int, :float, :str, :sym]
+    PRIMITIVES = [:int, :float, :str, :sym, :true, :false, :nil]
 
     ##
-    # Remaps the names for `on_send` callback nodes in cases where the original
-    # name of a method could not be used. For example, `on_send_[]=` is
-    # considered to be invalid syntax and thus its mapped to
-    # `on_send_assign_member`.
+    # Returns a Hash containing the method call evaluators to use for `(send)`
+    # nodes.
     #
     # @return [Hash]
     #
-    SEND_MAPPING = {'[]=' => 'assign_member'}
+    SEND_MAPPING = {
+      '[]='           => MethodCall::AssignMember,
+      'include'       => MethodCall::Include,
+      'extend'        => MethodCall::Include,
+      'alias_method'  => MethodCall::Alias,
+      'attr'          => MethodCall::Attribute,
+      'attr_reader'   => MethodCall::Attribute,
+      'attr_writer'   => MethodCall::Attribute,
+      'attr_accessor' => MethodCall::Attribute,
+      'define_method' => MethodCall::DefineMethod
+    }
 
     ##
     # Array containing the various argument types of method definitions.
     #
     # @return [Array]
     #
-    ARGUMENT_TYPES = [:arg, :optarg, :restarg, :blockarg]
+    ARGUMENT_TYPES = [:arg, :optarg, :restarg, :blockarg, :kwoptarg]
 
     ##
     # The types of variables to export outside of a method definition.
@@ -119,13 +133,6 @@ module RubyLint
     #
     EXPORT_VARIABLES = [:ivar, :cvar, :const]
 
-    ##
-    # Array containing the directories to use for looking up definition files.
-    #
-    # @return [Array]
-    #
-    LOAD_PATH = [File.expand_path('../definitions/core', __FILE__)]
-
     ##
     # The available method visibilities.
     #
@@ -133,78 +140,34 @@ module RubyLint
     #
     VISIBILITIES = [:public, :protected, :private].freeze
 
-    ##
-    # @return [RubyLint::Definition::RubyObject]
-    #
-    def self.global_scope
-      return @global_scope ||= Definition::RubyObject.new(
-        :name => 'global',
-        :type => :global
-      )
-    end
-
-    ##
-    # Looks up the given constant in the global scope. If it does not exist
-    # this method will try to load it from one of the existing definitions.
-    #
-    # @param [String] name
-    # @return [RubyLint::Definition::RubyObject]
-    #
-    def self.global_constant(name)
-      found = global_scope.lookup_constant_path(name)
-
-      if !found and !constant_loader.loaded?(name)
-        constant_loader.load_constant(name)
-
-        found = global_scope.lookup_constant_path(name)
-      end
-
-      return found
-    end
-
-    ##
-    # Creates a new proxy for a global constant.
-    #
-    # @param [String] name The name of the constant, can include an entire
-    #  constant path in the form of `Foo::Bar`.
-    # @return [RubyLint::Definition::ConstantProxy]
-    #
-    def self.constant_proxy(name)
-      return Definition::ConstantProxy.new(global_scope, name)
-    end
-
-    ##
-    # @return [RubyLint::ConstantLoader]
-    #
-    def self.constant_loader
-      return @constant_loader ||= ConstantLoader.new
-    end
-
     ##
     # Called after a new instance of the virtual machine has been created.
     #
     def after_initialize
-      @associations     = {}
-      @definitions      = initial_definitions
-      @scopes           = [@definitions]
-      @in_sclass        = false
-      @value_stack      = NestedStack.new
-      @variable_stack   = NestedStack.new
-      @ignored_nodes    = []
-      @visibility       = :public
+      @comments ||= {}
+
+      @associations   = {}
+      @definitions    = initial_definitions
+      @scopes         = [@definitions]
+      @value_stack    = NestedStack.new
+      @variable_stack = NestedStack.new
+      @ignored_nodes  = []
+      @visibility     = :public
 
+      reset_docstring_tags
       reset_method_type
     end
 
     ##
-    # Processes the given AST. Constants are autoloaded first.
+    # Processes the given AST or a collection of AST nodes.
     #
     # @see #iterate
+    # @param [Array|RubyLint::AST::Node] ast
     #
     def run(ast)
-      self.class.constant_loader.iterate(ast)
+      ast = [ast] unless ast.is_a?(Array)
 
-      iterate(ast)
+      ast.each { |node| iterate(node) }
 
       freeze
     end
@@ -213,11 +176,11 @@ module RubyLint
     # Freezes the VM along with all the instance variables.
     #
     def freeze
-      super
+      @associations.freeze
+      @definitions.freeze
+      @scopes.freeze
 
-      instance_variables.each do |var|
-        instance_variable_get(var).freeze
-      end
+      super
     end
 
     ##
@@ -309,7 +272,7 @@ module RubyLint
     def after_masgn(node)
       variables = variable_stack.pop
       values    = value_stack.pop.first
-      values    = values ? values.value : []
+      values    = values && values.value ? values.value : []
 
       variables.each_with_index do |variable, index|
         variable.value = values[index].value if values[index]
@@ -374,12 +337,27 @@ module RubyLint
       end
     end
 
+    ##
+    # Called whenever a magic regexp global variable is referenced (e.g. `$1`).
+    #
+    # @param [RubyLint::AST::Node] node
+    #
+    def on_nth_ref(node)
+      var = definitions.lookup(:gvar, "$#{node.children[0]}")
+
+      push_value(var.value)
+    end
+
     ##
     # @param [RubyLint::AST::Node] node
     #
     def on_const(node)
       increment_reference_amount(node)
       push_variable_value(node)
+
+      # The root node is also used in such a way that it processes child (=
+      # receiver) constants.
+      skip_child_nodes!(node)
     end
 
     ##
@@ -488,7 +466,7 @@ module RubyLint
         parent = evaluate_node(parent_node)
 
         if !parent or !parent.const?
-          raise TypeError, 'classes can only inherit another class'
+          parent = current_scope.lookup(:const, 'Object')
         end
       end
 
@@ -576,6 +554,15 @@ module RubyLint
 
       associate_node(node, definition)
 
+      buffer_docstring_tags(node)
+
+      if docstring_tags and docstring_tags.return_tag
+        assign_return_value_from_tag(
+          docstring_tags.return_tag,
+          definition
+        )
+      end
+
       push_scope(definition)
     end
 
@@ -588,29 +575,13 @@ module RubyLint
       previous = pop_scope
       current  = current_scope
 
+      reset_docstring_tags
+
       EXPORT_VARIABLES.each do |type|
         current.copy(previous, type)
       end
     end
 
-    ##
-    # @param [RubyLint::AST::Node] node
-    #
-    def on_args(node)
-      variable_stack.add_stack
-    end
-
-    ##
-    # @param [RubyLint::AST::Node] node
-    #
-    def after_args(node)
-      variables = variable_stack.pop
-
-      variables.each do |variable|
-        current_scope.add_definition(variable)
-      end
-    end
-
     # Creates callbacks for various argument types such as :arg and :optarg.
     ARGUMENT_TYPES.each do |type|
       define_method("on_#{type}") do |node|
@@ -620,16 +591,19 @@ module RubyLint
       define_method("after_#{type}") do |node|
         value = value_stack.pop.first
         name  = node.children[0].to_s
-        arg   = Definition::RubyObject.new(
-          :type          => type,
+        var   = Definition::RubyObject.new(
+          :type          => :lvar,
           :name          => name,
           :value         => value,
           :instance_type => :instance
         )
 
-        current_scope.add_definition(arg)
+        if docstring_tags and docstring_tags.param_tags[name]
+          update_parents_from_tag(docstring_tags.param_tags[name], var)
+        end
 
-        assign_variable(:lvar, name, value)
+        current_scope.add(type, name, var)
+        current_scope.add_definition(var)
       end
     end
 
@@ -659,65 +633,64 @@ module RubyLint
       receiver, name, _ = *node
 
       name        = name.to_s
-      mapped_name = SEND_MAPPING.fetch(name, name)
-      callback    = "after_send_#{mapped_name}"
+      args_length = node.children[2..-1].length
+      values      = value_stack.pop
+      arguments   = values.pop(args_length)
+      block       = nil
+
+      receiver_definition = values.first
+
+      if arguments.length != args_length
+        raise <<-EOF
+Not enough argument definitions for #{node.inspect_oneline}.
+Location: #{node.file} on line #{node.line}, column #{node.column}
+Expected: #{args_length}
+Received: #{arguments.length}
+        EOF
+      end
 
-      execute_callback(callback, node)
+      # If the receiver doesn't exist there's no point in associating a context
+      # with it.
+      if receiver and !receiver_definition
+        push_unknown_value
 
-      receiver_and_args = value_stack.pop
+        return
+      end
 
-      if receiver
-        context = receiver_and_args.shift
+      if receiver and receiver_definition
+        context = receiver_definition
       else
         context = current_scope
 
         # `parser` wraps (block) nodes around (send) calls which is a bit
         # inconvenient
-        context = previous_scope if context.block?
+        if context.block?
+          block   = context
+          context = previous_scope
+        end
+      end
+
+      if SEND_MAPPING[name]
+        evaluator = SEND_MAPPING[name].new(node, self)
+
+        evaluator.evaluate(arguments, context, block)
       end
 
       # Associate the receiver node with the context so that it becomes
       # easier to retrieve later on.
-      if receiver && context
+      if receiver and context
         associate_node(receiver, context)
       end
 
       if context and context.method_defined?(name)
         retval = context.call_method(name)
 
-        push_value(retval)
-      end
-    end
-
-    ##
-    # @param [RubyLint::AST::Node] node
-    #
-    def on_send_include(node)
-      value_stack.add_stack
-    end
-
-    ##
-    # Processes a `include` method call.
-    #
-    # @param [RubyLint::AST::Node] node
-    #
-    def after_send_include(node)
-      copy_types = INCLUDE_CALLS[node.children[1].to_s]
-      scope      = current_scope
-      arguments  = value_stack.pop
-
-      arguments.each do |source|
-        copy_types.each do |from, to|
-          source.list(from).each do |definition|
-            scope.add(to, definition.name, definition)
-          end
-        end
+        retval ? push_value(retval) : push_unknown_value
+      else
+        push_unknown_value
       end
     end
 
-    alias_method :on_send_extend, :on_send_include
-    alias_method :after_send_extend, :after_send_include
-
     VISIBILITIES.each do |vis|
       define_method("on_send_#{vis}") do |node|
         @visibility = vis
@@ -727,34 +700,26 @@ module RubyLint
     ##
     # @param [RubyLint::AST::Node] node
     #
-    def on_send_assign_member(node)
+    def on_alias(node)
       value_stack.add_stack
     end
 
     ##
-    # Processes the assignment of an object member (array index or hash key).
+    # Processes calls to `alias`. Two types of data can be aliased:
     #
-    # @param [RubyLint::AST::Node] node
+    # 1. Methods (using the syntax `alias ALIAS SOURCE`)
+    # 2. Global variables
     #
-    def after_send_assign_member(node)
-      array, *indexes, values = value_stack.pop
-      index_values            = []
-
-      if values and values.array?
-        index_values = values.list(:member).map(&:value)
-      elsif values
-        index_values = [values]
-      end
-
-      indexes.each do |index|
-        member = Definition::RubyObject.new(
-          :name  => index.value.to_s,
-          :type  => :member,
-          :value => index_values.shift
-        )
+    # This method dispatches the alias process to two possible methods:
+    #
+    # * on_alias_sym: aliasing methods (using symbols)
+    # * on_alias_gvar: aliasing global variables
+    #
+    def after_alias(node)
+      arguments = value_stack.pop
+      evaluator = MethodCall::Alias.new(node, self)
 
-        array.add_definition(member)
-      end
+      evaluator.evaluate(arguments, current_scope)
     end
 
     private
@@ -768,12 +733,10 @@ module RubyLint
       definitions = Definition::RubyObject.new(
         :name          => 'root',
         :type          => :root,
-        :parents       => [RubyLint::VirtualMachine.global_constant('Kernel')],
+        :parents       => [GlobalScope.definitions],
         :instance_type => :instance
       )
 
-      definitions.merge(RubyLint::VirtualMachine.global_scope)
-
       definitions.add(:keyword, 'self', definitions)
 
       return definitions
@@ -783,20 +746,22 @@ module RubyLint
     # Defines a new module/class based on the supplied node.
     #
     # @param [RubyLint::Node] node
-    # @param [Class] definition_builder
+    # @param [RubyLint::DefinitionBuilder::Base] definition_builder
     # @param [Hash] options
     #
     def define_module(node, definition_builder, options = {})
       builder    = definition_builder.new(node, current_scope, options)
       definition = builder.build
       scope      = builder.scope
-      existing   = scope.lookup(definition.type, definition.name)
+      existing   = scope.lookup(definition.type, definition.name, false)
 
       if existing
         definition = existing
 
         inherit_definition(definition, current_scope)
       else
+        definition.add_definition(definition)
+
         scope.add_definition(definition)
       end
 
@@ -881,6 +846,13 @@ module RubyLint
       value_stack.push(definition) if definition && !value_stack.empty?
     end
 
+    ##
+    # Pushes an unknown value object onto the value stack.
+    #
+    def push_unknown_value
+      push_value(Definition::RubyObject.create_unknown)
+    end
+
     ##
     # Adds a new variable and value stack.
     #
@@ -897,11 +869,14 @@ module RubyLint
     # @param [RubyLint::Definition::RubyObject] value
     #
     def assign_variable(type, name, value)
-      variable = Definition::RubyObject.new(
-        :type          => type,
-        :name          => name,
-        :value         => value,
-        :instance_type => :instance
+      existing   = current_scope.lookup(type, name)
+      ref_amount = existing ? existing.reference_amount + 1 : 0
+      variable   = Definition::RubyObject.new(
+        :type             => type,
+        :name             => name,
+        :value            => value,
+        :instance_type    => :instance,
+        :reference_amount => ref_amount
       )
 
       buffer_assignment_value(variable.value)
@@ -975,6 +950,8 @@ module RubyLint
     #  will be overwritten.
     #
     def conditional_assignment(variable, value, bool = true)
+      variable.reference_amount += 1
+
       if current_scope.has_definition?(variable.type, variable.name) == bool
         variable.value = value
 
@@ -997,6 +974,8 @@ module RubyLint
         definition = current_scope.lookup(node.type, node.name)
       end
 
+      definition = Definition::RubyObject.create_unknown unless definition
+
       return definition
     end
 
@@ -1040,5 +1019,103 @@ module RubyLint
         definition.parents << inherit
       end
     end
+
+    ##
+    # Extracts all the docstring tags from the documentation of the given
+    # node, retrieves the corresponding types and stores them for later use.
+    #
+    # @param [RubyLint::AST::Node] node
+    #
+    def buffer_docstring_tags(node)
+      return unless comments[node]
+
+      parser = Docstring::Parser.new
+      tags   = parser.parse(comments[node].map(&:text))
+
+      @docstring_tags = Docstring::Mapping.new(tags)
+    end
+
+    ##
+    # Resets the docstring tags collection back to its initial value.
+    #
+    def reset_docstring_tags
+      @docstring_tags = nil
+    end
+
+    ##
+    # Updates the parents of a definition according to the types of a `@param`
+    # tag.
+    #
+    # @param [RubyLint::Docstring::ParamTag] tag
+    # @param [RubyLint::Definition::RubyObject] definition
+    #
+    def update_parents_from_tag(tag, definition)
+      extra_parents = definitions_for_types(tag.types)
+
+      definition.parents.concat(extra_parents)
+    end
+
+    ##
+    # Creates an "unknown" definition with the given method in it.
+    #
+    # @param [String] name The name of the method to add.
+    # @return [RubyLint::Definition::RubyObject]
+    #
+    def create_unknown_with_method(name)
+      definition = Definition::RubyObject.create_unknown
+
+      definition.send("define_#{@method_type}", name)
+
+      return definition
+    end
+
+    ##
+    # Returns a collection of definitions for a set of YARD types.
+    #
+    # @param [Array] types
+    # @return [Array]
+    #
+    def definitions_for_types(types)
+      definitions = []
+
+      # There are basically two type signatures: either the name(s) of a
+      # constant or a method in the form of `#method_name`.
+      types.each do |type|
+        if type[0] == '#'
+          found = create_unknown_with_method(type[1..-1])
+        else
+          found = lookup_type_definition(type)
+        end
+
+        definitions << found if found
+      end
+
+      return definitions
+    end
+
+    ##
+    # Tries to look up the given type/constant in the current scope and falls
+    # back to the global scope if it couldn't be found in the former.
+    #
+    # @param [String] name
+    # @return [RubyLint::Definition::RubyObject]
+    #
+    def lookup_type_definition(name)
+      return current_scope.lookup(:const, name) ||
+        GlobalScope.global_constant(name)
+    end
+
+    ##
+    # @param [RubyLint::Docstring::ReturnTag] tag
+    # @param [RubyLint::Definition::RubyMethod] definition
+    #
+    def assign_return_value_from_tag(tag, definition)
+      definitions = definitions_for_types(tag.types)
+
+      # THINK: currently ruby-lint assumes methods always return a single type
+      # but YARD allows you to specify multiple ones. For now we'll take the
+      # first one but there should be a nicer way to do this.
+      definition.returns(definitions[0]) if definitions[0]
+    end
   end # VirtualMachine
 end # RubyLint