solargraph 0.58.0 → 0.59.0.dev.1

data/lib/solargraph/pin/delegated_method.rb

@@ -1,120 +1,131 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    # A DelegatedMethod is a more complicated version of a MethodAlias that
-    # allows aliasing a method from a different closure (class/module etc).
-    class DelegatedMethod < Pin::Method
-      # A DelegatedMethod can be constructed with either a :resolved_method
-      # pin, or a :receiver_chain. When a :receiver_chain is supplied, it
-      # will be used to *dynamically* resolve a receiver type within the
-      # given closure/scope, and the delegated method will then be resolved
-      # to a method pin on that type.
-      #
-      # @param method [Method, nil] an already resolved method pin.
-      # @param receiver [Source::Chain, nil] the source code used to resolve the receiver for this delegated method.
-      # @param name [String]
-      # @param receiver_method_name [String] the method name that will be called on the receiver (defaults to :name).
-      def initialize(method: nil, receiver: nil, name: method&.name, receiver_method_name: name, **splat)
-        raise ArgumentError, 'either :method or :receiver is required' if (method && receiver) || (!method && !receiver)
-        super(name: name, **splat)
-
-        @receiver_chain = receiver
-        @resolved_method = method
-        @receiver_method_name = receiver_method_name
-      end
-
-      def inner_desc
-        "#{name} => #{@receiver_chain}##{@receiver_method_name}"
-      end
-
-      def location
-        return super if super
-
-        @resolved_method&.send(:location)
-      end
-
-
-      def type_location
-        return super if super
-
-        @resolved_method&.send(:type_location)
-      end
-
-      %i[comments parameters return_type signatures].each do |method|
-        define_method(method) do
-          # @sg-ignore Need to set context correctly in define_method blocks
-          @resolved_method ? @resolved_method.send(method) : super()
-        end
-      end
-
-      %i[typify realize infer probe].each do |method|
-        # @param api_map [ApiMap]
-        define_method(method) do |api_map|
-          resolve_method(api_map)
-          # @sg-ignore Need to set context correctly in define_method blocks
-          @resolved_method ? @resolved_method.send(method, api_map) : super(api_map)
-        end
-      end
-
-      # @param api_map [ApiMap]
-      def resolvable?(api_map)
-        resolve_method(api_map)
-        !!@resolved_method
-      end
-
-      private
-
-      # Resolves the receiver chain and method name to a method pin, resetting any previously resolution.
-      #
-      # @param api_map [ApiMap]
-      # @return [Pin::Method, nil]
-      def resolve_method api_map
-        return if @resolved_method
-
-        resolver = @receiver_chain.define(api_map, self, []).first
-
-        unless resolver
-          Solargraph.logger.warn \
-            "Delegated receiver for #{path} was resolved to nil from `#{print_chain(@receiver_chain)}'"
-          return
-        end
-
-        receiver_type = resolver.return_type
-
-        return if receiver_type.undefined?
-
-        receiver_path, method_scope =
-          if @receiver_chain.constant?
-            # HACK: the `return_type` of a constant is Class<Whatever>, but looking up a method expects
-            # the arguments `"Whatever"` and `scope: :class`.
-            [receiver_type.to_s.sub(/^Class<(.+)>$/, '\1'), :class]
-          else
-            [receiver_type.to_s, :instance]
-          end
-
-        method_stack = api_map.get_method_stack(receiver_path, @receiver_method_name, scope: method_scope)
-        @resolved_method = method_stack.first
-      end
-
-      # helper to print a source chain as code, probably not 100% correct.
-      #
-      # @param chain [Source::Chain]
-      # @return [String]
-      def print_chain(chain)
-        out = +''
-        chain.links.each_with_index do |link, index|
-          if index > 0
-            if Source::Chain::Constant
-              out << '::' unless link.word.start_with?('::')
-            else
-              out << '.'
-            end
-          end
-          out << link.word
-        end
-        out
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    # A DelegatedMethod is a more complicated version of a MethodAlias that
+    # allows aliasing a method from a different closure (class/module etc).
+    class DelegatedMethod < Pin::Method
+      # A DelegatedMethod can be constructed with either a :resolved_method
+      # pin, or a :receiver_chain. When a :receiver_chain is supplied, it
+      # will be used to *dynamically* resolve a receiver type within the
+      # given closure/scope, and the delegated method will then be resolved
+      # to a method pin on that type.
+      #
+      # @param method [Method, nil] an already resolved method pin.
+      # @param receiver [Source::Chain, nil] the source code used to resolve the receiver for this delegated method.
+      # @param name [String, nil]
+      # @param receiver_method_name [String, nil] the method name that will be called on the receiver (defaults to :name).
+      def initialize(method: nil, receiver: nil, name: method&.name, receiver_method_name: name, **splat)
+        raise ArgumentError, 'either :method or :receiver is required' if (method && receiver) || (!method && !receiver)
+        # @sg-ignore Need to add nil check here
+        super(name: name, **splat)
+
+        @receiver_chain = receiver
+        @resolved_method = method
+        @receiver_method_name = receiver_method_name
+      end
+
+      def inner_desc
+        "#{name} => #{@receiver_chain}##{@receiver_method_name}"
+      end
+
+      def location
+        return super if super
+
+        @resolved_method&.send(:location)
+      end
+
+
+      def type_location
+        return super if super
+
+        @resolved_method&.send(:type_location)
+      end
+
+      %i[comments parameters return_type signatures].each do |method|
+        define_method(method) do
+          # @sg-ignore Need to set context correctly in define_method blocks
+          @resolved_method ? @resolved_method.send(method) : super()
+        end
+      end
+
+      %i[typify realize infer probe].each do |method|
+        # @param api_map [ApiMap]
+        define_method(method) do |api_map|
+          resolve_method(api_map)
+          # @sg-ignore Need to set context correctly in define_method blocks
+          @resolved_method ? @resolved_method.send(method, api_map) : super(api_map)
+        end
+      end
+
+      # @param api_map [ApiMap]
+      def resolvable?(api_map)
+        resolve_method(api_map)
+        !!@resolved_method
+      end
+
+      private
+
+      # Resolves the receiver chain and method name to a method pin, resetting any previously resolution.
+      #
+      # @param api_map [ApiMap]
+      # @return [Pin::Method, nil]
+      # @sg-ignore Declared return type ::Solargraph::Pin::Method, nil
+      #   does not match inferred type nil, false for
+      #   Solargraph::Pin::DelegatedMethod#resolve_method
+      def resolve_method api_map
+        return if @resolved_method
+
+        # @sg-ignore Need to add nil check here
+        resolver = @receiver_chain.define(api_map, self, []).first
+
+        unless resolver
+          # @sg-ignore Need to add nil check here
+          Solargraph.logger.warn "Delegated receiver for #{path} was resolved to nil from `#{print_chain(@receiver_chain)}'"
+          return
+        end
+
+        # @sg-ignore Need to add nil check here
+        receiver_type = resolver.return_type
+
+        # @sg-ignore Need to add nil check here
+        return if receiver_type.undefined?
+
+        receiver_path, method_scope =
+          # @sg-ignore Need to add nil check here
+          if @receiver_chain.constant?
+            # HACK: the `return_type` of a constant is Class<Whatever>, but looking up a method expects
+            # the arguments `"Whatever"` and `scope: :class`.
+            # @sg-ignore Need to add nil check here
+            [receiver_type.to_s.sub(/^Class<(.+)>$/, '\1'), :class]
+          else
+            # @sg-ignore Need to add nil check here
+            [receiver_type.to_s, :instance]
+          end
+
+        # @sg-ignore Need to add nil check here
+        method_stack = api_map.get_method_stack(receiver_path, @receiver_method_name, scope: method_scope)
+        @resolved_method = method_stack.first
+      end
+
+      # helper to print a source chain as code, probably not 100% correct.
+      #
+      # @param chain [Source::Chain]
+      # @return [String]
+      def print_chain(chain)
+        out = +''
+        chain.links.each_with_index do |link, index|
+          if index > 0
+            if Source::Chain::Constant
+              out << '::' unless link.word.start_with?('::')
+            else
+              out << '.'
+            end
+          end
+          out << link.word
+        end
+        out
+      end
+    end
+  end
+end

