steep 0.37.0 → 0.42.0

data/lib/steep/diagnostic/signature.rb

@@ -0,0 +1,357 @@
+module Steep
+  module Diagnostic
+    module Signature
+      class Base
+        include Helper
+
+        attr_reader :location
+
+        def initialize(location:)
+          @location = location
+        end
+
+        def header_line
+          StringIO.new.tap do |io|
+            puts io
+          end.string
+        end
+
+        def detail_lines
+          nil
+        end
+
+        def diagnostic_code
+          "RBS::#{error_name}"
+        end
+
+        def path
+          location.buffer.name
+        end
+      end
+
+      class SyntaxError < Base
+        attr_reader :exception
+
+        def initialize(exception, location:)
+          super(location: location)
+          @exception = exception
+        end
+
+        def header_line
+          if exception.is_a?(RBS::Parser::SyntaxError)
+            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}"
+          else
+            exception.message
+          end
+        end
+      end
+
+      class DuplicatedDeclaration < Base
+        attr_reader :type_name
+
+        def initialize(type_name:, location:)
+          super(location: location)
+          @type_name = type_name
+        end
+
+        def header_line
+          "Declaration of `#{type_name}` is duplicated"
+        end
+      end
+
+      class UnknownTypeName < Base
+        attr_reader :name
+
+        def initialize(name:, location:)
+          super(location: location)
+          @name = name
+        end
+
+        def header_line
+          "Cannot find type `#{name}`"
+        end
+      end
+
+      class InvalidTypeApplication < Base
+        attr_reader :name
+        attr_reader :args
+        attr_reader :params
+
+        def initialize(name:, args:, params:, location:)
+          super(location: location)
+          @name = name
+          @args = args
+          @params = params
+        end
+
+        def header_line
+          case
+          when params.empty?
+            "Type `#{name}` is not generic but used as a generic type with #{args.size} arguments"
+          when args.empty?
+            "Type `#{name}` is generic but used as a non generic type"
+          else
+            "Type `#{name}` expects #{params.size} arguments, but #{args.size} arguments are given"
+          end
+        end
+      end
+
+      class InvalidMethodOverload < Base
+        attr_reader :class_name
+        attr_reader :method_name
+
+        def initialize(class_name:, method_name:, location:)
+          super(location: location)
+          @class_name = class_name
+          @method_name = method_name
+        end
+
+        def header_line
+          "Cannot find a non-overloading definition of `#{method_name}` in `#{class_name}`"
+        end
+      end
+
+      class UnknownMethodAlias < Base
+        attr_reader :class_name
+        attr_reader :method_name
+
+        def initialize(class_name:, method_name:, location:)
+          super(location: location)
+          @class_name = class_name
+          @method_name = method_name
+        end
+
+        def header_line
+          "Cannot find the original method `#{method_name}` in `#{class_name}`"
+        end
+      end
+
+      class DuplicatedMethodDefinition < Base
+        attr_reader :class_name
+        attr_reader :method_name
+
+        def initialize(class_name:, method_name:, location:)
+          super(location: location)
+          @class_name = class_name
+          @method_name = method_name
+        end
+
+        def header_line
+          "Non-overloading method definition of `#{method_name}` in `#{class_name}` cannot be duplicated"
+        end
+      end
+
+      class RecursiveAlias < Base
+        attr_reader :class_name
+        attr_reader :names
+        attr_reader :location
+
+        def initialize(class_name:, names:, location:)
+          super(location: location)
+          @class_name = class_name
+          @names = names
+        end
+
+        def header_line
+          "Circular method alias is detected in `#{class_name}`: #{names.join(" -> ")}"
+        end
+      end
+
+      class RecursiveAncestor < Base
+        attr_reader :ancestors
+
+        def initialize(ancestors:, location:)
+          super(location: location)
+          @ancestors = ancestors
+        end
+
+        def header_line
+          names = ancestors.map do |ancestor|
+            case ancestor
+            when RBS::Definition::Ancestor::Singleton
+              "singleton(#{ancestor.name})"
+            when RBS::Definition::Ancestor::Instance
+              if ancestor.args.empty?
+                ancestor.name.to_s
+              else
+                "#{ancestor.name}[#{ancestor.args.join(", ")}]"
+              end
+            end
+          end
+
+          "Circular inheritance/mix-in is detected: #{names.join(" <: ")}"
+        end
+      end
+
+      class SuperclassMismatch < Base
+        attr_reader :name
+
+        def initialize(name:, location:)
+          super(location: location)
+          @name = name
+        end
+
+        def header_line
+          "Different superclasses are specified for `#{name}`"
+        end
+      end
+
+      class GenericParameterMismatch < Base
+        attr_reader :name
+
+        def initialize(name:, location:)
+          super(location: location)
+          @name = name
+        end
+
+        def header_line
+          "Different generic parameters are specified across definitions of `#{name}`"
+        end
+      end
+
+      class InvalidVarianceAnnotation < Base
+        attr_reader :name
+        attr_reader :param
+
+        def initialize(name:, param:, location:)
+          super(location: location)
+          @name = name
+          @param = param
+        end
+
+        def header_line
+          "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
+
+      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

@@ -19,43 +19,34 @@ module Steep
       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
+            service = Services::SignatureService.load_from(target.new_env_loader)
+
+            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)
+
+              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
-              when Project::Target::SignatureSyntaxErrorStatus
-                printer = SignatureErrorPrinter.new(stdout: stdout, stderr: stderr)
-                printer.print_syntax_errors(status.errors)
-              when Project::Target::SignatureValidationErrorStatus
-                printer = SignatureErrorPrinter.new(stdout: stdout, stderr: stderr)
-                printer.print_semantic_errors(status.errors)
               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

