Fixing New Expression

Author: teofr

crates/solidity-v2/inputs/language/src/definition.rs

@@ -3903,10 +3903,10 @@ ExpressionTrailingBlock: (Expression<'arena>, Block<'arena>) = {
 //    option calls)
 //
 // Note: To simplify my life right now, this is a bit different from what's generated, but we'll get there
-Expression0<IndexAccessPathRule>: Expression<'arena> = {
+Expression0<IndexAccessPathRule, NewExpressionRule>: Expression<'arena> = {
         <_IndexAccessPath: IndexAccessPathRule> => new_expression_index_access_path(arena, <>),
         
-        <_NewExpression: NewExpression>  => new_expression_new_expression(arena, <>),
+        <_NewExpression: NewExpressionRule> => new_expression_new_expression(arena, <>),
         
         <_TupleExpression: ProtoTuple<"True">>  => new_expression_tuple_expression(arena, new_tuple_expression_from_proto_tuple(arena, <>)),
         
@@ -3935,20 +3935,24 @@ NoIndexAccessPath_Expr: IndexAccessPath<'arena> = {};
 
 // We simplifiy all these levels of expressions into a single one, there's no need
 // for precedence here
-Expression1<IndexAccessPathRule>: Expression<'arena> = {
+Expression1<IndexAccessPathRule, NewExpressionRule>: Expression<'arena> = {
         
-        <_Expression: Expression1<NoIndexAccessPath_Expr>>  <_open_bracket: OpenBracket>  <_start: (Expression)?>  <_end: (IndexAccessEnd)?>  <_close_bracket: CloseBracket>  => new_expression_index_access_expression(arena, new_index_access_expression(arena, <>)),
+        <_Expression: Expression1<NoIndexAccessPath_Expr, NoNewExpression>>  <_open_bracket: OpenBracket>  <_start: (Expression)?>  <_end: (IndexAccessEnd)?>  <_close_bracket: CloseBracket>  => new_expression_index_access_expression(arena, new_index_access_expression(arena, <>)),
         
-        <_Expression: Expression1<IndexAccessPath<NoIdentPath>>>  <_period: Period>  <_member: MemberAccessIdentifier>  => new_expression_member_access_expression(arena, new_member_access_expression(arena, <>)),
+        <_Expression: Expression1<IndexAccessPath<NoIdentPath>, NoNewExpression>>  <_period: Period>  <_member: MemberAccessIdentifier>  => new_expression_member_access_expression(arena, new_member_access_expression(arena, <>)),
         
-        <_Expression: Expression1<IndexAccessPath<IdentifierPath>>>  <_open_brace: OpenBrace>  <_options: CallOptions>  <_close_brace: CloseBrace>  => new_expression_call_options_expression(arena, new_call_options_expression(arena, <>)),
+        <_Expression: Expression1<IndexAccessPath<IdentifierPath>, NewExpression>>  <_open_brace: OpenBrace>  <_options: CallOptions>  <_close_brace: CloseBrace>  => new_expression_call_options_expression(arena, new_call_options_expression(arena, <>)),
         
-        <_Expression: Expression1<IndexAccessPath<IdentifierPath>>>  <_arguments: ArgumentsDeclaration>  => new_expression_function_call_expression(arena, new_function_call_expression(arena, <>)),
+        <_Expression: Expression1<IndexAccessPath<IdentifierPath>, NewExpression>>  <_arguments: ArgumentsDeclaration>  => new_expression_function_call_expression(arena, new_function_call_expression(arena, <>)),
         
-        <Expression: Expression0<IndexAccessPathRule>>  => <>,
+        <Expression: Expression0<IndexAccessPathRule, NewExpressionRule>>  => <>,
     
 };
 
+    NoNewExpression: NewExpression<'arena> = {};
+
+
+
 // Tail is a rule identifying what comes after the expression, whatever is captured is added to the tuple result
 Expression5<Tail>: (Expression<'arena>, Tail) = {
         
@@ -3958,7 +3962,7 @@ Expression5<Tail>: (Expression<'arena>, Tail) = {
         },
         
         // A tail can appear just after a postfix or primary expression
-        <Expression: Expression1<IndexAccessPath<IdentifierPath>>> <tail: Tail> => {
+        <Expression: Expression1<IndexAccessPath<IdentifierPath>, NewExpression>> <tail: Tail> => {
             (Expression, tail)
         },
     
@@ -4326,26 +4330,24 @@ IndexAccessPath1<IdentPathRule>: IndexAccessPath<'arena> = {
                             name = NewExpression,
                             fields = (
                                 new_keyword = Required(NewKeyword),
-                                type_name = Required(TypeName),
-                                // TODO(v2): This disallows some grammar ambiguities, we should double check it's ok
-                                options =
-                                    Optional(reference = MultipleCallOptionsNew, enabled = From("0.6.2")),
-                                arguments = Required(ArgumentsDeclaration)
-                            )
-                        ),
-                        Repeated(
-                            name = MultipleCallOptionsNew,
-                            reference = CallOptionsNew,
-                            enabled = From("0.6.2")
-                        ),
-                        Struct(
-                            name = CallOptionsNew,
-                            enabled = From("0.6.2"),
-                            fields = (
-                                open_brace = Required(OpenBrace),
-                                options = Required(CallOptions),
-                                close_brace = Required(CloseBrace)
-                            )
+                                type_name = Required(TypeName)
+                            ),
+                            parser_options = ParserOptions(
+                                inline = false,
+                                pubb = true,
+                                verbatim = r#"
+    // TODO(v2): Right now we're avoiding function types entirely in new expressions, this is ok since they're not allowed
+    // in Solidity, but the error will be syntactic rather than semantic, which may be confusing.
+    // We do this to avoid the amibiguity of `try new function () returns (uint) ...`, where the returns clause may be
+    // parsed either as part of the function type or as part of a try statement.
+    NewExpression: NewExpression<'arena> = {
+        <_new_keyword: NewKeyword>  <_type_name: TypeName1<NoFunctionType, IndexAccessPath<IdentifierPath>>>  => new_new_expression(arena, <>),
+        
+    };
+
+    NoFunctionType: FunctionType<'arena> = {};
+
+"#)
                         ),
                         Struct(
                             name = TupleExpression,