steep 1.8.0.dev.2 → 1.8.0.pre.2

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])
@@ -241,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/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
@@ -731,7 +733,7 @@ module Steep
 
         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))
 
@@ -739,8 +741,8 @@ module Steep
           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 || []
@@ -790,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,8 +119,8 @@ 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,
@@ -130,7 +131,7 @@ module Steep
 
             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(
@@ -165,7 +166,7 @@ module Steep
               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
@@ -181,7 +182,7 @@ module Steep
               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)

data/lib/steep/services/signature_help_provider.rb

@@ -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

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

@@ -363,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
@@ -380,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)
@@ -418,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,

data/lib/steep/signature/validator.rb

@@ -79,8 +79,8 @@ module Steep
           type_params.zip(type_args).each do |param, arg|
             arg or raise
 
-            if param.upper_bound
-              upper_bound_type = factory.type(param.upper_bound).subst(subst)
+            if param.upper_bound_type
+              upper_bound_type = factory.type(param.upper_bound_type).subst(subst)
               arg_type = factory.type(arg)
 
               constraints = Subtyping::Constraints.empty
@@ -101,7 +101,8 @@ module Steep
                     name: param.name,
                     upper_bound: upper_bound_type,
                     variance: param.variance,
-                    unchecked: param.unchecked?
+                    unchecked: param.unchecked?,
+                    default_type: factory.type_opt(param.default_type)
                   ),
                   location: location
                 )
@@ -162,9 +163,9 @@ module Steep
 
           case
           when ancestor.name.interface?
-            AST::Types::Name::Interface.new(name: ancestor.name, args: args, location: nil)
+            AST::Types::Name::Interface.new(name: ancestor.name, args: args)
           when ancestor.name.class?
-            AST::Types::Name::Instance.new(name: ancestor.name, args: args, location: nil)
+            AST::Types::Name::Instance.new(name: ancestor.name, args: args)
           else
             raise "#{ancestor.name}"
           end
@@ -181,7 +182,7 @@ module Steep
         if immediate_self_types && !immediate_self_types.empty?
           # @type var sts: Array[AST::Types::t]
           sts = immediate_self_types.map {|st| ancestor_to_type(st) }
-          self_type = AST::Types::Intersection.build(types: sts.push(self_type), location: nil)
+          self_type = AST::Types::Intersection.build(types: sts.push(self_type))
         end
 
         mixin_ancestors.each do |ancestor|
@@ -236,7 +237,7 @@ module Steep
       def validate_definition_type(definition)
         each_method_type(definition) do |method_type|
           upper_bounds = method_type.type_params.each.with_object({}) do |param, hash|
-            hash[param.name] = factory.type_opt(param.upper_bound)
+            hash[param.name] = factory.type_opt(param.upper_bound_type)
           end
 
           checker.push_variable_bounds(upper_bounds) do
@@ -255,23 +256,21 @@ module Steep
         rescue_validation_errors(name) do
           Steep.logger.debug { "Validating class definition `#{name}`..." }
 
-          class_type = AST::Types::Name::Singleton.new(name: name, location: nil)
+          class_type = AST::Types::Name::Singleton.new(name: name)
           instance_type = AST::Types::Name::Instance.new(
             name: name,
-            args: entry.type_params.map { AST::Types::Any.new(location: nil) },
-            location: nil
+            args: entry.type_params.map { AST::Types::Any.instance() }
           )
 
           Steep.logger.tagged "#{name}" do
             builder.build_instance(name).tap do |definition|
               upper_bounds = definition.type_params_decl.each.with_object({}) do |param, bounds|
-                bounds[param.name] = factory.type_opt(param.upper_bound)
+                bounds[param.name] = factory.type_opt(param.upper_bound_type)
               end
 
               self_type = AST::Types::Name::Instance.new(
                 name: name,
-                args: entry.type_params.map { AST::Types::Var.new(name: _1.name) },
-                location: nil
+                args: entry.type_params.map { AST::Types::Var.new(name: _1.name) }
               )
 
               push_context(self_type: self_type, class_type: class_type, instance_type: instance_type) do
@@ -482,13 +481,12 @@ module Steep
             definition = builder.build_interface(name)
 
             upper_bounds = definition.type_params_decl.each.with_object({}) do |param, bounds|
-              bounds[param.name] = factory.type_opt(param.upper_bound)
+              bounds[param.name] = factory.type_opt(param.upper_bound_type)
             end
 
             self_type = AST::Types::Name::Interface.new(
               name: name,
-              args: definition.type_params.map { AST::Types::Var.new(name: _1) },
-              location: nil
+              args: definition.type_params.map { AST::Types::Var.new(name: _1) }
             )
 
             push_context(self_type: self_type, class_type: nil, instance_type: nil) do
@@ -561,11 +559,10 @@ module Steep
       def validate_one_alias(name, entry = env.type_alias_decls[name])
         *, inner_most_outer_module = entry.outer
         if inner_most_outer_module
-          class_type = AST::Types::Name::Singleton.new(name: inner_most_outer_module.name, location: nil)
+          class_type = AST::Types::Name::Singleton.new(name: inner_most_outer_module.name)
           instance_type = AST::Types::Name::Instance.new(
             name: inner_most_outer_module.name,
-            args: inner_most_outer_module.type_params.map { AST::Types::Any.new(location: nil) },
-            location: nil
+            args: inner_most_outer_module.type_params.map { AST::Types::Any.instance() },
           )
         end
 
@@ -579,7 +576,7 @@ module Steep
             end
 
             upper_bounds = entry.decl.type_params.each.with_object({}) do |param, bounds|
-              bounds[param.name] = factory.type_opt(param.upper_bound)
+              bounds[param.name] = factory.type_opt(param.upper_bound_type)
             end
 
             validator.validate_type_alias(entry: entry) do |type|