solargraph 0.60.4 → 0.62.0

data/lib/solargraph/parser/parser_gem/node_processors/struct_definition.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        module StructDefinition
+          autoload :StructDefintionNode, 'solargraph/parser/parser_gem/node_processors/struct_definition/struct_definition_node'
+          autoload :StructAssignmentNode, 'solargraph/parser/parser_gem/node_processors/struct_definition/struct_assignment_node'
+
+          class StructNode < Parser::NodeProcessor::Base
+            # @return [Boolean] continue processing the next processor of the same node.
+            def process
+              return true if struct_definition_node.nil?
+
+              loc = get_node_location(node)
+              nspin = Solargraph::Pin::Namespace.new(
+                type: :class,
+                location: loc,
+                closure: region.closure,
+                # @sg-ignore flow sensitive typing needs to handle attrs
+                name: struct_definition_node.class_name,
+                docstring: docstring,
+                visibility: :public,
+                gates: region.closure.gates.freeze,
+                source: :struct_definition
+              )
+              pins.push nspin
+
+              # define initialize method
+              initialize_method_pin = Pin::Method.new(
+                name: 'initialize',
+                parameters: [],
+                scope: :instance,
+                location: get_node_location(node),
+                closure: nspin,
+                visibility: :private,
+                docstring: docstring,
+                source: :struct_definition
+              )
+
+              pins.push initialize_method_pin
+
+              # @sg-ignore flow sensitive typing needs to handle attrs
+              struct_definition_node.attributes.map do |attribute_node, attribute_name|
+                initialize_method_pin.parameters.push(
+                  Pin::Parameter.new(
+                    name: attribute_name,
+                    decl: struct_definition_node.keyword_init? ? :kwoptarg : :arg,
+                    location: get_node_location(attribute_node),
+                    closure: initialize_method_pin,
+                    source: :struct_definition
+                  )
+                )
+              end
+
+              # define attribute accessors and instance variables
+              # @sg-ignore flow sensitive typing needs to handle attrs
+              struct_definition_node.attributes.each do |attribute_node, attribute_name|
+                [attribute_name, "#{attribute_name}="].each do |name|
+                  docs = docstring.tags.find { |t| t.tag_name == 'param' && t.name == attribute_name }
+
+                  attribute_type = ComplexType.parse(tag_string(docs))
+                  return_type_comment = attribute_comment(docs, false)
+                  param_comment = attribute_comment(docs, true)
+
+                  method_pin = Pin::Method.new(
+                    name: name,
+                    parameters: [],
+                    scope: :instance,
+                    location: get_node_location(attribute_node),
+                    closure: nspin,
+                    docstring: YARD::Docstring.new(return_type_comment),
+                    # even assignments return the value
+                    comments: return_type_comment,
+                    return_type: attribute_type,
+                    visibility: :public,
+                    source: :struct_definition
+                  )
+
+                  if name.end_with?('=')
+                    method_pin.parameters << Pin::Parameter.new(
+                      name: attribute_name,
+                      location: get_node_location(attribute_node),
+                      closure: method_pin,
+                      return_type: attribute_type,
+                      comments: param_comment,
+                      source: :struct_definition
+                    )
+
+                    pins.push Pin::InstanceVariable.new(name: "@#{attribute_name}",
+                                                        closure: method_pin,
+                                                        location: get_node_location(attribute_node),
+                                                        return_type: attribute_type,
+                                                        comments: "@type [#{attribute_type.rooted_tags}]",
+                                                        source: :struct_definition)
+                  end
+
+                  pins.push method_pin
+                end
+              end
+
+              process_children region.update(closure: nspin, visibility: :public)
+              false
+            end
+
+            private
+
+            # @return [StructDefinition::StructDefintionNode, StructDefinition::StructAssignmentNode, nil]
+            def struct_definition_node
+              @struct_definition_node ||= if StructDefintionNode.match?(node)
+                                            StructDefintionNode.new(node)
+                                          elsif StructAssignmentNode.match?(node)
+                                            StructAssignmentNode.new(node)
+                                          end
+            end
+
+            # Gets/generates the relevant docstring for this struct & it's attributes
+            # @return [YARD::Docstring]
+            def docstring
+              @docstring ||= parse_comments
+            end
+
+            # Parses any relevant comments for a struct int a yard docstring
+            # @return [YARD::Docstring]
+            def parse_comments
+              struct_comments = comments_for(node) || ''
+              # @sg-ignore Need to add nil check here
+              struct_definition_node.attributes.each do |attr_node, attr_name|
+                comment = comments_for(attr_node)
+                next if comment.nil?
+
+                # We should support specific comments for an attribute, and that can be either a @return on an @param
+                # But since we merge into the struct_comments, then we should interpret either as a param
+                comment = "@param #{attr_name}#{comment[7..]}" if comment.start_with?('@return')
+
+                struct_comments += "\n#{comment}"
+              end
+
+              Solargraph::Source.parse_docstring(struct_comments).to_docstring
+            end
+
+            # @param tag [YARD::Tags::Tag, nil] The param tag for this attribute.xtract_
+            #
+            # @return [String]
+            def tag_string tag
+              tag&.types&.join(',') || 'undefined'
+            end
+
+            # @param tag [YARD::Tags::Tag, nil] The param tag for this attribute. If nil, this method is a no-op
+            # @param for_setter [Boolean] If true, will return a @param tag instead of a @return tag
+            #
+            # @return [String] The formatted comment for the attribute
+            def attribute_comment tag, for_setter
+              return '' if tag.nil?
+
+              suffix = "[#{tag_string(tag)}] #{tag.text}"
+
+              if for_setter
+                "@param #{tag.name} #{suffix}"
+              else
+                "@return #{suffix}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem/node_processors.rb

