steep 0.29.0 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d09c66d40509db4956625f6be82477c4cda1b375d4cc37ebc2b4fdfdfdd971f
-  data.tar.gz: bfe074e9fc6e833faa4442f718e2bade7e54a5b6921fd8cf63465972ec39ced5
+  metadata.gz: b5293cbc87834cee36e50cb66bab84e466a5182c1e868732b7bd3e685b2bd954
+  data.tar.gz: 7794e42573b5ac04c74780824213cfbe1ca255f1feaa4465a1066377d2647e0b
 SHA512:
-  metadata.gz: 05d54b1565ccf9189d335163d952d075bd6f7b3a08c26362efb815c3d19cfd2ffa2eb13e124a5dc7a4a5f1343a6fbbe5694ed3d6000a4fe37f3ace4cb2d7c1d5
-  data.tar.gz: 2661d5a8a5273e5c4341b27fd78a5f57c296c31663f16d46bf8de39ea1af40b827bfdf48f9266e071a37b1fe395a58ec716149d88656cf983587ecbe89fa24e6
+  metadata.gz: e723bf77a7452e0696c38d6d1797e71f246fb97d1b1f18082ba21b8eadb8174d6bcc4deda872898b5f39d162b91173c413cacfa28175018517170f8f2568bd70
+  data.tar.gz: 38dbe78df43706fe33d5350ad04524c25606955bcba5397ad18690717a60c59d361485ad2d5d3077787336d23902bd91ba9fa5b31e1933a93d1fe32747837688

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## master
 
