steep 0.14.0 → 0.16.3

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

@@ -8,7 +8,7 @@ module Steep
           raise "Cannot find a configuration at #{path}: `steep init` to scaffold" unless path.file?
 
           steep_file_path = path.absolute? ? path : Pathname.pwd + path
-          Project.new(base_dir: steep_file_path.parent).tap do |project|
+          Project.new(steepfile_path: steep_file_path).tap do |project|
             Project::DSL.parse(project, path.read, filename: path.to_s)
           end
         end

data/lib/steep/drivers/vendor.rb

@@ -20,7 +20,7 @@ module Steep
       def run
         stdout.puts "Vendoring into #{vendor_dir}..."
 
-        vendorer = Ruby::Signature::Vendorer.new(vendor_dir: vendor_dir)
+        vendorer = RBS::Vendorer.new(vendor_dir: vendor_dir)
 
         if clean_before
           stdout.puts "  Cleaning directory..."
@@ -32,7 +32,7 @@ module Steep
 
         if defined?(Bundler)
           Bundler.locked_gems.specs.each do |spec|
-            if Ruby::Signature::EnvironmentLoader.gem_sig_path(spec.name, spec.version.to_s).directory?
+            if RBS::EnvironmentLoader.gem_sig_path(spec.name, spec.version.to_s).directory?
               stdout.puts "  Vendoring rubygem: #{spec.full_name}..."
               vendorer.gem! spec.name, spec.version.to_s
             end

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(dirs)
+        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::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)
 
-            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.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/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
@@ -99,10 +101,11 @@ module Steep
 
         items = []
 
+        context = typing.context_at(line: position.line, column: position.column)
+
         case
         when node.type == :send && node.children[0] == nil && at_end?(position, of: node.loc.selector)
           # foo ←
-          context = typing.context_of(node: node)
           prefix = node.children[1].to_s
 
           method_items_for_receiver_type(context.self_type,
@@ -114,12 +117,10 @@ module Steep
 
         when node.type == :lvar && at_end?(position, of: node.loc)
           # foo ← (lvar)
-          context = typing.context_of(node: node)
           local_variable_items_for_context(context, position: position, prefix: node.children[0].name.to_s, items: items)
 
         when node.type == :send && node.children[0] && at_end?(position, of: node.loc.selector)
           # foo.ba ←
-          context = typing.context_of(node: node)
           receiver_type = case (type = typing.type_of(node: node.children[0]))
                           when AST::Types::Self
                             context.self_type
@@ -136,7 +137,6 @@ module Steep
 
         when node.type == :const && node.children[0] == nil && at_end?(position, of: node.loc)
           # Foo ← (const)
-          context = typing.context_of(node: node)
           prefix = node.children[1].to_s
 
           method_items_for_receiver_type(context.self_type,
@@ -147,7 +147,6 @@ module Steep
 
         when node.type == :send && at_end?(position, of: node.loc.dot)
           # foo.← ba
-          context = typing.context_of(node: node)
           receiver_type = case (type = typing.type_of(node: node.children[0]))
                           when AST::Types::Self
                             context.self_type
@@ -163,12 +162,9 @@ module Steep
 
         when node.type == :ivar && at_end?(position, of: node.loc)
           # @fo ←
-          context = typing.context_of(node: node)
           instance_variable_items_for_context(context, position: position, prefix: node.children[0].to_s, items: items)
 
         else
-          context = typing.context_of(node: node)
-
           method_items_for_receiver_type(context.self_type,
                                          include_private: true,
                                          prefix: "",
@@ -190,7 +186,7 @@ module Steep
         return [] unless node
 
         if at_end?(shift_pos, of: node.loc)
-          context = typing.context_of(node: node)
+          context = typing.context_at(line: position.line, column: position.column)
           receiver_type = case (type = typing.type_of(node: node))
                           when AST::Types::Self
                             context.self_type
@@ -218,7 +214,7 @@ module Steep
 
         return [] unless node
 
-        context = typing.context_of(node: node)
+        context = typing.context_at(line: position.line, column: position.column)
         items = []
         instance_variable_items_for_context(context, prefix: "", position: position, items: items)
         items
@@ -263,7 +259,7 @@ module Steep
 
       def local_variable_items_for_context(context, position:, prefix:, items:)
         range = range_for(position, prefix: prefix)
-        context.type_env.lvar_types.each do |name, type|
+        context.lvar_env.each do |name, type|
           if name.to_s.start_with?(prefix)
             items << LocalVariableItem.new(identifier: name,
                                            range: range,

data/lib/steep/project/dsl.rb

@@ -9,6 +9,7 @@ module Steep
         attr_reader :ignored_sources
         attr_reader :no_builtin
         attr_reader :vendor_dir
+        attr_reader :strictness_level
 
         def initialize(name, sources: [], libraries: [], signatures: [], ignored_sources: [])
           @name = name
@@ -17,6 +18,7 @@ module Steep
           @signatures = signatures
           @ignored_sources = ignored_sources
           @vendor_dir = nil
+          @strictness_level = :default
         end
 
         def initialize_copy(other)
@@ -26,6 +28,7 @@ module Steep
           @signatures = other.signatures.dup
           @ignored_sources = other.ignored_sources.dup
           @vendor_dir = other.vendor_dir
+          @strictness_level = other.strictness_level
         end
 
         def check(*args)
@@ -40,6 +43,10 @@ module Steep
           libraries.push(*args)
         end
 
+        def typing_options(level)
+          @strictness_level = level
+        end
+
         def signature(*args)
           signatures.push(*args)
         end
@@ -114,6 +121,13 @@ module Steep
           options: Options.new.tap do |options|
             options.libraries.push(*target.libraries)
 
+            case target.strictness_level
+            when :strict
+              options.apply_strict_typing_options!
+            when :lenient
+              options.apply_lenient_typing_options!
+            end
+
             case target.vendor_dir
             when Array
               options.vendored_stdlib_path = target.vendor_dir[0]