steep 0.37.0 → 0.42.0

data/lib/steep/index/signature_symbol_provider.rb

@@ -0,0 +1,162 @@
+module Steep
+  module Index
+    class SignatureSymbolProvider
+      LSP = LanguageServer::Protocol
+      SymbolInformation = Struct.new(:name, :kind, :container_name, :location, keyword_init: true)
+
+      attr_reader :indexes
+
+      def initialize()
+        @indexes = []
+      end
+
+      def self.test_type_name(query, type_name)
+        case
+        when query == ""
+          true
+        else
+          type_name.to_s.upcase.include?(query.upcase)
+        end
+      end
+
+      class <<self
+        alias test_const_name test_type_name
+        alias test_global_name test_type_name
+      end
+
+      def self.test_method_name(query, method_name)
+        case
+        when query == ""
+          true
+        else
+          method_name.to_s.upcase.include?(query.upcase)
+        end
+      end
+
+      def query_symbol(query, assignment:)
+        symbols = []
+
+        indexes.each do |index|
+          index.each_entry do |entry|
+            case entry
+            when RBSIndex::TypeEntry
+              next unless SignatureSymbolProvider.test_type_name(query, entry.type_name)
+
+              container_name = entry.type_name.namespace.relative!.to_s.delete_suffix("::")
+              name = entry.type_name.name.to_s
+
+              entry.declarations.each do |decl|
+                next unless assignment =~ decl.location.buffer.name
+
+                case decl
+                when RBS::AST::Declarations::Class
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: decl.location,
+                    kind: LSP::Constant::SymbolKind::CLASS,
+                    container_name: container_name
+                  )
+                when RBS::AST::Declarations::Module
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: decl.location,
+                    kind: LSP::Constant::SymbolKind::MODULE,
+                    container_name: container_name
+                  )
+                when RBS::AST::Declarations::Interface
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: decl.location,
+                    kind: LSP::Constant::SymbolKind::INTERFACE,
+                    container_name: container_name
+                  )
+                when RBS::AST::Declarations::Alias
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: decl.location,
+                    kind: LSP::Constant::SymbolKind::ENUM,
+                    container_name: container_name
+                  )
+                end
+              end
+            when RBSIndex::MethodEntry
+              next unless SignatureSymbolProvider.test_method_name(query, entry.method_name)
+
+              name = case entry.method_name
+                     when InstanceMethodName
+                       "##{entry.method_name.method_name}"
+                     when SingletonMethodName
+                       ".#{entry.method_name.method_name}"
+                     end
+              container_name = entry.method_name.type_name.relative!.to_s
+
+              entry.declarations.each do |decl|
+                next unless assignment =~ decl.location.buffer.name
+
+                case decl
+                when RBS::AST::Members::MethodDefinition
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: decl.location,
+                    kind: LSP::Constant::SymbolKind::METHOD,
+                    container_name: container_name
+                  )
+                when RBS::AST::Members::Alias
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: decl.location,
+                    kind: LSP::Constant::SymbolKind::METHOD,
+                    container_name: container_name
+                  )
+                when RBS::AST::Members::AttrAccessor, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: decl.location,
+                    kind: LSP::Constant::SymbolKind::PROPERTY,
+                    container_name: container_name
+                  )
+
+                  if decl.ivar_name
+                    symbols << SymbolInformation.new(
+                      name: decl.ivar_name.to_s,
+                      location: decl.location,
+                      kind: LSP::Constant::SymbolKind::FIELD,
+                      container_name: container_name
+                    )
+                  end
+                end
+              end
+            when RBSIndex::ConstantEntry
+              next unless SignatureSymbolProvider.test_const_name(query, entry.const_name)
+
+              entry.declarations.each do |decl|
+                next unless assignment =~ decl.location.buffer.name
+
+                symbols << SymbolInformation.new(
+                  name: entry.const_name.name.to_s,
+                  location: decl.location,
+                  kind: LSP::Constant::SymbolKind::CONSTANT,
+                  container_name: entry.const_name.namespace.relative!.to_s.delete_suffix("::")
+                )
+              end
+            when RBSIndex::GlobalEntry
+              next unless SignatureSymbolProvider.test_global_name(query, entry.global_name)
+
+              entry.declarations.each do |decl|
+                next unless assignment =~ decl.location.buffer.name
+
+                symbols << SymbolInformation.new(
+                  name: decl.name.to_s,
+                  location: decl.location,
+                  kind: LSP::Constant::SymbolKind::VARIABLE
+                )
+              end
+            end
+          end
+        end
+
+        symbols.uniq {|symbol| [symbol.name, symbol.location] }.sort_by {|symbol| symbol.name.to_s }
+      end
+    end
+  end
+end

data/lib/steep/index/source_index.rb

