rubydex 0.2.9 → 0.4.0

data/rust/rubydex/src/indexing/ruby_indexer_tests.rs

@@ -6,6 +6,7 @@ use crate::{
     assert_def_comments_eq, assert_def_mixins_eq, assert_def_name_eq, assert_def_name_offset_eq, assert_def_str_eq,
     assert_def_superclass_ref_eq, assert_definition_at, assert_dependents, assert_local_diagnostics_eq,
     assert_method_has_receiver, assert_name_path_eq, assert_no_local_diagnostics, assert_string_eq,
+    diagnostic::Severity,
     model::{
         definitions::{Definition, Parameter, Receiver, Signatures},
         ids::{StringId, UriId},
@@ -967,7 +968,8 @@ mod class_and_module_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["dynamic-constant-reference: Dynamic constant reference (1:7-1:10)"]
+            ["DynamicConstantReference: Dynamic constant reference (1:7-1:10)"],
+            severity: Severity::Information
         );
         assert!(context.graph().definitions().is_empty());
     }
@@ -1071,7 +1073,7 @@ mod class_and_module_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["dynamic-constant-reference: Dynamic constant reference (1:8-1:11)"]
+            ["DynamicConstantReference: Dynamic constant reference (1:8-1:11)"]
         );
         assert!(context.graph().definitions().is_empty());
     }
@@ -1173,7 +1175,7 @@ mod method_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["dynamic-singleton-definition: Dynamic receiver for singleton method definition (1:1-1:17)"]
+            ["DynamicSingletonDefinition: Dynamic receiver for singleton method definition (1:1-1:17)"]
         );
         assert_eq!(context.graph().definitions().len(), 0);
         assert_method_references_eq!(&context, ["foo"]);
@@ -1416,7 +1418,7 @@ mod singleton_class_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["dynamic-singleton-definition: Dynamic singleton class definition (1:1-3:4)"]
+            ["DynamicSingletonDefinition: Dynamic singleton class definition (1:1-3:4)"]
         );
         assert_eq!(context.graph().definitions().len(), 0);
     }
@@ -1557,6 +1559,34 @@ mod visibility_tests {
         });
     }
 
