solargraph 0.58.0 → 0.59.0

data/lib/solargraph/pin/proxy_type.rb

@@ -1,39 +1,42 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class ProxyType < Base
-      # @param return_type [ComplexType]
-      # @param gates [Array<String>, nil] Namespaces to try while resolving non-rooted types
-      # @param binder [ComplexType, ComplexType::UniqueType, nil]
-      # @param gates [Array<String>, nil]
-      def initialize return_type: ComplexType::UNDEFINED, binder: nil, gates: nil, **splat
-        super(**splat)
-        @gates = gates
-        @return_type = return_type
-        @binder = binder if binder
-      end
-
-      def context
-        @return_type
-      end
-
-      # @param context [ComplexType, ComplexType::UniqueType] Used as context for this pin
-      # @param closure [Pin::Namespace, nil] Used as the closure for this pin
-      # @param binder [ComplexType, ComplexType::UniqueType, nil]
-      # @return [ProxyType]
-      def self.anonymous context, closure: nil, binder: nil, **kwargs
-        unless closure
-          parts = context.namespace.split('::')
-          namespace = parts[0..-2].join('::').to_s
-          closure = Solargraph::Pin::Namespace.new(name: namespace, source: :proxy_type)
-        end
-        # name = parts.last.to_s
-        # ProxyType.new(nil, namespace, name, return_type)
-        ProxyType.new(
-          closure: closure, return_type: context, binder: binder || context, **kwargs
-        )
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class ProxyType < Base
+      # @param return_type [ComplexType, ComplexType::UniqueType]
+      # @param gates [Array<String>, nil] Namespaces to try while resolving non-rooted types
+      # @param binder [ComplexType, ComplexType::UniqueType, nil]
+      # @param gates [Array<String>, nil]
+      # @param [Hash{Symbol => Object}] splat
+      def initialize return_type: ComplexType::UNDEFINED, binder: nil, gates: nil, **splat
+        super(**splat)
+        @gates = gates
+        @return_type = return_type
+        @binder = binder if binder
+      end
+
+      def context
+        @return_type
+      end
+
+      # @param context [ComplexType, ComplexType::UniqueType] Used as context for this pin
+      # @param closure [Pin::Namespace, nil] Used as the closure for this pin
+      # @param binder [ComplexType, ComplexType::UniqueType, nil]
+      # @return [ProxyType]
+      # @param [Hash{Symbol => Object}] kwargs
+      def self.anonymous context, closure: nil, binder: nil, **kwargs
+        unless closure
+          parts = context.namespace.split('::')
+          # @sg-ignore Need to add nil check here
+          namespace = parts[0..-2].join('::').to_s
+          closure = Solargraph::Pin::Namespace.new(name: namespace, source: :proxy_type)
+        end
+        # name = parts.last.to_s
+        # ProxyType.new(nil, namespace, name, return_type)
+        ProxyType.new(
+          closure: closure, return_type: context, binder: binder || context, **kwargs
+        )
+      end
+    end
+  end
+end

data/lib/solargraph/pin/reference/override.rb

