Syntax node children now passed by ref (#8044)

Author: eytan-starkware

crates/cairo-lang-formatter/src/formatter_impl.rs

@@ -1207,7 +1207,7 @@ impl<'a> FormatterImpl<'a> {
     fn format_terminal(&mut self, syntax_node: &SyntaxNode<'a>) {
         // TODO(spapini): Introduce a Terminal and a Token enum in ast.rs to make this cleaner.
         let children = syntax_node.get_children(self.db);
-        let [leading, token, trailing] = &children[..] else {
+        let [leading, token, trailing] = children else {
             panic!("Terminal node should have 3 children.");
         };
         // The first newlines is the leading trivia correspond exactly to empty lines.

crates/cairo-lang-formatter/src/node_properties.rs

@@ -963,7 +963,7 @@ impl<'a> SyntaxNodeFormat for SyntaxNode<'a> {
             );
             if (!is_expr_or_pattern_list || children.len() > 2)
             // Ensure that this node is the last element in the list.
-            && is_last(self, &children)
+            && is_last(self, children)
             {
                 return true;
             }
@@ -978,7 +978,7 @@ impl<'a> SyntaxNodeFormat for SyntaxNode<'a> {
             let statements_node = statement_node.parent(db).unwrap();
             // Checking if not the last statement, as `;` may be there to prevent the block from
             // returning the value of the current block.
-            let not_last = !is_last(&statement_node, &statements_node.get_children(db));
+            let not_last = !is_last(&statement_node, statements_node.get_children(db));
             let children = statement_node.get_children(db);
             if not_last
                 && matches!(
@@ -999,7 +999,7 @@ impl<'a> SyntaxNodeFormat for SyntaxNode<'a> {
         {
             let path_segment_node = self.parent(db).unwrap();
             let path_node = path_segment_node.parent(db).unwrap();
-            if !is_last(&path_segment_node, &path_node.get_children(db)) {
+            if !is_last(&path_segment_node, path_node.get_children(db)) {
                 false
             } else {
                 matches!(

crates/cairo-lang-parser/src/printer.rs

@@ -210,7 +210,7 @@ impl<'a> Printer<'a> {
             NodeKind::Struct { members: expected_children }
             | NodeKind::Terminal { members: expected_children, .. } => {
                 self.print_internal_struct(
-                    &children,
+                    children,
                     &expected_children,
                     indent.as_str(),
                     under_top_level,

crates/cairo-lang-syntax/src/node/db.rs

@@ -1,5 +1,3 @@
-use std::sync::Arc;
-
 use cairo_lang_filesystem::db::FilesGroup;
 use cairo_lang_utils::Upcast;
 
@@ -19,9 +17,11 @@ pub trait SyntaxGroup: FilesGroup + for<'a> Upcast<'a, dyn FilesGroup> {
     fn intern_syntax_node<'a>(&'a self, field: SyntaxNodeLongId<'a>) -> SyntaxNode<'a>;
 
     /// Query for caching [SyntaxNode::get_children].
-    fn get_children<'a>(&'a self, node: SyntaxNode<'a>) -> Arc<Vec<SyntaxNode<'a>>>;
+    #[salsa::transparent]
+    fn get_children<'a>(&'a self, node: SyntaxNode<'a>) -> &'a [SyntaxNode<'a>];
 }
 
-fn get_children<'a>(db: &'a dyn SyntaxGroup, node: SyntaxNode<'a>) -> Arc<Vec<SyntaxNode<'a>>> {
-    node.get_children_impl(db).into()
+#[salsa::tracked(returns(ref))]
+fn get_children<'a>(db: &'a dyn SyntaxGroup, node: SyntaxNode<'a>) -> Vec<SyntaxNode<'a>> {
+    node.get_children_impl(db)
 }

crates/cairo-lang-syntax/src/node/element_list.rs

@@ -1,5 +1,4 @@
 use std::marker::PhantomData;
-use std::sync::Arc;
 
 use super::SyntaxGroup;
 use crate::node::{SyntaxNode, TypedSyntaxNode};
@@ -25,8 +24,7 @@ impl<'db, T: TypedSyntaxNode<'db>> ElementList<'db, T, 1> {
         &self,
         db: &'db dyn SyntaxGroup,
     ) -> impl ExactSizeIterator<Item = T> + DoubleEndedIterator + 'db {
-        ElementListRawIter::new(self.node.get_children(db).as_slice().into())
-            .map(move |x| T::from_syntax_node(db, x))
+        self.node.get_children(db).iter().copied().map(move |x| T::from_syntax_node(db, x))
     }
     pub fn has_tail(&self, _db: &dyn SyntaxGroup) -> bool {
         false
@@ -40,51 +38,14 @@ impl<'db, T: TypedSyntaxNode<'db>> ElementList<'db, T, 2> {
         &self,
         db: &'db dyn SyntaxGroup,
     ) -> impl ExactSizeIterator<Item = T> + DoubleEndedIterator + 'db {
-        ElementListRawIter::new(self.node.get_children(db).as_slice().into())
+        self.node
+            .get_children(db)
+            .iter()
+            .copied()
             .step_by(2)
             .map(move |x| T::from_syntax_node(db, x))
     }
     pub fn has_tail(&self, db: &dyn SyntaxGroup) -> bool {
         !self.node.get_children(db).len().is_multiple_of(2)
     }
 }
-
-/// Iterator over the raw elements of an `ElementList`.
-struct ElementListRawIter<'a> {
-    /// The `Arc` storing the actual node.
-    _data: Arc<[SyntaxNode<'a>]>,
-    /// Actual iterator over the elements.
-    iter: std::slice::Iter<'a, SyntaxNode<'a>>,
-}
-
-impl<'a> ElementListRawIter<'a> {
-    fn new(data: Arc<[SyntaxNode<'a>]>) -> Self {
-        // We leak the Arc to get a 'static reference, and keep the Arc in the struct to avoid
-        // leaks.
-        let ptr: *const [SyntaxNode<'_>] = Arc::as_ptr(&data);
-        let slice: &'static [SyntaxNode<'_>] = unsafe { std::mem::transmute(&*ptr) };
-        let iter = slice.iter();
-        Self { _data: data, iter }
-    }
-}
-
-impl<'a> Iterator for ElementListRawIter<'a> {
-    type Item = SyntaxNode<'a>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next().copied()
-    }
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}
-impl ExactSizeIterator for ElementListRawIter<'_> {
-    fn len(&self) -> usize {
-        self.iter.len()
-    }
-}
-impl DoubleEndedIterator for ElementListRawIter<'_> {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        self.iter.next_back().copied()
-    }
-}

crates/cairo-lang-syntax/src/node/iter.rs

@@ -1,5 +1,3 @@
-use std::sync::Arc;
-
 use crate::node::SyntaxNode;
 use crate::node::db::SyntaxGroup;
 
@@ -33,7 +31,7 @@ pub struct Preorder<'a> {
 
 struct PreorderLayer<'a> {
     start: SyntaxNode<'a>,
-    children: Option<(Arc<Vec<SyntaxNode<'a>>>, usize)>,
+    children: Option<(&'a [SyntaxNode<'a>], usize)>,
 }
 
 impl<'a> Preorder<'a> {

crates/cairo-lang-syntax/src/node/mod.rs

@@ -1,5 +1,4 @@
 use core::hash::Hash;
-use std::sync::Arc;
 
 use cairo_lang_filesystem::ids::FileId;
 use cairo_lang_filesystem::span::{TextOffset, TextPosition, TextSpan, TextWidth};
@@ -139,7 +138,7 @@ impl<'a> SyntaxNode<'a> {
     }
 
     /// Gets the children syntax nodes of the current node.
-    pub fn get_children(&self, db: &'a dyn SyntaxGroup) -> Arc<Vec<SyntaxNode<'a>>> {
+    pub fn get_children(&self, db: &'a dyn SyntaxGroup) -> &'a [SyntaxNode<'a>] {
         db.get_children(*self)
     }