solargraph 0.60.4 → 0.62.0

data/lib/solargraph/shell.rb

@@ -98,60 +98,37 @@ module Solargraph
     # @return [void]
     def clear
       puts 'Deleting all cached documentation (gems, core and stdlib)'
-      Solargraph::PinCache.clear
+      Solargraph::CacheDir.clear
     end
     map 'clear-cache' => :clear
     map 'clear-cores' => :clear
 
-    desc 'cache', 'Cache a gem', hide: true
-    option :rebuild, type: :boolean, desc: 'Rebuild existing documentation', default: false
-    # @return [void]
-    # @param gem [String]
-    # @param version [String, nil]
-    def cache gem, version = nil
-      gemspec = Gem::Specification.find_by_name(gem, version)
-
-      if options[:rebuild] || !PinCache.has_yard?(gemspec)
-        pins = GemPins.build_yard_pins(['yard-activesupport-concern'], gemspec)
-        PinCache.serialize_yard_gem(gemspec, pins)
-      end
-
-      workspace = Solargraph::Workspace.new(Dir.pwd) if File.exist?('rbs_collection.yaml')
-      rbs_map = RbsMap.from_gemspec(gemspec, workspace&.rbs_collection_path, workspace&.rbs_collection_config_path)
-      if options[:rebuild] || !PinCache.has_rbs_collection?(gemspec, rbs_map.cache_key)
-        PinCache.serialize_rbs_collection_gem(gemspec, rbs_map.cache_key, rbs_map.pins)
-      end
-    rescue Gem::MissingSpecError
-      warn "Gem '#{gem}' not found"
-    end
-
     desc 'uncache GEM [...GEM]', 'Delete specific cached gem documentation'
     long_desc %(
       Specify one or more gem names to clear. 'core' or 'stdlib' may
       also be specified to clear cached system documentation.
       Documentation will be regenerated as needed.
     )
+    option :directory, type: :string, desc: 'Workspace directory', default: Dir.pwd
     # @param gems [Array<String>]
     # @return [void]
     def uncache *gems
       raise ArgumentError, 'No gems specified.' if gems.empty?
+      repo = Solargraph::Repo.new(options[:directory])
+
       gems.each do |gem|
         if gem == 'core'
-          PinCache.uncache_core
-          next
-        end
-
-        if gem == 'stdlib'
-          PinCache.uncache_stdlib
-          next
+          Solargraph::Collection::Core.uncache
+        elsif gem == 'stdlib'
+          FileUtils.rm_rf CacheDir.stdlib_dir
+        else
+          metagem = repo.find_by_name(gem)
+          Solargraph::Collection::Gem.uncache(metagem) if metagem
         end
-
-        spec = Gem::Specification.find_by_name(gem)
-        PinCache.uncache_gem(spec, out: $stdout)
       end
     end
 
-    desc 'gems [GEM[=VERSION]...] [STDLIB...] [core]', 'Cache documentation for
+    desc 'cache GEM_NAME [...GEM_NAME] [core]', 'Cache documentation for
          installed libraries'
     long_desc %( This command will cache the
     generated type documentation for the specified libraries.  While
@@ -172,56 +149,51 @@ module Solargraph
         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
+        Cached documentation is stored in #{CacheDir.base_dir}, which
         can be stored between CI runs.
     )
+    option :directory, type: :string, desc: 'Workspace directory', default: Dir.pwd
     option :rebuild, type: :boolean, desc: 'Rebuild existing documentation', default: false
     # @param names [Array<String>]
     # @return [void]