@@ -1,47 +1,47 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Reference
-      class Override < Reference
-        # @return [::Array<YARD::Tags::Tag>]
-        attr_reader :tags
-
-        # @return [::Array<Symbol>]
-        attr_reader :delete
-
-        def closure
-          nil
-        end
-
-        # @param location [Location, nil]
-        # @param name [String]
-        # @param tags [::Array<YARD::Tags::Tag>]
-        # @param delete [::Array<Symbol>]
-        # @param splat [Hash]
-        def initialize location, name, tags, delete = [], **splat
-          super(location: location, name: name, **splat)
-          @tags = tags
-          @delete = delete
-        end
-
-        # @param name [String]
-        # @param tags [::Array<String>]
-        # @param delete [::Array<Symbol>]
-        # @param splat [Hash]
-        # @return [Solargraph::Pin::Reference::Override]
-        def self.method_return name, *tags, delete: [], **splat
-          new(nil, name, [YARD::Tags::Tag.new('return', '', tags)], delete, **splat)
-        end
-
-        # @param name [String]
-        # @param comment [String]
-        # @param splat [Hash]
-        # @return [Solargraph::Pin::Reference::Override]
-        def self.from_comment name, comment, **splat
-          new(nil, name, Solargraph::Source.parse_docstring(comment).to_docstring.tags, **splat)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Reference
+      class Override < Reference
+        # @return [::Array<YARD::Tags::Tag>]
+        attr_reader :tags
+
+        # @return [::Array<::Symbol>]
+        attr_reader :delete
+
+        def closure
+          nil
+        end
+
+        # @param location [Location, nil]
+        # @param name [String]
+        # @param tags [::Array<YARD::Tags::Tag>]
+        # @param delete [::Array<Symbol>]
+        # @param splat [Hash]
+        def initialize location, name, tags, delete = [], **splat
+          super(location: location, name: name, **splat)
+          @tags = tags
+          @delete = delete
+        end
+
+        # @param name [String]
+        # @param tags [::Array<String>]
+        # @param delete [::Array<Symbol>]
+        # @param splat [Hash]
+        # @return [Solargraph::Pin::Reference::Override]
+        def self.method_return name, *tags, delete: [], **splat
+          new(nil, name, [YARD::Tags::Tag.new('return', '', tags)], delete, **splat)
+        end
+
+        # @param name [String]
+        # @param comment [String]
+        # @param splat [Hash]
+        # @return [Solargraph::Pin::Reference::Override]
+        def self.from_comment name, comment, **splat
+          new(nil, name, Solargraph::Source.parse_docstring(comment).to_docstring.tags, **splat)
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/pin/reference/superclass.rb

@@ -1,15 +1,17 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Reference
-      # A Superclass reference pin.
-      #
-      class Superclass < Reference
-        def reference_gates
-          @reference_gates ||= closure.gates - [closure.path]
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Reference
+      # A Superclass reference pin.
+      #
+      class Superclass < Reference
+        # @sg-ignore Need to add nil check here
+        def reference_gates
+          # @sg-ignore Need to add nil check here
+          @reference_gates ||= closure.gates - [closure.path]
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/pin/reference/type_alias.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Reference
+      class TypeAlias < Reference
+        # @param return_type [ComplexType]
+        # @param [Hash{Symbol => Object}] splat
+        def initialize return_type:, **splat
+          super(**splat)
+          @return_type = return_type
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/pin/reference.rb

@@ -1,39 +1,59 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Reference < Base
-      autoload :Require,    'solargraph/pin/reference/require'
-      autoload :Superclass, 'solargraph/pin/reference/superclass'
-      autoload :Include,    'solargraph/pin/reference/include'
-      autoload :Prepend,    'solargraph/pin/reference/prepend'
-      autoload :Extend,     'solargraph/pin/reference/extend'
-      autoload :Override,   'solargraph/pin/reference/override'
-
-      attr_reader :generic_values
-
-      # @param generic_values [Array<String>]
-      def initialize generic_values: [], **splat
-        super(**splat)
-        @generic_values = generic_values
-      end
-
-      # @return [ComplexType]
-      def type
-        @type ||= ComplexType.try_parse(
-          name +
-          if generic_values&.length&.> 0
-            "<#{generic_values.join(', ')}>"
-          else
-            ''
-          end
-        )
-      end
-
-      # @return [Array<String>]
-      def reference_gates
-        closure.gates
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Reference < Base
+      autoload :Require,    'solargraph/pin/reference/require'
+      autoload :Superclass, 'solargraph/pin/reference/superclass'
+      autoload :Include,    'solargraph/pin/reference/include'
+      autoload :Prepend,    'solargraph/pin/reference/prepend'
+      autoload :Extend,     'solargraph/pin/reference/extend'
+      autoload :Override,   'solargraph/pin/reference/override'
+      autoload :TypeAlias,  'solargraph/pin/reference/type_alias'
+
+      attr_reader :generic_values
+
+      # A Reference is a pin that associates a type with another type.
+      # The existing type is marked as the closure.  The name of the
+      # type we're associating with it is the 'name' field, and
+      # subtypes are in the 'generic_values' field.
+      #
+      # These pins are a little different - the name is a rooted name,
+      # which may be relative or absolute, preceded with ::, not a
+      # fully qualified namespace, which is implicitly in the root
+      # namespace and is never preceded by ::.
+      #
+      # @todo can the above be represented in a less subtle way?
+      # @todo consider refactoring so that we can replicate more
+      # complex types like Hash{String => Integer} and has both key
+      # types and subtypes.
+      #
+      # @param name [String] rooted name of the referenced type
+      # @param generic_values [Array<String>]
+      # @param [Hash{Symbol => Object}] splat
+      def initialize generic_values: [], **splat
+        super(**splat)
+        @generic_values = generic_values
+      end
+
+      # @return [ComplexType]
+      def type
+        @type ||= ComplexType.try_parse(
+          name +
+          if generic_values&.length&.> 0
+            "<#{generic_values.join(', ')}>"
+          else
+            ''
+          end
+        )
+      end
+
+      # @sg-ignore Need to add nil check here
+      # @return [Array<String>]
+      def reference_gates
+        # @sg-ignore Need to add nil check here
+        closure.gates
+      end
+    end
+  end
+end

