steep 0.40.0 → 0.44.0

data/lib/steep/diagnostic/ruby.rb

@@ -220,10 +220,6 @@ module Steep
         def header_line
           "The method cannot be called with a block"
         end
-
-        def to_s
-          format_message "method_type=#{method_type}"
-        end
       end
 
       class RequiredBlockMissing < Base
@@ -395,8 +391,8 @@ module Steep
           @method = method
         end
 
-        def to_s
-          format_message "method=#{method}"
+        def header_line
+          "No superclass method `#{method}` defined"
         end
       end
 
@@ -613,9 +609,18 @@ module Steep
         def header_line
           "UnexpectedError: #{error.message}"
         end
+      end
 
-        def detail_lines
-          error.backtrace.join("\n")
+      class SyntaxError < Base
+        attr_reader :message
+
+        def initialize(message: ,location:)
+          super(node: nil, location: location)
+          @message = message
+        end
+
+        def header_line
+          "SyntaxError: #{message}"
         end
       end
     end

data/lib/steep/diagnostic/signature.rb

@@ -21,7 +21,7 @@ module Steep
         end
 
         def diagnostic_code
-          "Ruby::#{error_name}"
+          "RBS::#{error_name}"
         end
 
         def path
@@ -37,8 +37,26 @@ module Steep
           @exception = exception
         end
 
+        def self.parser_syntax_error_message(exception)
+          value = if exception.error_value.is_a?(RBS::Parser::LocatedValue)
+                    exception.error_value.value
+                  else
+                    exception.error_value
+                  end
+          string = value.to_s
+          unless string.empty?
+            string = " (#{string})"
+          end
+
+          "Syntax error caused by token `#{exception.token_str}`#{string}"
+        end
+
         def header_line
-          "Syntax error: #{exception.message}"
+          if exception.is_a?(RBS::Parser::SyntaxError)
+            SyntaxError.parser_syntax_error_message(exception)
+          else
+            exception.message
+          end
         end
       end
 
@@ -219,6 +237,138 @@ module Steep
           "The variance of type parameter `#{param.name}` is #{param.variance}, but used in incompatible position here"
         end
       end
+
+      class ModuleSelfTypeError < Base
+        attr_reader :name
+        attr_reader :ancestor
+        attr_reader :relation
+
+        def initialize(name:, ancestor:, relation:, location:)
+          super(location: location)
+
+          @name = name
+          @ancestor = ancestor
+          @relation = relation
+        end
+
+        def header_line
+          "Module self type constraint in type `#{name}` doesn't satisfy: `#{relation}`"
+        end
+      end
+
+      class InstanceVariableTypeError < Base
+        attr_reader :name
+        attr_reader :variable
+        attr_reader :var_type
+        attr_reader :parent_type
+
+        def initialize(name:, location:, var_type:, parent_type:)
+          super(location: location)
+
+          @name = name
+          @var_type = var_type
+          @parent_type = parent_type
+        end
+
+        def header_line
+          "Instance variable cannot have different type with parents: #{var_type} <=> #{parent_type}"
+        end
+      end
+
+      class UnexpectedError < Base
+        attr_reader :message
+
+        def initialize(message:, location:)
+          @message = message
+          @location = location
+        end
+
+        def header_line
+          "Unexpected error: #{message}"
+        end
+      end
+
+      def self.from_rbs_error(error, factory:)
+        case error
+        when RBS::Parser::SemanticsError, RBS::Parser::LexerError
+          Diagnostic::Signature::SyntaxError.new(error, location: error.location)
+        when RBS::Parser::SyntaxError
+          Diagnostic::Signature::SyntaxError.new(error, location: error.error_value.location)
+        when RBS::DuplicatedDeclarationError
+          Diagnostic::Signature::DuplicatedDeclaration.new(
+            type_name: error.name,
+            location: error.decls[0].location
+          )
+        when RBS::GenericParameterMismatchError
+          Diagnostic::Signature::GenericParameterMismatch.new(
+            name: error.name,
+            location: error.decl.location
+          )
+        when RBS::InvalidTypeApplicationError
+          Diagnostic::Signature::InvalidTypeApplication.new(
+            name: error.type_name,
+            args: error.args.map {|ty| factory.type(ty) },
+            params: error.params,
+            location: error.location
+          )
+        when RBS::NoTypeFoundError,
+          RBS::NoSuperclassFoundError,
+          RBS::NoMixinFoundError,
+          RBS::NoSelfTypeFoundError
+          Diagnostic::Signature::UnknownTypeName.new(
+            name: error.type_name,
+            location: error.location
+          )
+        when RBS::InvalidOverloadMethodError
+          Diagnostic::Signature::InvalidMethodOverload.new(
+            class_name: error.type_name,
+            method_name: error.method_name,
+            location: error.members[0].location
+          )
+        when RBS::DuplicatedMethodDefinitionError
+          Diagnostic::Signature::DuplicatedMethodDefinition.new(
+            class_name: error.type_name,
+            method_name: error.method_name,
+            location: error.location
+          )
+        when RBS::DuplicatedInterfaceMethodDefinitionError
+          Diagnostic::Signature::DuplicatedMethodDefinition.new(
+            class_name: error.type_name,
+            method_name: error.method_name,
+            location: error.member.location
+          )
+        when RBS::UnknownMethodAliasError
+          Diagnostic::Signature::UnknownMethodAlias.new(
+            class_name: error.type_name,
+            method_name: error.original_name,
+            location: error.location
+          )
+        when RBS::RecursiveAliasDefinitionError
+          Diagnostic::Signature::RecursiveAlias.new(
+            class_name: error.type.name,
+            names: error.defs.map(&:name),
+            location: error.defs[0].original.location
+          )
+        when RBS::RecursiveAncestorError
+          Diagnostic::Signature::RecursiveAncestor.new(
+            ancestors: error.ancestors,
+            location: error.location
+          )
+        when RBS::SuperclassMismatchError
+          Diagnostic::Signature::SuperclassMismatch.new(
+            name: error.name,
+            location: error.entry.primary.decl.location
+          )
+        when RBS::InvalidVarianceAnnotationError
+          Diagnostic::Signature::InvalidVarianceAnnotation.new(
+            name: error.type_name,
+            param: error.param,
+            location: error.location
+          )
+        else
+          raise error
+        end
+      end
     end
   end
 end

