solargraph 0.58.3 → 0.59.0.dev.1

data/lib/solargraph/pin/block.rb

@@ -21,6 +21,7 @@ module Solargraph
         @context = context
         @return_type = ComplexType.parse('::Proc')
         @node = node
+        @name = '<block>'
       end
 
       # @param api_map [ApiMap]
@@ -30,7 +31,13 @@ module Solargraph
       end
 
       def binder
-        @rebind&.defined? ? @rebind : closure.binder
+        out = @rebind if @rebind&.defined?
+        out ||= super
+      end
+
+      def context
+        @context = @rebind if @rebind&.defined?
+        super
       end
 
       # @param yield_types [::Array<ComplexType>]
@@ -50,14 +57,17 @@ module Solargraph
       # @return [::Array<ComplexType>]
       def typify_parameters(api_map)
         chain = Parser.chain(receiver, filename, node)
+        # @sg-ignore Need to add nil check here
         clip = api_map.clip_at(location.filename, location.range.start)
         locals = clip.locals - [self]
+        # @sg-ignore Need to add nil check here
         meths = chain.define(api_map, closure, locals)
         # @todo Convert logic to use signatures
         # @param meth [Pin::Method]
         meths.each do |meth|
           next if meth.block.nil?
 
+          # @sg-ignore flow sensitive typing needs to handle attrs
           yield_types = meth.block.parameters.map(&:return_type)
           # 'arguments' is what the method says it will yield to the
           # block; 'parameters' is what the block accepts
@@ -67,6 +77,7 @@ module Solargraph
             param_type = chain.base.infer(api_map, param, locals)
             unless arg_type.nil?
               if arg_type.generic? && param_type.defined?
+                # @sg-ignore Need to add nil check here
                 namespace_pin = api_map.get_namespace_pins(meth.namespace, closure.namespace).first
                 arg_type.resolve_generics(namespace_pin, param_type)
               else
@@ -86,16 +97,27 @@ module Solargraph
       def maybe_rebind api_map
         return ComplexType::UNDEFINED unless receiver
 
-        chain = Parser.chain(receiver, location.filename)
+        # @sg-ignore Need to add nil check here
+        chain = Parser.chain(receiver, location.filename, node)
+        # @sg-ignore Need to add nil check here
         locals = api_map.source_map(location.filename).locals_at(location)
+        # @sg-ignore Need to add nil check here
         receiver_pin = chain.define(api_map, closure, locals).first
         return ComplexType::UNDEFINED unless receiver_pin
 
         types = receiver_pin.docstring.tag(:yieldreceiver)&.types
         return ComplexType::UNDEFINED unless types&.any?
 
-        target = chain.base.infer(api_map, receiver_pin, locals)
-        target = full_context unless target.defined?
+        name_pin = self
+        # if we have Foo.bar { |x| ... }, and the bar method references self...
+        target = if chain.base.defined?
+                   # figure out Foo
+                   chain.base.infer(api_map, name_pin, locals)
+                 else
+                   # if not, any self there must be the context of our closure
+                   # @sg-ignore Need to add nil check here
+                   closure.full_context
+                 end
 
         ComplexType.try_parse(*types).qualify(api_map, *receiver_pin.gates).self_to_type(target)
       end

data/lib/solargraph/pin/breakable.rb

@@ -1,9 +1,13 @@
 module Solargraph
   module Pin
-    # Mix-in for pins which enclose code which the 'break' statement works with-in - e.g., blocks, when, until, ...
+    # Mix-in for pins which enclose code which the 'break' statement
+    # works with-in - e.g., blocks, when, until, ...
     module Breakable
       # @return [Parser::AST::Node]
       attr_reader :node
+
+      # @return [Location, nil]
+      attr_reader :location
     end
   end
 end

data/lib/solargraph/pin/callable.rb

@@ -21,8 +21,15 @@ module Solargraph
         @parameters = parameters
       end
 
+      def reset_generated!
+        parameters.each(&:reset_generated!)
+        super
+      end
+
+      # @sg-ignore Need to add nil check here
       # @return [String]
       def method_namespace
