solargraph 0.58.0 → 0.58.2

data/lib/solargraph/pin/common.rb

@@ -1,79 +1,79 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    module Common
-      # @!method source
-      #   @abstract
-      #   @return [Source, nil]
-      # @type @closure [Pin::Closure, nil]
-
-      # @return [Location]
-      attr_reader :location
-
-      # @sg-ignore Solargraph::Pin::Common#closure return type could not be inferred
-      # @return [Pin::Closure, nil]
-      def closure
-        Solargraph.assert_or_log(:closure, "Closure not set on #{self.class} #{name.inspect} from #{source.inspect}") unless @closure
-        @closure
-      end
-
-      # @return [String]
-      def name
-        @name ||= ''
-      end
-
-      # @return [ComplexType]
-      def return_type
-        @return_type ||= ComplexType::UNDEFINED
-      end
-
-      # @return [ComplexType]
-      def context
-        # Get the static context from the nearest namespace
-        @context ||= find_context
-      end
-      alias full_context context
-
-      # @return [String]
-      def namespace
-        context.namespace.to_s
-      end
-
-      # @return [ComplexType]
-      def binder
-        @binder || context
-      end
-
-      # @return [String]
-      def comments
-        @comments ||= ''
-      end
-
-      # @return [String]
-      def path
-        @path ||= name.empty? ? context.namespace : "#{context.namespace}::#{name}"
-      end
-
-      protected
-
-      attr_writer :context
-
-      private
-
-      # @return [ComplexType]
-      def find_context
-        here = closure
-        until here.nil?
-          if here.is_a?(Pin::Namespace)
-            return here.return_type
-          elsif here.is_a?(Pin::Method)
-            return here.context
-          end
-          here = here.closure
-        end
-        ComplexType::ROOT
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    module Common
+      # @!method source
+      #   @abstract
+      #   @return [Source, nil]
+      # @type @closure [Pin::Closure, nil]
+
+      # @return [Location]
+      attr_reader :location
+
+      # @sg-ignore Solargraph::Pin::Common#closure return type could not be inferred
+      # @return [Pin::Closure, nil]
+      def closure
+        Solargraph.assert_or_log(:closure, "Closure not set on #{self.class} #{name.inspect} from #{source.inspect}") unless @closure
+        @closure
+      end
+
+      # @return [String]
+      def name
+        @name ||= ''
+      end
+
+      # @return [ComplexType]
+      def return_type
+        @return_type ||= ComplexType::UNDEFINED
+      end
+
+      # @return [ComplexType]
+      def context
+        # Get the static context from the nearest namespace
+        @context ||= find_context
+      end
+      alias full_context context
+
+      # @return [String]
+      def namespace
+        context.namespace.to_s
+      end
+
+      # @return [ComplexType]
+      def binder
+        @binder || context
+      end
+
+      # @return [String]
+      def comments
+        @comments ||= ''
+      end
+
+      # @return [String]
+      def path
+        @path ||= name.empty? ? context.namespace : "#{context.namespace}::#{name}"
+      end
+
+      protected
+
+      attr_writer :context
+
+      private
+
+      # @return [ComplexType]
+      def find_context
+        here = closure
+        until here.nil?
+          if here.is_a?(Pin::Namespace)
+            return here.return_type
+          elsif here.is_a?(Pin::Method)
+            return here.context
+          end
+          here = here.closure
+        end
+        ComplexType::ROOT
+      end
+    end
+  end
+end

data/lib/solargraph/pin/conversions.rb

