refactor: ErasedSegment::children to return an iterator

crates/lib-core/src/parser/segments/base.rs

@@ -383,14 +383,13 @@ impl ErasedSegment {
             .clone()
     }
 
-    pub fn children(&self, seg_types: &SyntaxSet) -> Vec<ErasedSegment> {
-        let mut buff = Vec::new();
-        for seg in self.segments() {
-            if seg_types.contains(seg.get_type()) {
-                buff.push(seg.clone());
-            }
-        }
-        buff
+    pub fn children<'set>(
+        &'set self,
+        seg_types: &'set SyntaxSet,
+    ) -> impl Iterator<Item = &ErasedSegment> + '_ {
+        self.segments()
+            .iter()
+            .filter(move |seg| seg_types.contains(seg.get_type()))
     }
 
     pub fn iter_patches(&self, templated_file: &TemplatedFile) -> Vec<FixPatch> {

crates/lib-core/src/parser/segments/from.rs

@@ -27,12 +27,12 @@ impl FromClauseSegment {
             );
         }
 
-        for clause in &direct_table_children {
+        for &clause in &direct_table_children {
             let tmp;
 
             let alias = FromExpressionElementSegment(clause.clone()).eventual_alias();
 
-            let table_expr = if direct_table_children.contains(clause) {
+            let table_expr = if direct_table_children.contains(&clause) {
                 clause
             } else {
                 tmp = clause
@@ -45,7 +45,7 @@ impl FromClauseSegment {
         }
 
         for clause in join_clauses {
-            let aliases = JoinClauseSegment(clause).eventual_aliases();
+            let aliases = JoinClauseSegment(clause.clone()).eventual_aliases();
 
             if !aliases.is_empty() {
                 buff.extend(aliases);

crates/lib-core/src/utils/analysis/query.rs

@@ -320,7 +320,7 @@ impl<T: Default + Clone> Query<'_, T> {
             selectables.extend(
                 segment
                     .children(const { &SyntaxSet::new(&[SyntaxKind::SelectStatement]) })
-                    .into_iter()
+                    .cloned()
                     .map(|selectable| Selectable {
                         selectable,
                         dialect,

crates/lib-core/src/utils/analysis/select.rs

@@ -67,7 +67,6 @@ pub fn get_select_statement_info(
     let select_targets =
         select_clause.children(const { &SyntaxSet::new(&[SyntaxKind::SelectClauseElement]) });
     let select_targets = select_targets
-        .iter()
         .map(|it| SelectClauseElementSegment(it.clone()))
         .collect_vec();
 
@@ -257,8 +256,8 @@ fn get_lambda_argument_columns(segment: &ErasedSegment, dialect: Option<&Dialect
                         .unwrap();
 
                     if start_bracket.raw() == "(" {
-                        let bracketed_arguments =
-                            child_segment.children(&SyntaxSet::single(SyntaxKind::ColumnReference));
+                        let bracketed_arguments = child_segment
+                            .children(const { &SyntaxSet::single(SyntaxKind::ColumnReference) });
 
                         lambda_argument_columns.extend(
                             bracketed_arguments

crates/lib/src/rules/aliasing/al08.rs

@@ -118,7 +118,7 @@ FROM
                         None,
                     ))
                 }
-                Entry::Vacant(entry) => _ = entry.insert(clause_element),
+                Entry::Vacant(entry) => _ = entry.insert(clause_element.clone()),
             };
         }
 

crates/lib/src/rules/structure/st06.rs

@@ -119,8 +119,9 @@ from x
         }
 
         let select_clause_segment = context.segment.clone();
-        let select_target_elements = select_clause_segment
-            .children(const { &SyntaxSet::new(&[SyntaxKind::SelectClauseElement]) });
+        let select_target_elements: Vec<_> = select_clause_segment
+            .children(const { &SyntaxSet::new(&[SyntaxKind::SelectClauseElement]) })
+            .collect();
 
         if select_target_elements.is_empty() {
             return Vec::new();
@@ -132,7 +133,7 @@ from x
             .collect();
         seen_band_elements.push(Vec::new());
 
-        for segment in &select_target_elements {
+        for &segment in &select_target_elements {
             let mut current_element_band: Option<usize> = None;
 
             for (i, band) in enumerate(SELECT_ELEMENT_ORDER_PREFERENCE) {
@@ -226,10 +227,10 @@ from x
             let fixes = zip(select_target_elements, ordered_select_target_elements)
                 .filter_map(
                     |(initial_select_target_element, replace_select_target_element)| {
-                        (initial_select_target_element != replace_select_target_element).then(
+                        (initial_select_target_element != &replace_select_target_element).then(
                             || {
                                 LintFix::replace(
-                                    initial_select_target_element,
+                                    initial_select_target_element.clone(),
                                     vec![replace_select_target_element],
                                     None,
                                 )

crates/lib/src/rules/structure/st09.rs

@@ -169,8 +169,9 @@ left join bar
             let comparison_operator = subcondition[1].clone();
             let first_column_reference = subcondition[0].clone();
             let second_column_reference = subcondition[2].clone();
-            let raw_comparison_operators = comparison_operator
-                .children(const { &SyntaxSet::new(&[SyntaxKind::RawComparisonOperator]) });
+            let raw_comparison_operators: Vec<_> = comparison_operator
+                .children(const { &SyntaxSet::new(&[SyntaxKind::RawComparisonOperator]) })
+                .collect();
             let first_table_seg = first_column_reference
                 .child(
                     const {