+        # @sg-ignore Need to add nil check here
         closure.namespace
       end
 
@@ -80,6 +87,7 @@ module Solargraph
         end
       end
 
+      # @sg-ignore Need to add nil check here
       # @return [Array<Pin::Parameter>]
       def blockless_parameters
         if parameters.last&.block?
@@ -89,11 +97,33 @@ module Solargraph
         end
       end
 
-      # @return [Array]
+      # e.g., [["T"], "", "?", "foo:"] - parameter arity declarations,
+      #   ignoring positional names.  Used to match signatures.
+      #
+      # @return [Array<Array<String>, String, nil>]
       def arity
         [generics, blockless_parameters.map(&:arity_decl), block&.arity]
       end
 
+      # e.g., [["T"], "1", "?3", "foo:5"] - parameter arity
+      #   declarations, including the number of unique types in each
+      #   parameter.  Used to determine whether combining two
+      #   signatures has lost useful information mapping specific
+      #   parameter types to specific return types.
+      #
+      # @return [Array<Array, String, nil>]
+      def type_arity
+        [generics, blockless_parameters.map(&:type_arity_decl), block&.type_arity]
+      end
+
+      # Same as type_arity, but includes return type arity at the front.
+      #
+      # @return [Array<Array, String, nil>]
+      def full_type_arity
+        # @sg-ignore flow sensitive typing needs to handle attrs
+        [return_type ? return_type.items.count.to_s : nil] + type_arity
+      end
+
       # @param generics_to_resolve [Enumerable<String>]
       # @param arg_types [Array<ComplexType>, nil]
       # @param return_type_context [ComplexType, nil]
@@ -101,6 +131,7 @@ module Solargraph
       # @param yield_return_type_context [ComplexType, nil]
       # @param context [ComplexType, nil]
       # @param resolved_generic_values [Hash{String => ComplexType}]