data/lib/steep/drivers/annotations.rb

@@ -4,7 +4,6 @@ module Steep
       attr_reader :command_line_patterns
       attr_reader :stdout
       attr_reader :stderr
-      attr_reader :labeling
 
       include Utils::DriverHelper
 
@@ -13,56 +12,39 @@ module Steep
         @stderr = stderr
 
         @command_line_patterns = []
-        @labeling = ASTUtils::Labeling.new
       end
 
       def run
         project = load_config()
 
-        loader = Project::FileLoader.new(project: project)
-        loader.load_sources(command_line_patterns)
-        loader.load_signatures()
+        loader = Services::FileLoader.new(base_dir: project.base_dir)
 
         project.targets.each do |target|
           Steep.logger.tagged "target=#{target.name}" do
-            target.load_signatures(validate: false) do |_, subtyping, _|
-              case (status = target.status)
-              when nil     # status set on error cases
-                target.source_files.each_value do |file|
-                  file.parse(subtyping.factory) do |source|
-                    source.each_annotation.sort_by {|node, _| [node.loc.expression.begin_pos, node.loc.expression.end_pos] }.each do |node, annotations|
-                      loc = node.loc
-                      stdout.puts "#{file.path}:#{loc.line}:#{loc.column}:#{node.type}:\t#{node.loc.expression.source.lines.first}"
-                      annotations.each do |annotation|
-                        stdout.puts "  #{annotation.location.source}"
-                      end
-                    end
-                  end
-                end
-              when Project::Target::SignatureErrorStatus
-                formatter = Diagnostic::LSPFormatter.new
-                diagnostics = status.errors.group_by {|e| e.location.buffer }.transform_values do |errors|
-                  errors.map {|error| formatter.format(error) }
-                end
+            service = Services::SignatureService.load_from(target.new_env_loader(project: project))
+
+            sigs = loader.load_changes(target.signature_pattern, changes: {})
+            service.update(sigs)
+
+            factory = AST::Types::Factory.new(builder: service.latest_builder)
+
+            srcs = loader.load_changes(target.source_pattern, command_line_patterns, changes: {})
+            srcs.each do |path, changes|
+              text = changes.inject("") {|text, change| change.apply_to(text) }
+              source = Source.parse(text, path: path, factory: factory)
 
-                diagnostics.each do |buffer, ds|
-                  printer = DiagnosticPrinter.new(stdout: stdout, buffer: buffer)
-                  ds.each do |d|
-                    printer.print(d)
-                    stdout.puts
-                  end
+              source.each_annotation.sort_by {|node, _| [node.loc.expression.begin_pos, node.loc.expression.end_pos] }.each do |node, annotations|
+                loc = node.loc
+                stdout.puts "#{path}:#{loc.line}:#{loc.column}:#{node.type}:\t#{node.loc.expression.source.lines.first}"
+                annotations.each do |annotation|
+                  stdout.puts "  #{annotation.location.source}"
                 end
               end
             end
           end
         end
 
