steep 0.40.0 → 0.44.0

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

@@ -20,6 +20,41 @@ module Steep
             end
           end
         end
+
+        def request_id
+          SecureRandom.alphanumeric(10)
+        end
+
+        def wait_for_response_id(reader:, id:, unknown_responses: :ignore)
+          wait_for_message(reader: reader, unknown_messages: unknown_responses) do |response|
+            response[:id] == id
+          end
+        end
+
+        def shutdown_exit(writer:, reader:)
+          request_id().tap do |id|
+            writer.write({ method: :shutdown, id: id })
+            wait_for_response_id(reader: reader, id: id)
+          end
+          writer.write({ method: :exit })
+        end
+
+        def wait_for_message(reader:, unknown_messages: :ignore, &block)
+          reader.read do |message|
+            if yield(message)
+              return message
+            else
+              case unknown_messages
+              when :ignore
+                # nop
+              when :log
+                Steep.logger.error { "Unexpected message: #{message.inspect}" }
+              when :raise
+                raise "Unexpected message: #{message.inspect}"
+              end
+            end
+          end
+        end
       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,33 +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::SignatureErrorStatus
-              formatter = Diagnostic::LSPFormatter.new
-              diagnostics = status.errors.group_by {|e| e.location.buffer }.transform_values do |errors|
-                errors.map {|error| formatter.format(error) }
+          controller = Services::SignatureService.load_from(target.new_env_loader(project: project))
+
+          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
 
-              diagnostics.each do |buffer, ds|
-                printer = DiagnosticPrinter.new(stdout: stdout, buffer: buffer)
-                ds.each do |d|
-                  printer.print(d)
-                  stdout.puts
-                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

data/lib/steep/drivers/watch.rb

@@ -7,6 +7,7 @@ module Steep
       attr_reader :queue
 
       include Utils::DriverHelper
+      include Utils::JobsCount
 
       LSP = LanguageServer::Protocol
 
@@ -17,6 +18,10 @@ module Steep
         @queue = Thread::Queue.new
       end
 
+      def watching?(changed_path, files:, dirs:)
+        files.empty? || files.include?(changed_path) || dirs.intersect?(changed_path.ascend.to_set)
+      end
+
       def run()
         if dirs.empty?
           stdout.puts "Specify directories to watch"
@@ -25,10 +30,6 @@ module Steep
 
         project = load_config()
 
-        loader = Project::FileLoader.new(project: project)
-        loader.load_sources(dirs)
-        loader.load_signatures()
-
         client_read, server_write = IO.pipe
         server_read, client_write = IO.pipe
 
@@ -38,28 +39,44 @@ 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)
-        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: dirs.map(&:to_s), 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(*dirs)
 
         main_thread = Thread.start do
           master.start()
         end
         main_thread.abort_on_exception = true
 
-        client_writer.write(method: "initialize", id: 0)
+        initialize_id = request_id()
+        client_writer.write(method: "initialize", id: initialize_id)
+        wait_for_response_id(reader: client_reader, id: initialize_id)
 
         Steep.logger.info "Watching #{dirs.join(", ")}..."
-        listener = Listen.to(*dirs.map(&:to_s)) do |modified, added, removed|
+
+        watch_paths = dirs.map do |dir|
+          case
+          when dir.directory?
+            dir.realpath
+          when dir.file?
+            dir.parent.realpath
+          else
+            dir
+          end
+        end
+
+        dir_paths = Set.new(dirs.select(&:directory?).map(&:realpath))
+        file_paths = Set.new(dirs.select(&:file?).map(&:realpath))
+
+        listener = Listen.to(*watch_paths.map(&:to_s)) do |modified, added, removed|
           stdout.puts Rainbow("🔬 Type checking updated files...").bold
 
           version = Time.now.to_i
@@ -67,43 +84,39 @@ module Steep
             Steep.logger.info "Received file system updates: modified=[#{modified.join(",")}], added=[#{added.join(",")}], removed=[#{removed.join(",")}]"
 
             (modified + added).each do |path|