+    #[test]
+    fn index_module_function_with_body() {
+        let context = index_source({
+            "
+            module Foo
+              module_function
+
+              def bar
+                @value = CONST
+                baz(1)
+              end
+            end
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+        assert_eq!(context.graph().definitions().len(), 4);
+        assert_eq!(context.graph().document().definitions().len(), 4);
+        assert_eq!(context.graph().document().constant_references().len(), 1);
+        assert_eq!(context.graph().document().method_references().len(), 1);
+        assert_constant_references_eq!(&context, ["CONST"]);
+        assert_method_references_eq!(&context, ["baz"]);
+
+        let methods = context.all_definitions_at("4:3-7:6");
+        assert_eq!(methods.len(), 2);
+        assert_definition_at!(&context, "5:5-5:11", InstanceVariable);
+    }
+
     #[test]
     fn index_def_node_with_visibility_nested() {
         let context = index_source({
@@ -1750,20 +1780,20 @@ mod visibility_tests {
     fn index_private_constant_calls_diagnostics() {
         let context = index_source({
             "
-            private_constant :NOT_INDEXED
-            self.private_constant :NOT_INDEXED
-            foo.private_constant :NOT_INDEXED # not indexed, dynamic receiver
+            private_constant :BAR # not indexed, called at top level
+            self.private_constant :BAR # not indexed, self receiver at top level
+            foo.private_constant :BAR # not indexed, dynamic receiver
 
             module Foo
-              private_constant NOT_INDEXED, not_indexed # not indexed, not a symbol
+              private_constant SomeConst, some_method # not indexed, non-literal arguments
               private_constant # not indexed, no arguments
 
               def self.qux
-                private_constant :Bar # not indexed, dynamic
+                private_constant :BAR # not indexed, inside a method
               end
 
               def foo
-                private_constant :Bar # not indexed, dynamic
+                private_constant :BAR # not indexed, inside a method
               end
             end
             "
@@ -1772,15 +1802,53 @@ mod visibility_tests {
         assert_local_diagnostics_eq!(
             &context,
             vec![
-                "invalid-private-constant: Private constant called at top level (1:1-1:30)",
-                "invalid-private-constant: Private constant called at top level (2:1-2:35)",
-                "invalid-private-constant: Dynamic receiver for private constant (3:1-3:34)",
-                "invalid-private-constant: Private constant called with non-symbol argument (6:20-6:31)",
-                "invalid-private-constant: Private constant called with non-symbol argument (6:33-6:44)",
+                "InvalidConstantVisibility: `private_constant` called at top level (1:1-1:22)",
+                "InvalidConstantVisibility: `private_constant` called at top level (2:1-2:27)",
+                "InvalidConstantVisibility: Dynamic receiver for `private_constant` (3:1-3:4)",
+                "InvalidConstantVisibility: `private_constant` called with a non-literal argument (6:20-6:29)",
+                "InvalidConstantVisibility: `private_constant` called with a non-literal argument (6:31-6:42)",
+            ],
+            severity: Severity::Warning
+        );
+
+        assert_eq!(context.graph().definitions().len(), 3); // Foo, Foo.qux, Foo#foo
+    }
+
+    #[test]
+    fn index_public_constant_calls_diagnostics() {
+        let context = index_source({
+            "
+            public_constant :BAR # not indexed, called at top level
+            self.public_constant :BAR # not indexed, self receiver at top level
+            foo.public_constant :BAR # not indexed, dynamic receiver
+
+            module Foo
+              public_constant SomeConst, some_method # not indexed, non-literal arguments
+              public_constant # not indexed, no arguments
+
+              def self.qux
+                public_constant :BAR # not indexed, inside a method
+              end
+
+              def foo
+                public_constant :BAR # not indexed, inside a method
+              end
+            end
+            "
+        });
+
+        assert_local_diagnostics_eq!(
+            &context,
+            vec![
+                "InvalidConstantVisibility: `public_constant` called at top level (1:1-1:21)",
+                "InvalidConstantVisibility: `public_constant` called at top level (2:1-2:26)",
+                "InvalidConstantVisibility: Dynamic receiver for `public_constant` (3:1-3:4)",
+                "InvalidConstantVisibility: `public_constant` called with a non-literal argument (6:19-6:28)",
+                "InvalidConstantVisibility: `public_constant` called with a non-literal argument (6:30-6:41)",
             ]
         );
 
-        assert_eq!(context.graph().definitions().len(), 3); // Foo, Foo::Qux, Foo#foo
+        assert_eq!(context.graph().definitions().len(), 3); // Foo, Foo.qux, Foo#foo
     }
 
     #[test]
@@ -1853,7 +1921,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `private` called with a non-literal argument (4:17-4:27)"]
+            vec!["InvalidMethodVisibility: `private` called with a non-literal argument (4:17-4:27)"]
         );
 
         // :foo is a literal arg, so visibility is still applied
@@ -1879,7 +1947,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `private` cannot be called with an explicit receiver (4:3-4:19)"]
+            vec!["InvalidMethodVisibility: `private` cannot be called with an explicit receiver (4:3-4:19)"]
         );
 
         for def in context.graph().definitions().values() {
@@ -1904,7 +1972,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `private` called with a non-literal argument (4:11-4:21)"]
+            vec!["InvalidMethodVisibility: `private` called with a non-literal argument (4:11-4:21)"]
         );
 
         // No MethodVisibilityDefinition created
@@ -1928,7 +1996,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `private` called with a non-literal argument (2:11-2:23)"]
+            vec!["InvalidMethodVisibility: `private` called with a non-literal argument (2:11-2:23)"]
         );
 
         // No MethodVisibilityDefinition created
@@ -1952,7 +2020,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `private` called with a non-literal argument (2:11-2:35)"]
+            vec!["InvalidMethodVisibility: `private` called with a non-literal argument (2:11-2:35)"]
         );
 
         // No MethodVisibilityDefinition or AttrReader created from that call
@@ -1995,9 +2063,7 @@ mod visibility_tests {
         // attr_reader(:foo) returns an array in multi-arg context, invalid for `private`
         assert_local_diagnostics_eq!(
             &context,
-            vec![
-                "invalid-method-visibility: `private` with `attr_*` is only supported as a single argument (2:11-2:28)"
-            ]
+            vec!["InvalidMethodVisibility: `private` with `attr_*` is only supported as a single argument (2:11-2:28)"]
         );
 
         // foo reader still defined via side effects, but public
@@ -2021,10 +2087,29 @@ mod visibility_tests {
 
         assert_no_local_diagnostics!(&context);
 
-        assert_definition_at!(&context, "4:20-4:23", MethodVisibility, |def| {
-            assert_def_str_eq!(&context, def, "foo()");
-            assert_eq!(def.visibility(), &Visibility::ModuleFunction);
-        });
+        let defs = context.all_definitions_at("4:20-4:23");
+        assert_eq!(defs.len(), 2, "expected two MethodVisibility defs");
+
+        let mut instance_side = None;
+        let mut singleton_side = None;
+        for def in defs {
+            let Definition::MethodVisibility(method_vis) = def else {
+                panic!("expected MethodVisibility, got {:?}", def.kind());
+            };
+            if method_vis.flags().is_singleton_method_visibility() {
+                singleton_side = Some(method_vis.as_ref());
+            } else {
+                instance_side = Some(method_vis.as_ref());
+            }
+        }
+
+        let instance_side = instance_side.expect("missing instance-side def");
+        assert_def_str_eq!(&context, instance_side, "foo()");
+        assert_eq!(instance_side.visibility(), &Visibility::ModuleFunction);
+
+        let singleton_side = singleton_side.expect("missing singleton-side def");
+        assert_def_str_eq!(&context, singleton_side, "foo()");
+        assert_eq!(singleton_side.visibility(), &Visibility::ModuleFunction);
     }
 
     #[test]
@@ -2041,7 +2126,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `module_function` can only be used in modules (4:3-4:23)"]
+            vec!["InvalidMethodVisibility: `module_function` can only be used in modules (4:3-4:23)"]
         );
 
         for def in context.graph().definitions().values() {
@@ -2113,8 +2198,8 @@ mod visibility_tests {
         assert_local_diagnostics_eq!(
             &context,
             vec![
-                "invalid-method-visibility: `private` called with a non-literal argument (2:25-2:32)",
-                "invalid-method-visibility: `private` called with a non-literal argument (3:11-3:18)",
+                "InvalidMethodVisibility: `private` called with a non-literal argument (2:25-2:32)",
+                "InvalidMethodVisibility: `private` called with a non-literal argument (3:11-3:18)",
             ]
         );
 
@@ -2144,8 +2229,8 @@ mod visibility_tests {
         assert_local_diagnostics_eq!(
             &context,
             vec![
-                "invalid-method-visibility: `private` called with a non-literal argument (2:11-2:18)",
-                "invalid-method-visibility: `private` called with a non-literal argument (2:20-2:27)",
+                "InvalidMethodVisibility: `private` called with a non-literal argument (2:11-2:18)",
+                "InvalidMethodVisibility: `private` called with a non-literal argument (2:20-2:27)",
             ]
         );
 
@@ -2165,7 +2250,7 @@ mod visibility_tests {
         // module_function in a class is always invalid regardless of args
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `module_function` can only be used in modules (2:3-2:37)"]
+            vec!["InvalidMethodVisibility: `module_function` can only be used in modules (2:3-2:37)"]
         );
 
         for def in context.graph().definitions().values() {
@@ -2251,12 +2336,13 @@ mod visibility_tests {
         assert_local_diagnostics_eq!(
             &context,
             vec![
-                "invalid-method-visibility: `private_class_method` called at top level (1:1-1:34)",
-                "invalid-method-visibility: `private_class_method` called at top level (2:1-2:39)",
-                "invalid-method-visibility: `private_class_method` called with a non-literal argument (6:24-6:35)",
-                "invalid-method-visibility: `private_class_method` does not accept `attr_*` arguments (8:24-8:41)",
-                "invalid-method-visibility: `private_class_method` requires a singleton method definition (9:24-9:39)",
-            ]
+                "InvalidMethodVisibility: `private_class_method` called at top level (1:1-1:34)",
+                "InvalidMethodVisibility: `private_class_method` called at top level (2:1-2:39)",
+                "InvalidMethodVisibility: `private_class_method` called with a non-literal argument (6:24-6:35)",
+                "InvalidMethodVisibility: `private_class_method` does not accept `attr_*` arguments (8:24-8:41)",
+                "InvalidMethodVisibility: `private_class_method` requires a singleton method definition (9:24-9:39)",
+            ],
+            severity: Severity::Warning
         );
     }
 
@@ -2290,7 +2376,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `private_class_method` called with a non-literal argument (5:28-5:40)"]
+            vec!["InvalidMethodVisibility: `private_class_method` called with a non-literal argument (5:28-5:40)"]
         );
 
         assert_definition_at!(&context, "5:25-5:26", MethodVisibility, |def| {
@@ -2311,7 +2397,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec!["invalid-method-visibility: `private_class_method` called at top level (1:1-1:32)"]
+            vec!["InvalidMethodVisibility: `private_class_method` called at top level (1:1-1:32)"]
         );
         assert_constant_references_eq!(&context, ["NESTED_REF"]);
     }
@@ -2396,7 +2482,7 @@ mod visibility_tests {
         assert_local_diagnostics_eq!(
             &context,
             vec![
-                "invalid-method-visibility: `private_class_method` array element must be a Symbol, String, or method definition (5:32-5:42)"
+                "InvalidMethodVisibility: `private_class_method` array element must be a Symbol, String, or method definition (5:32-5:42)"
             ]
         );
 
@@ -2424,9 +2510,7 @@ mod visibility_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            vec![
-                "invalid-method-visibility: `private_class_method` requires a singleton method definition (2:25-2:49)"
-            ]
+            vec!["InvalidMethodVisibility: `private_class_method` requires a singleton method definition (2:25-2:49)"]
         );
 
         for def in context.graph().definitions().values() {
@@ -2458,7 +2542,7 @@ mod visibility_tests {
         assert_local_diagnostics_eq!(
             &context,
             vec![
-                "invalid-method-visibility: `private_class_method` array argument must be the only argument (5:24-5:28)"
+                "InvalidMethodVisibility: `private_class_method` array argument must be the only argument (5:24-5:28)"
             ]
         );
 
@@ -2761,8 +2845,8 @@ mod constant_reference_tests {
         assert_local_diagnostics_eq!(
             &context,
             [
-                "dynamic-constant-reference: Dynamic constant reference (3:6-3:14)",
-                "parse-warning: assigned but unused variable - foo (5:1-5:4)",
+                "DynamicConstantReference: Dynamic constant reference (3:6-3:14)",
+                "ParseWarning: assigned but unused variable - foo (5:1-5:4)",
             ]
         );
 
@@ -2945,7 +3029,7 @@ mod method_reference_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["parse-error: unexpected ... when the parent method is not forwarding (31:5-31:8)"]
+            ["ParseError: unexpected ... when the parent method is not forwarding (31:5-31:8)"]
         );
 
         assert_method_references_eq!(
@@ -3031,18 +3115,18 @@ mod method_reference_tests {
         assert_local_diagnostics_eq!(
             &context,
             [
-                "parse-warning: possibly useless use of != in void context (1:1-1:7)",
-                "parse-warning: possibly useless use of % in void context (2:1-2:6)",
-                "parse-warning: possibly useless use of & in void context (3:1-3:6)",
-                "parse-warning: possibly useless use of * in void context (5:1-5:6)",
-                "parse-warning: possibly useless use of ** in void context (6:1-6:7)",
-                "parse-warning: possibly useless use of + in void context (7:1-7:6)",
-                "parse-warning: possibly useless use of - in void context (8:1-8:6)",
-                "parse-warning: possibly useless use of / in void context (9:1-9:6)",
-                "parse-warning: possibly useless use of == in void context (11:1-11:7)",
-                "parse-warning: possibly useless use of ^ in void context (14:1-14:6)",
-                "parse-warning: possibly useless use of | in void context (15:1-15:6)",
-                "parse-warning: possibly useless use of <=> in void context (17:1-17:8)"
+                "ParseWarning: possibly useless use of != in void context (1:1-1:7)",
+                "ParseWarning: possibly useless use of % in void context (2:1-2:6)",
+                "ParseWarning: possibly useless use of & in void context (3:1-3:6)",
+                "ParseWarning: possibly useless use of * in void context (5:1-5:6)",
+                "ParseWarning: possibly useless use of ** in void context (6:1-6:7)",
+                "ParseWarning: possibly useless use of + in void context (7:1-7:6)",
+                "ParseWarning: possibly useless use of - in void context (8:1-8:6)",
+                "ParseWarning: possibly useless use of / in void context (9:1-9:6)",
+                "ParseWarning: possibly useless use of == in void context (11:1-11:7)",
+                "ParseWarning: possibly useless use of ^ in void context (14:1-14:6)",
+                "ParseWarning: possibly useless use of | in void context (15:1-15:6)",
+                "ParseWarning: possibly useless use of <=> in void context (17:1-17:8)"
             ]
         );
 
@@ -3064,7 +3148,7 @@ mod method_reference_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["parse-warning: possibly useless use of < in void context (1:1-1:6)"]
+            ["ParseWarning: possibly useless use of < in void context (1:1-1:6)"]
         );
 
         assert_method_references_eq!(&context, ["x", "<", "<=>", "y"]);
@@ -3080,7 +3164,7 @@ mod method_reference_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["parse-warning: possibly useless use of <= in void context (1:1-1:7)"]
+            ["ParseWarning: possibly useless use of <= in void context (1:1-1:7)"]
         );
 
         assert_method_references_eq!(&context, ["x", "<=", "<=>", "y"]);
@@ -3096,7 +3180,7 @@ mod method_reference_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["parse-warning: possibly useless use of > in void context (1:1-1:6)"]
+            ["ParseWarning: possibly useless use of > in void context (1:1-1:6)"]
         );
 
         assert_method_references_eq!(&context, ["x", "<=>", ">", "y"]);
@@ -3112,7 +3196,7 @@ mod method_reference_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["parse-warning: possibly useless use of >= in void context (1:1-1:7)"]
+            ["ParseWarning: possibly useless use of >= in void context (1:1-1:7)"]
         );
 
         assert_method_references_eq!(&context, ["x", "<=>", ">=", "y"]);
@@ -3616,10 +3700,10 @@ mod superclass_tests {
         assert_local_diagnostics_eq!(
             &context,
             [
-                "dynamic-ancestor: Dynamic superclass (1:13-1:24)",
-                "dynamic-ancestor: Dynamic superclass (2:13-2:16)",
-                "dynamic-constant-reference: Dynamic constant reference (4:13-4:16)",
-                "dynamic-ancestor: Dynamic superclass (4:13-4:21)",
+                "DynamicAncestor: Dynamic superclass (1:13-1:24)",
+                "DynamicAncestor: Dynamic superclass (2:13-2:16)",
+                "DynamicConstantReference: Dynamic constant reference (4:13-4:16)",
+                "DynamicAncestor: Dynamic superclass (4:13-4:21)",
             ]
         );
 
@@ -3802,15 +3886,15 @@ mod mixin_tests {
         assert_local_diagnostics_eq!(
             &context,
             [
-                "dynamic-constant-reference: Dynamic constant reference (1:9-1:12)",
-                "dynamic-ancestor: Dynamic mixin argument (1:9-1:17)",
-                "dynamic-constant-reference: Dynamic constant reference (2:9-2:12)",
-                "dynamic-ancestor: Dynamic mixin argument (2:9-2:17)",
-                "dynamic-constant-reference: Dynamic constant reference (3:8-3:11)",
-                "dynamic-ancestor: Dynamic mixin argument (3:8-3:16)",
-                "dynamic-ancestor: Dynamic mixin argument (5:9-5:12)",
-                "dynamic-ancestor: Dynamic mixin argument (6:9-6:12)",
-                "dynamic-ancestor: Dynamic mixin argument (7:8-7:11)"
+                "DynamicConstantReference: Dynamic constant reference (1:9-1:12)",
+                "DynamicAncestor: Dynamic mixin argument (1:9-1:17)",
+                "DynamicConstantReference: Dynamic constant reference (2:9-2:12)",
+                "DynamicAncestor: Dynamic mixin argument (2:9-2:17)",
+                "DynamicConstantReference: Dynamic constant reference (3:8-3:11)",
+                "DynamicAncestor: Dynamic mixin argument (3:8-3:16)",
+                "DynamicAncestor: Dynamic mixin argument (5:9-5:12)",
+                "DynamicAncestor: Dynamic mixin argument (6:9-6:12)",
+                "DynamicAncestor: Dynamic mixin argument (7:8-7:11)"
             ]
         );
         assert!(context.graph().definitions().is_empty());
@@ -3829,9 +3913,9 @@ mod mixin_tests {
         assert_local_diagnostics_eq!(
             &context,
             [
-                "top-level-mixin-self: Top level mixin self (1:9-1:13)",
-                "top-level-mixin-self: Top level mixin self (2:9-2:13)",
-                "top-level-mixin-self: Top level mixin self (3:8-3:12)"
+                "TopLevelMixinSelf: Top level mixin self (1:9-1:13)",
+                "TopLevelMixinSelf: Top level mixin self (2:9-2:13)",
+                "TopLevelMixinSelf: Top level mixin self (3:8-3:12)"
             ]
         );
 
@@ -5112,6 +5196,29 @@ mod dynamic_namespace_tests {
         });
     }
 
+    #[test]
+    fn index_extend_self_in_anonymous_module() {
+        let context = index_source({
+            "
+            Module.new do
+              extend self
+            end
+            "
+        });
+        assert_no_local_diagnostics!(&context);
+
+        assert_definition_at!(&context, "1:1-3:4", Module, |anonymous_module| {
+            let extend = anonymous_module.mixins().first().unwrap();
+            let constant_reference = context
+                .graph()
+                .constant_references()
+                .get(extend.constant_reference_id())
+                .unwrap();
+
+            assert_eq!(anonymous_module.name_id(), constant_reference.name_id());
+        });
+    }
+
     #[test]
     fn index_singleton_method_in_class_new() {
         let context = index_source({
@@ -5205,9 +5312,10 @@ mod diagnostic_tests {
         assert_local_diagnostics_eq!(
             &context,
             [
-                "parse-error: expected an `end` to close the `class` statement (1:1-1:6)",
-                "parse-error: unexpected end-of-input, assuming it is closing the parent top level context (1:10-2:1)"
-            ]
+                "ParseError: expected an `end` to close the `class` statement (1:1-1:6)",
+                "ParseError: unexpected end-of-input, assuming it is closing the parent top level context (1:10-2:1)"
+            ],
+            severity: Severity::Error
         );
 
         // We still index the definition, even though it has errors
@@ -5227,7 +5335,8 @@ mod diagnostic_tests {
 
         assert_local_diagnostics_eq!(
             &context,
-            ["parse-warning: assigned but unused variable - foo (1:1-1:4)"]
+            ["ParseWarning: assigned but unused variable - foo (1:1-1:4)"],
+            severity: Severity::Warning
         );
     }
 }

data/rust/rubydex/src/lib.rs

@@ -16,6 +16,7 @@ pub mod listing;
 pub mod model;
 pub mod offset;
 pub mod operation;
+pub(crate) mod path_helpers;
 pub mod position;
 pub mod query;
 pub mod resolution;

data/rust/rubydex/src/listing.rs

@@ -1,6 +1,7 @@
 use crate::{
     errors::Errors,
     job_queue::{Job, JobQueue},
+    path_helpers,
 };
 use crossbeam_channel::{Sender, unbounded};
 use glob::Pattern;
@@ -129,7 +130,7 @@ pub fn collect_file_paths<S: BuildHasher>(
         Arc::new(excluded.iter().filter_map(|entry| Pattern::new(entry).ok()).collect());
 
     for path in paths {
-        let Ok(path) = std::path::absolute(&path) else {
+        let Ok(path) = std::path::absolute(&path).map(path_helpers::simplified) else {
             errors_tx
                 .send(Errors::FileError(format!("Failed to resolve path `{path}`")))
                 .expect("errors receiver dropped before run completion");
@@ -420,6 +421,30 @@ mod tests {
         assert_eq!(files, [foo.to_str().unwrap().to_string()]);
     }
 
+    #[cfg(windows)]
+    #[test]
+    fn collect_files_excludes_a_directory_below_a_verbatim_root() {
+        // Exclusions are joined onto the workspace path the configuration resolved, which is spelled plainly. A root
+        // given verbatim only matches them once it is spelled that way too.
+        let context = Context::new();
+        context.touch(&PathBuf::from("excluded").join("skipped.rb"));
+
+        let mut excluded = HashSet::new();
+        excluded.insert(
+            context
+                .absolute_path_to("excluded")
+                .to_string_lossy()
+                .replace('\\', "/")
+                .into_boxed_str(),
+        );
+
+        let (files, errors) =
+            collect_file_paths(vec![format!(r"\\?\{}", context.absolute_path().display())], &excluded);
+
+        assert!(errors.is_empty());
+        assert!(files.is_empty(), "expected the exclusion to apply: {files:?}");
+    }
+
     #[test]
     fn collect_files_excludes_nested_files_matching_globs() {
         let context = Context::new();