+      #
       # @return [self]
       def resolve_generics_from_context(generics_to_resolve,
                                         arg_types = nil,
@@ -137,9 +168,11 @@ module Solargraph
         end
       end
 
+      # @sg-ignore Need to add nil check here
       # @return [String]
       def method_name
         raise "closure was nil in #{self.inspect}" if closure.nil?
+        # @sg-ignore Need to add nil check here
         @method_name ||= closure.name
       end
 
@@ -150,6 +183,7 @@ module Solargraph
       # @param yield_return_type_context [ComplexType, nil]
       # @param context [ComplexType, nil]
       # @param resolved_generic_values [Hash{String => ComplexType}]
+      #
       # @return [self]
       def resolve_generics_from_context_until_complete(generics_to_resolve,
                                                        arg_types = nil,
@@ -184,7 +218,6 @@ module Solargraph
                                                              resolved_generic_values: resolved_generic_values)
       end
 
-      # @return [Array<String>]
       # @yieldparam [ComplexType]
       # @yieldreturn [ComplexType]
       # @return [self]
@@ -206,17 +239,31 @@ module Solargraph
         parcount = mandatory_positional_param_count
         parcount -= 1 if !parameters.empty? && parameters.last.block?
         return false if block? && !with_block
+        # @todo this and its caller should be changed so that this can
+        #   look at the kwargs provided and check names against what
+        #   we acccept
         return false if argcount < parcount && !(argcount == parcount - 1 && parameters.last.restarg?)
         true
       end
 
+      def reset_generated!
+        super
+        @parameters.each(&:reset_generated!)
+      end
+
       # @return [Integer]
       def mandatory_positional_param_count
         parameters.count(&:arg?)
       end
 
+      # @return [String]
+      def parameters_to_rbs
+        # @sg-ignore Need to add nil check here
+        rbs_generics + '(' + parameters.map { |param| param.to_rbs }.join(', ') + ') ' + (block.nil? ? '' : '{ ' + block.to_rbs + ' } ')
+      end
+
       def to_rbs
-        rbs_generics + '(' + parameters.map { |param| param.to_rbs }.join(', ') + ') ' + (block.nil? ? '' : '{ ' + block.to_rbs + ' } ') + '-> ' + return_type.to_rbs
+        parameters_to_rbs + '-> ' + (return_type&.to_rbs || 'untyped')
       end
 
       def block?

data/lib/solargraph/pin/closure.rb

@@ -2,12 +2,12 @@
 
 module Solargraph
   module Pin
-    class Closure < Base
+    class Closure < CompoundStatement
       # @return [::Symbol] :class or :instance
       attr_reader :scope
 
       # @param scope [::Symbol] :class or :instance
-      # @param generics [::Array<Pin::Parameter>, nil]
+      # @param generics [::Array<Pin::String>, nil]
       # @param generic_defaults [Hash{String => ComplexType}]
       def initialize scope: :class, generics: nil, generic_defaults: {},  **splat
         super(**splat)
@@ -44,10 +44,6 @@ module Solargraph
         end
       end
 
-      def binder
-        @binder || context
-      end
-
       # @param api_map [Solargraph::ApiMap]
       # @return [void]
       def rebind api_map; end

data/lib/solargraph/pin/common.rb

@@ -6,12 +6,24 @@ module Solargraph
       # @!method source
       #   @abstract
       #   @return [Source, nil]
+      # @!method reset_generated!
+      #   @abstract
+      #   @return [void]
       # @type @closure [Pin::Closure, nil]
+      # @type @binder [ComplexType, ComplexType::UniqueType, nil]
+
+      # @todo Missed nil violation
+      # @return [Location, nil]
+      attr_accessor :location
 
-      # @return [Location]
-      attr_reader :location
+      # @param value [Pin::Closure]
+      # @return [void]
+      def closure=(value)
+        @closure = value
+        # remove cached values generated from closure
+        reset_generated!
+      end
 
-      # @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
@@ -23,12 +35,13 @@ module Solargraph
         @name ||= ''
       end
 
+      # @todo redundant with Base#return_type?
       # @return [ComplexType]
       def return_type
         @return_type ||= ComplexType::UNDEFINED
       end
 
-      # @return [ComplexType]
+      # @return [ComplexType, ComplexType::UniqueType]
       def context
         # Get the static context from the nearest namespace
         @context ||= find_context
@@ -40,7 +53,8 @@ module Solargraph
         context.namespace.to_s
       end
 
-      # @return [ComplexType]
+      # @return [ComplexType, ComplexType::UniqueType]
+      # @sg-ignore https://github.com/castwide/solargraph/pull/1100
       def binder
         @binder || context
       end
@@ -70,6 +84,7 @@ module Solargraph
           elsif here.is_a?(Pin::Method)
             return here.context
           end
+          # @sg-ignore Need to add nil check here
           here = here.closure
         end
         ComplexType::ROOT

data/lib/solargraph/pin/compound_statement.rb

@@ -0,0 +1,55 @@
+module Solargraph
+  module Pin
+    # A series of statements where if a given statement executes, /all
+    # of the previous statements in the sequence must have executed as
+    # well/.  In other words, the statements are run from the top in
+    # sequence, until interrupted by something like a
+    # return/break/next/raise/etc.
+    #
+    # This mix-in is used in flow sensitive typing to determine how
+    # far we can assume a given assertion about a type can be trusted
+    # to be true.
+    #
+    # Some examples in Ruby:
+    #
+    # * Bodies of methods and Ruby blocks
+    # * Branches of conditionals and loops - if/elsif/else,
+    #   unless/else, when, until, ||=, ?:, switch/case/else
+    # * The body of begin-end/try/rescue/ensure statements
+    #
+    # Compare/contrast with:
+    #
+    # * Scope - a sequence where variables declared are not available
+    #   after the end of the scope.  Note that this is not necessarily
+    #   true for a compound statement.
+    # * Compound statement - synonym
+    # * Block - in Ruby this has a special meaning (a closure passed to a method), but
+    #   in general parlance this is also a synonym.
+    # * Closure - a sequence which is also a scope
+    # * Namespace - a named sequence which is also a scope and a
+    #   closure
+    #
+    # See:
+    #   https://cse.buffalo.edu/~regan/cse305/RubyBNF.pdf
+    #   https://ruby-doc.org/docs/ruby-doc-bundle/Manual/man-1.4/syntax.html
+    #   https://en.wikipedia.org/wiki/Block_(programming)
+    #
+    # Note:
+    #
+    # Just because statement #1 in a sequence is executed, it doesn't
+    # mean that future ones will.  Consider the effect of
+    # break/next/return/raise/etc. on control flow.
+    class CompoundStatement < Pin::Base
+      attr_reader :node
+
+      # @param receiver [Parser::AST::Node, nil]
+      # @param node [Parser::AST::Node, nil]
+      # @param context [ComplexType, nil]
+      # @param args [::Array<Parameter>]
+      def initialize node: nil, **splat
+        super(**splat)
+        @node = node
+      end
+    end
+  end
+end

data/lib/solargraph/pin/constant.rb

@@ -1,45 +1,45 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Constant < BaseVariable
-      attr_reader :visibility
-
-      # @param visibility [::Symbol] The visibility of the constant (:public, :protected, or :private)
-      # @param splat [Hash] Additional options supported by superclasses
-      def initialize visibility: :public, **splat
-        super(**splat)
-        @visibility = visibility
-      end
-
-      def return_type
-        @return_type ||= generate_complex_type
-      end
-
-      def completion_item_kind
-        Solargraph::LanguageServer::CompletionItemKinds::CONSTANT
-      end
-
-      # @return [Integer]
-      def symbol_kind
-        LanguageServer::SymbolKinds::CONSTANT
-      end
-
-      def path
-        @path ||= context.namespace.to_s.empty? ? name : "#{context.namespace}::#{name}"
-      end
-
-      private
-
-      # @return [ComplexType]
-      def generate_complex_type
-        tags = docstring.tags(:return).map(&:types).flatten.reject(&:nil?)
-        if tags.empty?
-          tags = docstring.tags(:type).map(&:types).flatten.reject(&:nil?)
-        end
-        return ComplexType::UNDEFINED if tags.empty?
-        ComplexType.try_parse *tags
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Constant < BaseVariable
+      attr_reader :visibility
+
+      # @param visibility [::Symbol] The visibility of the constant (:public, :protected, or :private)
+      # @param splat [Hash] Additional options supported by superclasses
+      def initialize visibility: :public, **splat
+        super(**splat)
+        @visibility = visibility
+      end
+
+      def return_type
+        @return_type ||= generate_complex_type
+      end
+
+      def completion_item_kind
+        Solargraph::LanguageServer::CompletionItemKinds::CONSTANT
+      end
+
+      # @return [Integer]
+      def symbol_kind
+        LanguageServer::SymbolKinds::CONSTANT
+      end
+
+      def path
+        @path ||= context.namespace.to_s.empty? ? name : "#{context.namespace}::#{name}"
+      end
+
+      private
+
+      # @return [ComplexType]
+      def generate_complex_type
+        tags = docstring.tags(:return).map(&:types).flatten.reject(&:nil?)
+        if tags.empty?
+          tags = docstring.tags(:type).map(&:types).flatten.reject(&:nil?)
+        end
+        return ComplexType::UNDEFINED if tags.empty?
+        ComplexType.try_parse *tags
+      end
+    end
+  end
+end

data/lib/solargraph/pin/conversions.rb

@@ -43,6 +43,7 @@ module Solargraph
           data: {
             path: path,
             return_type: return_type.tag,
+            # @sg-ignore flow sensitive typing needs to handle attrs
             location: (location ? location.to_hash : nil),
             deprecated: deprecated?
           }
@@ -80,7 +81,7 @@ module Solargraph
 
       # Get a markdown-flavored link to a documentation page.
       #
-      # @return [String]
+      # @return [String, nil]
       def link_documentation
         @link_documentation ||= generate_link
       end

data/lib/solargraph/pin/delegated_method.rb

@@ -13,10 +13,11 @@ module Solargraph
       #
       # @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).
+      # @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
@@ -69,30 +70,40 @@ module Solargraph
       #
       # @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
-          Solargraph.logger.warn \
-            "Delegated receiver for #{path} was resolved to nil from `#{print_chain(@receiver_chain)}'"
+          # @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

data/lib/solargraph/pin/documenting.rb

@@ -104,6 +104,7 @@ module Solargraph
         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?

data/lib/solargraph/pin/instance_variable.rb

@@ -3,13 +3,17 @@
 module Solargraph
   module Pin
     class InstanceVariable < BaseVariable
-      # @return [ComplexType]
+      # @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
 

data/lib/solargraph/pin/keyword.rb

@@ -11,10 +11,6 @@ module Solargraph
       def closure
         @closure ||= Pin::ROOT_PIN
       end
-
-      def name
-        @name
-      end
     end
   end
 end

data/lib/solargraph/pin/local_variable.rb

@@ -3,73 +3,29 @@
 module Solargraph
   module Pin
     class LocalVariable < BaseVariable
-      # @return [Range]
-      attr_reader :presence
-
-      def presence_certain?
-        @presence_certain
-      end
+      # @param api_map [ApiMap]
+      # @return [ComplexType, ComplexType::UniqueType]
+      def probe api_map
+        if presence_certain? && return_type && return_type&.defined?
+          # flow sensitive typing has already figured out this type
+          # has been downcast - use the type it figured out
+          # @sg-ignore flow sensitive typing should support ivars
+          return adjust_type api_map, return_type.qualify(api_map, *gates)
+        end
 
-      # @param assignment [AST::Node, nil]
-      # @param presence [Range, nil]
-      # @param presence_certain [Boolean]
-      # @param splat [Hash]
-      def initialize assignment: nil, presence: nil, presence_certain: false, **splat
-        super(**splat)
-        @assignment = assignment
-        @presence = presence
-        @presence_certain = presence_certain
+        super
       end
 
       def combine_with(other, attrs={})
-        new_attrs = {
-          assignment: assert_same(other, :assignment),
-          presence_certain: assert_same(other, :presence_certain?),
-        }.merge(attrs)
-        new_attrs[:presence] = assert_same(other, :presence) unless attrs.key?(:presence)
+        # keep this as a parameter
+        return other.combine_with(self, attrs) if other.is_a?(Parameter) && !self.is_a?(Parameter)
 
-        super(other, new_attrs)
-      end
-
-      # @param other_closure [Pin::Closure]
-      # @param other_loc [Location]
-      def visible_at?(other_closure, other_loc)
-        location.filename == other_loc.filename &&
-          presence.include?(other_loc.range.start) &&
-          match_named_closure(other_closure, closure)
+        super
       end
 
       def to_rbs
         (name || '(anon)') + ' ' + (return_type&.to_rbs || 'untyped')
       end
-
-      private
-
-      # @param tag1 [String]
-      # @param tag2 [String]
-      # @return [Boolean]
-      def match_tags tag1, tag2
-        # @todo This is an unfortunate hack made necessary by a discrepancy in
-        #   how tags indicate the root namespace. The long-term solution is to
-        #   standardize it, whether it's `Class<>`, an empty string, or
-        #   something else.
-        tag1 == tag2 ||
-          (['', 'Class<>'].include?(tag1) && ['', 'Class<>'].include?(tag2))
-      end
-
-      # @param needle [Pin::Base]
-      # @param haystack [Pin::Base]
-      # @return [Boolean]
-      def match_named_closure needle, haystack
-        return true if needle == haystack || haystack.is_a?(Pin::Block)
-        cursor = haystack
-        until cursor.nil?
-          return true if needle.path == cursor.path
-          return false if cursor.path && !cursor.path.empty?
-          cursor = cursor.closure
-        end
-        false
-      end
     end
   end
 end