solargraph 0.57.0 → 0.58.1

data/lib/solargraph/pin_cache.rb

@@ -48,7 +48,7 @@ module Solargraph
       end
 
       # @param require [String]
-      # @return [Array<Pin::Base>]
+      # @return [Array<Pin::Base>, nil]
       def deserialize_stdlib_require require
         load(stdlib_require_path(require))
       end
@@ -65,7 +65,7 @@ module Solargraph
         File.join(work_dir, 'core.ser')
       end
 
-      # @return [Array<Pin::Base>]
+      # @return [Array<Pin::Base>, nil]
       def deserialize_core
         load(core_path)
       end
@@ -83,7 +83,7 @@ module Solargraph
       end
 
       # @param gemspec [Gem::Specification]
-      # @return [Array<Pin::Base>]
+      # @return [Array<Pin::Base>, nil]
       def deserialize_yard_gem(gemspec)
         load(yard_gem_path(gemspec))
       end
@@ -116,7 +116,7 @@ module Solargraph
 
       # @param gemspec [Gem::Specification]
       # @param hash [String, nil]
-      # @return [Array<Pin::Base>]
+      # @return [Array<Pin::Base>, nil]
       def deserialize_rbs_collection_gem(gemspec, hash)
         load(rbs_collection_path(gemspec, hash))
       end
@@ -152,7 +152,7 @@ module Solargraph
 
       # @param gemspec [Gem::Specification]
       # @param hash [String, nil]
-      # @return [Array<Pin::Base>]
+      # @return [Array<Pin::Base>, nil]
       def deserialize_combined_gem gemspec, hash
         load(combined_path(gemspec, hash))
       end

data/lib/solargraph/position.rb

@@ -112,6 +112,7 @@ module Solargraph
 
     def == other
       return false unless other.is_a?(Position)
+      # @sg-ignore https://github.com/castwide/solargraph/pull/1114
       line == other.line and character == other.character
     end
   end

data/lib/solargraph/range.rb

@@ -27,9 +27,12 @@ module Solargraph
     # @param other [BasicObject]
     def <=>(other)
       return nil unless other.is_a?(Range)
+      # @sg-ignore https://github.com/castwide/solargraph/pull/1114
       if start == other.start
+        # @sg-ignore https://github.com/castwide/solargraph/pull/1114
         ending <=> other.ending
       else
+        # @sg-ignore https://github.com/castwide/solargraph/pull/1114
         start <=> other.start
       end
     end
@@ -98,6 +101,7 @@ module Solargraph
 
     def == other
       return false unless other.is_a?(Range)
+      # @sg-ignore https://github.com/castwide/solargraph/pull/1114
       start == other.start && ending == other.ending
     end
 

data/lib/solargraph/rbs_map/conversions.rb

@@ -65,6 +65,7 @@ module Solargraph
           # STDERR.puts "Skipping interface #{decl.name.relative!}"
           interface_decl_to_pin decl, closure
         when RBS::AST::Declarations::TypeAlias
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
           type_aliases[decl.name.to_s] = decl
         when RBS::AST::Declarations::Module
           module_decl_to_pin decl
@@ -426,6 +427,7 @@ module Solargraph
       # @param pin [Pin::Method]
       # @return [void]
       def method_def_to_sigs decl, pin
+        # @param overload [RBS::AST::Members::MethodDefinition::Overload]
         decl.overloads.map do |overload|
           type_location = location_decl_to_pin_location(overload.method_type.location)
           generics = overload.method_type.type_params.map(&:name).map(&:to_s)
@@ -466,33 +468,50 @@ module Solargraph
         parameters = []
         arg_num = -1
         type.type.required_positionals.each do |param|
+          # @sg-ignore RBS generic type understanding issue
           name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
+          # @sg-ignore RBS generic type understanding issue
           parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted, source: :rbs, type_location: type_location)
         end
         type.type.optional_positionals.each do |param|
+          # @sg-ignore RBS generic type understanding issue
           name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :optarg, name: name, closure: pin,
