steep 0.37.0 → 0.42.0

data/lib/steep/drivers/watch.rb

@@ -7,6 +7,9 @@ module Steep
       attr_reader :queue
 
       include Utils::DriverHelper
+      include Utils::JobsCount
+
+      LSP = LanguageServer::Protocol
 
       def initialize(stdout:, stderr:)
         @dirs = []
@@ -15,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"
@@ -23,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
 
@@ -36,17 +39,14 @@ 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
         )
 
         main_thread = Thread.start do
@@ -57,79 +57,100 @@ module Steep
         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..."
+
+        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
           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
-                    }
-                  ]
-                }
-              )
+              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
         end.tap(&:start)
 
         begin
-          stdout.puts "👀 Watching directories, Ctrl-C to stop."
+          stdout.puts Rainbow("👀 Watching directories, Ctrl-C to stop.").bold
           client_reader.read do |response|
             case response[:method]
             when "textDocument/publishDiagnostics"
               uri = URI.parse(response[:params][:uri])
               path = project.relative_path(Pathname(uri.path))
+              buffer = RBS::Buffer.new(content: path.read, name: path)
+              printer = DiagnosticPrinter.new(stdout: stdout, buffer: buffer)
 
               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}"
+                  printer.print(diagnostic)
                 end
               end
+            when "window/showMessage"
+              # Assuming ERROR message means unrecoverable error.
+              message = response[:params]
+              if message[:type] == LSP::Constant::MessageType::ERROR
+                stdout.puts "Unexpected error reported... 🚨"
+              end
             end
           end
         rescue Interrupt
+          shutdown_id = -1
           stdout.puts "Shutting down workers..."
-          client_writer.write({ method: :shutdown, id: 10000 })
+          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()
         end
 
         listener.stop
-        main_thread.join
+        begin
+          main_thread.join
+        rescue Interrupt
+          master.kill
+          main_thread.join
+        end
 
         0
       end

data/lib/steep/drivers/worker.rb

@@ -6,6 +6,10 @@ module Steep
       attr_accessor :steepfile_path
       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
 
@@ -13,30 +17,34 @@ 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
                      raise "Unknown worker type: #{worker_type}"
                    end
 
+          unless delay_shutdown
+            worker.skip_jobs_after_shutdown!
+          end
+
           Steep.logger.info "Starting #{worker_type} worker..."
 
           worker.run()

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

data/lib/steep/index/rbs_index.rb