-              client_writer.write(
-                method: "textDocument/didChange",
-                params: {
-                  textDocument: {
-                    uri: "file://#{path}",
-                    version: version
-                  },
-                  contentChanges: [
-                    {
-                      text: Pathname(path).read
-                    }
-                  ]
-                }
-              )
+              p = Pathname(path)
+              if watching?(p, files: file_paths, dirs: dir_paths)
+                client_writer.write(
+                  method: "textDocument/didChange",
+                  params: {
+                    textDocument: { uri: "file://#{path}", version: version },
+                    contentChanges: [{ text: p.read }]
+                  }
+                )
+              end
             end
 
             removed.each do |path|
-              client_writer.write(
-                method: "textDocument/didChange",
-                params: {
-                  textDocument: {
-                    uri: "file://#{path}",
-                    version: version
-                  },
-                  contentChanges: [
-                    {
-                      text: ""
-                    }
-                  ]
-                }
-              )
+              if watching?(p, files: file_paths, dirs: dir_paths)
+                client_writer.write(
+                  method: "textDocument/didChange",
+                  params: {
+                    textDocument: { uri: "file://#{path}", version: version },
+                    contentChanges: [{ text: "" }]
+                  }
+                )
+              end
             end
           end
+
+          client_writer.write(method: "$/typecheck", params: { guid: nil })
         end.tap(&:start)
 
         begin
           stdout.puts Rainbow("👀 Watching directories, Ctrl-C to stop.").bold
+
+          client_writer.write(method: "$/typecheck", params: { guid: nil })
+
           client_reader.read do |response|
             case response[:method]
             when "textDocument/publishDiagnostics"
@@ -117,6 +130,7 @@ module Steep
               unless diagnostics.empty?
                 diagnostics.each do |diagnostic|
                   printer.print(diagnostic)
+                  stdout.flush
                 end
               end
             when "window/showMessage"
@@ -128,16 +142,8 @@ module Steep
             end
           end
         rescue Interrupt
-          shutdown_id = -1
           stdout.puts "Shutting down workers..."
-          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 })
-          client_writer.io.close()
+          shutdown_exit(reader: client_reader, writer: client_writer)
         end
 
         listener.stop

data/lib/steep/drivers/worker.rb

@@ -7,6 +7,9 @@ module Steep
       attr_accessor :worker_type
       attr_accessor :worker_name
       attr_accessor :delay_shutdown
+      attr_accessor :max_index
+      attr_accessor :index
+      attr_accessor :commandline_args
 
       include Utils::DriverHelper
 
@@ -14,24 +17,24 @@ module Steep
         @stdout = stdout
         @stderr = stderr
         @stdin = stdin
+        @commandline_args = []
       end
 
       def run()
         Steep.logger.tagged("#{worker_type}:#{worker_name}") do
           project = load_config()
 
-          loader = Project::FileLoader.new(project: project)
-          loader.load_sources([])
-          loader.load_signatures()
-
           reader = LanguageServer::Protocol::Transport::Io::Reader.new(stdin)
           writer = LanguageServer::Protocol::Transport::Io::Writer.new(stdout)
 
           worker = case worker_type
-                   when :code
-                     Server::CodeWorker.new(project: project, reader: reader, writer: writer)
-                   when :signature
-                     Server::SignatureWorker.new(project: project, reader: reader, writer: writer)
+                   when :typecheck
+                     assignment = Services::PathAssignment.new(max_index: max_index, index: index)
+                     Server::TypeCheckWorker.new(project: project,
+                                                 reader: reader,
+                                                 writer: writer,
+                                                 assignment: assignment,
+                                                 commandline_args: commandline_args)
                    when :interaction
                      Server::InteractionWorker.new(project: project, reader: reader, writer: writer)
                    else

data/lib/steep/expectations.rb

