Accept type ascription within binary expressions (#6849)

Signed-off-by: Nick Cameron <nrc@ncameron.org>

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

@@ -162,6 +162,7 @@ impl BinaryPart {
             BinaryPart::UnaryExpression(ue) => ue.compute_digest(),
             BinaryPart::MemberExpression(me) => me.compute_digest(),
             BinaryPart::IfExpression(e) => e.compute_digest(),
+            BinaryPart::AscribedExpression(e) => e.compute_digest(),
         }
     }
 }

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

@@ -52,6 +52,7 @@ impl BinaryPart {
             BinaryPart::UnaryExpression(unary_expression) => unary_expression.module_id,
             BinaryPart::MemberExpression(member_expression) => member_expression.module_id,
             BinaryPart::IfExpression(e) => e.module_id,
+            BinaryPart::AscribedExpression(e) => e.module_id,
         }
     }
 }

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

@@ -1215,6 +1215,7 @@ impl From<&BinaryPart> for Expr {
             BinaryPart::UnaryExpression(unary_expression) => Expr::UnaryExpression(unary_expression.clone()),
             BinaryPart::MemberExpression(member_expression) => Expr::MemberExpression(member_expression.clone()),
             BinaryPart::IfExpression(e) => Expr::IfExpression(e.clone()),
+            BinaryPart::AscribedExpression(e) => Expr::AscribedExpression(e.clone()),
         }
     }
 }
@@ -1281,6 +1282,7 @@ pub enum BinaryPart {
     UnaryExpression(BoxNode<UnaryExpression>),
     MemberExpression(BoxNode<MemberExpression>),
     IfExpression(BoxNode<IfExpression>),
+    AscribedExpression(BoxNode<AscribedExpression>),
 }
 
 impl From<BinaryPart> for SourceRange {
@@ -1306,6 +1308,7 @@ impl BinaryPart {
             BinaryPart::UnaryExpression(unary_expression) => unary_expression.get_constraint_level(),
             BinaryPart::MemberExpression(member_expression) => member_expression.get_constraint_level(),
             BinaryPart::IfExpression(e) => e.get_constraint_level(),
+            BinaryPart::AscribedExpression(e) => e.expr.get_constraint_level(),
         }
     }
 
@@ -1324,6 +1327,7 @@ impl BinaryPart {
             }
             BinaryPart::MemberExpression(_) => {}
             BinaryPart::IfExpression(e) => e.replace_value(source_range, new_value),
+            BinaryPart::AscribedExpression(e) => e.expr.replace_value(source_range, new_value),
         }
     }
 
@@ -1336,6 +1340,7 @@ impl BinaryPart {
             BinaryPart::UnaryExpression(unary_expression) => unary_expression.start,
             BinaryPart::MemberExpression(member_expression) => member_expression.start,
             BinaryPart::IfExpression(e) => e.start,
+            BinaryPart::AscribedExpression(e) => e.start,
         }
     }
 
@@ -1348,6 +1353,7 @@ impl BinaryPart {
             BinaryPart::UnaryExpression(unary_expression) => unary_expression.end,
             BinaryPart::MemberExpression(member_expression) => member_expression.end,
             BinaryPart::IfExpression(e) => e.end,
+            BinaryPart::AscribedExpression(e) => e.end,
         }
     }
 
@@ -1369,6 +1375,7 @@ impl BinaryPart {
                 member_expression.rename_identifiers(old_name, new_name)
             }
             BinaryPart::IfExpression(ref mut if_expression) => if_expression.rename_identifiers(old_name, new_name),
+            BinaryPart::AscribedExpression(ref mut e) => e.expr.rename_identifiers(old_name, new_name),
         }
     }
 }

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

@@ -631,8 +631,7 @@ fn operand(i: &mut TokenSlice) -> PResult<BinaryPart> {
                 | Expr::ArrayExpression(_)
                 | Expr::ArrayRangeExpression(_)
                 | Expr::ObjectExpression(_)
-                | Expr::LabelledExpression(..)
-                | Expr::AscribedExpression(..) => return Err(CompilationError::fatal(source_range, TODO_783)),
+                | Expr::LabelledExpression(..) => return Err(CompilationError::fatal(source_range, TODO_783)),
                 Expr::None(_) => {
                     return Err(CompilationError::fatal(
                         source_range,
@@ -658,6 +657,7 @@ fn operand(i: &mut TokenSlice) -> PResult<BinaryPart> {
                 Expr::CallExpressionKw(x) => BinaryPart::CallExpressionKw(x),
                 Expr::MemberExpression(x) => BinaryPart::MemberExpression(x),
                 Expr::IfExpression(x) => BinaryPart::IfExpression(x),
+                Expr::AscribedExpression(x) => BinaryPart::AscribedExpression(x),
             };
             Ok(expr)
         })
@@ -2068,7 +2068,7 @@ fn expr_allowed_in_pipe_expr(i: &mut TokenSlice) -> PResult<Expr> {
 }
 
 fn possible_operands(i: &mut TokenSlice) -> PResult<Expr> {
-    alt((
+    let mut expr = alt((
         unary_expression.map(Box::new).map(Expr::UnaryExpression),
         bool_value.map(Expr::Literal),
         member_expression.map(Box::new).map(Expr::MemberExpression),
@@ -2081,7 +2081,14 @@ fn possible_operands(i: &mut TokenSlice) -> PResult<Expr> {
     .context(expected(
         "a KCL value which can be used as an argument/operand to an operator",
     ))
-    .parse_next(i)
+    .parse_next(i)?;
+
+    let ty = opt((colon, opt(whitespace), argument_type)).parse_next(i)?;
+    if let Some((_, _, ty)) = ty {
+        expr = Expr::AscribedExpression(Box::new(AscribedExpression::new(expr, ty)))
+    }
+
+    Ok(expr)
 }
 
 /// Parse an item visibility specifier, e.g. export.