steep 1.2.1 → 1.3.0.pre.2

data/lib/steep/diagnostic/signature.rb

@@ -11,9 +11,7 @@ module Steep
         end
 
         def header_line
-          StringIO.new.tap do |io|
-            puts io
-          end.string
+          raise
         end
 
         def detail_lines
@@ -25,7 +23,9 @@ module Steep
         end
 
         def path
-          location.buffer.name
+          if location
+            Pathname(location.buffer.name)
+          end
         end
       end
 
@@ -166,7 +166,6 @@ module Steep
       class RecursiveAlias < Base
         attr_reader :class_name
         attr_reader :names
-        attr_reader :location
 
         def initialize(class_name:, names:, location:)
           super(location: location)
@@ -284,7 +283,6 @@ module Steep
 
       class InstanceVariableTypeError < Base
         attr_reader :name
-        attr_reader :variable
         attr_reader :var_type
         attr_reader :parent_type
 
@@ -318,7 +316,7 @@ module Steep
         private
 
         def mixin_name
-          case member
+          case mem = member
           when RBS::AST::Members::Prepend
             "prepend"
           when RBS::AST::Members::Include
@@ -329,6 +327,19 @@ module Steep
         end
       end
 
+      class InheritModuleError < Base
+        attr_reader :super_class
+
+        def initialize(super_class)
+          super(location: super_class.location)
+          @super_class = super_class
+        end
+
+        def header_line
+          "Cannot inherit from a module `#{super_class.name}`"
+        end
+      end
+
       class UnexpectedError < Base
         attr_reader :message
 
@@ -427,7 +438,7 @@ module Steep
           Diagnostic::Signature::RecursiveAlias.new(
             class_name: error.type.name,
             names: error.defs.map(&:name),
-            location: error.defs[0].original.location
+            location: error.defs[0].original&.location
           )
         when RBS::RecursiveAncestorError
           Diagnostic::Signature::RecursiveAncestor.new(
@@ -462,6 +473,8 @@ module Steep
             nonregular_type: factory.type(error.diagnostic.nonregular_type),
             location: error.location
           )
+        when RBS::InheritModuleError
+          Diagnostic::Signature::InheritModuleError.new(error.super_decl)
         else
           raise error
         end

data/lib/steep/drivers/check.rb

@@ -36,11 +36,11 @@ module Steep
         server_reader = LanguageServer::Protocol::Transport::Io::Reader.new(server_read)
         server_writer = LanguageServer::Protocol::Transport::Io::Writer.new(server_write)
 
