steep 0.40.0 → 0.44.0

data/lib/steep/index/signature_symbol_provider.rb

@@ -4,10 +4,14 @@ module Steep
       LSP = LanguageServer::Protocol
       SymbolInformation = Struct.new(:name, :kind, :container_name, :location, keyword_init: true)
 
+      attr_reader :project
       attr_reader :indexes
+      attr_reader :assignment
 
-      def initialize()
+      def initialize(project:, assignment:)
         @indexes = []
+        @project = project
+        @assignment = assignment
       end
 
       def self.test_type_name(query, type_name)
@@ -33,6 +37,16 @@ module Steep
         end
       end
 
+      def assigned?(path)
+        if path.relative?
+          if project.targets.any? {|target| target.possible_signature_file?(path) }
+            path = project.absolute_path(path)
+          end
+        end
+
+        assignment =~ path
+      end
+
       def query_symbol(query)
         symbols = []
 
@@ -46,6 +60,8 @@ module Steep
               name = entry.type_name.name.to_s
 
               entry.declarations.each do |decl|
+                next unless assigned?(Pathname(decl.location.buffer.name))
+
                 case decl
                 when RBS::AST::Declarations::Class
                   symbols << SymbolInformation.new(
@@ -89,6 +105,8 @@ module Steep
               container_name = entry.method_name.type_name.relative!.to_s
 
               entry.declarations.each do |decl|
+                next unless assigned?(Pathname(decl.location.buffer.name))
+
                 case decl
                 when RBS::AST::Members::MethodDefinition
                   symbols << SymbolInformation.new(
@@ -126,6 +144,8 @@ module Steep
               next unless SignatureSymbolProvider.test_const_name(query, entry.const_name)
 
               entry.declarations.each do |decl|
+                next unless assigned?(Pathname(decl.location.buffer.name))
+
                 symbols << SymbolInformation.new(
                   name: entry.const_name.name.to_s,
                   location: decl.location,
@@ -137,6 +157,8 @@ module Steep
               next unless SignatureSymbolProvider.test_global_name(query, entry.global_name)
 
               entry.declarations.each do |decl|
+                next unless assigned?(Pathname(decl.location.buffer.name))
+
                 symbols << SymbolInformation.new(
                   name: decl.name.to_s,
                   location: decl.location,

data/lib/steep/index/source_index.rb

@@ -43,8 +43,51 @@ module Steep
         end
       end
 
+      class MethodEntry
+        attr_reader :name
+
+        attr_reader :definitions
+        attr_reader :references
+
+        def initialize(name:)
+          @name = name
+
+          @definitions = Set[].compare_by_identity
+          @references = Set[].compare_by_identity
+        end
+
+        def add_definition(node)
+          case node.type
+          when :def, :defs
+            @definitions << node
+          else
+            raise "Unexpected method definition: #{node.type}"
+          end
+
+          self
+        end
+
+        def add_reference(node)
+          case node.type
+          when :send, :block
+            @references << node
+          else
+            raise "Unexpected method reference: #{node.type}"
+          end
+
+          self
+        end
+
+        def merge!(other)
+          definitions.merge(other.definitions)
+          references.merge(other.references)
+          self
+        end
+      end
+
       attr_reader :source
       attr_reader :constant_index
+      attr_reader :method_index
 
       attr_reader :parent
       attr_reader :count
@@ -58,6 +101,7 @@ module Steep
         @count = @parent_count || 0
 
         @constant_index = {}
+        @method_index = {}
       end
 
       def new_child
@@ -72,25 +116,31 @@ module Steep
           entry.merge!(child_entry)
         end
 
+        method_index.merge!(child.method_index) do |_, entry, child_entry|
+          entry.merge!(child_entry)
+        end
+
         @count = child.count + 1
       end
 
-      def add_definition(constant:, definition:)
+      def add_definition(constant: nil, method: nil, definition:)
         @count += 1
-        entry(constant: constant).add_definition(definition)
+        entry(constant: constant, method: method).add_definition(definition)
         self
       end
 
-      def add_reference(constant:, ref:)
+      def add_reference(constant: nil, method: nil, ref:)
         @count += 1
-        entry(constant: constant).add_reference(ref)
+        entry(constant: constant, method: method).add_reference(ref)
         self
       end
 
-      def entry(constant:)
+      def entry(constant: nil, method: nil)
         case
         when constant
           constant_index[constant] ||= ConstantEntry.new(name: constant)
+        when method
+          method_index[method] ||= MethodEntry.new(name: method)
         else
           raise
         end

data/lib/steep/interface/block.rb

@@ -13,6 +13,10 @@ module Steep
         @optional
       end
 
+      def required?
+        !optional?
+      end
+
       def to_optional
         self.class.new(
           type: type,

data/lib/steep/project.rb

@@ -42,35 +42,5 @@ module Steep
         ]
       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]
-
-      if source_file
-
-        case (status = source_file.status)
-        when SourceFile::TypeCheckStatus
-          node = status.source.find_node(line: line, column: column)
-
-          type = begin
-            status.typing.type_of(node: node)
-          rescue RuntimeError
-            AST::Builtin.any_type
-          end
-
-          if block_given?
-            yield type, node
-          else
-            type
-          end
-        end
-      end
-    end
   end
 end

data/lib/steep/project/dsl.rb

@@ -120,11 +120,13 @@ module Steep
 
         target.instance_eval(&block) if block_given?
 
+        source_pattern = Pattern.new(patterns: target.sources, ignores: target.ignored_sources, ext: ".rb")
+        signature_pattern = Pattern.new(patterns: target.signatures, ext: ".rbs")
+
         Project::Target.new(
           name: target.name,
-          source_patterns: target.sources,
-          ignore_patterns: target.ignored_sources,
-          signature_patterns: target.signatures,
+          source_pattern: source_pattern,
+          signature_pattern: signature_pattern,
           options: Options.new.tap do |options|
             options.libraries.push(*target.libraries)
             options.repository_paths.push(*target.repo_paths)

data/lib/steep/project/pattern.rb

@@ -0,0 +1,56 @@
+module Steep
+  class Project
+    class Pattern
+      attr_reader :patterns
+      attr_reader :ignores
+      attr_reader :prefixes
+      attr_reader :ignore_prefixes
+      attr_reader :ext
+
+      def initialize(patterns:, ignores: [], ext:)
+        @patterns = patterns
+        @ignores = ignores
+        @ext = ext
+
+        @prefixes = patterns.map do |pat|
+          if pat == "." || pat == "./"
+            ""
+          else
+            pat.delete_prefix("./").delete_suffix(File::Separator) << File::Separator
+          end
+        end
+        @ignore_prefixes = ignores.map do |pat|
+          if pat == "." || pat == "./"
+            ""
+          else
+            pat.delete_prefix("./").delete_suffix(File::Separator) << File::Separator
+          end
+        end
+      end
+
+      def =~(path)
+        unless path.is_a?(Pathname)
+          path = Pathname(path.to_s)
+        end
+
+        match?(path) && !ignore?(path)
+      end
+
+      def match?(path)
+        test_string(path, patterns, prefixes)
+      end
+
+      def ignore?(path)
+        test_string(path, ignores, ignore_prefixes)
+      end
+
+      def test_string(path, patterns, prefixes)
+        string = path.to_s
+        extension = path.extname
+
+        patterns.any? {|pat| File.fnmatch(pat, string) } ||
+          prefixes.any? {|prefix| string.start_with?(prefix) && extension == ext }
+      end
+    end
+  end
+end

data/lib/steep/project/target.rb

@@ -4,118 +4,35 @@ module Steep
       attr_reader :name
       attr_reader :options
 
-      attr_reader :source_patterns
-      attr_reader :ignore_patterns
-      attr_reader :signature_patterns
+      attr_reader :source_pattern
+      attr_reader :signature_pattern
 
-      attr_reader :source_files
-      attr_reader :signature_files
-
-      attr_reader :status
-
-      SignatureErrorStatus = Struct.new(:timestamp, :errors, keyword_init: true)
-      TypeCheckStatus = Struct.new(:environment, :subtyping, :type_check_sources, :timestamp, keyword_init: true)
-
-      def initialize(name:, options:, source_patterns:, ignore_patterns:, signature_patterns:)
+      def initialize(name:, options:, source_pattern:, signature_pattern:)
         @name = name
         @options = options
-        @source_patterns = source_patterns
-        @ignore_patterns = ignore_patterns
-        @signature_patterns = signature_patterns
+        @source_pattern = source_pattern
+        @signature_pattern = signature_pattern
 
         @source_files = {}
         @signature_files = {}
       end
 
-      def add_source(path, content = "")
-        file = SourceFile.new(path: path)
-
-        if block_given?
-          file.content = yield
-        else
-          file.content = content
-        end
-
-        source_files[path] = file
-      end
-
-      def remove_source(path)
-        source_files.delete(path)
-      end
-
-      def update_source(path, content = nil)
-        file = source_files[path]
-        if block_given?
-          file.content = yield(file.content)
-        else
-          file.content = content || file.content
-        end
-      end
-
-      def add_signature(path, content = "")
-        file = SignatureFile.new(path: path)
-        if block_given?
-          file.content = yield
-        else
-          file.content = content
-        end
-        signature_files[path] = file
-      end
-
-      def remove_signature(path)
-        signature_files.delete(path)
-      end
-
-      def update_signature(path, content = nil)
-        file = signature_files[path]
-        if block_given?
-          file.content = yield(file.content)
-        else
-          file.content = content || file.content
-        end
-      end
-
-      def source_file?(path)
-        source_files.key?(path)
-      end
-
-      def signature_file?(path)
-        signature_files.key?(path)
-      end
-
       def possible_source_file?(path)
-        self.class.test_pattern(source_patterns, path, ext: ".rb") &&
-          !self.class.test_pattern(ignore_patterns, path, ext: ".rb")
+        source_pattern =~ path
       end
 
       def possible_signature_file?(path)
-        self.class.test_pattern(signature_patterns, path, ext: ".rbs")
-      end
-
-      def self.test_pattern(patterns, path, ext:)
-        patterns.any? do |pattern|
-          p = pattern.end_with?(File::Separator) ? pattern : pattern + File::Separator
-          p.delete_prefix!('./')
-          (path.to_s.start_with?(p) && path.extname == ext) || File.fnmatch(pattern, path.to_s)
-        end
+        signature_pattern =~ path
       end
 
-      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
+      def new_env_loader(project:)
+        Target.construct_env_loader(options: options, project: project)
       end
 
-      def self.construct_env_loader(options:)
+      def self.construct_env_loader(options:, project:)
         repo = RBS::Repository.new(no_stdlib: options.vendor_path)
         options.repository_paths.each do |path|
-          repo.add(path)
+          repo.add(project.absolute_path(path))
         end
 
         loader = RBS::EnvironmentLoader.new(
@@ -130,139 +47,6 @@ module Steep
 
         loader
       end
-
-      def environment
-        @environment ||= RBS::Environment.from_loader(Target.construct_env_loader(options: options))
-      end
-
-      def parse_signatures(timestamp:)
-        updated_signature_files = []
-
-        signature_files.each_value do |file|
-          if !timestamp || file.content_updated_at >= timestamp
-            Steep.logger.debug { "Loading #{file.path}..."}
-            updated_signature_files << file
-            file.load!()
-          end
-        end
-
-        error_sigs = signature_files.each_value.reject {|file| file.status.is_a?(SignatureFile::DeclarationsStatus) }
-
-        if error_sigs.empty?
-          yield updated_signature_files
-        else
-          errors = error_sigs.map do |file|
-            case error = file.status.error
-            when RBS::Parser::SemanticsError
-              Diagnostic::Signature::SyntaxError.new(error, location: error.location)
-            when RBS::Parser::SyntaxError
-              Diagnostic::Signature::SyntaxError.new(error, location: error.error_value.location)
-            end
-          end
-
-          @status = SignatureErrorStatus.new(
-            errors: errors,
-            timestamp: Time.now
-          )
-        end
-      end
-
-      def load_decls(now:)
-        errors = []
-        env = environment.dup
-
-        signature_files.each_value do |file|
-          raise unless file.status.is_a?(SignatureFile::DeclarationsStatus)
-
-          file.status.declarations.each do |decl|
-            env << decl
-          rescue RBS::DuplicatedDeclarationError => exn
-            errors << Diagnostic::Signature::DuplicatedDeclaration.new(
-              type_name: exn.name,
-              location: exn.decls[0].location
-            )
-          end
-        end
-
-        if errors.empty?
-          yield env.resolve_type_names
-        else
-          @status = SignatureErrorStatus.new(
-            errors: errors,
-            timestamp: now
-          )
-        end
-      end
-
-      def load_signatures(validate:)
-        timestamp = case status
-                    when TypeCheckStatus
-                      status.timestamp
-                    end
-        now = Time.now
-
-        parse_signatures(timestamp: timestamp) do |updated_signature_files|
-          if status.is_a?(TypeCheckStatus) && updated_signature_files.empty?
-            yield status.environment, status.subtyping, status.timestamp
-          else
-            load_decls(now: now) do |env|
-              definition_builder = RBS::DefinitionBuilder.new(env: env)
-              factory = AST::Types::Factory.new(builder: definition_builder)
-              check = Subtyping::Check.new(factory: factory)
-
-              if validate
-                validator = Signature::Validator.new(checker: check)
-                validator.validate()
-
-                if validator.no_error?
-                  yield env, check, now
-                else
-                  @status = SignatureErrorStatus.new(
-                    errors: validator.each_error.to_a,
-                    timestamp: now
-                  )
-                end
-              else
-                yield env, check, Time.now
-              end
-            end
-          end
-        end
-      end
-
-      def run_type_check(env, check, timestamp, target_sources: source_files.values)
-        type_check_sources = []
-
-        target_sources.each do |file|
-          Steep.logger.tagged("path=#{file.path}") do
-            if file.type_check(check, timestamp)
-              type_check_sources << file
-            end
-          end
-        end
-
-        @status = TypeCheckStatus.new(
-          environment: env,
-          subtyping: check,
-          type_check_sources: type_check_sources,
-          timestamp: timestamp
-        )
-      end
-
-      def no_error?
-        source_files.all? do |_, file|
-          file.status.is_a?(Project::SourceFile::TypeCheckStatus)
-        end
-      end
-
-      def errors
-        case status
-        when TypeCheckStatus
-          source_files.each_value.flat_map(&:errors).select { |error | options.error_to_report?(error) }
-        else
-          []
-        end
-      end
     end
   end
 end