KCL parser: Allow .prop or [index] to follow any expression (#7371)

Previously in a member expression like `foo.x` or `foo[3]`, `foo` had to be an identifier. You could not do something like `f().x` (and if you tried, you got a cryptic error). Rather than make the error better, we should just accept any expression to be the LHS of a member expression (aka its 'object').

This does knock our "parse lots of function calls" from 58 to 55 calls before it stack overflows. But I think it's fine, we'll address this in https://github.com/KittyCAD/modeling-app/pull/6226 when I get back to it.

Closes https://github.com/KittyCAD/modeling-app/issues/7273

rust/kcl-lib/src/parsing/ast/digest.rs

@@ -4,7 +4,7 @@ use crate::parsing::ast::types::{
     Annotation, ArrayExpression, ArrayRangeExpression, AscribedExpression, BinaryExpression, BinaryPart, BodyItem,
     CallExpressionKw, DefaultParamVal, ElseIf, Expr, ExpressionStatement, FunctionExpression, FunctionType, Identifier,
     IfExpression, ImportItem, ImportSelector, ImportStatement, ItemVisibility, KclNone, LabelledExpression, Literal,
-    LiteralIdentifier, LiteralValue, MemberExpression, MemberObject, Name, ObjectExpression, ObjectProperty, Parameter,
+    LiteralIdentifier, LiteralValue, MemberExpression, Name, ObjectExpression, ObjectProperty, Parameter,
     PipeExpression, PipeSubstitution, PrimitiveType, Program, ReturnStatement, TagDeclarator, Type, TypeDeclaration,
     UnaryExpression, VariableDeclaration, VariableDeclarator, VariableKind,
 };
@@ -167,15 +167,6 @@ impl BinaryPart {
     }
 }
 
-impl MemberObject {
-    pub fn compute_digest(&mut self) -> Digest {
-        match self {
-            MemberObject::MemberExpression(me) => me.compute_digest(),
-            MemberObject::Identifier(id) => id.compute_digest(),
-        }
-    }
-}
-
 impl LiteralIdentifier {
     pub fn compute_digest(&mut self) -> Digest {
         match self {

rust/kcl-lib/src/parsing/ast/mod.rs

@@ -2,7 +2,7 @@ pub(crate) mod digest;
 pub mod types;
 
 use crate::{
-    parsing::ast::types::{BinaryPart, BodyItem, Expr, LiteralIdentifier, MemberObject},
+    parsing::ast::types::{BinaryPart, BodyItem, Expr, LiteralIdentifier},
     ModuleId,
 };
 
@@ -57,15 +57,6 @@ impl BinaryPart {
     }
 }
 
-impl MemberObject {
-    pub fn module_id(&self) -> ModuleId {
-        match self {
-            MemberObject::MemberExpression(member_expression) => member_expression.module_id,
-            MemberObject::Identifier(identifier) => identifier.module_id,
-        }
-    }
-}
-
 impl LiteralIdentifier {
     pub fn module_id(&self) -> ModuleId {
         match self {

rust/kcl-lib/src/parsing/ast/types/mod.rs

@@ -2756,47 +2756,6 @@ impl ObjectProperty {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
-#[ts(export)]
-#[serde(tag = "type")]
-pub enum MemberObject {
-    MemberExpression(BoxNode<MemberExpression>),
-    Identifier(BoxNode<Identifier>),
-}
-
-impl MemberObject {
-    pub fn start(&self) -> usize {
-        match self {
-            MemberObject::MemberExpression(member_expression) => member_expression.start,
-            MemberObject::Identifier(identifier) => identifier.start,
-        }
-    }
-
-    pub fn end(&self) -> usize {
-        match self {
-            MemberObject::MemberExpression(member_expression) => member_expression.end,
-            MemberObject::Identifier(identifier) => identifier.end,
-        }
-    }
-
-    pub(crate) fn contains_range(&self, range: &SourceRange) -> bool {
-        let sr = SourceRange::from(self);
-        sr.contains_range(range)
-    }
-}
-
-impl From<MemberObject> for SourceRange {
-    fn from(obj: MemberObject) -> Self {
-        Self::new(obj.start(), obj.end(), obj.module_id())
-    }
-}
-
-impl From<&MemberObject> for SourceRange {
-    fn from(obj: &MemberObject) -> Self {
-        Self::new(obj.start(), obj.end(), obj.module_id())
-    }
-}
-
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
 #[ts(export)]
 #[serde(tag = "type")]
@@ -2842,7 +2801,7 @@ impl From<&LiteralIdentifier> for SourceRange {
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct MemberExpression {
-    pub object: MemberObject,
+    pub object: Expr,
     pub property: LiteralIdentifier,
     pub computed: bool,
 
@@ -2864,12 +2823,7 @@ impl Node<MemberExpression> {
 impl MemberExpression {
     /// Rename all identifiers that have the old name to the new given name.
     fn rename_identifiers(&mut self, old_name: &str, new_name: &str) {
-        match &mut self.object {
-            MemberObject::MemberExpression(ref mut member_expression) => {
-                member_expression.rename_identifiers(old_name, new_name)
-            }
-            MemberObject::Identifier(ref mut identifier) => identifier.rename(old_name, new_name),
-        }
+        self.object.rename_identifiers(old_name, new_name);
 
         match &mut self.property {
             LiteralIdentifier::Identifier(ref mut identifier) => identifier.rename(old_name, new_name),

rust/kcl-lib/src/parsing/ast/types/path.rs

@@ -1,6 +1,6 @@
 use serde::Serialize;
 
-use super::{BodyItem, Expr, MemberObject, Node, Program};
+use super::{BodyItem, Expr, Node, Program};
 use crate::SourceRange;
 
 /// A traversal path through the AST to a node.
@@ -248,7 +248,7 @@ impl NodePath {
             Expr::MemberExpression(node) => {
                 if node.object.contains_range(&range) {
                     path.push(Step::MemberExpressionObject);
-                    return Self::from_member_expr_object(&node.object, range, path);
+                    return NodePath::from_expr(&node.object, range, path);
                 }
                 if node.property.contains_range(&range) {
                     path.push(Step::MemberExpressionProperty);
@@ -313,18 +313,6 @@ impl NodePath {
         Some(path)
     }
 
-    fn from_member_expr_object(mut expr: &MemberObject, range: SourceRange, mut path: NodePath) -> Option<NodePath> {
-        while let MemberObject::MemberExpression(node) = expr {
-            if !node.object.contains_range(&range) {
-                break;
-            }
-            path.push(Step::MemberExpressionObject);
-            expr = &node.object;
-        }
-
-        Some(path)
-    }
-
     pub fn is_empty(&self) -> bool {
         self.steps.is_empty()
     }