Changeset 269922 in webkit for trunk/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp

Timestamp:

Nov 17, 2020, 1:37:39 PM (5 years ago)

Author:

[email protected]

Message:

[JSC] Add support for static public class fields
​https://bugs.webkit.org/show_bug.cgi?id=194095

Patch by Xan López <Xan Lopez> on 2020-11-17
Reviewed by Yusuke Suzuki.

JSTests:

Enable static public fields, and import new stress tests from the
V8 project. Also split the support code into a separate file
(harmony-support.js) to avoid duplication.

• test262/config.yaml: enable static public fields.
• stress/class-fields-harmony.js: use the new support file.
• stress/class-fields-static-harmony.js: Added.
• stress/resources/harmony-support.js: Added.

Source/JavaScriptCore:

Add support for static public class fields. We can reuse most of
the existing machinery available for instance fields. Like
instance fields, static fields are initialized with a synthetic
function. This is done to allow us to trivially follow the scoping
rules in the spec. As it happens with instance fields this could
be inlined in a future patch.

A lot of small changes in many files are just a matter of doing
s/instance/class/ for variables related to class fields, which
before were assuming there are only instance fields implemented.

• bytecode/UnlinkedFunctionExecutable.cpp:

(JSC::generateUnlinkedFunctionCodeBlock): do s/instanceField/classField/.

• bytecode/UnlinkedFunctionExecutable.h: ditto.
• bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::emitNewClassFieldInitializerFunction): ditto.

• bytecompiler/BytecodeGenerator.h: ditto, plus add a parameter

for static field locations in emitDefineClassElements.

• bytecompiler/NodesCodegen.cpp:

(JSC::PropertyListNode::emitBytecode): save static fields
locations when going through the property list.
(JSC::PropertyListNode::emitSaveComputedFieldName): consider
static fields here too.
(JSC::ClassExprNode::emitBytecode): call the initializer for
static fields as the very last action of the class creation.

• parser/ASTBuilder.h:

(JSC::ASTBuilder::createDefineField): field nodes can be static
too now.

• parser/NodeConstructors.h:

(JSC::DefineFieldNode::DefineFieldNode): ditto.

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

(JSC::Parser<LexerType>::parseInner): s/instanceField/classField/
(JSC::Parser<LexerType>::parseClass): consider static fields.
(JSC::Parser<LexerType>::parseInstanceFieldInitializerSourceElements):
s/instanceField/classField/, and consider static fields.

• parser/Parser.h:

(JSC::Parser<LexerType>::parse): s/instanceField/classField/
(JSC::parse): ditto.

• runtime/JSFunction.cpp:

(JSC::JSFunction::setFunctionName): s/instanceField/classField/

• runtime/OptionsList.h: add option to enable/disable static public fields.

File:

• trunk/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp (modified) (9 diffs)

trunk/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp

@@ -187 +187 @@
 static RegisterID* emitHomeObjectForCallee(BytecodeGenerator& generator)
 {
-    if ((generator.isDerivedClassContext() || generator.isDerivedConstructorContext()) && generator.parseMode() != SourceParseMode::InstanceFieldInitializerMode) {
+    if ((generator.isDerivedClassContext() || generator.isDerivedConstructorContext()) && generator.parseMode() != SourceParseMode::ClassFieldInitializerMode) {
         RegisterID* derivedConstructor = generator.emitLoadDerivedConstructorFromArrowFunctionLexicalEnvironment();
         return generator.emitGetById(generator.newTemporary(), derivedConstructor, generator.propertyNames().builtinNames().homeObjectPrivateName());
@@ -578 +578 @@
 }
 
-RegisterID* PropertyListNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dstOrConstructor, RegisterID* prototype, Vector<JSTextPosition>* instanceFieldLocations)
+RegisterID* PropertyListNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dstOrConstructor, RegisterID* prototype, Vector<JSTextPosition>* instanceFieldLocations, Vector<JSTextPosition>* staticFieldLocations)
 {
     PropertyListNode* p = this;
@@ -593 +593 @@
             ASSERT(instanceFieldLocations);
             instanceFieldLocations->append(p->position());
+            continue;
+        }
+
+        if (p->isStaticClassField()) {
+            ASSERT(staticFieldLocations);
+            staticFieldLocations->append(p->position());
             continue;
         }
@@ -650 +656 @@
                 ASSERT(node->m_type & PropertyNode::Constant);
                 instanceFieldLocations->append(p->position());
+                continue;
+            }
+
+            if (p->isStaticClassField()) {
+                ASSERT(staticFieldLocations);
+                staticFieldLocations->append(p->position());
                 continue;
             }
