steep 1.8.0.dev.1 → 1.8.0.pre.1

data/lib/steep/server/type_check_worker.rb

@@ -11,9 +11,7 @@ module Steep
       TypeCheckCodeJob = _ = Struct.new(:guid, :path, keyword_init: true)
       ValidateAppSignatureJob = _ = Struct.new(:guid, :path, keyword_init: true)
       ValidateLibrarySignatureJob = _ = Struct.new(:guid, :path, keyword_init: true)
-      GotoJob = _ = Struct.new(:id, :kind, :params, keyword_init: true) do
-        # @implements GotoJob
-
+      class GotoJob < Struct.new(:id, :kind, :params, keyword_init: true)
         def self.implementation(id:, params:)
           new(
             kind: :implementation,
@@ -57,7 +55,6 @@ module Steep
         super(project: project, reader: reader, writer: writer)
 
         @assignment = assignment
-        @service = Services::TypeCheckService.new(project: project)
         @buffered_changes = {}
         @mutex = Mutex.new()
         @queue = Queue.new
@@ -65,30 +62,35 @@ module Steep
         @current_type_check_guid = nil
       end
 
+      def service
+        @service ||= Services::TypeCheckService.new(project: project)
+      end
+
       def handle_request(request)
         case request[:method]
         when "initialize"
-          load_files(project: project, commandline_args: commandline_args)
           writer.write({ id: request[:id], result: nil})
 
         when "textDocument/didChange"
           collect_changes(request)
 
-        when "$/file/reset"
-          uri = request[:params][:uri]
-          text = request[:params][:content]
+        when CustomMethods::FileLoad::METHOD
+          input = request[:params][:content]
+          load_files(input)
+
+        when CustomMethods::FileReset::METHOD
+          params = request[:params] #: CustomMethods::FileReset::params
+          uri = params[:uri]
+          text = params[:content]
           reset_change(uri: uri, text: text)
 
         when "workspace/symbol"
           query = request[:params][:query]
           queue << WorkspaceSymbolJob.new(id: request[:id], query: query)
-        when "workspace/executeCommand"
-          case request[:params][:command]
-          when "steep/stats"
-            queue << StatsJob.new(id: request[:id])
-          end
-        when "$/typecheck/start"
-          params = request[:params]
+        when CustomMethods::Stats::METHOD
+          queue << StatsJob.new(id: request[:id])
+        when CustomMethods::TypeCheck__Start::METHOD
+          params = request[:params] #: CustomMethods::TypeCheck__Start::params
           enqueue_typecheck_jobs(params)
         when "textDocument/definition"
           queue << GotoJob.definition(id: request[:id], params: request[:params])
@@ -173,7 +175,9 @@ module Steep
                 method: :"textDocument/publishDiagnostics",
                 params: LSP::Interface::PublishDiagnosticsParams.new(
                   uri: Steep::PathHelper.to_uri(job.path).to_s,
-                  diagnostics: diagnostics.map {|diagnostic| formatter.format(diagnostic) }.uniq
+                  diagnostics: diagnostics.map {|diagnostic|
+                    _ = formatter.format(diagnostic)
+                  }.uniq
                 )
               )
             end
@@ -191,7 +195,7 @@ module Steep
                 method: :"textDocument/publishDiagnostics",
                 params: LSP::Interface::PublishDiagnosticsParams.new(
                   uri: Steep::PathHelper.to_uri(job.path).to_s,
-                  diagnostics: diagnostics.map {|diagnostic| formatter.format(diagnostic) }.uniq.compact
+                  diagnostics: diagnostics.map {|diagnostic| _ = formatter.format(diagnostic) }.uniq.compact
                 )
               )
             end
