steep 0.29.0 → 0.33.0

data/lib/steep/project/signature_file.rb

@@ -0,0 +1,33 @@
+module Steep
+  class Project
+    class SignatureFile
+      attr_reader :path
+      attr_reader :content
+      attr_reader :content_updated_at
+
+      attr_reader :status
+
+      ParseErrorStatus = Struct.new(:error, :timestamp, keyword_init: true)
+      DeclarationsStatus = Struct.new(:declarations, :timestamp, keyword_init: true)
+
+      def initialize(path:)
+        @path = path
+        self.content = ""
+      end
+
+      def content=(content)
+        @content_updated_at = Time.now
+        @content = content
+        @status = nil
+      end
+
+      def load!
+        buffer = RBS::Buffer.new(name: path, content: content)
+        decls = RBS::Parser.parse_signature(buffer)
+        @status = DeclarationsStatus.new(declarations: decls, timestamp: Time.now)
+      rescue RBS::Parser::SyntaxError, RBS::Parser::SemanticsError => exn
+        @status = ParseErrorStatus.new(error: exn, timestamp: Time.now)
+      end
+    end
+  end
+end

data/lib/steep/project/{file.rb → source_file.rb}

@@ -8,10 +8,10 @@ module Steep
 
       attr_accessor :status
 
-      ParseErrorStatus = Struct.new(:error, keyword_init: true)
-      AnnotationSyntaxErrorStatus = Struct.new(:error, :location, keyword_init: true)
+      ParseErrorStatus = Struct.new(:error, :timestamp, keyword_init: true)
+      AnnotationSyntaxErrorStatus = Struct.new(:error, :location, :timestamp, keyword_init: true)
       TypeCheckStatus = Struct.new(:typing, :source, :timestamp, keyword_init: true)
-      TypeCheckErrorStatus = Struct.new(:error, keyword_init: true)
+      TypeCheckErrorStatus = Struct.new(:error, :timestamp, keyword_init: true)
 
       def initialize(path:)
         @path = path
@@ -20,11 +20,9 @@ module Steep
       end
 
       def content=(content)
-        if @content != content
-          @content_updated_at = Time.now
-          @content = content
-          @status = nil
-        end
+        @content_updated_at = Time.now
+        @content = content
+        @status = nil
       end
 
       def errors
