KCL: Rm clone in parser for 3% speedup (#7857)

Previously, building a member expression required cloning the Expr that
became the member expression's object. Now I changed things a bit, so
that the object expr doesn't need to be cloned.

This is used every time an Expr is parsed, so it's somewhat hot code,
and fixing the clone gave a consistent 2-4% speedup across tests on my
Macbook Pro.

Author: adamchalmers

rust/kcl-lib/src/parsing/parser.rs

@@ -1369,15 +1369,17 @@ fn member_expression_subscript(i: &mut TokenSlice) -> ModalResult<(Expr, usize,
     Ok((property, end, computed))
 }
 
-/// Get a property of an object, or an index of an array, or a member of a collection.
-/// Can be arbitrarily nested, e.g. `people[i]['adam'].age`.
-fn build_member_expression(object: Expr, i: &mut TokenSlice) -> ModalResult<Node<MemberExpression>> {
+fn find_members(i: &mut TokenSlice) -> ModalResult<Vec<(Expr, usize, bool)>> {
     // Now a sequence of members.
     let member = alt((member_expression_dot, member_expression_subscript)).context(expected("a member/property, e.g. size.x and size['height'] and size[0] are all different ways to access a member/property of 'size'"));
-    let mut members: Vec<_> = repeat(1.., member)
+    repeat(1.., member)
         .context(expected("a sequence of at least one members/properties"))
-        .parse_next(i)?;
+        .parse_next(i)
+}
 
+/// Get a property of an object, or an index of an array, or a member of a collection.
+/// Can be arbitrarily nested, e.g. `people[i]['adam'].age`.
+fn build_member_expression(object: Expr, mut members: Vec<(Expr, usize, bool)>) -> Node<MemberExpression> {
     // Process the first member.
     // It's safe to call remove(0), because the vec is created from repeat(1..),
     // which is guaranteed to have >=1 elements.
@@ -1397,7 +1399,7 @@ fn build_member_expression(object: Expr, i: &mut TokenSlice) -> ModalResult<Node
     );
 
     // Each remaining member wraps the current member expression inside another member expression.
-    Ok(members
+    members
         .into_iter()
         // Take the accumulated member expression from the previous iteration,
         // and use it as the `object` of a new, bigger member expression.
@@ -1413,7 +1415,7 @@ fn build_member_expression(object: Expr, i: &mut TokenSlice) -> ModalResult<Node
                 end,
                 module_id,
             )
-        }))
+        })
 }
 
 /// Find a noncode node which occurs just after a body item,
@@ -2146,8 +2148,8 @@ fn expr_allowed_in_pipe_expr(i: &mut TokenSlice) -> ModalResult<Expr> {
     .context(expected("a KCL expression (but not a pipe expression)"))
     .parse_next(i)?;
 
-    let maybe_member = build_member_expression(parsed_expr.clone(), i); // TODO: Eliminate this clone.
-    if let Ok(mem) = maybe_member {
+    if let Ok(Some(members)) = opt(find_members).parse_next(i) {
+        let mem = build_member_expression(parsed_expr, members);
         return Ok(Expr::MemberExpression(Box::new(mem)));
     }
     Ok(parsed_expr)
@@ -2170,8 +2172,8 @@ fn possible_operands(i: &mut TokenSlice) -> ModalResult<Expr> {
         "a KCL value which can be used as an argument/operand to an operator",
     ))
     .parse_next(i)?;
-    let maybe_member = build_member_expression(expr.clone(), i);
-    if let Ok(mem) = maybe_member {
+    if let Ok(Some(members)) = opt(find_members).parse_next(i) {
+        let mem = build_member_expression(expr, members);
         expr = Expr::MemberExpression(Box::new(mem));
     }