@@ -210,7 +214,9 @@ module Steep
                 method: :"textDocument/publishDiagnostics",
                 params: LSP::Interface::PublishDiagnosticsParams.new(
                   uri: Steep::PathHelper.to_uri(job.path).to_s,
-                  diagnostics: diagnostics.map {|diagnostic| formatter.format(diagnostic) }.uniq.compact
+                  diagnostics: diagnostics.map {|diagnostic|
+                    _ = formatter.format(diagnostic)
+                  }.uniq.compact
                 )
               )
             end
@@ -237,10 +243,7 @@ module Steep
       end
 
       def typecheck_progress(guid:, path:)
-        writer.write(
-          method: "$/typecheck/progress",
-          params: { guid: guid, path: path }
-        )
+        writer.write(CustomMethods::TypeCheck__Progress.notification({ guid: guid, path: path.to_s }))
       end
 
       def workspace_symbol_result(query)

data/lib/steep/server/work_done_progress.rb

@@ -0,0 +1,64 @@
+module Steep
+  module Server
+    class WorkDoneProgress
+      attr_reader :sender, :guid, :percentage
+
+      def initialize(guid, &block)
+        @sender = block
+        @guid = guid
+        @percentage = 0
+      end
+
+      def begin(title, message = nil, request_id:)
+        sender.call(
+          {
+            id: request_id,
+            method: "window/workDoneProgress/create",
+            params: { token: guid }
+          }
+        )
+
+        value = { kind: "begin", cancellable: false, title: title, percentage: percentage }
+        value[:message] = message if message
+
+        sender.call(
+          {
+            method: "$/progress",
+            params: { token: guid, value: value }
+          }
+        )
+
+        self
+      end
+
+      def report(percentage, message = nil)
+        @percentage = percentage
+        value = { kind: "report", percentage: percentage }
+        value[:message] = message if message
+
+        sender.call(
+          {
+            method: "$/progress",
+            params: { token: guid, value: value }
+          }
+        )
+
+        self
+      end
+
+      def end(message = nil)
+        value = { kind: "end" }
+        value[:message] = message if message
+
+        sender.call(
+          {
+            method: "$/progress",
+            params: { token: guid, value: value }
+          }
+        )
+
+        self
+      end
+    end
+  end
+end

data/lib/steep/server/worker_process.rb

@@ -132,7 +132,7 @@ module Steep
         new(reader: reader, writer: writer, stderr: stderr, wait_thread: thread, name: name, index: index&.[](1))
       end
 
-      def self.start_typecheck_workers(steepfile:, args:, steep_command:, count: [Etc.nprocessors - 1, 1].max, delay_shutdown: false)
+      def self.start_typecheck_workers(steepfile:, args:, steep_command:, count: [Etc.nprocessors - 1, 1].max || raise, delay_shutdown: false)
         count.times.map do |i|
           start_worker(
             :typecheck,

data/lib/steep/services/completion_provider.rb

@@ -183,8 +183,9 @@ module Steep
         end
 
         Steep.measure "typechecking" do
+          location = source.buffer.loc_to_pos([line, column])
           resolver = RBS::Resolver::ConstantResolver.new(builder: subtyping.factory.definition_builder)
-          @typing = TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver)
+          @typing = TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver, cursor: location)
         end
       end
 
@@ -348,7 +349,7 @@ module Steep
 
         items = [] #: Array[item]
 
-        context = typing.context_at(line: position.line, column: position.column)
+        context = typing.cursor_context.context or raise
 
         case
         when node.type == :send && node.children[0] == nil && at_end?(position, of: (_ = node.loc).selector)
@@ -469,7 +470,7 @@ module Steep
 
         if at_end?(shift_pos, of: node.loc)
           begin
-            context = typing.context_at(line: position.line, column: position.column)
+            context = typing.cursor_context.context or raise
             receiver_type =
               case (type = typing.type_of(node: node))
               when AST::Types::Self
@@ -499,7 +500,7 @@ module Steep
 
         if at_end?(shift_pos, of: node.loc)
           begin
