solargraph 0.58.2 → 0.59.0.dev.1

data/lib/solargraph/shell.rb

@@ -3,6 +3,7 @@
 require 'benchmark'
 require 'thor'
 require 'yard'
+require 'yaml'
 
 module Solargraph
   class Shell < Thor
@@ -104,9 +105,8 @@ module Solargraph
     # @param gem [String]
     # @param version [String, nil]
     def cache gem, version = nil
-      api_map = Solargraph::ApiMap.load(Dir.pwd)
-      spec = Gem::Specification.find_by_name(gem, version)
-      api_map.cache_gem(spec, rebuild: options[:rebuild], out: $stdout)
+      gems(gem + (version ? "=#{version}" : ''))
+      # '
     end
 
     desc 'uncache GEM [...GEM]', "Delete specific cached gem documentation"
@@ -119,39 +119,83 @@ module Solargraph
     # @return [void]
     def uncache *gems
       raise ArgumentError, 'No gems specified.' if gems.empty?
+      workspace = Solargraph::Workspace.new(Dir.pwd)
+
       gems.each do |gem|
         if gem == 'core'
-          PinCache.uncache_core
+          PinCache.uncache_core(out: $stdout)
           next
         end
 
         if gem == 'stdlib'
-          PinCache.uncache_stdlib
+          PinCache.uncache_stdlib(out: $stdout)
           next
         end
 
-        spec = Gem::Specification.find_by_name(gem)
-        PinCache.uncache_gem(spec, out: $stdout)
+        spec = workspace.find_gem(gem)
+        raise Thor::InvocationError, "Gem '#{gem}' not found" if spec.nil?
+
+        # @sg-ignore flow sensitive typing needs to handle 'raise if'
+        workspace.uncache_gem(spec, out: $stdout)
       end
     end
 
-    desc 'gems [GEM[=VERSION]]', 'Cache documentation for installed gems'
+    desc 'gems [GEM[=VERSION]...] [STDLIB...] [core]', 'Cache documentation for
+         installed libraries'
+    long_desc %( This command will cache the
+    generated type documentation for the specified libraries.  While
+    Solargraph will generate this on the fly when needed, it takes
+    time.  This command will generate it in advance, which can be
+    useful for CI scenarios.
+
+        With no arguments, it will cache all libraries in the current
+        workspace.  If a gem or standard library name is specified, it
+        will cache that library's type documentation.
+
+        An equals sign after a gem will allow a specific gem version
+        to be cached.
+
+        The 'core' argument can be used to cache the type
+        documentation for the core Ruby libraries.
+
+        If the library is already cached, it will be rebuilt if the
+        --rebuild option is set.
+
+        Cached documentation is stored in #{PinCache.base_dir}, which
+        can be stored between CI runs.
+    )
     option :rebuild, type: :boolean, desc: 'Rebuild existing documentation', default: false
     # @param names [Array<String>]
     # @return [void]
     def gems *names
-      api_map = ApiMap.load('.')
+      # print time with ms
+      workspace = Solargraph::Workspace.new('.')
+
       if names.empty?
-        Gem::Specification.to_a.each { |spec| do_cache spec, api_map }
-        STDERR.puts "Documentation cached for all #{Gem::Specification.count} gems."
+        workspace.cache_all_for_workspace!($stdout, rebuild: options[:rebuild])
       else
+        $stderr.puts("Caching these gems: #{names}")
         names.each do |name|
-          spec = Gem::Specification.find_by_name(*name.split('='))
-          do_cache spec, api_map
+          if name == 'core'
+            PinCache.cache_core(out: $stdout) if !PinCache.core? || options[:rebuild]
+            next
+          end
+
+          gemspec = workspace.find_gem(*name.split('='))
+          if gemspec.nil?
+            warn "Gem '#{name}' not found"
+          else
+            workspace.cache_gem(gemspec, rebuild: options[:rebuild], out: $stdout)
+          end
         rescue Gem::MissingSpecError
           warn "Gem '#{name}' not found"
