steep 0.25.0 → 0.31.0

data/lib/steep/server/master.rb

@@ -14,6 +14,8 @@ module Steep
       attr_reader :signature_worker
       attr_reader :code_workers
 
+      include Utils
+
       def initialize(project:, reader:, writer:, interaction_worker:, signature_worker:, code_workers:, queue: Queue.new)
         @project = project
         @reader = reader
@@ -23,22 +25,28 @@ module Steep
         @signature_worker = signature_worker
         @code_workers = code_workers
         @worker_to_paths = {}
+        @shutdown_request_id = nil
       end
 
       def start
-        source_paths = project.targets.flat_map {|target| target.source_files.keys }
+        source_paths = project.all_source_files
         bin_size = (source_paths.size / code_workers.size) + 1
         source_paths.each_slice(bin_size).with_index do |paths, index|
           register_code_to_worker(paths, worker: code_workers[index])
         end
 
+        tags = Steep.logger.formatter.current_tags.dup
+        tags << "master"
+
         Thread.new do
+          Steep.logger.formatter.push_tags(*tags, "from-worker@interaction")
           interaction_worker.reader.read do |message|
             process_message_from_worker(message)
           end
         end
 
         Thread.new do
+          Steep.logger.formatter.push_tags(*tags, "from-worker@signature")
           signature_worker.reader.read do |message|
             process_message_from_worker(message)
           end
@@ -46,6 +54,7 @@ module Steep
 
         code_workers.each do |worker|
           Thread.new do
+            Steep.logger.formatter.push_tags(*tags, "from-worker@#{worker.name}")
             worker.reader.read do |message|
               process_message_from_worker(message)
             end
@@ -53,13 +62,21 @@ module Steep
         end
 
         Thread.new do
+          Steep.logger.formatter.push_tags(*tags, "from-client")
           reader.read do |request|
             process_message_from_client(request)
           end
         end
 
         while job = queue.pop
-          writer.write(job)
+          if @shutdown_request_id
+            if job[:id] == @shutdown_request_id
+              writer.write(job)
+              break
+            end
+          else
+            writer.write(job)
+          end
         end
 
         writer.io.close