data/lib/solargraph/pin/search.rb

@@ -1,61 +1,62 @@
-# frozen_string_literal: true
-
-require 'jaro_winkler'
-
-module Solargraph
-  module Pin
-    class Search
-      class Result
-        # @return [Float]
-        attr_reader :match
-
-        # @return [Pin::Base]
-        attr_reader :pin
-
-        # @param match [Float] The match score for the pin
-        # @param pin [Pin::Base]
-        def initialize match, pin
-          @match = match
-          @pin = pin
-        end
-      end
-
-      # @param pins [::Array<Pin::Base>]
-      # @param query [String]
-      def initialize pins, query
-        @pins = pins
-        @query = query
-      end
-
-      # @return [::Array<Pin::Base>]
-      def results
-        @results ||= do_query
-      end
-
-      private
-
-      # @return [::Array<Pin::Base>]
-      def do_query
-        return @pins if @query.nil? || @query.empty?
-        @pins.map do |pin|
-          match = [fuzzy_string_match(pin.path, @query), fuzzy_string_match(pin.name, @query)].max
-          Result.new(match, pin) if match > 0.7
-        end
-          .compact
-          # @param a [self]
-          # @param b [self]
-          # @sg-ignore https://github.com/castwide/solargraph/pull/1050
-          .sort { |a, b| b.match <=> a.match }
-          .map(&:pin)
-      end
-
-      # @param str1 [String]
-      # @param str2 [String]
-      # @return [Float]
-      def fuzzy_string_match str1, str2
-        return 1.0 + (str2.length.to_f / str1.length.to_f) if str1.downcase.include?(str2.downcase)
-        JaroWinkler.similarity(str1, str2, ignore_case: true)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'jaro_winkler'
+
+module Solargraph
+  module Pin
+    class Search
+      class Result
+        # @return [Float]
+        attr_reader :match
+
+        # @return [Pin::Base]
+        attr_reader :pin
+
+        # @param match [Float] The match score for the pin
+        # @param pin [Pin::Base]
+        def initialize match, pin
+          @match = match
+          @pin = pin
+        end
+      end
+
+      # @param pins [::Array<Pin::Base>]
+      # @param query [String]
+      def initialize pins, query
+        @pins = pins
+        @query = query
+      end
+
+      # @return [::Array<Pin::Base>]
+      def results
+        @results ||= do_query
+      end
+
+      private
+
+      # @return [::Array<Pin::Base>]
+      def do_query
+        return @pins if @query.nil? || @query.empty?
+        @pins.map do |pin|
+          match = [fuzzy_string_match(pin.path, @query), fuzzy_string_match(pin.name, @query)].max
+          Result.new(match, pin) if match > 0.7
+        end
+          .compact
+          # @param a [self]
+          # @param b [self]
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1050
+          .sort { |a, b| b.match <=> a.match }
+             .map(&:pin)
+      end
+
+      # @param str1 [String]
+      # @param str2 [String]
+      #
+      # @return [Float]
+      def fuzzy_string_match str1, str2
+        return 1.0 + (str2.length.to_f / str1.length) if str1.downcase.include?(str2.downcase)
+        JaroWinkler.similarity(str1, str2, ignore_case: true)
+      end
+    end
+  end
+end

