solargraph 0.58.3 → 0.59.2

data/lib/solargraph/pin/parameter.rb

@@ -15,6 +15,7 @@ module Solargraph
 
       # @param decl [::Symbol] :arg, :optarg, :kwarg, :kwoptarg, :restarg, :kwrestarg, :block, :blockarg
       # @param asgn_code [String, nil]
+      # @param [Hash{Symbol => Object}] splat
       def initialize decl: :arg, asgn_code: nil, **splat
         super(**splat)
         @asgn_code = asgn_code
@@ -29,21 +30,41 @@ module Solargraph
         super || closure&.type_location
       end
 
-      def combine_with(other, attrs={})
-        new_attrs = {
-          decl: assert_same(other, :decl),
-          presence: choose(other, :presence),
-          asgn_code: choose(other, :asgn_code),
-        }.merge(attrs)
-        super(other, new_attrs)
+      def combine_with other, attrs = {}
+        # Parameters can only be combined with local variables in the same closure
+        return self unless other.closure == closure
+
+        new_attrs = if other.is_a?(Parameter)
+                      {
+                        decl: assert_same(other, :decl),
+                        asgn_code: choose(other, :asgn_code)
+                      }
+                    else
+                      {
+                        decl: decl,
+                        asgn_code: asgn_code
+                      }
+                    end
+        super(other, new_attrs.merge(attrs))
+      end
+
+      def combine_return_type other
+        out = super
+        if out&.undefined?
+          # allow our return_type method to provide a better type
+          # using :param tag
+          out = nil
+        end
+        out
       end
 
       def keyword?
-        [:kwarg, :kwoptarg].include?(decl)
+        %i[kwarg kwoptarg].include?(decl)
       end
 
       def kwrestarg?
-        decl == :kwrestarg || (assignment && [:HASH, :hash].include?(assignment.type))
+        # @sg-ignore flow sensitive typing needs to handle attrs
+        decl == :kwrestarg || (assignment && %i[HASH hash].include?(assignment.type))
       end
 
       def needs_consistent_name?
@@ -52,26 +73,31 @@ module Solargraph
 
       # @return [String]
       def arity_decl
-        name = (self.name || '(anon)')
-        type = (return_type&.to_rbs || 'untyped')
+        name = self.name || '(anon)'
+        return_type&.to_rbs || 'untyped'
         case decl
         when :arg
-          ""
+          ''
         when :optarg
-          "?"
+          '?'
         when :kwarg
           "#{name}:"
         when :kwoptarg
           "?#{name}:"
         when :restarg
-          "*"
+          '*'
         when :kwrestarg
-          "**"
+          '**'
         else
           "(unknown decl: #{decl})"
         end
       end
 
+      # @return [String]
+      def type_arity_decl
+        arity_decl + return_type.items.count.to_s
+      end
+
       def arg?
         decl == :arg
       end
@@ -80,12 +106,20 @@ module Solargraph
         decl == :restarg
       end
 
+      def mandatory_positional?
+        decl == :arg
+      end
+
+      def positional?
+        !keyword?
+      end
+
       def rest?
-        decl == :restarg || decl == :kwrestarg
+        %i[restarg kwrestarg].include?(decl)
       end
 
       def block?
-        [:block, :blockarg].include?(decl)
+        %i[block blockarg].include?(decl)
       end
 
       def to_rbs
@@ -123,6 +157,11 @@ module Solargraph
         end
       end
 
+      def reset_generated!
+        @return_type = nil if param_tag
+        super
+      end
+
       # @return [String]
       def full
         full_name + case decl
@@ -135,50 +174,67 @@ module Solargraph
                     end
       end
 
+      # @sg-ignore super always sets @return_type to something
       # @return [ComplexType]
       def return_type
         if @return_type.nil?
           @return_type = ComplexType::UNDEFINED
           found = param_tag
-          @return_type = ComplexType.try_parse(*found.types) unless found.nil? or found.types.nil?
+          @return_type = ComplexType.try_parse(*found.types) unless found.nil? || found.types.nil?
+          # @sg-ignore flow sensitive typing should be able to handle redefinition
           if @return_type.undefined?
-            if decl == :restarg
+            case decl
+            when :restarg
               @return_type = ComplexType.try_parse('::Array')
-            elsif decl == :kwrestarg
+            when :kwrestarg
               @return_type = ComplexType.try_parse('::Hash')
-            elsif decl == :blockarg
+            when :blockarg
               @return_type = ComplexType.try_parse('::Proc')
             end
           end
         end
         super
-        @return_type
       end
 
       # The parameter's zero-based location in the block's signature.
       #
+      # @sg-ignore Need to add nil check here
       # @return [Integer]
       def index
-        # @type [Method, Block]
         method_pin = closure