@@ -6,31 +6,34 @@ module Solargraph
   module Parser
     module ParserGem
       module NodeProcessors
-        autoload :BeginNode,     'solargraph/parser/parser_gem/node_processors/begin_node'
-        autoload :DefNode,       'solargraph/parser/parser_gem/node_processors/def_node'
-        autoload :DefsNode,      'solargraph/parser/parser_gem/node_processors/defs_node'
-        autoload :SendNode,      'solargraph/parser/parser_gem/node_processors/send_node'
-        autoload :NamespaceNode, 'solargraph/parser/parser_gem/node_processors/namespace_node'
-        autoload :SclassNode,    'solargraph/parser/parser_gem/node_processors/sclass_node'
-        autoload :IvasgnNode,    'solargraph/parser/parser_gem/node_processors/ivasgn_node'
-        autoload :IfNode,        'solargraph/parser/parser_gem/node_processors/if_node'
-        autoload :CvasgnNode,    'solargraph/parser/parser_gem/node_processors/cvasgn_node'
-        autoload :LvasgnNode,    'solargraph/parser/parser_gem/node_processors/lvasgn_node'
-        autoload :GvasgnNode,    'solargraph/parser/parser_gem/node_processors/gvasgn_node'
-        autoload :CasgnNode,     'solargraph/parser/parser_gem/node_processors/casgn_node'
-        autoload :MasgnNode,     'solargraph/parser/parser_gem/node_processors/masgn_node'
-        autoload :AliasNode,     'solargraph/parser/parser_gem/node_processors/alias_node'
-        autoload :ArgsNode,      'solargraph/parser/parser_gem/node_processors/args_node'
-        autoload :BlockNode,     'solargraph/parser/parser_gem/node_processors/block_node'
-        autoload :OrasgnNode,    'solargraph/parser/parser_gem/node_processors/orasgn_node'
-        autoload :OpasgnNode,    'solargraph/parser/parser_gem/node_processors/opasgn_node'
-        autoload :SymNode,       'solargraph/parser/parser_gem/node_processors/sym_node'
-        autoload :ResbodyNode,   'solargraph/parser/parser_gem/node_processors/resbody_node'
-        autoload :UntilNode,     'solargraph/parser/parser_gem/node_processors/until_node'
-        autoload :WhenNode,      'solargraph/parser/parser_gem/node_processors/when_node'
-        autoload :WhileNode,     'solargraph/parser/parser_gem/node_processors/while_node'
-        autoload :AndNode,       'solargraph/parser/parser_gem/node_processors/and_node'
-        autoload :OrNode,        'solargraph/parser/parser_gem/node_processors/or_node'
+        autoload :BeginNode,        'solargraph/parser/parser_gem/node_processors/begin_node'
+        autoload :DefNode,          'solargraph/parser/parser_gem/node_processors/def_node'
+        autoload :DefsNode,         'solargraph/parser/parser_gem/node_processors/defs_node'
+        autoload :SendNode,         'solargraph/parser/parser_gem/node_processors/send_node'
+        autoload :NamespaceNode,    'solargraph/parser/parser_gem/node_processors/namespace_node'
+        autoload :SclassNode,       'solargraph/parser/parser_gem/node_processors/sclass_node'
+        autoload :IvasgnNode,       'solargraph/parser/parser_gem/node_processors/ivasgn_node'
+        autoload :IfNode,           'solargraph/parser/parser_gem/node_processors/if_node'
+        autoload :CvasgnNode,       'solargraph/parser/parser_gem/node_processors/cvasgn_node'
+        autoload :LvasgnNode,       'solargraph/parser/parser_gem/node_processors/lvasgn_node'
+        autoload :GvasgnNode,       'solargraph/parser/parser_gem/node_processors/gvasgn_node'
+        autoload :CasgnNode,        'solargraph/parser/parser_gem/node_processors/casgn_node'
+        autoload :MasgnNode,        'solargraph/parser/parser_gem/node_processors/masgn_node'
+        autoload :AliasNode,        'solargraph/parser/parser_gem/node_processors/alias_node'
+        autoload :ArgsNode,         'solargraph/parser/parser_gem/node_processors/args_node'
+        autoload :BlockNode,        'solargraph/parser/parser_gem/node_processors/block_node'
+        autoload :OrasgnNode,       'solargraph/parser/parser_gem/node_processors/orasgn_node'
+        autoload :OpasgnNode,       'solargraph/parser/parser_gem/node_processors/opasgn_node'
+        autoload :SymNode,          'solargraph/parser/parser_gem/node_processors/sym_node'
+        autoload :ResbodyNode,      'solargraph/parser/parser_gem/node_processors/resbody_node'
+        autoload :UntilNode,        'solargraph/parser/parser_gem/node_processors/until_node'
+        autoload :WhenNode,         'solargraph/parser/parser_gem/node_processors/when_node'
+        autoload :WhileNode,        'solargraph/parser/parser_gem/node_processors/while_node'
+        autoload :AndNode,          'solargraph/parser/parser_gem/node_processors/and_node'
+        autoload :OrNode,           'solargraph/parser/parser_gem/node_processors/or_node'
+        autoload :ClassDefinition,  'solargraph/parser/parser_gem/node_processors/class_definition'
+        autoload :StructDefinition, 'solargraph/parser/parser_gem/node_processors/struct_definition'
+        autoload :DataDefinition,   'solargraph/parser/parser_gem/node_processors/data_definition'
       end
     end
 