@@ -1,123 +1,123 @@
-# frozen_string_literal: true
-
-require 'cgi'
-
-module Solargraph
-  module Pin
-    # @todo Move this stuff. It should be the responsibility of the language server.
-    # @todo abstract methods below should be verified to be overridden
-    #   by type checker when mixin included by non-abstract class
-    module Conversions
-      # @!parse
-      #   include Documenting
-      #   include Common
-
-      # @return [Integer]
-      # @abstract
-      def completion_item_kind
-        raise NotImplementedError
-      end
-
-      # @abstract
-      # @return [Boolean]
-      def deprecated?
-        raise NotImplementedError
-      end
-
-      # @abstract
-      def probed?
-        raise NotImplementedError
-      end
-
-      # @abstract
-      def proxied?
-        raise NotImplementedError
-      end
-
-      # @return [Hash]
-      def completion_item
-        @completion_item ||= {
-          label: name,
-          kind: completion_item_kind,
-          detail: detail,
-          data: {
-            path: path,
-            return_type: return_type.tag,
-            location: (location ? location.to_hash : nil),
-            deprecated: deprecated?
-          }
-        }
-      end
-
-      # @return [Hash]
-      def resolve_completion_item
-        @resolve_completion_item ||= begin
-          extra = {}
-          alldoc = ''
-          # alldoc += link_documentation unless link_documentation.nil?
-          # alldoc += "\n\n" unless alldoc.empty?
-          alldoc += documentation unless documentation.nil?
-          extra[:documentation] = alldoc unless alldoc.empty?
-          completion_item.merge(extra)
-        end
-      end
-
-      # @return [::Array<Hash>]
-      def signature_help
-        []
-      end
-
-      # @return [String, nil]
-      def detail
-        # This property is not cached in an instance variable because it can
-        # change when pins get proxied.
-        detail = String.new
-        detail += "=#{probed? ? '~' : (proxied? ? '^' : '>')} #{return_type.to_s}" unless return_type.undefined?
-        detail.strip!
-        return nil if detail.empty?
-        detail
-      end
-
-      # Get a markdown-flavored link to a documentation page.
-      #
-      # @return [String]
-      def link_documentation
-        @link_documentation ||= generate_link
-      end
-
-      # @return [String, nil]
-      def text_documentation
-        this_path = path || name || return_type.tag
-        return nil if this_path == 'undefined'
-        escape_brackets this_path
-      end
-
-      # @return [void]
-      def reset_conversions
-        @completion_item = nil
-        @resolve_completion_item = nil
-        @signature_help = nil
-        @detail = nil
-        @link_documentation = nil
-      end
-
-      private
-
-      # @return [String, nil]
-      def generate_link
-        this_path = path || name || return_type.tag
-        return nil if this_path == 'undefined'
-        return nil if this_path.nil? || this_path == 'undefined'
-        return this_path if path.nil?
-        "[#{escape_brackets(this_path).gsub('_', '\\\\_')}](solargraph:/document?query=#{CGI.escape(this_path)})"
-      end
-
-      # @param text [String]
-      # @return [String]
-      def escape_brackets text
-        # text.gsub(/(\<|\>)/, "\\#{$1}")
-        text.gsub("<", '\<').gsub(">", '\>')
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'cgi'
+
+module Solargraph
+  module Pin
+    # @todo Move this stuff. It should be the responsibility of the language server.
+    # @todo abstract methods below should be verified to be overridden
+    #   by type checker when mixin included by non-abstract class
+    module Conversions
+      # @!parse
+      #   include Documenting
+      #   include Common
+
+      # @return [Integer]
+      # @abstract
+      def completion_item_kind
+        raise NotImplementedError
+      end
+
+      # @abstract
+      # @return [Boolean]
+      def deprecated?
+        raise NotImplementedError
+      end
+
+      # @abstract
+      def probed?
+        raise NotImplementedError
+      end
+
+      # @abstract
+      def proxied?
+        raise NotImplementedError
+      end
+
+      # @return [Hash]
+      def completion_item
+        @completion_item ||= {
+          label: name,
+          kind: completion_item_kind,
+          detail: detail,
+          data: {
+            path: path,
+            return_type: return_type.tag,
+            location: (location ? location.to_hash : nil),
+            deprecated: deprecated?
+          }
+        }
+      end
+
+      # @return [Hash]
+      def resolve_completion_item
+        @resolve_completion_item ||= begin
+          extra = {}
+          alldoc = ''
+          # alldoc += link_documentation unless link_documentation.nil?
+          # alldoc += "\n\n" unless alldoc.empty?
+          alldoc += documentation unless documentation.nil?
+          extra[:documentation] = alldoc unless alldoc.empty?
+          completion_item.merge(extra)
+        end
+      end
+
+      # @return [::Array<Hash>]
+      def signature_help
+        []
+      end
+
+      # @return [String, nil]
+      def detail
+        # This property is not cached in an instance variable because it can
+        # change when pins get proxied.
+        detail = String.new
+        detail += "=#{probed? ? '~' : (proxied? ? '^' : '>')} #{return_type.to_s}" unless return_type.undefined?
+        detail.strip!
+        return nil if detail.empty?
+        detail
+      end
+
+      # Get a markdown-flavored link to a documentation page.
+      #
+      # @return [String]
+      def link_documentation
+        @link_documentation ||= generate_link
+      end
+
+      # @return [String, nil]
+      def text_documentation
+        this_path = path || name || return_type.tag
+        return nil if this_path == 'undefined'
+        escape_brackets this_path
+      end
+
+      # @return [void]
+      def reset_conversions
+        @completion_item = nil
+        @resolve_completion_item = nil
+        @signature_help = nil
+        @detail = nil
+        @link_documentation = nil
+      end
+
+      private
+
+      # @return [String, nil]
+      def generate_link
+        this_path = path || name || return_type.tag
+        return nil if this_path == 'undefined'
+        return nil if this_path.nil? || this_path == 'undefined'
+        return this_path if path.nil?
+        "[#{escape_brackets(this_path).gsub('_', '\\\\_')}](solargraph:/document?query=#{CGI.escape(this_path)})"
+      end
+
+      # @param text [String]
+      # @return [String]
+      def escape_brackets text
+        # text.gsub(/(\<|\>)/, "\\#{$1}")
+        text.gsub("<", '\<').gsub(">", '\>')
+      end
+    end
+  end
+end

data/lib/solargraph/pin/delegated_method.rb

@@ -1,120 +1,120 @@
-# 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]
+      # @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