Performance improvements

Author: pkondzior

lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -41,9 +41,24 @@ def private?
       @visibility == :private
     end
 
+    #: -> bool
+    def resolved?
+      true
+    end
+
+    #: -> bool
+    def in_dependencies?
+      @in_dependencies ||= file_path && (
+        ::RubyLsp::BUNDLE_PATH && file_path.start_with?(
+          ::RubyLsp::BUNDLE_PATH, #: as !nil
+        ) ||
+        file_path.start_with?(RbConfig::CONFIG["rubylibdir"])
+      )
+    end
+
     #: -> String
     def file_name
-      if @uri.scheme == "untitled"
+      @file_name ||= if @uri.scheme == "untitled"
         @uri.opaque #: as !nil
       else
         File.basename(
@@ -54,7 +69,7 @@ def file_name
 
     #: -> String?
     def file_path
-      @uri.full_path
+      @file_path ||= @uri.full_path
     end
 
     #: -> String
@@ -373,6 +388,11 @@ def initialize(target, nesting, name, uri, location, comments) # rubocop:disable
         @target = target
         @nesting = nesting
       end
+
+      #: -> Bool
+      def resolved?
+        false
+      end
     end
 
     # Alias represents a resolved alias, which points to an existing constant target
@@ -386,11 +406,16 @@ def initialize(target, unresolved_alias)
           unresolved_alias.name,
           unresolved_alias.uri,
           unresolved_alias.location,
-          unresolved_alias.comments,
+          nil,
         )
 
         @visibility = unresolved_alias.visibility
         @target = target
+        @unresolved_alias = unresolved_alias
+      end
+
+      def comments
+        @comments ||= @unresolved_alias.comments
       end
     end
 
@@ -439,6 +464,11 @@ def initialize(new_name, old_name, owner, uri, location, comments) # rubocop:dis
         @old_name = old_name
         @owner = owner
       end
+
+      #: -> Bool
+      def resolved?
+        false
+      end
     end
 
     # A method alias is a resolved alias entry that points to the exact method target it refers to
@@ -451,19 +481,25 @@ class MethodAlias < Entry
 
       #: ((Member | MethodAlias) target, UnresolvedMethodAlias unresolved_alias) -> void
       def initialize(target, unresolved_alias)
-        full_comments = +"Alias for #{target.name}\n"
-        full_comments << "#{unresolved_alias.comments}\n"
-        full_comments << target.comments
-
         super(
           unresolved_alias.new_name,
           unresolved_alias.uri,
           unresolved_alias.location,
-          full_comments,
+          nil,
         )
 
         @target = target
         @owner = unresolved_alias.owner #: Entry::Namespace?
+        @unresolved_alias = unresolved_alias
+      end
+
+      #: -> String
+      def comments
+        @comments ||= <<~COMMENTS.chomp
+          Alias for #{@target.name}
+          #{@unresolved_alias.comments}
+          #{@target.comments}
+        COMMENTS
       end
 
       #: -> String

lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -203,9 +203,7 @@ def fuzzy_search(query)
 
           entries
         end
-        return entries.flat_map do |entries|
-          skip_unresolved_entries(entries)
-        end
+        return entries.flatten
       end
 
       normalized_query = query.gsub("::", "").downcase
@@ -389,6 +387,8 @@ def index_single(uri, source, collect_comments: true)
       require_path = uri.require_path
       @require_paths_tree.insert(require_path, uri) if require_path
 
+      process_unresolved_entries
+
       indexing_errors = listener.indexing_errors.uniq
       indexing_errors.each { |error| $stderr.puts(error) } if indexing_errors.any?
     rescue SystemStackError => e
@@ -731,6 +731,20 @@ def entries_for(uri, type = nil)
       entries&.grep(type)
     end
 
+    #: -> voide
+    def process_unresolved_entries
+      @entries.values.each do |entries|
+        entries.each do |entry|
+          case entry
+          when Entry::UnresolvedConstantAlias
+            resolve_alias(entry, [])
+          when Entry::UnresolvedMethodAlias
+            resolve_method_alias(entry, entry.owner&.name || "", [])
+          end
+        end
+      end
+    end
+
     private
 
     # Always returns the linearized ancestors for the attached class, regardless of whether `name` refers to a singleton