@@ -44,8 +47,8 @@ module Solargraph
       register :defs,         ParserGem::NodeProcessors::DefsNode
       register :if,           ParserGem::NodeProcessors::IfNode
       register :send,         ParserGem::NodeProcessors::SendNode
-      register :class,        Convention::StructDefinition::NodeProcessors::StructNode
-      register :class,        Convention::DataDefinition::NodeProcessors::DataNode
+      register :class,        ParserGem::NodeProcessors::StructDefinition::StructNode
+      register :class,        ParserGem::NodeProcessors::DataDefinition::DataNode
       register :class,        ParserGem::NodeProcessors::NamespaceNode
       register :module,       ParserGem::NodeProcessors::NamespaceNode
       register :sclass,       ParserGem::NodeProcessors::SclassNode
@@ -53,8 +56,9 @@ module Solargraph
       register :cvasgn,       ParserGem::NodeProcessors::CvasgnNode
       register :lvasgn,       ParserGem::NodeProcessors::LvasgnNode
       register :gvasgn,       ParserGem::NodeProcessors::GvasgnNode
-      register :casgn,        Convention::StructDefinition::NodeProcessors::StructNode
-      register :casgn,        Convention::DataDefinition::NodeProcessors::DataNode
+      register :casgn,        ParserGem::NodeProcessors::StructDefinition::StructNode
+      register :casgn,        ParserGem::NodeProcessors::DataDefinition::DataNode
+      register :casgn,        ParserGem::NodeProcessors::ClassDefinition::ClassNode
       register :casgn,        ParserGem::NodeProcessors::CasgnNode
       register :masgn,        ParserGem::NodeProcessors::MasgnNode
       register :alias,        ParserGem::NodeProcessors::AliasNode

data/lib/solargraph/pin/base.rb

@@ -158,7 +158,17 @@ module Solargraph
       # @param other [self]
       # @return [Pin::Closure, nil]
       def combine_closure other