+## 0.30.0 (2020-10-03)
+
+* Let top-level defs be methods of Object ([#227](https://github.com/soutaro/steep/pull/227))
+* Fix error caused by attribute definitions ([#228](https://github.com/soutaro/steep/pull/228))
+* LSP worker improvements ([#222](https://github.com/soutaro/steep/pull/222), [#223](https://github.com/soutaro/steep/pull/223), [#226](https://github.com/soutaro/steep/pull/226), [#229](https://github.com/soutaro/steep/pull/229))
+
 ## 0.29.0 (2020-09-28)
 
 * Implement reasoning on `is_a?`, `nil?`, and `===` methods. ([#218](https://github.com/soutaro/steep/pull/218))

data/lib/steep.rb

@@ -83,7 +83,8 @@ require "steep/server/interaction_worker"
 require "steep/server/master"
 
 require "steep/project"
-require "steep/project/file"
+require "steep/project/signature_file"
+require "steep/project/source_file"
 require "steep/project/options"
 require "steep/project/target"
 require "steep/project/dsl"

data/lib/steep/ast/types/factory.rb

@@ -344,41 +344,43 @@ module Steep
             defined_in = method_def.defined_in
             member = method_def.member
 
-            case
-            when defined_in == RBS::BuiltinNames::Object.name && member.instance?
-              case method_name
-              when :is_a?, :kind_of?, :instance_of?
-                return method_type.with(
-                  return_type: AST::Types::Logic::ReceiverIsArg.new(location: method_type.return_type.location)
-                )
-              when :nil?
-                return method_type.with(
-                  return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.return_type.location)
-                )
-              end
+            if member.is_a?(RBS::AST::Members::MethodDefinition)
+              case
+              when defined_in == RBS::BuiltinNames::Object.name && member.instance?
+                case method_name
+                when :is_a?, :kind_of?, :instance_of?
+                  return method_type.with(
+                    return_type: AST::Types::Logic::ReceiverIsArg.new(location: method_type.return_type.location)
+                  )
+                when :nil?
+                  return method_type.with(
+                    return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.return_type.location)
+                  )
+                end
 
-            when defined_in == AST::Builtin::NilClass.module_name && member.instance?
-              case method_name
-              when :nil?
-                return method_type.with(
-                  return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.return_type.location)
-                )
-              end
+              when defined_in == AST::Builtin::NilClass.module_name && member.instance?
+                case method_name
+                when :nil?
+                  return method_type.with(
+                    return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.return_type.location)
+                  )
+                end
 
-            when defined_in == RBS::BuiltinNames::BasicObject.name && member.instance?
-              case method_name
-              when :!
-                return method_type.with(
-                  return_type: AST::Types::Logic::Not.new(location: method_type.return_type.location)
-                )
-              end
+              when defined_in == RBS::BuiltinNames::BasicObject.name && member.instance?
+                case method_name
+                when :!
+                  return method_type.with(
+                    return_type: AST::Types::Logic::Not.new(location: method_type.return_type.location)
+                  )
+                end
 
-            when defined_in == RBS::BuiltinNames::Module.name && member.instance?
-              case method_name
-              when :===
-                return method_type.with(
-                  return_type: AST::Types::Logic::ArgIsReceiver.new(location: method_type.return_type.location)
-                )
+              when defined_in == RBS::BuiltinNames::Module.name && member.instance?
+                case method_name
+                when :===
+                  return method_type.with(
+                    return_type: AST::Types::Logic::ArgIsReceiver.new(location: method_type.return_type.location)
+                  )
+                end
               end
             end
           end

data/lib/steep/project.rb

@@ -24,6 +24,31 @@ module Steep
       (base_dir + path).cleanpath
     end
 
+    def target_for_source_path(path)
+      targets.find do |target|
+        target.possible_source_file?(path)
+      end
+    end
+
+    def targets_for_path(path)
+      if target = target_for_source_path(path)
+        [target, []]
+      else
+        [
+          nil,
+          targets.select do |target|
+            target.possible_signature_file?(path)
+          end
+        ]
+      end
+    end
+
+    def all_source_files
+      targets.each.with_object(Set[]) do |target, paths|
+        paths.merge(target.source_files.keys)
+      end
+    end
+
     def type_of_node(path:, line:, column:)
       source_file = targets.map {|target| target.source_files[path] }.compact[0]
 

data/lib/steep/project/file_loader.rb

@@ -28,15 +28,20 @@ module Steep
       end
 
       def load_sources(command_line_patterns)
+        loaded_paths = Set[]
+
         project.targets.each do |target|
           Steep.logger.tagged "target=#{target.name}" do
             target_patterns = command_line_patterns.empty? ? target.source_patterns : command_line_patterns
 
-            each_path_in_patterns target_patterns, ".rb" do |path|
+            each_path_in_patterns(target_patterns, ".rb") do |path|
               if target.possible_source_file?(path)
-                unless target.source_file?(path)
+                if loaded_paths.include?(path)
+                  Steep.logger.warn { "Skipping #{target} while loading #{path}... (Already loaded to another target.)" }
+                else
                   Steep.logger.info { "Adding source file: #{path}" }
                   target.add_source path, project.absolute_path(path).read
+                  loaded_paths << path
                 end
               end
             end

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/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
@@ -27,19 +29,24 @@ module Steep
       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
@@ -47,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
@@ -54,6 +62,7 @@ module Steep
         end
 
         Thread.new do
+          Steep.logger.formatter.push_tags(*tags, "from-client")
           reader.read do |request|
             process_message_from_client(request)
           end
@@ -97,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(
@@ -112,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()

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/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.29.0"
+  VERSION = "0.30.0"
 end

data/smoke/toplevel/Steepfile

@@ -0,0 +1,5 @@
+target :test do
+  typing_options :strict
+  check "*.rb"
+  signature "*.rbs"
+end

data/smoke/toplevel/a.rb

@@ -0,0 +1,4 @@
+# !expects MethodBodyTypeMismatch: method=fizz_buzz, expected=::String, actual=nil
+def fizz_buzz(n)
+  nil
+end

data/smoke/toplevel/a.rbs

@@ -0,0 +1,3 @@
+class Object
+  def fizz_buzz: (Integer) -> String
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.29.0
+  version: 0.30.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-09-28 00:00:00.000000000 Z
+date: 2020-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -187,10 +187,11 @@ files:
 - lib/steep/project.rb
 - lib/steep/project/completion_provider.rb
 - lib/steep/project/dsl.rb
-- lib/steep/project/file.rb
 - lib/steep/project/file_loader.rb
 - lib/steep/project/hover_content.rb
 - lib/steep/project/options.rb
+- lib/steep/project/signature_file.rb
+- lib/steep/project/source_file.rb
 - lib/steep/project/target.rb
 - lib/steep/server/base_worker.rb
 - lib/steep/server/code_worker.rb
@@ -347,6 +348,9 @@ files:
 - smoke/super/Steepfile
 - smoke/super/a.rb
 - smoke/super/a.rbs
+- smoke/toplevel/Steepfile
+- smoke/toplevel/a.rb
+- smoke/toplevel/a.rbs
 - smoke/type_case/Steepfile
 - smoke/type_case/a.rb
 - smoke/yield/Steepfile