Changeset 194153 in webkit

Timestamp:

Dec 16, 2015 9:49:14 AM (8 years ago)

Author:

commit-queue@webkit.org

Message:

[JSC] fix error message for eval/arguments CoverInitializedName in strict code
​https://bugs.webkit.org/show_bug.cgi?id=152304

Patch by Caitlin Potter <​caitp@igalia.com> on 2015-12-16
Reviewed by Darin Adler.

Because the error was originally classified as indicating a Pattern, the
error in AssignmentPattern parsing causes the reported message to revert to
the original Expression error message, which in this case is incorrect.

This change modifies the implementation of the strict code
error slightly, and reclassifies the error to prevent the message revert,
which improves the clarity of the message overall.

• parser/Parser.cpp:

(JSC::Parser<LexerType>::parseAssignmentElement):
(JSC::Parser<LexerType>::parseDestructuringPattern):

• parser/Parser.h:

(JSC::Parser::ExpressionErrorClassifier::reclassifyExpressionError):
(JSC::Parser::reclassifyExpressionError):

• tests/stress/destructuring-assignment-syntax.js:

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• parser/Parser.cpp (modified) (2 diffs)
• parser/Parser.h (modified) (2 diffs)
• tests/stress/destructuring-assignment-syntax.js (modified) (1 diff)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2015-12-16  Caitlin Potter  <caitp@igalia.com>
+
+        [JSC] fix error message for eval/arguments CoverInitializedName in strict code
+        https://bugs.webkit.org/show_bug.cgi?id=152304
+
+        Reviewed by Darin Adler.
+
+        Because the error was originally classified as indicating a Pattern, the
+        error in AssignmentPattern parsing causes the reported message to revert to
+        the original Expression error message, which in this case is incorrect.
+
+        This change modifies the implementation of the strict code
+        error slightly, and reclassifies the error to prevent the message revert,
+        which improves the clarity of the message overall.
+
+        * parser/Parser.cpp:
+        (JSC::Parser<LexerType>::parseAssignmentElement):
+        (JSC::Parser<LexerType>::parseDestructuringPattern):
+        * parser/Parser.h:
+        (JSC::Parser::ExpressionErrorClassifier::reclassifyExpressionError):
+        (JSC::Parser::reclassifyExpressionError):
+        * tests/stress/destructuring-assignment-syntax.js:
+
 2015-12-16  Joseph Pecoraro  <pecoraro@apple.com>
 

trunk/Source/JavaScriptCore/parser/Parser.cpp

@@ -844 +844 @@
 
     if (strictMode() && m_lastIdentifier && context.isResolve(element)) {
-        failIfTrueIfStrict(m_vm->propertyNames->eval == *m_lastIdentifier, "Cannot modify 'eval' in strict mode");
-        failIfTrueIfStrict(m_vm->propertyNames->arguments == *m_lastIdentifier, "Cannot modify 'arguments' in strict mode");
+        bool isEvalOrArguments = m_vm->propertyNames->eval == *m_lastIdentifier || m_vm->propertyNames->arguments == *m_lastIdentifier;
+        failIfTrueIfStrict(isEvalOrArguments, "Cannot modify '", m_lastIdentifier->impl(), "' in strict mode");
     }
 
@@ -932 +932 @@
                     innerPattern = parseBindingOrAssignmentElement(context, kind, exportType, duplicateIdentifier, hasDestructuringPattern, bindingContext, depth + 1);
                 else {
-                    if (kind == DestructureToExpressions && strictMode()) {
-                        failIfTrueIfStrict(m_vm->propertyNames->eval == *propertyName, "Cannot modify 'eval' in strict mode");
-                        failIfTrueIfStrict(m_vm->propertyNames->arguments == *propertyName, "Cannot modify 'arguments' in strict mode");
+                    if (kind == DestructureToExpressions) {
+                        bool isEvalOrArguments = m_vm->propertyNames->eval == *propertyName || m_vm->propertyNames->arguments == *propertyName;
+                        if (isEvalOrArguments && strictMode())
+                            reclassifyExpressionError(ErrorIndicatesPattern, ErrorIndicatesNothing);
+                        failIfTrueIfStrict(isEvalOrArguments, "Cannot modify '", propertyName->impl(), "' in strict mode");
                     }
                     innerPattern = createBindingPattern(context, kind, exportType, *propertyName, identifierToken, bindingContext, duplicateIdentifier);

trunk/Source/JavaScriptCore/parser/Parser.h

@@ -765 +765 @@
         }
 
+        void reclassifyExpressionError(ExpressionErrorClass oldClassification, ExpressionErrorClass classification)
+        {
+            if (m_class != oldClassification)
+                return;
+            m_class = classification;
+        }
+
         void propagateExpressionErrorClass()
         {
@@ -783 +790 @@
         if (m_expressionErrorClassifier)
             m_expressionErrorClassifier->classifyExpressionError(classification);
+    }
+
+    ALWAYS_INLINE void reclassifyExpressionError(ExpressionErrorClass oldClassification, ExpressionErrorClass classification)
+    {
+        if (m_expressionErrorClassifier)
+            m_expressionErrorClassifier->reclassifyExpressionError(oldClassification, classification);
     }
 

trunk/Source/JavaScriptCore/tests/stress/destructuring-assignment-syntax.js

@@ -60 +60 @@
 
 testSyntaxError("'use strict'; ({ eval } = {})", "SyntaxError: Cannot modify 'eval' in strict mode.");
-// FIXME: support CoverInitializedName properly.
-//testSyntaxError("'use strict'; ({ eval = 0 } = {})", "SyntaxError: Cannot modify 'eval' in strict mode.");
+testSyntaxError("'use strict'; ({ eval = 0 } = {})", "SyntaxError: Cannot modify 'eval' in strict mode.");
 testSyntaxError("'use strict'; ({ a: eval } = {})", "SyntaxError: Cannot modify 'eval' in strict mode.");
 testSyntaxError("'use strict'; ({ a: eval = 0 } = {})", "SyntaxError: Cannot modify 'eval' in strict mode.");
 testSyntaxError("'use strict'; ({ arguments } = {})", "SyntaxError: Cannot modify 'arguments' in strict mode.");
-// FIXME: support CoverInitializedName properly.
-//testSyntaxError("'use strict'; ({ arguments = 0 } = {})", "SyntaxError: Cannot modify 'arguments' in strict mode.");
+testSyntaxError("'use strict'; ({ arguments = 0 } = {})", "SyntaxError: Cannot modify 'arguments' in strict mode.");
 testSyntaxError("'use strict'; ({ a: arguments } = {})", "SyntaxError: Cannot modify 'arguments' in strict mode.");
 testSyntaxError("'use strict'; ({ a: arguments = 0 } = {})", "SyntaxError: Cannot modify 'arguments' in strict mode.");