+        # @sg-ignore Need to add nil check here
         method_pin.parameter_names.index(name)
       end
 
       # @param api_map [ApiMap]
       def typify api_map
-        return return_type.qualify(api_map, *closure.gates) unless return_type.undefined?
-        closure.is_a?(Pin::Block) ? typify_block_param(api_map) : typify_method_param(api_map)
+        new_type = super
+        return new_type if new_type.defined?
+
+        # sniff based on param tags
+        new_type = closure.is_a?(Pin::Block) ? typify_block_param(api_map) : typify_method_param(api_map)
+
+        return adjust_type api_map, new_type.self_to_type(full_context) if new_type.defined?
+
+        adjust_type api_map, super.self_to_type(full_context)
       end
 
       # @param atype [ComplexType]
       # @param api_map [ApiMap]
-      def compatible_arg?(atype, api_map)
+      def compatible_arg? atype, api_map
         # make sure we get types from up the method
         # inheritance chain if we don't have them on this pin
         ptype = typify api_map
-        ptype.undefined? || ptype.can_assign?(api_map, atype) || ptype.generic?
+        return true if ptype.undefined?
+
+        return true if atype.conforms_to?(api_map,
+                                          ptype,
+                                          :method_call,
+                                          %i[allow_empty_params allow_undefined])
+        ptype.generic?
       end
 
+      # @sg-ignore flow sensitive typing needs to handle attrs
       def documentation
         tag = param_tag
         return '' if tag.nil? || tag.text.nil?
@@ -187,12 +243,19 @@ module Solargraph
 
       private
 
+      def generate_complex_type
+        nil
+      end
+
       # @return [YARD::Tags::Tag, nil]
       def param_tag
+        # @sg-ignore Need to add nil check here
         params = closure.docstring.tags(:param)
+        # @sg-ignore Need to add nil check here
         params.each do |p|
           return p if p.name == name
         end
+        # @sg-ignore Need to add nil check here
         params[index] if index && params[index] && (params[index].name.nil? || params[index].name.empty?)
       end
 
@@ -200,15 +263,14 @@ module Solargraph
       # @return [ComplexType]
       def typify_block_param api_map
         block_pin = closure
-        if block_pin.is_a?(Pin::Block) && block_pin.receiver
-          return block_pin.typify_parameters(api_map)[index]
-        end
+        return block_pin.typify_parameters(api_map)[index] if block_pin.is_a?(Pin::Block) && block_pin.receiver && index
         ComplexType::UNDEFINED
       end
 
       # @param api_map [ApiMap]
       # @return [ComplexType]
       def typify_method_param api_map
+        # @sg-ignore Need to add nil check here
         meths = api_map.get_method_stack(closure.full_context.tag, closure.name, scope: closure.scope)
         # meths.shift # Ignore the first one
         meths.each do |meth|
@@ -219,10 +281,14 @@ module Solargraph
             found = p
             break
           end
-          if found.nil? and !index.nil?
-            found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
+          if found.nil? && !index.nil? && params[index] && (params[index].name.nil? || params[index].name.empty?)
+            found = params[index]
+          end
+          unless found.nil? || found.types.nil?
+            return ComplexType.try_parse(*found.types).qualify(api_map,
+                                                               # @sg-ignore Need to add nil check here
+                                                               *meth.closure.gates)
           end
-          return ComplexType.try_parse(*found.types).qualify(api_map, *meth.closure.gates) unless found.nil? || found.types.nil?
         end
         ComplexType::UNDEFINED
       end
@@ -230,6 +296,7 @@ module Solargraph
       # @param heredoc [YARD::Docstring]
       # @param api_map [ApiMap]
       # @param skip [::Array]
+      #
       # @return [::Array<YARD::Tags::Tag>]
       def see_reference heredoc, api_map, skip = []
         # This should actually be an intersection type
@@ -237,7 +304,7 @@ module Solargraph
         heredoc.ref_tags.each do |ref|
           # @sg-ignore ref should actually be an intersection type
           next unless ref.tag_name == 'param' && ref.owner
-          # @sg-ignore ref should actually be an intersection type
+          # @todo ref should actually be an intersection type
           result = resolve_reference(ref.owner.to_s, api_map, skip)
           return result unless result.nil?
         end
@@ -257,14 +324,13 @@ module Solargraph
         else
           fqns = api_map.qualify(parts.first, namespace)
           return nil if fqns.nil?
+          # @sg-ignore Need to add nil check here
           path = fqns + ref[parts.first.length] + parts.last
         end
         pins = api_map.get_path_pins(path)
         pins.each do |pin|
           params = pin.docstring.tags(:param)
           return params unless params.empty?
-        end
-        pins.each do |pin|
           params = see_reference(pin.docstring, api_map, skip)
           return params unless params.empty?
         end

