From 2e7a9165e5a2693721f5aefcad39501068b2ee97 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 1 Mar 2024 17:38:58 -0500
Subject: [PATCH] chore: Optimize `TraitsResolver` by using fewer allocations

---
 clarity/src/vm/ast/traits_resolver/mod.rs | 40 ++++++++++-------------
 1 file changed, 17 insertions(+), 23 deletions(-)

diff --git a/clarity/src/vm/ast/traits_resolver/mod.rs b/clarity/src/vm/ast/traits_resolver/mod.rs
index 4cdb2f54a..bff0c40e7 100644
--- a/clarity/src/vm/ast/traits_resolver/mod.rs
+++ b/clarity/src/vm/ast/traits_resolver/mod.rs
@@ -50,7 +50,7 @@ impl TraitsResolver {
 
         for exp in contract_ast.pre_expressions.iter() {
             // Top-level comment nodes have been filtered from `args` by `try_parse_pre_expr`.
-            let Some((define_type, args)) = self.try_parse_pre_expr(exp) else {
+            let Some((define_type, args)) = self.try_parse_pre_expr(&exp) else {
                 continue;
             };
 
@@ -71,7 +71,7 @@ impl TraitsResolver {
 
                             // Traverse and probe for generics nested in the trait definition
                             self.probe_for_generics(
-                                trait_definition.iter().collect(),
+                                trait_definition.iter(),
                                 &mut referenced_traits,
                                 true,
                             )?;
@@ -144,7 +144,7 @@ impl TraitsResolver {
                 | DefineFunctions::PrivateFunction
                 | DefineFunctions::ReadOnlyFunction => {
                     // Traverse and probe for generics in functions type definitions
-                    self.probe_for_generics(args, &mut referenced_traits, true)?;
+                    self.probe_for_generics(args.into_iter(), &mut referenced_traits, true)?;
                 }
                 DefineFunctions::Constant
                 | DefineFunctions::Map
@@ -152,7 +152,11 @@ impl TraitsResolver {
                 | DefineFunctions::FungibleToken
                 | DefineFunctions::NonFungibleToken => {
                     if !args.is_empty() {
-                        self.probe_for_generics(args[1..].to_vec(), &mut referenced_traits, false)?;
+                        self.probe_for_generics(
+                            args[1..].to_vec().into_iter(),
+                            &mut referenced_traits,
+                            false,
+                        )?;
                     }
                 }
             };
@@ -180,31 +184,25 @@ impl TraitsResolver {
     ) -> Option<(DefineFunctions, Vec<&'a PreSymbolicExpression>)> {
         let expressions = expression.match_list()?;
         // Filter comment nodes out of the list of expressions.
-        let filtered_expressions: Vec<&PreSymbolicExpression> = expressions
+        let mut filtered_expressions = expressions
             .iter()
-            .filter(|expr| expr.match_comment().is_none())
-            .collect();
-        let (function_name, args) = filtered_expressions.split_first()?;
-        let function_name = function_name.match_atom()?;
+            .filter(|expr| expr.match_comment().is_none());
+        let function_name = filtered_expressions.next()?.match_atom()?;
         let define_type = DefineFunctions::lookup_by_name(function_name)?;
-        Some((define_type, args.to_vec()))
+        Some((define_type, filtered_expressions.collect()))
     }
 
     #[allow(clippy::only_used_in_recursion)]
-    fn probe_for_generics(
+    fn probe_for_generics<'a>(
         &mut self,
-        exprs: Vec<&PreSymbolicExpression>,
+        exprs: impl Iterator<Item = &'a PreSymbolicExpression>,
         referenced_traits: &mut HashMap<ClarityName, PreSymbolicExpression>,
         should_reference: bool,
     ) -> ParseResult<()> {
-        for &expression in exprs.iter() {
+        for expression in exprs {
             match &expression.pre_expr {
                 List(list) => {
-                    self.probe_for_generics(
-                        list.iter().collect(),
-                        referenced_traits,
-                        should_reference,
-                    )?;
+                    self.probe_for_generics(list.iter(), referenced_traits, should_reference)?;
                 }
                 TraitReference(trait_name) => {
                     if should_reference {
@@ -214,11 +212,7 @@ impl TraitsResolver {
                     }
                 }
                 Tuple(atoms) => {
-                    self.probe_for_generics(
-                        atoms.iter().collect(),
-                        referenced_traits,
-                        should_reference,
-                    )?;
+                    self.probe_for_generics(atoms.iter(), referenced_traits, should_reference)?;
                 }
                 _ => { /* no-op */ }
             }