-        project.targets.each do |target|
-          Steep.logger.tagged "target=#{target.name}" do
-          end
-        end
-
-        project.targets.all? {|target| !target.status } ? 0 : 1
+        0
       end
     end
   end

data/lib/steep/drivers/check.rb

@@ -6,8 +6,11 @@ module Steep
       attr_reader :stdout
       attr_reader :stderr
       attr_reader :command_line_patterns
+      attr_accessor :with_expectations_path
+      attr_accessor :save_expectations_path
 
       include Utils::DriverHelper
+      include Utils::JobsCount
 
       def initialize(stdout:, stderr:)
         @stdout = stdout
@@ -18,10 +21,6 @@ module Steep
       def run
         project = load_config()
 
-        loader = Project::FileLoader.new(project: project)
-        loader.load_sources(command_line_patterns)
-        loader.load_signatures()
-
         stdout.puts Rainbow("# Type checking files:").bold
         stdout.puts
 
@@ -34,30 +33,38 @@ module Steep
         server_reader = LanguageServer::Protocol::Transport::Io::Reader.new(server_read)
         server_writer = LanguageServer::Protocol::Transport::Io::Writer.new(server_write)
 
-        interaction_worker = Server::WorkerProcess.spawn_worker(:interaction, name: "interaction", steepfile: project.steepfile_path, delay_shutdown: true)
-        signature_worker = Server::WorkerProcess.spawn_worker(:signature, name: "signature", steepfile: project.steepfile_path, delay_shutdown: true)
-        code_workers = Server::WorkerProcess.spawn_code_workers(steepfile: project.steepfile_path, delay_shutdown: true)
+        typecheck_workers = Server::WorkerProcess.spawn_typecheck_workers(
+          steepfile: project.steepfile_path,
+          args: command_line_patterns,
+          delay_shutdown: true,
+          count: jobs_count
+        )
 
         master = Server::Master.new(
           project: project,
           reader: server_reader,
           writer: server_writer,
-          interaction_worker: interaction_worker,
-          signature_worker: signature_worker,
-          code_workers: code_workers
+          interaction_worker: nil,
+          typecheck_workers: typecheck_workers
         )
+        master.typecheck_automatically = false
+        master.commandline_args.push(*command_line_patterns)
 
         main_thread = Thread.start do
           master.start()
         end
         main_thread.abort_on_exception = true
 
-        client_writer.write({ method: :initialize, id: 0 })
+        Steep.logger.info { "Initializing server" }
+        initialize_id = request_id()
+        client_writer.write({ method: :initialize, id: initialize_id, params: {} })
+        wait_for_response_id(reader: client_reader, id: initialize_id)
 
-        shutdown_id = -1
-        client_writer.write({ method: :shutdown, id: shutdown_id })
+        request_guid = SecureRandom.uuid
+        Steep.logger.info { "Starting type checking: #{request_guid}" }
+        client_writer.write({ method: "$/typecheck", params: { guid: request_guid } })
 
-        responses = []
+        diagnostic_notifications = []
         error_messages = []
         client_reader.read do |response|
           case
@@ -68,7 +75,7 @@ module Steep
             else
               stdout.print "F"
             end
-            responses << response[:params]
+            diagnostic_notifications << response[:params]
             stdout.flush
           when response[:method] == "window/showMessage"
             # Assuming ERROR message means unrecoverable error.
@@ -76,43 +83,145 @@ module Steep
             if message[:type] == LSP::Constant::MessageType::ERROR
               error_messages << message[:message]
             end
-          when response[:id] == shutdown_id
-            break
+          when response[:method] == "$/progress"
+            if response[:params][:token] == request_guid
+              if response[:params][:value][:kind] == "end"
+                break
+              end
+            end
           end
         end
 
-        client_writer.write({ method: :exit })
-        client_writer.io.close()
+        Steep.logger.info { "Shutting down..." }
 
+        shutdown_exit(reader: client_reader, writer: client_writer)
         main_thread.join()
 
         stdout.puts
         stdout.puts
 