-    def gems *names
-      # print time with ms
-      workspace = Solargraph::Workspace.new('.')
-
-      if names.empty?
-        Gem::Specification.to_a.each { |spec| do_cache spec, rebuild: options[:rebuild] }
-        $stderr.puts "Documentation cached for all #{Gem::Specification.count} gems."
-      else
-        warn("Caching these gems: #{names}")
-        names.each do |name|
-          if name == 'core'
-            # @sg-ignore cache_core and core? are dynamically defined
-            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
-            if options[:rebuild] || !PinCache.has_yard?(gemspec)
-              pins = GemPins.build_yard_pins(['yard-activesupport-concern'], gemspec)
-              PinCache.serialize_yard_gem(gemspec, pins)
-            end
-
-            workspace = Solargraph::Workspace.new(Dir.pwd)
-            rbs_map = RbsMap.from_gemspec(gemspec, workspace.rbs_collection_path, workspace.rbs_collection_config_path)
-            if options[:rebuild] || !PinCache.has_rbs_collection?(gemspec, rbs_map.cache_key)
-              # cache pins even if result is zero, so we don't retry building pins
-              pins = rbs_map.pins || []
-              PinCache.serialize_rbs_collection_gem(gemspec, rbs_map.cache_key, pins)
-            end
-          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
-        warn "Documentation cached for #{names.count} gems."
+    # @param [Array<Object>] gem_names
+    def cache *gem_names
+      repo = Solargraph::Repo.new(options[:directory])
+      metagems = if gem_names.empty?
+                   if repo.bundled?
+                     repo.bundled.select(&:cacheable?)
+                   else
+                     Gem::Specification.all_names
+                                       .map { |name| Gem::Specification.find_by_full_name(name) }
+                                       .map { |gemspec| Metagem.from_specification(gemspec) }
+                   end
+                 else
+                   gem_names.each_with_object([]) do |name, result|
+                     if name == 'core'
+                       Collection::Core.uncache if options[:rebuild]
+                       puts 'Caching core'
+                       Collection::Core.load
+                     else
+                       # @todo Quick and dirty hack for solargraph-rspec require bug
+                       #   (see https://github.com/lekemula/solargraph-rspec/pull/38)
+                       #   TL;DR: `repo.find_by_path` should not be necessary
+                       found = repo.find_by_name(name) || repo.find_by_path(name)
+                       if found
+                         result.push found
+                       else
+                         warn "Gem #{name} not found"
+                       end
+                     end
+                   end
+                 end
+      metagems.each do |metagem|
+        Collection::Gem.uncache(metagem) if options[:rebuild]
+        puts "Caching #{metagem.name} #{metagem.version} (#{metagem.cache_name})"
+        Collection::Gem.load(metagem)
       end
+      puts "Documentation cached for #{metagems.count} gems."
     end
+    map 'gems' => :cache
 
     desc 'reporters', 'Get a list of diagnostics reporters'
     # @return [void]
@@ -596,27 +568,5 @@ module Solargraph
         puts pin.inspect
       end
     end
-
-    # @param gemspec [Gem::Specification, nil]
-    # @param rebuild [Boolean]
-    # @return [void]
-    def do_cache gemspec, rebuild: false
-      if gemspec.nil?
-        warn "Gem '#{gemspec&.name}' not found"
-      else
-        if rebuild || !PinCache.has_yard?(gemspec)
-          pins = GemPins.build_yard_pins(['yard-activesupport-concern'], gemspec)
-          PinCache.serialize_yard_gem(gemspec, pins)
-        end
-
-        workspace = Solargraph::Workspace.new(Dir.pwd)
-        rbs_map = RbsMap.from_gemspec(gemspec, workspace.rbs_collection_path, workspace.rbs_collection_config_path)
-        if rebuild || !PinCache.has_rbs_collection?(gemspec, rbs_map.cache_key)
-          # cache pins even if result is zero, so we don't retry building pins
-          pins = rbs_map.pins || []
-          PinCache.serialize_rbs_collection_gem(gemspec, rbs_map.cache_key, pins)
-        end
-      end
-    end
   end
 end

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

@@ -55,18 +55,39 @@ module Solargraph
           # 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