data/lib/solargraph/pin/documenting.rb

@@ -1,114 +1,115 @@
-# frozen_string_literal: true
-
-require 'kramdown'
-require 'kramdown-parser-gfm'
-require 'yard'
-require 'reverse_markdown'
-require 'solargraph/converters/dl'
-require 'solargraph/converters/dt'
-require 'solargraph/converters/dd'
-require 'solargraph/converters/misc'
-
-# @todo upstream this definition
-
-# @!parse
-#   module ::Kramdown
-#     class Document
-#       # @return [String]
-#       def to_html; end
-#     end
-#   end
-#   module ReverseMarkdown
-#     # @param input [String]
-#     # @param options [Hash]
-#     # @return [String]
-#     def self.convert(input, options = {}); end
-#   end
-
-module Solargraph
-  module Pin
-    # A module to add the Pin::Base#documentation method.
-    #
-    module Documenting
-      # A documentation formatter that either performs Markdown conversion for
-      # text, or applies backticks for code blocks.
-      #
-      class DocSection
-        # @return [String]
-        attr_reader :plaintext
-
-        # @param code [Boolean] True if this section is a code block
-        def initialize code
-          @plaintext = String.new('')
-          @code = code
-        end
-
-        def code?
-          @code
-        end
-
-        # @param text [String]
-        # @return [String]
-        def concat text
-          @plaintext.concat text
-        end
-
-        def to_s
-          return to_code if code?
-          to_markdown
-        end
-
-        private
-
-        # @return [String]
-        def to_code
-          "\n```ruby\n#{Documenting.normalize_indentation(@plaintext)}#{@plaintext.end_with?("\n") ? '' : "\n"}```\n\n"
-        end
-
-        # @return [String]
-        def to_markdown
-          ReverseMarkdown.convert Kramdown::Document.new(@plaintext, input: 'GFM').to_html
-        end
-      end
-
-      # @return [String]
-      def documentation
-        @documentation ||= begin
-          # Using DocSections allows for code blocks that start with an empty
-          # line and at least two spaces of indentation. This is a common
-          # convention in Ruby core documentation, e.g., String#split.
-          sections = [DocSection.new(false)]
-          Documenting.normalize_indentation(Documenting.strip_html_comments(docstring.to_s.gsub("\t", '  '))).lines.each do |l|
-            if l.start_with?('  ')
-              # Code block
-              sections.push DocSection.new(true) unless sections.last.code?
-            elsif sections.last.code?
-              # Regular documentation
-              sections.push DocSection.new(false)
-            end
-            sections.last.concat l
-          end
-          sections.map(&:to_s).join.strip
-        end
-      end
-
-      # @param text [String]
-      # @return [String]
-      def self.strip_html_comments text
-        text.gsub(/<!--([\s\S]*?)-->/, '').strip
-      end
-
-      # @param text [String]
-      # @return [String]
-      def self.normalize_indentation text
-        left = text.lines.map do |line|
-          match = line.match(/^ +/)
-          next 0 unless match
-          match[0].length
-        end.min
-        return text if left.nil? || left.zero?
-        text.lines.map { |line| line[left..] }.join
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'kramdown'
+require 'kramdown-parser-gfm'
+require 'yard'
+require 'reverse_markdown'
+require 'solargraph/converters/dl'
+require 'solargraph/converters/dt'
+require 'solargraph/converters/dd'
+require 'solargraph/converters/misc'
+
+# @todo upstream this definition
+
+# @!parse
+#   module ::Kramdown
+#     class Document
+#       # @return [String]
+#       def to_html; end
+#     end
+#   end
+#   module ReverseMarkdown
+#     # @param input [String]
+#     # @param options [Hash]
+#     # @return [String]
+#     def self.convert(input, options = {}); end
+#   end
+
+module Solargraph
+  module Pin
+    # A module to add the Pin::Base#documentation method.
+    #
+    module Documenting
+      # A documentation formatter that either performs Markdown conversion for
+      # text, or applies backticks for code blocks.
+      #
+      class DocSection
+        # @return [String]
+        attr_reader :plaintext
+
+        # @param code [Boolean] True if this section is a code block
+        def initialize code
+          @plaintext = String.new('')
+          @code = code
+        end
+
+        def code?
+          @code
+        end
+
+        # @param text [String]
+        # @return [String]
+        def concat text
+          @plaintext.concat text
+        end
+
+        def to_s
+          return to_code if code?
+          to_markdown
+        end
+
+        private
+
+        # @return [String]
+        def to_code
+          "\n```ruby\n#{Documenting.normalize_indentation(@plaintext)}#{@plaintext.end_with?("\n") ? '' : "\n"}```\n\n"
+        end
+
+        # @return [String]
+        def to_markdown
+          ReverseMarkdown.convert Kramdown::Document.new(@plaintext, input: 'GFM').to_html
+        end
+      end
+
+      # @return [String]
+      def documentation
+        @documentation ||= begin
+          # Using DocSections allows for code blocks that start with an empty
+          # line and at least two spaces of indentation. This is a common
+          # convention in Ruby core documentation, e.g., String#split.
+          sections = [DocSection.new(false)]
+          Documenting.normalize_indentation(Documenting.strip_html_comments(docstring.to_s.gsub("\t", '  '))).lines.each do |l|
+            if l.start_with?('  ')
+              # Code block
+              sections.push DocSection.new(true) unless sections.last.code?
+            elsif sections.last.code?
+              # Regular documentation
+              sections.push DocSection.new(false)
+            end
+            sections.last.concat l
+          end
+          sections.map(&:to_s).join.strip
+        end
+      end
+
+      # @param text [String]
+      # @return [String]
+      def self.strip_html_comments text
+        text.gsub(/<!--([\s\S]*?)-->/, '').strip
+      end
+
+      # @param text [String]
+      # @return [String]
+      def self.normalize_indentation text
+        left = text.lines.map do |line|
+          match = line.match(/^ +/)
+          next 0 unless match
+          # @sg-ignore Need to add nil check here
+          match[0].length
+        end.min
+        return text if left.nil? || left.zero?
+        text.lines.map { |line| line[left..] }.join
+      end
+    end
+  end
+end