-        choose_pin_attr_with_same_name(other, :closure)
+        chosen = choose_pin_attr_with_same_name(other, :closure)
+        return chosen unless chosen.is_a?(Pin::Namespace) && chosen.generics.empty?
+
+        # Combined types may name type parameters only the other closure declares
+        own = closure
+        return own if own.is_a?(Pin::Namespace) && !own.generics.empty?
+
+        theirs = other.closure
+        return theirs if theirs.is_a?(Pin::Namespace) && !theirs.generics.empty?
+
+        chosen
       end
 
       # @param other [self]
@@ -435,6 +445,7 @@ module Solargraph
       # @param context_type [ComplexType] The receiver type
       # @return [self]
       def resolve_generics definitions, context_type
+        definitions = declaring_definitions(definitions)
         transform_types { |t| t&.resolve_generics(definitions, context_type) }
       end
 
@@ -731,6 +742,19 @@ module Solargraph
 
       private
 
+      # Declarations of a reopened generic may spell its parameters
+      # differently, so bind by position against this pin's own one.
+      #
+      # @param definitions [Pin::Namespace, nil]
+      # @return [Pin::Namespace, nil]
+      def declaring_definitions definitions
+        own = closure
+        return definitions unless definitions.is_a?(Pin::Namespace) && own.is_a?(Pin::Namespace)
+        return definitions unless own.path == definitions.path && !own.generics.empty?
+
+        own
+      end
+
       # @return [void]
       def parse_comments
         # HACK: Avoid a NoMethodError on nil with empty overload tags

data/lib/solargraph/pin/base_variable.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'rbs'
+
 module Solargraph
   module Pin
     class BaseVariable < Base
@@ -14,6 +16,9 @@ module Solargraph
       # @return [Range, nil]
       attr_reader :presence
 
+      # @return [String, nil]
+      attr_reader :type_assertion
+
       # @param return_type [ComplexType, nil]
       # @param assignment [Parser::AST::Node, nil] First assignment
       #   that was made to this variable
@@ -45,12 +50,16 @@ module Solargraph
       # @see https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types
       # @see https://en.wikipedia.org/wiki/Intersection_type#TypeScript_example
       # @param presence [Range, nil]
+      # @param type_assertion [String, nil] RBS type from a trailing
+      #   rbs-inline `#: TYPE` comment on the assignment
       # @param [Hash{Symbol => Object}] splat
       def initialize assignment: nil, assignments: [], mass_assignment: nil,
                      presence: nil, return_type: nil,
                      intersection_return_type: nil, exclude_return_type: nil,
+                     type_assertion: nil,
                      **splat
         super(**splat)
+        @type_assertion = type_assertion
         @assignments = (assignment.nil? ? [] : [assignment]) + assignments
         # @type [nil, ::Array(Parser::AST::Node, Integer)]
         @mass_assignment = mass_assignment
@@ -95,7 +104,8 @@ module Solargraph
                                   return_type: combine_return_type(other),
                                   intersection_return_type: combine_types(other, :intersection_return_type),
                                   exclude_return_type: combine_types(other, :exclude_return_type),
-                                  presence: combine_presence(other)
+                                  presence: combine_presence(other),
+                                  type_assertion: choose(other, :type_assertion)
                                 })
         super(other, new_attrs)
       end
@@ -170,6 +180,9 @@ module Solargraph
           end
         end
         types
+      rescue FileNotFoundError
+        # @todo Necessary for pins from source maps that are not part of the workspace
+        [ComplexType::UNDEFINED]
       end
 
       # @param api_map [ApiMap]
@@ -364,12 +377,29 @@ module Solargraph
         :instance
       end
 
+      # An rbs-inline type assertion takes precedence over a @type tag,
+      # as inline RBS method signatures do over YARD tags.
+      #
       # @return [ComplexType, nil]
       def generate_complex_type
+        asserted = type_from_assertion
+        return asserted unless asserted.nil?
         tag = docstring.tag(:type)
         return ComplexType.try_parse(*tag.types) unless tag.nil? || tag.types.nil? || tag.types.empty?
         nil
       end
+
+      # @return [ComplexType, nil]
+      def type_from_assertion
+        assertion = type_assertion
+        return nil if assertion.nil? || assertion.empty?
+        @type_from_assertion ||= begin
+          rbs_type = RBS::Parser.parse_type(assertion, require_eof: true)
+          RbsTranslator.to_complex_type(rbs_type) unless rbs_type.nil?
+        rescue RBS::ParsingError
+          nil
+        end
+      end
     end
   end
 end

data/lib/solargraph/pin/callable.rb