-        case
-        when responses.all? {|res| res[:diagnostics].empty? } && error_messages.empty?
+        if error_messages.empty?
+          loader = Services::FileLoader.new(base_dir: project.base_dir)
+          all_files = project.targets.each.with_object(Set[]) do |target, set|
+            set.merge(loader.load_changes(target.source_pattern, command_line_patterns, changes: {}).each_key)
+            set.merge(loader.load_changes(target.signature_pattern, changes: {}).each_key)
+          end.to_a
+
+          case
+          when with_expectations_path
+            print_expectations(project: project,
+                               all_files: all_files,
+                               expectations_path: with_expectations_path,
+                               notifications: diagnostic_notifications)
+          when save_expectations_path
+            save_expectations(project: project,
+                              all_files: all_files,
+                              expectations_path: save_expectations_path,
+                              notifications: diagnostic_notifications)
+          else
+            print_result(project: project, notifications: diagnostic_notifications)
+          end
+        else
+          stdout.puts Rainbow("Unexpected error reported. 🚨").red.bold
+          1
+        end
+      end
+
+      def print_expectations(project:, all_files:, expectations_path:, notifications:)
+        expectations = Expectations.load(path: expectations_path, content: expectations_path.read)
+
+        expected_count = 0
+        unexpected_count = 0
+        missing_count = 0
+
+        ns = notifications.each.with_object({}) do |notification, hash|
+          path = project.relative_path(Pathname(URI.parse(notification[:uri]).path))
+          hash[path] = notification[:diagnostics]
+        end
+
+        all_files.sort.each do |path|
+          test = expectations.test(path: path, diagnostics: ns[path] || [])
+
+          buffer = RBS::Buffer.new(name: path, content: path.read)
+          printer = DiagnosticPrinter.new(buffer: buffer, stdout: stdout)
+
+          test.each_diagnostics.each do |type, diag|
+            case type
+            when :expected
+              expected_count += 1
+            when :unexpected
+              unexpected_count += 1
+              printer.print(diag, prefix: Rainbow("+ ").green)
+            when :missing
+              missing_count += 1
+              printer.print(diag, prefix: Rainbow("- ").red, source: false)
+            end
+          end
+        end
+
+        if unexpected_count > 0 || missing_count > 0
+          stdout.puts
+
+          stdout.puts Rainbow("Expectations unsatisfied:").bold.red
+          stdout.puts "  #{expected_count} expected #{"diagnostic".pluralize(expected_count)}"
+          stdout.puts Rainbow("  + #{unexpected_count} unexpected #{"diagnostic".pluralize(unexpected_count)}").green
+          stdout.puts Rainbow("  - #{missing_count} missing #{"diagnostic".pluralize(missing_count)}").red
+          1
+        else
+          stdout.puts Rainbow("Expectations satisfied:").bold.green
+          stdout.puts "  #{expected_count} expected #{"diagnostic".pluralize(expected_count)}"
+          0
+        end
+      end
+
+      def save_expectations(project:, all_files:, expectations_path:, notifications:)
+        expectations = if expectations_path.file?
+                         Expectations.load(path: expectations_path, content: expectations_path.read)
+                       else
+                         Expectations.empty()
+                       end
+
+        ns = notifications.each.with_object({}) do |notification, hash|
+          path = project.relative_path(Pathname(URI.parse(notification[:uri]).path))
+          hash[path] = notification[:diagnostics]
+        end
+
+        all_files.sort.each do |path|
+          ds = ns[path] || []
+
+          if ds.empty?
+            expectations.diagnostics.delete(path)
+          else
+            expectations.diagnostics[path] = ds
+          end
+        end
+
+        expectations_path.write(expectations.to_yaml)
+        stdout.puts Rainbow("Saved expectations in #{expectations_path}...").bold
+        0
+      end
+
+      def print_result(project:, notifications:)
+        if notifications.all? {|notification| notification[:diagnostics].empty? }
           emoji = %w(🫖 🫖 🫖 🫖 🫖 🫖 🫖 🫖 🍵 🧋 🧉).sample
           stdout.puts Rainbow("No type error detected. #{emoji}").green.bold
           0
-        when !error_messages.empty?
-          stdout.puts Rainbow("Unexpected error reported. 🚨").red.bold
-          1
         else
-          errors = responses.reject {|res| res[:diagnostics].empty? }
-          total = errors.sum {|res| res[:diagnostics].size }
-          stdout.puts Rainbow("Detected #{total} problems from #{errors.size} files").red.bold
-          stdout.puts
+          errors = notifications.reject {|notification| notification[:diagnostics].empty? }
+          total = errors.sum {|notification| notification[:diagnostics].size }
 
-          errors.each do |resp|
-            path = project.relative_path(Pathname(URI.parse(resp[:uri]).path))
+          errors.each do |notification|
+            path = project.relative_path(Pathname(URI.parse(notification[:uri]).path))
             buffer = RBS::Buffer.new(name: path, content: path.read)
             printer = DiagnosticPrinter.new(buffer: buffer, stdout: stdout)
 
-            resp[:diagnostics].each do |diag|
+            notification[:diagnostics].each do |diag|
               printer.print(diag)
               stdout.puts
             end
           end
+
+          stdout.puts Rainbow("Detected #{total} #{"problem".pluralize(total)} from #{errors.size} #{"file".pluralize(errors.size)}").red.bold
           1
         end
       end