Changeset 258861 in webkit

Timestamp:

Mar 23, 2020 11:23:50 AM (4 years ago)

Author:

Ross Kirsling

Message:

Catch parameters must not be lexically redeclared
​https://bugs.webkit.org/show_bug.cgi?id=208976

Reviewed by Keith Miller.

JSTests:

• test262/expectations.yaml:

Mark four test cases as passing.

Source/JavaScriptCore:

From ​https://tc39.es/ecma262/#sec-try-statement-static-semantics-early-errors:

Catch : catch ( CatchParameter ) Block

It is a Syntax Error if any element of the BoundNames of CatchParameter
also occurs in the LexicallyDeclaredNames of Block.

In other words, let/const/class/function declarations in the immediate catch block scope
must not shadow catch parameters.

• parser/Parser.cpp:

(JSC::Parser<LexerType>::parseTryStatement):
(JSC::Parser<LexerType>::parseBlockStatement):

• parser/Parser.h:

(JSC::Scope::Scope):
(JSC::Scope::setIsCatchBlockScope): Added.
(JSC::Scope::isCatchBlockScope): Added.
(JSC::Parser::declareVariable):
(JSC::Parser::declareFunction):

Location:

trunk

Files:

• JSTests/ChangeLog (modified) (1 diff)
• JSTests/test262/expectations.yaml (modified) (1 diff)
• Source/JavaScriptCore/ChangeLog (modified) (1 diff)
• Source/JavaScriptCore/parser/Parser.cpp (modified) (3 diffs)
• Source/JavaScriptCore/parser/Parser.h (modified) (8 diffs)

trunk/JSTests/ChangeLog

@@ +1 @@
+2020-03-23  Ross Kirsling  <ross.kirsling@sony.com>
+
+        Catch parameters must not be lexically redeclared
+        https://bugs.webkit.org/show_bug.cgi?id=208976
+
+        Reviewed by Keith Miller.
+
+        * test262/expectations.yaml:
+        Mark four test cases as passing.
+
 2020-03-20  Ross Kirsling  <ross.kirsling@sony.com>
 

trunk/JSTests/test262/expectations.yaml

@@ -3680 +3680 @@
   default: 'Test262: This statement should not be evaluated.'
   strict mode: 'Test262: This statement should not be evaluated.'
-test/language/statements/try/early-catch-function.js:
-  default: 'Test262: This statement should not be evaluated.'
-  strict mode: 'Test262: This statement should not be evaluated.'
-test/language/statements/try/early-catch-lex.js:
-  default: 'Test262: This statement should not be evaluated.'
-  strict mode: 'Test262: This statement should not be evaluated.'
 test/language/statements/while/let-array-with-newline.js:
   default: 'Test262: This statement should not be evaluated.'

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2020-03-23  Ross Kirsling  <ross.kirsling@sony.com>
+
+        Catch parameters must not be lexically redeclared
+        https://bugs.webkit.org/show_bug.cgi?id=208976
+
+        Reviewed by Keith Miller.
+
+        From https://tc39.es/ecma262/#sec-try-statement-static-semantics-early-errors:
+          Catch : catch ( CatchParameter ) Block
+            It is a Syntax Error if any element of the BoundNames of CatchParameter
+            also occurs in the LexicallyDeclaredNames of Block.
+
+        In other words, let/const/class/function declarations in the immediate catch block scope
+        must not shadow catch parameters.
+
+        * parser/Parser.cpp:
+        (JSC::Parser<LexerType>::parseTryStatement):
+        (JSC::Parser<LexerType>::parseBlockStatement):
+        * parser/Parser.h:
+        (JSC::Scope::Scope):
+        (JSC::Scope::setIsCatchBlockScope): Added.
+        (JSC::Scope::isCatchBlockScope): Added.
+        (JSC::Parser::declareVariable):
+        (JSC::Parser::declareFunction):
+
 2020-03-23  Michael Catanzaro  <mcatanzaro@gnome.org>
 

trunk/Source/JavaScriptCore/parser/Parser.cpp

@@ -1780 +1780 @@
             handleProductionOrFail(CLOSEPAREN, ")", "end", "'catch' target");
             matchOrFail(OPENBRACE, "Expected exception handler to be a block statement");
-            catchBlock = parseBlockStatement(context);
+            constexpr bool isCatchBlock = true;
+            catchBlock = parseBlockStatement(context, isCatchBlock);
             failIfFalse(catchBlock, "Unable to parse 'catch' block");
             catchEnvironment = catchScope->finalizeLexicalEnvironment();