+        rescue Gem::Requirement::BadRequirementError => e
+          warn "Gem '#{name}' failed while loading"
+          warn e.message
+          # @sg-ignore Need to add nil check here
+          warn e.backtrace.join("\n")
         end
-        STDERR.puts "Documentation cached for #{names.count} gems."
+        $stderr.puts "Documentation cached for #{names.count} gems."
       end
     end
 
@@ -176,7 +220,10 @@ module Solargraph
       workspace = Solargraph::Workspace.new(directory)
       level = options[:level].to_sym
       rules = workspace.rules(level)
-      api_map = Solargraph::ApiMap.load_with_cache(directory, $stdout)
+      api_map =
+        Solargraph::ApiMap.load_with_cache(directory, $stdout,
+                                           loose_unions:
+                                             !rules.require_all_unique_types_support_call?)
       probcount = 0
       if files.empty?
         files = api_map.source_maps.map(&:filename)
@@ -184,10 +231,9 @@ module Solargraph
         files.map! { |file| File.realpath(file) }
       end
       filecount = 0
-
       time = Benchmark.measure {
         files.each do |file|
-          checker = TypeChecker.new(file, api_map: api_map, level: options[:level].to_sym, workspace: workspace)
+          checker = TypeChecker.new(file, api_map: api_map, rules: rules, level: options[:level].to_sym, workspace: workspace)
           problems = checker.problems
           next if problems.empty?
           problems.sort! { |a, b| a.location.range.start.line <=> b.location.range.start.line }
@@ -195,7 +241,6 @@ module Solargraph
           filecount += 1
           probcount += problems.length
         end
-        # "
       }
       puts "Typecheck finished in #{time.real} seconds."
       puts "#{probcount} problem#{probcount != 1 ? 's' : ''} found#{files.length != 1 ? " in #{filecount} of #{files.length} files" : ''}."
@@ -219,19 +264,25 @@ module Solargraph
       api_map = nil
       time = Benchmark.measure {
         api_map = Solargraph::ApiMap.load_with_cache(directory, $stdout)
+        # @sg-ignore flow sensitive typing should be able to handle redefinition
         api_map.pins.each do |pin|
           begin
             puts pin_description(pin) if options[:verbose]
             pin.typify api_map
             pin.probe api_map
           rescue StandardError => e
+            # @todo to add nil check here
+            # @todo should warn on nil dereference below
             STDERR.puts "Error testing #{pin_description(pin)} #{pin.location ? "at #{pin.location.filename}:#{pin.location.range.start.line + 1}" : ''}"
             STDERR.puts "[#{e.class}]: #{e.message}"
+            # @todo Need to add nil check here
+            # @todo flow sensitive typing should be able to handle redefinition
             STDERR.puts e.backtrace.join("\n")
             exit 1
           end
         end
       }
+      # @sg-ignore Need to add nil check here
       puts "Scanned #{directory} (#{api_map.pins.length} pins) in #{time.real} seconds."
     end
 
@@ -279,6 +330,7 @@ module Solargraph
         exit 1
       when Pin::Namespace
         if options[:references]
+          # @sg-ignore Need to add nil check here
           superclass_tag = api_map.qualify_superclass(pin.return_type.tag)
           superclass_pin = api_map.get_path_pins(superclass_tag).first if superclass_tag
           references[:superclass] = superclass_pin if superclass_pin
@@ -309,6 +361,7 @@ module Solargraph
     def pin_description pin
       desc = if pin.path.nil? || pin.path.empty?
         if pin.closure
+          # @sg-ignore Need to add nil check here
           "#{pin.closure.path} | #{pin.name}"
         else
           "#{pin.context.namespace} | #{pin.name}"
@@ -316,20 +369,12 @@ module Solargraph
       else
         pin.path
       end
+      # @sg-ignore Need to add nil check here
       desc += " (#{pin.location.filename} #{pin.location.range.start.line})" if pin.location
       desc
     end
 