@@ -0,0 +1,334 @@
+module Steep
+  module Index
+    class RBSIndex
+      class TypeEntry
+        attr_reader :type_name
+        attr_reader :declarations
+        attr_reader :references
+
+        def initialize(type_name:)
+          @type_name = type_name
+          @declarations = Set[]
+          @references = Set[]
+        end
+
+        def add_declaration(decl)
+          case decl
+          when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module
+            declarations << decl
+          when RBS::AST::Declarations::Interface
+            declarations << decl
+          when RBS::AST::Declarations::Alias
+            declarations << decl
+          else
+            raise "Unexpected type declaration: #{decl}"
+          end
+
+          self
+        end
+
+        def add_reference(ref)
+          case ref
+          when RBS::AST::Members::MethodDefinition
+            references << ref
+          when RBS::AST::Members::AttrAccessor, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter
+            references << ref
+          when RBS::AST::Members::InstanceVariable, RBS::AST::Members::ClassInstanceVariable, RBS::AST::Members::ClassVariable
+            references << ref
+          when RBS::AST::Members::Include, RBS::AST::Members::Extend
+            references << ref
+          when RBS::AST::Declarations::Module, RBS::AST::Declarations::Class
+            references << ref
+          when RBS::AST::Declarations::Constant, RBS::AST::Declarations::Global
+            references << ref
+          when RBS::AST::Declarations::Alias
+            references << ref
+          else
+            raise "Unexpected type reference: #{ref}"
+          end
+
+          self
+        end
+      end
+
+      class MethodEntry
+        attr_reader :method_name
+        attr_reader :declarations
+        attr_reader :references
+
+        def initialize(method_name:)
+          @method_name = method_name
+          @declarations = Set[]
+          @references = Set[]
+        end
+
+        def add_declaration(decl)
+          case decl
+          when RBS::AST::Members::MethodDefinition,
+            RBS::AST::Members::Alias,
+            RBS::AST::Members::AttrWriter,
+            RBS::AST::Members::AttrReader,
+            RBS::AST::Members::AttrAccessor
+            declarations << decl
+          else
+            raise "Unexpected method declaration: #{decl}"
+          end
+
+          self
+        end
+      end
+
+      class ConstantEntry
+        attr_reader :const_name
+        attr_reader :declarations
+
+        def initialize(const_name:)
+          @const_name = const_name
+          @declarations = Set[]
+        end
+
+        def add_declaration(decl)
+          case decl
+          when RBS::AST::Declarations::Constant
+            declarations << decl
+          else
+            raise
+          end
+
+          self
+        end
+      end
+
+      class GlobalEntry
+        attr_reader :global_name
+        attr_reader :declarations
+
+        def initialize(global_name:)
+          @global_name = global_name
+          @declarations = Set[]
+        end
+
+        def add_declaration(decl)
+          case decl
+          when RBS::AST::Declarations::Global
+            declarations << decl
+          else
+            raise
+          end
+
+          self
+        end
+      end
+
+      attr_reader :type_index
+      attr_reader :method_index
+      attr_reader :const_index
+      attr_reader :global_index
+
+      def initialize()
+        @type_index = {}
+        @method_index = {}
+        @const_index = {}
+        @global_index = {}
+      end
+
+      def entry(type_name: nil, method_name: nil, const_name: nil, global_name: nil)
+        case
+        when type_name
+          type_index[type_name] ||= TypeEntry.new(type_name: type_name)
+        when method_name
+          method_index[method_name] ||= MethodEntry.new(method_name: method_name)
+        when const_name
+          const_index[const_name] ||= ConstantEntry.new(const_name: const_name)
+        when global_name
+          global_index[global_name] ||= GlobalEntry.new(global_name: global_name)
+        else
+          raise
+        end
+      end
+
+      def each_entry(&block)
+        if block_given?
+          type_index.each_value(&block)
+          method_index.each_value(&block)
+          const_index.each_value(&block)
+          global_index.each_value(&block)
+        else
+          enum_for(:each_entry)
+        end
+      end
+
+      def add_type_declaration(type_name, declaration)
+        entry(type_name: type_name).add_declaration(declaration)
+      end
+
+      def add_method_declaration(method_name, member)
+        entry(method_name: method_name).add_declaration(member)
+      end
+
+      def add_constant_declaration(const_name, decl)
+        entry(const_name: const_name).add_declaration(decl)
+      end
+
+      def add_global_declaration(global_name, decl)
+        entry(global_name: global_name).add_declaration(decl)
+      end
+
+      def each_declaration(type_name: nil, method_name: nil, const_name: nil, global_name: nil, &block)
+        if block
+          entry = entry(type_name: type_name, method_name: method_name, const_name: const_name, global_name: global_name)
+          entry.declarations.each(&block)
+        else
+          enum_for(:each_declaration, type_name: type_name, method_name: method_name, const_name: const_name, global_name: global_name)
+        end
+      end
+
+      def add_type_reference(type_name, ref)
+        entry(type_name: type_name).add_reference(ref)
+      end
+
+      def each_reference(type_name: nil, &block)
+        if block
+          entry(type_name: type_name).references.each(&block)
+        else
+          enum_for(:each_reference, type_name: type_name)
+        end
+      end
+
+      class Builder
+        attr_reader :index
+
+        def initialize(index:)
+          @index = index
+        end
+
+        def member(type_name, member)
+          case member
+          when RBS::AST::Members::MethodDefinition
+            member.types.each do |method_type|
+              method_type.each_type do |type|
+                type_reference type, from: member
+              end
+            end
+
+            if member.instance?
+              method_name = InstanceMethodName.new(type_name: type_name, method_name: member.name)
+              index.add_method_declaration(method_name, member)
+            end
+
+            if member.singleton?
+              method_name = SingletonMethodName.new(type_name: type_name, method_name: member.name)
+              index.add_method_declaration(method_name, member)
+            end
+
+          when RBS::AST::Members::AttrAccessor, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter
+            type_reference member.type, from: member
+
+            if member.is_a?(RBS::AST::Members::AttrReader) || member.is_a?(RBS::AST::Members::AttrAccessor)
+              method_name = case member.kind
+                            when :instance
+                              InstanceMethodName.new(type_name: type_name, method_name: member.name)
+                            when :singleton
+                              SingletonMethodName.new(type_name: type_name, method_name: member.name)
+                            end
+              index.add_method_declaration(method_name, member)
+            end
+
+            if member.is_a?(RBS::AST::Members::AttrWriter) || member.is_a?(RBS::AST::Members::AttrAccessor)
+              method_name = case member.kind
+                            when :instance
+                              InstanceMethodName.new(type_name: type_name, method_name: "#{member.name}=".to_sym)
+                            when :singleton
+                              SingletonMethodName.new(type_name: type_name, method_name: "#{member.name}=".to_sym)
+                            end
+              index.add_method_declaration(method_name, member)
+            end
+
+          when RBS::AST::Members::InstanceVariable, RBS::AST::Members::ClassVariable, RBS::AST::Members::ClassInstanceVariable
+            type_reference member.type, from: member
+
+          when RBS::AST::Members::Include, RBS::AST::Members::Extend
+            index.add_type_reference member.name, member
+            member.args.each do |type|
+              type_reference type, from: member
+            end
+
+          when RBS::AST::Members::Alias
+            if member.instance?
+              new_name = InstanceMethodName.new(type_name: type_name, method_name: member.new_name)
+              index.add_method_declaration(new_name, member)
+            end
+
+            if member.singleton?
+              new_name = SingletonMethodName.new(type_name: type_name, method_name: member.new_name)
+              index.add_method_declaration(new_name, member)
+            end
+          end
+        end
+
+        def type_reference(type, from:)
+          case type
+          when RBS::Types::ClassInstance, RBS::Types::ClassSingleton, RBS::Types::Alias, RBS::Types::Interface
+            index.add_type_reference(type.name, from)
+          end
+
+          type.each_type do |ty|
+            type_reference ty, from: from
+          end
+        end
+
+        def env(env)
+          env.class_decls.each do |name, decl|
+            decl.decls.each do |d|
+              index.add_type_declaration(name, d.decl)
+
+              case d.decl
+              when RBS::AST::Declarations::Class
+                if super_class = d.decl.super_class
+                  index.add_type_reference(super_class.name, d.decl)
+                  super_class.args.each do |type|
+                    type_reference(type, from: d.decl)
+                  end
+                end
+              when RBS::AST::Declarations::Module
+                d.decl.self_types.each do |self_type|
+                  index.add_type_reference(self_type.name, d.decl)
+                  self_type.args.each do |type|
+                    type_reference(type, from: d.decl)
+                  end
+                end
+              end
+
+              d.decl.members.each do |member|
+                member(name, member)
+              end
+            end
+          end
+
+          env.interface_decls.each do |name, decl|
+            index.add_type_declaration(name, decl.decl)
+
+            decl.decl.members.each do |member|
+              member(name, member)
+            end
+          end
+
+          env.alias_decls.each do |name, decl|
+            index.add_type_declaration(name, decl.decl)
+            type_reference decl.decl.type, from: decl.decl
+          end
+
+          env.constant_decls.each do |name, decl|
+            index.add_constant_declaration(name, decl.decl)
+            type_reference decl.decl.type, from: decl.decl
+          end
+
+          env.global_decls.each do |name, decl|
+            index.add_global_declaration(name, decl.decl)
+            type_reference decl.decl.type, from: decl.decl
+          end
+        end
+      end
+    end
+  end
+end