solargraph 0.28.4 → 0.29.0

data/lib/solargraph/pin/method_alias.rb

@@ -0,0 +1,19 @@
+module Solargraph
+  module Pin
+    # Use this class to track method aliases for later remapping. Common
+    # examples are aliases for superclass methods or methods from included
+    # modules.
+    #
+    class MethodAlias < Method
+      attr_reader :original
+
+      def initialize location, namespace, name, scope, original
+        # @todo Determine how to handle these parameters. Among other things,
+        #   determine if the visibility is defined by the location of the
+        #   alias call or the original method.
+        super(location, namespace, name, '', scope, :public, [])
+        @original = original
+      end
+    end
+  end
+end

data/lib/solargraph/pin/yard_pin/method.rb

@@ -6,7 +6,7 @@ module Solargraph
 
         def initialize code_object, location, name = nil, scope = nil, visibility = nil
           comments = (code_object.docstring ? code_object.docstring.all : nil)
-          super(location, code_object.namespace.to_s, name || code_object.name.to_s, comments, scope || code_object.scope, visibility || code_object.visibility, get_parameters(code_object))
+          super(location, code_object.namespace.to_s, name || code_object.name.to_s, comments, scope || code_object.scope, visibility || code_object.visibility, get_parameters(code_object), nil)
         end
 
         def return_complex_type
@@ -28,7 +28,7 @@ module Solargraph
             args.push p
           end
           args
-        end  
+        end
       end
     end
   end

data/lib/solargraph/source.rb

@@ -46,7 +46,12 @@ module Solargraph
         @node, @comments = Source.parse_with_comments(@code, filename)
         @parsed = true
       rescue Parser::SyntaxError, EncodingError => e
-        @node, @comments = Source.parse_with_comments(@code.gsub(/[^s]/, ' '), filename)
+        # @todo 100% whitespace results in a nil node, so there's no reason to parse it.
+        #   We still need to determine whether the resulting node should be nil or a dummy
+        #   node with a location that encompasses the range.
+        # @node, @comments = Source.parse_with_comments(@code.gsub(/[^\s]/, ' '), filename)
+        @node = nil
+        @comments = []
         @parsed = false
       rescue Exception => e
         STDERR.puts e.message
@@ -171,8 +176,65 @@ module Solargraph
       @error_ranges ||= []
     end
 
+    def code_for(node)
+      # @todo Using node locations on code with converted EOLs seems
+      #   slightly more efficient than calculating offsets.
+      # b = node.location.expression.begin.begin_pos
+      # e = node.location.expression.end.end_pos
+      b = Position.line_char_to_offset(@code, node.location.line, node.location.column)
+      e = Position.line_char_to_offset(@code, node.location.last_line, node.location.last_column)
+      frag = code[b..e-1].to_s
+      frag.strip.gsub(/,$/, '')
+    end
+
+    # @param node [Parser::AST::Node]
+    # @return [String]
+    def comments_for node
+      arr = associated_comments[node.loc.line]
+      arr ? stringify_comment_array(arr) : nil
+    end
+
+    def location
+      st = Position.new(0, 0)
+      en = Position.from_offset(code, code.length)
+      range = Range.new(st, en)
+      Location.new(filename, range)
+    end
+
     private
 