data/lib/solargraph/pin/proxy_type.rb

@@ -3,10 +3,11 @@
 module Solargraph
   module Pin
     class ProxyType < Base
-      # @param return_type [ComplexType]
+      # @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
@@ -22,9 +23,11 @@ module Solargraph
       # @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

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

@@ -7,7 +7,7 @@ module Solargraph
         # @return [::Array<YARD::Tags::Tag>]
         attr_reader :tags
 
-        # @return [::Array<Symbol>]
+        # @return [::Array<::Symbol>]
         attr_reader :delete
 
         def closure

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

@@ -1,14 +1,14 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Reference
-      class Require < Reference
-        def initialize location, name, **splat
-          # super(location, '', name)
-          super(location: location, name: name, closure: Pin::ROOT_PIN, **splat)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Reference
+      class Require < Reference
+        def initialize location, name, **splat
+          # super(location, '', name)
+          super(location: location, name: name, closure: Pin::ROOT_PIN, **splat)
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,9 @@ module Solargraph
       # 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

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

@@ -9,10 +9,28 @@ module Solargraph
       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
@@ -30,8 +48,10 @@ module Solargraph
         )
       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

data/lib/solargraph/pin/search.rb

@@ -41,19 +41,20 @@ module Solargraph
           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)
+             .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)
+        return 1.0 + (str2.length.to_f / str1.length) if str1.downcase.include?(str2.downcase)
         JaroWinkler.similarity(str1, str2, ignore_case: true)
       end
     end

data/lib/solargraph/pin/signature.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Solargraph
   module Pin
     class Signature < Callable
@@ -5,11 +7,8 @@ module Solargraph
       # to the method pin
       attr_writer :closure
 
-      def initialize **splat
-        super(**splat)
-      end
-
       def generics
+        # @type [Array<::String, nil>]
         @generics ||= [].freeze
       end
 
@@ -17,8 +16,7 @@ module Solargraph
         @identity ||= "signature#{object_id}"
       end
 
-      attr_writer :closure
-
+      # @ sg-ignore need boolish support for ? methods
       def dodgy_return_type_source?
         super || closure&.dodgy_return_type_source?
       end
@@ -32,8 +30,11 @@ module Solargraph
       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
@@ -44,13 +45,15 @@ module Solargraph
         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 }
+          sig = pin.signatures.find { |s| s.arity == 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
+          # @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}" }

data/lib/solargraph/pin/singleton.rb

@@ -1,11 +1,11 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Singleton < Closure
-      def initialize name: '', location: nil, closure: nil, **splat
-        super
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Singleton < Closure
+      def initialize name: '', location: nil, closure: nil, **splat
+        super
+      end
+    end
+  end
+end

data/lib/solargraph/pin/symbol.rb

@@ -3,8 +3,9 @@
 module Solargraph
   module Pin
     class Symbol < Base
-      # @param location [Solargraph::Location]
+      # @param location [Solargraph::Location, nil]
       # @param name [String]
+      # @param [Hash{Symbol => Object}] kwargs
       def initialize(location, name, **kwargs)
         # @sg-ignore "Unrecognized keyword argument kwargs to Solargraph::Pin::Base#initialize"
         super(location: location, name: name, **kwargs)

data/lib/solargraph/pin/until.rb

@@ -2,13 +2,11 @@
 
 module Solargraph
   module Pin
-    class Until < Base
+    class Until < CompoundStatement
       include Breakable
 
-      # @param receiver [Parser::AST::Node, nil]
       # @param node [Parser::AST::Node, nil]
-      # @param context [ComplexType, nil]
-      # @param args [::Array<Parameter>]
+      # @param [Hash{Symbol => Object}] splat
       def initialize node: nil, **splat
         super(**splat)
         @node = node

data/lib/solargraph/pin/while.rb

@@ -2,13 +2,11 @@
 
 module Solargraph
   module Pin
-    class While < Base
+    class While < CompoundStatement
       include Breakable
 
-      # @param receiver [Parser::AST::Node, nil]
       # @param node [Parser::AST::Node, nil]
-      # @param context [ComplexType, nil]
-      # @param args [::Array<Parameter>]
+      # @param [Hash{Symbol => Object}] splat
       def initialize node: nil, **splat
         super(**splat)
         @node = node

data/lib/solargraph/pin.rb

@@ -38,6 +38,8 @@ module Solargraph
     autoload :Until,            'solargraph/pin/until'
     autoload :While,            'solargraph/pin/while'
     autoload :Callable,         'solargraph/pin/callable'
+    autoload :CompoundStatement,
+             'solargraph/pin/compound_statement'
 
     ROOT_PIN = Pin::Namespace.new(type: :class, name: '', closure: nil, source: :pin_rb)
   end