@@ -0,0 +1,100 @@
+module Steep
+  module Index
+    class SourceIndex
+      class ConstantEntry
+        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 :casgn, :class, :module
+            @definitions << node
+          else
+            raise "Unexpected constant definition: #{node.type}"
+          end
+
+          self
+        end
+
+        def add_reference(node)
+          case node.type
+          when :const
+            @references << node
+          else
+            raise "Unexpected constant 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 :parent
+      attr_reader :count
+      attr_reader :parent_count
+
+      def initialize(source:, parent: nil)
+        @source = source
+        @parent = parent
+        @parent_count = parent&.count
+
+        @count = @parent_count || 0
+
+        @constant_index = {}
+      end
+
+      def new_child
+        SourceIndex.new(source: source, parent: self)
+      end
+
+      def merge!(child)
+        raise unless child.parent == self
+        raise unless child.parent_count == count
+
+        constant_index.merge!(child.constant_index) do |_, entry, child_entry|
+          entry.merge!(child_entry)
+        end
+
+        @count = child.count + 1
+      end
+
+      def add_definition(constant:, definition:)
+        @count += 1
+        entry(constant: constant).add_definition(definition)
+        self
+      end
+
+      def add_reference(constant:, ref:)
+        @count += 1
+        entry(constant: constant).add_reference(ref)
+        self
+      end
+
+      def entry(constant:)
+        case
+        when constant
+          constant_index[constant] ||= ConstantEntry.new(name: constant)
+        else
+          raise
+        end
+      end
+    end
+  end
+end

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

@@ -40,13 +40,13 @@ module Steep
 
       def error_to_report?(error)
         case
-        when error.is_a?(Errors::FallbackAny)
+        when error.is_a?(Diagnostic::Ruby::FallbackAny)
           !allow_fallback_any
-        when error.is_a?(Errors::MethodDefinitionMissing)
+        when error.is_a?(Diagnostic::Ruby::MethodDefinitionMissing)
           !allow_missing_definitions
-        when error.is_a?(Errors::NoMethod)
+        when error.is_a?(Diagnostic::Ruby::NoMethod)
           !allow_unknown_method_calls
-        when error.is_a?(Errors::UnknownConstantAssigned)
+        when error.is_a?(Diagnostic::Ruby::UnknownConstantAssigned)
           !allow_unknown_constant_assignment
         else
           true

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,114 +4,29 @@ 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
-
-      SignatureSyntaxErrorStatus = Struct.new(:timestamp, :errors, keyword_init: true)
-      SignatureValidationErrorStatus = Struct.new(:timestamp, :errors, keyword_init: true)
-      SignatureOtherErrorStatus = Struct.new(:timestamp, :error, 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")
+        signature_pattern =~ path
       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
-      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
+        Target.construct_env_loader(options: options)
       end
 
       def self.construct_env_loader(options:)
@@ -132,126 +47,6 @@ module Steep
 
         loader
       end
-
-      def environment
-        @environment ||= RBS::Environment.from_loader(Target.construct_env_loader(options: options))
-      end
-
-      def load_signatures(validate:)
-        timestamp = case status
-                    when TypeCheckStatus
-                      status.timestamp
-                    end
-        now = Time.now
-
-        updated_files = []
-
-        signature_files.each_value do |file|
-          if !timestamp || file.content_updated_at >= timestamp
-            updated_files << file
-            file.load!()
-          end
-        end
-
-        if signature_files.each_value.all? {|file| file.status.is_a?(SignatureFile::DeclarationsStatus) }
-          if status.is_a?(TypeCheckStatus) && updated_files.empty?
-            yield status.environment, status.subtyping, status.timestamp
-          else
-            begin
-              env = environment.dup
-
-              signature_files.each_value do |file|
-                if file.status.is_a?(SignatureFile::DeclarationsStatus)
-                  file.status.declarations.each do |decl|
-                    env << decl
-                  end
-                end
-              end
-
-              env = env.resolve_type_names
-
-              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 = SignatureValidationErrorStatus.new(
-                    errors: validator.each_error.to_a,
-                    timestamp: now
-                  )
-                end
-              else
-                yield env, check, Time.now
-              end
-            rescue RBS::DuplicatedDeclarationError => exn
-              @status = SignatureValidationErrorStatus.new(
-                errors: [
-                  Signature::Errors::DuplicatedDefinitionError.new(
-                    name: exn.name,
-                    location: exn.decls[0].location
-                  )
-                ],
-                timestamp: now
-              )
-            rescue => exn
-              Steep.log_error exn
-              @status = SignatureOtherErrorStatus.new(error: exn, timestamp: now)
-            end
-          end
-
-        else
-          errors = signature_files.each_value.with_object([]) do |file, errors|
-            if file.status.is_a?(SignatureFile::ParseErrorStatus)
-              errors << file.status.error
-            end
-          end
-
-          @status = SignatureSyntaxErrorStatus.new(
-            errors: errors,
-            timestamp: Time.now
-          )
-        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