steep 0.15.0 → 0.16.0

data/lib/steep/drivers/watch.rb

@@ -15,110 +15,122 @@ module Steep
         @queue = Thread::Queue.new
       end
 
-      def listener
-        @listener ||= begin
-          Steep.logger.info "Watching #{dirs.join(", ")}..."
-          Listen.to(*dirs.map(&:to_s)) do |modified, added, removed|
-            Steep.logger.tagged "watch" do
-              Steep.logger.info "Received file system updates: modified=[#{modified.join(",")}], added=[#{added.join(",")}], removed=[#{removed.join(",")}]"
-            end
-            queue << [modified, added, removed]
-          end
+      def run()
+        if dirs.empty?
+          stdout.puts "Specify directories to watch"
+          return 1
         end
-      end
 
-      def type_check_loop(project)
-        until queue.closed?
-          stdout.puts "🚥 Waiting for updates..."
+        project = load_config()
 
-          events = []
-          events << queue.deq
-          until queue.empty?
-              events << queue.deq(nonblock: true)
-          end
+        loader = Project::FileLoader.new(project: project)
+        loader.load_sources([])
+        loader.load_signatures()
 
-          events.compact.each do |modified, added, removed|
-            modified.each do |name|
-              path = Pathname(name).relative_path_from(Pathname.pwd)
+        client_read, server_write = IO.pipe
+        server_read, client_write = IO.pipe
 
-              project.targets.each do |target|
-                target.update_source path, path.read if target.source_file?(path)
-                target.update_signature path, path.read if target.signature_file?(path)
-              end
-            end
+        client_reader = LanguageServer::Protocol::Transport::Io::Reader.new(client_read)
+        client_writer = LanguageServer::Protocol::Transport::Io::Writer.new(client_write)
 
-            added.each do |name|
-              path = Pathname(name).relative_path_from(Pathname.pwd)
+        server_reader = LanguageServer::Protocol::Transport::Io::Reader.new(server_read)
+        server_writer = LanguageServer::Protocol::Transport::Io::Writer.new(server_write)
 
-              project.targets.each do |target|
-                target.add_source path, path.read if target.possible_source_file?(path)
-                target.add_signature path, path.read if target.possible_signature_file?(path)
-              end
-            end
+        interaction_worker = Server::InteractionWorker.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)
 
-            removed.each do |name|
-              path = Pathname(name).relative_path_from(Pathname.pwd)
+        master = Server::Master.new(
+          project: project,
+          reader: server_reader,
+          writer: server_writer,
+          interaction_worker: interaction_worker,
+          signature_worker: signature_worker,
+          code_workers: code_workers
+        )
 
-              project.targets.each do |target|
-                target.remove_source path if target.source_file?(path)
-                target.remove_signature path if target.signature_file?(path)
-              end
+        main_thread = Thread.start do
+          master.start()
+        end
+        main_thread.abort_on_exception = true
+
+        client_writer.write(method: "initialize", id: 0)
+
+        Steep.logger.info "Watching #{dirs.join(", ")}..."
+        listener = Listen.to(*dirs.map(&:to_s)) do |modified, added, removed|
+          stdout.puts "🔬 Type checking updated files..."
+
+          version = Time.now.to_i
+          Steep.logger.tagged "watch" do
+            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
+                    }
+                  ]
+                }
+              )
             end
-          end
 
-          stdout.puts "🔬 Type checking..."
-          type_check project
-          print_project_result project
-        end
-      rescue ClosedQueueError
-        # nop
-      end
+            removed.each do |path|
+              client_writer.write(
+                method: "textDocument/didChange",
+                params: {
+                  textDocument: {
+                    uri: "file://#{path}",
+                    version: version
+                  },
+                  contentChanges: [
+                    {
+                      text: ""
+                    }
+                  ]
+                }
+              )
+            end
+          end
+        end.tap(&:start)
 
-      def print_project_result(project)
-        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|
-                source_file.errors.each do |error|
-                  error.print_to stdout
+        begin
+          stdout.puts "👀 Watching directories, Ctrl-C to stop."
+          client_reader.read do |response|
+            case response[:method]
+            when "textDocument/publishDiagnostics"
+              uri = URI.parse(response[:params][:uri])
+              path = project.relative_path(Pathname(uri.path))
+
+              diagnostics = response[:params][:diagnostics]
+
+              unless diagnostics.empty?
+                diagnostics.each do |diagnostic|
+                  start = diagnostic[:range][:start]
+                  loc = "#{start[:line]+1}:#{start[:character]}"
+                  message = diagnostic[:message].chomp.lines.join("  ")
+
+                  stdout.puts "#{path}:#{loc}: #{message}"
                 end
               end
             end
           end