@@ -55,12 +53,14 @@ module Steep
         context = TypeInference::Context.new(
           block_context: nil,
           module_context: TypeInference::Context::ModuleContext.new(
-            instance_type: nil,
-            module_type: nil,
+            instance_type: AST::Builtin::Object.instance_type,
+            module_type: AST::Builtin::Object.module_type,
             implement_name: nil,
             current_namespace: RBS::Namespace.root,
             const_env: const_env,
-            class_name: nil
+            class_name: AST::Builtin::Object.module_name,
+            instance_definition: subtyping.factory.definition_builder.build_instance(AST::Builtin::Object.module_name),
+            module_definition: subtyping.factory.definition_builder.build_singleton(AST::Builtin::Object.module_name)
           ),
           method_context: nil,
           break_context: nil,
@@ -86,31 +86,31 @@ module Steep
 
       def type_check(subtyping, env_updated_at)
         # skip type check
-        return false if status.is_a?(TypeCheckStatus) && env_updated_at <= status.timestamp
+        return false if status && env_updated_at <= status.timestamp
+
+        now = Time.now
 
         parse(subtyping.factory) do |source|
           typing = self.class.type_check(source, subtyping: subtyping)
-          @status = TypeCheckStatus.new(
-            typing: typing,
-            source: source,
-            timestamp: Time.now
-          )
+          @status = TypeCheckStatus.new(typing: typing, source: source, timestamp: now)
         rescue RBS::NoTypeFoundError,
           RBS::NoMixinFoundError,
           RBS::NoSuperclassFoundError,
           RBS::DuplicatedMethodDefinitionError,
           RBS::InvalidTypeApplicationError => exn
           # Skip logging known signature errors (they are handled with load_signatures(validate: true))
-          @status = TypeCheckErrorStatus.new(error: exn)
+          @status = TypeCheckErrorStatus.new(error: exn, timestamp: now)
         rescue => exn
           Steep.log_error(exn)
-          @status = TypeCheckErrorStatus.new(error: exn)
+          @status = TypeCheckErrorStatus.new(error: exn, timestamp: now)
         end
 
         true
       end
 
       def parse(factory)
+        now = Time.now
+
         if status.is_a?(TypeCheckStatus)
           yield status.source
         else
@@ -118,40 +118,10 @@ module Steep
         end
       rescue AnnotationParser::SyntaxError => exn
         Steep.logger.warn { "Annotation syntax error on #{path}: #{exn.inspect}" }
-        @status = AnnotationSyntaxErrorStatus.new(error: exn, location: exn.location)
+        @status = AnnotationSyntaxErrorStatus.new(error: exn, location: exn.location, timestamp: now)
       rescue ::Parser::SyntaxError, EncodingError => exn
         Steep.logger.warn { "Source parsing error on #{path}: #{exn.inspect}" }
-        @status = ParseErrorStatus.new(error: exn)
-      end
-    end
-
-    class SignatureFile
-      attr_reader :path
-      attr_reader :content
-      attr_reader :content_updated_at
-
-      attr_reader :status
-
-      ParseErrorStatus = Struct.new(:error, keyword_init: true)
-      DeclarationsStatus = Struct.new(:declarations, keyword_init: true)
-
-      def initialize(path:)
-        @path = path
-        self.content = ""
-      end
-
-      def content=(content)
-        @content_updated_at = Time.now
-        @content = content
-        @status = nil
-      end
-
-      def load!
-        buffer = RBS::Buffer.new(name: path, content: content)
-        decls = RBS::Parser.parse_signature(buffer)
-        @status = DeclarationsStatus.new(declarations: decls)
-      rescue RBS::Parser::SyntaxError, RBS::Parser::SemanticsError => exn
-        @status = ParseErrorStatus.new(error: exn)
+        @status = ParseErrorStatus.new(error: exn, timestamp: now)
       end
     end
   end

data/lib/steep/project/target.rb

@@ -29,9 +29,15 @@ module Steep
         @signature_files = {}
       end
 
-      def add_source(path, content)
+      def add_source(path, content = "")
         file = SourceFile.new(path: path)
-        file.content = content
+
+        if block_given?
+          file.content = yield
+        else
+          file.content = content
+        end
+
         source_files[path] = file
       end
 
@@ -39,14 +45,22 @@ module Steep
         source_files.delete(path)
       end
 
-      def update_source(path, content)
+      def update_source(path, content = nil)
         file = source_files[path]
-        file.content = content
+        if block_given?
+          file.content = yield(file.content)
+        else
+          file.content = content || file.content
+        end
       end
 
-      def add_signature(path, content)
+      def add_signature(path, content = "")
         file = SignatureFile.new(path: path)
-        file.content = content
+        if block_given?
+          file.content = yield
+        else
+          file.content = content
+        end
         signature_files[path] = file
       end
 
@@ -54,9 +68,13 @@ module Steep
         signature_files.delete(path)
       end
 
-      def update_signature(path, content)
+      def update_signature(path, content = nil)
         file = signature_files[path]
-        file.content = content
+        if block_given?
+          file.content = yield(file.content)
+        else
+          file.content = content || file.content
+        end
       end
 
       def source_file?(path)
@@ -115,6 +133,7 @@ module Steep
                     when TypeCheckStatus
                       status.timestamp
                     end
+        now = Time.now
 
         updated_files = []
 
@@ -151,11 +170,11 @@ module Steep
                 validator.validate()
 
                 if validator.no_error?
-                  yield env, check, Time.now
+                  yield env, check, now
                 else
                   @status = SignatureValidationErrorStatus.new(
                     errors: validator.each_error.to_a,
-                    timestamp: Time.now
+                    timestamp: now
                   )
                 end
               else
@@ -169,11 +188,11 @@ module Steep
                     location: exn.decls[0].location
                   )
                 ],