-            context = typing.context_at(line: position.line, column: position.column)
+            context = typing.cursor_context.context or raise
             receiver_type =
               case (type = typing.type_of(node: node))
               when AST::Types::Self
@@ -529,11 +530,11 @@ module Steep
         case node&.type
         when :const
           # Constant:: ←
-          context = typing.context_at(line: position.line, column: position.column)
+          context = typing.cursor_context.context or raise
           constant_items_for_context(context, parent: node, position: position, items: items, prefix: "")
         when nil
           # :: ←
-          context = typing.context_at(line: position.line, column: position.column)
+          context = typing.cursor_context.context or raise
           constant_items_for_context(context, parent: nil, position: position, items: items, prefix: "")
         end
 
@@ -552,7 +553,7 @@ module Steep
 
         return [] unless node
 
-        context = typing.context_at(line: position.line, column: position.column)
+        context = typing.cursor_context.context or raise
         items = [] #: Array[item]
         instance_variable_items_for_context(context, prefix: "@", position: position, items: items)
         items
@@ -561,7 +562,7 @@ module Steep
       def items_for_rbs(position:, buffer:)
         items = [] #: Array[item]
 
-        context = typing.context_at(line: position.line, column: position.column)
+        context = typing.cursor_context.context or raise
         completion = TypeNameCompletion.new(env: context.env, context: context.module_context.nesting, dirs: [])
         prefix = TypeNameCompletion::Prefix.parse(buffer, line: position.line, column: position.column)
 
@@ -609,7 +610,7 @@ module Steep
 
       def method_items_for_receiver_type(type, include_private:, prefix:, position:, items:)
         range = range_for(position, prefix: prefix)
-        context = typing.context_at(line: position.line, column: position.column)
+        context = typing.cursor_context.context or raise
 
         config =
           if (module_type = context.module_context&.module_type) && (instance_type = context.module_context&.instance_type)
@@ -634,39 +635,40 @@ module Steep
                 case type
                 when AST::Types::Name::Instance, AST::Types::Name::Interface, AST::Types::Name::Singleton
                   # Simple method type
-                  all_decls = Set.new(method_entry.method_types.flat_map {|method_type| method_type.method_decls.to_a }).sort_by {|decl| decl.method_name.to_s }
+                  all_decls = Set.new(method_entry.overloads.flat_map {|overload| overload.method_decls(name) }).sort_by {|decl| decl.method_name.to_s }
                   all_members = Set.new(all_decls.flat_map {|decl| decl.method_def.member })
                   all_members.each do |member|
                     associated_decl = all_decls.find {|decl| decl.method_def.member == member } or next
-                    method_types = method_entry.method_types.select {|method_type| method_type.method_decls.any? {|decl| decl.method_def.member == member }}
+                    overloads = method_entry.overloads.select {|overload| overload.method_defs.any? {|defn| defn.member == member }}
                     items << SimpleMethodNameItem.new(
                       identifier: name,
                       range: range,
                       receiver_type: type,
                       method_name: associated_decl.method_name,
-                      method_types: method_types.map {|type| subtyping.factory.method_type_1(type) },
+                      method_types: overloads.map {|overload| subtyping.factory.method_type_1(overload.method_type) },
                       method_member: member
                     )
                   end
                 else
-                  generated_method_types, defined_method_types = method_entry.method_types.partition {|method_type| method_type.method_decls.empty? }
+                  generated_overloads, defined_overloads =
+                    method_entry.overloads.partition {|overload| overload.method_defs.empty? }
 
-                  unless defined_method_types.empty?
+                  unless defined_overloads.empty?
                     items << ComplexMethodNameItem.new(
                       identifier: name,
                       range: range,
                       receiver_type: type,
-                      method_types: defined_method_types.map {|type| subtyping.factory.method_type_1(type) },
-                      method_decls: defined_method_types.flat_map {|type| type.method_decls.to_a }.sort_by {|decl| decl.method_name.to_s }
+                      method_types: defined_overloads.map { subtyping.factory.method_type_1(_1.method_type) },
+                      method_decls: defined_overloads.flat_map { _1.method_decls(name).to_a }.sort_by {|decl| decl.method_name.to_s }
                     )
                   end
 
