fix: fix wrong ChainExpression wrapper

closes #98
meriyah · Oct 1, 2020 · a33771c · a33771c
1 parent d3de211
commit a33771c
Show file tree

Hide file tree

Showing 2 changed files with 178 additions and 3 deletions.
diff --git a/src/parser.ts b/src/parser.ts
@@ -3946,6 +3946,12 @@ export function parseMemberOrUpdateExpression(
           return expr;
         }
 
+        let restoreHasOptionalChaining = false;
+        if ((parser.flags & Flags.HasOptionalChaining) === Flags.HasOptionalChaining) {
+          restoreHasOptionalChaining = true;
+          parser.flags = (parser.flags | Flags.HasOptionalChaining) ^ Flags.HasOptionalChaining;
+        }
+
         const args = parseArguments(parser, context, inGroup);
 
         parser.assignable = AssignmentKind.CannotAssign;
@@ -3955,6 +3961,10 @@ export function parseMemberOrUpdateExpression(
           callee: expr,
           arguments: args
         });
+
+        if (restoreHasOptionalChaining) {
+          parser.flags |= Flags.HasOptionalChaining;
+        }
         break;
       }
 
@@ -4016,13 +4026,21 @@ export function parseOptionalChain(
   line: number,
   column: number
 ): ESTree.MemberExpression | ESTree.CallExpression {
+  let restoreHasOptionalChaining = false;
+  let node;
+  if (parser.token === Token.LeftBracket || parser.token === Token.LeftParen) {
+    if ((parser.flags & Flags.HasOptionalChaining) === Flags.HasOptionalChaining) {
+      restoreHasOptionalChaining = true;
+      parser.flags = (parser.flags | Flags.HasOptionalChaining) ^ Flags.HasOptionalChaining;
+    }
+  }
   if (parser.token === Token.LeftBracket) {
     nextToken(parser, context | Context.AllowRegExp);
     const { tokenPos, linePos, colPos } = parser;
     const property = parseExpressions(parser, context, 0, 1, tokenPos, linePos, colPos);
     consume(parser, context, Token.RightBracket);
     parser.assignable = AssignmentKind.CannotAssign;
-    return finishNode(parser, context, start, line, column, {
+    node = finishNode(parser, context, start, line, column, {
       type: 'MemberExpression',
       object: expr,
       computed: true,
@@ -4034,7 +4052,7 @@ export function parseOptionalChain(
 
     parser.assignable = AssignmentKind.CannotAssign;
 
-    return finishNode(parser, context, start, line, column, {
+    node = finishNode(parser, context, start, line, column, {
       type: 'CallExpression',
       callee: expr,
       arguments: args
@@ -4043,14 +4061,19 @@ export function parseOptionalChain(
     if ((parser.token & (Token.IsIdentifier | Token.Keyword)) < 1) report(parser, Errors.InvalidDotProperty);
     const property = parseIdentifier(parser, context, 0);
     parser.assignable = AssignmentKind.CannotAssign;
-    return finishNode(parser, context, start, line, column, {
+    node = finishNode(parser, context, start, line, column, {
       type: 'MemberExpression',
       object: expr,
       computed: false,
       optional: true,
       property
     });
   }
+
+  if (restoreHasOptionalChaining) {
+    parser.flags |= Flags.HasOptionalChaining;
+  }
+  return node;
 }
 
 /**

diff --git a/test/parser/next/optional-chaining.ts b/test/parser/next/optional-chaining.ts
@@ -911,6 +911,158 @@ describe('Next - Optional chaining', () => {
         end: 15,
         range: [0, 15]
       }
+    ],
+    [
+      'a?.[x]',
+      Context.OptionsNext | Context.OptionsRanges | Context.OptionsWebCompat,
+      {
+        body: [
+          {
+            end: 6,
+            expression: {
+              end: 6,
+              expression: {
+                computed: true,
+                end: 6,
+                object: {
+                  end: 1,
+                  name: 'a',
+                  range: [0, 1],
+                  start: 0,
+                  type: 'Identifier'
+                },
+                optional: true,
+                property: {
+                  end: 5,
+                  name: 'x',
+                  range: [4, 5],
+                  start: 4,
+                  type: 'Identifier'
+                },
+                range: [0, 6],
+                start: 0,
+                type: 'MemberExpression'
+              },
+              range: [0, 6],
+              start: 0,
+              type: 'ChainExpression'
+            },
+            range: [0, 6],
+            start: 0,
+            type: 'ExpressionStatement'
+          }
+        ],
+        end: 6,
+        range: [0, 6],
+        sourceType: 'script',
+        start: 0,
+        type: 'Program'
+      }
+    ],
+    [
+      'a?.import("string")?.import.meta??(a)',
+      Context.OptionsNext | Context.OptionsRanges | Context.OptionsWebCompat,
+      {
+        body: [
+          {
+            end: 37,
+            expression: {
+              end: 37,
+              left: {
+                end: 32,
+                expression: {
+                  computed: false,
+                  end: 32,
+                  object: {
+                    computed: false,
+                    end: 27,
+                    object: {
+                      arguments: [
+                        {
+                          end: 18,
+                          range: [10, 18],
+                          start: 10,
+                          type: 'Literal',
+                          value: 'string'
+                        }
+                      ],
+                      callee: {
+                        computed: false,
+                        end: 9,
+                        object: {
+                          end: 1,
+                          name: 'a',
+                          range: [0, 1],
+                          start: 0,
+                          type: 'Identifier'
+                        },
+                        optional: true,
+                        property: {
+                          end: 9,
+                          name: 'import',
+                          range: [3, 9],
+                          start: 3,
+                          type: 'Identifier'
+                        },
+                        range: [0, 9],
+                        start: 0,
+                        type: 'MemberExpression'
+                      },
+                      end: 19,
+                      range: [0, 19],
+                      start: 0,
+                      type: 'CallExpression'
+                    },
+                    optional: true,
+                    property: {
+                      end: 27,
+                      name: 'import',
+                      range: [21, 27],
+                      start: 21,
+                      type: 'Identifier'
+                    },
+                    range: [0, 27],
+                    start: 0,
+                    type: 'MemberExpression'
+                  },
+                  property: {
+                    end: 32,
+                    name: 'meta',
+                    range: [28, 32],
+                    start: 28,
+                    type: 'Identifier'
+                  },
+                  range: [0, 32],
+                  start: 0,
+                  type: 'MemberExpression'
+                },
+                range: [0, 32],
+                start: 0,
+                type: 'ChainExpression'
+              },
+              operator: '??',
+              range: [0, 37],
+              right: {
+                end: 36,
+                name: 'a',
+                range: [35, 36],
+                start: 35,
+                type: 'Identifier'
+              },
+              start: 0,
+              type: 'LogicalExpression'
+            },
+            range: [0, 37],
+            start: 0,
+            type: 'ExpressionStatement'
+          }
+        ],
+        end: 37,
+        range: [0, 37],
+        sourceType: 'script',
+        start: 0,
+        type: 'Program'
+      }
     ]
   ]);
 });