-                timestamp: Time.now
+                timestamp: now
               )
             rescue => exn
               Steep.log_error exn
-              @status = SignatureOtherErrorStatus.new(error: exn, timestamp: Time.now)
+              @status = SignatureOtherErrorStatus.new(error: exn, timestamp: now)
             end
           end
 

data/lib/steep/server/code_worker.rb

@@ -5,47 +5,32 @@ module Steep
 
       include Utils
 
-      attr_reader :target_files
+      attr_reader :typecheck_paths
       attr_reader :queue
 
       def initialize(project:, reader:, writer:, queue: Queue.new)
         super(project: project, reader: reader, writer: writer)
 
-        @target_files = {}
+        @typecheck_paths = Set[]
         @queue = queue
       end
 
-      def enqueue_type_check(target:, path:, version: target_files[path])
-        Steep.logger.info "Enqueueing type check: #{path}(#{version})@#{target.name}..."
-        target_files[path] = version
-        queue << [path, version, target]
-      end
-
-      def each_type_check_subject(path:, version:)
-        case
-        when !(updated_targets = project.targets.select {|target| target.signature_file?(path) }).empty?
-          updated_targets.each do |target|
-            target_files.each_key do |path|
-              if target.source_file?(path)
-                yield target, path, target_files[path]
-              end
-            end
-          end
-
-        when target = project.targets.find {|target| target.source_file?(path) }
-          if target_files.key?(path)
-            yield target, path, version
-          end
-        end
+      def enqueue_type_check(target:, path:)
+        Steep.logger.info "Enqueueing type check: #{target.name}::#{path}..."
+        queue << [target, path]
       end
 
       def typecheck_file(path, target)
-        Steep.logger.info "Starting type checking: #{path}@#{target.name}..."
+        Steep.logger.info "Starting type checking: #{target.name}::#{path}..."
 
         source = target.source_files[path]
         target.type_check(target_sources: [source], validate_signatures: false)
 
-        Steep.logger.info "Finished type checking: #{path}@#{target.name}"
+        if target.status.is_a?(Project::Target::TypeCheckStatus) && target.status.type_check_sources.empty?
+          Steep.logger.debug "Skipped type checking: #{target.name}::#{path}"
+        else
+          Steep.logger.info "Finished type checking: #{target.name}::#{path}"
+        end
 
         diagnostics = source_diagnostics(source, target.options)
 
@@ -109,8 +94,8 @@ module Steep
           # Don't respond to initialize request, but start type checking.
           project.targets.each do |target|
             target.source_files.each_key do |path|
-              if target_files.key?(path)
-                enqueue_type_check(target: target, path: path, version: target_files[path])
+              if typecheck_paths.include?(path)
+                enqueue_type_check(target: target, path: path)
               end
             end
           end
@@ -118,35 +103,34 @@ module Steep
         when "workspace/executeCommand"
           if request[:params][:command] == "steep/registerSourceToWorker"
             paths = request[:params][:arguments].map {|arg| source_path(URI.parse(arg)) }
-            paths.each do |path|
-              target_files[path] = 0
-            end
+            typecheck_paths.merge(paths)
           end
 
         when "textDocument/didChange"
-          update_source(request) do |path, version|
-            if target_files.key?(path)
-              target_files[path] = version
+          update_source(request) do |path, _|
+            source_target, signature_targets = project.targets_for_path(path)
+
+            if source_target
+              if typecheck_paths.include?(path)
+                enqueue_type_check(target: source_target, path: path)
+              end
             end
-          end
 
-          path = source_path(URI.parse(request[:params][:textDocument][:uri]))
-          version = request[:params][:textDocument][:version]
-          each_type_check_subject(path: path, version: version) do |target, path, version|
-            enqueue_type_check(target: target, path: path, version: version)
+            signature_targets.each do |target|
+              target.source_files.each_key do |source_path|
+                if typecheck_paths.include?(source_path)
+                  enqueue_type_check(target: target, path: source_path)
+                end
+              end
+            end
           end
         end
       end
 
       def handle_job(job)
