solargraph 0.24.1 → 0.25.0

data/lib/solargraph/pin/method_parameter.rb

@@ -4,19 +4,26 @@ module Solargraph
       def return_complex_types
         if @return_complex_types.nil?
           @return_complex_types = []
-          unless block.docstring.nil?
-            found = nil
-            params = block.docstring.tags(:param)
-            params.each do |p|
-              next unless p.name == name
-              found = p
-            end
-            @return_complex_types.concat ComplexType.parse(*found.types) unless found.nil? or found.types.nil?
+          found = nil
+          params = block.docstring.tags(:param)
+          params.each do |p|
+            next unless p.name == name
+            found = p
           end
+          @return_complex_types.concat ComplexType.parse(*found.types) unless found.nil? or found.types.nil?
         end
         super
         @return_complex_types
       end
+
+      def try_merge! pin
+        return false unless super
+        # @todo This is a little expensive, but it's necessary because
+        #   parameter data depends on the method's docstring.
+        @return_complex_types = pin.return_complex_types
+        reset_conversions
+        true
+      end
     end
   end
 end

data/lib/solargraph/pin/namespace.rb

@@ -8,8 +8,8 @@ module Solargraph
       # @return [Pin::Reference]
       attr_reader :superclass_reference
 
-      def initialize location, namespace, name, docstring, type, visibility, superclass
-        super(location, namespace, name, docstring)
+      def initialize location, namespace, name, comments, type, visibility, superclass
+        super(location, namespace, name, comments)
         @type = type
         @visibility = visibility
         # @superclass_reference = Reference.new(self, superclass) unless superclass.nil?

data/lib/solargraph/pin/reference.rb

@@ -23,6 +23,13 @@ module Solargraph
       def filename
         location.filename
       end
+
+      def == other
+        return false unless self.class == other.class
+        location == other.location and
+          namespace = other.namespace and
+          name == other.name
+      end
     end
   end
 end

data/lib/solargraph/pin/yard_pin.rb

@@ -0,0 +1,10 @@
+module Solargraph
+  module Pin
+    module YardPin
+      autoload :YardMixin, 'solargraph/pin/yard_pin/yard_mixin'
+      autoload :Constant,  'solargraph/pin/yard_pin/constant'
+      autoload :Method,    'solargraph/pin/yard_pin/method'
+      autoload :Namespace, 'solargraph/pin/yard_pin/namespace'
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Solargraph
+  module Pin
+    module YardPin
+      class Constant < Pin::Constant
+        include YardMixin
+
+        def initialize code_object, location
+          super(location, code_object.namespace.to_s, code_object.name.to_s, comments_from(code_object), nil, nil, nil, code_object.visibility)
+        end
+      end
+    end
+  end
+end
+map = Solargraph::ApiMap.new

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

@@ -0,0 +1,35 @@
+module Solargraph
+  module Pin
+    module YardPin
+      class Method < Pin::Method
+        include YardMixin
+
+        def initialize code_object, location
+          comments = (code_object.docstring ? code_object.docstring.all : nil)
+          super(location, code_object.namespace.to_s, code_object.name.to_s, comments, code_object.scope, code_object.visibility, get_parameters(code_object))
+        end
+
+        def return_complex_types
+          @return_complex_types ||= Solargraph::ComplexType.parse(Solargraph::CoreFills::CUSTOM_RETURN_TYPES[path]) if Solargraph::CoreFills::CUSTOM_RETURN_TYPES.has_key?(path)
+          super
+        end
+
+        private
+
+        def get_parameters code_object
+          return [] unless code_object.kind_of?(YARD::CodeObjects::MethodObject)
+          args = []
+          code_object.parameters.each do |a|
+            p = a[0]
+            unless a[1].nil?
+              p += ' =' unless p.end_with?(':')
+              p += " #{a[1]}"
+            end
+            args.push p
+          end
+          args
+        end  
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Solargraph
+  module Pin
+    module YardPin
+      class Namespace < Pin::Namespace
+        include YardMixin
+
+        def initialize code_object, location
+          superclass = nil
+          superclass = code_object.superclass.to_s if code_object.is_a?(YARD::CodeObjects::ClassObject) and code_object.superclass
+          super(location, code_object.namespace.to_s, code_object.name.to_s, comments_from(code_object), namespace_type(code_object), code_object.visibility, superclass)
+          # code_object.class_mixins.each do |m|
+          #   extend_references.push Pin::Reference.new(location, path, m.path)
+          # end
+          # code_object.instance_mixins.each do |m|
+          #   include_references.push Pin::Reference.new(location, path, m.path)
+          # end
+        end
+
+        private
+
+        def namespace_type code_object
+          code_object.is_a?(YARD::CodeObjects::ClassObject) ? :class : :module
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Solargraph
+  module Pin
+    module YardPin
+      module YardMixin
+        def yard_pin?
+          true
+        end
+
+        private
+
+        def comments_from code_object
+          return nil if code_object.docstring.nil?
+          code_object.docstring.all
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source.rb