-        end
-      end
-
-      def run()
-        if dirs.empty?
-          stdout.puts "Specify directories to watch"
-          return 1
-        end
-
-        project = load_config()
-
-        loader = Project::FileLoader.new(project: project)
-        loader.load_sources([])
-        loader.load_signatures()
-
-        type_check project
-        print_project_result project
-
-        listener.start
-
-        stdout.puts "👀 Watching directories, Ctrl-C to stop."
-        begin
-          type_check_loop project
         rescue Interrupt
-          # bye
+          stdout.puts "Shutting down workers..."
+          client_writer.write({ method: :shutdown, id: 10000 })
+          client_writer.write({ method: :exit })
+          client_writer.io.close()
         end
 
+        listener.stop
+        main_thread.join
+
         0
       end
     end

data/lib/steep/drivers/worker.rb

@@ -0,0 +1,51 @@
+module Steep
+  module Drivers
+    class Worker
+      attr_reader :stdout, :stderr, :stdin
+
+      attr_accessor :steepfile_path
+      attr_accessor :worker_type
+      attr_accessor :worker_name
+
+      include Utils::DriverHelper
+
+      def initialize(stdout:, stderr:, stdin:)
+        @stdout = stdout
+        @stderr = stderr
+        @stdin = stdin
+      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 :interaction
+                     Server::InteractionWorker.new(project: project, reader: reader, writer: writer)
+                   else
+                     raise "Unknown worker type: #{worker_type}"
+                   end
+
+          Steep.logger.info "Starting #{worker_type} worker..."
+
+          worker.run()
+        rescue Interrupt
+          Steep.logger.info "Shutting down by interrupt..."
+        end
+
+        0
+      end
+    end
+  end
+end

data/lib/steep/project/completion_provider.rb

@@ -47,8 +47,10 @@ module Steep
         position = Position.new(line: line, column: column)
 
         begin
-          Steep.measure "type_check!" do
-            type_check!(source_text)
+          Steep.logger.tagged "completion_provider#run(line: #{line}, column: #{column})" do
+            Steep.measure "type_check!" do
+              type_check!(source_text)
+            end
           end
 
           Steep.measure "completion item collection" do

data/lib/steep/project/file.rb

@@ -96,6 +96,7 @@ module Steep
             timestamp: Time.now
           )
         rescue => exn
+          Steep.log_error(exn)
           @status = TypeCheckErrorStatus.new(error: exn)
         end
 

data/lib/steep/project/hover_content.rb

@@ -33,9 +33,12 @@ module Steep
       end
 
       def content_for(path:, line:, column:)
-        source_file = project.targets.map {|target| target.source_files[path] }.compact[0]
+        target = project.targets.find {|target| target.source_file?(path) }
+
+        if target
+          source_file = target.source_files[path]
+          target.type_check(target_sources: [source_file], validate_signatures: false)
 
-        if source_file
           case (status = source_file.status)
           when SourceFile::TypeCheckStatus
             node, *parents = status.source.find_nodes(line: line, column: column)

data/lib/steep/project/target.rb

@@ -67,24 +67,30 @@ module Steep
       end
 
       def possible_source_file?(path)
-        self.class.test_pattern(source_patterns, path) &&
-          !self.class.test_pattern(ignore_patterns, path)
+        self.class.test_pattern(source_patterns, path, ext: ".rb") &&
+          !self.class.test_pattern(ignore_patterns, path, ext: ".rb")
       end
 
       def possible_signature_file?(path)
-        self.class.test_pattern(signature_patterns, path)
+        self.class.test_pattern(signature_patterns, path, ext: ".rbs")
       end
 
-      def self.test_pattern(patterns, path)
+      def self.test_pattern(patterns, path, ext:)
         patterns.any? do |pattern|
           p = pattern.end_with?(File::Separator) ? pattern : pattern + File::Separator
-          path.to_s.start_with?(p) || File.fnmatch(pattern, path.to_s)
+          (path.to_s.start_with?(p) && path.extname == ext) || File.fnmatch(pattern, path.to_s)
         end
       end
 
