Merge branch 'optional-chaining-support' into nullish-coalescing-support

Author: sanex3339

escodegen.js

@@ -103,9 +103,8 @@
         Call: 16,
         New: 17,
         TaggedTemplate: 18,
-        OptionalMember: 19,
-        Member: 20,
-        Primary: 21
+        Member: 19,
+        Primary: 20
     };
 
     BinaryPrecedence = {
@@ -1899,9 +1898,18 @@
         },
 
         CallExpression: function (expr, precedence, flags) {
-            var result, i, iz;
-            // F_ALLOW_UNPARATH_NEW becomes false.
-            result = [this.generateExpression(expr.callee, Precedence.Call, E_TTF)];
+            var result,
+                i,
+                iz,
+                exprCalleeFlags = E_TTF;
+
+            if (expr.callee.type === 'ChainExpression' && expr.callee.expression.optional) {
+                // F_ALLOW_UNPARATH_NEW becomes false.
+                result = [this.generateExpression(expr.callee, Precedence.Member, exprCalleeFlags)];
+            } else {
+                // F_ALLOW_UNPARATH_NEW becomes false.
+                result = [this.generateExpression(expr.callee, Precedence.Call, exprCalleeFlags)];
+            }
 
             if (expr.optional) {
                 result.push('?.');
@@ -1919,6 +1927,7 @@
             if (!(flags & F_ALLOW_CALL)) {
                 return ['(', result, ')'];
             }
+
             return parenthesize(result, Precedence.Call, precedence);
         },
 
@@ -1956,14 +1965,16 @@
         },
 
         MemberExpression: function (expr, precedence, flags) {
-            var result, fragment;
+            var result,
+                fragment,
+                exprObjectFlags = (flags & F_ALLOW_CALL) ? E_TTF : E_TFF;
 
             if (expr.object.type === 'ChainExpression' && expr.object.expression.optional) {
                 // F_ALLOW_UNPARATH_NEW becomes false.
-                result = [this.generateExpression(expr.object, Precedence.Member, (flags & F_ALLOW_CALL) ? E_TTF : E_TFF)];
+                result = [this.generateExpression(expr.object, Precedence.Member, exprObjectFlags)];
             } else {
                 // F_ALLOW_UNPARATH_NEW becomes false.
-                result = [this.generateExpression(expr.object, Precedence.Call, (flags & F_ALLOW_CALL) ? E_TTF : E_TFF)];
+                result = [this.generateExpression(expr.object, Precedence.Call, exprObjectFlags)];
             }
 
             if (expr.computed) {
@@ -1975,7 +1986,7 @@
                 result.push(this.generateExpression(expr.property, Precedence.Sequence, flags & F_ALLOW_CALL ? E_TTT : E_TFT));
                 result.push(']');
             } else {
-                if (expr.object.type === Syntax.Literal && typeof expr.object.value === 'number') {
+                if (!expr.optional && expr.object.type === Syntax.Literal && typeof expr.object.value === 'number') {
                     fragment = toSourceNodeWhenNeeded(result).toString();
                     // When the following conditions are all true,
                     //   1. No floating point
@@ -1997,7 +2008,7 @@
             }
 
             if (precedence === Precedence.Member) {
-                return parenthesize(result, Precedence.OptionalMember, precedence);
+                return parenthesize(result, Precedence.Call, precedence);
             }
 
             return parenthesize(result, Precedence.Member, precedence);

test/compare-acorn-es2020/optional-chaining.expected.js

@@ -18,4 +18,15 @@ obj[aaa]?.[bbb];
 (obj?.[aaa])[bbb];
 (obj?.[aaa])?.[bbb];
 obj[aaa][bbb][ccc][ddd];
-((obj?.[aaa])[bbb]?.[ccc])[ddd];
+((obj?.[aaa])[bbb]?.[ccc])[ddd];
+1?.a;
+obj()();
+obj()?.();
+obj?.()();
+obj?.()?.();
+obj()();
+obj()?.();
+(obj?.())();
+(obj?.())?.();
+obj()()()();
+((obj?.())()?.())();

test/compare-acorn-es2020/optional-chaining.expected.min.js

@@ -19,3 +19,14 @@ obj?.[aaa]?.[bbb];
 (obj?.[aaa])?.[bbb];
 ((obj[aaa])[bbb][ccc])[ddd];
 ((obj?.[aaa])[bbb]?.[ccc])[ddd];
+1?.a;
+obj()();
+obj()?.();
+obj?.()();
+obj?.()?.();
+(obj())();
+(obj())?.();
+(obj?.())();
+(obj?.())?.();
+((obj())()())();
+((obj?.())()?.())();