@@ -1,5 +1,6 @@
 require 'parser/current'
 require 'time'
+require 'yard'
 
 module Solargraph
   class Source
@@ -63,6 +64,7 @@ module Solargraph
         @fixed = code
         @filename = filename
         @version = 0
+        @domains = []
         begin
           parse
         rescue Parser::SyntaxError, EncodingError
@@ -315,9 +317,9 @@ module Solargraph
     def hard_fix_node
       @fixed = @code.gsub(/[^\s]/, '_')
       node, comments = inner_parse(@fixed, filename)
+      process_parsed node, comments
       @node = node
       @comments = comments
-      process_parsed node, comments
       @parsed = false
     end
 
@@ -335,24 +337,66 @@ module Solargraph
       synchronize_mapped *new_map_data
     end
 
-    def synchronize_mapped new_pins, new_locals, new_requires, new_symbols, new_path_macros, new_domains
-      resync = (
-        @pins.nil? or
-        @locals.nil? or
-        @pins[1..-1] != new_pins[1..-1] or
-        @locals != new_locals
-        # @requires != new_requires or
-        # @path_macros != new_path_macros or
-        # @new_domains != new_domains
-      )
+    def synchronize_mapped new_pins, new_locals, new_requires, new_symbols #, new_path_macros, new_domains
+      return if @requires == new_requires and @symbols == new_symbols and try_merge(new_pins, new_locals)
       @pins = new_pins
       @locals = new_locals
       @requires = new_requires
       @symbols = new_symbols
-      @path_macros = new_path_macros
-      @domains = new_domains
-      # Check for bare minimum change required to synchronize workspaces, etc.
-      @stime = Time.now if resync
+      @domains = []
+      @path_macros = {}
+      dirpins = []
+      @pins.select(&:maybe_directives?).each do |pin|
+        dirpins.push pin unless pin.directives.empty?
+      end
+      process_directives dirpins
+      @stime = Time.now
+    end
+
+    # @param new_pins [Array<Solargraph::Pin::Base>]
+    # @param new_locals [Array<Solargraph::Pin::Base>]
+    # @return [Boolean]
+    def try_merge new_pins, new_locals
+      return false if @pins.nil? or @locals.nil? or new_pins.length != @pins.length or new_locals.length != @locals.length
+      new_pins.each_index do |i|
+        return false unless @pins[i].try_merge!(new_pins[i])
+      end
+      new_locals.each_index do |i|
+        return false unless @locals[i].try_merge!(new_locals[i])
+      end
+      true
+    end
+
+    # @return [void]
+    def process_directives pins
+      pins.each do |pin|
+        pin.directives.each do |d|
+          # ns = namespace_for(k.node)
+          ns = (pin.kind == Pin::NAMESPACE ? pin.path : pin.namespace)
+          docstring = YARD::Docstring.parser.parse(d.tag.text).to_docstring
+          if d.tag.tag_name == 'attribute'
+            t = (d.tag.types.nil? || d.tag.types.empty?) ? nil : d.tag.types.flatten.join('')
+            if t.nil? or t.include?('r')
+              # location, namespace, name, docstring, access
+              @pins.push Solargraph::Pin::Attribute.new(pin.location, pin.path, d.tag.name, docstring.all, :reader, :instance)
+            end
+            if t.nil? or t.include?('w')
+              @pins.push Solargraph::Pin::Attribute.new(pin.location, pin.path, "#{d.tag.name}=", docstring.all, :writer, :instance)
+            end
+          elsif d.tag.tag_name == 'method'
+            gen_src = Source.new("def #{d.tag.name};end", filename)
+            gen_pin = gen_src.pins.last # Method is last pin after root namespace
+            # next if ns.nil? or ns.empty? # @todo Add methods to global namespace?
+            @pins.push Solargraph::Pin::Method.new(pin.location, pin.path, gen_pin.name, docstring.all, :instance, :public, [])
+          elsif d.tag.tag_name == 'macro'
+            @path_macros[pin.path] = d
+          elsif d.tag.tag_name == 'domain'
+            @domains.push d.tag.text
+          else
+            # STDERR.puts "Nothing to do for directive: #{d}"
+          end
+        end
+      end
     end
 
     class << self