+          # Resolve one unique type at a time, so a `self` return type narrows to the one that supplied the pin.
+          # @type [::Array<Pin::Base>]
+          resolved = []
+          unresolved_type = false
+          binder.each_unique_type do |context|
+            if context.duck_type? && context.name[1..] == word
+              # explicit: false skips arity checking; the duck type
+              # only tells us the method exists, not its signature
+              pin = Pin::DuckMethod.new(name: word, source: :chain, explicit: false)
+            else
+              ns_tag = context.namespace == '' ? '' : context.namespace_type.tag
+              stack = api_map.get_method_stack(ns_tag, word, scope: context.scope)
+              pin = stack.first
+            end
+            if pin.nil?
+              unresolved_type = true
+              next
+            end
+            # Bind name_pin to this type alone, so #inferred_pins (incl. Class#new) cannot see the others.
+            type_name_pin = Pin::ProxyType.anonymous(name_pin.context,
+                                                     closure: name_pin.closure,
+                                                     gates: name_pin.gates,
+                                                     binder: context,
+                                                     source: :chain)
+            resolved.concat inferred_pins([pin], api_map, type_name_pin, locals)
           end
-          pin_groups = [] if !api_map.loose_unions && pin_groups.any?(&:empty?)
-          pins = pin_groups.flatten.uniq(&:path)
-          return [] if pins.empty?
-          inferred_pins(pins, api_map, name_pin, locals)
+          return [] if unresolved_type && !api_map.loose_unions
+          return [] if resolved.empty?
+          # Accumulating every type's result treats the binder as a union, which is the only
+          # multi-type binder ComplexType builds; dedup on rooted_tags rather than #tag, which
+          # reports only the first member and so collapses two distinct unions.
+          resolved.uniq { |pin| [pin.path, pin.return_type.rooted_tags] }
         end
 
         private
@@ -153,16 +174,18 @@ module Solargraph
           # qualify(), however, happens in the namespace where
           # the docs were written - from the method pin.
           # @todo Need to add nil check here
-          if new_return_type.defined?
-            type = with_params(new_return_type.self_to_type(self_type), self_type).qualify(api_map, *pin.gates)
-          end
+          type = if new_return_type.defined?
+                   with_params(new_return_type.self_to_type(self_type), self_type).qualify(api_map, *pin.gates)
+                 else
+                   inferr_from_factory_parameters(api_map, pin)
+                 end
           type ||= ComplexType::UNDEFINED
           [type, new_signature_pin]
         end
 
         # @param pins [::Enumerable<Pin::Base>]
         # @param api_map [ApiMap]
-        # @param name_pin [Pin::Base]
+        # @param name_pin [Pin::Base] its #binder resolves `self` in the declarations of `pins`
         # @param locals [::Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
         # @return [::Array<Pin::Base>]
         def inferred_pins pins, api_map, name_pin, locals
@@ -219,6 +242,27 @@ module Solargraph
           end
         end
 
+        # @param api_map [ApiMap]
+        # @param method_pin [Pin::Method]
+        # @return [ComplexType, nil]
+        def inferr_from_factory_parameters api_map, method_pin
+          factory_parameter = api_map.factory_parameters_for_method(method_pin).find do |factory_param|
+            method_pin.parameters.each_with_index.find do |param, index|
+              current_argument = arguments[index]
+              next unless current_argument&.literal?
+              # @type [Solargraph::Source::Chain::Literal]
+              last_link = current_argument.links.last
+              argument_value = last_link.value
+
+              param.name == factory_param.param_name && argument_value == factory_param.value
+            end
+          end
+
+          return nil if factory_parameter.nil?
+
+          factory_parameter.return_type.qualify(api_map, method_pin.namespace)
+        end
+
         # @param pin [Pin::Base]
         # @param api_map [ApiMap]
         # @param context [ComplexType, ComplexType::UniqueType]

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

@@ -6,29 +6,29 @@ module Solargraph
   class Source
     class Chain
       class Literal < Link
-        attr_reader :word, :value
+        attr_reader :word
+
+        # @return [::String, ::Symbol]
+        attr_reader :value
+
+        # @return [Parser::AST::Node]
+        attr_reader :node
 
         # @param type [String]
         # @param node [Parser::AST::Node, Object]
         def initialize type, node
           super("<#{type}>")
+          @node = node
 