-        typecheck_workers = Server::WorkerProcess.spawn_typecheck_workers(
+        typecheck_workers = Server::WorkerProcess.start_typecheck_workers(
           steepfile: project.steepfile_path,
           args: command_line_patterns,
           delay_shutdown: true,
-          steep_command: jobs_option.steep_command_value,
+          steep_command: jobs_option.steep_command,
           count: jobs_option.jobs_count_value
         )
 

data/lib/steep/drivers/checkfile.rb

@@ -101,11 +101,11 @@ module Steep
 
         Steep.logger.info { "Starting #{count} workers for #{files.size} files..." }
 
-        typecheck_workers = Server::WorkerProcess.spawn_typecheck_workers(
+        typecheck_workers = Server::WorkerProcess.start_typecheck_workers(
           steepfile: project.steepfile_path,
           args: [],
           delay_shutdown: true,
-          steep_command: jobs_option.steep_command_value,
+          steep_command: jobs_option.steep_command,
           count: count
         )
 

data/lib/steep/drivers/langserver.rb

@@ -35,8 +35,8 @@ module Steep
       def run
         @project = load_config()
 
-        interaction_worker = Server::WorkerProcess.spawn_worker(:interaction, name: "interaction", steepfile: project.steepfile_path, steep_command: jobs_option.steep_command_value)
-        typecheck_workers = Server::WorkerProcess.spawn_typecheck_workers(steepfile: project.steepfile_path, args: [], steep_command: jobs_option.steep_command_value, count: jobs_option.jobs_count_value)
+        interaction_worker = Server::WorkerProcess.start_worker(:interaction, name: "interaction", steepfile: project.steepfile_path, steep_command: jobs_option.steep_command)
+        typecheck_workers = Server::WorkerProcess.start_typecheck_workers(steepfile: project.steepfile_path, args: [], steep_command: jobs_option.steep_command, count: jobs_option.jobs_count_value)
 
         master = Server::Master.new(
           project: project,

data/lib/steep/drivers/stats.rb

@@ -126,11 +126,11 @@ module Steep
         server_reader = LanguageServer::Protocol::Transport::Io::Reader.new(server_read)
         server_writer = LanguageServer::Protocol::Transport::Io::Writer.new(server_write)
 
-        typecheck_workers = Server::WorkerProcess.spawn_typecheck_workers(
+        typecheck_workers = Server::WorkerProcess.start_typecheck_workers(
           steepfile: project.steepfile_path,
           delay_shutdown: true,
           args: command_line_patterns,
-          steep_command: jobs_option.steep_command_value,
+          steep_command: jobs_option.steep_command,
           count: jobs_option.jobs_count_value
         )
 

data/lib/steep/drivers/utils/jobs_option.rb

@@ -17,10 +17,6 @@ module Steep
         def jobs_count_value
           jobs_count || default_jobs_count
         end
-
-        def steep_command_value
-          steep_command || "steep"
-        end
       end
     end
   end

data/lib/steep/drivers/watch.rb

@@ -42,7 +42,7 @@ module Steep
         server_reader = LanguageServer::Protocol::Transport::Io::Reader.new(server_read)
         server_writer = LanguageServer::Protocol::Transport::Io::Writer.new(server_write)
 
-        typecheck_workers = Server::WorkerProcess.spawn_typecheck_workers(steepfile: project.steepfile_path, args: dirs.map(&:to_s), steep_command: jobs_option.steep_command_value, count: jobs_option.jobs_count_value)
+        typecheck_workers = Server::WorkerProcess.start_typecheck_workers(steepfile: project.steepfile_path, args: dirs.map(&:to_s), steep_command: jobs_option.steep_command, count: jobs_option.jobs_count_value)
 
         master = Server::Master.new(
           project: project,

data/lib/steep/drivers/worker.rb

@@ -3,7 +3,6 @@ module Steep
     class Worker
       attr_reader :stdout, :stderr, :stdin
 
-      attr_accessor :steepfile_path
       attr_accessor :worker_type
       attr_accessor :worker_name
       attr_accessor :delay_shutdown

data/lib/steep/server/lsp_formatter.rb

@@ -17,6 +17,8 @@ module Steep
         def to_s
           unless @array.empty?
             @array.join("\n\n----\n\n")
+          else
+            ""
           end
         end
 
@@ -83,7 +85,7 @@ module Steep
 #{decl.method_type}
 ```
 
-#{decl.method_def.comment.string.gsub(/\A([ \t]*\n)+/, "")}
+#{comment.string.gsub(/\A([ \t]*\n)+/, "")}
 EOM
               end
             end
@@ -108,10 +110,10 @@ EOM
           end
         when HoverProvider::Ruby::ConstantContent
           CommentBuilder.build do |builder|
-            if content.class_or_module?
+            if decl = content.class_or_module?
               builder << <<EOM
 ```rbs
-#{declaration_summary(content.decl.primary.decl)}
+#{declaration_summary(decl.primary.decl)}
 ```
 EOM
             end
@@ -141,6 +143,14 @@ EOM
               builder << comment.string
             end
           end
+        when HoverProvider::Ruby::TypeAssertionContent
+          CommentBuilder.build do |builder|
+            builder << <<-EOM
+`#{content.asserted_type.to_s}`
+
+↑ Converted from `#{content.original_type.to_s}`
+            EOM
+          end
         when HoverProvider::RBS::ClassContent
           CommentBuilder.build do |builder|
             builder << <<EOM

data/lib/steep/server/master.rb

@@ -796,7 +796,10 @@ module Steep
 
           Steep.logger.info "Sending $/typecheck/start notifications"
           typecheck_workers.each do |worker|
-            assignment = Services::PathAssignment.new(max_index: typecheck_workers.size, index: worker.index)
+            assignment = Services::PathAssignment.new(
+              max_index: typecheck_workers.size,
+              index: worker.index || raise
+            )
 
             job_queue << SendMessageJob.to_worker(
               worker,

data/lib/steep/server/worker_process.rb

@@ -18,48 +18,125 @@ module Steep
         @index = index
       end
 
-      def self.spawn_worker(type, name:, steepfile:, steep_command: "steep", options: [], delay_shutdown: false, index: nil)
+      def self.start_worker(type, name:, steepfile:, steep_command:, index: nil, delay_shutdown: false, patterns: [])
+        begin
+          unless steep_command
+            fork_worker(
+              type,
+              name: name,
+              steepfile: steepfile,
+              index: index,
+              delay_shutdown: delay_shutdown,
+              patterns: patterns
+            )
+          else
+            # Use `#spawn_worker`
+            raise NotImplementedError
+          end
+        rescue NotImplementedError
+          spawn_worker(
+            type,
+            name: name,
+            steepfile: steepfile,
+            steep_command: steep_command || "steep",
+            index: index,
+            delay_shutdown: delay_shutdown,
+            patterns: patterns
+          )
+        end
+      end
+
+      def self.fork_worker(type, name:, steepfile:, index:, delay_shutdown:, patterns:)
+        stdin_in, stdin_out = IO.pipe
+        stdout_in, stdout_out = IO.pipe
+
+        worker = Drivers::Worker.new(stdout: stdout_out, stdin: stdin_in, stderr: STDERR)
+
+        worker.steepfile = steepfile
+        worker.worker_type = type
+        worker.worker_name = name
+        worker.delay_shutdown = delay_shutdown
+        if (max, this = index)
+          worker.max_index = max
+          worker.index = this
+        end
+        worker.commandline_args = patterns
+
+        pid = fork do
+          worker.run()
+        end
+
+        pid or raise
+
+        writer = LanguageServer::Protocol::Transport::Io::Writer.new(stdin_out)
+        reader = LanguageServer::Protocol::Transport::Io::Reader.new(stdout_in)
+
+        # @type var wait_thread: Thread & _ProcessWaitThread
+        wait_thread = _ = Thread.new { Process.waitpid(pid) }
+        wait_thread.define_singleton_method(:pid) { pid }
+
+        stdin_in.close
+        stdout_out.close
+
+        new(
+          reader: reader,
+          writer: writer,
+          stderr: STDERR,
+          wait_thread: wait_thread,
+          name: name,
+          index: index&.[](1)
+        )
+      end
+
+      def self.spawn_worker(type, name:, steepfile:, steep_command:, index:, delay_shutdown:, patterns:)
         args = ["--name=#{name}", "--steepfile=#{steepfile}"]
         args << (%w(debug info warn error fatal unknown)[Steep.logger.level].yield_self {|log_level| "--log-level=#{log_level}" })
+
         if Steep.log_output.is_a?(String)
           args << "--log-output=#{Steep.log_output}"
         end
+
+        if (max, this = index)
+          args << "--max-index=#{max}"
+          args << "--index=#{this}"
+        end
+
+        if delay_shutdown
+          args << "--delay-shutdown"
+        end
+
         command = case type
                   when :interaction
-                    [steep_command, "worker", "--interaction", *args, *options]
+                    [steep_command, "worker", "--interaction", *args, *patterns]
                   when :typecheck
-                    [steep_command, "worker", "--typecheck", *args, *options]
+                    [steep_command, "worker", "--typecheck", *args, *patterns]
                   else
                     raise "Unknown type: #{type}"
                   end
 
-        if delay_shutdown
-          command << "--delay-shutdown"
-        end
-
         stdin, stdout, thread = if Gem.win_platform?
-                                  Open3.popen2(*command, new_pgroup: true)
+                                  __skip__ = Open3.popen2(*command, new_pgroup: true)
                                 else
-                                  Open3.popen2(*command, pgroup: true)
+                                  __skip__ = Open3.popen2(*command, pgroup: true)
                                 end
         stderr = nil
 
         writer = LanguageServer::Protocol::Transport::Io::Writer.new(stdin)
         reader = LanguageServer::Protocol::Transport::Io::Reader.new(stdout)
 
-        new(reader: reader, writer: writer, stderr: stderr, wait_thread: thread, name: name, index: index)
+        new(reader: reader, writer: writer, stderr: stderr, wait_thread: thread, name: name, index: index&.[](1))
       end
 
-      def self.spawn_typecheck_workers(steepfile:, args:, steep_command: "steep", count: [Etc.nprocessors - 1, 1].max, delay_shutdown: false)
+      def self.start_typecheck_workers(steepfile:, args:, steep_command:, count: [Etc.nprocessors - 1, 1].max, delay_shutdown: false)
         count.times.map do |i|
-          spawn_worker(
+          start_worker(
             :typecheck,
             name: "typecheck@#{i}",
             steepfile: steepfile,
             steep_command: steep_command,
-            options: ["--max-index=#{count}", "--index=#{i}", *args],
+            index: [count, i],
+            patterns: args,
             delay_shutdown: delay_shutdown,
-            index: i
           )
         end
       end

data/lib/steep/services/completion_provider.rb

@@ -88,7 +88,8 @@ module Steep
         end
 
         Steep.measure "typechecking" do
-          @typing = TypeCheckService.type_check(source: source, subtyping: subtyping)
+          resolver = RBS::Resolver::ConstantResolver.new(builder: subtyping.factory.definition_builder)
+          @typing = TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver)
         end
       end
 

data/lib/steep/services/goto_service.rb

@@ -211,8 +211,9 @@ module Steep
         subtyping = signature_service.current_subtyping or return
         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),
+          Services::TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver),
           signature_service
         ]
       rescue

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

@@ -2,9 +2,9 @@ module Steep
   module Services
     module HoverProvider
       class RBS
-        TypeAliasContent = Struct.new(:location, :decl, keyword_init: true)
-        ClassContent = Struct.new(:location, :decl, keyword_init: true)
-        InterfaceContent = Struct.new(:location, :decl, keyword_init: true)
+        TypeAliasContent = _ = Struct.new(:location, :decl, keyword_init: true)
+        ClassContent = _ = Struct.new(:location, :decl, keyword_init: true)
+        InterfaceContent = _ = Struct.new(:location, :decl, keyword_init: true)
 
         attr_reader :service
 
@@ -33,14 +33,14 @@ module Steep
             alias_decl = service.latest_env.alias_decls[head.name]&.decl or raise
 
             TypeAliasContent.new(
-              location: head.location,
+              location: head.location || raise,
               decl: alias_decl
             )
           when ::RBS::Types::ClassInstance, ::RBS::Types::ClassSingleton
             if loc_key == :name
               env = service.latest_env
-              class_decl = env.class_decls[head.name]&.decls[0]&.decl or raise
-              location = head.location[:name]
+              class_decl = env.class_decls[head.name]&.decls&.[](0)&.decl or raise
+              location = head.location&.[](:name) or raise
               ClassContent.new(
                 location: location,
                 decl: class_decl
@@ -49,7 +49,7 @@ module Steep
           when ::RBS::Types::Interface
             env = service.latest_env
             interface_decl = env.interface_decls[head.name]&.decl or raise
-            location = head.location[:name]
+            location = head.location&.[](:name) or raise
 
             InterfaceContent.new(
               location: location,

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

@@ -4,6 +4,7 @@ module Steep
       class Ruby
         TypeContent = _ = Struct.new(:node, :type, :location, keyword_init: true)
         VariableContent = _ = Struct.new(:node, :name, :type, :location, keyword_init: true)
+        TypeAssertionContent = _ = Struct.new(:node, :original_type, :asserted_type, :location, keyword_init: true)
         MethodCallContent = _ = Struct.new(:node, :method_call, :location, keyword_init: true)
         DefinitionContent = _ = Struct.new(:node, :method_name, :method_type, :definition, :location, keyword_init: true)
         ConstantContent = _ = Struct.new(:location, :full_name, :type, :decl, keyword_init: true) do
@@ -33,11 +34,15 @@ module Steep
           end
 
           def constant?
-            decl.is_a?(::RBS::Environment::SingleEntry)
+            if decl.is_a?(::RBS::Environment::SingleEntry)
+              decl
+            end
           end
 
           def class_or_module?
-            decl.is_a?(::RBS::Environment::MultiEntry)
+            if decl.is_a?(::RBS::Environment::MultiEntry)
+              decl
+            end
           end
         end
 
@@ -72,14 +77,16 @@ module Steep
           subtyping = service.signature_services[target.name].current_subtyping or return
           source = Source.parse(content, path: path, factory: subtyping.factory)
           source = source.without_unrelated_defs(line: line, column: column)
-          Services::TypeCheckService.type_check(source: source, subtyping: subtyping)
+          resolver = ::RBS::Resolver::ConstantResolver.new(builder: subtyping.factory.definition_builder)
+          Services::TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver)
         rescue
           nil
         end
 
         def method_name_from_method(context, builder:)
-          defined_in = context.method.defined_in
-          method_name = context.name
+          context.method or raise
+          defined_in = context.method.defined_in or raise
+          method_name = context.name or raise
 
           case
           when defined_in.class?
@@ -171,6 +178,15 @@ module Steep
                   decl: decl
                 )
               end
+            when :assertion
+              original_node, _ = node.children
+
+              original_type = typing.type_of(node: original_node)
+              asserted_type = typing.type_of(node: node)
+
+              if original_type != asserted_type
+                return TypeAssertionContent.new(node: node, original_type: original_type, asserted_type: asserted_type, location: node.location.expression)
+              end
             end
 
             TypeContent.new(

data/lib/steep/services/signature_service.rb

@@ -19,6 +19,10 @@ module Steep
             builder.env(last_builder.env)
           end
         end
+
+        def constant_resolver
+          @constant_resolver ||= RBS::Resolver::ConstantResolver.new(builder: last_builder)
+        end
       end
 
       class AncestorErrorStatus
@@ -37,6 +41,10 @@ module Steep
             builder.env(last_builder.env)
           end
         end
+
+        def constant_resolver
+          @constant_resolver ||= RBS::Resolver::ConstantResolver.new(builder: last_builder)
+        end
       end
 
       class LoadedStatus
@@ -61,6 +69,10 @@ module Steep
             builder.env(self.builder.env)
           end
         end
+
+        def constant_resolver
+          @constant_resolver ||= RBS::Resolver::ConstantResolver.new(builder: builder)
+        end
       end
 
       FileStatus = _ = Struct.new(:path, :content, :decls, keyword_init: true)
@@ -125,6 +137,10 @@ module Steep
         status.rbs_index
       end
 
+      def latest_constant_resolver
+        status.constant_resolver
+      end
+
       def current_subtyping
         if status.is_a?(LoadedStatus)
           status.subtyping
@@ -174,7 +190,7 @@ module Steep
                                file.decls
                              else
                                # factory is not used here because the error is a syntax error.
-                               Diagnostic::Signature.from_rbs_error(file.decls, factory: nil)
+                               Diagnostic::Signature.from_rbs_error(file.decls, factory: _ = nil)
                              end
                 diagnostics << diagnostic
               end
@@ -214,6 +230,7 @@ module Steep
 
       def update_env(updated_files, paths:)
         Steep.logger.tagged "#update_env" do
+          # @type var errors: Array[RBS::BaseError]
           errors = []
           new_decls = Set[].compare_by_identity
 
@@ -230,7 +247,9 @@ module Steep
             updated_files.each_value do |content|
               case decls = content.decls
               when RBS::BaseError
-                errors << content.decls
+                errors << decls
+              when Diagnostic::Signature::UnexpectedError
+                return [decls]
               else
                 begin
                   decls.each do |decl|
@@ -255,7 +274,7 @@ module Steep
           unless errors.empty?
             return errors.map {|error|
               # Factory will not be used because of the possible error types.
-              Diagnostic::Signature.from_rbs_error(error, factory: nil)
+              Diagnostic::Signature.from_rbs_error(error, factory: _ = nil)
             }
           end
 
@@ -277,7 +296,7 @@ module Steep
 
           unless errors.empty?
             # Builder won't be used.
-            factory = AST::Types::Factory.new(builder: nil)
+            factory = AST::Types::Factory.new(builder: _ = nil)
             return errors.map {|error| Diagnostic::Signature.from_rbs_error(error, factory: factory) }
           end
 

data/lib/steep/services/type_check_service.rb

@@ -280,7 +280,7 @@ module Steep
 
             if subtyping
               text = source_files[path].content
-              file = type_check_file(target: target, subtyping: subtyping, path: path, text: text)
+              file = type_check_file(target: target, subtyping: subtyping, path: path, text: text) { signature_service.latest_constant_resolver }
               yield [file.path, file.diagnostics]
               source_files[path] = file
             end
@@ -326,7 +326,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)
+          typing = TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: yield)
           SourceFile.with_typing(path: path, content: text, node: source.node, typing: typing)
         end
       rescue AnnotationParser::SyntaxError => exn
@@ -342,7 +342,7 @@ module Steep
         SourceFile.no_data(path: path, content: text)
       end
 
-      def self.type_check(source:, subtyping:)
+      def self.type_check(source:, subtyping:, constant_resolver:)
         annotations = source.annotations(block: source.node, factory: subtyping.factory, context: nil)
 
         definition = subtyping.factory.definition_builder.build_instance(AST::Builtin::Object.module_name)
@@ -350,7 +350,7 @@ module Steep
         const_env = TypeInference::ConstantEnv.new(
           factory: subtyping.factory,
           context: nil,
-          resolver: RBS::Resolver::ConstantResolver.new(builder: subtyping.factory.definition_builder)
+          resolver: constant_resolver
         )
         type_env = TypeInference::TypeEnv.new(const_env)
         type_env = TypeInference::TypeEnvBuilder.new(