data/lib/solargraph/source/mapper.rb

@@ -20,25 +20,24 @@ module Solargraph
         @node = node
         @node_stack = []
         @directives = {}
-        @docstring_hash = associate_comments(node, comments)
-        # @todo Stuff that needs to be resolved
-        @variables = []
-        @path_macros = {}
-        @domains = []
-
+        @node_comments = associate_comments(node, comments)
         @pins = []
         @requires = []
         @symbols = []
         @locals = []
 
+        @used_comment_locs = []
+
         # 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, nil)
         process root
-        process_directives
-        [@pins, @locals, @requires, @symbols, @path_macros, @domains]
+        @node_comments.reject{|k, v| @used_comment_locs.include?(k)}.each do |k, v|
+          @pins.first.comments.concat v
+        end
+        [@pins, @locals, @requires, @symbols]
       end
 
       class << self
@@ -83,7 +82,7 @@ module Solargraph
             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, docstring_for(node), node.type, visibility, sc)
+            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, sc)
           end
           file = filename
           node.children.each do |c|
@@ -95,18 +94,17 @@ module Solargraph
                   ora = find_parent(stack, :or_asgn)
                   unless ora.nil?
                     u = c.updated(:ivasgn, c.children + ora.children[1..-1], nil)
-                    @docstring_hash[u.loc] = docstring_for(ora)
-                    pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, docstring_for(u), resolve_node_signature(u.children[1]), infer_literal_node_type(u.children[1]), context)
+                    pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, comments_for(u), resolve_node_signature(u.children[1]), infer_literal_node_type(u.children[1]), context)
                     if visibility == :module_function and context.kind == Pin::METHOD
                       other = pins.select{|pin| pin.path == "#{context.namespace}.#{context.name}"}.first
-                      pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, docstring_for(u), resolve_node_signature(u.children[1]), infer_literal_node_type(u.children[1]), other) unless other.nil?
+                      pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, comments_for(u), resolve_node_signature(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, docstring_for(c), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), context)
+                  pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(c), fqn || '',c.children[0].to_s, comments_for(c), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), context)
                   if visibility == :module_function and context.kind == Pin::METHOD
                     other = pins.select{|pin| pin.path == "#{context.namespace}.#{context.name}"}.first
-                    pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(c), fqn || '',c.children[0].to_s, docstring_for(c), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), other)
+                    pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(c), fqn || '',c.children[0].to_s, comments_for(c), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), other)
                   end
                 end
               elsif c.type == :cvasgn
@@ -116,11 +114,10 @@ module Solargraph
                   ora = find_parent(stack, :or_asgn)
                   unless ora.nil?
                     u = c.updated(:cvasgn, c.children + ora.children[1..-1], nil)
-                    @docstring_hash[u.loc] = docstring_for(ora)
-                    pins.push Solargraph::Pin::ClassVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, docstring_for(u), resolve_node_signature(u.children[1]), infer_literal_node_type(u.children[1]), context)
+                    pins.push Solargraph::Pin::ClassVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, comments_for(u), resolve_node_signature(u.children[1]), infer_literal_node_type(u.children[1]), context)
                   end
                 else
-                  pins.push Solargraph::Pin::ClassVariable.new(get_node_location(c), fqn || '', c.children[0].to_s, docstring_for(c), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), context)
+                  pins.push Solargraph::Pin::ClassVariable.new(get_node_location(c), fqn || '', c.children[0].to_s, comments_for(c), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), context)
                 end
               elsif c.type == :lvasgn
                 here = get_node_start_position(c)
@@ -131,31 +128,29 @@ module Solargraph
                   ora = find_parent(stack, :or_asgn)
                   unless ora.nil?
                     u = c.updated(:lvasgn, c.children + ora.children[1..-1], nil)
-                    @docstring_hash[u.loc] = docstring_for(ora)
-                    @locals.push Solargraph::Pin::LocalVariable.new(get_node_location(u), fqn, u.children[0].to_s, docstring_for(u), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), context, block, presence)
+                    @locals.push Solargraph::Pin::LocalVariable.new(get_node_location(u), fqn, u.children[0].to_s, comments_for(ora), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), context, block, presence)
                   end
                 else
-                  @locals.push Solargraph::Pin::LocalVariable.new(get_node_location(c), fqn, c.children[0].to_s, docstring_for(c), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), context, block, presence)
+                  @locals.push Solargraph::Pin::LocalVariable.new(get_node_location(c), fqn, c.children[0].to_s, comments_for(c), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), context, block, presence)
                 end
               elsif c.type == :gvasgn
