solargraph 0.59.1 → 0.60.0

data/lib/solargraph/source_map/mapper.rb

@@ -61,13 +61,6 @@ module Solargraph
         @pins ||= []
       end
 
-      # @param position [Solargraph::Position]
-      # @return [Solargraph::Pin::Closure]
-      def closure_at position
-        # @sg-ignore Need to add nil check here
-        pins.select { |pin| pin.is_a?(Pin::Closure) and pin.location.range.contain?(position) }.last
-      end
-
       # @param source_position [Position]
       # @param comment_position [Position]
       # @param comment [String]
@@ -108,135 +101,12 @@ module Solargraph
       # @param directive [YARD::Tags::Directive]
       # @return [void]
       def process_directive source_position, comment_position, directive
-        # @sg-ignore Need to add nil check here
-        docstring = Solargraph::Source.parse_docstring(directive.tag.text).to_docstring
-        location = Location.new(@filename, Range.new(comment_position, comment_position))
-        case directive.tag.tag_name
-        when 'method'
-          namespace = closure_at(source_position) || @pins.first
-          # @sg-ignore Need to add nil check here
-          namespace = closure_at(comment_position) if namespace.location.range.start.line < comment_position.line
-          begin
-            src = Solargraph::Source.load_string("def #{directive.tag.name};end", @source.filename)
-            region = Parser::Region.new(source: src, closure: namespace)
-            # @type [Array<Pin::Method>]
-            method_gen_pins = Parser.process_node(src.node, region).first.select { |pin| pin.is_a?(Pin::Method) }
-            gen_pin = method_gen_pins.last
-            return if gen_pin.nil?
-            # Move the location to the end of the line so it gets recognized
-            # as originating from a comment
-            shifted = Solargraph::Position.new(comment_position.line,
-                                               @code.lines[comment_position.line].to_s.chomp.length)
-            # @todo: Smelly instance variable access
-            gen_pin.instance_variable_set(:@comments, docstring.all.to_s)
-            gen_pin.instance_variable_set(:@location, Solargraph::Location.new(@filename, Range.new(shifted, shifted)))
-            gen_pin.instance_variable_set(:@explicit, false)
-            @pins.push gen_pin
-          rescue Parser::SyntaxError
-            # @todo Handle error in directive
-          end
-        when 'attribute'
-          return if directive.tag.name.nil?
-          namespace = closure_at(source_position)
-          t = directive.tag.types.nil? || directive.tag.types.empty? ? nil : directive.tag.types.join
-          if t.nil? || t.include?('r')
-            pins.push Solargraph::Pin::Method.new(
-              location: location,
-              closure: namespace,
-              name: directive.tag.name,
-              comments: docstring.all.to_s,
-              scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
-              visibility: :public,
-              explicit: false,
-              attribute: true,
-              source: :source_map
-            )
-          end
-          if t.nil? || t.include?('w')
-            method_pin = Solargraph::Pin::Method.new(
-              location: location,
-              closure: namespace,
-              name: "#{directive.tag.name}=",
-              comments: docstring.all.to_s,
-              scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
-              visibility: :public,
-              attribute: true,
-              source: :source_map
-            )
-            pins.push method_pin
-            method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last,
-                                                          source: :source_map)
-            if pins.last.return_type.defined?
-              pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '),
-                                                              'value')
-            end
-          end
-        when 'visibility'
+        directive_processor = YardMap::Directives.for(directive)
+        return unless directive_processor
 