@@ -1813 +1814 @@
 
 template <typename LexerType>
-template <class TreeBuilder> TreeStatement Parser<LexerType>::parseBlockStatement(TreeBuilder& context)
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseBlockStatement(TreeBuilder& context, bool isCatchBlock)
 {
     ASSERT(match(OPENBRACE));
@@ -1825 +1826 @@
         newScope->setIsLexicalScope();
         newScope->preventVarDeclarations();
+        if (isCatchBlock)
+            newScope->setIsCatchBlockScope();
         lexicalScope.setIsValid(newScope, this);
     }

trunk/Source/JavaScriptCore/parser/Parser.h

@@ -177 +177 @@
         , m_isGlobalCodeScope(false)
         , m_isSimpleCatchParameterScope(false)
+        , m_isCatchBlockScope(false)
         , m_isFunctionBoundary(false)
         , m_isValidStrictMode(true)
@@ -299 +300 @@
     void setIsSimpleCatchParameterScope() { m_isSimpleCatchParameterScope = true; }
     bool isSimpleCatchParameterScope() { return m_isSimpleCatchParameterScope; }
+
+    void setIsCatchBlockScope() { m_isCatchBlockScope = true; }
+    bool isCatchBlockScope() { return m_isCatchBlockScope; }
 
     void setIsLexicalScope() 
@@ -830 +834 @@
     bool m_isGlobalCodeScope;
     bool m_isSimpleCatchParameterScope;
+    bool m_isCatchBlockScope;
     bool m_isFunctionBoundary;
     bool m_isValidStrictMode;
@@ -1281 +1286 @@
             return DeclarationResult::InvalidDuplicateDeclaration;
 
-        return currentLexicalDeclarationScope()->declareLexicalVariable(ident, type == DeclarationType::ConstDeclaration, importType);
+        ScopeRef scope = currentLexicalDeclarationScope();
+        if (scope->isCatchBlockScope() && scope.containingScope()->hasLexicallyDeclaredVariable(*ident))
+            return DeclarationResult::InvalidDuplicateDeclaration;
+
+        return scope->declareLexicalVariable(ident, type == DeclarationType::ConstDeclaration, importType);
     }
 
@@ -1296 +1305 @@
         }
 
+        bool declareAsVar = false;
+        ScopeRef lexicalVariableScope = currentLexicalDeclarationScope();
+        if (lexicalVariableScope->isCatchBlockScope() && lexicalVariableScope.containingScope()->hasLexicallyDeclaredVariable(*ident))
+            return std::make_pair(DeclarationResult::InvalidDuplicateDeclaration, lexicalVariableScope);
+
         if (!strictMode()) {
             ASSERT(currentScope()->isFunction() || closestParentOrdinaryFunctionNonLexicalScope()->isEvalContext());
@@ -1307 +1321 @@
             // binding if the block evaluates. For example, this means we wont won't perform the binding if it's inside
             // the untaken branch of an if statement.
-            bool declareAsVar = false;
             bool isSloppyModeHoistingCandidate = true;
-            ScopeRef lexicalVariableScope = currentLexicalDeclarationScope();
             ScopeRef varScope = currentVariableScope();
             varScope->addSloppyModeHoistableFunctionCandidate(ident);
@@ -1316 +1328 @@
         }
 
-        bool declareAsVar = false;
         bool isSloppyModeHoistingCandidate = false;
-        ScopeRef lexicalVariableScope = currentLexicalDeclarationScope();
         return std::make_pair(lexicalVariableScope->declareFunction(ident, declareAsVar, isSloppyModeHoistingCandidate), lexicalVariableScope);
     }
@@ -1636 +1646 @@
     template <class TreeBuilder> TreeStatement parseExpressionOrLabelStatement(TreeBuilder&, bool allowFunctionDeclarationAsStatement);
     template <class TreeBuilder> TreeStatement parseIfStatement(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseBlockStatement(TreeBuilder&);
+    template <class TreeBuilder> TreeStatement parseBlockStatement(TreeBuilder&, bool isCatchBlock = false);
     template <class TreeBuilder> TreeExpression parseExpression(TreeBuilder&);
     template <class TreeBuilder> TreeExpression parseAssignmentExpression(TreeBuilder&, ExpressionErrorClassifier&);