-                pins.push Solargraph::Pin::GlobalVariable.new(get_node_location(c), fqn, c.children[0].to_s, docstring_for(c), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), @pins.first)
+                pins.push Solargraph::Pin::GlobalVariable.new(get_node_location(c), fqn, c.children[0].to_s, comments_for(c), resolve_node_signature(c.children[1]), infer_literal_node_type(c.children[1]), @pins.first)
               elsif c.type == :sym
                 @symbols.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, docstring_for(c), resolve_node_signature(c.children[2]), infer_literal_node_type(c.children[2]), block, :public)
+                pins.push Solargraph::Pin::Constant.new(get_node_location(c), fqn, c.children[1].to_s, comments_for(c), resolve_node_signature(c.children[2]), infer_literal_node_type(c.children[2]), block, :public)
               elsif c.type == :def
-                methpin = Solargraph::Pin::Method.new(get_node_location(c), fqn || '', c.children[(c.type == :def ? 0 : 1)].to_s, docstring_for(c), scope, visibility, get_method_args(c))
+                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.docstring, :class, :public, methpin.parameters)
+                  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_type, methpin.namespace)
                   pins.last.instance_variable_set(:@return_complex_types, ComplexType.parse(methpin.namespace))
-                  pins.push Solargraph::Pin::Method.new(methpin.location, methpin.namespace, methpin.name, methpin.docstring, methpin.scope, :private, methpin.parameters)
+                  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.docstring, :class, :public, methpin.parameters)
-                  pins.push Solargraph::Pin::Method.new(methpin.location, methpin.namespace, methpin.name, methpin.docstring, :instance, :private, methpin.parameters)
+                  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
@@ -168,7 +163,7 @@ module Solargraph
                   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)]}", docstring_for(c), :class, s_visi, get_method_args(c))
+                  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
@@ -179,7 +174,7 @@ module Solargraph
                   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.docstring, ref.scope, :private, ref.parameters)
+                    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
@@ -194,15 +189,14 @@ module Solargraph
                     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.docstring, ref.signature, ref.return_type, ref.context, :private)
+                      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.docstring, 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, (ref.superclass_reference.nil? ? nil : ref.superclass_reference.name))
                     end
                   end
                 end
                 next
               elsif c.type == :send and c.children[1] == :module_function
-                # @todo Handle module_function
                 if c.children[2].nil?
                   visibility = :module_function
                 elsif c.children[2].type == :sym or c.children[2].type == :str
@@ -212,13 +206,13 @@ module Solargraph
                     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.docstring, :class, :public, ref.parameters)
-                      cm = Solargraph::Pin::Method.new(ref.location, ref.namespace, ref.name, ref.docstring, :instance, :private, ref.parameters)
+                      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}.each do |ivar|
                         pins.delete ivar
-                        pins.push Solargraph::Pin::InstanceVariable.new(ivar.location, ivar.namespace, ivar.name, ivar.docstring, ivar.signature, ivar.instance_variable_get(:@literal), mm)
-                        pins.push Solargraph::Pin::InstanceVariable.new(ivar.location, ivar.namespace, ivar.name, ivar.docstring, ivar.signature, ivar.instance_variable_get(:@literal), cm)
+                        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
@@ -259,10 +253,10 @@ module Solargraph
               elsif c.type == :send and [: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]}", docstring_for(c), :reader, scope)
+                    pins.push Solargraph::Pin::Attribute.new(get_node_location(c), fqn || '', "#{a.children[0]}", comments_for(c), :reader, scope)
                   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]}=", docstring_for(c), :writer, scope)
+                    pins.push Solargraph::Pin::Attribute.new(get_node_location(c), fqn || '', "#{a.children[0]}=", comments_for(c), :writer, scope)
                   end
                 end
               elsif c.type == :sclass and c.children[0].type == :self
@@ -270,35 +264,29 @@ module Solargraph
                 next
               elsif c.type == :send and c.children[1] == :require
                 if c.children[2].kind_of?(AST::Node) and c.children[2].type == :str
-                  # @requires.push c.children[2].children[0].to_s
                   @requires.push Solargraph::Pin::Reference.new(get_node_location(c), fqn, 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|
-                    # @todo Fix this
-                    # pins.push Solargraph::Pin::BlockParameter.new(self, u, fqn || '', @node_stack.clone, pi)
                     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]}", docstring_for(c), blk)
+                    @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(c)
-                    # blk = get_block_pin(here)
-                    # @locals.push Solargraph::Pin::MethodParameter.new(get_node_location(u), fqn || '', "#{u.children[0]}", docstring_for(c), blk)
                     here = get_node_start_position(u)
                     context = get_named_path_pin(here)
                     block = get_block_pin(here)
                     presence = Source::Range.new(here, block.location.range.ending)