-                  unless generated_method_types.empty?
+                  unless generated_overloads.empty?
                     items << GeneratedMethodNameItem.new(
                       identifier: name,
                       range: range,
                       receiver_type: type,
-                      method_types: generated_method_types.map {|type| subtyping.factory.method_type_1(type) }
+                      method_types: generated_overloads.map { subtyping.factory.method_type_1(_1.method_type) }
                     )
                   end
                 end
@@ -725,27 +727,33 @@ module Steep
       end
 
       def keyword_argument_items_for_method(call_node:, send_node:, position:, prefix:, items:)
-        receiver_node, method_name, argument_nodes = deconstruct_send_node!(send_node)
+        _receiver_node, _method_name, argument_nodes = deconstruct_send_node!(send_node)
 
         call = typing.call_of(node: call_node)
 
         case call
         when TypeInference::MethodCall::Typed, TypeInference::MethodCall::Error
-          context = typing.context_at(line: position.line, column: position.column)
+          context = typing.cursor_context.context or raise
           type = call.receiver_type
+          type = type.subst(Interface::Substitution.build([], self_type: context.self_type, module_type: context.module_context&.module_type, instance_type: context.module_context&.instance_type))
 
           config = Interface::Builder::Config.new(self_type: type, variable_bounds: context.variable_context.upper_bounds)
           if shape = subtyping.builder.shape(type, config)
             shape = shape.public_shape if private_send?(call_node)
             if method = shape.methods[call.method_name]
-              method.method_types.each.with_index do |method_type, i|
-                defn = method_type.method_decls.to_a[0]&.method_def
+              method.overloads.each.with_index do |overload, i|
+                defn = overload.method_decls(call.method_name).to_a[0]&.method_def
                 if defn && defn.type.type
                   range = range_for(position, prefix: prefix)
                   kwargs = argument_nodes.find { |arg| arg.type == :kwargs }&.children || []
                   used_kwargs = kwargs.filter_map { |arg| arg.type == :pair && arg.children.first.children.first }
 
-                  kwargs = defn.type.type.required_keywords.keys + defn.type.type.optional_keywords.keys
+                  if defn.type.type.is_a?(RBS::Types::UntypedFunction)
+                    kwargs = [] #: Array[Symbol]
+                  else
+                    kwargs = defn.type.type.required_keywords.keys + defn.type.type.optional_keywords.keys
+                  end
+
                   kwargs.each do |name|
                     if name.to_s.start_with?(prefix) && !used_kwargs.include?(name)
                       items << KeywordArgumentItem.new(identifier: "#{name}:", range: range)
@@ -784,7 +792,7 @@ module Steep
       def unwrap_optional(type)
         if type.is_a?(AST::Types::Union) && type.types.include?(AST::Builtin.nil_type)
           types = type.types.reject { |t| t == AST::Builtin.nil_type }
-          AST::Types::Union.new(types: types, location: type.location)
+          AST::Types::Union.new(types: types)
         else
           type
         end

data/lib/steep/services/goto_service.rb

@@ -176,7 +176,7 @@ module Steep
               when :def, :defs
                 named_location = (_ = node.location) #: Parser::AST::_NamedLocation
                 if test_ast_location(named_location.name, line: line, column: column)
-                  if method_context = typing.context_at(line: line, column: column).method_context
+                  if method_context = typing.cursor_context.context&.method_context
                     if method = method_context.method
                       method.defs.each do |defn|
                         singleton_method =
