steep 0.15.0 → 0.17.0

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/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

data/lib/steep/project/file.rb

@@ -42,7 +42,7 @@ module Steep
 
       def self.type_check(source, subtyping:)
         annotations = source.annotations(block: source.node, factory: subtyping.factory, current_module: AST::Namespace.root)
-        const_env = TypeInference::ConstantEnv.new(factory: subtyping.factory, context: nil)
+        const_env = TypeInference::ConstantEnv.new(factory: subtyping.factory, context: [AST::Namespace.root])
         type_env = TypeInference::TypeEnv.build(annotations: annotations,
                                                 subtyping: subtyping,
                                                 const_env: const_env,
@@ -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)
@@ -107,7 +110,7 @@ module Steep
                 context = status.typing.context_at(line: line, column: column)
                 method_context = context.method_context
 
-                if method_context
+                if method_context && method_context.method
                   DefinitionContent.new(
                     node: node,
                     method_name: method_context.name,

data/lib/steep/project/options.rb

@@ -37,6 +37,21 @@ module Steep
         self.allow_unknown_constant_assignment = true
         self.allow_unknown_method_calls = true
       end
+
+      def error_to_report?(error)
+        case
+        when error.is_a?(Errors::FallbackAny)
+          !allow_fallback_any
+        when error.is_a?(Errors::MethodDefinitionMissing)
+          !allow_missing_definitions
+        when error.is_a?(Errors::NoMethod)
+          !allow_unknown_method_calls
+        when error.is_a?(Errors::UnknownConstantAssigned)
+          !allow_unknown_constant_assignment
+        else
+          true
+        end
+      end
     end
   end
 end

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