steep 0.39.0 → 0.40.0

data/lib/steep/diagnostic/signature.rb

@@ -0,0 +1,224 @@
+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
+          "Ruby::#{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
+          "Syntax error: #{exception.message}"
+        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
+    end
+  end
+end

data/lib/steep/drivers/annotations.rb

@@ -39,12 +39,19 @@ module Steep
                     end
                   end
                 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)
+              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
+
+                diagnostics.each do |buffer, ds|
+                  printer = DiagnosticPrinter.new(stdout: stdout, buffer: buffer)
+                  ds.each do |d|
+                    printer.print(d)
+                    stdout.puts
+                  end
+                end
               end
             end
           end

data/lib/steep/drivers/check.rb

@@ -1,20 +1,18 @@
 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
-
       include Utils::DriverHelper
 
       def initialize(stdout:, stderr:)
         @stdout = stdout
         @stderr = stderr
         @command_line_patterns = []
-
-        self.dump_all_types = false
       end
 
       def run
@@ -24,73 +22,98 @@ module Steep
         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)
+
+        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)
+
+        master = Server::Master.new(
+          project: project,
+          reader: server_reader,
+          writer: server_writer,
+          interaction_worker: interaction_worker,
+          signature_worker: signature_worker,
+          code_workers: code_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 })
+
+        responses = []
+        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
+            responses << 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
 
-        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
-        end
+        client_writer.write({ method: :exit })
+        client_writer.io.close()
 
-        1
-      end
+        main_thread.join()
 
-      def output_types(typing)
-        lines = []
+        stdout.puts
+        stdout.puts
 
-        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]
-          end
-        end
+        case
+        when responses.all? {|res| res[:diagnostics].empty? } && error_messages.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.each do |resp|
+            path = project.relative_path(Pathname(URI.parse(resp[:uri]).path))
+            buffer = RBS::Buffer.new(name: path, content: path.read)
+            printer = DiagnosticPrinter.new(buffer: buffer, stdout: stdout)
 
-        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})"
+            resp[:diagnostics].each do |diag|
+              printer.print(diag)
+              stdout.puts
+            end
+          end
+          1
         end
       end
     end

data/lib/steep/drivers/diagnostic_printer.rb

@@ -0,0 +1,94 @@
+module Steep
+  module Drivers
+    class DiagnosticPrinter
+      LSP = LanguageServer::Protocol
+
+      attr_reader :stdout
+      attr_reader :buffer
+
+      def initialize(stdout:, buffer:)
+        @stdout = stdout
+        @buffer = buffer
+      end
+
+      def path
+        buffer.name
+      end
+
+      def color_severity(string, severity:)
+        s = Rainbow(string)
+
+        case severity
+        when LSP::Constant::DiagnosticSeverity::ERROR
+          s.red
+        when LSP::Constant::DiagnosticSeverity::WARNING
+          s.yellow
+        when LSP::Constant::DiagnosticSeverity::INFORMATION
+          s.blue
+        else
+          s
+        end
+      end
+
+      def severity_message(severity)
+        string = case severity
+                 when LSP::Constant::DiagnosticSeverity::ERROR
+                   "error"
+                 when LSP::Constant::DiagnosticSeverity::WARNING
+                   "warning"
+                 when LSP::Constant::DiagnosticSeverity::INFORMATION
+                   "information"
+                 when LSP::Constant::DiagnosticSeverity::HINT
+                   "hint"
+                 end
+
+        color_severity(string, severity: severity)
+      end
+
+      def location(diagnostic)
+        start = diagnostic[:range][:start]
+        Rainbow("#{path}:#{start[:line]+1}:#{start[:character]}").magenta
+      end
+
+      def print(diagnostic)
+        header, *rest = diagnostic[:message].split(/\n/)
+
+        stdout.puts "#{location(diagnostic)}: [#{severity_message(diagnostic[:severity])}] #{Rainbow(header).underline}"
+
+        unless rest.empty?
+          rest.each do |message|
+            stdout.puts "│ #{message}"
+          end
+        end
+
+        if diagnostic[:code]
+          stdout.puts "│" unless rest.empty?
+          stdout.puts "│ Diagnostic ID: #{diagnostic[:code]}"
+        end
+
+        stdout.puts "│"
+
+        print_source_line(diagnostic)
+      end
+
+      def print_source_line(diagnostic)
+        start_pos = diagnostic[:range][:start]
+        end_pos = diagnostic[:range][:end]
+
+        line = buffer.lines[start_pos[:line]]
+
+        leading = line[0...start_pos[:character]]
+        if start_pos[:line] == end_pos[:line]
+          subject = line[start_pos[:character]...end_pos[:character]]
+          trailing = line[end_pos[:character]...].chomp
+        else
+          subject = line[start_pos[:character]...].chomp
+          trailing = ""
+        end
+
+        stdout.puts "└ #{leading}#{color_severity(subject, severity: diagnostic[:severity])}#{trailing}"
+        stdout.puts "  #{" " * leading.size}#{"~" * subject.size}"
+      end
+    end
+  end
+end