-        sleep 0.1
+        target, path = job
 
-        path, version, target = job
-        if !version || target_files[path] == version
-          typecheck_file(path, target)
-        else
-          Steep.logger.info "Skipping type check: #{path}@#{target.name}, queued version=#{version}, latest version=#{target_files[path]}"
-        end
+        typecheck_file(path, target)
       end
     end
   end

data/lib/steep/server/interaction_worker.rb

@@ -52,21 +52,23 @@ module Steep
 
       def response_to_hover(path:, line:, column:)
         Steep.logger.tagged "#response_to_hover" do
-          Steep.logger.debug { "path=#{path}, line=#{line}, column=#{column}" }
-
-          hover = Project::HoverContent.new(project: project)
-          content = hover.content_for(path: path, line: line+1, column: column+1)
-          if content
-            range = content.location.yield_self do |location|
-              start_position = { line: location.line - 1, character: location.column }
-              end_position = { line: location.last_line - 1, character: location.last_column }
-              { start: start_position, end: end_position }
-            end
+          Steep.measure "Generating response" do
+            Steep.logger.info { "path=#{path}, line=#{line}, column=#{column}" }
+
+            hover = Project::HoverContent.new(project: project)
+            content = hover.content_for(path: path, line: line+1, column: column+1)
+            if content
+              range = content.location.yield_self do |location|
+                start_position = { line: location.line - 1, character: location.column }
+                end_position = { line: location.last_line - 1, character: location.last_column }
+                { start: start_position, end: end_position }
+              end
 
-            LSP::Interface::Hover.new(
-              contents: { kind: "markdown", value: format_hover(content) },
-              range: range
-            )
+              LSP::Interface::Hover.new(
+                contents: { kind: "markdown", value: format_hover(content) },
+                range: range
+              )
+            end
           end
         rescue Typing::UnknownNodeError => exn
           Steep.log_error exn, message: "Failed to compute hover: #{exn.inspect}"
@@ -126,33 +128,35 @@ HOVER
 
       def response_to_completion(path:, line:, column:, trigger:)
         Steep.logger.tagged("#response_to_completion") do
-          Steep.logger.info "path: #{path}, line: #{line}, column: #{column}, trigger: #{trigger}"
-
-          target = project.targets.find {|target| target.source_file?(path) } or return
-          target.type_check(target_sources: [], validate_signatures: false)
-
-          case (status = target&.status)
-          when Project::Target::TypeCheckStatus
-            subtyping = status.subtyping
-            source = target.source_files[path]
+          Steep.measure "Generating response" do
+            Steep.logger.info "path: #{path}, line: #{line}, column: #{column}, trigger: #{trigger}"
+
+            target = project.target_for_source_path(path) or return
+            target.type_check(target_sources: [], validate_signatures: false)
+
+            case (status = target&.status)
+            when Project::Target::TypeCheckStatus
+              subtyping = status.subtyping
+              source = target.source_files[path]
+
+              provider = Project::CompletionProvider.new(source_text: source.content, path: path, subtyping: subtyping)
+              items = begin
+                        provider.run(line: line, column: column)
+                      rescue Parser::SyntaxError
+                        []
+                      end
+
+              completion_items = items.map do |item|
+                format_completion_item(item)
+              end
 
-            provider = Project::CompletionProvider.new(source_text: source.content, path: path, subtyping: subtyping)
-            items = begin
-                      provider.run(line: line, column: column)
-                    rescue Parser::SyntaxError
-                      []
-                    end
+              Steep.logger.debug "items = #{completion_items.inspect}"
 
-            completion_items = items.map do |item|
-              format_completion_item(item)
+              LSP::Interface::CompletionList.new(
+                is_incomplete: false,
+                items: completion_items
+              )
             end
-
-            Steep.logger.debug "items = #{completion_items.inspect}"
-
-            LSP::Interface::CompletionList.new(
-              is_incomplete: false,
-              items: completion_items
-            )
           end
         end
       end