+                                                         # @sg-ignore RBS generic type understanding issue
                                                          return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted,
                                                          type_location: type_location,
                                                          source: :rbs)
         end
         if type.type.rest_positionals
           name = type.type.rest_positionals.name ? type.type.rest_positionals.name.to_s : "arg_#{arg_num += 1}"
-          parameters.push Solargraph::Pin::Parameter.new(decl: :restarg, name: name, closure: pin, source: :rbs, type_location: type_location)
+          inner_rest_positional_type =
+            ComplexType.try_parse(other_type_to_tag(type.type.rest_positionals.type))
+          rest_positional_type = ComplexType::UniqueType.new('Array',
+                                                             [],
+                                                             [inner_rest_positional_type],
+                                                             rooted: true, parameters_type: :list)
+          parameters.push Solargraph::Pin::Parameter.new(decl: :restarg, name: name, closure: pin,
+                                                         source: :rbs, type_location: type_location,
+                                                         return_type: rest_positional_type,)
         end
         type.type.trailing_positionals.each do |param|
+          # @sg-ignore RBS generic type understanding issue
           name = param.name ? param.name.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :arg, name: name, closure: pin, source: :rbs, type_location: type_location)
         end
         type.type.required_keywords.each do |orig, param|
+          # @sg-ignore RBS generic type understanding issue
           name = orig ? orig.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :kwarg, name: name, closure: pin,
+                                                         # @sg-ignore RBS generic type understanding issue
                                                          return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted,
                                                          source: :rbs, type_location: type_location)
         end
         type.type.optional_keywords.each do |orig, param|
+          # @sg-ignore RBS generic type understanding issue
           name = orig ? orig.to_s : "arg_#{arg_num += 1}"
           parameters.push Solargraph::Pin::Parameter.new(decl: :kwoptarg, name: name, closure: pin,
+                                                         # @sg-ignore RBS generic type understanding issue
                                                          return_type: ComplexType.try_parse(other_type_to_tag(param.type)).force_rooted,
                                                          type_location: type_location,
                                                          source: :rbs)
@@ -784,7 +803,9 @@ module Solargraph
       # @param namespace [Pin::Namespace]
       # @return [void]
       def add_mixins decl, namespace
+        # @param mixin [RBS::AST::Members::Include, RBS::AST::Members::Members::Extend, RBS::AST::Members::Members::Prepend]
         decl.each_mixin do |mixin|
+          # @todo are we handling prepend correctly?
           klass = mixin.is_a?(RBS::AST::Members::Include) ? Pin::Reference::Include : Pin::Reference::Extend
           type = build_type(mixin.name, mixin.args)
           generic_values = type.all_params.map(&:to_s)

data/lib/solargraph/rbs_map/core_fills.rb

@@ -48,6 +48,24 @@ module Solargraph
         Solargraph::Pin::Reference::Include.new(name: '_ToAry',
                                                 closure: Solargraph::Pin::Namespace.new(name: 'Array', source: :core_fill),
                                                 generic_values: ['generic<Elem>'],
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_ToAry',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Set', source: :core_fill),
+                                                generic_values: ['generic<Elem>'],
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_Each',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Array', source: :core_fill),
+                                                generic_values: ['generic<Elem>'],
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_Each',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Set', source: :core_fill),
+                                                generic_values: ['generic<Elem>'],
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_ToS',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'Object', source: :core_fill),
+                                                source: :core_fill),
+        Solargraph::Pin::Reference::Include.new(name: '_ToS',
+                                                closure: Solargraph::Pin::Namespace.new(name: 'String', source: :core_fill),
                                                 source: :core_fill)
       ]
 

data/lib/solargraph/rbs_map/core_map.rb

@@ -5,12 +5,13 @@ module Solargraph
     # Ruby core pins
     #
     class CoreMap
+      include Logging
 
       def resolved?
         true
       end
 
-      FILLS_DIRECTORY = File.join(File.dirname(__FILE__), '..', '..', '..', 'rbs', 'fills')
+      FILLS_DIRECTORY = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'rbs', 'fills'))
 
       def initialize; end
 
@@ -23,9 +24,16 @@ module Solargraph
         if cache
           @pins.replace cache
         else