-      def type_check
-        load_signatures do |env, check, timestamp|
-          run_type_check(env, check, timestamp)
+      def type_check(target_sources: source_files.values, validate_signatures: true)
+        Steep.logger.tagged "target#type_check(target_sources: [#{target_sources.map(&:path).join(", ")}], validate_signatures: #{validate_signatures})" do
+          Steep.measure "load signature and type check" do
+            load_signatures(validate: validate_signatures) do |env, check, timestamp|
+              Steep.measure "type checking #{target_sources.size} files" do
+                run_type_check(env, check, timestamp, target_sources: target_sources)
+              end
+            end
+          end
         end
       end
 
@@ -100,7 +106,7 @@ module Steep
         end
       end
 
-      def load_signatures
+      def load_signatures(validate:)
         timestamp = case status
                     when TypeCheckStatus
                       status.timestamp
@@ -133,16 +139,20 @@ module Steep
             factory = AST::Types::Factory.new(builder: definition_builder)
             check = Subtyping::Check.new(factory: factory)
 
-            validator = Signature::Validator.new(checker: check)
-            validator.validate()
-
-            if validator.no_error?
-              yield env, check, Time.now
+            if validate
+              validator = Signature::Validator.new(checker: check)
+              validator.validate()
+
+              if validator.no_error?
+                yield env, check, Time.now
+              else
+                @status = SignatureValidationErrorStatus.new(
+                  errors: validator.each_error.to_a,
+                  timestamp: Time.now
+                )
+              end
             else
-              @status = SignatureValidationErrorStatus.new(
-                errors: validator.each_error.to_a,
-                timestamp: Time.now
-              )
+              yield env, check, Time.now
             end
           end
 
@@ -160,10 +170,10 @@ module Steep
         end
       end
 
-      def run_type_check(env, check, timestamp)
+      def run_type_check(env, check, timestamp, target_sources: source_files.values)
         type_check_sources = []
 
-        source_files.each_value do |file|
+        target_sources.each do |file|
           if file.type_check(check, timestamp)
             type_check_sources << file
           end

data/lib/steep/project.rb

@@ -1,17 +1,21 @@
 module Steep
   class Project
     attr_reader :targets
-    attr_reader :base_dir
+    attr_reader :steepfile_path
 
-    def initialize(base_dir:)
+    def initialize(steepfile_path:)
       @targets = []
-      @base_dir = base_dir
+      @steepfile_path = steepfile_path
 
-      unless base_dir.absolute?
-        raise "Project#initialize(base_dir:): base_dir should be absolute path"
+      unless steepfile_path.absolute?
+        raise "Project#initialize(steepfile_path:): steepfile_path should be absolute path"
       end
     end
 
+    def base_dir
+      steepfile_path.parent
+    end
+
     def relative_path(path)
       path.relative_path_from(base_dir)
     end

data/lib/steep/server/base_worker.rb

@@ -0,0 +1,56 @@
+module Steep
+  module Server
+    class BaseWorker
+      LSP = LanguageServer::Protocol
+
+      include Utils
+
+      attr_reader :project
+      attr_reader :reader, :writer
+
+      def initialize(project:, reader:, writer:)
+        @project = project
+        @reader = reader
+        @writer = writer
+      end
+
+      def handle_request(request)
+        # process request
+      end
+
+      def handle_job(job)
+        # process async job
+      end
+
+      def run
+        tags = Steep.logger.formatter.current_tags.dup
+        thread = Thread.new do
+          Steep.logger.formatter.push_tags(*tags)
+          Steep.logger.tagged "background" do
+            while job = queue.pop
+              handle_job(job)
+            end
+          end
+        end
+
+        Steep.logger.tagged "frontend" do
+          begin
+            reader.read do |request|
+              case request[:method]
+              when "shutdown"
+                # nop
+              when "exit"
+                break
+              else
+                handle_request(request)
+              end
+            end
+          ensure
+            queue << nil
+            thread.join
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/server/code_worker.rb