-          kind = directive.tag.text&.to_sym
-          return unless %i[private protected public].include?(kind)
-
-          name = directive.tag.name
-          closure = closure_at(source_position) || @pins.first
-          # @sg-ignore Need to add nil check here
-          closure = closure_at(comment_position) if closure.location.range.start.line < comment_position.line
-          if closure.is_a?(Pin::Method) && no_empty_lines?(comment_position.line, source_position.line)
-            # @todo Smelly instance variable access
-            closure.instance_variable_set(:@visibility, kind)
-          else
-            matches = pins.select do |pin|
-              pin.is_a?(Pin::Method) && pin.name == name && pin.namespace == namespace && pin.context.scope == namespace.is_a?(Pin::Singleton) ? :class : :instance
-            end
-            matches.each do |pin|
-              # @todo Smelly instance variable access
-              pin.instance_variable_set(:@visibility, kind)
-            end
-          end
-
-        when 'parse'
-          begin
-            ns = closure_at(source_position)
-            # @sg-ignore Need to add nil check here
-            src = Solargraph::Source.load_string(directive.tag.text, @source.filename)
-            region = Parser::Region.new(source: src, closure: ns)
-            # @todo These pins may need to be marked not explicit
-            index = @pins.length
-            loff = if @code.lines[comment_position.line].strip.end_with?('@!parse')
-                     comment_position.line + 1
-                   else
-                     comment_position.line
-                   end
-            locals = []
-            ivars = []
-            Parser.process_node(src.node, region, @pins, locals, ivars)
-            @pins.concat ivars
-            # @sg-ignore Need to add nil check here
-            @pins[index..].each do |p|
-              # @todo Smelly instance variable access
-              p.location.range.start.instance_variable_set(:@line, p.location.range.start.line + loff)
-              p.location.range.ending.instance_variable_set(:@line, p.location.range.ending.line + loff)
-            end
-          rescue Parser::SyntaxError
-            # @todo Handle parser errors in !parse directives
-          end
-        when 'domain'
-          namespace = closure_at(source_position) || Pin::ROOT_PIN
-          # @sg-ignore flow sensitive typing should be able to handle redefinition
-          namespace.domains.concat directive.tag.types unless directive.tag.types.nil?
-        when 'override'
-          pins.push Pin::Reference::Override.new(location, directive.tag.name, docstring.tags,
-                                                 source: :source_map)
-        when 'macro'
-          # @todo Handle macros
-        end
-      end
-
-      # @param line1 [Integer]
-      # @param line2 [Integer]
-      # @sg-ignore Need to add nil check here
-      def no_empty_lines? line1, line2
-        # @sg-ignore Need to add nil check here
-        @code.lines[line1..line2].none? { |line| line.strip.empty? }
+        @pins += directive_processor.process_directive(
+          @source, @pins, source_position, comment_position, directive
+        )
       end
 
       # @param comment [String]

data/lib/solargraph/source_map.rb

@@ -152,6 +152,20 @@ module Solargraph
       locals.select { |pin| pin.visible_at?(closure, location) }
     end
 
+    # @return [Array<Parser::AST::Node>]
+    def method_call_nodes
+      # @sg-ignore node expected Parser::AST::Node, received Parser::AST::Node, nil
+      @method_call_nodes ||= Solargraph::Parser::ParserGem::NodeMethods.call_nodes_from(source.node)
+    end
+
+    # @param macro_method_names [Array<String>]
+    # @return [Array<Parser::AST::Node>]
+    def macro_method_candidates macro_method_names
+      return @macro_method_candidates if @macro_method_names == macro_method_names
+      @macro_method_names = macro_method_names
+      @macro_method_candidates = method_call_nodes.select { |node| macro_method_names.include?(node.children[1].to_s) }
+    end
+
     class << self
       # @param filename [String]
       # @return [SourceMap]

data/lib/solargraph/version.rb

@@ -1,5 +1,23 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.59.1')
+  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.60.0')
+end
+
+# @generic T
+class A
+  # @yieldparam param0 [generic<T>]
+  def foo
+  end
+end
+
+class B < A # [Integer]
+  def bar
+    foo { |param0| }
+  end
+end
+
+b = B.new
+b.foo do |arg|
+  arg #=> Integer
 end

data/lib/solargraph/yard_map/cache.rb