-          loader.add(path: Pathname(FILLS_DIRECTORY))
-          @pins = conversions.pins
+          @pins.concat conversions.pins
+
+          # Avoid RBS::DuplicatedDeclarationError by loading in a different EnvironmentLoader
+          fill_loader = RBS::EnvironmentLoader.new(core_root: nil, repository: RBS::Repository.new(no_stdlib: false))
+          fill_loader.add(path: Pathname(FILLS_DIRECTORY))
+          fill_conversions = Conversions.new(loader: fill_loader)
+          @pins.concat fill_conversions.pins
+
           @pins.concat RbsMap::CoreFills::ALL
+
           processed = ApiMap::Store.new(pins).pins.reject { |p| p.is_a?(Solargraph::Pin::Reference::Override) }
           @pins.replace processed
 
@@ -34,10 +42,6 @@ module Solargraph
         @pins
       end
 
-      def loader
-        @loader ||= RBS::EnvironmentLoader.new(repository: RBS::Repository.new(no_stdlib: false))
-      end
-
       private
 
       # @return [RBS::EnvironmentLoader]

data/lib/solargraph/rbs_map.rb

@@ -23,7 +23,7 @@ module Solargraph
     attr_reader :rbs_collection_config_path
 
     # @param library [String]
-    # @param version [String, nil
+    # @param version [String, nil]
     # @param rbs_collection_config_path [String, Pathname, nil]
     # @param rbs_collection_paths [Array<Pathname, String>]
     def initialize library, version = nil, rbs_collection_config_path: nil, rbs_collection_paths: []
@@ -72,7 +72,7 @@ module Solargraph
       end
     end
 
-    # @param gemspec [Gem::Specification]
+    # @param gemspec [Gem::Specification, Bundler::LazySpecification]
     # @param rbs_collection_path [String, Pathname, nil]
     # @param rbs_collection_config_path [String, Pathname, nil]
     # @return [RbsMap]

data/lib/solargraph/shell.rb

@@ -79,6 +79,7 @@ module Solargraph
           conf['extensions'].push m
         end
       end
+      # @param file [File]
       File.open(File.join(directory, '.solargraph.yml'), 'w') do |file|
         file.puts conf.to_yaml
       end
@@ -172,6 +173,9 @@ module Solargraph
     # @return [void]
     def typecheck *files
       directory = File.realpath(options[:directory])
+      workspace = Solargraph::Workspace.new(directory)
+      level = options[:level].to_sym
+      rules = workspace.rules(level)
       api_map = Solargraph::ApiMap.load_with_cache(directory, $stdout)
       probcount = 0
       if files.empty?
