steep 0.13.0 → 0.16.2

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

@@ -0,0 +1,298 @@
+module Steep
+  class Project
+    class CompletionProvider
+      Position = Struct.new(:line, :column, keyword_init: true) do
+        def -(size)
+          Position.new(line: line, column: column - size)
+        end
+      end
+      Range = Struct.new(:start, :end, keyword_init: true)
+
+      InstanceVariableItem = Struct.new(:identifier, :range, :type, keyword_init: true)
+      LocalVariableItem = Struct.new(:identifier, :range, :type, keyword_init: true)
+      MethodNameItem = Struct.new(:identifier, :range, :definition, :method_type, keyword_init: true)
+
+      attr_reader :source_text
+      attr_reader :path
+      attr_reader :subtyping
+      attr_reader :modified_text
+      attr_reader :source
+      attr_reader :typing
+
+      def initialize(source_text:, path:, subtyping:)
+        @source_text = source_text
+        @path = path
+        @subtyping = subtyping
+      end
+
+      def type_check!(text)
+        @modified_text = text
+
+        Steep.measure "parsing" do
+          @source = SourceFile.parse(text, path: path, factory: subtyping.factory)
+        end
+
+        Steep.measure "typechecking" do
+          @typing = SourceFile.type_check(source, subtyping: subtyping)
+        end
+      end
+
+      def run(line:, column:)
+        source_text = self.source_text.dup
+        index = index_for(source_text, line:line, column: column)
+        possible_trigger = source_text[index-1]
+
+        Steep.logger.debug "possible_trigger: #{possible_trigger.inspect}"
+
+        position = Position.new(line: line, column: column)
+
+        begin
+          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
+            items_for_trigger(position: position)
+          end
+
+        rescue Parser::SyntaxError => exn
+          Steep.logger.error "recovering syntax error: #{exn.inspect}"
+          case possible_trigger
+          when "."
+            source_text[index-1] = " "
+            type_check!(source_text)
+            items_for_dot(position: position)
+          when "@"
+            source_text[index-1] = " "
+            type_check!(source_text)
+            items_for_atmark(position: position)
+          else
+            []
+          end
+        end
+      end
+
+      def range_from_loc(loc)
+        Range.new(
+          start: Position.new(line: loc.line, column: loc.column),
+          end: Position.new(line: loc.last_line, column: loc.last_line)
+        )
+      end
+
+      def at_end?(pos, of:)
+        of.last_line == pos.line && of.last_column == pos.column
+      end
+
+      def range_for(position, prefix: "")
+        if prefix.empty?
+          Range.new(start: position, end: position)
+        else
+          Range.new(start: position - prefix.size, end: position)
+        end
+      end
+
+      def items_for_trigger(position:)
+        node, *parents = source.find_nodes(line: position.line, column: position.column)
+        node ||= source.node
+
+        return [] unless node
+
+        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 ←
+          prefix = node.children[1].to_s
+
+          method_items_for_receiver_type(context.self_type,
+                                         include_private: true,
+                                         prefix: prefix,
+                                         position: position,
+                                         items: items)
+          local_variable_items_for_context(context, position: position, prefix: prefix, items: items)
+
+        when node.type == :lvar && at_end?(position, of: node.loc)
+          # foo ← (lvar)
+          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 ←
+          receiver_type = case (type = typing.type_of(node: node.children[0]))
+                          when AST::Types::Self
+                            context.self_type
+                          else
+                            type
+                          end
+          prefix = node.children[1].to_s
+
+          method_items_for_receiver_type(receiver_type,
+                                         include_private: false,
+                                         prefix: prefix,
+                                         position: position,
+                                         items: items)
+
+        when node.type == :const && node.children[0] == nil && at_end?(position, of: node.loc)
+          # Foo ← (const)
+          prefix = node.children[1].to_s
+
+          method_items_for_receiver_type(context.self_type,
+                                         include_private: false,
+                                         prefix: prefix,
+                                         position: position,
+                                         items: items)
+
+        when node.type == :send && at_end?(position, of: node.loc.dot)
+          # foo.← ba
+          receiver_type = case (type = typing.type_of(node: node.children[0]))
+                          when AST::Types::Self
+                            context.self_type
+                          else
+                            type
+                          end
+
+          method_items_for_receiver_type(receiver_type,
+                                         include_private: false,
+                                         prefix: "",
+                                         position: position,
+                                         items: items)
+
+        when node.type == :ivar && at_end?(position, of: node.loc)
+          # @fo ←
+          instance_variable_items_for_context(context, position: position, prefix: node.children[0].to_s, items: items)
+
+        else
+          method_items_for_receiver_type(context.self_type,
+                                         include_private: true,
+                                         prefix: "",
+                                         position: position,
+                                         items: items)
+          local_variable_items_for_context(context, position: position, prefix: "", items: items)
+          instance_variable_items_for_context(context, position: position, prefix: "", items: items)
+        end
+
+        items
+      end
+
+      def items_for_dot(position:)
+        # foo. ←
+        shift_pos = position-1
+        node, *parents = source.find_nodes(line: shift_pos.line, column: shift_pos.column)
+        node ||= source.node
+
+        return [] unless node
+
+        if at_end?(shift_pos, of: node.loc)
+          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
+                          else
+                            type
+                          end
+
+          items = []
+          method_items_for_receiver_type(receiver_type,
+                                         include_private: false,
+                                         prefix: "",
+                                         position: position,
+                                         items: items)
+          items
+        else
+          []
+        end
+      end
+
+      def items_for_atmark(position:)
+        # @ ←
+        shift_pos = position-1
+        node, *parents = source.find_nodes(line: shift_pos.line, column: shift_pos.column)
+        node ||= source.node
+
+        return [] unless node
+
+        context = typing.context_at(line: position.line, column: position.column)
+        items = []
+        instance_variable_items_for_context(context, prefix: "", position: position, items: items)
+        items
+      end
+
+      def method_items_for_receiver_type(type, include_private:, prefix:, position:, items:)
+        range = range_for(position, prefix: prefix)
+        definition = case type
+                     when AST::Types::Name::Instance
+                       type_name = subtyping.factory.type_name_1(type.name)
+                       subtyping.factory.definition_builder.build_instance(type_name)
+                     when AST::Types::Name::Class, AST::Types::Name::Module
+                       type_name = subtyping.factory.type_name_1(type.name)
+                       subtyping.factory.definition_builder.build_singleton(type_name)
+                     when AST::Types::Name::Interface
+                       type_name = subtyping.factory.type_name_1(type.name)
+                       interface = subtyping.factory.env.find_class(type_name)
+                       subtyping.factory.definition_builder.build_interface(type_name, interface)
+                     end
+
+        if definition
+          definition.methods.each do |name, method|
+            if include_private || method.public?
+              if name.to_s.start_with?(prefix)
+                if word_name?(name.to_s)
+                  method.method_types.each do |method_type|
+                    items << MethodNameItem.new(identifier: name,
+                                                range: range,
+                                                definition: method,
+                                                method_type: method_type)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def word_name?(name)
+        name =~ /\w/
+      end
+
+      def local_variable_items_for_context(context, position:, prefix:, items:)
+        range = range_for(position, prefix: prefix)
+        context.lvar_env.each do |name, type|
+          if name.to_s.start_with?(prefix)
+            items << LocalVariableItem.new(identifier: name,
+                                           range: range,
+                                           type: type)
+          end
+        end
+      end
+
+      def instance_variable_items_for_context(context, position:, prefix:, items:)
+        range = range_for(position, prefix: prefix)
+        context.type_env.ivar_types.map do |name, type|
+          if name.to_s.start_with?(prefix)
+            items << InstanceVariableItem.new(identifier: name,
+                                              range: range,
+                                              type: type)
+          end
+        end
+      end
+
+      def index_for(string, line:, column:)
+        index = 0
+
+        string.each_line.with_index do |s, i|
+          if i+1 == line
+            index += column
+            break
+          else
+            index += s.size
+          end
+        end
+
+        index
+      end
+    end
+  end
+end