chore(fmt): format parentheses expression

compiler/noirc_frontend/src/ast/expression.rs

@@ -26,6 +26,7 @@ pub enum ExpressionKind {
     Variable(Path),
     Tuple(Vec<Expression>),
     Lambda(Box<Lambda>),
+    Parentheses(Box<Expression>),
     Error,
 }
 
@@ -479,6 +480,7 @@ impl Display for ExpressionKind {
                 write!(f, "({})", elements.join(", "))
             }
             Lambda(lambda) => lambda.fmt(f),
+            Parentheses(subexpr) => write!(f, "({subexpr})"),
             Error => write!(f, "Error"),
         }
     }

compiler/noirc_frontend/src/hir/resolution/resolver.rs

@@ -1260,6 +1260,7 @@ impl<'a> Resolver<'a> {
                     captures: lambda_context.captures,
                 })
             }),
+            ExpressionKind::Parentheses(subexpr) => return self.resolve_expression(*subexpr),
         };
 
         let expr_id = self.interner.push_expr(hir_expr);

compiler/noirc_frontend/src/parser/parser.rs

@@ -1554,7 +1554,9 @@ where
         literal(),
     ))
     .map_with_span(Expression::new)
-    .or(parenthesized(expr_parser.clone()))
+    .or(parenthesized(expr_parser.clone()).map_with_span(|subexpr, span| {
+        Expression::new(ExpressionKind::Parentheses(subexpr.into()), span)
+    }))
     .or(tuple(expr_parser))
     .labelled(ParsingRuleLabel::Atom)
 }

tooling/nargo_fmt/src/visitor/expr.rs

@@ -84,6 +84,7 @@ impl FmtVisitor<'_> {
                     literal.to_string()
                 }
             },
+            ExpressionKind::Parentheses(subexpr) => format!("({})", self.format_expr(*subexpr)),
             // TODO:
             _expr => slice!(self, span.start(), span.end()).to_string(),
         }

tooling/nargo_fmt/tests/expected/expr.nr

@@ -71,3 +71,11 @@ fn test() {
     // 324
     34
 }
+
+fn parentheses() {
+    value + (x as Field)
+}
+
+fn parentheses() {
+    (i as u8) + (j as u8) + (k as u8) + x + y + z
+}

tooling/nargo_fmt/tests/input/expr.nr

@@ -80,3 +80,11 @@ fn test() {
     // 324
     34
 }
+
+fn parentheses() {
+    value + ( x as Field )
+}
+
+fn parentheses() {
+    ( i as u8 ) + ( j as u8 ) + (  k as u8   ) +   x + y   +   z
+}