+    def associated_comments
+      @associated_comments ||= begin
+        result = {}
+        Parser::Source::Comment.associate_locations(node, comments).each_pair do |loc, all|
+          block = all.select{ |l| l.document? || code.lines[l.loc.line].strip.start_with?('#')}
+          next if block.empty?
+          result[loc.line] ||= []
+          result[loc.line].concat block
+        end
+        result
+      end
+    end
+
+    def stringify_comment_array comments
+      ctxt = ''
+      num = nil
+      started = false
+      comments.each { |l|
+        # Trim the comment and minimum leading whitespace
+        p = l.text.gsub(/^#/, '')
+        if num.nil? and !p.strip.empty?
+          num = p.index(/[^ ]/)
+          started = true
+        elsif started and !p.strip.empty?
+          cur = p.index(/[^ ]/)
+          num = cur if cur < num
+        end
+        ctxt += "#{p[num..-1]}\n" if started
+      }
+      ctxt
+    end
+
     # @return [Array<Range>]
     def string_ranges
       @string_ranges ||= string_ranges_in(@node)

data/lib/solargraph/source/chain/call.rb

@@ -42,16 +42,18 @@ module Solargraph
         def inferred_pins pins, api_map, context, locals
           result = pins.map do |p|
             if CoreFills::METHODS_RETURNING_SELF.include?(p.path)
-              next Solargraph::Pin::Method.new(p.location, p.namespace, p.name, "@return [#{context.tag}]", p.scope, p.visibility, p.parameters)
+              next Solargraph::Pin::Method.new(p.location, p.namespace, p.name, "@return [#{context.tag}]", p.scope, p.visibility, p.parameters, p.node)
             end
             if CoreFills::METHODS_RETURNING_SUBTYPES.include?(p.path) && !context.subtypes.empty?
-              next Solargraph::Pin::Method.new(p.location, p.namespace, p.name, "@return [#{context.subtypes.first.tag}]", p.scope, p.visibility, p.parameters)
+              next Solargraph::Pin::Method.new(p.location, p.namespace, p.name, "@return [#{context.subtypes.first.tag}]", p.scope, p.visibility, p.parameters, p.node)
+            end
+            if p.kind == Pin::METHOD && !p.macros.empty?
+              result = process_macro(p, api_map, context, locals)
+              next result unless result.return_type.undefined?
+            elsif !p.directives.empty?
+              result = process_directive(p, api_map, context, locals)
+              next result unless result.return_type.undefined?
             end
-            # @todo Temporarily disabled macros
-            # if p.kind == Pin::METHOD && !p.macros.empty?
-            #   result = process_macro(p, api_map, context, locals)
-            #   next result unless result.return_type.undefined?
-            # end
             next p if p.kind == Pin::METHOD || p.kind == Pin::ATTRIBUTE || p.kind == Pin::NAMESPACE
             type = p.infer(api_map)
             next p if p.return_complex_type == type
@@ -67,22 +69,39 @@ module Solargraph
         # @param pin [Pin::Method]
         # @param api_map [ApiMap]
         # @param context [ComplexType]
+        # @return [Pin::Base]
         def process_macro pin, api_map, context, locals
           pin.macros.each do |macro|
-            vals = arguments.map{ |c| Pin::ProxyType.anonymous(c.infer(api_map, pin, locals)) }
-            txt = macro.tag.text.clone
-            i = 1
-            vals.each do |v|
-              txt.gsub!(/\$#{i}/, v.context.namespace)
-              i += 1
-            end
-            docstring = YARD::Docstring.parser.parse(txt).to_docstring
-            tag = docstring.tag(:return)
-            unless tag.nil? || tag.types.nil?
-              return Pin::ProxyType.anonymous(ComplexType.parse(*tag.types))
-            end
+            result = inner_process_macro(pin, macro, api_map, context, locals)
+            return result unless result.return_type.undefined?
+          end
+          Pin::ProxyType.new(nil, nil, nil, ComplexType::UNDEFINED)
+        end
+
+        def process_directive pin, api_map, context, locals
+          pin.directives.each do |dir|
+            macro = api_map.named_macro(dir.tag.name)
+            next if macro.nil?
+            result = inner_process_macro(pin, macro, api_map, context, locals)
+            return result unless result.return_type.undefined?
+          end
+          Pin::ProxyType.new(nil, nil, nil, ComplexType::UNDEFINED)
+        end
+
+        def inner_process_macro pin, macro, api_map, context, locals
+          vals = arguments.map{ |c| Pin::ProxyType.anonymous(c.infer(api_map, pin, locals)) }
+          txt = macro.tag.text.clone
+          i = 1
+          vals.each do |v|
+            txt.gsub!(/\$#{i}/, v.context.namespace)
+            i += 1
+          end
+          docstring = YARD::Docstring.parser.parse(txt).to_docstring
+          tag = docstring.tag(:return)
+          unless tag.nil? || tag.types.nil?
+            return Pin::ProxyType.anonymous(ComplexType.parse(*tag.types))
           end
-          return Pin::ProxyType.new(nil, nil, nil, ComplexType::UNDEFINED)
+          Pin::ProxyType.new(nil, nil, nil, ComplexType::UNDEFINED)
         end
       end
     end

data/lib/solargraph/source/node_chainer.rb

@@ -41,7 +41,7 @@ module Solargraph
       # @param n [Parser::AST::Node]
       # @return [Array<Chain::Link>]
       def generate_links n
-        return [] if n.nil?
+        return [] unless n.is_a?(Parser::AST::Node)
         return generate_links(n.children[0]) if n.type == :begin
         # @todo This might not be right. It's weird either way.
         # return generate_links(n.children[2] || n.children[0]) if n.type == :block

data/lib/solargraph/source/node_methods.rb

@@ -60,6 +60,8 @@ module Solargraph
           return 'Float'
         elsif node.type == :sym
           return 'Symbol'
+        elsif node.type == :regexp
+          return 'Regexp'
         # @todo Maybe ignore nils
         # elsif node.type == :nil
         #   return 'NilClass'
@@ -106,6 +108,85 @@ module Solargraph
         end
         signature
       end
+
+      def returns_from node
+        DeepInference.get_return_nodes(node)
+      end
+
+      module DeepInference
+        class << self
+          CONDITIONAL = [:if, :unless]
+          REDUCEABLE = [:begin, :kwbegin]
+          SKIPPABLE = [:def, :defs, :class, :sclass, :module]
+
+          def get_return_nodes node
+            result = []
+            if REDUCEABLE.include?(node.type)
+              result.concat get_return_nodes_from_children(node)
+            elsif CONDITIONAL.include?(node.type)
+              result.concat reduce_to_value_nodes(node.children[1..-1])
+            else
+              result.push node
+            end
+            result
+          end
+
+          private
+
+          def get_return_nodes_from_children parent
+            result = []
+            nodes = parent.children.select{|n| n.is_a?(AST::Node)}
+            nodes[0..-2].each do |node|
+              next if SKIPPABLE.include?(node.type)
+              if node.type == :return
+                result.concat reduce_to_value_nodes([node.children[0]])
+                # @todo Maybe return the result here because the rest of the code is
+                #   unreachable
+                return result
+              else
+                result.concat get_return_nodes_only(node)
+              end
+            end
+            result.concat reduce_to_value_nodes([nodes.last]) unless nodes.last.nil?
+            result
+          end
+
+          def get_return_nodes_only parent
+            result = []
+            nodes = parent.children.select{|n| n.is_a?(AST::Node)}
+            nodes.each do |node|
+              next if SKIPPABLE.include?(node.type)
+              if node.type == :return
+                result.concat reduce_to_value_nodes([node.children[0]])
+                # @todo Maybe return the result here because the rest of the code is
+                #   unreachable
+              else
+                result.concat get_return_nodes_only(node)
+              end
+            end
+            result
+          end
+
+          def reduce_to_value_nodes nodes
+            result = []
+            nodes.each do |node|
+              if REDUCEABLE.include?(node.type)
+                result.concat get_return_nodes_from_children(node)
+                # node.children.each do |child|
+                #   result.concat reduce_to_value_nodes(child)
+                # end
+              elsif CONDITIONAL.include?(node.type)
+                result.concat reduce_to_value_nodes(node.children[1..-1])
+              elsif node.type == :return
+                result.concat get_return_nodes(node.children[0])
+              else
+                result.push node
+              end
+            end
+            result
+          end
+        end
+      end      
     end
   end
 end

data/lib/solargraph/source_map.rb

@@ -2,9 +2,11 @@ module Solargraph
   # An index of pins and other ApiMap-related data for a Source.
   #
   class SourceMap
+    autoload :NodeProcessor, 'solargraph/source_map/node_processor'
     autoload :Mapper,        'solargraph/source_map/mapper'
     autoload :Clip,          'solargraph/source_map/clip'
     autoload :Completion,    'solargraph/source_map/completion'
+    autoload :Region,        'solargraph/source_map/region'
 
     # @return [Source]
     attr_reader :source
@@ -15,6 +17,9 @@ module Solargraph
     # @return [Array<Pin::Base>]
     attr_reader :locals
 
+    # @param source [Source]
+    # @param pins [Array<Pin::Base>]
+    # @param locals [Array<Pin::Base>]
     def initialize source, pins, locals
       # HACK: Keep the library from changing this
       @source = source.dup
@@ -22,14 +27,17 @@ module Solargraph
       @locals = locals
     end
 
+    # @return [String]
     def filename
       source.filename
     end
 
+    # @return [String]
     def code
       source.code
     end
 
+    # @return [Array<Pin::Reference::Require>]
     def requires
       @requires ||= pins.select{|p| p.kind == Pin::REQUIRE_REFERENCE}
     end
@@ -46,12 +54,15 @@ module Solargraph
       @source.comment_at?(position)
     end
 
+    # @return [Array<Pin::Base>]
     def document_symbols
       @document_symbols ||= pins.select { |pin|
         [Pin::ATTRIBUTE, Pin::CONSTANT, Pin::METHOD, Pin::NAMESPACE].include?(pin.kind) and !pin.path.empty?
       }
     end
 
+    # @param query [String]
+    # @return [Array<Pin::Base>]
     def query_symbols query
       document_symbols.select{|pin| pin.path.include?(query)}
     end
@@ -82,6 +93,7 @@ module Solargraph
     end
 
     # @param other_map [SourceMap]
+    # @return Boolean
     def try_merge! other_map
       return false if pins.length != other_map.pins.length || locals.length != other_map.locals.length || requires.map(&:name).uniq.sort != other_map.requires.map(&:name).uniq.sort
       pins.each_index do |i|
@@ -101,12 +113,15 @@ module Solargraph
     end
 
     class << self
+      # @param filename [String]
       # @return [SourceMap]
       def load filename
         source = Solargraph::Source.load(filename)
         SourceMap.map(source)
       end
 
+      # @param code [String]
+      # @param filename [String, nil]
       # @return [SourceMap]
       def load_string code, filename = nil
         source = Solargraph::Source.load_string(code, filename)

data/lib/solargraph/source_map/clip.rb

@@ -29,7 +29,7 @@ module Solargraph
             type = cursor.chain.base.infer(api_map, context_pin, locals)
           else
             full = cursor.chain.links.first.word
-            if full.include?('::')
+            if full.include?('::') && cursor.chain.links.length == 1
               type = ComplexType.parse(full.split('::')[0..-2].join('::'))
             elsif cursor.chain.links.length > 1
               type = ComplexType.parse(full)

data/lib/solargraph/source_map/mapper.rb

@@ -13,29 +13,14 @@ module Solargraph
       # Generate the data.
       #
       # @return [Array]
-      def map filename, code, node, comments
-        @filename = filename
-        @code = code
-        @node = node
-        @comments = comments
-        @node_stack = []
-        @directives = {}
-        @comment_ranges = comments.map do |c|
-          Range.from_to(c.loc.expression.line, c.loc.expression.column, c.loc.expression.last_line, c.loc.expression.last_column)
-        end
-        @node_comments = associate_comments(node, comments)
-        @pins = []
-        @locals = []
-        @strings = []
-
-        # HACK make sure the first node gets processed
-        root = AST::Node.new(:source, [filename])
-        root = root.append node
-        # @todo Is the root namespace a class or a module? Assuming class for now.
-        @pins.push Pin::Namespace.new(get_node_location(nil), '', '', nil, :class, :public)
-        process root
+      def map source
+        @filename = source.filename
+        @code = source.code
+        @comments = source.comments
+        @pins = Solargraph::SourceMap::NodeProcessor.process(source.node, Solargraph::SourceMap::Region.new(source: source), [])
         process_comment_directives
-        [@pins, @locals]
+        locals = @pins.select{|p| [Pin::LocalVariable, Pin::MethodParameter, Pin::BlockParameter].include?(p.class)}
+        [@pins - locals, locals]
       end
 
       def unmap filename, code
@@ -50,23 +35,10 @@ module Solargraph
         # @return [Array]
         def map source
           return new.unmap(source.filename, source.code) unless source.parsed?
-          new.map source.filename, source.code, source.node, source.comments
+          new.map source
         end
       end
 
-      # @param node [Parser::AST::Node]
-      # @return [String]
-      def code_for node
-        # @todo Using node locations on code with converted EOLs seems
-        #   slightly more efficient than calculating offsets.
-        b = node.location.expression.begin.begin_pos
-        e = node.location.expression.end.end_pos
-        # b = Position.line_char_to_offset(@code, node.location.line - 1, node.location.column)
-        # e = Position.line_char_to_offset(@code, node.location.last_line - 1, node.location.last_column)
-        frag = source_from_parser[b..e-1].to_s
-        frag.strip.gsub(/,$/, '')
-      end
-
       # @return [String]
       def filename
         @filename
@@ -77,346 +49,6 @@ module Solargraph
         @pins ||= []
       end
 
-      # @param node [Parser::AST::Node]
-      def process node, tree = [], visibility = :public, scope = :instance, fqn = '', stack = []
-        return unless node.is_a?(AST::Node)
-        return if node.type == :str
-        stack.push node
-        if node.kind_of?(AST::Node)
-          @node_stack.unshift node
-          if node.type == :class or node.type == :module
-            visibility = :public
-            if node.children[0].kind_of?(AST::Node) and node.children[0].children[0].kind_of?(AST::Node) and node.children[0].children[0].type == :cbase
-              tree = pack_name(node.children[0])
-              tree.shift if tree.first.empty?
-            else
-              tree = tree + pack_name(node.children[0])
-            end
-            fqn = tree.join('::')
-            sc = nil
-            if node.type == :class and !node.children[1].nil?
-              sc = unpack_name(node.children[1])
-            end
-            pins.push Solargraph::Pin::Namespace.new(get_node_location(node), tree[0..-2].join('::') || '', pack_name(node.children[0]).last.to_s, comments_for(node), node.type, visibility)
-            pins.push Pin::Reference::Superclass.new(pins.last.location, pins.last.path, sc) unless sc.nil?
-          end
-          file = filename
-          node.children.each do |c|
-            if c.kind_of?(AST::Node)
-              if c.type == :ivasgn
-                here = get_node_start_position(c)
-                named_path = get_named_path_pin(here)
-                if c.children[1].nil?
-                  ora = find_parent(stack, :or_asgn)
-                  unless ora.nil?
-                    u = c.updated(:ivasgn, c.children + ora.children[1..-1], nil)
-                    pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, comments_for(u), u.children[1], infer_literal_node_type(u.children[1]), named_path.context)
-                    if visibility == :module_function and named_path.kind == Pin::METHOD
-                      other = ComplexType.parse("Module<#{named_path.context.namespace}>")
-                      pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, comments_for(u), u.children[1], infer_literal_node_type(u.children[1]), other) #unless other.nil?
-                    end
-                  end
-                else
-                  pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(c), fqn || '',c.children[0].to_s, comments_for(c), c.children[1], infer_literal_node_type(c.children[1]), named_path.context)
-                  if visibility == :module_function and named_path.kind == Pin::METHOD
-                    other = ComplexType.parse("Module<#{named_path.context.namespace}>")
-                     pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(c), fqn || '',c.children[0].to_s, comments_for(c), c.children[1], infer_literal_node_type(c.children[1]), other)
-                  end
-                end
-              elsif c.type == :cvasgn
-                here = get_node_start_position(c)
-                context = get_named_path_pin(here)
-                if c.children[1].nil?
-                  ora = find_parent(stack, :or_asgn)
-                  unless ora.nil?
-                    u = c.updated(:cvasgn, c.children + ora.children[1..-1], nil)
-                    pins.push Solargraph::Pin::ClassVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, comments_for(u), u.children[1], infer_literal_node_type(u.children[1]), context.context)
-                  end
-                else
-                  pins.push Solargraph::Pin::ClassVariable.new(get_node_location(c), fqn || '', c.children[0].to_s, comments_for(c), c.children[1], infer_literal_node_type(c.children[1]), context.context)
-                end
-              elsif c.type == :lvasgn
-                here = get_node_start_position(c)
-                context = get_named_path_pin(here)
-                block = get_block_pin(here)
-                presence = Range.new(here, block.location.range.ending)
-                if c.children[1].nil?
-                  ora = find_parent(stack, :or_asgn)
-                  unless ora.nil?
-                    u = c.updated(:lvasgn, c.children + ora.children[1..-1], nil)
-                    @locals.push Solargraph::Pin::LocalVariable.new(get_node_location(u), fqn, u.children[0].to_s, comments_for(ora), u.children[1], infer_literal_node_type(c.children[1]), context.context, block, presence)
-                  end
-                else
-                  @locals.push Solargraph::Pin::LocalVariable.new(get_node_location(c), fqn, c.children[0].to_s, comments_for(c), c.children[1], infer_literal_node_type(c.children[1]), context.context, block, presence)
-                end
-              elsif c.type == :gvasgn
-                if c.children[1].nil?
-                  ora = find_parent(stack, :or_asgn)
-                  unless ora.nil?
-                    u = c.updated(:gvasgn, c.children + ora.children[1..-1], nil)
-                    pins.push Solargraph::Pin::GlobalVariable.new(get_node_location(c), fqn, u.children[0].to_s, comments_for(c), u.children[1], infer_literal_node_type(c.children[1]), @pins.first.context)
-                  end
-                else
-                  pins.push Solargraph::Pin::GlobalVariable.new(get_node_location(c), fqn, c.children[0].to_s, comments_for(c), c.children[1], infer_literal_node_type(c.children[1]), @pins.first.context)
-                end
-              elsif c.type == :sym
-                pins.push Solargraph::Pin::Symbol.new(get_node_location(c), ":#{c.children[0]}")
-              elsif c.type == :casgn
-                here = get_node_start_position(c)
-                block = get_block_pin(here)
-                pins.push Solargraph::Pin::Constant.new(get_node_location(c), fqn, c.children[1].to_s, comments_for(c), c.children[2], infer_literal_node_type(c.children[2]), block.context, :public)
-              elsif c.type == :def
-                methpin = Solargraph::Pin::Method.new(get_node_location(c), fqn || '', c.children[(c.type == :def ? 0 : 1)].to_s, comments_for(c), scope, visibility, get_method_args(c))
-                if methpin.name == 'initialize' and methpin.scope == :instance
-                  pins.push Solargraph::Pin::Method.new(methpin.location, methpin.namespace, 'new', methpin.comments, :class, :public, methpin.parameters)
-                  # @todo Smelly instance variable access.
-                  pins.last.instance_variable_set(:@return_complex_type, ComplexType.parse(methpin.namespace))
-                  pins.push Solargraph::Pin::Method.new(methpin.location, methpin.namespace, methpin.name, methpin.comments, methpin.scope, :private, methpin.parameters)
-                elsif visibility == :module_function
-                  pins.push Solargraph::Pin::Method.new(methpin.location, methpin.namespace, methpin.name, methpin.comments, :class, :public, methpin.parameters)
-                  pins.push Solargraph::Pin::Method.new(methpin.location, methpin.namespace, methpin.name, methpin.comments, :instance, :private, methpin.parameters)
-                else
-                  pins.push methpin
-                end
-              elsif c.type == :defs
-                s_visi = visibility
-                s_visi = :public if s_visi == :module_function or scope != :class
-                if c.children[0].is_a?(AST::Node) and c.children[0].type == :self
-                  dfqn = fqn || ''
-                else
-                  dfqn = unpack_name(c.children[0])
-                end
-                unless dfqn.nil?
-                  pins.push Solargraph::Pin::Method.new(get_node_location(c), dfqn, "#{c.children[(node.type == :def ? 0 : 1)]}", comments_for(c), :class, s_visi, get_method_args(c))
-                  process c, tree, scope, :class, dfqn, stack
-                end
-                next
-              elsif c.type == :send and [:public, :protected, :private].include?(c.children[1])
-                visibility = c.children[1]
-              elsif c.type == :send and [:private_class_method].include?(c.children[1]) and c.children[2].kind_of?(AST::Node)
-                if c.children[2].type == :sym or c.children[2].type == :str
-                  ref = pins.select{|p| p.namespace == (fqn || '') and p.name == c.children[2].children[0].to_s}.first
-                  unless ref.nil?
-                    pins.delete ref
-                    pins.push Solargraph::Pin::Method.new(ref.location, ref.namespace, ref.name, ref.comments, ref.scope, :private, ref.parameters)
-                  end
-                else
-                  process c, tree, :private, :class, fqn, stack
-                  next
-                end
-              elsif c.type == :send and [:private_constant].include?(c.children[1]) and c.children[2].kind_of?(AST::Node)
-                if c.children[2].type == :sym or c.children[2].type == :str
-                  # @todo What to do about references?
-                  cn = c.children[2].children[0].to_s
-                  ref = pins.select{|p| p.namespace == (fqn || '') and p.name == cn}.first
-                  unless ref.nil?
-                    pins.delete ref
-                    # Might be either a namespace or constant
-                    if ref.kind == Pin::CONSTANT
-                      pins.push ref.class.new(ref.location, ref.namespace, ref.name, ref.comments, ref.signature, ref.return_type, ref.context, :private)
-                    else
-                      # pins.push ref.class.new(ref.location, ref.namespace, ref.name, ref.comments, ref.type, :private, (ref.superclass_reference.nil? ? nil : ref.superclass_reference.name))
-                      pins.push ref.class.new(ref.location, ref.namespace, ref.name, ref.comments, ref.type, :private)
-                    end
-                  end
-                end
-                next
-              elsif c.type == :send and c.children[1] == :module_function
-                if c.children[2].nil?
-                  visibility = :module_function
-                elsif c.children[2].type == :sym or c.children[2].type == :str
-                  # @todo What to do about references?
-                  c.children[2..-1].each do |x|
-                    cn = x.children[0].to_s
-                    ref = pins.select{|p| p.namespace == (fqn || '') and p.name == cn}.first
-                    unless ref.nil?
-                      pins.delete ref
-                      mm = Solargraph::Pin::Method.new(ref.location, ref.namespace, ref.name, ref.comments, :class, :public, ref.parameters)
-                      cm = Solargraph::Pin::Method.new(ref.location, ref.namespace, ref.name, ref.comments, :instance, :private, ref.parameters)
-                      pins.push mm, cm
-                      pins.select{|pin| pin.kind == Pin::INSTANCE_VARIABLE and pin.context == ref.context}.each do |ivar|
-                        pins.delete ivar
-                        pins.push Solargraph::Pin::InstanceVariable.new(ivar.location, ivar.namespace, ivar.name, ivar.comments, ivar.signature, ivar.instance_variable_get(:@literal), mm)
-                        pins.push Solargraph::Pin::InstanceVariable.new(ivar.location, ivar.namespace, ivar.name, ivar.comments, ivar.signature, ivar.instance_variable_get(:@literal), cm)
-                      end
-                    end
-                  end
-                elsif c.children[2].type == :def
-                  # @todo A single function
-                  process c, tree, :module_function, :class, fqn, stack
-                  next
-                end
-              elsif c.type == :send and c.children[1] == :include and c.children[0].nil?
-                last_node = get_last_in_stack_not_begin(stack)
-                if last_node.nil? or last_node.type == :class or last_node.type == :module or last_node.type == :source
-                  if c.children[2].kind_of?(AST::Node) and c.children[2].type == :const
-                    c.children[2..-1].each do |i|
-                      nspin = @pins.select{|pin| pin.kind == Pin::NAMESPACE and pin.path == fqn}.last
-                      unless nspin.nil?
-                        # iref = Pin::Reference.new(get_node_location(c), nspin.path, unpack_name(i))
-                        # nspin.include_references.push(iref)
-                        pins.push Pin::Reference::Include.new(get_node_location(c), nspin.path, unpack_name(i))
-                      end
-                    end
-                  end
-                end
-              elsif c.type == :send and c.children[1] == :extend and c.children[0].nil?
-                last_node = get_last_in_stack_not_begin(stack)
-                if last_node.nil? or last_node.type == :class or last_node.type == :module or last_node.type == :source
-                  c.children[2..-1].each do |i|
-                    nspin = @pins.select{|pin| pin.kind == Pin::NAMESPACE and pin.path == fqn}.last
-                    unless nspin.nil?
-                      ref = nil
-                      if i.type == :self
-                        # ref = Pin::Reference.new(get_node_location(c), nspin.path, nspin.path)
-                        ref = Pin::Reference::Extend.new(get_node_location(c), nspin.path, nspin.path)
-                      elsif i.type == :const
-                        # ref = Pin::Reference.new(get_node_location(c), nspin.path, unpack_name(i))
-                        ref = Pin::Reference::Extend.new(get_node_location(c), nspin.path, unpack_name(i))
-                      end
-                      # nspin.extend_references.push(ref) unless ref.nil?
-                      pins.push ref unless ref.nil?
-                    end
-                  end
-                end
-              elsif c.type == :send && [:attr_reader, :attr_writer, :attr_accessor].include?(c.children[1])
-                c.children[2..-1].each do |a|
-                  if c.children[1] == :attr_reader or c.children[1] == :attr_accessor
-                    pins.push Solargraph::Pin::Attribute.new(get_node_location(c), fqn || '', "#{a.children[0]}", comments_for(c), :reader, scope, visibility)
-                  end
-                  if c.children[1] == :attr_writer or c.children[1] == :attr_accessor
-                    pins.push Solargraph::Pin::Attribute.new(get_node_location(c), fqn || '', "#{a.children[0]}=", comments_for(c), :writer, scope, visibility)
-                  end
-                end
-              elsif c.type == :alias
-                pin = pins.select{|p| p.name == c.children[1].children[0].to_s && p.namespace == fqn && p.scope == scope}.first
-                unless pin.nil?
-                  if pin.is_a?(Solargraph::Pin::Method)
-                    pins.push Solargraph::Pin::Method.new(get_node_location(c), pin.namespace, c.children[0].children[0].to_s, comments_for(c) || pin.comments, pin.scope, pin.visibility, pin.parameters)
-                  elsif pin.is_a?(Solargraph::Pin::Attribute)
-                    pins.push Solargraph::Pin::Attribute.new(get_node_location(c), pin.namespace, c.children[0].children[0].to_s, comments_for(c) || pin.comments, pin.access, pin.scope, pin.visibility)
-                  end
-                end
-              elsif c.type == :send && c.children[1] == :alias_method && c.children[2] && c.children[2] && c.children[2].type == :sym && c.children[3] && c.children[3].type == :sym
-                pin = pins.select{|p| p.name == c.children[3].children[0].to_s && p.namespace == fqn && p.scope == scope}.first
-                unless pin.nil?
-                  if pin.is_a?(Solargraph::Pin::Method)
-                    pins.push Solargraph::Pin::Method.new(get_node_location(c), pin.namespace, c.children[2].children[0].to_s, comments_for(c) || pin.comments, pin.scope, pin.visibility, pin.parameters)
-                  elsif pin.is_a?(Solargraph::Pin::Attribute)
-                    pins.push Solargraph::Pin::Attribute.new(get_node_location(c), pin.namespace, c.children[2].children[0].to_s, comments_for(c) || pin.comments, pin.access, pin.scope, pin.visibility)
-                  end
-                end
-              elsif c.type == :sclass && c.children[0].type == :self
-                process c, tree, :public, :class, fqn || '', stack
-                next
-              elsif c.type == :send && c.children[1] == :require
-                if c.children[2].kind_of?(AST::Node) and c.children[2].type == :str
-                  # @requires.push Solargraph::Pin::Reference.new(get_node_location(c), fqn, c.children[2].children[0].to_s)
-                  pins.push Pin::Reference::Require.new(get_node_location(c), c.children[2].children[0].to_s)
-                end
-              elsif c.type == :args
-                if @node_stack.first.type == :block
-                  pi = 0
-                  c.children.each do |u|
-                    here = get_node_start_position(c)
-                    blk = get_block_pin(here)
-                    @locals.push Solargraph::Pin::BlockParameter.new(get_node_location(u), fqn || '', "#{u.children[0]}", comments_for(c), blk)
-                    blk.parameters.push @locals.push.last
-                    pi += 1
-                  end
-                else
-                  c.children.each do |u|
-                    here = get_node_start_position(u)
-                    context = get_named_path_pin(here)
-                    block = get_block_pin(here)
-                    presence = Range.new(here, block.location.range.ending)
-                    @locals.push Solargraph::Pin::MethodParameter.new(get_node_location(u), fqn, u.children[0].to_s, comments_for(c), resolve_node_signature(u.children[1]), infer_literal_node_type(u.children[1]), context, block, presence)
-                  end
-                end
-              elsif c.type == :block
-                here = get_node_start_position(c)
-                named_path = get_named_path_pin(here)
-                @pins.push Solargraph::Pin::Block.new(get_node_location(c), fqn || '', '', comments_for(c), c.children[0], named_path.context)
-              end
-              process c, tree, visibility, scope, fqn, stack
-            end
-          end
-          @node_stack.shift
-        end
-        stack.pop
-      end
-
-      def get_last_in_stack_not_begin stack
-        index = stack.length - 1
-        last = stack[index]
-        while !last.nil? and last.type == :begin
-          index -= 1
-          last = stack[index]
-        end
-        last
-      end
-
-      def get_block_pin position
-        @pins.select{|pin| [Pin::BLOCK, Pin::NAMESPACE, Pin::METHOD].include?(pin.kind) and pin.location.range.contain?(position)}.last
-      end
-
-      def get_named_path_pin position
-        @pins.select{|pin| [Pin::NAMESPACE, Pin::METHOD].include?(pin.kind) and pin.location.range.contain?(position)}.last
-      end
-
-      def get_namespace_pin position
-        @pins.select{|pin| pin.kind == Pin::NAMESPACE and pin.location.range.contain?(position)}.last
-      end
-
-      # @return [String]
-      def comments_for node
-        result = @node_comments[node.loc]
-        return nil if result.nil?
-        result
-      end
-
-      # @param node [Parser::AST::Node]
-      # @return [Solargraph::Location]
-      def get_node_location(node)
-        if node.nil?
-          st = Position.new(0, 0)
-          en = Position.from_offset(@code, @code.length)
-        else
-          st = Position.new(node.loc.line, node.loc.column)
-          en = Position.new(node.loc.last_line, node.loc.last_column)
-        end
-        range = Range.new(st, en)
-        Location.new(filename, range)
-      end
-
-      # @param node [Parser::AST::Node]
-      # @param comments [Array]
-      # @return [Hash]
-      def associate_comments node, comments
-        return nil if comments.nil?
-        comment_hash = Parser::Source::Comment.associate_locations(node, comments)
-        result_hash = {}
-        comment_hash.each_pair { |k, v|
-          ctxt = ''
-          num = nil
-          started = false
-          v.each { |l|
-            # Trim the comment and minimum leading whitespace
-            p = l.text.gsub(/^#/, '')
-            if num.nil? and !p.strip.empty?
-              num = p.index(/[^ ]/)
-              started = true
-            elsif started and !p.strip.empty?
-              cur = p.index(/[^ ]/)
-              num = cur if cur < num
-            end
-            ctxt += "#{p[num..-1]}\n" if started
-          }
-          result_hash[k] = ctxt
-        }
-        result_hash
-      end
-
       # @param node [Parser::AST::Node]
       # @return [Solargraph::Pin::Namespace]
       def namespace_for(node)
@@ -428,46 +60,6 @@ module Solargraph
         @pins.select{|pin| pin.kind == Pin::NAMESPACE and pin.location.range.contain?(position)}.last
       end
 
-      def find_parent(stack, *types)
-        stack.reverse.each { |p|
-          return p if types.include?(p.type)
-        }
-        nil
-      end
-
-      def get_method_args node
-        return [] if node.nil?
-        list = nil
-        args = []
-        node.children.each { |c|
-          if c.kind_of?(AST::Node) and c.type == :args
-            list = c
-            break
-          end
-        }
-        return args if list.nil?
-        list.children.each { |c|
-          if c.type == :arg
-            args.push c.children[0].to_s
-          elsif c.type == :restarg
-            args.push "*#{c.children[0]}"
-          elsif c.type == :optarg
-            args.push "#{c.children[0]} = #{code_for(c.children[1])}"
-          elsif c.type == :kwarg
-            args.push "#{c.children[0]}:"
-          elsif c.type == :kwoptarg
-            args.push "#{c.children[0]}: #{code_for(c.children[1])}"
-          elsif c.type == :blockarg
-            args.push "&#{c.children[0]}"
-          end
-        }
-        args
-      end
-
-      def source_from_parser
-        @source_from_parser ||= @code.gsub(/\r\n/, "\n")
-      end
-
       def process_comment position, comment
         cmnt = remove_inline_comment_hashes(comment)
         return unless cmnt =~ /(@\!method|@\!attribute|@\!domain|@\!macro)/
@@ -485,7 +77,7 @@ module Solargraph
           namespace = namespace_at(position)
           gen_src = Solargraph::SourceMap.load_string("def #{directive.tag.name};end")
           gen_pin = gen_src.pins.last # Method is last pin after root namespace
-          @pins.push Solargraph::Pin::Method.new(location, namespace.path, gen_pin.name, docstring.all, :instance, :public, gen_pin.parameters)
+          @pins.push Solargraph::Pin::Method.new(location, namespace.path, gen_pin.name, docstring.all, :instance, :public, gen_pin.parameters, nil)
         when 'attribute'
           namespace = namespace_at(position)
           t = (directive.tag.types.nil? || directive.tag.types.empty?) ? nil : directive.tag.types.flatten.join('')
@@ -499,10 +91,6 @@ module Solargraph
         when 'domain'
           namespace = namespace_at(position)
           namespace.domains.push directive.tag.text
-        when 'macro'
-          nxt_pos = Position.new(position.line + 1, @code.lines[position.line + 1].length)
-          path_pin = get_named_path_pin(nxt_pos)
-          path_pin.macros.push directive
         end
       end