ruby-lsp 0.10.1 → 0.11.1

data/lib/ruby_lsp/internal.rb

@@ -2,10 +2,8 @@
 # frozen_string_literal: true
 
 require "sorbet-runtime"
-require "syntax_tree"
 require "yarp"
 require "language_server-protocol"
-require "benchmark"
 require "bundler"
 require "uri"
 require "cgi"
@@ -14,11 +12,12 @@ require "ruby-lsp"
 require "ruby_indexer/ruby_indexer"
 require "core_ext/uri"
 require "ruby_lsp/utils"
+require "ruby_lsp/parameter_scope"
 require "ruby_lsp/server"
 require "ruby_lsp/executor"
 require "ruby_lsp/event_emitter"
 require "ruby_lsp/requests"
 require "ruby_lsp/listener"
 require "ruby_lsp/store"
-require "ruby_lsp/extension"
+require "ruby_lsp/addon"
 require "ruby_lsp/requests/support/rubocop_runner"

data/lib/ruby_lsp/listener.rb

@@ -31,7 +31,7 @@ module RubyLsp
     def _response; end
   end
 
-  # ExtensibleListener is an abstract class to be used by requests that accept extensions.
+  # ExtensibleListener is an abstract class to be used by requests that accept addons.
   class ExtensibleListener < Listener
     extend T::Sig
     extend T::Generic