@@ -285,8 +285,9 @@ module Steep
         source = Source.parse(content, path: path, factory: subtyping.factory)
         source = source.without_unrelated_defs(line: line, column: column)
         resolver = RBS::Resolver::ConstantResolver.new(builder: subtyping.factory.definition_builder)
+        loc = source.buffer.loc_to_pos([line, column])
         [
-          Services::TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver),
+          Services::TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver, cursor: loc),
           signature_service
         ]
       rescue

data/lib/steep/services/hover_provider/ruby.rb

@@ -84,7 +84,8 @@ module Steep
           source = Source.parse(content, path: path, factory: subtyping.factory)
           source = source.without_unrelated_defs(line: line, column: column)
           resolver = ::RBS::Resolver::ConstantResolver.new(builder: subtyping.factory.definition_builder)
-          Services::TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver)
+          pos = source.buffer.loc_to_pos([line, column])
+          Services::TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver, cursor: pos)
         rescue
           nil
         end
@@ -118,17 +119,27 @@ module Steep
             case node.type
             when :lvar
               var_name = node.children[0]
-              context = typing.context_at(line: line, column: column)
-              var_type = context.type_env[var_name] || AST::Types::Any.new(location: nil)
+              context = typing.cursor_context.context or raise
+              var_type = context.type_env[var_name] || AST::Types::Any.instance()
 
-              return VariableContent.new(node: node, name: var_name, type: var_type, location: node.location.name)
+              return VariableContent.new(
+                node: node,
+                name: var_name,
+                type: var_type,
+                location: node.location.name # steep:ignore NoMethod
+              )
 
             when :lvasgn
               var_name, rhs = node.children
-              context = typing.context_at(line: line, column: column)
+              context = typing.cursor_context.context or raise
               type = context.type_env[var_name] || typing.type_of(node: node)
 
-              return VariableContent.new(node: node, name: var_name, type: type, location: node.location.name)
+              return VariableContent.new(
+                node: node,
+                name: var_name,
+                type: type,
+                location: node.location.name # steep:ignore NoMethod
+              )
 
             when :send, :csend
               result_node =
@@ -149,27 +160,29 @@ module Steep
                   return MethodCallContent.new(
                     node: result_node,
                     method_call: call,
-                    location: node.location.selector
+                    location: node.location.selector # steep:ignore NoMethod
                   )
                 end
               end
 
             when :def, :defs
-              context = typing.context_at(line: line, column: column)
+              context = typing.cursor_context.context or raise
               method_context = context.method_context
 
               if method_context && method_context.method
-                return DefinitionContent.new(
-                  node: node,
-                  method_name: method_name_from_method(method_context, builder: context.factory.definition_builder),
-                  method_type: method_context.method_type,
-                  definition: method_context.method,
-                  location: node.loc.name
-                )
+                if method_context.method_type
+                  return DefinitionContent.new(
+                    node: node,
+                    method_name: method_name_from_method(method_context, builder: context.factory.definition_builder),
+                    method_type: method_context.method_type,
+                    definition: method_context.method,
+                    location: node.loc.name # steep:ignore NoMethod
+                  )
+                end
               end
 
             when :const, :casgn
-              context = typing.context_at(line: line, column: column)
+              context = typing.cursor_context.context or raise
 
               type = typing.type_of(node: node)
               const_name = typing.source_index.reference(constant_node: node)
