Changeset 191030 in webkit

Timestamp:

Oct 13, 2015, 8:56:53 PM (10 years ago)

Author:

Yusuke Suzuki

Message:

[ES6] Class expression should have lexical environment that has itself as an imutable binding
​https://bugs.webkit.org/show_bug.cgi?id=150089

Reviewed by Geoffrey Garen.

According to ES6 spec, class expression has its own lexical environment that holds itself
as an immutable binding[1] (section 14.5.14 step 2, 3, 4, 23)

As a result, even if the binding declared in the outer scope is overridden, methods inside
class expression can refer its class by the class name.

[1]: ​http://ecma-international.org/ecma-262/6.0/#sec-runtime-semantics-classdefinitionevaluation

• bytecompiler/NodesCodegen.cpp:

(JSC::ClassExprNode::emitBytecode):

• parser/ASTBuilder.h:

(JSC::ASTBuilder::createClassExpr):

• parser/NodeConstructors.h:

(JSC::ClassExprNode::ClassExprNode):

• parser/Nodes.h:
• parser/Parser.cpp:

(JSC::Parser<LexerType>::parseClass):

• parser/SyntaxChecker.h:

(JSC::SyntaxChecker::createClassExpr):

• tests/es6.yaml:
• tests/stress/class-expression-generates-environment.js: Added.

(shouldBe):
(shouldThrow):
(prototype.method):
(staticMethod):
(A.prototype.method):
(A.staticMethod):
(A):

• tests/stress/class-expression-should-be-tdz-in-heritage.js: Added.

(shouldThrow):
(shouldThrow.A):

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• bytecompiler/NodesCodegen.cpp (modified) (2 diffs)
• parser/ASTBuilder.h (modified) (1 diff)
• parser/NodeConstructors.h (modified) (1 diff)
• parser/Nodes.h (modified) (1 diff)
• parser/Parser.cpp (modified) (3 diffs)
• parser/SyntaxChecker.h (modified) (1 diff)
• tests/es6.yaml (modified) (2 diffs)
• tests/stress/class-expression-generates-environment.js (added)
• tests/stress/class-expression-should-be-tdz-in-heritage.js (added)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2015-10-13  Yusuke Suzuki  <[email protected]>
+
+        [ES6] Class expression should have lexical environment that has itself as an imutable binding
+        https://bugs.webkit.org/show_bug.cgi?id=150089
+
+        Reviewed by Geoffrey Garen.
+
+        According to ES6 spec, class expression has its own lexical environment that holds itself
+        as an immutable binding[1] (section 14.5.14 step 2, 3, 4, 23)
+
+        As a result, even if the binding declared in the outer scope is overridden, methods inside
+        class expression can refer its class by the class name.
+
+        [1]: http://ecma-international.org/ecma-262/6.0/#sec-runtime-semantics-classdefinitionevaluation
+
+        * bytecompiler/NodesCodegen.cpp:
+        (JSC::ClassExprNode::emitBytecode):
+        * parser/ASTBuilder.h:
+        (JSC::ASTBuilder::createClassExpr):
+        * parser/NodeConstructors.h:
+        (JSC::ClassExprNode::ClassExprNode):
+        * parser/Nodes.h:
+        * parser/Parser.cpp:
+        (JSC::Parser<LexerType>::parseClass):
+        * parser/SyntaxChecker.h:
+        (JSC::SyntaxChecker::createClassExpr):
+        * tests/es6.yaml:
+        * tests/stress/class-expression-generates-environment.js: Added.
+        (shouldBe):
+        (shouldThrow):
+        (prototype.method):
+        (staticMethod):
+        (A.prototype.method):
+        (A.staticMethod):
+        (A):
+        * tests/stress/class-expression-should-be-tdz-in-heritage.js: Added.
+        (shouldThrow):
+        (shouldThrow.A):
+
 2015-10-13  Saam barati  <[email protected]>
 

trunk/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp

@@ -3011 +3011 @@
 RegisterID* ClassExprNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