@@ -14,12 +14,15 @@ module Solargraph
       # @param block [Signature, nil]
       # @param return_type [ComplexType, nil]
       # @param parameters [::Array<Pin::Parameter>]
+      # @param block_required [Boolean] Whether callers must pass a block, per
+      #   an RBS non-optional block (`{ ... }` rather than `?{ ... }`).
       # @param [Hash{Symbol => Object}] splat
-      def initialize block: nil, return_type: nil, parameters: [], **splat
+      def initialize block: nil, return_type: nil, parameters: [], block_required: false, **splat
         super(**splat)
         @block = block
         @return_type = return_type
         @parameters = parameters
+        @block_required = block_required
       end
 
       def reset_generated!
@@ -55,6 +58,7 @@ module Solargraph
       def combine_with other, attrs = {}
         new_attrs = {
           block: combine_blocks(other),
+          block_required: block_required? || other.block_required?,
           return_type: combine_return_type(other)
         }.merge(attrs)
         new_attrs[:parameters] = choose_parameters(other).clone.freeze unless new_attrs.key?(:parameters)
@@ -241,7 +245,7 @@ module Solargraph
         argcount = arguments.length
         parcount = mandatory_positional_param_count
         parcount -= 1 if !parameters.empty? && parameters.last.block?
-        return false if block? && !with_block
+        return false if block? && block_required? && !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
@@ -267,6 +271,11 @@ module Solargraph
         !!@block
       end
 
+      # @return [Boolean]
+      def block_required?
+        !!@block_required
+      end
+
       protected
 
       attr_writer :block

data/lib/solargraph/pin/closure.rb

@@ -6,6 +6,23 @@ module Solargraph
       # @return [::Symbol] :class or :instance
       attr_reader :scope
 
+      # Override the pin's scope.
+      #
+      # Scope is normally determined by the syntax that declared the pin, but
+      # YARD's `@!scope` directive can change it after the fact. Any values
+      # derived from the scope, such as the pin's path and context, are
+      # recalculated.
+      #
+      # @param scope [::Symbol] :class or :instance
+      # @return [void]
+      def scope= scope
+        return if @scope == scope
+
+        @scope = scope
+        # remove cached values generated from scope
+        reset_generated!
+      end
+
       # @param scope [::Symbol] :class or :instance
       # @param generics [::Array<Pin::String>, nil]
       # @param generic_defaults [Hash{String => ComplexType}]

data/lib/solargraph/pin/delegated_method.rb

@@ -5,6 +5,11 @@ module Solargraph
     # 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
+      # @return [Boolean]
+      def body?
+        false
+      end
+
       # 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

data/lib/solargraph/pin/duck_method.rb

@@ -1,16 +1,36 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    # DuckMethod pins are used to add completion items for type tags that
-    # use duck typing, e.g., `@param file [#read]`.
-    #
-    class DuckMethod < Pin::Method
-      # @param location [Solargraph::Location]
-      # @param name [String]
-      # def initialize location, name
-      #   # super(location, '', name, nil, :instance, :public, [])
-      # end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    # DuckMethod pins are used to add completion items for type tags that
+    # use duck typing, e.g., `@param file [#read]`.
+    #
+    class DuckMethod < Pin::Method
+      # A duck-type tag has no syntax for arguments, so the default empty
+      # #parameters would synthesize a zero-arg signature no real call matches.
+      #
+      # @param splat [Hash{Symbol => Object}]
+      def initialize **splat
+        super(parameters: accepts_any_arguments, **splat)
+      end
+
+      # @return [::Array<Pin::Parameter>]
+      def accepts_any_arguments
+        [
+          Pin::Parameter.new(decl: :restarg, name: 'args', closure: self, source: :api_map),
+          Pin::Parameter.new(decl: :kwrestarg, name: 'kwargs', closure: self, source: :api_map)
+        ]
+      end
+
+      # A synthetic pin sits in no ancestor chain and has no closure. Letting
+      # the inherited walk find a type sends #typify on to `closure.gates`,
+      # which raises.
+      #
+      # @param _api_map [ApiMap]
+      # @return [Array<Pin::Method>]
+      def rest_of_stack _api_map
+        []
+      end
+    end
+  end
+end