-                    @locals.push Solargraph::Pin::MethodParameter.new(get_node_location(u), fqn, u.children[0].to_s, docstring_for(c), resolve_node_signature(u.children[1]), infer_literal_node_type(u.children[1]), context, block, presence)
+                    @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
-                @pins.push Solargraph::Pin::Block.new(get_node_location(c), fqn || '', '', docstring_for(c), resolve_node_signature(c.children[0]))
+                @pins.push Solargraph::Pin::Block.new(get_node_location(c), fqn || '', '', comments_for(c), resolve_node_signature(c.children[0]))
               end
               process c, tree, visibility, scope, fqn, stack
             end
@@ -326,10 +314,12 @@ module Solargraph
         @pins.select{|pin| [Pin::NAMESPACE, Pin::METHOD].include?(pin.kind) and pin.location.range.contain?(position)}.last
       end
 
-      # @return [YARD::Docstring]
-      def docstring_for node
-        return @docstring_hash[node.loc] if node.respond_to?(:loc)
-        nil
+      # @return [String]
+      def comments_for node
+        result = @node_comments[node.loc]
+        return nil if result.nil?
+        @used_comment_locs.push node.loc
+        result
       end
 
       # @param node [Parser::AST::Node]
@@ -352,7 +342,7 @@ module Solargraph
       def associate_comments node, comments
         return nil if comments.nil?
         comment_hash = Parser::Source::Comment.associate_locations(node, comments)
-        yard_hash = {}
+        result_hash = {}
         comment_hash.each_pair { |k, v|
           ctxt = ''
           num = nil
@@ -367,18 +357,11 @@ module Solargraph
               cur = p.index(/[^ ]/)
               num = cur if cur < num
             end
-            if started
-              ctxt += "#{p[num..-1]}\n"
-            end
+            ctxt += "#{p[num..-1]}\n" if started
           }
-          parse = YARD::Docstring.parser.parse(ctxt)
-          unless parse.directives.empty?
-            @directives[k] ||= []
-            @directives[k].concat parse.directives
-          end
-          yard_hash[k] = parse.to_docstring
+          result_hash[k] = ctxt
         }
-        yard_hash
+        result_hash
       end
 
       # @param node [Parser::AST::Node]
@@ -388,42 +371,6 @@ module Solargraph
         @pins.select{|pin| pin.kind == Pin::NAMESPACE and pin.location.range.contain?(position)}.last
       end
 
-      # @return [void]
-      def process_directives
-        @directives.each_pair do |k, v|
-          v.each do |d|
-            ns = namespace_for(k.node)
-            docstring = YARD::Docstring.parser.parse(d.tag.text).to_docstring
-            if d.tag.tag_name == 'attribute'
-              t = (d.tag.types.nil? || d.tag.types.empty?) ? nil : d.tag.types.flatten.join('')
-              if t.nil? or t.include?('r')
-                # location, namespace, name, docstring, access
-                pins.push Solargraph::Pin::Attribute.new(get_node_location(k.node), namespace_for(k.node).path, d.tag.name, docstring, :reader, :instance)
-              end
-              if t.nil? or t.include?('w')
-                pins.push Solargraph::Pin::Attribute.new(get_node_location(k.node), namespace_for(k.node).path, "#{d.tag.name}=", docstring, :writer, :instance)
-              end
-            elsif d.tag.tag_name == 'method'
-              gen_src = Source.new("def #{d.tag.name};end", filename)
-              gen_pin = gen_src.pins.last # Method is last pin after root namespace
-              nsp = namespace_for(k.node)
-              next if nsp.nil? # @todo Add methods to global namespace?
-              @pins.push Solargraph::Pin::Method.new(get_node_location(k.node), nsp.path, gen_pin.name, docstring, :instance, :public, [])
-            elsif d.tag.tag_name == 'macro'
-              # @todo Handle various types of macros (attach, new, whatever)
-              # path = path_for(k.node)
-              here = get_node_start_position(k.node)
-              pin = @pins.select{|pin| [Pin::NAMESPACE, Pin::METHOD].include?(pin.kind) and pin.location.range.contain?(here)}.first
-              @path_macros[pin.path] = v
-            elsif d.tag.tag_name == 'domain'
-              @domains.push d.tag.text
-            else
-              # STDERR.puts "Nothing to do for directive: #{d}"
-            end
-          end
-        end
-      end
-
       def find_parent(stack, *types)
         stack.reverse.each { |p|
           return p if types.include?(p.type)