data/lib/solargraph/pin/signature.rb

@@ -1,61 +1,64 @@
-module Solargraph
-  module Pin
-    class Signature < Callable
-      # allow signature to be created before method pin, then set this
-      # to the method pin
-      attr_writer :closure
-
-      def initialize **splat
-        super(**splat)
-      end
-
-      def generics
-        @generics ||= [].freeze
-      end
-
-      def identity
-        @identity ||= "signature#{object_id}"
-      end
-
-      attr_writer :closure
-
-      def dodgy_return_type_source?
-        super || closure&.dodgy_return_type_source?
-      end
-
-      def type_location
-        super || closure&.type_location
-      end
-
-      def location
-        super || closure&.location
-      end
-
-      def typify api_map
-        if return_type.defined?
-          qualified = return_type.qualify(api_map, closure.namespace)
-          logger.debug { "Signature#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
-          return qualified
-        end
-        return ComplexType::UNDEFINED if closure.nil?
-        return ComplexType::UNDEFINED unless closure.is_a?(Pin::Method)
-        # @sg-ignore need is_a? support
-        # @type [Array<Pin::Method>]
-        method_stack = closure.rest_of_stack api_map
-        logger.debug { "Signature#typify(self=#{self}) - method_stack: #{method_stack}" }
-        method_stack.each do |pin|
-          sig = pin.signatures.find { |s| s.arity == self.arity }
-          next unless sig
-          unless sig.return_type.undefined?
-            qualified = sig.return_type.qualify(api_map, closure.namespace)
-            logger.debug { "Signature#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
-            return qualified
-          end
-        end
-        out = super
-        logger.debug { "Signature#typify(self=#{self}) => #{out}" }
-        out
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Signature < Callable
+      # allow signature to be created before method pin, then set this
+      # to the method pin
+      attr_writer :closure
+
+      def generics
+        # @type [Array<::String, nil>]
+        @generics ||= [].freeze
+      end
+
+      def identity
+        @identity ||= "signature#{object_id}"
+      end
+
+      # @ sg-ignore need boolish support for ? methods
+      def dodgy_return_type_source?
+        super || closure&.dodgy_return_type_source?
+      end
+
+      def type_location
+        super || closure&.type_location
+      end
+
+      def location
+        super || closure&.location
+      end
+
+      def typify api_map
+        # @sg-ignore Need to add nil check here
+        if return_type.defined?
+          # @sg-ignore Need to add nil check here
+          qualified = return_type.qualify(api_map, closure.namespace)
+          # @sg-ignore Need to add nil check here
+          logger.debug { "Signature#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
+          return qualified
+        end
+        return ComplexType::UNDEFINED if closure.nil?
+        return ComplexType::UNDEFINED unless closure.is_a?(Pin::Method)
+        # @sg-ignore need is_a? support
+        # @type [Array<Pin::Method>]
+        method_stack = closure.rest_of_stack api_map
+        logger.debug { "Signature#typify(self=#{self}) - method_stack: #{method_stack}" }
+        method_stack.each do |pin|
+          sig = pin.signatures.find { |s| s.arity == arity }
+          next unless sig
+          # @sg-ignore Need to add nil check here
+          next if sig.return_type.undefined?
+          # @sg-ignore Need to add nil check here
+          qualified = sig.return_type.qualify(api_map, closure.namespace)
+          # @sg-ignore Need to add nil check here
+          logger.debug { "Signature#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
+          return qualified
+        end
+        out = super
+        logger.debug { "Signature#typify(self=#{self}) => #{out}" }
+        out
+      end
+    end
+  end
+end