-    # @param gemspec [Gem::Specification]
-    # @param api_map [ApiMap]
-    # @return [void]
-    def do_cache gemspec, api_map
-      # @todo if the rebuild: option is passed as a positional arg,
-      #   typecheck doesn't complain on the below line
-      api_map.cache_gem(gemspec, rebuild: options.rebuild, out: $stdout)
-    end
-
-    # @param type [ComplexType]
+    # @param type [ComplexType, ComplexType::UniqueType]
     # @return [void]
     def print_type(type)
       if options[:rbs]

data/lib/solargraph/source/chain/call.rb

@@ -37,6 +37,7 @@ module Solargraph
 
         # @sg-ignore Fix "Not enough arguments to Module#protected"
         protected def equality_fields
+          # @sg-ignore literal arrays in this module turn into ::Solargraph::Source::Chain::Array
           super + [arguments, block]
         end
 
@@ -50,24 +51,35 @@ module Solargraph
         def resolve api_map, name_pin, locals
           return super_pins(api_map, name_pin) if word == 'super'
           return yield_pins(api_map, name_pin) if word == 'yield'
-          found = if head?
-            api_map.visible_pins(locals, word, name_pin, location)
-          else
-            []
-          end
-          return inferred_pins(found, api_map, name_pin, locals) unless found.empty?
-          pins = name_pin.binder.each_unique_type.flat_map do |context|
+          found = api_map.var_at_location(locals, word, name_pin, location) if head?
+
+          return inferred_pins([found], api_map, name_pin, locals) unless found.nil?
+          binder = name_pin.binder
+          # this is a q_call - i.e., foo&.bar - assume result of call
+          # will be nil or result as if binder were not nil -
+          # chain.rb#maybe_nil will add the nil type later, we just
+          # need to worry about the not-nil case
+
+          # @sg-ignore Need to handle duck-typed method calls on union types
+          binder = binder.without_nil if nullable?
+          # @sg-ignore Need to handle duck-typed method calls on union types
+          pin_groups = binder.each_unique_type.map do |context|
             ns_tag = context.namespace == '' ? '' : context.namespace_type.tag
             stack = api_map.get_method_stack(ns_tag, word, scope: context.scope)
             [stack.first].compact
           end
+          # @sg-ignore literal arrays in this module turn into ::Solargraph::Source::Chain::Array
+          if !api_map.loose_unions && pin_groups.any? { |pins| pins.empty? }
+            pin_groups = []
+          end
+          pins = pin_groups.flatten.uniq(&:path)
           return [] if pins.empty?
           inferred_pins(pins, api_map, name_pin, locals)
         end
 
         private
 
-        # @param pins [::Enumerable<Pin::Method>]
+        # @param pins [::Enumerable<Pin::Base>]
         # @param api_map [ApiMap]
         # @param name_pin [Pin::Base]
         # @param locals [::Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
@@ -84,9 +96,13 @@ module Solargraph
             # reject it regardless
 
             with_block, without_block = overloads.partition(&:block?)
+            # @sg-ignore flow sensitive typing should handle is_a? and next
+            # @type Array<Pin::Signature>
             sorted_overloads = with_block + without_block
             # @type [Pin::Signature, nil]
             new_signature_pin = nil
+            # @sg-ignore flow sensitive typing should handle is_a? and next
+            # @param ol [Pin::Signature]
             sorted_overloads.each do |ol|
               next unless ol.arity_matches?(arguments, with_block?)
               match = true
@@ -99,6 +115,7 @@ module Solargraph
                   break
                 end
                 arg_name_pin = Pin::ProxyType.anonymous(name_pin.context,
+                                                        closure: name_pin.closure,
                                                         gates: name_pin.gates,
                                                         source: :chain)
                 atype = atypes[idx] ||= arg.infer(api_map, arg_name_pin, locals)
@@ -110,6 +127,7 @@ module Solargraph
               if match
                 if ol.block && with_block?
                   block_atypes = ol.block.parameters.map(&:return_type)
