solargraph 0.58.3 → 0.60.0

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

data/lib/solargraph/yard_map/helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Solargraph
   class YardMap
     module Helpers
@@ -5,7 +7,7 @@ module Solargraph
 
       # @param code_object [YARD::CodeObjects::Base]
       # @param spec [Gem::Specification, nil]
-      # @return [Solargraph::Location, nil]
+      # @return [Solargraph::Location]
       def object_location code_object, spec
         if spec.nil? || code_object.nil? || code_object.file.nil? || code_object.line.nil?
           if code_object.namespace.is_a?(YARD::CodeObjects::NamespaceObject)
@@ -14,6 +16,7 @@ module Solargraph
           end
           return Solargraph::Location.new(__FILE__, Solargraph::Range.from_to(__LINE__ - 1, 0, __LINE__ - 1, 0))
         end
+        # @sg-ignore flow sensitive typing should be able to identify more blocks that always return
         file = File.join(spec.full_gem_path, code_object.file)
         Solargraph::Location.new(file, Solargraph::Range.from_to(code_object.line - 1, 0, code_object.line - 1, 0))
       end
@@ -21,10 +24,12 @@ module Solargraph
       # @param code_object [YARD::CodeObjects::Base]
       # @param spec [Gem::Specification, nil]
       # @return [Solargraph::Pin::Namespace]
-      def create_closure_namespace_for(code_object, spec)
+      def create_closure_namespace_for code_object, spec
         code_object_for_location = code_object
         # code_object.namespace is sometimes a YARD proxy object pointing to a method path ("Object#new")
-        code_object_for_location = code_object.namespace if code_object.namespace.is_a?(YARD::CodeObjects::NamespaceObject)
+        if code_object.namespace.is_a?(YARD::CodeObjects::NamespaceObject)
+          code_object_for_location = code_object.namespace
+        end
         namespace_location = object_location(code_object_for_location, spec)
         ns_name = code_object.namespace.to_s
         if ns_name.empty?

data/lib/solargraph/yard_map/macro.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    class Macro
+      PROCESSABLE_DIRECTIVES = %w[method attribute parse].freeze
+
+      class << self
+        # @param directive [YARD::Tags::Directive]
+        # @param method_pin [Pin::Method]
+        # @return [Macro]
+        def from_directive directive, method_pin
+          macro_name = directive.tag.name.empty? ? method_pin.path.downcase : directive.tag.name
+          method_object = method_object_from_pin(method_pin)
+          code = directive.tag.text.to_s.gsub(/\n(?!@!|\s)/, "\n  ")
+          macro_object = YARD::CodeObjects::MacroObject.create(macro_name.to_s, code, method_object)
+          new(macro_object, method_pin, directive)
+        end
+
+        private
+
+        # @param method_pin [Pin::Method]
+        # @return [YARD::CodeObjects::MethodObject]
+        def method_object_from_pin method_pin
+          namespace_object = nil
+          method_pin.each_closure do |namespace_pin|
+            next if namespace_pin.name.empty?
+
+            namespace_object = YARD::CodeObjects::NamespaceObject.new(
+              namespace_object,
+              namespace_pin.name.to_sym
+            )
+          end
+          # @sg-ignore Wrong argument type for YARD::CodeObjects::MethodObject.new: namespace
+          # expected YARD::CodeObjects::NamespaceObject, got nil.
+          #   False positive because namespace_object is set in the loop above.
+          YARD::CodeObjects::MethodObject.new(namespace_object, method_pin.name)
+        end
+      end
+
+      # @return [YARD::Tags::MacroDirective]
+      attr_reader :directive
+      # @return [YARD::CodeObjects::MacroObject]
+      attr_reader :macro_object
+
+      # @param macro_object [YARD::CodeObjects::MacroObject]
+      # @param method_pin [Pin::Method]
+      # @param directive [YARD::Tags::Directive]
+      def initialize macro_object, method_pin, directive
+        @macro_object = macro_object
+        @method_pin = method_pin
+        @directive = directive
+      end
+
+      # @return [String]
+      def name
+        @directive.tag.name.to_s
+      end
+
+      # @return [String]
+      def text
+        @directive.tag.text.to_s
+      end
+
+      # @return [YARD::Tags::Tag]
+      def tag
+        @directive.tag
+      end
+
+      # @param chain [Source::Chain]
+      # @param pin [Pin::Closure]
+      # @param source_map [SourceMap]
+      # @return [Array<Pin::Base>]
+      def generate_pins_from chain, pin, source_map
+        call_location = Solargraph::Location.from_node(chain.node)
+        # @param generated_pins [Array<Pin::Base>]
+        generate_yardoc_from(chain, source_map).reduce([]) do |generated_pins, directive|
+          directive_processor = YardMap::Directives.for(directive)
+          next generated_pins unless directive_processor && call_location
+          generated_pins + directive_processor.process_directive(
+            source_map.source, source_map.pins, call_location.range.start, call_location.range.start, directive
+          )
+        end
+      end
+
+      private
+
+      # @param chain [Solargraph::Source::Chain]
+      # @param [SourceMap] source_map
+      # @return [Array<YARD::Tags::Directive>]
+      def generate_yardoc_from chain, source_map
+        name = chain.links.last.word
+        # @sg-ignore chain.links.last is assumed to be a Chain::Call
+        values = chain.links.last.arguments.map(&:node).map { |arg| Solargraph::Parser::ParserGem::NodeMethods.simple_convert(arg).to_s }
+        # @sg-ignore chain.node is assumed to exist
+        code = source_map.source.code_for(chain.node)
+        expanded_comment = macro_object.expand([name, *values], code)
+                                       .gsub(/\n(?!@!|\s)/, "\n  ")
+        directives = Solargraph::Source.parse_docstring(expanded_comment).directives.select do |directive|
+          PROCESSABLE_DIRECTIVES.include?(directive.tag.tag_name)
+        end
+        directives.each do |directive|
+          # @sg-ignore chain.node is assumed to exist
+          comments = source_map.source.comments_for(chain.node)
+          if comments&.length&.positive? && directive.tag.tag_name != 'parse'
+            directive.tag.text += "\n#{comments}"
+          end
+        end
+        directives
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/mapper/to_constant.rb

