rubydex 0.4.1-aarch64-linux → 0.4.2-aarch64-linux

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

@@ -93,8 +93,8 @@ pub struct RubyIndexer<'a> {
 
 impl<'a> RubyIndexer<'a> {
     #[must_use]
-    pub fn new(uri: String, source: &'a str) -> Self {
-        let uri_id = UriId::from(&uri);
+    pub fn new(uri: Box<str>, source: &'a str) -> Self {
+        let uri_id = UriId::from(&*uri);
         let local_graph = LocalGraph::new(uri_id, Document::new(uri, source));
 
         Self {
@@ -120,7 +120,7 @@ impl<'a> RubyIndexer<'a> {
             self.local_graph.add_diagnostic(
                 Rule::ParseError,
                 Offset::from_prism_location(&error.location()),
-                error.message().to_string(),
+                String::from_utf8_lossy(error.message()).to_string(),
             );
         }
 
@@ -128,7 +128,7 @@ impl<'a> RubyIndexer<'a> {
             self.local_graph.add_diagnostic(
                 Rule::ParseWarning,
                 Offset::from_prism_location(&warning.location()),
-                warning.message().to_string(),
+                String::from_utf8_lossy(warning.message()).to_string(),
             );
         }
 
@@ -313,7 +313,9 @@ impl<'a> RubyIndexer<'a> {
                 }
             }
 
-            if let Some(block) = parameters_list.block() {
+            if let Some(block) = parameters_list.block()
+                && let Some(block) = block.as_block_parameter_node()
+            {
                 let location = block.name_loc().unwrap_or_else(|| block.location());
                 let str_id = self.local_graph.intern_string(Self::location_to_string(&location));
 
@@ -1389,8 +1391,8 @@ impl<'a> RubyIndexer<'a> {
         match arg {
             ruby_prism::Node::SymbolNode { .. } => {
                 let symbol = arg.as_symbol_node().unwrap();
-                let value_loc = symbol.value_loc()?;
-                Some((Self::location_to_string(&value_loc), value_loc))
+                let content_loc = symbol.content_loc();
+                Some((Self::location_to_string(&content_loc), content_loc))
             }
             ruby_prism::Node::StringNode { .. } => {
                 let string = arg.as_string_node().unwrap();
@@ -1522,7 +1524,7 @@ impl CommentGroup {
     // Accepts the next line if it is continuous
     fn accepts(&self, next: &ruby_prism::Comment, source: &str) -> bool {
         let current_end_offset = self.end_offset;
-        let next_line_start_offset = next.location().start_offset();
+        let next_line_start_offset = next.location().start() as usize;
 
         let between = &source.as_bytes()[current_end_offset..next_line_start_offset];
         if !between.iter().all(|&b| b.is_ascii_whitespace()) {
@@ -1538,7 +1540,7 @@ impl CommentGroup {
     // 1. still move the group end offset to the end of the magic comment
     // 2. not add the comment to the comments array
     fn add_comment(&mut self, comment: &ruby_prism::Comment) {
-        self.end_offset = comment.location().end_offset();
+        self.end_offset = comment.location().end() as usize;
         let text = String::from_utf8_lossy(comment.location().as_slice()).to_string();
 
         if text.lines().any(|line| line.starts_with("# @deprecated")) {
@@ -1547,7 +1549,7 @@ impl CommentGroup {
 
         self.comments.push(Comment::new(
             Offset::from_prism_location(&comment.location()),
-            text.trim().to_string(),
+            text.trim().into(),
         ));
     }
 
@@ -1984,12 +1986,18 @@ impl Visit<'_> for RubyIndexer<'_> {
             });
         };
 
-        let message_loc = node.message_loc();
+        let message_loc = if node.name().as_slice().is_empty() {
+            // Incomplete calls like `Foo.` have no message. We still index them using the call operator location, so
+            // that the receiver's singleton class gets created, which completion depends on
+            node.call_operator_loc()
+        } else {
+            node.message_loc()
+        };
 
-        if message_loc.is_none() {
+        let Some(message_loc) = message_loc else {
             // No message, we can't index this node
             return;
-        }
+        };
 
         let message = String::from_utf8_lossy(node.name().as_slice()).to_string();
 
@@ -2217,11 +2225,11 @@ impl Visit<'_> for RubyIndexer<'_> {
                     self.visit(&receiver);
                 }
 
-                self.index_method_reference(message.clone(), &node.message_loc().unwrap(), method_receiver);
+                self.index_method_reference(message.clone(), &message_loc, method_receiver);
 
                 match message.as_str() {
                     ">" | "<" | ">=" | "<=" => {
-                        self.index_method_reference("<=>".to_string(), &node.message_loc().unwrap(), method_receiver);
+                        self.index_method_reference("<=>".to_string(), &message_loc, method_receiver);
                     }
                     _ => {}
                 }
@@ -2382,7 +2390,7 @@ impl Visit<'_> for RubyIndexer<'_> {
             match expression {
                 ruby_prism::Node::SymbolNode { .. } => {
                     let symbol = expression.as_symbol_node().unwrap();
-                    let name = Self::location_to_string(&symbol.value_loc().unwrap());
+                    let name = Self::location_to_string(&symbol.content_loc());
                     self.index_method_reference(name, &node.location(), None);
                 }
                 _ => {
@@ -2394,13 +2402,13 @@ impl Visit<'_> for RubyIndexer<'_> {
 
     fn visit_alias_method_node(&mut self, node: &ruby_prism::AliasMethodNode<'_>) {
         let mut new_name = if let Some(symbol_node) = node.new_name().as_symbol_node() {
-            Self::location_to_string(&symbol_node.value_loc().unwrap())
+            Self::location_to_string(&symbol_node.content_loc())
         } else {
             Self::location_to_string(&node.new_name().location())
         };
 
         let mut old_name = if let Some(symbol_node) = node.old_name().as_symbol_node() {
-            Self::location_to_string(&symbol_node.value_loc().unwrap())
+            Self::location_to_string(&symbol_node.content_loc())
         } else {
             Self::location_to_string(&node.old_name().location())
         };

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

@@ -900,7 +900,7 @@ mod class_and_module_tests {
             assert_def_name_eq!(&context, def, "Baz");
             assert_def_name_offset_eq!(&context, def, "3:11-3:14");
             assert!(def.superclass_ref().is_none());
-            assert!(def.members().is_empty());
+            assert_eq!(def.members(), []);
 
             assert_definition_at!(&context, "2:3-4:6", Class, |parent_nesting| {
                 assert_eq!(parent_nesting.id(), def.lexical_nesting_id().unwrap());
@@ -948,7 +948,7 @@ mod class_and_module_tests {
             assert_def_name_eq!(&context, def, "Quuux");
             assert_def_name_offset_eq!(&context, def, "3:13-3:18");
             assert!(def.superclass_ref().is_none());
-            assert!(def.members().is_empty());
+            assert_eq!(def.members(), []);
 
             assert_definition_at!(&context, "2:3-4:6", Class, |parent_nesting| {
                 assert_eq!(parent_nesting.id(), def.lexical_nesting_id().unwrap());
@@ -1250,6 +1250,46 @@ mod method_tests {
         });
     }
 
+    #[test]
+    fn index_def_node_with_no_block_parameter() {
+        let context = index_source({
+            "
+                def foo(a, &nil); end
+                "
+        });
+
+        assert_no_local_diagnostics!(&context);
+
+        assert_definition_at!(&context, "1:1-1:22", Method, |def| {
+            assert_simple_signature!(def, |params| {
+                assert_eq!(params.len(), 1);
+                assert_parameter!(&params[0], RequiredPositional, |param| {
+                    assert_string_eq!(context, param.str(), "a");
+                });
+            });
+        });
+    }
+
+    #[test]
+    fn index_def_node_with_trailing_comma_in_parameters() {
+        let context = index_source({
+            "
+                def foo(a,); end
+                "
+        });
+
+        assert_no_local_diagnostics!(&context);
+
+        assert_definition_at!(&context, "1:1-1:17", Method, |def| {
+            assert_simple_signature!(def, |params| {
+                assert_eq!(params.len(), 1);
+                assert_parameter!(&params[0], RequiredPositional, |param| {
+                    assert_string_eq!(context, param.str(), "a");
+                });
+            });
+        });
+    }
+
     #[test]
     fn index_nested_method_definitions() {
         let context = index_source({

data/rust/rubydex/src/indexing.rs

@@ -101,7 +101,7 @@ impl Job for IndexingJob {
         };
 
         let language = self.path.extension().map_or(LanguageId::Ruby, LanguageId::from);
-        let local_graph = build_local_graph(url.to_string(), &source, &language, self.backend);
+        let local_graph = build_local_graph(url.to_string().into(), &source, &language, self.backend);
 
         self.local_graph_tx
             .send(local_graph)
@@ -110,8 +110,8 @@ impl Job for IndexingJob {
 }
 
 /// Indexes a single source string in memory, dispatching to the appropriate indexer based on `language_id`.
-pub fn index_source(graph: &mut Graph, uri: &str, source: &str, language_id: &LanguageId) {
-    let local_graph = build_local_graph(uri.to_string(), source, language_id, IndexerBackend::RubyIndexer);
+pub fn index_source(graph: &mut Graph, uri: Box<str>, source: &str, language_id: &LanguageId) {
+    let local_graph = build_local_graph(uri, source, language_id, IndexerBackend::RubyIndexer);
     graph.consume_document_changes(local_graph);
 }
 
@@ -153,7 +153,7 @@ pub fn index_files(graph: &mut Graph, paths: Vec<PathBuf>, backend: IndexerBacke
 
 /// Indexes a source string using the appropriate indexer for the given language.
 #[must_use]
-pub fn build_local_graph(uri: String, source: &str, language: &LanguageId, backend: IndexerBackend) -> LocalGraph {
+pub fn build_local_graph(uri: Box<str>, source: &str, language: &LanguageId, backend: IndexerBackend) -> LocalGraph {
     match language {
         LanguageId::Ruby => match backend {
             IndexerBackend::RubyIndexer => {
@@ -203,7 +203,7 @@ mod tests {
         let mut graph = Graph::new();
         let errors = index_files(&mut graph, vec![relative_to_pwd.clone()], IndexerBackend::RubyIndexer);
 
-        assert!(errors.is_empty());
+        assert_eq!(errors.as_slice(), []);
         assert_eq!(graph.documents().len(), 2);
     }
 
@@ -228,7 +228,7 @@ mod tests {
         assert_eq!(6, graph.definitions().len());
         assert_eq!(2, graph.documents().len());
 
-        index_source(&mut graph, &uri, "", &LanguageId::Ruby);
+        index_source(&mut graph, uri.into(), "", &LanguageId::Ruby);
 
         assert_eq!(5, graph.definitions().len());
         assert_eq!(2, graph.documents().len());

data/rust/rubydex/src/listing.rs

@@ -211,7 +211,7 @@ mod tests {
 
         let (files, errors) = collect_document_paths(&context, &["foo", "bar"]);
 
-        assert!(errors.is_empty());
+        assert_eq!(errors.as_slice(), []);
 
         assert_eq!(
             files,
@@ -236,7 +236,7 @@ mod tests {
 
         let (files, errors) = collect_document_paths(&context, &["bar"]);
 
-        assert!(errors.is_empty());
+        assert_eq!(errors.as_slice(), []);
 
         assert_eq!(
             files,
@@ -260,7 +260,7 @@ mod tests {
 
         let (files, errors) = collect_document_paths(&context, &["lib", "sig", "config.ru"]);
 
-        assert!(errors.is_empty());
+        assert_eq!(errors.as_slice(), []);
 
         assert_eq!(
             [
@@ -287,7 +287,7 @@ mod tests {
             &HashSet::new(),
         );
 
-        assert!(files.is_empty());
+        assert_eq!(files, [] as [std::path::PathBuf; 0]);
 
         assert_eq!(
             errors,
@@ -315,8 +315,8 @@ mod tests {
 
         let (files, errors) = collect_file_paths(vec![relative_root.to_string_lossy().into_owned()], &HashSet::new());
 
-        assert!(errors.is_empty());
-        assert!(!files.is_empty());
+        assert_eq!(errors.as_slice(), []);
+        assert_ne!(files, [] as [std::path::PathBuf; 0]);
         assert!(
             files.iter().all(|path| path.is_absolute()),
             "expected only absolute paths, got {files:?}"
@@ -336,7 +336,7 @@ mod tests {
 
         let (files, errors) = collect_document_paths_with_exclusions(&context, &["included", "excluded"], &excluded);
 
-        assert!(errors.is_empty());
+        assert_eq!(errors.as_slice(), []);
         assert_eq!(files, [included.to_str().unwrap().to_string()]);
     }
 
@@ -353,7 +353,7 @@ mod tests {
 
         let (files, errors) = collect_document_paths_with_exclusions(&context, &["root"], &excluded);
 
-        assert!(errors.is_empty());
+        assert_eq!(errors.as_slice(), []);
         assert_eq!(files, [kept.to_str().unwrap().to_string()]);
     }
 
@@ -374,7 +374,7 @@ mod tests {
 
         let (files, errors) = collect_document_paths(&context, &["project"]);
 
-        assert!(errors.is_empty());
+        assert_eq!(errors.as_slice(), []);
         // The symlink is indexed at its own path, not resolved to the target.
         let alias = PathBuf::from("project").join("alias.rb");
         assert_eq!(files, [alias.to_str().unwrap().to_string()]);
@@ -398,7 +398,7 @@ mod tests {
 
         let (files, errors) = collect_document_paths(&context, &["project"]);
 
-        assert!(errors.is_empty());
+        assert_eq!(errors.as_slice(), []);
         // The symlinked directory is not followed, so `outside/bar.rb` is never reached.
         assert_eq!(files, [kept.to_str().unwrap().to_string()]);
     }
@@ -415,7 +415,7 @@ mod tests {
 
         let (files, errors) = collect_document_paths(&context, &["link"]);
 
-        assert!(errors.is_empty());
+        assert_eq!(errors.as_slice(), []);
         // The requested root is traversed; files are indexed under the requested (symlink) path.
         let foo = PathBuf::from("link").join("foo.rb");
         assert_eq!(files, [foo.to_str().unwrap().to_string()]);
@@ -458,7 +458,7 @@ mod tests {
 
         let (files, errors) = collect_document_paths_with_exclusions(&context, &["lib"], &excluded);
 
-        assert!(errors.is_empty());
+        assert_eq!(errors.as_slice(), []);
         assert_eq!(files, [kept.to_str().unwrap().to_string()]);
     }
 }

data/rust/rubydex/src/model/built_in.rs

@@ -48,7 +48,7 @@ pub fn add_built_in_data(graph: &mut Graph) {
       class Class < Module
       end
     ";
-    indexing::index_source(graph, uri.as_ref(), source, &LanguageId::Rbs);
+    indexing::index_source(graph, uri.to_string().into(), source, &LanguageId::Rbs);
 
     // Creating declarations eagerly is still necessary because we need to associate correct ownership data no matter in
     // what order we discover classes and modules

data/rust/rubydex/src/model/comment.rs

@@ -4,13 +4,13 @@ use crate::offset::Offset;
 #[derive(Debug, Clone)]
 pub struct Comment {
     offset: Offset,
-    string: String,
+    string: Box<str>,
 }
-assert_mem_size!(Comment, 32);
+assert_mem_size!(Comment, 24);
 
 impl Comment {
     #[must_use]
-    pub fn new(offset: Offset, string: String) -> Self {
+    pub fn new(offset: Offset, string: Box<str>) -> Self {
         Self { offset, string }
     }
 
@@ -20,7 +20,7 @@ impl Comment {
     }
 
     #[must_use]
-    pub fn string(&self) -> &String {
+    pub fn string(&self) -> &str {
         &self.string
     }
 }

data/rust/rubydex/src/model/declaration.rs

@@ -119,7 +119,7 @@ pub struct DeclarationCore<T> {
     /// The list of definition IDs that compose this declaration
     definition_ids: Vec<DefinitionId>,
     /// The set of references that are made to this declaration
-    references: IdentityHashSet<T>,
+    references: Vec<T>,
     /// The ID of the owner of this declaration
     owner_id: DeclarationId,
 }
@@ -130,7 +130,7 @@ impl<T: Eq + Hash> DeclarationCore<T> {
         Self {
             name: name.into_boxed_str(),
             definition_ids: Vec::new(),
-            references: IdentityHashSet::default(),
+            references: Vec::new(),
             owner_id,
         }
     }
@@ -152,16 +152,24 @@ impl<T: Eq + Hash> DeclarationCore<T> {
     }
 
     #[must_use]
-    pub fn references(&self) -> &IdentityHashSet<T> {
+    pub fn references(&self) -> &[T] {
         &self.references
     }
 
     pub fn add_reference(&mut self, reference_id: T) {
-        self.references.insert(reference_id);
+        debug_assert!(
+            !self.references.contains(&reference_id),
+            "Cannot add the same exact reference to a declaration twice. Duplicate reference IDs"
+        );
+
+        self.references.push(reference_id);
     }
 
     pub fn remove_reference(&mut self, reference_id: &T) {
-        self.references.remove(reference_id);
+        if let Some(pos) = self.references.iter().position(|id| id == reference_id) {
+            self.references.swap_remove(pos);
+            self.references.shrink_to_fit();
+        }
     }
 
     #[must_use]
@@ -493,7 +501,7 @@ impl Declaration {
     /// Returns the constant reference IDs for declarations that track constant references (`Namespace`, `Constant`,
     /// `ConstantAlias`). Returns `None` for other declaration types.
     #[must_use]
-    pub fn constant_references(&self) -> Option<&IdentityHashSet<ConstantReferenceId>> {
+    pub fn constant_references(&self) -> Option<&[ConstantReferenceId]> {
         match self {
             Declaration::Namespace(it) => Some(it.references()),
             Declaration::Constant(it) | Declaration::ConstantAlias(it) => Some(it.references()),
@@ -559,7 +567,7 @@ impl Namespace {
     }
 
     #[must_use]
-    pub fn references(&self) -> &IdentityHashSet<ConstantReferenceId> {
+    pub fn references(&self) -> &[ConstantReferenceId] {
         all_namespaces!(self, it => &it.core.references)
     }
 
@@ -674,31 +682,31 @@ impl Namespace {
 }
 
 namespace_declaration!(Class, ClassDeclaration);
-assert_mem_size!(ClassDeclaration, 184);
+assert_mem_size!(ClassDeclaration, 176);
 namespace_declaration!(Module, ModuleDeclaration);
-assert_mem_size!(ModuleDeclaration, 184);
+assert_mem_size!(ModuleDeclaration, 176);
 namespace_declaration!(SingletonClass, SingletonClassDeclaration);
-assert_mem_size!(SingletonClassDeclaration, 184);
+assert_mem_size!(SingletonClassDeclaration, 176);
 namespace_declaration!(Todo, TodoDeclaration);
-assert_mem_size!(TodoDeclaration, 184);
+assert_mem_size!(TodoDeclaration, 176);
 
 pub type ConstantDeclaration = DeclarationCore<ConstantReferenceId>;
-assert_mem_size!(ConstantDeclaration, 80);
+assert_mem_size!(ConstantDeclaration, 72);
 
 pub type MethodDeclaration = DeclarationCore<MethodReferenceId>;
-assert_mem_size!(MethodDeclaration, 80);
+assert_mem_size!(MethodDeclaration, 72);
 
 pub type GlobalVariableDeclaration = DeclarationCore<GlobalVariableReferenceId>;
-assert_mem_size!(GlobalVariableDeclaration, 80);
+assert_mem_size!(GlobalVariableDeclaration, 72);
 
 pub type InstanceVariableDeclaration = DeclarationCore<InstanceVariableReferenceId>;
-assert_mem_size!(InstanceVariableDeclaration, 80);
+assert_mem_size!(InstanceVariableDeclaration, 72);
 
 pub type ClassVariableDeclaration = DeclarationCore<ClassVariableReferenceId>;
-assert_mem_size!(ClassVariableDeclaration, 80);
+assert_mem_size!(ClassVariableDeclaration, 72);
 
 pub type ConstantAliasDeclaration = DeclarationCore<ConstantReferenceId>;
-assert_mem_size!(ConstantAliasDeclaration, 80);
+assert_mem_size!(ConstantAliasDeclaration, 72);
 
 #[cfg(test)]
 mod tests {

data/rust/rubydex/src/model/document.rs

@@ -12,7 +12,7 @@ use crate::model::ids::{ConstantReferenceId, DefinitionId, MethodReferenceId};
 // definitions and references discovered in it
 #[derive(Debug)]
 pub struct Document {
-    uri: String,
+    uri: Box<str>,
     line_index: LineIndex,
     definition_ids: Vec<DefinitionId>,
     method_reference_ids: Vec<MethodReferenceId>,
@@ -20,11 +20,11 @@ pub struct Document {
     diagnostics: Vec<Diagnostic>,
     content_hash: u64,
 }
-assert_mem_size!(Document, 184);
+assert_mem_size!(Document, 176);
 
 impl Document {
     #[must_use]
-    pub fn new(uri: String, source: &str) -> Self {
+    pub fn new(uri: Box<str>, source: &str) -> Self {
         Self {
             uri,
             line_index: LineIndex::new(source),
@@ -176,7 +176,7 @@ mod tests {
     #[test]
     #[should_panic(expected = "Cannot add the same exact definition to a document twice. Duplicate definition IDs")]
     fn inserting_duplicate_definitions() {
-        let mut document = Document::new("file:///foo.rb".to_string(), "class Foo; end");
+        let mut document = Document::new("file:///foo.rb".into(), "class Foo; end");
         let def_id = DefinitionId::new(123);
 
         document.add_definition(def_id);
@@ -187,7 +187,7 @@ mod tests {
 
     #[test]
     fn tracking_references() {
-        let mut document = Document::new("file:///foo.rb".to_string(), "class Foo; end");
+        let mut document = Document::new("file:///foo.rb".into(), "class Foo; end");
         let method_ref = MethodReferenceId::new(1);
         let constant_ref = ConstantReferenceId::new(2);
 
@@ -202,7 +202,7 @@ mod tests {
     fn require_path() {
         let root = test_root();
         let path = root.join("lib").join("foo").join("bar.rb");
-        let uri = Url::from_file_path(path).unwrap().to_string();
+        let uri = Url::from_file_path(path).unwrap().to_string().into();
         let load_paths = [root.join("lib")];
 
         let document = Document::new(uri, "");
@@ -213,7 +213,7 @@ mod tests {
     fn require_path_first_load_path_wins() {
         let root = test_root();
         let path = root.join("a").join("b").join("foo.rb");
-        let uri = Url::from_file_path(path).unwrap().to_string();
+        let uri = Url::from_file_path(path).unwrap().to_string().into();
         let load_path_a = root.join("a");
         let load_path_ab = root.join("a").join("b");
         let load_paths = [load_path_a, load_path_ab];
@@ -228,18 +228,18 @@ mod tests {
         let load_paths = [root.join("lib")];
 
         // non-file URI
-        let document = Document::new("untitled:Untitled-1".to_string(), "");
+        let document = Document::new("untitled:Untitled-1".into(), "");
         assert!(document.require_path(&load_paths).is_none());
 
         // non-.rb extension
         let path = root.join("lib").join("foo.so");
-        let uri = Url::from_file_path(path).unwrap().to_string();
+        let uri = Url::from_file_path(path).unwrap().to_string().into();
         let document = Document::new(uri, "");
         assert!(document.require_path(&load_paths).is_none());
 
         // /libfoo is not under /lib - should not match due to partial directory name
         let path = root.join("libfoo").join("bar.rb");
-        let uri = Url::from_file_path(path).unwrap().to_string();
+        let uri = Url::from_file_path(path).unwrap().to_string().into();
         let document = Document::new(uri, "");
         assert!(document.require_path(&load_paths).is_none());
     }
@@ -248,7 +248,7 @@ mod tests {
     fn require_path_with_spaces() {
         let root = test_root();
         let path = root.join("lib").join("space foo").join("bar.rb");
-        let uri = Url::from_file_path(path).unwrap().to_string();
+        let uri = Url::from_file_path(path).unwrap().to_string().into();
         let load_paths = [root.join("lib")];
 
         let document = Document::new(uri, "");

data/rust/rubydex/src/model/graph.rs

@@ -1759,7 +1759,7 @@ mod tests {
         assert_eq!(context.graph().constant_references.len(), 4);
         {
             let declaration = context.graph().declarations().get(&DeclarationId::from("Foo")).unwrap();
-            assert!(declaration.as_namespace().unwrap().references().is_empty());
+            assert_eq!(declaration.as_namespace().unwrap().references(), []);
         }
     }
 
@@ -2090,14 +2090,14 @@ mod tests {
         let definitions = context.graph().get("CommentedClass").unwrap();
         let def = definitions.first().unwrap();
         assert_eq!(
-            def.comments().iter().map(Comment::string).collect::<Vec<&String>>(),
+            def.comments().iter().map(Comment::string).collect::<Vec<&str>>(),
             ["# This is a class comment", "# Multi-line comment"]
         );
 
         let definitions = context.graph().get("CommentedModule").unwrap();
         let def = definitions.first().unwrap();
         assert_eq!(
-            def.comments().iter().map(Comment::string).collect::<Vec<&String>>(),
+            def.comments().iter().map(Comment::string).collect::<Vec<&str>>(),
             ["# Module comment"]
         );
 

data/rust/rubydex/src/offset.rs

@@ -30,21 +30,9 @@ impl Offset {
         Self { start, end }
     }
 
-    /// # Panics
-    ///
-    /// This function can panic if the Prism location offsets do not fit into a u32
     #[must_use]
     pub fn from_prism_location(location: &ruby_prism::Location) -> Self {
-        Self::new(
-            location
-                .start_offset()
-                .try_into()
-                .expect("Expected usize `start` to fit in `u32`"),
-            location
-                .end_offset()
-                .try_into()
-                .expect("Expected usize `end` to fit in `u32`"),
-        )
+        Self::new(location.start(), location.end())
     }
 
     /// # Panics