+                  # @todo Need to add nil check here
                   if block.links.map(&:class) == [BlockSymbol]
                     # like the bar in foo(&:bar)
                     blocktype = block_symbol_call_type(api_map, name_pin.context, block_atypes, locals)
@@ -140,6 +158,7 @@ module Solargraph
                 #
                 # qualify(), however, happens in the namespace where
                 # the docs were written - from the method pin.
+                # @todo Need to add nil check here
                 type = with_params(new_return_type.self_to_type(self_type), self_type).qualify(api_map, *p.gates) if new_return_type.defined?
                 type ||= ComplexType::UNDEFINED
               end
@@ -149,9 +168,11 @@ module Solargraph
             next p.proxy(type) if type.defined?
             if !p.macros.empty?
               result = process_macro(p, api_map, name_pin.context, locals)
+              # @sg-ignore flow sensitive typing should be able to handle redefinition
               next result unless result.return_type.undefined?
             elsif !p.directives.empty?
               result = process_directive(p, api_map, name_pin.context, locals)
+              # @sg-ignore flow sensitive typing should be able to handle redefinition
               next result unless result.return_type.undefined?
             end
             p
@@ -162,8 +183,11 @@ module Solargraph
               reduced_context = name_pin.binder.reduce_class_type
               pin.proxy(reduced_context)
             else
+              # @sg-ignore Need to add nil check here
               next pin if pin.return_type.undefined?
+              # @sg-ignore Need to add nil check here
               selfy = pin.return_type.self_to_type(name_pin.binder)
+              # @sg-ignore Need to add nil check here
               selfy == pin.return_type ? pin : pin.proxy(selfy)
             end
           end
@@ -171,7 +195,7 @@ module Solargraph
 
         # @param pin [Pin::Base]
         # @param api_map [ApiMap]
-        # @param context [ComplexType]
+        # @param context [ComplexType, ComplexType::UniqueType]
         # @param locals [::Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
         # @return [Pin::Base]
         def process_macro pin, api_map, context, locals
@@ -190,7 +214,7 @@ module Solargraph
 
         # @param pin [Pin::Method]
         # @param api_map [ApiMap]
-        # @param context [ComplexType]
+        # @param context [ComplexType, ComplexType::UniqueType]
         # @param locals [::Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
         # @return [Pin::ProxyType]
         def process_directive pin, api_map, context, locals
@@ -206,21 +230,24 @@ module Solargraph
         # @param pin [Pin::Base]
         # @param macro [YARD::Tags::MacroDirective]
         # @param api_map [ApiMap]
-        # @param context [ComplexType]
+        # @param context [ComplexType, ComplexType::UniqueType]
         # @param locals [::Array<Pin::LocalVariable, Pin::Parameter>]
         # @return [Pin::ProxyType]
         def inner_process_macro pin, macro, api_map, context, locals
           vals = arguments.map{ |c| Pin::ProxyType.anonymous(c.infer(api_map, pin, locals), source: :chain) }
           txt = macro.tag.text.clone
+          # @sg-ignore Need to add nil check here
           if txt.empty? && macro.tag.name
             named = api_map.named_macro(macro.tag.name)
             txt = named.tag.text.clone if named
           end
           i = 1
           vals.each do |v|