+    if (!m_name.isNull())
+        generator.pushLexicalScope(this, true);
+
     RefPtr<RegisterID> superclass;
     if (m_classHeritage) {
@@ -3074 +3077 @@
     if (m_instanceMethods)
         generator.emitNode(prototype.get(), m_instanceMethods);
+
+    if (!m_name.isNull()) {
+        Variable classNameVar = generator.variable(m_name);
+        RELEASE_ASSERT(classNameVar.isResolved());
+        RefPtr<RegisterID> scope = generator.emitResolveScope(nullptr, classNameVar);
+        generator.emitPutToScope(scope.get(), classNameVar, constructor.get(), ThrowIfNotFound, Initialization);
+        generator.popLexicalScope(this);
+    }
 
     return generator.moveToDestinationIfNeeded(dst, constructor.get());

trunk/Source/JavaScriptCore/parser/ASTBuilder.h

@@ -343 +343 @@
 
 #if ENABLE(ES6_CLASS_SYNTAX)
-    ClassExprNode* createClassExpr(const JSTokenLocation& location, const Identifier& name, ExpressionNode* constructor,
+    ClassExprNode* createClassExpr(const JSTokenLocation& location, const Identifier& name, VariableEnvironment& classEnvironment, ExpressionNode* constructor,
         ExpressionNode* parentClass, PropertyListNode* instanceMethods, PropertyListNode* staticMethods)
     {
-        return new (m_parserArena) ClassExprNode(location, name, constructor, parentClass, instanceMethods, staticMethods);
+        return new (m_parserArena) ClassExprNode(location, name, classEnvironment, constructor, parentClass, instanceMethods, staticMethods);
     }
 #endif

trunk/Source/JavaScriptCore/parser/NodeConstructors.h

@@ -923 +923 @@
     }
 
-    inline ClassExprNode::ClassExprNode(const JSTokenLocation& location, const Identifier& name, ExpressionNode* constructorExpression, ExpressionNode* classHeritage, PropertyListNode* instanceMethods, PropertyListNode* staticMethods)
-        : ExpressionNode(location)
+    inline ClassExprNode::ClassExprNode(const JSTokenLocation& location, const Identifier& name, VariableEnvironment& classEnvironment, ExpressionNode* constructorExpression, ExpressionNode* classHeritage, PropertyListNode* instanceMethods, PropertyListNode* staticMethods)
+        : ExpressionNode(location)
+        , VariableEnvironmentNode(classEnvironment)
         , m_name(name)
         , m_constructorExpression(constructorExpression)

trunk/Source/JavaScriptCore/parser/Nodes.h

@@ -1931 +1931 @@
 
 #if ENABLE(ES6_CLASS_SYNTAX)
-    class ClassExprNode final : public ExpressionNode {
-    public:
-        ClassExprNode(const JSTokenLocation&, const Identifier&, ExpressionNode* constructorExpresssion,
+    class ClassExprNode final : public ExpressionNode, public VariableEnvironmentNode {
+    public:
+        using ParserArenaDeletable::operator new;
+
+        ClassExprNode(const JSTokenLocation&, const Identifier&, VariableEnvironment& classEnvironment, ExpressionNode* constructorExpresssion,
             ExpressionNode* parentClass, PropertyListNode* instanceMethods, PropertyListNode* staticMethods);
 

trunk/Source/JavaScriptCore/parser/Parser.cpp

@@ -1924 +1924 @@
 
     AutoPopScopeRef classScope(this, pushScope());
+    classScope->setIsLexicalScope();
+    classScope->preventVarDeclarations();
     classScope->setStrictMode();
 
@@ -1931 +1933 @@
         info.className = className;
         next();
-        failIfTrue(classScope->declareVariable(className) & DeclarationResult::InvalidStrictMode, "'", className->impl(), "' is not a valid class name");
+        failIfTrue(classScope->declareLexicalVariable(className, true) & DeclarationResult::InvalidStrictMode, "'", className->impl(), "' is not a valid class name");
     } else if (requirements == FunctionNeedsName) {
         if (match(OPENBRACE))
@@ -2048 +2050 @@
     }
 
+    consumeOrFail(CLOSEBRACE, "Expected a closing '}' after a class body");
+
+    auto classExpression = context.createClassExpr(location, *className, classScope->finalizeLexicalEnvironment(), constructor, parentClass, instanceMethods, staticMethods);
     popScope(classScope, TreeBuilder::NeedsFreeVariableInfo);
-    consumeOrFail(CLOSEBRACE, "Expected a closing '}' after a class body");
-
-    return context.createClassExpr(location, *className, constructor, parentClass, instanceMethods, staticMethods);
+    return classExpression;
 }
 #endif

trunk/Source/JavaScriptCore/parser/SyntaxChecker.h

@@ -184 +184 @@
     ExpressionType createEmptyLetExpression(const JSTokenLocation&, const Identifier&) { return AssignmentExpr; }
 #if ENABLE(ES6_CLASS_SYNTAX)
-    ClassExpression createClassExpr(const JSTokenLocation&, const Identifier&, ExpressionType, ExpressionType, PropertyList, PropertyList) { return ClassExpr; }
+    ClassExpression createClassExpr(const JSTokenLocation&, const Identifier&, VariableEnvironment&, ExpressionType, ExpressionType, PropertyList, PropertyList) { return ClassExpr; }
 #endif
     ExpressionType createFunctionExpr(const JSTokenLocation&, const ParserFunctionInfo<SyntaxChecker>&) { return FunctionExpr; }

trunk/Source/JavaScriptCore/tests/es6.yaml

@@ -87 +87 @@
 - path: es6/class_class_expression.js
   cmd: runES6 :normal
+- path: es6/class_class_name_is_lexically_scoped.js
+  cmd: runES6 :normal
 - path: es6/class_class_statement.js
   cmd: runES6 :normal
@@ -729 +731 @@
 - path: es6/block-level_function_declaration.js
   cmd: runES6 :fail
-- path: es6/class_class_name_is_lexically_scoped.js
-  cmd: runES6 :fail
 - path: es6/destructuring_computed_properties.js
   cmd: runES6 :fail