@@ -178,7 +191,7 @@ module Steep
                 entry = context.env.constant_entry(const_name) or return
 
                 return ConstantContent.new(
-                  location: node.location.name,
+                  location: node.location.name, # steep:ignore NoMethod
                   full_name: const_name,
                   type: type,
                   decl: entry

data/lib/steep/services/signature_help_provider.rb

@@ -11,7 +11,7 @@ module Steep
             arguments = [] #: Array[String]
             arguments.push(*method_type.type.required_positionals.map(&:to_s))
             arguments.push(*method_type.type.optional_positionals.map {|p| "?#{p}"})
-            arguments.push("*#{self.method_type.type.rest_positionals}") if method_type.type.rest_positionals
+            arguments.push("*#{method_type.type.rest_positionals}") if method_type.type.rest_positionals
             arguments.push(*method_type.type.trailing_positionals.map(&:to_s))
             arguments.push(*method_type.type.required_keywords.map {|name, param| "#{name}: #{param}" })
             arguments.push(*method_type.type.optional_keywords.map {|name, param| "?#{name}: #{param}" })
@@ -76,7 +76,8 @@ module Steep
       def type_check!(line:, column:)
         source = self.source.without_unrelated_defs(line: line, column: column)
         resolver = RBS::Resolver::ConstantResolver.new(builder: subtyping.factory.definition_builder)
-        TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver)
+        pos = self.source.buffer.loc_to_pos([line, column])
+        TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver, cursor: pos)
       end
 
       def last_argument_nodes_for(argument_nodes:, line:, column:)
@@ -99,7 +100,7 @@ module Steep
 
       def signature_help_for(node, argument, last_argument, typing)
         call = typing.call_of(node: node)
-        context = typing.context_at(line: node.loc.expression.line, column: node.loc.expression.column)
+        context = typing.cursor_context.context or raise
 
         items = [] #: Array[Item]
         index = nil #: Integer?
@@ -113,14 +114,14 @@ module Steep
             shape = shape.public_shape if private_send?(node)
 
             if method = shape.methods[call.method_name]
-              method.method_types.each.with_index do |method_type, i|
-                defn = method_type.method_decls.to_a[0]&.method_def
+              method.overloads.each.with_index do |overload, i|
+                defn = overload.method_defs[0]
 
                 active_parameter = active_parameter_for(defn&.type, argument, last_argument, node)
-                items << Item.new(subtyping.factory.method_type_1(method_type), defn&.comment, active_parameter)
+                items << Item.new(subtyping.factory.method_type_1(overload.method_type), defn&.comment, active_parameter)
 
                 if call.is_a?(MethodCall::Typed)
-                  if method_type.method_decls.intersect?(call.method_decls)
+                  if call.method_decls.intersect?(overload.method_decls(call.method_name).to_set)
                     index = i
                   end
                 end
@@ -136,6 +137,7 @@ module Steep
 
       def active_parameter_for(method_type, argument_nodes, last_argument_nodes, node)
         return unless method_type
+        return unless method_type.type.is_a?(RBS::Types::Function)
 
         positionals = method_type.type.required_positionals.size + method_type.type.optional_positionals.size + (method_type.type.rest_positionals ? 1 : 0) + method_type.type.trailing_positionals.size
 

data/lib/steep/services/signature_service.rb

@@ -156,6 +156,7 @@ module Steep
                 old_text = files[path]&.content
                 content = cs.inject(old_text || "") {|text, change| change.apply_to(text) }
 
+                content ||= "" # It was not clear why `content` can be `nil`, but it happens with `master_test`.
                 buffer = RBS::Buffer.new(name: path, content: content)
 
                 update[path] =
@@ -228,7 +229,6 @@ module Steep
       end
 
       def update_env(updated_files, paths:)
-
         Steep.logger.tagged "#update_env" do
           errors = [] #: Array[RBS::BaseError]
           new_decls = Set[].compare_by_identity #: Set[RBS::AST::Declarations::t]

data/lib/steep/services/type_check_service.rb

@@ -139,8 +139,11 @@ module Steep
 
           case service.status
           when SignatureService::SyntaxErrorStatus, SignatureService::AncestorErrorStatus
-            service.status.diagnostics.group_by {|diag| Pathname(diag.location.buffer.name) }.each do |path, diagnostics|
-              signature_diagnostics[path].push(*diagnostics)
+            service.status.diagnostics.group_by {|diag| diag.location&.buffer&.name&.to_s }.each do |path_string, diagnostics|
+              if path_string
+                path = Pathname(path_string)
+                signature_diagnostics[path].push(*diagnostics)
+              end
             end
           when SignatureService::LoadedStatus
             validation_diagnostics = signature_validation_diagnostics[target.name] || {}