@@ -48,7 +48,7 @@ module RubyLsp
       super
       @response_merged = T.let(false, T::Boolean)
       @external_listeners = T.let(
-        Extension.extensions.filter_map do |ext|
+        Addon.addons.filter_map do |ext|
           initialize_external_listener(ext)
         end,
         T::Array[RubyLsp::Listener[ResponseType]],
@@ -56,7 +56,7 @@ module RubyLsp
     end
 
     # Merge responses from all external listeners into the base listener's response. We do this to return a single
-    # response to the editor including the results of all extensions
+    # response to the editor including the results of all addons
     sig { void }
     def merge_external_listeners_responses!
       @external_listeners.each { |l| merge_response!(l) }
@@ -69,14 +69,15 @@ module RubyLsp
     end
 
     sig do
-      abstract.params(extension: RubyLsp::Extension).returns(T.nilable(RubyLsp::Listener[ResponseType]))
+      abstract.params(addon: RubyLsp::Addon).returns(T.nilable(RubyLsp::Listener[ResponseType]))
     end
-    def initialize_external_listener(extension); end
+    def initialize_external_listener(addon); end
 
-    # Does nothing by default. Requests that accept extensions should override this method to define how to merge
-    # responses coming from external listeners
+    # Does nothing by default. Requests that accept addons should override this method to define how to merge responses
+    # coming from external listeners
     sig { abstract.params(other: Listener[T.untyped]).returns(T.self_type) }
     def merge_response!(other)
     end
   end
+  private_constant(:ExtensibleListener)
 end

data/lib/ruby_lsp/parameter_scope.rb

@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  class ParameterScope
+    extend T::Sig
+
+    sig { returns(T.nilable(ParameterScope)) }
+    attr_reader :parent
+
+    sig { params(parent: T.nilable(ParameterScope)).void }
+    def initialize(parent = nil)
+      @parent = parent
+      @parameters = T.let(Set.new, T::Set[Symbol])
+    end
+
+    sig { params(name: T.any(String, Symbol)).void }
+    def <<(name)
+      @parameters << name.to_sym
+    end
+
+    sig { params(name: T.any(Symbol, String)).returns(Symbol) }
+    def type_for(name)
+      parameter?(name) ? :parameter : :variable
+    end
+
+    sig { params(name: T.any(Symbol, String)).returns(T::Boolean) }
+    def parameter?(name)
+      sym = name.to_sym
+      @parameters.include?(sym) || (!@parent.nil? && @parent.parameter?(sym))
+    end
+  end
+end

data/lib/ruby_lsp/requests/base_request.rb

@@ -4,7 +4,7 @@
 module RubyLsp
   module Requests
     # :nodoc:
-    class BaseRequest < SyntaxTree::Visitor
+    class BaseRequest < YARP::Visitor
       extend T::Sig
       extend T::Helpers
       include Support::Common
@@ -20,10 +20,10 @@ module RubyLsp
       sig { abstract.returns(Object) }
       def run; end
 
-      # Syntax Tree implements `visit_all` using `map` instead of `each` for users who want to use the pattern
+      # YARP implements `visit_all` using `map` instead of `each` for users who want to use the pattern
       # `result = visitor.visit(tree)`. However, we don't use that pattern and should avoid producing a new array for
       # every single node visited
-      sig { params(nodes: T::Array[T.nilable(SyntaxTree::Node)]).void }
+      sig { params(nodes: T::Array[T.nilable(YARP::Node)]).void }
       def visit_all(nodes)
         nodes.each { |node| visit(node) }
       end

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -43,11 +43,11 @@ module RubyLsp
 
       sig { override.returns(T.any(Interface::CodeAction, Error)) }
       def run
+        return Error::EmptySelection if @document.source.empty?
+
         source_range = @code_action.dig(:data, :range)
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
-        return Error::InvalidTargetRange if @document.syntax_error?
-
         scanner = @document.create_scanner
         start_index = scanner.find_char_position(source_range[:start])
         end_index = scanner.find_char_position(source_range[:end])
@@ -55,26 +55,23 @@ module RubyLsp
 
         # Find the closest statements node, so that we place the refactor in a valid position
         closest_statements, parent_statements = @document
-          .locate(T.must(@document.tree), start_index, node_types: [SyntaxTree::Statements])
-        return Error::InvalidTargetRange if closest_statements.nil?
+          .locate(@document.tree, start_index, node_types: [YARP::StatementsNode, YARP::BlockNode])
+
+        return Error::InvalidTargetRange if closest_statements.nil? || closest_statements.child_nodes.compact.empty?
 
         # Find the node with the end line closest to the requested position, so that we can place the refactor
         # immediately after that closest node
-        closest_node = closest_statements.child_nodes.compact.min_by do |node|
+        closest_node = T.must(closest_statements.child_nodes.compact.min_by do |node|
           distance = source_range.dig(:start, :line) - (node.location.end_line - 1)
           distance <= 0 ? Float::INFINITY : distance
-        end
+        end)
 
-        # Find the parent expression of the closest node
-        parent_expression = parent_statements.child_nodes.compact.find do |node|
-          loc = node.location
-          loc.start_line - 1 <= source_range.dig(:start, :line) && loc.end_line - 1 >= source_range.dig(:end, :line)
-        end if parent_statements
+        return Error::InvalidTargetRange if closest_node.is_a?(YARP::MissingNode)
 
         closest_node_loc = closest_node.location
         # If the parent expression is a single line block, then we have to extract it inside of the oneline block
-        if parent_expression.is_a?(SyntaxTree::MethodAddBlock) &&
-            parent_expression.location.start_line == parent_expression.location.end_line
+        if parent_statements.is_a?(YARP::BlockNode) &&
+            parent_statements.location.start_line == parent_statements.location.end_line
 
           variable_source = " #{NEW_VARIABLE_NAME} = #{extracted_source};"
           character = source_range.dig(:start, :character) - 1
@@ -105,7 +102,10 @@ module RubyLsp
             end: { line: target_line, character: indentation },
           }
 
-          variable_source = if T.must(lines[target_line]).strip.empty?
+          line = lines[target_line]
+          return Error::InvalidTargetRange unless line
+
+          variable_source = if line.strip.empty?
             "\n#{" " * indentation}#{NEW_VARIABLE_NAME} = #{extracted_source}"
           else
             "#{NEW_VARIABLE_NAME} = #{extracted_source}\n#{" " * indentation}"

data/lib/ruby_lsp/requests/code_lens.rb

@@ -31,10 +31,9 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :_response
 
-      sig { params(uri: URI::Generic, emitter: EventEmitter, message_queue: Thread::Queue, test_library: String).void }
-      def initialize(uri, emitter, message_queue, test_library)
+      sig { params(uri: URI::Generic, emitter: EventEmitter, message_queue: Thread::Queue).void }
+      def initialize(uri, emitter, message_queue)
         @uri = T.let(uri, URI::Generic)
-        @test_library = T.let(test_library, String)
         @_response = T.let([], ResponseType)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         # visibility_stack is a stack of [current_visibility, previous_visibility]
