steep 0.37.0 → 0.42.0

data/lib/steep/drivers/diagnostic_printer.rb

@@ -0,0 +1,99 @@
+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, prefix: "", source: true)
+        header, *rest = diagnostic[:message].split(/\n/)
+
+        stdout.puts "#{prefix}#{location(diagnostic)}: [#{severity_message(diagnostic[:severity])}] #{Rainbow(header).underline}"
+
+        unless rest.empty?
+          rest.each do |message|
+            stdout.puts "#{prefix}│ #{message}"
+          end
+        end
+
+        if diagnostic[:code]
+          stdout.puts "#{prefix}│" unless rest.empty?
+          stdout.puts "#{prefix}│ Diagnostic ID: #{diagnostic[:code]}"
+        end
+
+        stdout.puts "#{prefix}│"
+
+        if source
+          print_source_line(diagnostic, prefix: prefix)
+        else
+          stdout.puts "#{prefix}└ (no source code available)"
+          stdout.puts "#{prefix}"
+        end
+      end
+
+      def print_source_line(diagnostic, prefix: "")
+        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 "#{prefix}└ #{leading}#{color_severity(subject, severity: diagnostic[:severity])}#{trailing}"
+        stdout.puts "#{prefix}  #{" " * leading.size}#{"~" * subject.size}"
+      end
+    end
+  end
+end

data/lib/steep/drivers/langserver.rb

@@ -10,6 +10,7 @@ module Steep
       attr_reader :type_check_thread
 
       include Utils::DriverHelper
+      include Utils::JobsCount
 
       TypeCheckRequest = Struct.new(:version, keyword_init: true)
 
@@ -36,21 +37,15 @@ module Steep
       def run
         @project = load_config()
 
-        loader = Project::FileLoader.new(project: project)
-        loader.load_sources([])
-        loader.load_signatures()
-
         interaction_worker = Server::WorkerProcess.spawn_worker(:interaction, name: "interaction", steepfile: project.steepfile_path)
-        signature_worker = Server::WorkerProcess.spawn_worker(:signature, name: "signature", steepfile: project.steepfile_path)
-        code_workers = Server::WorkerProcess.spawn_code_workers(steepfile: project.steepfile_path)
+        typecheck_workers = Server::WorkerProcess.spawn_typecheck_workers(steepfile: project.steepfile_path, args: [], count: jobs_count)
 
         master = Server::Master.new(
           project: project,
           reader: reader,
           writer: writer,
           interaction_worker: interaction_worker,
-          signature_worker: signature_worker,
-          code_workers: code_workers
+          typecheck_workers: typecheck_workers
         )
 
         master.start()

data/lib/steep/drivers/print_project.rb

@@ -14,33 +14,34 @@ module Steep
       def run
         project = load_config()
 
-        loader = Project::FileLoader.new(project: project)
-        loader.load_sources([])
-        loader.load_signatures()
+        loader = Services::FileLoader.new(base_dir: project.base_dir)
 
         project.targets.each do |target|
+          source_changes = loader.load_changes(target.source_pattern, changes: {})
+          signature_changes = loader.load_changes(target.signature_pattern, changes: {})
+
           stdout.puts "Target:"
           stdout.puts "  #{target.name}:"
           stdout.puts "    sources:"
           stdout.puts "      patterns:"
-          target.source_patterns.each do |pattern|
+          target.source_pattern.patterns.each do |pattern|
             stdout.puts "        - #{pattern}"
           end
           stdout.puts "      ignores:"
-          target.ignore_patterns.each do |pattern|
+          target.source_pattern.ignores.each do |pattern|
             stdout.puts "        - #{pattern}"
           end
           stdout.puts "      files:"
-          target.source_files.each_key do |path|
+          source_changes.each_key do |path|
             stdout.puts "        - #{path}"
           end
           stdout.puts "    signatures:"
           stdout.puts "      patterns:"
-          target.signature_patterns.each do |pattern|
+          target.signature_pattern.patterns.each do |pattern|
             stdout.puts "        - #{pattern}"
           end
           stdout.puts "      files:"
-          target.signature_files.each_key do |path|
+          signature_changes.each_key do |path|
             stdout.puts "        - #{path}"
           end
           stdout.puts "    libraries:"
@@ -48,7 +49,7 @@ module Steep
             stdout.puts "      - #{lib}"
           end
           stdout.puts "    library dirs:"
-          Project::Target.construct_env_loader(options: target.options).tap do |loader|
+          target.new_env_loader.tap do |loader|
             loader.each_dir do |lib, path|
               case lib
               when :core

data/lib/steep/drivers/stats.rb

@@ -8,6 +8,7 @@ module Steep
       attr_reader :command_line_patterns
 
       include Utils::DriverHelper
+      include Utils::JobsCount
 
       def initialize(stdout:, stderr:)
         @stdout = stdout
@@ -18,49 +19,140 @@ module Steep
       def run
         project = load_config()
 
-        loader = Project::FileLoader.new(project: project)
-        loader.load_sources(command_line_patterns)
-        loader.load_signatures()
+        stderr.puts Rainbow("# Calculating stats:").bold
+        stderr.puts
 