@@ -0,0 +1,159 @@
+module Steep
+  class Expectations
+    class TestResult
+      attr_reader :path
+      attr_reader :expectation
+      attr_reader :actual
+
+      def initialize(path:, expectation:, actual:)
+        @path = path
+        @expectation = expectation
+        @actual = actual
+      end
+
+      def empty?
+        actual.empty?
+      end
+
+      def satisfied?
+        unexpected_diagnostics.empty? && missing_diagnostics.empty?
+      end
+
+      def each_diagnostics
+        if block_given?
+          expected_set = Set.new(expectation)
+          actual_set = Set.new(actual)
+
+          (expected_set + actual_set).sort_by {|a| Expectations.sort_key(a) }.each do |lsp|
+            case
+            when expected_set.include?(lsp) && actual_set.include?(lsp)
+              yield :expected, lsp
+            when expected_set.include?(lsp)
+              yield :missing, lsp
+            when actual_set.include?(lsp)
+              yield :unexpected, lsp
+            end
+          end
+        else
+          enum_for :each_diagnostics
+        end
+      end
+
+      def expected_diagnostics
+        each_diagnostics.select {|type, _| type == :expected }.map {|_, diag| diag }
+      end
+
+      def unexpected_diagnostics
+        each_diagnostics.select {|type, _| type == :unexpected }.map {|_, diag| diag }
+      end
+
+      def missing_diagnostics
+        each_diagnostics.select {|type, _| type == :missing }.map {|_, diag| diag }
+      end
+    end
+
+    LSP = LanguageServer::Protocol
+
+    attr_reader :diagnostics
+
+    def self.sort_key(hash)
+      [
+        hash.dig(:range, :start, :line),
+        hash.dig(:range, :start, :character),
+        hash.dig(:range, :end, :line),
+        hash.dig(:range, :end, :character),
+        hash[:code],
+        hash[:severity],
+        hash[:message]
+      ]
+    end
+
+    def initialize()
+      @diagnostics = {}
+    end
+
+    def test(path:, diagnostics:)
+      TestResult.new(path: path, expectation: self.diagnostics[path] || [], actual: diagnostics)
+    end
+
+    def self.empty
+      new()
+    end
+
+    def to_yaml
+      array = []
+
+      diagnostics.each_key.sort.each do |key|
+        ds = diagnostics[key]
+        array << {
+          "file" => key.to_s,
+          'diagnostics' => ds.sort_by {|hash| Expectations.sort_key(hash) }
+                             .map { |d| Expectations.lsp_to_hash(d) }
+        }
+      end
+
+      YAML.dump(array)
+    end
+
+    def self.load(path:, content:)
+      expectations = new()
+
+      YAML.load(content, filename: path.to_s).each do |entry|
+        file = Pathname(entry["file"])
+        expectations.diagnostics[file] = entry["diagnostics"]
+                                           .map {|hash| hash_to_lsp(hash) }
+                                           .sort_by! {|h| sort_key(h) }
+      end
+
+      expectations
+    end
+
+    # Translate hash to LSP Diagnostic message
+    def self.hash_to_lsp(hash)
+      {
+        range: {
+          start: {
+            line: hash.dig("range", "start", "line") - 1,
+            character: hash.dig("range", "start", "character")
+          },
+          end: {
+            line: hash.dig("range", "end", "line") - 1,
+            character: hash.dig("range", "end", "character")
+          }
+        },
+        severity: {
+          "ERROR" => LSP::Constant::DiagnosticSeverity::ERROR,
+          "WARNING" => LSP::Constant::DiagnosticSeverity::WARNING,
+          "INFORMATION" => LSP::Constant::DiagnosticSeverity::INFORMATION,
+          "HINT" => LSP::Constant::DiagnosticSeverity::HINT
+        }[hash["severity"] || "ERROR"],
+        message: hash["message"],
+        code: hash["code"]
+      }
+    end
+
+    # Translate LSP diagnostic message to hash
+    def self.lsp_to_hash(lsp)
+      {
+        "range" => {
+          "start" => {
+            "line" => lsp.dig(:range, :start, :line) + 1,
+            "character" => lsp.dig(:range, :start, :character)
+          },
+          "end" => {
+            "line" => lsp.dig(:range, :end, :line) + 1,
+            "character" => lsp.dig(:range, :end, :character)
+          }
+        },
+        "severity" => {
+          LSP::Constant::DiagnosticSeverity::ERROR => "ERROR",
+          LSP::Constant::DiagnosticSeverity::WARNING => "WARNING",
+          LSP::Constant::DiagnosticSeverity::INFORMATION => "INFORMATION",
+          LSP::Constant::DiagnosticSeverity::HINT => "HINT"
+        }[lsp[:severity] || LSP::Constant::DiagnosticSeverity::ERROR],
+        "message" => lsp[:message],
+        "code" => lsp[:code]
+      }
+    end
+  end
+end