@@ -48,18 +47,15 @@ module RubyLsp
           :on_class,
           :after_class,
           :on_def,
-          :on_command,
-          :after_command,
           :on_call,
           :after_call,
-          :on_vcall,
         )
       end
 
-      sig { params(node: SyntaxTree::ClassDeclaration).void }
+      sig { params(node: YARP::ClassNode).void }
       def on_class(node)
         @visibility_stack.push(["public", "public"])
-        class_name = node.constant.constant.value
+        class_name = node.constant_path.slice
         @class_stack.push(class_name)
 
         if @path && class_name.end_with?("Test")
@@ -72,20 +68,20 @@ module RubyLsp
         end
       end
 
-      sig { params(node: SyntaxTree::ClassDeclaration).void }
+      sig { params(node: YARP::ClassNode).void }
       def after_class(node)
         @visibility_stack.pop
         @class_stack.pop
       end
 
-      sig { params(node: SyntaxTree::DefNode).void }
+      sig { params(node: YARP::DefNode).void }
       def on_def(node)
         class_name = @class_stack.last
         return unless class_name&.end_with?("Test")
 
         visibility, _ = @visibility_stack.last
         if visibility == "public"
-          method_name = node.name.value
+          method_name = node.name.to_s
           if @path && method_name.start_with?("test_")
             add_test_code_lens(
               node,
@@ -97,58 +93,44 @@ module RubyLsp
         end
       end
 
-      sig { params(node: SyntaxTree::Command).void }
-      def on_command(node)
-        node_message = node.message.value
-        if ACCESS_MODIFIERS.include?(node_message) && node.arguments.parts.any?
-          visibility, _ = @visibility_stack.pop
-          @visibility_stack.push([node_message, visibility])
-        elsif @path&.include?("Gemfile") && node_message.include?("gem") && node.arguments.parts.any?
-          remote = resolve_gem_remote(node)
-          return unless remote
+      sig { params(node: YARP::CallNode).void }
+      def on_call(node)
+        name = node.name
+        arguments = node.arguments
+
+        # If we found `private` by itself or `private def foo`
+        if ACCESS_MODIFIERS.include?(name)
+          if arguments.nil?
+            @visibility_stack.pop
+            @visibility_stack.push([name, name])
+          elsif arguments.arguments.first.is_a?(YARP::DefNode)
+            visibility, _ = @visibility_stack.pop
+            @visibility_stack.push([name, visibility])
+          end
 
-          add_open_gem_remote_code_lens(node, remote)
+          return
         end
-      end
 
-      sig { params(node: SyntaxTree::Command).void }
-      def after_command(node)
-        _, prev_visibility = @visibility_stack.pop
-        @visibility_stack.push([prev_visibility, prev_visibility])
-      end
+        if @path&.include?("Gemfile") && name == "gem" && arguments
+          first_argument = arguments.arguments.first
+          return unless first_argument.is_a?(YARP::StringNode)
 
-      sig { params(node: SyntaxTree::CallNode).void }
-      def on_call(node)
-        ident = node.message if node.message.is_a?(SyntaxTree::Ident)
+          remote = resolve_gem_remote(first_argument)
+          return unless remote
 
-        if ident
-          ident_value = T.cast(ident, SyntaxTree::Ident).value
-          if ACCESS_MODIFIERS.include?(ident_value)
-            visibility, _ = @visibility_stack.pop
-            @visibility_stack.push([ident_value, visibility])
-          end
+          add_open_gem_remote_code_lens(node, remote)
         end
       end
 
-      sig { params(node: SyntaxTree::CallNode).void }
+      sig { params(node: YARP::CallNode).void }
       def after_call(node)
         _, prev_visibility = @visibility_stack.pop
         @visibility_stack.push([prev_visibility, prev_visibility])
       end
 
-      sig { params(node: SyntaxTree::VCall).void }
-      def on_vcall(node)
-        vcall_value = node.value.value
-
-        if ACCESS_MODIFIERS.include?(vcall_value)
-          @visibility_stack.pop
-          @visibility_stack.push([vcall_value, vcall_value])
-        end
-      end
-
-      sig { override.params(extension: RubyLsp::Extension).returns(T.nilable(Listener[ResponseType])) }
-      def initialize_external_listener(extension)
-        extension.create_code_lens_listener(@uri, @emitter, @message_queue)
+      sig { override.params(addon: Addon).returns(T.nilable(Listener[ResponseType])) }
+      def initialize_external_listener(addon)
+        addon.create_code_lens_listener(@uri, @emitter, @message_queue)
       end
 
       sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
@@ -159,10 +141,10 @@ module RubyLsp
 
       private
 
-      sig { params(node: SyntaxTree::Node, name: String, command: String, kind: Symbol).void }
+      sig { params(node: YARP::Node, name: String, command: String, kind: Symbol).void }
       def add_test_code_lens(node, name:, command:, kind:)
         # don't add code lenses if the test library is not supported or unknown
-        return unless SUPPORTED_TEST_LIBRARIES.include?(@test_library) && @path
+        return unless SUPPORTED_TEST_LIBRARIES.include?(DependencyDetector.instance.detected_test_library) && @path
 
         arguments = [
           @path,
@@ -201,15 +183,9 @@ module RubyLsp
         )
       end
 
-      sig { params(node: SyntaxTree::Command).returns(T.nilable(String)) }
-      def resolve_gem_remote(node)
-        gem_statement = node.arguments.parts.first
-        return unless gem_statement.is_a?(SyntaxTree::StringLiteral)
-
-        gem_name = gem_statement.parts.first
-        return unless gem_name.is_a?(SyntaxTree::TStringContent)
-
-        spec = Gem::Specification.stubs.find { |gem| gem.name == gem_name.value }&.to_spec
+      sig { params(gem_name: YARP::StringNode).returns(T.nilable(String)) }
+      def resolve_gem_remote(gem_name)
+        spec = Gem::Specification.stubs.find { |gem| gem.name == gem_name.content }&.to_spec
         return if spec.nil?
 
         [spec.homepage, spec.metadata["source_code_uri"]].compact.find do |page|
@@ -221,7 +197,7 @@ module RubyLsp
       def generate_test_command(class_name:, method_name: nil)
         command = BASE_COMMAND + T.must(@path)
 
-        case @test_library
+        case DependencyDetector.instance.detected_test_library
         when "minitest"
           command += if method_name
             " --name " + "/#{Shellwords.escape(class_name + "#" + method_name)}/"
@@ -239,7 +215,7 @@ module RubyLsp
         command
       end
 
-      sig { params(node: SyntaxTree::Command, remote: String).void }
+      sig { params(node: YARP::CallNode, remote: String).void }
       def add_open_gem_remote_code_lens(node, remote)
         @_response << create_code_lens(
           node,

data/lib/ruby_lsp/requests/completion.rb

@@ -40,58 +40,80 @@ module RubyLsp
         @index = index
         @nesting = nesting
 
-        emitter.register(self, :on_tstring_content, :on_const_path_ref, :on_const, :on_top_const_ref)
+        emitter.register(self, :on_string, :on_constant_path, :on_constant_read)
       end
 
-      sig { params(node: SyntaxTree::TStringContent).void }
-      def on_tstring_content(node)
-        @index.search_require_paths(node.value).map!(&:require_path).sort!.each do |path|
+      sig { params(node: YARP::StringNode).void }
+      def on_string(node)
+        @index.search_require_paths(node.content).map!(&:require_path).sort!.each do |path|
           @_response << build_completion(T.must(path), node)
         end
       end
 
       # Handle completion on regular constant references (e.g. `Bar`)
-      sig { params(node: SyntaxTree::Const).void }
-      def on_const(node)
-        return if DependencyDetector::HAS_TYPECHECKER
+      sig { params(node: YARP::ConstantReadNode).void }
+      def on_constant_read(node)
+        return if DependencyDetector.instance.typechecker
 
-        name = node.value
+        name = node.slice
         candidates = @index.prefix_search(name, @nesting)
         candidates.each do |entries|
-          @_response << build_entry_completion(name, node, entries, top_level?(T.must(entries.first).name, candidates))
+          complete_name = T.must(entries.first).name
+          @_response << build_entry_completion(complete_name, node, entries, top_level?(complete_name, candidates))
         end
       end
 
       # Handle completion on namespaced constant references (e.g. `Foo::Bar`)
-      sig { params(node: SyntaxTree::ConstPathRef).void }
-      def on_const_path_ref(node)
-        return if DependencyDetector::HAS_TYPECHECKER
+      sig { params(node: YARP::ConstantPathNode).void }
+      def on_constant_path(node)
+        return if DependencyDetector.instance.typechecker
 
-        name = full_constant_name(node)
-        candidates = @index.prefix_search(name, @nesting)
-        candidates.each do |entries|
-          @_response << build_entry_completion(name, node, entries, top_level?(T.must(entries.first).name, candidates))
+        name = node.slice
+
+        top_level_reference = if name.start_with?("::")
+          name = name.delete_prefix("::")
+          true
+        else
+          false
         end
-      end
 
-      # Handle completion on top level constant references (e.g. `::Bar`)
-      sig { params(node: SyntaxTree::TopConstRef).void }
-      def on_top_const_ref(node)
-        return if DependencyDetector::HAS_TYPECHECKER
+        # If we're trying to provide completion for an aliased namespace, we need to first discover it's real name in
+        # order to find which possible constants match the desired search
+        *namespace, incomplete_name = name.split("::")
+        aliased_namespace = namespace.join("::")
+        namespace_entries = @index.resolve(aliased_namespace, @nesting)
+        return unless namespace_entries
+
+        real_namespace = @index.follow_aliased_namespace(T.must(namespace_entries.first).name)
 
-        name = full_constant_name(node)
-        candidates = @index.prefix_search(name, [])
-        candidates.each { |entries| @_response << build_entry_completion(name, node, entries, true) }
+        candidates = @index.prefix_search("#{real_namespace}::#{incomplete_name}", top_level_reference ? [] : @nesting)
+        candidates.each do |entries|
+          # The only time we may have a private constant reference from outside of the namespace is if we're dealing
+          # with ConstantPath and the entry name doesn't start with the current nesting
+          first_entry = T.must(entries.first)
+          next if first_entry.visibility == :private && !first_entry.name.start_with?("#{@nesting}::")
+
+          constant_name = T.must(first_entry.name.split("::").last)
+
+          full_name = aliased_namespace.empty? ? constant_name : "#{aliased_namespace}::#{constant_name}"
+
+          @_response << build_entry_completion(
+            full_name,
+            node,
+            entries,
+            top_level_reference || top_level?(T.must(entries.first).name, candidates),
+          )
+        end
       end
 
       private
 
-      sig { params(label: String, node: SyntaxTree::TStringContent).returns(Interface::CompletionItem) }
+      sig { params(label: String, node: YARP::StringNode).returns(Interface::CompletionItem) }
       def build_completion(label, node)
         Interface::CompletionItem.new(
           label: label,
           text_edit: Interface::TextEdit.new(
-            range: range_from_syntax_tree_node(node),
+            range: range_from_node(node),
             new_text: label,
           ),
           kind: Constant::CompletionItemKind::REFERENCE,
@@ -101,7 +123,7 @@ module RubyLsp
       sig do
         params(
           name: String,
-          node: SyntaxTree::Node,
+          node: YARP::Node,
           entries: T::Array[RubyIndexer::Index::Entry],
           top_level: T::Boolean,
         ).returns(Interface::CompletionItem)
@@ -119,7 +141,7 @@ module RubyLsp
           Constant::CompletionItemKind::REFERENCE
         end
 
-        insertion_text = first_entry.name.dup
+        insertion_text = name.dup
 
         # If we have two entries with the same name inside the current namespace and the user selects the top level
         # option, we have to ensure it's prefixed with `::` or else we're completing the wrong constant. For example:
@@ -143,17 +165,17 @@ module RubyLsp
         # For these top level references, we need to include the `::` as part of the filter text or else it won't match
         # the right entries in the index
         Interface::CompletionItem.new(
-          label: first_entry.name,
-          filter_text: top_level ? "::#{first_entry.name}" : first_entry.name,
+          label: name,
+          filter_text: top_level ? "::#{name}" : name,
           text_edit: Interface::TextEdit.new(
-            range: range_from_syntax_tree_node(node),
+            range: range_from_node(node),
             new_text: insertion_text,
           ),
           kind: kind,
           label_details: Interface::CompletionItemLabelDetails.new(
             description: entries.map(&:file_name).join(","),
           ),
-          documentation: markdown_from_index_entries(first_entry.name, entries),
+          documentation: markdown_from_index_entries(name, entries),
         )
       end
 

data/lib/ruby_lsp/requests/definition.rb

@@ -43,12 +43,11 @@ module RubyLsp
 
         super(emitter, message_queue)
 
-        emitter.register(self, :on_command, :on_const, :on_const_path_ref)
+        emitter.register(self, :on_call, :on_constant_read, :on_constant_path)
       end
-
-      sig { override.params(ext: Extension).returns(T.nilable(RubyLsp::Listener[ResponseType])) }
-      def initialize_external_listener(ext)
-        ext.create_definition_listener(@uri, @nesting, @index, @emitter, @message_queue)
+      sig { override.params(addon: Addon).returns(T.nilable(RubyLsp::Listener[ResponseType])) }
+      def initialize_external_listener(addon)
+        addon.create_definition_listener(@uri, @nesting, @index, @emitter, @message_queue)
       end
 
       sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
@@ -67,32 +66,21 @@ module RubyLsp
         self
       end
 
-      sig { params(node: SyntaxTree::ConstPathRef).void }
-      def on_const_path_ref(node)
-        name = full_constant_name(node)
-        find_in_index(name)
-      end
-
-      sig { params(node: SyntaxTree::Const).void }
-      def on_const(node)
-        find_in_index(node.value)
-      end
-
-      sig { params(node: SyntaxTree::Command).void }
-      def on_command(node)
-        message = node.message.value
+      sig { params(node: YARP::CallNode).void }
+      def on_call(node)
+        message = node.name
         return unless message == "require" || message == "require_relative"
 
-        argument = node.arguments.parts.first
-        return unless argument.is_a?(SyntaxTree::StringLiteral)
+        arguments = node.arguments
+        return unless arguments
 
-        string = argument.parts.first
-        return unless string.is_a?(SyntaxTree::TStringContent)
+        argument = arguments.arguments.first
+        return unless argument.is_a?(YARP::StringNode)
 
         case message
         when "require"
-          entry = @index.search_require_paths(string.value).find do |indexable_path|
-            indexable_path.require_path == string.value
+          entry = @index.search_require_paths(argument.content).find do |indexable_path|
+            indexable_path.require_path == argument.content
           end
 
           if entry
@@ -107,7 +95,7 @@ module RubyLsp
             )
           end
         when "require_relative"
-          required_file = "#{string.value}.rb"
+          required_file = "#{argument.content}.rb"
           path = @uri.to_standardized_path
           current_folder = path ? Pathname.new(CGI.unescape(path)).dirname : Dir.pwd
           candidate = File.expand_path(File.join(current_folder, required_file))
@@ -122,6 +110,16 @@ module RubyLsp
         end
       end
 
+      sig { params(node: YARP::ConstantPathNode).void }
+      def on_constant_path(node)
+        find_in_index(node.slice)
+      end
+
+      sig { params(node: YARP::ConstantReadNode).void }
+      def on_constant_read(node)
+        find_in_index(node.slice)
+      end
+
       private
 
       sig { params(value: String).void }
@@ -129,6 +127,11 @@ module RubyLsp
         entries = @index.resolve(value, @nesting)
         return unless entries
 
+        # We should only allow jumping to the definition of private constants if the constant is defined in the same
+        # namespace as the reference
+        first_entry = T.must(entries.first)
+        return if first_entry.visibility == :private && first_entry.name != "#{@nesting.join("::")}::#{value}"
+
         bundle_path = begin
           Bundler.bundle_path.to_s
         rescue Bundler::GemfileNotFound
@@ -141,7 +144,7 @@ module RubyLsp
           # additional behavior on top of jumping to RBIs. Sorbet can already handle go to definition for all constants
           # in the project, even if the files are typed false
           file_path = entry.file_path
-          if DependencyDetector::HAS_TYPECHECKER && bundle_path && !file_path.start_with?(bundle_path) &&
+          if DependencyDetector.instance.typechecker && bundle_path && !file_path.start_with?(bundle_path) &&
               !file_path.start_with?(RbConfig::CONFIG["rubylibdir"])
 
             next