@@ -230,6 +233,7 @@ module Steep
               case service.status
               when SignatureService::SyntaxErrorStatus
                 diagnostics = service.status.diagnostics.select do |diag|
+                  diag.location or raise
                   Pathname(diag.location.buffer.name) == path &&
                     (diag.is_a?(Diagnostic::Signature::SyntaxError) || diag.is_a?(Diagnostic::Signature::UnexpectedError))
                 end
@@ -239,12 +243,15 @@ module Steep
                 end
 
               when SignatureService::AncestorErrorStatus
-                diagnostics = service.status.diagnostics.select {|diag| Pathname(diag.location.buffer.name) == path }
+                diagnostics = service.status.diagnostics.select do |diag|
+                  diag.location or raise
+                  Pathname(diag.location.buffer.name) == path
+                end
                 accumulated_diagnostics.push(*diagnostics)
                 yield [path, accumulated_diagnostics]
 
               when SignatureService::LoadedStatus
-                validator = Signature::Validator.new(checker: service.current_subtyping)
+                validator = Signature::Validator.new(checker: service.current_subtyping || raise)
                 type_names = service.type_names(paths: Set[path], env: service.latest_env).to_set
 
                 unless type_names.empty?
@@ -286,7 +293,10 @@ module Steep
                   end
                 end
 
-                diagnostics = validator.each_error.select {|error| Pathname(error.location.buffer.name) == path }
+                diagnostics = validator.each_error.select do |error|
+                  error.location or raise
+                  Pathname(error.location.buffer.name) == path
+                end
                 accumulated_diagnostics.push(*diagnostics)
                 yield [path, accumulated_diagnostics]
               end
@@ -353,7 +363,7 @@ module Steep
       def type_check_file(target:, subtyping:, path:, text:)
         Steep.logger.tagged "#type_check_file(#{path}@#{target.name})" do
           source = Source.parse(text, path: path, factory: subtyping.factory)
-          typing = TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: yield)
+          typing = TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: yield, cursor: nil)
           ignores = Source::IgnoreRanges.new(ignores: source.ignores)
           SourceFile.with_typing(path: path, content: text, node: source.node, typing: typing, ignores: ignores)
         end
@@ -361,7 +371,7 @@ module Steep
         error = Diagnostic::Ruby::SyntaxError.new(message: exn.message, location: exn.location)
         SourceFile.with_syntax_error(path: path, content: text, error: error)
       rescue ::Parser::SyntaxError => exn
-        error = Diagnostic::Ruby::SyntaxError.new(message: exn.message, location: exn.diagnostic.location)
+        error = Diagnostic::Ruby::SyntaxError.new(message: exn.message, location: (_ = exn).diagnostic.location)
         SourceFile.with_syntax_error(path: path, content: text, error: error)
       rescue EncodingError => exn
         SourceFile.no_data(path: path, content: "")
@@ -370,7 +380,7 @@ module Steep
         SourceFile.no_data(path: path, content: text)
       end
 
-      def self.type_check(source:, subtyping:, constant_resolver:)
+      def self.type_check(source:, subtyping:, constant_resolver:, cursor:)
         annotations = source.annotations(block: source.node, factory: subtyping.factory, context: nil)
 
         definition = subtyping.factory.definition_builder.build_instance(AST::Builtin::Object.module_name)
@@ -408,7 +418,7 @@ module Steep
           variable_context: TypeInference::Context::TypeVariableContext.empty
         )
 
-        typing = Typing.new(source: source, root_context: context)
+        typing = Typing.new(source: source, root_context: context, cursor: cursor)
 
         construction = TypeConstruction.new(
           checker: subtyping,