@@ -89,7 +106,7 @@ module Steep
             result: LSP::Interface::InitializeResult.new(
               capabilities: LSP::Interface::ServerCapabilities.new(
                 text_document_sync: LSP::Interface::TextDocumentSyncOptions.new(
-                  change: LSP::Constant::TextDocumentSyncKind::FULL
+                  change: LSP::Constant::TextDocumentSyncKind::INCREMENTAL
                 ),
                 hover_provider: true,
                 completion_provider: LSP::Interface::CompletionOptions.new(
@@ -104,36 +121,10 @@ module Steep
           end
 
         when "textDocument/didChange"
+          update_source(message)
+
           uri = URI.parse(message[:params][:textDocument][:uri])
           path = project.relative_path(Pathname(uri.path))
-          text = message[:params][:contentChanges][0][:text]
-
-          project.targets.each do |target|
-            case
-            when target.source_file?(path)
-              if text.empty? && !path.file?
-                Steep.logger.info { "Deleting source file: #{path}..." }
-                target.remove_source(path)
-              else
-                Steep.logger.info { "Updating source file: #{path}..." }
-                target.update_source(path, text)
-              end
-            when target.possible_source_file?(path)
-              Steep.logger.info { "Adding source file: #{path}..." }
-              target.add_source(path, text)
-            when target.signature_file?(path)
-              if text.empty? && !path.file?
-                Steep.logger.info { "Deleting signature file: #{path}..." }
-                target.remove_signature(path)
-              else
-                Steep.logger.info { "Updating signature file: #{path}..." }
-                target.update_signature(path, text)
-              end
-            when target.possible_signature_file?(path)
-              Steep.logger.info { "Adding signature file: #{path}..." }
-              target.add_signature(path, text)
-            end
-          end
 
           unless registered_path?(path)
             register_code_to_worker [path], worker: least_busy_worker()
@@ -154,6 +145,7 @@ module Steep
 
         when "shutdown"
           queue << { id: id, result: nil }
+          @shutdown_request_id = id
 
         when "exit"
           queue << nil

data/lib/steep/server/utils.rb

@@ -7,23 +7,56 @@ module Steep
         project.relative_path(Pathname(uri.path))
       end
 
+      def apply_change(change, text)
+        range = change[:range]
+
+        if range
+          text = text.dup
+
+          buf = AST::Buffer.new(name: :_, content: text)
+
+          start_pos = buf.loc_to_pos(range[:start].yield_self {|pos| [pos[:line]+1, pos[:character]] })
+          end_pos = buf.loc_to_pos(range[:end].yield_self {|pos| [pos[:line]+1, pos[:character]] })
+
+          text[start_pos...end_pos] = change[:text]
+          text
+        else
+          change[:text]
+        end
+      end
+
       def update_source(request)
         path = source_path(URI.parse(request[:params][:textDocument][:uri]))
-        text = request[:params][:contentChanges][0][:text]
         version = request[:params][:textDocument][:version]
+        Steep.logger.info { "Updating source: path=#{path}, version=#{version}..." }
+
+        changes = request[:params][:contentChanges]
+
+        source_target, signature_targets = project.targets_for_path(path)
+
+        if source_target
+          changes.each do |change|
+            case
+            when source_target.source_file?(path)
+              Steep.logger.debug { "Updating source in #{source_target.name}: path=#{path}" }
+              source_target.update_source(path) {|text| apply_change(change, text) }
+            when source_target.possible_source_file?(path)
+              Steep.logger.debug { "Adding source to #{source_target.name}: path=#{path}" }
+              source_target.add_source(path, change[:text])
+            end
+          end
+        end
 
-        Steep.logger.debug "Updateing source: path=#{path}, version=#{version}, size=#{text.bytesize}"
-
-        project.targets.each do |target|
-          case
-          when target.source_file?(path)
-            target.update_source path, text
-          when target.possible_source_file?(path)
-            target.add_source path, text
-          when target.signature_file?(path)
-            target.update_signature path, text
-          when target.possible_signature_file?(path)
-            target.add_signature path, text
+        signature_targets.each do |target|
+          changes.each do |change|
+            case
+            when target.signature_file?(path)
+              Steep.logger.debug { "Updating signature in #{target.name}: path=#{path}" }
+              target.update_signature(path) {|text| apply_change(change, text) }
+            when target.possible_signature_file?(path)
+              Steep.logger.debug { "Adding signature to #{target.name}: path=#{path}" }
+              target.add_signature(path, change[:text])
+            end
           end
         end
 

data/lib/steep/server/worker_process.rb

@@ -5,13 +5,15 @@ module Steep
       attr_reader :writer
       attr_reader :stderr
 
+      attr_reader :name
       attr_reader :wait_thread
 
-      def initialize(reader:, writer:, stderr:, wait_thread:)
+      def initialize(reader:, writer:, stderr:, wait_thread:, name:)
         @reader = reader
         @writer = writer
         @stderr = stderr
         @wait_thread = wait_thread
+        @name = name
       end
 
       def self.spawn_worker(type, name:, steepfile:)
@@ -33,7 +35,7 @@ module Steep
         writer = LanguageServer::Protocol::Transport::Io::Writer.new(stdin)
         reader = LanguageServer::Protocol::Transport::Io::Reader.new(stdout)
 
-        new(reader: reader, writer: writer, stderr: stderr, wait_thread: thread)
+        new(reader: reader, writer: writer, stderr: stderr, wait_thread: thread, name: name)
       end
 
       def self.spawn_code_workers(steepfile:, count: [Etc.nprocessors-3, 1].max)

data/lib/steep/signature/validator.rb

@@ -130,19 +130,19 @@ module Steep
         yield
       rescue RBS::InvalidTypeApplicationError => exn
         @errors << Errors::InvalidTypeApplicationError.new(
-          name: factory.type_name(exn.type_name),
+          name: exn.type_name,
           args: exn.args.map {|ty| factory.type(ty) },
           params: exn.params,
           location: exn.location
         )
       rescue RBS::NoTypeFoundError, RBS::NoSuperclassFoundError, RBS::NoMixinFoundError => exn
         @errors << Errors::UnknownTypeNameError.new(
-          name: factory.type_name(exn.type_name),
+          name: exn.type_name,
           location: exn.location
         )
       rescue RBS::InvalidOverloadMethodError => exn
         @errors << Errors::InvalidMethodOverloadError.new(
-          class_name: factory.type_name(exn.type_name),
+          class_name: exn.type_name,
           method_name: exn.method_name,
           location: exn.members[0].location
         )

data/lib/steep/source.rb

@@ -38,7 +38,7 @@ module Steep
     end
 
     def self.parser
-      ::Parser::Ruby25.new(Builder.new).tap do |parser|
+      ::Parser::Ruby27.new(Builder.new).tap do |parser|
         parser.diagnostics.all_errors_are_fatal = true
         parser.diagnostics.ignore_warnings = true
       end
@@ -60,7 +60,7 @@ module Steep
       _, comments, _ = yield_self do
         buffer = ::Parser::Source::Buffer.new(path.to_s)
         buffer.source = source_code
-        parser = ::Parser::Ruby25.new
+        parser = ::Parser::Ruby27.new
 
         parser.tokenize(buffer)
       end
@@ -276,6 +276,18 @@ module Steep
       end
     end
 
+    def self.map_child_nodes(node)
+      children = node.children.map do |child|
+        if child.is_a?(::AST::Node)
+          yield child
+        else
+          child
+        end
+      end
+
+      node.updated(nil, children)
+    end
+
     def annotations(block:, factory:, current_module:)
       AST::Annotation::Collection.new(
         annotations: mapping[block.__id__] || [],
@@ -316,5 +328,50 @@ module Steep
         end
       end
     end
+
+    def self.delete_defs(node, allow_list)
+      case node.type
+      when :def
+        if allow_list.include?(node)
+          node
+        else
+          node.updated(:nil, [])
+        end
+      when :defs
+        if allow_list.include?(node)
+          node
+        else
+          delete_defs(node.children[0], allow_list)
+        end
+      else
+        map_child_nodes(node) do |child|
+          delete_defs(child, allow_list)
+        end
+      end
+    end
+
+    def without_unrelated_defs(line:, column:)
+      nodes = find_nodes(line: line, column: column) || []
+      defs = Set[].compare_by_identity.merge(nodes.select {|node| node.type == :def || node.type == :defs })
+
+      node_ = Source.delete_defs(node, defs)
+
+      Source.new(path: path, node: node_, mapping: mapping)
+    end
+
+    def compact_siblings(node)
+      case node
+      when :def
+        node.updated(:nil, [])
+      when :defs
+        node.children[0]
+      when :class
+        node.updated(:class, [node.children[0], node.children[1], nil])
+      when :module
+        node.updated(:module, [node.children[0], nil])
+      else
+        node
+      end
+    end
   end
 end

data/lib/steep/subtyping/check.rb

@@ -10,8 +10,7 @@ module Steep
       end
 
       def instance_super_types(type_name, args:)
-        type_name_1 = factory.type_name_1(type_name)
-        ancestors = factory.definition_builder.one_instance_ancestors(type_name_1)
+        ancestors = factory.definition_builder.one_instance_ancestors(type_name)
 
         subst = unless args.empty?
                   args_ = args.map {|type| factory.type_1(type) }
@@ -19,7 +18,7 @@ module Steep
                 end
 
         ancestors.each_ancestor.map do |ancestor|
-          name = factory.type_name(ancestor.name)
+          name = ancestor.name
 
           case ancestor
           when RBS::Definition::Ancestor::Instance
@@ -42,9 +41,8 @@ module Steep
               )
             end
           when RBS::Definition::Ancestor::Singleton
-            AST::Types::Name::Class.new(
+            AST::Types::Name::Singleton.new(
               name: name,
-              constructor: nil,
               location: nil
             )
           end
@@ -52,11 +50,10 @@ module Steep
       end
 
       def singleton_super_types(type_name)
-        type_name_1 = factory.type_name_1(type_name)
-        ancestors = factory.definition_builder.one_singleton_ancestors(type_name_1)
+        ancestors = factory.definition_builder.one_singleton_ancestors(type_name)
 
         ancestors.each_ancestor.map do |ancestor|
-          name = factory.type_name(ancestor.name)
+          name = ancestor.name
 
           case ancestor
           when RBS::Definition::Ancestor::Instance
@@ -78,9 +75,8 @@ module Steep
               )
             end
           when RBS::Definition::Ancestor::Singleton
-            AST::Types::Name::Class.new(
+            AST::Types::Name::Singleton.new(
               name: name,
-              constructor: nil,
               location: nil
             )
           end
@@ -180,6 +176,14 @@ module Steep
               constraints: constraints
             )
 
+          when relation.super_type.is_a?(AST::Types::Var) && constraints.unknown?(relation.super_type.name)
+            constraints.add(relation.super_type.name, sub_type: relation.sub_type)
+            success(constraints: constraints)
+
+          when relation.sub_type.is_a?(AST::Types::Var) && constraints.unknown?(relation.sub_type.name)
+            constraints.add(relation.sub_type.name, super_type: relation.super_type)
+            success(constraints: constraints)
+
           when relation.sub_type.is_a?(AST::Types::Union)
             results = relation.sub_type.types.map do |sub_type|
               check(Relation.new(sub_type: sub_type, super_type: relation.super_type),
@@ -232,14 +236,6 @@ module Steep
               results.find(&:failure?)
             end
 
-          when relation.super_type.is_a?(AST::Types::Var) && constraints.unknown?(relation.super_type.name)
-            constraints.add(relation.super_type.name, sub_type: relation.sub_type)
-            success(constraints: constraints)
-
-          when relation.sub_type.is_a?(AST::Types::Var) && constraints.unknown?(relation.sub_type.name)
-            constraints.add(relation.sub_type.name, super_type: relation.super_type)
-            success(constraints: constraints)
-
           when relation.super_type.is_a?(AST::Types::Var) || relation.sub_type.is_a?(AST::Types::Var)
             failure(error: Result::Failure::UnknownPairError.new(relation: relation),
                     trace: trace)
@@ -266,7 +262,7 @@ module Steep
               possible_sub_types = case relation.sub_type
                                    when AST::Types::Name::Instance
                                      instance_super_types(relation.sub_type.name, args: relation.sub_type.args)
-                                   when AST::Types::Name::Class
+                                   when AST::Types::Name::Singleton
                                      singleton_super_types(relation.sub_type.name)
                                    else
                                      []
@@ -302,10 +298,9 @@ module Steep
           when relation.sub_type.is_a?(AST::Types::Tuple) && relation.super_type.is_a?(AST::Types::Tuple)
             if relation.sub_type.types.size >= relation.super_type.types.size
               pairs = relation.sub_type.types.take(relation.super_type.types.size).zip(relation.super_type.types)
-              results = pairs.flat_map do |t1, t2|
+              results = pairs.map do |t1, t2|
                 relation = Relation.new(sub_type: t1, super_type: t2)
-                [check(relation, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints),
-                 check(relation.flip, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)]
+                check(relation, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
               end
 
               if results.all?(&:success?)
@@ -395,12 +390,12 @@ module Steep
       end
 
       def definition_for_type(type)
-        type_name = factory.type_name_1(type.name)
+        type_name = type.name
 
         case type
         when AST::Types::Name::Instance
           factory.definition_builder.build_instance(type_name)
-        when AST::Types::Name::Class
+        when AST::Types::Name::Singleton
           factory.definition_builder.build_singleton(type_name)
         when AST::Types::Name::Interface
           factory.definition_builder.build_interface(type_name)
@@ -485,11 +480,7 @@ module Steep
           if sub_type.name == super_type.name && sub_type.args.size == super_type.args.size
             sub_type.args.zip(super_type.args)
           end
-        when sub_type.is_a?(AST::Types::Name::Class) && super_type.is_a?(AST::Types::Name::Class)
-          if sub_type.name == super_type.name
-            []
-          end
-        when sub_type.is_a?(AST::Types::Name::Module) && super_type.is_a?(AST::Types::Name::Module)
+        when sub_type.is_a?(AST::Types::Name::Singleton) && super_type.is_a?(AST::Types::Name::Singleton)
           if sub_type.name == super_type.name
             []
           end
@@ -536,29 +527,24 @@ module Steep
 
       def check_method(name, sub_method, super_method, self_type:, assumption:, trace:, constraints:)
         trace.method name, sub_method, super_method do
-          case
-          when sub_method.overload? && super_method.overload?
-            super_method.types.map do |super_type|
-              sub_method.types.map do |sub_type|
-                check_generic_method_type name,
-                                          sub_type,
-                                          super_type,
-                                          self_type: self_type,
-                                          assumption: assumption,
-                                          trace: trace,
-                                          constraints: constraints
-              end.yield_self do |results|
-                results.find(&:success?) || results[0]
-              end
+          super_method.method_types.map do |super_type|
+            sub_method.method_types.map do |sub_type|
+              check_generic_method_type name,
+                                        sub_type,
+                                        super_type,
+                                        self_type: self_type,
+                                        assumption: assumption,
+                                        trace: trace,
+                                        constraints: constraints
             end.yield_self do |results|
-              if results.all?(&:success?) || sub_method.incompatible?
-                success constraints: constraints
-              else
-                results.select(&:failure?).last
-              end
+              results.find(&:success?) || results[0]
+            end
+          end.yield_self do |results|
+            if results.all?(&:success?)
+              success constraints: constraints
+            else
+              results.select(&:failure?).last
             end
-          else
-            raise "aaaaaaaaaaaaaa"
           end
         end
       end