-          # @todo We might be able to do some light inference from literals and
-          #   tuples as long as literal values are intransitive.
-
-          # 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 %i[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
+          if node.is_a?(::Parser::AST::Node)
+            if node.type == :true
+              @value = true
+            elsif node.type == :false
+              @value = false
+            elsif %i[int sym].include?(node.type)
+              @value = node.children.first
+            end
+          end
           @type = type
           # @literal_type = ComplexType.try_parse(@value.inspect)
           @literal_type = ComplexType::UNDEFINED

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      # A method parameter represented as a link in a method call chain.
+      #
+      # @example
+      #   some_method('literal_value')
+      #                ^^^^^^^^^^^^^
+      class Parameter < Link
+        # @param literal [Chain::Literal] - literal argument
+        # @param method_call_chain [Chain] method call that contains the argument
+        def initialize literal, method_call_chain # rubocop:disable Lint/MissingSuper
+          @literal = literal
+          @method_call_chain = method_call_chain
+        end
+
+        def word
+          @word ||= "#{method_name}(.., #{@literal.word}, ..)"
+        end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @param locals [::Array<Pin::Parameter, Pin::LocalVariable>]
+        # @return [::Array<Pin::Base>]
+        def resolve api_map, name_pin, locals
+          # @type [Pin::Method]
+          method_pin = method_call_chain.define(api_map, name_pin, locals)&.first
+          return [] unless method_pin
+
+          # Use indexed lookup for better performance
+          api_map.factory_parameters_for_method(method_pin).select do |fp|
+            param_index = method_pin.parameters.find_index { |param| param.name == fp.param_name }
+            next if param_index.nil?
+            next false unless fp.value == literal_value
+
+            # a splat takes every argument from its position on
+            method_pin.parameters[param_index].restarg? ? current_index >= param_index : current_index == param_index
+          end
+        end
+
+        # @return [Boolean] true if this is a parameter of Kernel#require
+        def require_parameter?
+          method_call_chain.links.last.word == 'require'
+        end
+
+        private
+
+        # @return [Chain::Literal]
+        attr_reader :literal
+        # @ return [Chain]
+        attr_reader :method_call_chain
+
+        # @return [String] The name of the method that this parameter belongs to
+        def method_name
+          @method_name ||= method_call.word
+        end
+
+        # @return [Chain::Call]
+        def method_call
+          @method_call_chain.links.last
+        end
+
+        # The index of the literal in the method call chain.
+        # @return [Integer]
+        def current_index
+          @current_index ||= method_call_chain.node.children[2..].index(literal.node)
+        end
+
+        # @return [::String, ::Symbol] The literal value of the parameter
+        # @sg-ignore false "return type could not be inferred"
+        def literal_value
+          literal.node.children.first
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain.rb

@@ -34,6 +34,7 @@ module Solargraph
       autoload :ZSuper,           'solargraph/source/chain/z_super'
       autoload :Hash,             'solargraph/source/chain/hash'
       autoload :Array,            'solargraph/source/chain/array'
+      autoload :Parameter,        'solargraph/source/chain/parameter'
 
       @@inference_stack = []
       @@inference_depth = 0
@@ -182,6 +183,13 @@ module Solargraph
         links.last.is_a?(Chain::Literal)
       end
 
+      # @return [Boolean]
+      # @sg-ignore false "return type could not be inferred"
+      def require_parameter?
+        # @sg-ignore false "Unresolved call to require_parameter? on Solargraph::Source::Chain::Link"
+        links.last.is_a?(Chain::Parameter) && links.last.require_parameter?
+      end
+
       def undefined?
         links.any?(&:undefined?)
       end

data/lib/solargraph/source/node_map.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class NodeMap
+      # @param node [Parser::AST::Node]
+      def initialize node
+        @node = node
+      end
+
+      def find_by_type type
+        node_map[type] || []
+      end
+
+      private
+
+      def node_map
+        @node_map ||= flatten(@node).to_set.classify(&:type)
+      end
+
+      def flatten from
+        return [] unless from.is_a?(::Parser::AST::Node)
+        [from].concat(from.children.flat_map { |child| flatten child })
+      end
+    end
+  end
+end

data/lib/solargraph/source/source_chainer.rb