lib/ruby_indexer/lib/ruby_indexer/uri.rb

@@ -12,24 +12,37 @@ class Generic
     # NOTE: We also define this in the shim
     PARSER = const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER
 
+    # This unsafe regex is the same one used in the URI::RFC2396_REGEXP class with the exception of the fact that we
+    # do not include colon as a safe character. VS Code URIs always escape colons and we need to ensure we do the
+    # same to avoid inconsistencies in our URIs, which are used to identify resources
+    UNSAFE_REGEX = %r{[^\-_.!~*'()a-zA-Z\d;/?@&=+$,\[\]]}
+
     class << self
       #: (path: String, ?fragment: String?, ?scheme: String, ?load_path_entry: String?) -> URI::Generic
-      def from_path(path:, fragment: nil, scheme: "file", load_path_entry: nil)
-        # This unsafe regex is the same one used in the URI::RFC2396_REGEXP class with the exception of the fact that we
-        # do not include colon as a safe character. VS Code URIs always escape colons and we need to ensure we do the
-        # same to avoid inconsistencies in our URIs, which are used to identify resources
-        unsafe_regex = %r{[^\-_.!~*'()a-zA-Z\d;/?@&=+$,\[\]]}
-
+      def from_win_path(path:, fragment: nil, scheme: "file", load_path_entry: nil)
         # On Windows, if the path begins with the disk name, we need to add a leading slash to make it a valid URI
         escaped_path = if /^[A-Z]:/i.match?(path)
-          PARSER.escape("/#{path}", unsafe_regex)
+          PARSER.escape("/#{path}", UNSAFE_REGEX)
         elsif path.start_with?("//?/")
           # Some paths on Windows start with "//?/". This is a special prefix that allows for long file paths
-          PARSER.escape(path.delete_prefix("//?"), unsafe_regex)
+          PARSER.escape(path.delete_prefix("//?"), UNSAFE_REGEX)
         else
-          PARSER.escape(path, unsafe_regex)
+          PARSER.escape(path, UNSAFE_REGEX)
+        end
+
+        uri = build(scheme: scheme, path: escaped_path, fragment: fragment)
+
+        if load_path_entry
+          uri.require_path = path.delete_prefix("#{load_path_entry}/").delete_suffix(".rb")
         end
 
+        uri
+      end
+
+      #: (path: String, ?fragment: String?, ?scheme: String, ?load_path_entry: String?) -> URI::Generic
+      def from_unix_path(path:, fragment: nil, scheme: "file", load_path_entry: nil)
+        escaped_path = PARSER.escape(path, UNSAFE_REGEX)
+
         uri = build(scheme: scheme, path: escaped_path, fragment: fragment)
 
         if load_path_entry
@@ -38,6 +51,12 @@ def from_path(path:, fragment: nil, scheme: "file", load_path_entry: nil)
 
         uri
       end
+
+      if Gem.win_platform?
+        alias_method :from_path, :from_win_path
+      else
+        alias_method :from_path, :from_unix_path
+      end
     end
 
     #: String?
@@ -51,22 +70,43 @@ def add_require_path_from_load_entry(load_path_entry)
       self.require_path = path.delete_prefix("#{load_path_entry}/").delete_suffix(".rb")
     end
 
-    #: -> String?
-    def to_standardized_path
+    # On Windows, when we're getting the file system path back from the URI, we need to remove the leading forward
+    # slash
+    def to_standardized_win_path
       parsed_path = path
+
       return unless parsed_path
 
+      # we can bail out parsing if there is nothing to unscape
+      return parsed_path unless parsed_path.match?(/%[0-9A-Fa-f]{2}/)
+
       unescaped_path = PARSER.unescape(parsed_path)
 
-      # On Windows, when we're getting the file system path back from the URI, we need to remove the leading forward
-      # slash
       if %r{^/[A-Z]:}i.match?(unescaped_path)
         unescaped_path.delete_prefix("/")
       else
         unescaped_path
       end
     end
 
+    #: -> String?
+    def to_standardized_unix_path
+      unscapped_path = path
+      return unless unscapped_path
+
+      # we can bail out parsing if there is nothing to unscape
+      return unscapped_path unless unscapped_path.match?(/%[0-9A-Fa-f]{2}/)
+
+      PARSER.unescape(unscapped_path)
+    end
+
+
+    if Gem.win_platform?
+      alias_method :to_standardized_path, :to_standardized_win_path
+    else
+      alias_method :to_standardized_path, :to_standardized_unix_path
+    end
+
     alias_method :full_path, :to_standardized_path
   end
 end

lib/ruby_indexer/test/constant_test.rb

@@ -207,10 +207,9 @@ module C
         SECOND = A::FIRST
       RUBY
 
-      unresolve_entry = @index["A::FIRST"]&.first #: as Entry::UnresolvedConstantAlias
-      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
-      assert_equal(["A"], unresolve_entry.nesting)
-      assert_equal("B::C", unresolve_entry.target)
+      resolved_entry = @index["A::FIRST"]&.first #: as Entry::ConstantAlias
+      assert_instance_of(Entry::ConstantAlias, resolved_entry)
+      assert_equal("A::B::C", resolved_entry.target)
 
       resolved_entry = @index.resolve("A::FIRST", [])&.first #: as Entry::ConstantAlias
       assert_instance_of(Entry::ConstantAlias, resolved_entry)
@@ -233,23 +232,17 @@ module Other
         end
       RUBY
 
-      unresolve_entry = @index["A::ALIAS"]&.first #: as Entry::UnresolvedConstantAlias
-      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
-      assert_equal(["A"], unresolve_entry.nesting)
-      assert_equal("B", unresolve_entry.target)
-
-      resolved_entry = @index.resolve("ALIAS", ["A"])&.first #: as Entry::ConstantAlias
+      resolved_entry = @index["A::ALIAS"]&.first #: as Entry::ConstantAlias
       assert_instance_of(Entry::ConstantAlias, resolved_entry)
       assert_equal("A::B", resolved_entry.target)
 
       resolved_entry = @index.resolve("ALIAS::C", ["A"])&.first #: as Entry::Module
       assert_instance_of(Entry::Module, resolved_entry)
       assert_equal("A::B::C", resolved_entry.name)
 
-      unresolve_entry = @index["Other::ONE_MORE"]&.first #: as Entry::UnresolvedConstantAlias
-      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
-      assert_equal(["Other"], unresolve_entry.nesting)
-      assert_equal("A::ALIAS", unresolve_entry.target)
+      resolved_entry = @index["Other::ONE_MORE"]&.first #: as Entry::ConstantAlias
+      assert_instance_of(Entry::ConstantAlias, resolved_entry)
+      assert_equal("A::ALIAS", resolved_entry.target)
 
       resolved_entry = @index.resolve("Other::ONE_MORE::C", [])&.first
       assert_instance_of(Entry::Module, resolved_entry)
@@ -266,45 +259,25 @@ module A
       RUBY
 
       # B and C
-      unresolve_entry = @index["A::B"]&.first #: as Entry::UnresolvedConstantAlias
-      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
-      assert_equal(["A"], unresolve_entry.nesting)
-      assert_equal("C", unresolve_entry.target)
-
-      resolved_entry = @index.resolve("A::B", [])&.first #: as Entry::ConstantAlias
+      resolved_entry = @index["A::B"]&.first #: as Entry::ConstantAlias
       assert_instance_of(Entry::ConstantAlias, resolved_entry)
       assert_equal("A::C", resolved_entry.target)
 
       constant = @index["A::C"]&.first #: as Entry::Constant
       assert_instance_of(Entry::Constant, constant)
 
       # D and E
-      unresolve_entry = @index["A::D"]&.first #: as Entry::UnresolvedConstantAlias
-      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
-      assert_equal(["A"], unresolve_entry.nesting)
-      assert_equal("E", unresolve_entry.target)
-
-      resolved_entry = @index.resolve("A::D", [])&.first #: as Entry::ConstantAlias
+      resolved_entry = @index["A::D"]&.first #: as Entry::ConstantAlias
       assert_instance_of(Entry::ConstantAlias, resolved_entry)
       assert_equal("A::E", resolved_entry.target)
 
       # F and G::H
-      unresolve_entry = @index["A::F"]&.first #: as Entry::UnresolvedConstantAlias
-      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
-      assert_equal(["A"], unresolve_entry.nesting)
-      assert_equal("G::H", unresolve_entry.target)
-
-      resolved_entry = @index.resolve("A::F", [])&.first #: as Entry::ConstantAlias
+      resolved_entry = @index["A::F"]&.first #: as Entry::ConstantAlias
       assert_instance_of(Entry::ConstantAlias, resolved_entry)
       assert_equal("A::G::H", resolved_entry.target)
 
       # I::J, K::L and M
-      unresolve_entry = @index["A::I::J"]&.first #: as Entry::UnresolvedConstantAlias
-      assert_instance_of(Entry::UnresolvedConstantAlias, unresolve_entry)
-      assert_equal(["A"], unresolve_entry.nesting)
-      assert_equal("K::L", unresolve_entry.target)
-
-      resolved_entry = @index.resolve("A::I::J", [])&.first #: as Entry::ConstantAlias
+      resolved_entry = @index["A::I::J"]&.first #: as Entry::ConstantAlias
       assert_instance_of(Entry::ConstantAlias, resolved_entry)
       assert_equal("A::K::L", resolved_entry.target)
 
@@ -356,7 +329,7 @@ module Real
       assert_entry("A::D::E", Entry::UnresolvedConstantAlias, "/fake/path/foo.rb:2-2:2-6")
       assert_entry("A::F::G", Entry::Constant, "/fake/path/foo.rb:2-8:2-12")
       assert_entry("A::H", Entry::Constant, "/fake/path/foo.rb:3-2:3-3")
-      assert_entry("A::I::J", Entry::UnresolvedConstantAlias, "/fake/path/foo.rb:3-5:3-9")
+      assert_entry("A::I::J", Entry::ConstantAlias, "/fake/path/foo.rb:3-5:3-9")
       assert_entry("A::K", Entry::Constant, "/fake/path/foo.rb:4-2:4-3")
       assert_entry("A::L", Entry::Constant, "/fake/path/foo.rb:4-5:4-6")
     end

lib/ruby_indexer/test/method_test.rb

@@ -575,9 +575,13 @@ def third_method; end
       assert_equal("Foo", entry.owner&.name)
     end
 
-    def test_keeps_track_of_aliases
+    def test_keeps_track_of_aliases_and_comments
       index(<<~RUBY)
         class Foo
+          # A comment
+          def to_s
+          end
+          # Whatever Comment
           alias whatever to_s
           alias_method :foo, :to_a
           alias_method "bar", "to_a"
@@ -588,9 +592,10 @@ class Foo
         end
       RUBY
 
-      assert_entry("whatever", Entry::UnresolvedMethodAlias, "/fake/path/foo.rb:1-8:1-16")
-      assert_entry("foo", Entry::UnresolvedMethodAlias, "/fake/path/foo.rb:2-15:2-19")
-      assert_entry("bar", Entry::UnresolvedMethodAlias, "/fake/path/foo.rb:3-15:3-20")
+      assert_entry("whatever", Entry::MethodAlias, "/fake/path/foo.rb:5-8:5-16")
+      assert_equal("Alias for to_s\nWhatever Comment\nA comment", @index["whatever"]&.first&.comments)
+      assert_entry("foo", Entry::UnresolvedMethodAlias, "/fake/path/foo.rb:6-15:6-19")
+      assert_entry("bar", Entry::UnresolvedMethodAlias, "/fake/path/foo.rb:7-15:7-20")
       # Foo plus 3 valid aliases
       assert_equal(4, @index.length - @default_indexed_entries.length)
     end