@@ -0,0 +1,151 @@
+module Steep
+  module Server
+    class CodeWorker < BaseWorker
+      LSP = LanguageServer::Protocol
+
+      include Utils
+
+      attr_reader :target_files
+      attr_reader :queue
+
+      def initialize(project:, reader:, writer:, queue: Queue.new)
+        super(project: project, reader: reader, writer: writer)
+
+        @target_files = {}
+        @queue = queue
+      end
+
+      def enqueue_type_check(target:, path:, version: target_files[path])
+        Steep.logger.info "Enqueueing type check: #{path}(#{version})@#{target.name}..."
+        target_files[path] = version
+        queue << [path, version, target]
+      end
+
+      def each_type_check_subject(path:, version:)
+        case
+        when !(updated_targets = project.targets.select {|target| target.signature_file?(path) }).empty?
+          updated_targets.each do |target|
+            target_files.each_key do |path|
+              if target.source_file?(path)
+                yield target, path, target_files[path]
+              end
+            end
+          end
+
+        when target = project.targets.find {|target| target.source_file?(path) }
+          if target_files.key?(path)
+            yield target, path, version
+          end
+        end
+      end
+
+      def typecheck_file(path, target)
+        Steep.logger.info "Starting type checking: #{path}@#{target.name}..."
+
+        source = target.source_files[path]
+        target.type_check(target_sources: [source], validate_signatures: false)
+
+        Steep.logger.info "Finished type checking: #{path}@#{target.name}"
+
+        diagnostics = source_diagnostics(source)
+
+        writer.write(
+          method: :"textDocument/publishDiagnostics",
+          params: LSP::Interface::PublishDiagnosticsParams.new(
+            uri: URI.parse(project.absolute_path(path).to_s).tap {|uri| uri.scheme = "file"},
+            diagnostics: diagnostics
+          )
+        )
+      end
+
+      def source_diagnostics(source)
+        case status = source.status
+        when Project::SourceFile::ParseErrorStatus
+          []
+        when Project::SourceFile::AnnotationSyntaxErrorStatus
+          [
+            LSP::Interface::Diagnostic.new(
+              message: "Annotation syntax error: #{status.error.cause.message}",
+              severity: LSP::Constant::DiagnosticSeverity::ERROR,
+              range: LSP::Interface::Range.new(
+                start: LSP::Interface::Position.new(
+                  line: status.location.start_line - 1,
+                  character: status.location.start_column
+                ),
+                end: LSP::Interface::Position.new(
+                  line: status.location.end_line - 1,
+                  character: status.location.end_column
+                )
+              )
+            )
+          ]
+        when Project::SourceFile::TypeCheckStatus
+          status.typing.errors.map do |error|
+            loc = error.location_to_str
+
+            LSP::Interface::Diagnostic.new(
+              message: StringIO.new.tap {|io| error.print_to(io) }.string.gsub(/\A#{loc}: /, "").chomp,
+              severity: LSP::Constant::DiagnosticSeverity::ERROR,
+              range: LSP::Interface::Range.new(
+                start: LSP::Interface::Position.new(
+                  line: error.node.loc.line - 1,
+                  character: error.node.loc.column
+                ),
+                end: LSP::Interface::Position.new(
+                  line: error.node.loc.last_line - 1,
+                  character: error.node.loc.last_column
+                )
+              )
+            )
+          end
+        when Project::SourceFile::TypeCheckErrorStatus
+          []
+        end
+      end
+
+      def handle_request(request)
+        case request[:method]
+        when "initialize"
+          # Don't respond to initialize request, but start type checking.
+          project.targets.each do |target|
+            target.source_files.each_key do |path|
+              if target_files.key?(path)
+                enqueue_type_check(target: target, path: path, version: target_files[path])
+              end
+            end
+          end
+
+        when "workspace/executeCommand"
+          if request[:params][:command] == "steep/registerSourceToWorker"
+            paths = request[:params][:arguments].map {|arg| source_path(URI.parse(arg)) }
+            paths.each do |path|
+              target_files[path] = 0
+            end
+          end
+
+        when "textDocument/didChange"
+          update_source(request) do |path, version|
+            if target_files.key?(path)
+              target_files[path] = version
+            end
+          end
+
+          path = source_path(URI.parse(request[:params][:textDocument][:uri]))
+          version = request[:params][:textDocument][:version]
+          each_type_check_subject(path: path, version: version) do |target, path, version|
+            enqueue_type_check(target: target, path: path, version: version)
+          end
+        end
+      end
+
+      def handle_job(job)
+        path, version, target = job
+        if !version || target_files[path] == version
+          typecheck_file(path, target)
+        else
+          Steep.logger.info "Skipping type check: #{path}@#{target.name}, queued version=#{version}, latest version=#{target_files[path]}"
+        end
+      end
+    end
+  end
+end