steep 1.2.0 → 1.3.0.pre.1

data/lib/steep/diagnostic/ruby.rb

@@ -773,6 +773,65 @@ module Steep
         end
       end
 
+      class FalseAssertion < Base
+        attr_reader :node, :assertion_type, :node_type
+
+        def initialize(node:, assertion_type:, node_type:)
+          super(node: node)
+          @assertion_type = assertion_type
+          @node_type = node_type
+        end
+
+        def header_line
+          "Assertion cannot hold: no relationship between infered type (`#{node_type.to_s}`) and asserted type (`#{assertion_type.to_s}`)"
+        end
+      end
+
+      class UnexpectedTypeArgument < Base
+        attr_reader :type_arg, :method_type
+
+        def initialize(type_arg:, method_type:)
+          super(node: nil, location: type_arg.location)
+          @type_arg = type_arg
+          @method_type = method_type
+        end
+
+        def header_line
+          "Unexpected type arg is given to method type `#{method_type.to_s}`"
+        end
+      end
+
+      class InsufficientTypeArgument < Base
+        attr_reader :type_args, :method_type
+
+        def initialize(node:, type_args:, method_type:)
+          super(node: node)
+          @type_args = type_args
+          @method_type = method_type
+        end
+
+        def header_line
+          "Requires #{method_type.type_params.size} types, but #{type_args.size} given: `#{method_type.to_s}`"
+        end
+      end
+
+      class TypeArgumentMismatchError < Base
+        attr_reader :type_argument, :type_parameter, :result
+
+        def initialize(type_arg:, type_param:, result:)
+          super(node: nil, location: type_arg.location)
+          @type_argument = type_arg
+          @type_parameter = type_param
+          @result = result
+        end
+
+        include ResultPrinter
+
+        def header_line
+          "Cannot pass a type `#{type_argument}` as a type parameter `#{type_parameter.to_s}`"
+        end
+      end
+
       ALL = ObjectSpace.each_object(Class).with_object([]) do |klass, array|
         if klass < Base
           array << klass
@@ -781,24 +840,29 @@ module Steep
 
       def self.all_error
         @all_error ||= ALL.each.with_object({}) do |klass, hash|
+          # @type var hash: Hash[singleton(Base), LSPFormatter::severity]
           hash[klass] = LSPFormatter::ERROR
         end.freeze
       end
 
       def self.default
-        @default ||= all_error.merge(
+        @default ||= _ = all_error.merge(
           {
             ImplicitBreakValueMismatch => :warning,
             FallbackAny => :information,
             ElseOnExhaustiveCase => :warning,
             UnknownConstant => :warning,
-            MethodDefinitionMissing => :information
+            MethodDefinitionMissing => :information,
+            FalseAssertion => :information,
+            UnexpectedTypeArgument => :information,
+            InsufficientTypeArgument => :information,
+            UnexpectedTypeArgument => :information
           }
         ).freeze
       end
 
       def self.strict
-        @strict ||= all_error.merge(
+        @strict ||= _ = all_error.merge(
           {
             NoMethod => nil,
             ImplicitBreakValueMismatch => nil,
@@ -811,7 +875,7 @@ module Steep
       end
 
       def self.lenient
-        @lenient ||= all_error.merge(
+        @lenient ||= _ = all_error.merge(
           {
             NoMethod => nil,
             ImplicitBreakValueMismatch => nil,
@@ -819,7 +883,8 @@ module Steep
             ElseOnExhaustiveCase => nil,
             UnknownConstant => nil,
             MethodDefinitionMissing => nil,
-            UnexpectedJump => nil
+            UnexpectedJump => nil,
+            FalseAssertion => :hint
           }
         ).freeze
       end

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,7 +36,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(
+        typecheck_workers = Server::WorkerProcess.start_typecheck_workers(
           steepfile: project.steepfile_path,
           args: command_line_patterns,
           delay_shutdown: true,

data/lib/steep/drivers/checkfile.rb

@@ -101,7 +101,7 @@ 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,

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_value)
+        typecheck_workers = Server::WorkerProcess.start_typecheck_workers(steepfile: project.steepfile_path, args: [], steep_command: jobs_option.steep_command_value, count: jobs_option.jobs_count_value)
 
         master = Server::Master.new(
           project: project,

data/lib/steep/drivers/stats.rb

@@ -126,7 +126,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(
+        typecheck_workers = Server::WorkerProcess.start_typecheck_workers(
           steepfile: project.steepfile_path,
           delay_shutdown: true,
           args: command_line_patterns,

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_value, 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,120 @@ 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: "steep", index: nil, delay_shutdown: false, patterns: [])
+        begin
+          fork_worker(
+            type,
+            name: name,
+            steepfile: steepfile,
+            index: index,
+            delay_shutdown: delay_shutdown,
+            patterns: patterns
+          )
+        rescue NotImplementedError
+          spawn_worker(
+            type,
+            name: name,
+            steepfile: steepfile,
+            steep_command: steep_command,
+            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: "steep", 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/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
 
@@ -78,8 +83,9 @@ module Steep
         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 +177,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

@@ -174,7 +174,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 +214,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 +231,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 +258,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 +280,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