@@ -31,55 +31,18 @@ module Solargraph
 
       # @return [Source::Chain]
       def chain
-        # Special handling for files that end with an integer and a period
-        # if phrase =~ /^[0-9]+\.$/
-        #   return Chain.new([Chain::Literal.new('Integer', Integer(phrase[0..-2])),
-        #                     Chain::UNDEFINED_CALL])
-        # end
-        if phrase.start_with?(':') && !phrase.start_with?('::')
-          return Chain.new([Chain::Literal.new('Symbol',
-                                               # @sg-ignore Need to add nil check here
-                                               phrase[1..].to_sym)])
-        end
-        if end_of_phrase.strip == '::' && source.code[Position.to_offset(
-          source.code, position
-        )].to_s.match?(/[a-z]/i)
-          return SourceChainer.chain(source,
-                                     Position.new(position.line,
-                                                  position.character + 1))
-        end
+        return SourceChainer.chain(source, Position.new(position.line, position.character + 1)) if end_of_phrase.strip == '::' && source.code[Position.to_offset(source.code, position)].to_s.match?(/[a-z]/i)
+
         begin
-          return Chain.new([]) if phrase.end_with?('..')
-          # @type [::Parser::AST::Node, nil]
-          node = nil
-          # @type [::Parser::AST::Node, nil]
-          parent = nil
-          if !source.repaired? && source.parsed? && source.synchronized?
-            tree = source.tree_at(position.line, position.column)
-            node, parent = tree[0..2]
-          elsif source.parsed? && source.repaired? && end_of_phrase == '.'
-            node, parent = source.tree_at(fixed_position.line, fixed_position.column)[0..2]
-            # provide filename and line so that we can look up local variables there later
-            node = Parser.parse(fixed_phrase, source.filename, fixed_position.line) if node.nil?
-          elsif source.repaired?
-            node = Parser.parse(fixed_phrase, source.filename, fixed_position.line)
-          else
-            unless source.error_ranges.any? do |r|
-              r.nil? || r.include?(fixed_position)
-            end
-              node, parent = source.tree_at(fixed_position.line,
-                                            fixed_position.column)[0..2]
-            end
-            # Exception for positions that chain literal nodes in unsynchronized sources
-            node = nil unless source.synchronized? || !Parser.infer_literal_node_type(node).nil?
-            node = Parser.parse(fixed_phrase, source.filename, fixed_position.line) if node.nil?
-          end
+          node, parent, tree = node_from_position
         rescue Parser::SyntaxError
           return Chain.new([Chain::UNDEFINED_CALL])
         end
+
         return Chain.new([Chain::UNDEFINED_CALL]) if node.nil? || (node.type == :sym && !phrase.start_with?(':'))
-        # chain = NodeChainer.chain(node, source.filename, parent && parent.type == :block)
-        chain = Parser.chain(node, source.filename, parent)
+
+        chain = Parser.chain(node, source.filename, parent, tree)
+
         if source.repaired? || !source.parsed? || !source.synchronized?
           if end_of_phrase.strip == '.'
             chain.links.push Chain::UNDEFINED_CALL
@@ -94,6 +57,39 @@ module Solargraph
 
       private
 
+      # @return [Array(Parser::AST::Node, Parser::AST::Node, Array<Parser::AST::Node>)]
+      #   parent node, child node, and the tree at the position
+      def node_from_position
+        node = nil
+        parent = nil
+        tree = nil
+
+        if source.parsed? && !source.repaired? && source.synchronized?
+          tree = source.tree_at(position.line, position.column)
+          node, parent = tree[0..2]
+        elsif source.parsed? && source.repaired? && end_of_phrase == '.'
+          tree = source.tree_at(fixed_position.line, fixed_position.column)
+          node, parent = tree[0..2]
+          # provide filename and line so that we can look up local variables there later
+          node = Parser.parse(fixed_phrase, source.filename, fixed_position.line) if node.nil?
+          tree = source.tree_at(fixed_position.line, fixed_position.column) if node
+        elsif source.repaired?
+          node = Parser.parse(fixed_phrase, source.filename, fixed_position.line)
+          tree = source.tree_at(fixed_position.line, fixed_position.column) if node
+        else
+          unless source.error_ranges.any? { |r| r.nil? || r.include?(fixed_position) }
+            tree = source.tree_at(fixed_position.line, fixed_position.column)
+            node, parent = tree[0..2]
+          end
+          # Exception for positions that chain literal nodes in unsynchronized sources
+          node = nil unless source.synchronized? || !Parser.infer_literal_node_type(node).nil?
+          node = Parser.parse(fixed_phrase, source.filename, fixed_position.line) if node.nil?
+          tree = source.tree_at(fixed_position.line, fixed_position.column) if node
+        end
+
+        [node, parent, tree]
+      end
+
       # @return [Position]
       attr_reader :position
 