@@ -1,28 +1,28 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class YardMap
-    class Mapper
-      module ToConstant
-        extend YardMap::Helpers
-
-        # @param code_object [YARD::CodeObjects::Base]
-        # @param closure [Pin::Closure, nil]
-        # @param spec [Gem::Specification, nil]
-        # @return [Pin::Constant]
-        def self.make code_object, closure = nil, spec = nil
-          closure ||= create_closure_namespace_for(code_object, spec)
-
-          Pin::Constant.new(
-            location: object_location(code_object, spec),
-            closure: closure,
-            name: code_object.name.to_s,
-            comments: code_object.docstring ? code_object.docstring.all.to_s : '',
-            visibility: code_object.visibility,
-            source: :yardoc
-          )
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    class Mapper
+      module ToConstant
+        extend YardMap::Helpers
+
+        # @param code_object [YARD::CodeObjects::Base]
+        # @param closure [Pin::Closure, nil]
+        # @param spec [Gem::Specification, nil]
+        # @return [Pin::Constant]
+        def self.make code_object, closure = nil, spec = nil
+          closure ||= create_closure_namespace_for(code_object, spec)
+
+          Pin::Constant.new(
+            location: object_location(code_object, spec),
+            closure: closure,
+            name: code_object.name.to_s,
+            comments: code_object.docstring ? code_object.docstring.all.to_s : '',
+            visibility: code_object.visibility,
+            source: :yardoc
+          )
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/mapper/to_method.rb

@@ -6,10 +6,11 @@ module Solargraph
       module ToMethod
         extend YardMap::Helpers
 
+        # @type [Hash{Array<String, Symbol, String> => Symbol}]
         VISIBILITY_OVERRIDE = {
           # YARD pays attention to 'private' statements prior to class methods but shouldn't
-          ["Rails::Engine", :class, "find_root_with_flag"] => :public
-        }
+          ['Rails::Engine', :class, 'find_root_with_flag'] => :public
+        }.freeze
 
         # @param code_object [YARD::CodeObjects::MethodObject]
         # @param name [String, nil]
@@ -25,10 +26,15 @@ module Solargraph
           return_type = ComplexType::SELF if name == 'new'
           comments = code_object.docstring ? code_object.docstring.all.to_s : ''
           final_scope = scope || code_object.scope
+          # @sg-ignore Need to add nil check here
           override_key = [closure.path, final_scope, name]
           final_visibility = VISIBILITY_OVERRIDE[override_key]
+          # @sg-ignore Need to add nil check here
           final_visibility ||= VISIBILITY_OVERRIDE[[closure.path, final_scope]]
-          final_visibility ||= :private if closure.path == 'Kernel' && Kernel.private_instance_methods(false).include?(name.to_sym)
+          # @sg-ignore Need to add nil check here
+          if closure.path == 'Kernel' && Kernel.private_method_defined?(name.to_sym, false)
+            final_visibility ||= :private
+          end
           final_visibility ||= visibility
           final_visibility ||= :private if code_object.module_function? && final_scope == :instance
           final_visibility ||= :public if code_object.module_function? && final_scope == :class
@@ -46,9 +52,10 @@ module Solargraph
               explicit: code_object.is_explicit?,
               return_type: return_type,
               parameters: [],
-              source: :yardoc,
+              source: :yardoc
             )
           else
+            # @sg-ignore Need to add nil check here
             pin = Pin::Method.new(
               location: location,
               closure: closure,
@@ -61,7 +68,7 @@ module Solargraph
               return_type: return_type,
               attribute: code_object.is_attribute?,
               parameters: [],
-              source: :yardoc,
+              source: :yardoc
             )
             pin.parameters.concat get_parameters(code_object, location, comments, pin)
             pin.parameters.freeze
@@ -85,7 +92,6 @@ module Solargraph
             # HACK: Skip `nil` and `self` parameters that are sometimes emitted
             # for methods defined in C
             # See https://github.com/castwide/solargraph/issues/345
-            # @sg-ignore https://github.com/castwide/solargraph/pull/1114
             code_object.parameters.select { |a| a[0] && a[0] != 'self' }.map do |a|
               Solargraph::Pin::Parameter.new(
                 location: location,
@@ -95,7 +101,7 @@ module Solargraph
                 presence: nil,
                 decl: arg_type(a),
                 asgn_code: a[1],
-                source: :yardoc,
+                source: :yardoc
               )
             end
           end

data/lib/solargraph/yard_map/mapper/to_namespace.rb

@@ -21,8 +21,9 @@ module Solargraph
             type: code_object.is_a?(YARD::CodeObjects::ClassObject) ? :class : :module,
             visibility: code_object.visibility,
             closure: closure,
+            # @sg-ignore need to add a nil check here
             gates: closure.gates,
-            source: :yardoc,
+            source: :yardoc
           )
         end
       end