fix(parser): fixes assignment edge cases

Meriyah now passes the fuzzer I'm running and destructuring & assignment works as it should. Time to move on to the next step !
meriyah · May 15, 2019 · b2cf29f · b2cf29f
1 parent 7805610
commit b2cf29f
Show file tree

Hide file tree

Showing 3 changed files with 134 additions and 18 deletions.
diff --git a/src/parser.ts b/src/parser.ts
@@ -2568,7 +2568,7 @@ export function parsePrimaryExpressionExtended(
       if (IsEvalOrArguments) {
         if (context & Context.Strict) report(parser, Errors.StrictEvalArguments);
         parser.flags |= Flags.SimpleParameterList;
-      }
+      } else parser.flags = (parser.flags | Flags.SimpleParameterList) ^ Flags.SimpleParameterList;
       if (!assignable) report(parser, Errors.InvalidAssignmentTarget);
 
       return parseArrowFunctionExpression(parser, context, [expr], /* isAsync */ 0);
@@ -3883,26 +3883,18 @@ export function parseObjectLiteralOrPattern(
                 : AssignmentKind.Assignable;
 
             if (parser.token === Token.Comma || parser.token === Token.RightBrace) {
-              if (parser.assignable & AssignmentKind.NotAssignable) destructible |= DestructuringKind.NotDestructible;
+              if (parser.assignable & AssignmentKind.NotAssignable) {
+                destructible |= DestructuringKind.NotDestructible;
+              }
+            } else if (parser.destructible & DestructuringKind.Required) {
+              report(parser, Errors.InvalidDestructuringTarget);
             } else {
               value = parseMemberOrUpdateExpression(parser, context, value, /* assignable */ 0);
-
-              destructible =
-                parser.assignable & AssignmentKind.NotAssignable ? destructible | DestructuringKind.NotDestructible : 0;
-
-              const notAssignable = parser.token !== Token.Assign;
+              destructible = parser.assignable & AssignmentKind.NotAssignable ? DestructuringKind.NotDestructible : 0;
 
               if (parser.token !== Token.Comma && parser.token !== Token.RightBrace) {
-                if (notAssignable) destructible |= DestructuringKind.NotDestructible;
-
-                value = parseAssignmentExpression(
-                  parser,
-                  (context | Context.DisallowInContext) ^ Context.DisallowInContext,
-                  value
-                );
-
-                if (notAssignable) destructible |= DestructuringKind.NotDestructible;
-              } else if (notAssignable) {
+                value = parseAssignmentExpression(parser, context, value);
+              } else if (parser.token !== Token.Assign) {
                 destructible |=
                   type || parser.assignable & AssignmentKind.NotAssignable
                     ? DestructuringKind.NotDestructible

diff --git a/test/parser/miscellaneous/directives.ts b/test/parser/miscellaneous/directives.ts
@@ -129,8 +129,30 @@ describe('Miscellaneous - Directives', () => {
   ]) {
     it(`/* comment in front */ ${arg}`, () => {
       t.doesNotThrow(() => {
-        parseSource(`/* comment in front */ ${arg}`, undefined, Context.OptionsDirectives);
+        parseSource(`/* comment in front */ ${arg}`, undefined, Context.OptionsDirectives | Context.OptionsRaw);
       });
     });
+
+    it(`/* comment in front */ ${arg}`, () => {
+      t.doesNotThrow(() => {
+        parseSource(
+          `/* comment in front */ ${arg}`,
+          undefined,
+          Context.OptionsDirectives | Context.OptionsWebCompat | Context.OptionsRaw
+        );
+      });
+    });
+  }
+
+  for (const arg of ['.foo', '[foo]', '()', '`x`', ' + x', '/f', '/f/g']) {
+    t.throws(() => {
+      parseSource(`function f(){ "use strict" \n /* suffix = */   ${arg} ; eval = 1; }`, undefined, Context.Strict);
+    });
+  }
+
+  for (const arg of ['foo', '++x', '--x', 'function f(){}', '{x}', ';', '25', 'true']) {
+    t.throws(() => {
+      parseSource(`function f(){ "use strict" \n  ${arg} ; eval = 1; }`, undefined, Context.None);
+    });
   }
 });
diff --git a/test/parser/statements/if.ts b/test/parser/statements/if.ts
@@ -35,6 +35,108 @@ describe('Statements - None', () => {
   ]);
 
   pass('Statements - If (pass)', [
+    [
+      'if (yield === void 0) { async = false; }',
+      Context.OptionsWebCompat,
+      {
+        type: 'Program',
+        sourceType: 'script',
+        body: [
+          {
+            type: 'IfStatement',
+            test: {
+              type: 'BinaryExpression',
+              left: {
+                type: 'Identifier',
+                name: 'yield'
+              },
+              right: {
+                type: 'UnaryExpression',
+                operator: 'void',
+                argument: {
+                  type: 'Literal',
+                  value: 0
+                },
+                prefix: true
+              },
+              operator: '==='
+            },
+            consequent: {
+              type: 'BlockStatement',
+              body: [
+                {
+                  type: 'ExpressionStatement',
+                  expression: {
+                    type: 'AssignmentExpression',
+                    left: {
+                      type: 'Identifier',
+                      name: 'async'
+                    },
+                    operator: '=',
+                    right: {
+                      type: 'Literal',
+                      value: false
+                    }
+                  }
+                }
+              ]
+            },
+            alternate: null
+          }
+        ]
+      }
+    ],
+    [
+      'if (await === void 0) { async = false; }',
+      Context.OptionsWebCompat,
+      {
+        type: 'Program',
+        sourceType: 'script',
+        body: [
+          {
+            type: 'IfStatement',
+            test: {
+              type: 'BinaryExpression',
+              left: {
+                type: 'Identifier',
+                name: 'await'
+              },
+              right: {
+                type: 'UnaryExpression',
+                operator: 'void',
+                argument: {
+                  type: 'Literal',
+                  value: 0
+                },
+                prefix: true
+              },
+              operator: '==='
+            },
+            consequent: {
+              type: 'BlockStatement',
+              body: [
+                {
+                  type: 'ExpressionStatement',
+                  expression: {
+                    type: 'AssignmentExpression',
+                    left: {
+                      type: 'Identifier',
+                      name: 'async'
+                    },
+                    operator: '=',
+                    right: {
+                      type: 'Literal',
+                      value: false
+                    }
+                  }
+                }
+              ]
+            },
+            alternate: null
+          }
+        ]
+      }
+    ],
     [
       'if (async === void 0) { async = false; }',
       Context.OptionsWebCompat,