+            # @sg-ignore Need to add nil check here
             txt.gsub!(/\$#{i}/, v.context.namespace)
             i += 1
           end
+          # @sg-ignore Need to add nil check here
           docstring = Solargraph::Source.parse_docstring(txt).to_docstring
           tag = docstring.tag(:return)
           unless tag.nil? || tag.types.nil?
@@ -246,6 +273,7 @@ module Solargraph
         def find_method_pin(name_pin)
           method_pin = name_pin
           until method_pin.is_a?(Pin::Method)
+            # @sg-ignore Need to support this in flow sensitive typing
             method_pin = method_pin.closure
             return if method_pin.nil?
           end
@@ -271,13 +299,14 @@ module Solargraph
 
           # @param signature_pin [Pin::Signature]
           method_pin.signatures.map(&:block).compact.map do |signature_pin|
+            # @sg-ignore Need to add nil check here
             return_type = signature_pin.return_type.qualify(api_map, *name_pin.gates)
             signature_pin.proxy(return_type)
           end
         end
 
         # @param type [ComplexType]
-        # @param context [ComplexType]
+        # @param context [ComplexType, ComplexType::UniqueType]
         # @return [ComplexType]
         def with_params type, context
           return type unless type.to_s.include?('$')
@@ -291,13 +320,14 @@ module Solargraph
         end
 
         # @param api_map [ApiMap]
-        # @param context [ComplexType]
+        # @param context [ComplexType, ComplexType::UniqueType]
         # @param block_parameter_types [::Array<ComplexType>]
         # @param locals [::Array<Pin::LocalVariable>]
         # @return [ComplexType, nil]
         def block_symbol_call_type(api_map, context, block_parameter_types, locals)
           # Ruby's shorthand for sending the passed in method name
           # to the first yield parameter with no arguments
+          # @sg-ignore Need to add nil check here
           block_symbol_name = block.links.first.word
           block_symbol_call_path = "#{block_parameter_types.first}##{block_symbol_name}"
           callee = api_map.get_path_pins(block_symbol_call_path).first
@@ -305,6 +335,7 @@ module Solargraph
           # @todo: Figure out why we get unresolved generics at
           #   this point and need to assume method return types
           #   based on the generic type
+          # @sg-ignore Need to add nil check here
           return_type ||= api_map.get_path_pins("#{context.subtypes.first}##{block.links.first.word}").first&.return_type
           return_type || ComplexType::UNDEFINED
         end
@@ -312,9 +343,11 @@ module Solargraph
         # @param api_map [ApiMap]
         # @return [Pin::Block, nil]
         def find_block_pin(api_map)
+          # @sg-ignore Need to add nil check here
           node_location = Solargraph::Location.from_node(block.node)
-          return if  node_location.nil?
+          return if node_location.nil?
           block_pins = api_map.get_block_pins
+          # @sg-ignore Need to add nil check here
           block_pins.find { |pin| pin.location.contain?(node_location) }
         end
 
@@ -326,10 +359,12 @@ module Solargraph
         def block_call_type(api_map, name_pin, locals)
           return nil unless with_block?
 
-          block_context_pin = name_pin
           block_pin = find_block_pin(api_map)
-          block_context_pin = block_pin.closure if block_pin
-          block.infer(api_map, block_context_pin, locals)
+          # We use the block pin as the closure, as the parameters
+          # here will only be defined inside the block itself and we
+          # need to be able to see them
+          # @sg-ignore Need to add nil check here
+          block.infer(api_map, block_pin, locals)
         end
       end
     end

data/lib/solargraph/source/chain/constant.rb

@@ -17,7 +17,9 @@ module Solargraph
             base = word
             gates = name_pin.gates
           end
+          # @sg-ignore Need to add nil check here
           fqns = api_map.resolve(base, gates)
+          # @sg-ignore Need to add nil check here
           api_map.get_path_pins(fqns)
         end
       end

data/lib/solargraph/source/chain/hash.rb

@@ -14,6 +14,7 @@ module Solargraph
 
         # @sg-ignore Fix "Not enough arguments to Module#protected"
         protected def equality_fields
+          # @sg-ignore literal arrays in this module turn into ::Solargraph::Source::Chain::Array
           super + [@splatted]
         end
 

data/lib/solargraph/source/chain/if.rb

@@ -15,6 +15,7 @@ module Solargraph
 
         # @sg-ignore Fix "Not enough arguments to Module#protected"
         protected def equality_fields
+          # @sg-ignore literal arrays in this module turn into ::Solargraph::Source::Chain::Array
           super + [@links]
         end
 

data/lib/solargraph/source/chain/instance_variable.rb

@@ -4,9 +4,30 @@ module Solargraph
   class Source
     class Chain
       class InstanceVariable < Link
+        # @param word [String]
+        # @param node [Parser::AST::Node, nil] The node representing the variable
+        # @param location [Location, nil] The location of the variable reference in the source
+        def initialize word, node, location
+          super(word)
+          @node = node
+          @location = location
+        end
+
+        # @sg-ignore Declared return type
+        #   ::Array<::Solargraph::Pin::Base> does not match inferred
+        #   type ::Array<::Solargraph::Pin::BaseVariable, ::NilClass>
+        #   for Solargraph::Source::Chain::InstanceVariable#resolve
         def resolve api_map, name_pin, locals
-          api_map.get_instance_variable_pins(name_pin.binder.namespace, name_pin.binder.scope).select{|p| p.name == word}
+          ivars = api_map.get_instance_variable_pins(name_pin.context.namespace, name_pin.context.scope).select{|p| p.name == word}
+          out = api_map.var_at_location(ivars, word, name_pin, location)
+          [out].compact
         end
+
+        private
+
+        # @todo: Missed nil violation
+        # @return [Location]
+        attr_reader :location
       end
     end
   end

data/lib/solargraph/source/chain/literal.rb

@@ -16,11 +16,15 @@ module Solargraph
         # @param node [Parser::AST::Node, Object]
         def initialize type, node
           if node.is_a?(::Parser::AST::Node)
+            # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
             if node.type == :true
               @value = true
+            # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
             elsif node.type == :false
               @value = false
+            # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
             elsif [:int, :sym].include?(node.type)
+              # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
               @value = node.children.first
             end
           end
@@ -31,6 +35,7 @@ module Solargraph
 
         # @sg-ignore Fix "Not enough arguments to Module#protected"
         protected def equality_fields
+          # @sg-ignore literal arrays in this module turn into ::Solargraph::Source::Chain::Array
           super + [@value, @type, @literal_type, @complex_type]
         end
 

data/lib/solargraph/source/chain/or.rb

@@ -8,6 +8,8 @@ module Solargraph
           '<or>'
         end
 
+        attr_reader :links
+
         # @param links [::Array<Chain>]
         def initialize links
           @links = links
@@ -15,7 +17,13 @@ module Solargraph
 
         def resolve api_map, name_pin, locals
           types = @links.map { |link| link.infer(api_map, name_pin, locals) }
-          [Solargraph::Pin::ProxyType.anonymous(Solargraph::ComplexType.new(types.uniq), source: :chain)]
+          combined_type = Solargraph::ComplexType.new(types)
+          unless types.all?(&:nullable?)
+            # @sg-ignore flow sensitive typing should be able to handle redefinition
+            combined_type = combined_type.without_nil
+          end
+
+          [Solargraph::Pin::ProxyType.anonymous(combined_type, source: :chain)]
         end
       end
     end

data/lib/solargraph/source/chain.rb

@@ -71,6 +71,7 @@ module Solargraph
 
       # @return [Chain]
       def base
+        # @sg-ignore Need to add nil check here
         @base ||= Chain.new(links[0..-2])
       end
 
@@ -78,25 +79,25 @@ module Solargraph
       #
       # @param api_map [ApiMap]
       #
-      # @param name_pin [Pin::Base] A pin
-      # representing the place in which expression is evaluated (e.g.,
-      # a Method pin, or a Module or Class pin if not run within a
-      # method - both in terms of the closure around the chain, as well
-      # as the self type used for any method calls in head position.
+      # @param name_pin [Pin::Base] A pin representing the closure in
+      #   which expression is evaluated (e.g., a Method pin, or a
+      #   Module or Class pin if not run within a method - both in
+      #   terms of the closure around the chain, as well as the self
+      #   type used for any method calls in head position.
       #
       #   Requirements for name_pin:
       #
       #     * name_pin.context: This should be a type representing the
-      #       namespace where we can look up non-local variables and
-      #       method names.  If it is a Class<X>, we will look up
-      #       :class scoped methods/variables.
+      #       namespace where we can look up non-local variables.  If
+      #       it is a Class<X>, we will look up :class scoped
+      #       instance variables.
       #
       #     * name_pin.binder: Used for method call lookups only
       #       (Chain::Call links).  For method calls as the first
       #       element in the chain, 'name_pin.binder' should be the
       #       same as name_pin.context above.  For method calls later
-      #       in the chain (e.g., 'b' in a.b.c), it should represent
-      #       'a'.
+      #       in the chain, it changes.  (e.g., for 'b' in a.b.c, it
+      #       should represent the type of 'a').
       #
       # @param locals [::Array<Pin::LocalVariable>] Any local
       #   variables / method parameters etc visible by the statement
@@ -113,6 +114,7 @@ module Solargraph
         #
         # @todo ProxyType uses 'type' for the binder, but '
         working_pin = name_pin
+        # @sg-ignore Need to add nil check here
         links[0..-2].each do |link|
           pins = link.resolve(api_map, working_pin, locals)
           type = infer_from_definitions(pins, working_pin, api_map, locals)
@@ -138,7 +140,8 @@ module Solargraph
       # @return [ComplexType]
       # @sg-ignore
       def infer api_map, name_pin, locals
-        cache_key = [node, node&.location, links, name_pin&.return_type, locals]
+        # includes binder as it is mutable in Pin::Block
+        cache_key = [node, node&.location, links, name_pin&.return_type, name_pin&.binder, locals]
         if @@inference_invalidation_key == api_map.hash
           cached = @@inference_cache[cache_key]
           return cached if cached
@@ -154,7 +157,7 @@ module Solargraph
       # @param api_map [ApiMap]
       # @param name_pin [Pin::Base]
       # @param locals [::Array<Pin::LocalVariable>]
-      # @return [ComplexType]
+      # @return [ComplexType, ComplexType::UniqueType]
       def infer_uncached api_map, name_pin, locals
         pins = define(api_map, name_pin, locals)
         if pins.empty?
@@ -209,12 +212,12 @@ module Solargraph
       private
 
       # @param pins [::Array<Pin::Base>]
-      # @param context [Pin::Base]
+      # @param name_pin [Pin::Base]
       # @param api_map [ApiMap]
       # @param locals [::Enumerable<Pin::LocalVariable>]
-      # @return [ComplexType]
-      def infer_from_definitions pins, context, api_map, locals
-        # @type [::Array<ComplexType>]
+      # @return [ComplexType, ComplexType::UniqueType]
+      def infer_from_definitions pins, name_pin, api_map, locals
+        # @type [::Array<ComplexType, ComplexType::UniqueType>]
         types = []
         unresolved_pins = []
         # @todo this param tag shouldn't be needed to probe the type
@@ -232,7 +235,8 @@ module Solargraph
               # @todo even at strong, no typechecking complaint
               #   happens when a [Pin::Base,nil] is passed into a method
               #   that accepts only [Pin::Namespace] as an argument
-              type = type.resolve_generics(pin.closure, context.binder)
+              # @sg-ignore Need to add nil check here
+              type = type.resolve_generics(pin.closure, name_pin.binder)
             end
             types << type
           else
@@ -271,16 +275,15 @@ module Solargraph
                else
                  ComplexType.new(types)
                end
-        if context.nil? || context.return_type.undefined?
+        if name_pin.nil? || name_pin.context.undefined?
           # up to downstream to resolve self type
           return type
         end
-
-        type.self_to_type(context.return_type)
+        type.self_to_type(name_pin.context)
       end
 
-      # @param type [ComplexType]
-      # @return [ComplexType]
+      # @param type [ComplexType, ComplexType::UniqueType]
+      # @return [ComplexType, ComplexType::UniqueType]
       def maybe_nil type
         return type if type.undefined? || type.void? || type.nullable?
         return type unless nullable?