@@ -1,96 +1,218 @@
 module Steep
   module Drivers
     class Check
+      LSP = LanguageServer::Protocol
+
       attr_reader :stdout
       attr_reader :stderr
       attr_reader :command_line_patterns
-
-      attr_accessor :dump_all_types
+      attr_accessor :with_expectations_path
+      attr_accessor :save_expectations_path
 
       include Utils::DriverHelper
+      include Utils::JobsCount
 
       def initialize(stdout:, stderr:)
         @stdout = stdout
         @stderr = stderr
         @command_line_patterns = []
-
-        self.dump_all_types = false
       end
 
       def run
         project = load_config()
 
-        loader = Project::FileLoader.new(project: project)
-        loader.load_sources(command_line_patterns)
-        loader.load_signatures()
-
-        type_check(project)
-
-        if self.dump_all_types
-          project.targets.each do |target|
-            case (status = target.status)
-            when Project::Target::TypeCheckStatus
-              target.source_files.each_value do |file|
-                case (file_status = file.status)
-                when Project::SourceFile::TypeCheckStatus
-                  output_types(file_status.typing)
-                end
-              end
-            end
-          end
+        stdout.puts Rainbow("# Type checking files:").bold
+        stdout.puts
+
+        client_read, server_write = IO.pipe
+        server_read, client_write = IO.pipe
+
+        client_reader = LanguageServer::Protocol::Transport::Io::Reader.new(client_read)
+        client_writer = LanguageServer::Protocol::Transport::Io::Writer.new(client_write)
+
+        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: command_line_patterns,
+          delay_shutdown: true,
+          count: jobs_count
+        )
+
+        master = Server::Master.new(
+          project: project,
+          reader: server_reader,
+          writer: server_writer,
+          interaction_worker: nil,
+          typecheck_workers: typecheck_workers
+        )
+
+        main_thread = Thread.start do
+          master.start()
         end
+        main_thread.abort_on_exception = true
 
-        project.targets.each do |target|
-          Steep.logger.tagged "target=#{target.name}" do
-            case (status = target.status)
-            when Project::Target::SignatureSyntaxErrorStatus
-              printer = SignatureErrorPrinter.new(stdout: stdout, stderr: stderr)
-              printer.print_syntax_errors(status.errors)
-            when Project::Target::SignatureValidationErrorStatus
-              printer = SignatureErrorPrinter.new(stdout: stdout, stderr: stderr)
-              printer.print_semantic_errors(status.errors)
-            when Project::Target::TypeCheckStatus
-              status.type_check_sources.each do |source_file|
-                case source_file.status
-                when Project::SourceFile::TypeCheckStatus
-                  source_file.errors.select {|error| target.options.error_to_report?(error) }.each do |error|
-                    error.print_to stdout
-                  end
-                when Project::SourceFile::TypeCheckErrorStatus
-                  Steep.log_error source_file.status.error
-                end
-              end
-            when Project::Target::SignatureOtherErrorStatus
-              Steep.log_error status.error
+        client_writer.write({ method: :initialize, id: 0 })
+
+        shutdown_id = -1
+        client_writer.write({ method: :shutdown, id: shutdown_id })
+
+        diagnostic_notifications = []
+        error_messages = []
+        client_reader.read do |response|
+          case
+          when response[:method] == "textDocument/publishDiagnostics"
+            ds = response[:params][:diagnostics]
+            if ds.empty?
+              stdout.print "."
             else
-              Steep.logger.error { "Unexpected status: #{status.class}" }
+              stdout.print "F"
+            end
+            diagnostic_notifications << response[:params]
+            stdout.flush
+          when response[:method] == "window/showMessage"
+            # Assuming ERROR message means unrecoverable error.
+            message = response[:params]
+            if message[:type] == LSP::Constant::MessageType::ERROR
+              error_messages << message[:message]
             end
+          when response[:id] == shutdown_id
+            break
+          end
+        end
+
+        client_writer.write({ method: :exit })
+        client_writer.io.close()
+
+        main_thread.join()
+
+        stdout.puts
+        stdout.puts
+
+        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
 
-        if project.targets.all? {|target| target.status.is_a?(Project::Target::TypeCheckStatus) && target.no_error? && target.errors.empty? }
-          Steep.logger.info "No type error found"
-          return 0
+        ns = notifications.each.with_object({}) do |notification, hash|
+          path = project.relative_path(Pathname(URI.parse(notification[:uri]).path))
+          hash[path] = notification[:diagnostics]
         end
 
-        1
+        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 output_types(typing)
-        lines = []
+      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
 
-        typing.each_typing do |node, _|
-          begin
-            type = typing.type_of(node: node)
-            lines << [node.loc.expression.source_buffer.name, [node.loc.last_line,node.loc.last_column], [node.loc.first_line, node.loc.column], node, type]
-          rescue
-            lines << [node.loc.expression.source_buffer.name, [node.loc.last_line,node.loc.last_column], [node.loc.first_line, node.loc.column], node, nil]
+        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
 
-        lines.sort {|x,y| y <=> x }.reverse_each do |line|
-          source = line[3].loc.expression.source
-          stdout.puts "#{line[0]}:(#{line[2].join(",")}):(#{line[1].join(",")}):\t#{line[3].type}:\t#{line[4]}\t(#{source.split(/\n/).first})"
+        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
+        else
+          errors = notifications.reject {|notification| notification[:diagnostics].empty? }
+          total = errors.sum {|notification| notification[:diagnostics].size }
+
+          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)
+
+            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
     end