@@ -1,25 +1,25 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class YardMap
-    class Cache
-      def initialize
-        # @type [Hash{String => Array<Solargraph::Pin::Base>}]
-        @path_pins = {}
-      end
-
-      # @param path [String]
-      # @param pins [Array<Solargraph::Pin::Base>]
-      # @return [Array<Solargraph::Pin::Base>]
-      def set_path_pins path, pins
-        @path_pins[path] = pins
-      end
-
-      # @param path [String]
-      # @return [Array<Solargraph::Pin::Base>]
-      def get_path_pins path
-        @path_pins[path]
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    class Cache
+      def initialize
+        # @type [Hash{String => Array<Solargraph::Pin::Base>}]
+        @path_pins = {}
+      end
+
+      # @param path [String]
+      # @param pins [Array<Solargraph::Pin::Base>]
+      # @return [Array<Solargraph::Pin::Base>]
+      def set_path_pins path, pins
+        @path_pins[path] = pins
+      end
+
+      # @param path [String]
+      # @return [Array<Solargraph::Pin::Base>]
+      def get_path_pins path
+        @path_pins[path]
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/directives/attribute_directive.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    module Directives
+      module AttributeDirective
+        module_function
+
+        # @param source [Solargraph::Source]
+        # @param pins [Array<Solargraph::Pin::Base>]
+        # @param source_position [Position]
+        # @param comment_position [Position]
+        # @param directive [YARD::Tags::Directive]
+        # @return [Array<Solargraph::Pin::Method>]
+        def process_directive source, pins, source_position, comment_position, directive
+          new_pins = []
+          location = Location.new(source.filename, Range.new(comment_position, comment_position))
+          docstring = Solargraph::Source.parse_docstring(directive.tag.text.to_s).to_docstring
+          return [] if directive.tag.name.nil?
+          namespace = closure_at(pins, source_position)
+          t = directive.tag.types.nil? || directive.tag.types.empty? ? nil : directive.tag.types.join
+          if t.nil? || t.include?('r')
+            new_pins.push Solargraph::Pin::Method.new(
+              location: location,
+              closure: namespace,
+              name: directive.tag.name,
+              comments: docstring.all.to_s,
+              scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
+              visibility: :public,
+              explicit: false,
+              attribute: true,
+              source: :yard_map
+            )
+          end
+          if t.nil? || t.include?('w')
+            write_pin = Solargraph::Pin::Method.new(
+              location: location,
+              closure: namespace,
+              name: "#{directive.tag.name}=",
+              comments: docstring.all.to_s,
+              scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
+              visibility: :public,
+              attribute: true,
+              source: :yard_map
+            )
+            new_pins.push(write_pin)
+            write_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: write_pin, source: :yard_map)
+            if write_pin.return_type&.defined?
+              write_pin.docstring.add_tag YARD::Tags::Tag.new(:param, '', write_pin.return_type.to_s.split(', '), 'value')
+            end
+          end
+
+          new_pins.compact
+        end
+
+        # @param [Array<Pin::Base>] pins
+        # @param [Position] position
+        # @return [Pin::Closure]
+        def closure_at pins, position
+          pins.select { |pin| pin.is_a?(Pin::Closure) and pin.location&.range&.contain?(position) }.last
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/directives/domain_directive.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    module Directives
+      module DomainDirective
+        module_function
+
+        # @param source [Solargraph::Source]
+        # @param pins [Array<Solargraph::Pin::Base>]
+        # @param source_position [Position]
+        # @param _comment_position [Position]
+        # @param directive [YARD::Tags::Directive]
+        # @return [Array<Solargraph::Pin::Method>]
+        def process_directive source, pins, source_position, _comment_position, directive
+          namespace = closure_at(pins, source_position) || Pin::ROOT_PIN
+          namespace.domains.concat directive.tag.types unless directive.tag.types.nil?
+          []
+        end
+
+        # @param [Array<Pin::Base>] pins
+        # @param [Position] position
+        # @return [Pin::Namespace]
+        def closure_at pins, position
+          pins.select { |pin| pin.is_a?(Pin::Namespace) and pin.location&.range&.contain?(position) }.last
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/directives/method_directive.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    module Directives
+      module MethodDirective
+        module_function
+
+        # @param source [Solargraph::Source]
+        # @param pins [Array<Solargraph::Pin::Base>]
+        # @param source_position [Position]
+        # @param comment_position [Position]
+        # @param directive [YARD::Tags::Directive]
+        # @return [Array<Solargraph::Pin::Method>]
+        def process_directive source, pins, source_position, comment_position, directive
+          namespace = closure_at(pins, source_position) || pins.first
+
+          namespace = closure_at(pins, comment_position) if namespace.location&.range&.start&.line&.< comment_position.line # rubocop:disable Style/SafeNavigationChainLength
+          begin
+            src = Solargraph::Source.load_string("def #{directive.tag.name};end", source.filename)
+            region = Parser::Region.new(source: src, closure: namespace)
+            method_gen_pins = Parser.process_node(src.node, region).first.select { |pin| pin.is_a?(Pin::Method) }
+            gen_pin = method_gen_pins.last
+            return [] if gen_pin.nil?
+            # Move the location to the end of the line so it gets recognized
+            # as originating from a comment
+            shifted = Solargraph::Position.new(comment_position.line,
+                                               source.code.lines[comment_position.line].to_s.chomp.length)
+            comments = Solargraph::Source.parse_docstring(directive.tag.text.to_s).to_docstring.all.to_s
+            # @todo: Smelly instance variable access
+            gen_pin.instance_variable_set(:@comments, comments)
+            gen_pin.instance_variable_set(:@location,
+                                          Solargraph::Location.new(source.filename, Range.new(shifted, shifted)))
+            gen_pin.instance_variable_set(:@explicit, false)
+            [gen_pin]
+          rescue Parser::SyntaxError
+            # @todo Handle error in directive
+            []
+          end
+        end
+
+        # @param [Array<Pin::Base>] pins
+        # @param [Position] position
+        # @return [Pin::Closure]
+        def closure_at pins, position
+          pins.select { |pin| pin.is_a?(Pin::Closure) and pin.location&.range&.contain?(position) }.last
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/directives/override_directive.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    module Directives
+      module OverrideDirective
+        module_function
+
+        # @param source [Solargraph::Source]
+        # @param _pins [Array<Solargraph::Pin::Base>]
+        # @param _source_position [Position]
+        # @param comment_position [Position]
+        # @param directive [YARD::Tags::Directive]
+        # @return [Array<Pin::Base>]
+        def process_directive source, _pins, _source_position, comment_position, directive
+          docstring = Solargraph::Source.parse_docstring(directive.tag.text.to_s).to_docstring
+          location = Location.new(source.filename, Range.new(comment_position, comment_position))
+          [Pin::Reference::Override.new(location, directive.tag.name.to_s, docstring.tags, source: :yard_map)]
+        end
+
+        # @param [Array<Pin::Base>] pins
+        # @param [Position] position
+        # @return [Pin::Closure]
+        def closure_at pins, position
+          pins.select { |pin| pin.is_a?(Pin::Closure) and pin.location&.range&.contain?(position) }.last
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/directives/parse_directive.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    module Directives
+      module ParseDirective
+        module_function
+
+        # @param source [Solargraph::Source]
+        # @param pins [Array<Solargraph::Pin::Base>]
+        # @param source_position [Position]
+        # @param comment_position [Position]
+        # @param directive [YARD::Tags::Directive]
+        # @return [Array<Solargraph::Pin::Base>]
+        def process_directive source, pins, source_position, comment_position, directive
+          ns = closure_at(pins, source_position)
+          pins_copy = pins.dup
+          src = Solargraph::Source.load_string(directive.tag.text.to_s, source.filename)
+          region = Parser::Region.new(source: src, closure: ns)
+          # @todo These pins may need to be marked not explicit
+          old_pins_index = pins.length
+          loff = if source.code.lines[comment_position.line].strip.end_with?('@!parse')
+                   comment_position.line + 1
+                 else
+                   comment_position.line
+                 end
+          Parser.process_node(src.node, region, pins_copy)
+          new_pins = pins_copy[old_pins_index..] || []
+          new_pins.each do |p|
+            # @todo Smelly instance variable access
+            next if p.location.nil?
+            # @sg-ignore Unresolved call to range on Solargraph::Location, nil - does not account for next clause above.
+            p.location.range.start.instance_variable_set(:@line, p.location.range.start.line + loff)
+            # @sg-ignore Unresolved call to range on Solargraph::Location, nil
+            p.location.range.ending.instance_variable_set(:@line, p.location.range.ending.line + loff)
+          end
+
+          new_pins
+        rescue Parser::SyntaxError
+          # @todo Handle parser errors in !parse directives
+          []
+        end
+
+        # @param [Array<Pin::Base>] pins
+        # @param [Position] position
+        # @return [Pin::Closure]
+        def closure_at pins, position
+          pins.select { |pin| pin.is_a?(Pin::Closure) and pin.location&.range&.contain?(position) }.last
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/directives/visibility_directive.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    module Directives
+      module VisibilityDirective
+        module_function
+
+        VALID_VISIBILITIES = %i[public protected private].freeze
+
+        # @param source [Solargraph::Source]
+        # @param pins [Array<Solargraph::Pin::Base>]
+        # @param source_position [Position]
+        # @param comment_position [Position]
+        # @param directive [YARD::Tags::Directive]
+        # @return [Array<Solargraph::Pin::Base>]
+        def process_directive source, pins, source_position, comment_position, directive
+          kind = directive.tag.text&.to_sym
+
+          # @sg-ignore include? only expects Symbol, but receives Symbol or nil
+          return [] unless VALID_VISIBILITIES.include?(kind.to_sym)
+
+          name = directive.tag.name
+          closure = closure_at(pins, source_position) || pins.first
+          closure = closure_at(pins, comment_position) if closure.location&.range&.start&.line&.< comment_position.line # rubocop:disable Style/SafeNavigationChainLength
+          if closure.is_a?(Pin::Method) && no_empty_lines?(source.code, comment_position.line, source_position.line)
+            # @todo Smelly instance variable access
+            closure.instance_variable_set(:@visibility, kind)
+          else
+            namespace = closure_at(pins, source_position)
+            matches = pins.select do |pin|
+              if pin.is_a?(Pin::Method) &&
+                 pin.name == name &&
+                 pin.namespace == namespace &&
+                 pin.context.scope == namespace.is_a?(Pin::Singleton)
+                :class
+              else
+                :instance
+              end
+            end
+
+            matches.each do |pin|
+              # @todo Smelly instance variable access
+              pin.instance_variable_set(:@visibility, kind)
+            end
+          end
+
+          []
+        end
+
+        # @param [String] code
+        # @param [Integer] line1
+        # @param [Integer] line2
+        # @return [Boolean]
+        # @sg-ignore return type could not be inferred
+        def no_empty_lines? code, line1, line2
+          # @sg-ignore unresolved call none? on the array.
+          code.lines[line1..line2].none? { |line| line.strip.empty? }
+        end
+
+        # @param [Array<Pin::Base>] pins
+        # @param [Position] position
+        # @return [Pin::Closure]
+        def closure_at pins, position
+          pins.select { |pin| pin.is_a?(Pin::Closure) and pin.location&.range&.contain?(position) }.last
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/directives.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    module Directives
+      autoload :AttributeDirective, 'solargraph/yard_map/directives/attribute_directive'
+      autoload :MethodDirective, 'solargraph/yard_map/directives/method_directive'
+      autoload :DomainDirective, 'solargraph/yard_map/directives/domain_directive'
+      autoload :OverrideDirective, 'solargraph/yard_map/directives/override_directive'
+      autoload :ParseDirective, 'solargraph/yard_map/directives/parse_directive'
+      autoload :VisibilityDirective, 'solargraph/yard_map/directives/visibility_directive'
+
+      # @param directive [YARD::Tags::Directive]
+      # @return [Class<AttributeDirective>, Class<MethodDirective>, Class<DomainDirective>, Class<OverrideDirective>, Class<ParseDirective>, Class<VisibilityDirective>, nil]
+      def self.for directive
+        case directive.tag.tag_name
+        when 'attribute'
+          AttributeDirective
+        when 'method'
+          MethodDirective
+        when 'domain'
+          DomainDirective
+        when 'override'
+          OverrideDirective
+        when 'parse'
+          ParseDirective
+        when 'visibility'
+          VisibilityDirective
+        else # rubocop:disable Style/EmptyElse
+          nil
+        end
+      end
+    end
+  end
+end