data/lib/solargraph/pin/instance_variable.rb

@@ -1,34 +1,38 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class InstanceVariable < BaseVariable
-      # @return [ComplexType]
-      def binder
-        closure.binder
-      end
-
-      # @return [::Symbol]
-      def scope
-        closure.binder.scope
-      end
-
-      # @return [ComplexType]
-      def context
-        @context ||= begin
-          result = super
-          if scope == :class
-            ComplexType.parse("::Class<#{result.rooted_namespace}>")
-          else
-            result.reduce_class_type
-          end
-        end
-      end
-
-      # @param other [InstanceVariable]
-      def nearly? other
-        super && binder == other.binder
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class InstanceVariable < BaseVariable
+      # @sg-ignore Need to add nil check here
+      # @return [ComplexType, ComplexType::UniqueType]
+      def binder
+        # @sg-ignore Need to add nil check here
+        closure.binder
+      end
+
+      # @sg-ignore Need to add nil check here
+      # @return [::Symbol]
+      def scope
+        # @sg-ignore Need to add nil check here
+        closure.binder.scope
+      end
+
+      # @return [ComplexType]
+      def context
+        @context ||= begin
+          result = super
+          if scope == :class
+            ComplexType.parse("::Class<#{result.rooted_namespace}>")
+          else
+            result.reduce_class_type
+          end
+        end
+      end
+
+      # @param other [InstanceVariable]
+      def nearly? other
+        super && binder == other.binder
+      end
+    end
+  end
+end

data/lib/solargraph/pin/keyword.rb

@@ -1,20 +1,16 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Keyword < Base
-      def initialize(name, **kwargs)
-        # @sg-ignore "Unrecognized keyword argument kwargs to Solargraph::Pin::Base#initialize"
-        super(name: name, **kwargs)
-      end
-
-      def closure
-        @closure ||= Pin::ROOT_PIN
-      end
-
-      def name
-        @name
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Keyword < Base
+      def initialize(name, **kwargs)
+        # @sg-ignore "Unrecognized keyword argument kwargs to Solargraph::Pin::Base#initialize"
+        super(name: name, **kwargs)
+      end
+
+      def closure
+        @closure ||= Pin::ROOT_PIN
+      end
+    end
+  end
+end