@@ -183,7 +187,7 @@ module Solargraph
 
       time = Benchmark.measure {
         files.each do |file|
-          checker = TypeChecker.new(file, api_map: api_map, level: options[:level].to_sym)
+          checker = TypeChecker.new(file, api_map: api_map, 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 }
@@ -241,6 +245,63 @@ module Solargraph
       puts "#{workspace.filenames.length} files total."
     end
 
+    desc 'pin [PATH]', 'Describe a pin', hide: true
+    option :rbs, type: :boolean, desc: 'Output the pin as RBS', default: false
+    option :typify, type: :boolean, desc: 'Output the calculated return type of the pin from annotations', default: false
+    option :references, type: :boolean, desc: 'Show references', default: false
+    option :probe, type: :boolean, desc: 'Output the calculated return type of the pin from annotations and inference', default: false
+    option :stack, type: :boolean, desc: 'Show entire stack of a method pin by including definitions in superclasses', default: false
+    # @param path [String] The path to the method pin, e.g. 'Class#method' or 'Class.method'
+    # @return [void]
+    def pin path
+      api_map = Solargraph::ApiMap.load_with_cache('.', $stderr)
+      is_method = path.include?('#') || path.include?('.')
+      if is_method && options[:stack]
+        scope, ns, meth = if path.include? '#'
+                            [:instance, *path.split('#', 2)]
+                          else
+                            [:class, *path.split('.', 2)]
+                          end
+
+        # @sg-ignore Wrong argument type for
+        #   Solargraph::ApiMap#get_method_stack: rooted_tag
+        #   expected String, received Array<String>
+        pins = api_map.get_method_stack(ns, meth, scope: scope)
+      else
+        pins = api_map.get_path_pins path
+      end
+      # @type [Hash{Symbol => Pin::Base}]
+      references = {}
+      pin = pins.first
+      case pin
+      when nil
+        $stderr.puts "Pin not found for path '#{path}'"
+        exit 1
+      when Pin::Namespace
+        if options[:references]
+          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
+        end
+      end
+
+      pins.each do |pin|
+        if options[:typify] || options[:probe]
+          type = ComplexType::UNDEFINED
+          type = pin.typify(api_map) if options[:typify]
+          type = pin.probe(api_map) if options[:probe] && type.undefined?
+          print_type(type)
+          next
+        end
+
+        print_pin(pin)
+      end
+      references.each do |key, refpin|
+        puts "\n# #{key.to_s.capitalize}:\n\n"
+        print_pin(refpin)
+      end
+    end
+
     private
 
     # @param pin [Solargraph::Pin::Base]
@@ -267,5 +328,25 @@ module Solargraph
       #   typecheck doesn't complain on the below line
       api_map.cache_gem(gemspec, rebuild: options.rebuild, out: $stdout)
     end
+
+    # @param type [ComplexType]
+    # @return [void]
+    def print_type(type)
+      if options[:rbs]
+        puts type.to_rbs
+      else
+        puts type.rooted_tag
+      end
+    end
+
+    # @param pin [Solargraph::Pin::Base]
+    # @return [void]
+    def print_pin(pin)
+      if options[:rbs]
+        puts pin.to_rbs
+      else
+        puts pin.inspect
+      end
+    end
   end
 end

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

@@ -98,7 +98,10 @@ module Solargraph
                   match = ol.parameters.any?(&:restarg?)
                   break
                 end
-                atype = atypes[idx] ||= arg.infer(api_map, Pin::ProxyType.anonymous(name_pin.context, source: :chain), locals)
+                arg_name_pin = Pin::ProxyType.anonymous(name_pin.context,
+                                                        gates: name_pin.gates,
+                                                        source: :chain)
+                atype = atypes[idx] ||= arg.infer(api_map, arg_name_pin, locals)
                 unless param.compatible_arg?(atype, api_map) || param.restarg?
                   match = false
                   break
@@ -137,7 +140,7 @@ module Solargraph
                 #
                 # qualify(), however, happens in the namespace where
                 # the docs were written - from the method pin.
-                type = with_params(new_return_type.self_to_type(self_type), self_type).qualify(api_map, p.namespace) if new_return_type.defined?
+                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
               break if type.defined?
@@ -266,8 +269,9 @@ module Solargraph
           method_pin = find_method_pin(name_pin)
           return [] unless method_pin
 
+          # @param signature_pin [Pin::Signature]
           method_pin.signatures.map(&:block).compact.map do |signature_pin|
-            return_type = signature_pin.return_type.qualify(api_map, name_pin.namespace)
+            return_type = signature_pin.return_type.qualify(api_map, *name_pin.gates)
             signature_pin.proxy(return_type)
           end
         end

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

@@ -15,73 +15,10 @@ module Solargraph
             gates = ['']
           else
             base = word
-            gates = crawl_gates(name_pin)
+            gates = name_pin.gates
           end
-          parts = base.split('::')
-          gates.each do |gate|
-            # @todo 'Wrong argument type for
-            #   Solargraph::Source::Chain::Constant#deep_constant_type:
-            #   gate expected String, received generic<Elem>' is because
-            #   we lose 'rooted' information in the 'Chain::Array' class
-            #   internally, leaving ::Array#each shadowed when it
-            #   shouldn't be.
-            type = deep_constant_type(gate, api_map)
-            # Use deep inference to resolve root
-            parts[0..-2].each do |sym|
-              pins = api_map.get_constants('', type.namespace).select{ |pin| pin.name == sym }
-              type = first_pin_type(pins, api_map)
-              break if type.undefined?
-            end
-            next if type.undefined?
-            result = api_map.get_constants('', type.namespace).select { |pin| pin.name == parts.last }
-            return result unless result.empty?
-          end
-          []
-        end
-
-        private
-
-        # @param pin [Pin::Closure]
-        # @return [::Array<String>]
-        def crawl_gates pin
-          clos = pin
-          until clos.nil?
-            if clos.is_a?(Pin::Namespace)
-              gates = clos.gates
-              gates.push('') if gates.empty?
-              return gates
-            end
-            clos = clos.closure
-          end
-          ['']
-        end
-
-        # @param pins [::Array<Pin::Base>]
-        # @param api_map [ApiMap]
-        # @return [ComplexType]
-        def first_pin_type(pins, api_map)
-          type = ComplexType::UNDEFINED
-          pins.each do |pin|
-            type = pin.typify(api_map)
-            break if type.defined?
-            type = pin.probe(api_map)
-            break if type.defined?
-          end
-          type
-        end
-
-        # @param gate [String]
-        # @param api_map [ApiMap]
-        # @return [ComplexType]
-        def deep_constant_type(gate, api_map)
-          type = ComplexType::ROOT
-          return type if gate == ''
-          gate.split('::').each do |word|
-            pins = api_map.get_constants('', type.namespace).select { |pin| pin.name == word }
-            type = first_pin_type(pins, api_map)
-            break if type.undefined?
-          end
-          type
+          fqns = api_map.resolve(base, gates)
+          api_map.get_path_pins(fqns)
         end
       end
     end

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

@@ -8,7 +8,7 @@ module Solargraph
           '<if>'
         end
 
-        # @param links [::Array<Link>]
+        # @param links [::Array<Chain>]
         def initialize links
           @links = links
         end

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

@@ -38,7 +38,7 @@ module Solargraph
 
         # @param api_map [ApiMap]
         # @param name_pin [Pin::Base]
-        # @param locals [::Enumerable<Pin::Base>]
+        # @param locals [::Array<Pin::Base>]
         # @return [::Array<Pin::Base>]
         def resolve api_map, name_pin, locals
           []

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

@@ -8,7 +8,7 @@ module Solargraph
           '<or>'
         end
 
-        # @param links [::Array<Link>]
+        # @param links [::Array<Chain>]
         def initialize links
           @links = links
         end

data/lib/solargraph/source/chain.rb

@@ -264,6 +264,8 @@ module Solargraph
                  ComplexType::UNDEFINED
                elsif types.length > 1
                  # Move nil to the end by convention
+
+                 # @param a [ComplexType::UniqueType]
                  sorted = types.flat_map(&:items).sort { |a, _| a.tag == 'nil' ? 1 : 0 }
                  ComplexType.new(sorted.uniq)
                else

data/lib/solargraph/source/encoding_fixes.rb

@@ -1,23 +1,23 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class Source
-    module EncodingFixes
-      module_function
-
-      # Convert strings to normalized UTF-8.
-      #
-      # @param string [String]
-      # @return [String]
-      def normalize string
-        begin
-          string.dup.force_encoding('UTF-8')
-        rescue ::Encoding::CompatibilityError, ::Encoding::UndefinedConversionError, ::Encoding::InvalidByteSequenceError => e
-          # @todo Improve error handling
-          Solargraph::Logging.logger.warn "Normalize error: #{e.message}"
-          string
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    module EncodingFixes
+      module_function
+
+      # Convert strings to normalized UTF-8.
+      #
+      # @param string [String]
+      # @return [String]
+      def normalize string
+        begin
+          string.dup.force_encoding('UTF-8')
+        rescue ::Encoding::CompatibilityError, ::Encoding::UndefinedConversionError, ::Encoding::InvalidByteSequenceError => e
+          # @todo Improve error handling
+          Solargraph::Logging.logger.warn "Normalize error: #{e.message}"
+          string
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source.rb

@@ -15,7 +15,7 @@ module Solargraph
 
     include EncodingFixes
 
-    # @return [String]
+    # @return [String, nil]
     attr_reader :filename
 
     # @return [String]

data/lib/solargraph/source_map/clip.rb

@@ -11,15 +11,14 @@ module Solargraph
       def initialize api_map, cursor
         @api_map = api_map
         @cursor = cursor
-        block_pin = block
-        block_pin.rebind(api_map) if block_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(block_pin.receiver).contain?(cursor.range.start)
-        @in_block = nil
+        closure_pin = closure
+        closure_pin.rebind(api_map) if closure_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(closure_pin.receiver).contain?(cursor.range.start)
       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?
-        result = cursor.chain.define(api_map, block, locals)
+        result = cursor.chain.define(api_map, closure, locals)
         result.concat file_global_methods
         result.concat((source_map.pins + source_map.locals).select{ |p| p.name == cursor.word && p.location.range.contain?(cursor.position) }) if result.empty?
         result
@@ -51,14 +50,15 @@ module Solargraph
 
       # @return [ComplexType]
       def infer
-        result = cursor.chain.infer(api_map, block, locals)
+        result = cursor.chain.infer(api_map, closure, locals)
         if result.tag == 'Class'
           # HACK: Exception to return BasicObject from Class#new
-          dfn = cursor.chain.define(api_map, block, locals).first
+          dfn = cursor.chain.define(api_map, closure, locals).first
           return ComplexType.try_parse('::BasicObject') if dfn && dfn.path == 'Class#new'
         end
-        return result unless result.tag == 'self'
-        cursor.chain.base.infer(api_map, block, locals)
+        # should receive result with selfs resolved from infer()
+        Solargraph.assert_or_log(:clip_infer_self, 'Received selfy inference') if result.selfy?
+        result
       end
 
       # Get an array of all the locals that are visible from the cursors's
@@ -72,22 +72,14 @@ module Solargraph
 
       # @return [::Array<String>]
       def gates
-        block.gates
-      end
-
-      def in_block?
-        return @in_block unless @in_block.nil?
-        @in_block = begin
-          tree = cursor.source.tree_at(cursor.position.line, cursor.position.column)
-          Parser.is_ast_node?(tree[1]) && [:block, :ITER].include?(tree[1].type)
-        end
+        closure.gates
       end
 
       # @param phrase [String]
       # @return [Array<Solargraph::Pin::Base>]
       def translate phrase
         chain = Parser.chain(Parser.parse(phrase))
-        chain.define(api_map, block, locals)
+        chain.define(api_map, closure, locals)
       end
 
       private
@@ -109,8 +101,8 @@ module Solargraph
       end
 
       # @return [Solargraph::Pin::Closure]
-      def block
-        @block ||= source_map.locate_block_pin(cursor.node_position.line, cursor.node_position.character)
+      def closure
+        @closure ||= source_map.locate_closure_pin(cursor.node_position.line, cursor.node_position.character)
       end
 
       # The context at the current position.
@@ -201,20 +193,20 @@ module Solargraph
             result.concat api_map.get_constants(type.namespace, cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates)
           end
         else
-          type = cursor.chain.base.infer(api_map, block, locals)
-          result.concat api_map.get_complex_type_methods(type, block.binder.namespace, cursor.chain.links.length == 1)
+          type = cursor.chain.base.infer(api_map, closure, locals)
+          result.concat api_map.get_complex_type_methods(type, closure.binder.namespace, cursor.chain.links.length == 1)
           if cursor.chain.links.length == 1
             if cursor.word.start_with?('@@')
               return package_completions(api_map.get_class_variable_pins(context_pin.full_context.namespace))
             elsif cursor.word.start_with?('@')
-              return package_completions(api_map.get_instance_variable_pins(block.binder.namespace, block.binder.scope))
+              return package_completions(api_map.get_instance_variable_pins(closure.binder.namespace, closure.binder.scope))
             elsif cursor.word.start_with?('$')
               return package_completions(api_map.get_global_variable_pins)
             end
             result.concat locals
-            result.concat file_global_methods unless block.binder.namespace.empty?
+            result.concat file_global_methods unless closure.binder.namespace.empty?
             result.concat api_map.get_constants(context_pin.context.namespace, *gates)
-            result.concat api_map.get_methods(block.binder.namespace, scope: block.binder.scope, visibility: [:public, :private, :protected])
+            result.concat api_map.get_methods(closure.binder.namespace, scope: closure.binder.scope, visibility: [:public, :private, :protected])
             result.concat api_map.get_methods('Kernel')
             result.concat api_map.keyword_pins.to_a
           end