data/lib/solargraph/pin/factory_parameter.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    # A method parameter with a literal value used in a factory method.
+    #
+    # @example
+    #   RSpec.shared_examples 'some examples'
+    #
+    #   FactoryParameter.new(
+    #     method_name: 'shared_examples',
+    #     method_namespace: 'RSpec',
+    #     method_scope: :class,
+    #     param_name: 'name',
+    #     value: 'some examples',
+    #     decl: :arg,
+    #     return_type: 'void'
+    #   )
+    class FactoryParameter < Base
+      # @return [String]
+      attr_reader :method_name
+      # @return [String]
+      attr_reader :method_namespace
+      # @return [Symbol] :class or :instance
+      attr_reader :method_scope
+      # @return [String, nil]
+      attr_reader :param_name
+      # @return [::String, ::Symbol] The literal value
+      attr_reader :value
+      # @return [::Symbol] :arg, :optarg, :kwarg, :kwoptarg, :restarg, :kwrestarg, :block, :blockarg
+      attr_reader :decl
+      # @return [Location, nil]
+      attr_reader :location
+
+      # @param method_name [String] The name of the method that this parameter belongs to
+      # @param method_namespace [String] The class of the method that this parameter belongs to
+      # @param method_scope [Symbol] The scope of the method, either :class or :instance
+      # @param param_name [String, nil] The name of the parameter
+      # @param value [String, Symbol] The value of the parameter
+      # @param decl [::Symbol] :arg, :kwarg
+      # @param location [Location, nil] The location of the parameter in the source code
+      # @param return_type [String, nil] The return type of the method that this parameter belongs to
+      def initialize method_name:,
+                     method_namespace:,
+                     method_scope:,
+                     param_name:,
+                     value:,
+                     return_type:,
+                     decl: :arg,
+                     location: nil
+        super(location: location)
+        @method_name = method_name
+        @method_namespace = method_namespace
+        @method_scope = method_scope
+        @param_name = param_name
+        @value = value
+        @decl = decl
+        @return_type = return_type
+      end
+
+      def name
+        param_name
+      end
+
+      def text_documentation
+        "#{method_path}(#{param_name}) = #{value.inspect}"
+      end
+
+      # @return [String]
+      def method_path
+        # @sg-ignore false failure on method_scope "Wrong argument type for Solargraph::Pin::Base#==: other expected
+        # Solargraph::Pin::Base, received :instance"
+        @method_path ||= "#{method_namespace}#{method_scope == :instance ? '#' : '.'}#{method_name}"
+      end
+
+      private
+
+      def inner_desc
+        "method_path=#{method_path}, value=#{value.inspect}, decl=#{decl.inspect}, " \
+          "return_type=#{return_type&.to_s || 'nil'}"
+      end
+    end
+  end
+end

data/lib/solargraph/pin/instance_variable.rb

@@ -33,6 +33,51 @@ module Solargraph
       def nearly? other
         super && binder == other.binder
       end
+
+      # Same-file requirement only applies when +presence+ is set; an
+      # unnarrowed ivar has none and can be assigned and read in
+      # different files (e.g. ancestor class's method vs. descendant's).
+      #
+      # @param other_closure [Pin::Closure]
+      # @param other_loc [Location]
+      def visible_at? other_closure, other_loc
+        return false if presence && location&.filename != other_loc.filename
+        # @sg-ignore flow sensitive typing needs to handle attrs
+        return false if presence && !presence.include?(other_loc.range.start)
+
+        visible_in_closure?(other_closure)
+      end
+
+      private
+
+      # Unlike BaseVariable, doesn't stop at a lexically-mismatched
+      # Namespace pin: #get_instance_variable_pins already restricts
+      # candidates to the reading namespace and its ancestors, so
+      # reaching one here means visible via inheritance.
+      #
+      # @param viewing_closure [Pin::Closure]
+      # @return [Boolean]
+      def visible_in_closure? viewing_closure
+        return false if closure.nil?
+
+        # top-level ivars aren't visible from within a method
+        # @sg-ignore Need to add nil check here
+        return false if viewing_closure.is_a?(Pin::Method) && closure.context.tags == 'Class<>'
+
+        # @sg-ignore Need to add nil check here
+        return true if viewing_closure.binder.namespace == closure.binder.namespace
+
+        # @sg-ignore Need to add nil check here
+        return true if viewing_closure.return_type == closure.context
+
+        return true if viewing_closure.is_a?(Pin::Namespace)
+
+        parent_of_viewing_closure = viewing_closure.closure
+
+        return false if parent_of_viewing_closure.nil?
+
+        visible_in_closure?(parent_of_viewing_closure)
+      end
     end
   end
 end