@@ -745 +757 @@
 void PropertyListNode::emitPutConstantProperty(BytecodeGenerator& generator, RegisterID* newObj, PropertyNode& node)
 {
-    // Private fields are handled in the synthetic instanceFieldInitializer function, not here.
+    // Private fields are handled in a synthetic classFieldInitializer function, not here.
     ASSERT(!(node.type() & PropertyNode::Private));
 
@@ -801 +813 @@
 {
     ASSERT(node.isComputedClassField());
-    RefPtr<RegisterID> propertyExpr;
 
     // The 'name' refers to a synthetic private name in the class scope, where the property key is saved for later use.
@@ -808 +819 @@
     ASSERT(!var.local());
 
-    propertyExpr = generator.emitNode(node.m_expression);
-    RegisterID* propertyName = generator.emitToPropertyKey(generator.newTemporary(), propertyExpr.get());
+    RefPtr<RegisterID> propertyExpr = generator.emitNode(node.m_expression);
+    RefPtr<RegisterID> propertyName = generator.emitToPropertyKey(generator.newTemporary(), propertyExpr.get());
+
+    if (node.isStaticClassField()) {
+        Ref<Label> validPropertyNameLabel = generator.newLabel();
+        RefPtr<RegisterID> prototypeString = generator.emitLoad(nullptr, JSValue(generator.addStringConstant(generator.propertyNames().prototype)));
+        generator.emitJumpIfFalse(generator.emitBinaryOp<OpStricteq>(generator.newTemporary(), prototypeString.get(), propertyName.get(), OperandTypes(ResultType::stringType(), ResultType::stringType())), validPropertyNameLabel.get());
+        generator.emitThrowTypeError("Cannot declare a static field named 'prototype'");
+        generator.emitLabel(validPropertyNameLabel.get());
+    }
 
     RefPtr<RegisterID> scope = generator.emitResolveScope(nullptr, var);
-    generator.emitPutToScope(scope.get(), var, propertyName, ThrowIfNotFound, InitializationMode::ConstInitialization);
+    generator.emitPutToScope(scope.get(), var, propertyName.get(), ThrowIfNotFound, InitializationMode::ConstInitialization);
 }
 
@@ -4947 +4966 @@
     generator.emitCallDefineProperty(constructor.get(), prototypeNameRegister.get(), prototype.get(), nullptr, nullptr, 0, m_position);
 
+    Vector<JSTextPosition> staticFieldLocations;
     if (m_classElements) {
         m_classElements->emitDeclarePrivateFieldNames(generator, generator.scopeRegister());
 
         Vector<JSTextPosition> instanceFieldLocations;
-        generator.emitDefineClassElements(m_classElements, constructor.get(), prototype.get(), instanceFieldLocations);
+        generator.emitDefineClassElements(m_classElements, constructor.get(), prototype.get(), instanceFieldLocations, staticFieldLocations);
         if (!instanceFieldLocations.isEmpty()) {
-            RefPtr<RegisterID> instanceFieldInitializer = generator.emitNewInstanceFieldInitializerFunction(generator.newTemporary(), WTFMove(instanceFieldLocations), m_classHeritage);
+            RefPtr<RegisterID> instanceFieldInitializer = generator.emitNewClassFieldInitializerFunction(generator.newTemporary(), WTFMove(instanceFieldLocations), m_classHeritage);
 
             // FIXME: Skip this if the initializer function isn't going to need a home object (no eval or super properties)
@@ -4963 +4983 @@
     }
 
-    if (m_needsLexicalScope) {
-        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, InitializationMode::Initialization);
-        }
+    if (m_needsLexicalScope && !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, InitializationMode::Initialization);
+    }
+
+    if (!staticFieldLocations.isEmpty()) {
+        RefPtr<RegisterID> staticFieldInitializer = generator.emitNewClassFieldInitializerFunction(generator.newTemporary(), WTFMove(staticFieldLocations), m_classHeritage);
+        // FIXME: Skip this if the initializer function isn't going to need a home object (no eval or super properties)
+        // https://bugs.webkit.org/show_bug.cgi?id=196867
+        emitPutHomeObject(generator, staticFieldInitializer.get(), constructor.get());
+
+        CallArguments args(generator, nullptr);
+        generator.move(args.thisRegister(), constructor.get());
+        generator.emitCall(generator.newTemporary(), staticFieldInitializer.get(), NoExpectedFunction, args, position(), position(), position(), DebuggableCall::No);
+    }
+
+    if (m_needsLexicalScope)
         generator.popLexicalScope(this);
-    }
 
     return generator.move(generator.finalDestination(dst, constructor.get()), constructor.get());