-        type_check(project)
+        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,
+          delay_shutdown: true,
+          args: command_line_patterns,
+          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
+
+        client_writer.write({ method: :initialize, id: 0 })
+
+        stats_id = -1
+        client_writer.write(
+          {
+            id: stats_id,
+            method: "workspace/executeCommand",
+            params: { command: "steep/stats", arguments: [] }
+          })
+
+        stats_result = []
+        client_reader.read do |response|
+          if response[:id] == stats_id
+            stats_result.push(*response[:result])
+            break
+          end
+        end
+
+        shutdown_id = -2
+        client_writer.write({ method: :shutdown, id: shutdown_id })
+
+        client_reader.read do |response|
+          if response[:id] == shutdown_id
+            break
+          end
+        end
+
+        client_writer.write({ method: "exit" })
+        main_thread.join()
 
         stdout.puts(
           CSV.generate do |csv|
             csv << ["Target", "File", "Status", "Typed calls", "Untyped calls", "All calls", "Typed %"]
-
-            project.targets.each do |target|
-              case (status = target.status)
-              when Project::Target::TypeCheckStatus
-                status.type_check_sources.each do |source_file|
-                  case source_file.status
-                  when Project::SourceFile::TypeCheckStatus
-                    typing = source_file.status.typing
-
-                    typed = 0
-                    untyped = 0
-                    total = 0
-                    typing.method_calls.each_value do |call|
-                      case call
-                      when TypeInference::MethodCall::Typed
-                        typed += 1
-                      when TypeInference::MethodCall::Untyped
-                        untyped += 1
-                      end
-
-                      total += 1
-                    end
-
-                    csv << format_stats(target, source_file.path, "success", typed, untyped, total)
-                  when Project::SourceFile::TypeCheckErrorStatus
-                    csv << format_stats(target, source_file.path, "error", 0, 0, 0)
+            stats_result.each do |row|
+              if row[:type] == "success"
+                csv << [
+                  row[:target],
+                  row[:path],
+                  row[:type],
+                  row[:typed_calls],
+                  row[:untyped_calls],
+                  row[:total_calls],
+                  if row[:total_calls].nonzero?
+                    (row[:typed_calls].to_f / row[:total_calls] * 100).to_i
                   else
-                    csv << format_stats(target, source_file.path, "unknown (#{source_file.status.class.to_s.split(/::/).last})", 0, 0, 0)
+                    100
                   end
-                end
+                ]
+              else
+                csv << [
+                  row[:target],
+                  row[:path],
+                  row[:type],
+                  0,
+                  0,
+                  0,
+                  0
+                ]
               end
             end
           end
         )
+        #
+        # type_check(project)
+        #
+        # stdout.puts(
+        #   CSV.generate do |csv|
+        #     csv << ["Target", "File", "Status", "Typed calls", "Untyped calls", "All calls", "Typed %"]
+        #
+        #     project.targets.each do |target|
+        #       case (status = target.status)
+        #       when Project::Target::TypeCheckStatus
+        #         status.type_check_sources.each do |source_file|
+        #           case source_file.status
+        #           when Project::SourceFile::TypeCheckStatus
+        #             typing = source_file.status.typing
+        #
+        #             typed = 0
+        #             untyped = 0
+        #             total = 0
+        #             typing.method_calls.each_value do |call|
+        #               case call
+        #               when TypeInference::MethodCall::Typed
+        #                 typed += 1
+        #               when TypeInference::MethodCall::Untyped
+        #                 untyped += 1
+        #               end
+        #
+        #               total += 1
+        #             end
+        #
+        #             csv << format_stats(target, source_file.path, "success", typed, untyped, total)
+        #           when Project::SourceFile::TypeCheckErrorStatus
+        #             csv << format_stats(target, source_file.path, "error", 0, 0, 0)
+        #           else
+        #             csv << format_stats(target, source_file.path, "unknown (#{source_file.status.class.to_s.split(/::/).last})", 0, 0, 0)
+        #           end
+        #         end
+        #       end
+        #     end
+        #   end
+        # )
 
         0
       end

data/lib/steep/drivers/trace_printer.rb

@@ -9,7 +9,7 @@ module Steep
 
       def print(trace, level: 0)
         trace.each.with_index do |t, i|
-          prefix = " " * (i + level)
+          prefix = "  " * (i + level)
           case t[0]
           when :type
             io.puts "#{prefix}#{t[1]} <: #{t[2]}"
@@ -17,6 +17,10 @@ module Steep
             io.puts "#{prefix}(#{t[3]}) #{t[1]} <: #{t[2]}"
           when :method_type
             io.puts "#{prefix}#{t[1]} <: #{t[2]}"
+          when :interface
+            # nop
+          else
+            Steep.logger.error { "Unexpected trace item: #{t[0]}" }
           end
         end
       end

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

@@ -0,0 +1,9 @@
+module Steep
+  module Drivers
+    module Utils
+      module JobsCount
+        attr_accessor :jobs_count
+      end
+    end
+  end
+end

data/lib/steep/drivers/validate.rb

@@ -13,26 +13,44 @@ module Steep
 
       def run
         project = load_config()
+        file_loader = Services::FileLoader.new(base_dir: project.base_dir)
 
-        loader = Project::FileLoader.new(project: project)
-        loader.load_signatures()
-
-        type_check(project)
+        any_error = false
 
         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)
+          controller = Services::SignatureService.load_from(target.new_env_loader)
+
+          changes = file_loader.load_changes(target.signature_pattern, changes: {})
+          controller.update(changes)
+
+          errors =
+            Steep.measure "Validation" do
+              case controller.status
+              when Services::SignatureService::SyntaxErrorStatus, Services::SignatureService::AncestorErrorStatus
+                controller.status.diagnostics
+              when Services::SignatureService::LoadedStatus
+                check = Subtyping::Check.new(factory: AST::Types::Factory.new(builder: controller.latest_builder))
+                Signature::Validator.new(checker: check).tap {|v| v.validate() }.each_error.to_a
+              end
+            end
+
+          any_error ||= !errors.empty?
+
+          formatter = Diagnostic::LSPFormatter.new
+          diagnostics = 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
 
-        project.targets.all? {|target| target.status.is_a?(Project::Target::TypeCheckStatus) } ? 0 : 1
+        any_error ? 1 : 0
       end
     end
   end