data/lib/solargraph/source.rb

@@ -12,6 +12,7 @@ module Solargraph
     autoload :Cursor,        'solargraph/source/cursor'
     autoload :Chain,         'solargraph/source/chain'
     autoload :SourceChainer, 'solargraph/source/source_chainer'
+    autoload :NodeMap,       'solargraph/source/node_map'
 
     include EncodingFixes
 
@@ -213,6 +214,21 @@ module Solargraph
       end
     end
 
+    # The RBS type in an rbs-inline type assertion, i.e., a `#: TYPE`
+    # comment that trails the node on its last line.
+    #
+    # @example
+    #   x = [] #: Array[String]
+    #
+    # @param node [AST::Node]
+    # @return [String, nil]
+    def type_assertion_for node
+      rng = Range.from_node(node)
+      return nil if rng.nil?
+      rest = code_lines[rng.ending.line]&.[](rng.ending.column..)
+      rest&.[](/\A\s*#:(.*)$/, 1)&.strip
+    end
+
     # A location representing the file in its entirety.
     #
     # @return [Location]
@@ -457,6 +473,7 @@ module Solargraph
     # @return [String]
     def code= val
       @code_lines = nil
+      @node_map = nil
       @finalized = false
       @code = val
     end

data/lib/solargraph/source_map/call.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class SourceMap
+    class Call
+      attr_reader :source_map, :chain, :closure
+
+      # @param source_map [SourceMap]
+      # @param chain [Source::Chain]
+      # @param closure [Pin::Closure]
+      def initialize source_map, chain, closure
+        @source_map = source_map
+        @chain = chain
+        @closure = closure
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/clip.rb

@@ -13,14 +13,14 @@ module Solargraph
         @cursor = cursor
         closure_pin = closure
         # @sg-ignore Need to add nil check here
-        if closure_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(closure_pin.receiver).contain?(cursor.range.start)
+        if closure_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(closure_pin.receiver)&.contain?(cursor.range.start)
           closure_pin.rebind(api_map)
         end
       end
 
       # @return [Array<Pin::Base>] Relevant pins for infering the type of the Cursor's position
       def define
-        return [] if cursor.comment? || cursor.chain.literal?
+        return [] if cursor.comment? || cursor.chain.literal? || cursor.chain.require_parameter?
         result = cursor.chain.define(api_map, closure, locals)
         result.concat file_global_methods
         if result.empty?
@@ -40,7 +40,8 @@ module Solargraph
       # @return [Completion]
       def complete
         return package_completions([]) if !source_map.source.parsed? || cursor.string?
-        if cursor.chain.literal? && cursor.chain.links.last.word == '<Symbol>'
+        # TODO: Improve magic word comparsion == '<::Symbol>', too fragile
+        if cursor.chain.literal? && cursor.chain.links.last.word == '<::Symbol>'
           return package_completions(api_map.get_symbols)
         end
         return Completion.new([], cursor.range) if cursor.chain.literal?
@@ -211,6 +212,7 @@ module Solargraph
               result.concat api_map.get_constants('', cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates) # .select { |pin| pin.name.start_with?(full) }
             end
           else
+            type = type.qualify(api_map, *gates)
             result.concat api_map.get_constants(type.namespace,
                                                 cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates)
           end