ChangeLog

2020-06-04  Caitlin Potter  <caitp@igalia.com>

        [JSC] Add support for private class fields

        https://bugs.webkit.org/show_bug.cgi?id=206431

        Reviewed by Saam Barati.

        Expanding upon the earlier public class fields patch, we implement the remaining (and

        significant parts) of the instance fields (https://tc39.es/proposal-class-fields/).

        There are a variety of key changes here:

            - Parser now understands the concept of private names (Token PRIVATENAME).

            - 1 new opcode (op_get_private_name), one changed opcode (op_put_by_val_direct).

            - A method for creating Symbol objects with a null PrivateSymbolImpl is exposed as a

              LinkTimeConstant (@createPrivateSymbol).

            - Null Private Symbols are stored by name (not a valid identifier) in a JSScope, and

              are loaded from the outer scope whenever they are used by the modified opcodes.

        The changes to op_put_by_val_direct include a new bytecode operand (PutByValFlags) which are

        used to distinguish between overwriting or defining a new private field. Specifically, when it

        comes to private field accesses, it's necessary to throw an exception when accessing a field

        which does not exist, or when attempting to define a private field which has already been

        defined.

        During the evaluation of a class expression, before the class element list is evaluated (in case

        any computed property names expressions refer to a new private field), a new PrivateSymbol is

        created for each individual private field name, and stored in the class lexical scope.

        Private field names are loaded from scope before their use. This prevents multiple evaluations

        of the same class source from accessing each other's private fields, because the values of the

        symbols loaded from the class scope would be distinct. This is required by the proposal text,

        and is the key reason why we use ByVal lookups rather than ById lookups.

        To illustrate, typical private field access will look like:

        <Field Reads>

        resolve_scope      <scope=>, <currentScope>, "#x", GlobalProperty, 0

        get_from_scope     <symbol=>, <scope>, "#x", 1050624<DoNotThrowIfNotFound|GlobalProperty|NotInitialization>, 0, 0

        get_private_name   <value=>, <receiver --- probably 'this'>, <symbol>

        <Field Writes>

        resolve_scope      <scope=>, <currentScope>, "#x", GlobalProperty, 0

        get_from_scope     <symbol=>, <scope>, "#x", 1050624<DoNotThrowIfNotFound|GlobalProperty|NotInitialization>, 0, 0

        put_by_val_direct  <receiver, probably 'this'>, <symbol>, <value>, <PutByValPrivateName>

        <Field Definition>

        resolve_scope      <scope=>, <currentScope>, "#x", GlobalProperty, 0

        get_from_scope     <symbol=>, <scope>, "#x", 1050624<DoNotThrowIfNotFound|GlobalProperty|NotInitialization>, 0, 0

        put_by_val_direct  <receiver, probably 'this'>, <symbol>, <value>, <PutByValPrivateName|PutByValThrowIfExists>

        The feature is currently hidden behind the feature flag JSC::Options::usePrivateClassFields.

        * CMakeLists.txt:

        * JavaScriptCore.xcodeproj/project.pbxproj:

        * Sources.txt:

        * builtins/BuiltinNames.h:

        * bytecode/BytecodeList.rb:

        * bytecode/BytecodeUseDef.cpp:

        (JSC::computeUsesForBytecodeIndexImpl):

        (JSC::computeDefsForBytecodeIndexImpl):

        * bytecode/CodeBlock.cpp:

        (JSC::CodeBlock::finalizeLLIntInlineCaches):

        * bytecode/Fits.h:

        * bytecode/LinkTimeConstant.h:

        * bytecode/PutByValFlags.cpp: Copied from Source/JavaScriptCore/bytecode/PutKind.h.

        (WTF::printInternal):

        * bytecode/PutByValFlags.h: Added.

        (JSC::PutByValFlags::create):

        (JSC::PutByValFlags::createDirect):

        (JSC::PutByValFlags::createDefinePrivateField):

        (JSC::PutByValFlags::createPutPrivateField):

        (JSC::PutByValFlags::isDirect const):

        (JSC::PutByValFlags::ecmaMode const):

        (JSC::PutByValFlags::privateFieldAccessKind const):

        (JSC::PutByValFlags::isPrivateFieldAccess const):

        (JSC::PutByValFlags::isPrivateFieldPut const):

        (JSC::PutByValFlags::isPrivateFieldAdd const):

        (JSC::PutByValFlags::PutByValFlags):

        * bytecode/PutKind.h:

        * bytecode/UnlinkedFunctionExecutable.cpp:

        (JSC::generateUnlinkedFunctionCodeBlock):

        * bytecompiler/BytecodeGenerator.cpp:

        (JSC::BytecodeGenerator::instantiateLexicalVariables):

        (JSC::BytecodeGenerator::emitDirectGetByVal):

        (JSC::BytecodeGenerator::emitDirectPutByVal):

        (JSC::BytecodeGenerator::emitDefinePrivateField):

        (JSC::BytecodeGenerator::emitPrivateFieldPut):

        * bytecompiler/BytecodeGenerator.h:

        * bytecompiler/NodesCodegen.cpp:

        (JSC::PropertyListNode::emitDeclarePrivateFieldNames):

        (JSC::PropertyListNode::emitBytecode):

        (JSC::PropertyListNode::emitPutConstantProperty):

        (JSC::DotAccessorNode::emitBytecode):

        (JSC::BaseDotNode::emitGetPropertyValue):

        (JSC::BaseDotNode::emitPutProperty):

        (JSC::FunctionCallDotNode::emitBytecode):

        (JSC::PostfixNode::emitDot):

        (JSC::PrefixNode::emitDot):

        (JSC::AssignDotNode::emitBytecode):

        (JSC::ReadModifyDotNode::emitBytecode):

        (JSC::DefineFieldNode::emitBytecode):

        (JSC::ClassExprNode::emitBytecode):

        * dfg/DFGByteCodeParser.cpp:

        (JSC::DFG::ecmaMode):

        (JSC::DFG::ecmaMode<OpPutByValDirect>):

        (JSC::DFG::ByteCodeParser::handlePutByVal):

        * dfg/DFGCapabilities.cpp:

        (JSC::DFG::capabilityLevel):

        * dfg/DFGSpeculativeJIT.cpp:

        (JSC::DFG::SpeculativeJIT::cachedPutById):

        * ftl/FTLLowerDFGToB3.cpp:

        (JSC::FTL::DFG::LowerDFGToB3::compilePutById):

        * generator/DSL.rb:

        * jit/ICStats.h:

        * jit/JIT.cpp:

        (JSC::JIT::privateCompileMainPass):

        * jit/JIT.h:

        * jit/JITInlineCacheGenerator.cpp:

        (JSC::JITPutByIdGenerator::JITPutByIdGenerator):

        (JSC::JITPutByIdGenerator::slowPathFunction):

        * jit/JITInlineCacheGenerator.h:

        (JSC::JITPutByIdGenerator::JITPutByIdGenerator):

        * jit/JITInlines.h:

        (JSC::JIT::ecmaMode):

        (JSC::JIT::ecmaMode<OpPutById>):

        (JSC::JIT::ecmaMode<OpPutByValDirect>):

        (JSC::JIT::privateFieldAccessKind):

        (JSC::JIT::privateFieldAccessKind<OpPutByValDirect>):

        * jit/JITOperations.cpp:

        (JSC::putPrivateField):

        (JSC::definePrivateField):

        * jit/JITOperations.h:

        * jit/JITPropertyAccess.cpp:

        (JSC::JIT::emitPutByValWithCachedId):

        (JSC::JIT::emitSlow_op_put_by_val):

        (JSC::JIT::emit_op_put_by_id):

        * jit/JITPropertyAccess32_64.cpp:

        (JSC::JIT::emitSlow_op_put_by_val):

        (JSC::JIT::emit_op_put_by_id):

        * jit/Repatch.cpp:

        (JSC::appropriateGenericPutByIdFunction):

        (JSC::appropriateOptimizingPutByIdFunction):

        (JSC::tryCachePutByID):

        * llint/LLIntOffsetsExtractor.cpp:

        * llint/LLIntSlowPaths.cpp:

        (JSC::LLInt::LLINT_SLOW_PATH_DECL):

        * llint/LLIntSlowPaths.h:

        * llint/LowLevelInterpreter32_64.asm:

        * llint/LowLevelInterpreter64.asm:

        * parser/ASTBuilder.h:

        (JSC::ASTBuilder::createDotAccess):

        (JSC::ASTBuilder::isPrivateLocation):

        (JSC::ASTBuilder::makeFunctionCallNode):

        (JSC::ASTBuilder::makeAssignNode):

        * parser/Lexer.cpp:

        (JSC::Lexer<LChar>::parseIdentifier):

        (JSC::Lexer<UChar>::parseIdentifier):

        (JSC::Lexer<CharacterType>::parseIdentifierSlowCase):

        (JSC::Lexer<T>::lexWithoutClearingLineTerminator):

        * parser/NodeConstructors.h:

        (JSC::BaseDotNode::BaseDotNode):

        (JSC::DotAccessorNode::DotAccessorNode):

        (JSC::FunctionCallDotNode::FunctionCallDotNode):

        (JSC::CallFunctionCallDotNode::CallFunctionCallDotNode):

        (JSC::ApplyFunctionCallDotNode::ApplyFunctionCallDotNode):

        (JSC::HasOwnPropertyFunctionCallDotNode::HasOwnPropertyFunctionCallDotNode):

        (JSC::AssignDotNode::AssignDotNode):

        (JSC::ReadModifyDotNode::ReadModifyDotNode):

        * parser/Nodes.cpp:

        (JSC::PropertyListNode::shouldCreateLexicalScopeForClass):

        * parser/Nodes.h:

        (JSC::ExpressionNode::isPrivateLocation const):

        (JSC::BaseDotNode::base const):

        (JSC::BaseDotNode::identifier const):

        (JSC::BaseDotNode::type const):

        (JSC::BaseDotNode::isPrivateField const):

        * parser/Parser.cpp:

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

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

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

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

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

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

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

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

        * parser/Parser.h:

        (JSC::Scope::isPrivateNameScope const):

        (JSC::Scope::setIsPrivateNameScope):

        (JSC::Scope::hasPrivateName):

        (JSC::Scope::copyUndeclaredPrivateNamesTo):

        (JSC::Scope::hasUsedButUndeclaredPrivateNames const):

        (JSC::Scope::usePrivateName):

        (JSC::Scope::declarePrivateName):

        (JSC::Parser::findPrivateNameScope):

        (JSC::Parser::privateNameScope):

        (JSC::Parser::copyUndeclaredPrivateNamesToOuterScope):

        (JSC::Parser::matchAndUpdate):

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

        (JSC::parse):

        * parser/ParserTokens.h:

        * parser/SyntaxChecker.h:

        (JSC::SyntaxChecker::createDotAccess):

        (JSC::SyntaxChecker::operatorStackPop):

        * parser/VariableEnvironment.cpp:

        (JSC::VariableEnvironment::operator=):

        (JSC::VariableEnvironment::swap):

        (JSC::CompactVariableEnvironment::CompactVariableEnvironment):

        * parser/VariableEnvironment.h:

        (JSC::VariableEnvironmentEntry::isPrivateName const):

        (JSC::VariableEnvironmentEntry::setIsPrivateName):

        (JSC::PrivateNameEntry::PrivateNameEntry):

        (JSC::PrivateNameEntry::isUsed const):

        (JSC::PrivateNameEntry::isDeclared const):

        (JSC::PrivateNameEntry::setIsUsed):

        (JSC::PrivateNameEntry::setIsDeclared):

        (JSC::PrivateNameEntry::bits const):

        (JSC::PrivateNameEntry::operator== const):

        (JSC::VariableEnvironment::VariableEnvironment):

        (JSC::VariableEnvironment::size const):

        (JSC::VariableEnvironment::mapSize const):

        (JSC::VariableEnvironment::declarePrivateName):

        (JSC::VariableEnvironment::usePrivateName):

        (JSC::VariableEnvironment::privateNames const):

        (JSC::VariableEnvironment::privateNamesSize const):

        (JSC::VariableEnvironment::hasPrivateName):

        (JSC::VariableEnvironment::copyPrivateNamesTo const):

        (JSC::VariableEnvironment::copyUndeclaredPrivateNamesTo const):

        (JSC::VariableEnvironment::RareData::RareData):

        (JSC::VariableEnvironment::getOrAddPrivateName):

        * runtime/CachedTypes.cpp:

        (JSC::CachedOptional::decodeAsPtr const):

        (JSC::CachedVariableEnvironmentRareData::encode):

        (JSC::CachedVariableEnvironmentRareData::decode const):

        (JSC::CachedVariableEnvironment::encode):

        (JSC::CachedVariableEnvironment::decode const):

        (JSC::CachedSymbolTableRareData::encode):

        (JSC::CachedSymbolTableRareData::decode const):

        (JSC::CachedSymbolTable::encode):

        (JSC::CachedSymbolTable::decode const):

        * runtime/CodeCache.cpp:

        (JSC::generateUnlinkedCodeBlockImpl):

        * runtime/CommonIdentifiers.cpp:

        (JSC::CommonIdentifiers::CommonIdentifiers):

        * runtime/CommonIdentifiers.h:

        * runtime/CommonSlowPaths.cpp:

        (JSC::SLOW_PATH_DECL):

        * runtime/CommonSlowPaths.h:

        * runtime/ExceptionHelpers.cpp:

        (JSC::createInvalidPrivateNameError):

        (JSC::createRedefinedPrivateNameError):

        * runtime/ExceptionHelpers.h:

        * runtime/JSGlobalObject.cpp:

        (JSC::createPrivateSymbol):

        (JSC::JSGlobalObject::init):

        * runtime/JSObject.h:

        * runtime/JSObjectInlines.h:

        (JSC::JSObject::getPrivateFieldSlot):

        (JSC::JSObject::getPrivateField):

        (JSC::JSObject::putPrivateField):

        (JSC::JSObject::definePrivateField):

        * runtime/JSScope.cpp:

        (JSC::JSScope::collectClosureVariablesUnderTDZ):

        * runtime/OptionsList.h:

        * runtime/SymbolTable.cpp:

        (JSC::SymbolTable::cloneScopePart):

        * runtime/SymbolTable.h:

2020-06-04  Mark Lam  <mark.lam@apple.com>

        Reduce DFGDoesGCCheck to only storing a uint32_t.

Source/JavaScriptCore/CMakeLists.txt

@@set(JavaScriptCore_PRIVATE_FRAMEWORK_HEADERS

    bytecode/Operands.h

    bytecode/PropertyCondition.h

    bytecode/PutByIdFlags.h

543 bytecode/PutByValFlags.h

    bytecode/SpeculatedType.h

    bytecode/StructureSet.h

    bytecode/SuperSampler.h

Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

		86704B8712DBA33700A9FE7B /* YarrJIT.h in Headers */ = {isa = PBXBuildFile; fileRef = 86704B8012DBA33700A9FE7B /* YarrJIT.h */; settings = {ATTRIBUTES = (Private, ); }; };

		86704B8812DBA33700A9FE7B /* YarrParser.h in Headers */ = {isa = PBXBuildFile; fileRef = 86704B8112DBA33700A9FE7B /* YarrParser.h */; settings = {ATTRIBUTES = (Private, ); }; };

		86704B8A12DBA33700A9FE7B /* YarrPattern.h in Headers */ = {isa = PBXBuildFile; fileRef = 86704B8312DBA33700A9FE7B /* YarrPattern.h */; settings = {ATTRIBUTES = (Private, ); }; };

1253 8676C6E82346467E00FAAFF3 /* PutByValFlags.h in Headers */ = {isa = PBXBuildFile; fileRef = 8676C6E62346450B00FAAFF3 /* PutByValFlags.h */; settings = {ATTRIBUTES = (Private, ); }; };

		868916B0155F286300CB2B9A /* PrivateName.h in Headers */ = {isa = PBXBuildFile; fileRef = 868916A9155F285400CB2B9A /* PrivateName.h */; settings = {ATTRIBUTES = (Private, ); }; };

		868921C21F9C0CB7001159F6 /* JSBigInt.h in Headers */ = {isa = PBXBuildFile; fileRef = 868921C11F9C0CB7001159F6 /* JSBigInt.h */; settings = {ATTRIBUTES = (Private, ); }; };

		86976E5E1FA3E8B600E7C4E1 /* BigIntPrototype.h in Headers */ = {isa = PBXBuildFile; fileRef = 86976E5A1FA3758A00E7C4E1 /* BigIntPrototype.h */; settings = {ATTRIBUTES = (Private, ); }; };

		86704B8112DBA33700A9FE7B /* YarrParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = YarrParser.h; path = yarr/YarrParser.h; sourceTree = "<group>"; };

		86704B8212DBA33700A9FE7B /* YarrPattern.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = YarrPattern.cpp; path = yarr/YarrPattern.cpp; sourceTree = "<group>"; };

		86704B8312DBA33700A9FE7B /* YarrPattern.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = YarrPattern.h; path = yarr/YarrPattern.h; sourceTree = "<group>"; };

4119 8676C6E62346450B00FAAFF3 /* PutByValFlags.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = PutByValFlags.h; sourceTree = "<group>"; };

4120 8676C6E7234645B300FAAFF3 /* PutByValFlags.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = PutByValFlags.cpp; sourceTree = "<group>"; };

		86880F1B14328BB900B08D42 /* DFGSpeculativeJIT32_64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DFGSpeculativeJIT32_64.cpp; path = dfg/DFGSpeculativeJIT32_64.cpp; sourceTree = "<group>"; };

		86880F4C14353B2100B08D42 /* DFGSpeculativeJIT64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DFGSpeculativeJIT64.cpp; path = dfg/DFGSpeculativeJIT64.cpp; sourceTree = "<group>"; };

		868916A9155F285400CB2B9A /* PrivateName.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PrivateName.h; sourceTree = "<group>"; };

				0F93329A14CA7DC10085F3C6 /* PutByIdStatus.h */,

				0F93B4A718B92C4D00178A3F /* PutByIdVariant.cpp */,

				0F93B4A818B92C4D00178A3F /* PutByIdVariant.h */,

8411 8676C6E7234645B300FAAFF3 /* PutByValFlags.cpp */,

8412 8676C6E62346450B00FAAFF3 /* PutByValFlags.h */,

				0F9FC8C114E1B5FB00D52AE0 /* PutKind.h */,

				0F44A7AD20BF685F0022B171 /* RecordedStatuses.cpp */,

				0F44A7AA20BF685E0022B171 /* RecordedStatuses.h */,

				C2981FD917BAEE4B00A3BC98 /* DFGDesiredWeakReferences.h in Headers */,

				0FF427651591A1CE004CB9FF /* DFGDisassembler.h in Headers */,

				0F5A1274192D9FDF008764A3 /* DFGDoesGC.h in Headers */,

9349 FEC3A3A1248735CA00395B54 /* DFGDoesGCCheck.h in Headers */,

				0FD81AD3154FB4F000983E72 /* DFGDominators.h in Headers */,

				0F1E3A471534CBB9000F9456 /* DFGDoubleFormatState.h in Headers */,

				0FD3C82814115D4F00FD81CB /* DFGDriver.h in Headers */,

				0F15CD231BA5F9860031FFD3 /* PutByIdFlags.h in Headers */,

				0F9332A414CA7DD90085F3C6 /* PutByIdStatus.h in Headers */,

				0F93B4AA18B92C4D00178A3F /* PutByIdVariant.h in Headers */,

10162 8676C6E82346467E00FAAFF3 /* PutByValFlags.h in Headers */,

				0F0CD4C215F1A6070032F1C0 /* PutDirectIndexMode.h in Headers */,

				0F9FC8C514E1B60400D52AE0 /* PutKind.h in Headers */,

				147B84630E6DE6B1004775A4 /* PutPropertySlot.h in Headers */,

				79D5CD5B1C1106A900CECA07 /* SamplingProfiler.h in Headers */,

				0FE050281AA9095600D33B33 /* ScopedArguments.h in Headers */,

				0FE050291AA9095600D33B33 /* ScopedArgumentsTable.h in Headers */,

10204 FEC3A3A1248735CA00395B54 /* DFGDoesGCCheck.h in Headers */,

				0FE0502B1AA9095600D33B33 /* ScopeOffset.h in Headers */,

				0F24E55217EE274900ABB217 /* ScratchRegisterAllocator.h in Headers */,

				33111B8B2397256500AA34CE /* Scribble.h in Headers */,

Source/JavaScriptCore/Sources.txt

@@bytecode/ProxyableAccessCase.cpp

bytecode/PutByIdFlags.cpp

bytecode/PutByIdStatus.cpp

bytecode/PutByIdVariant.cpp

271bytecode/PutByValFlags.cpp

bytecode/RecordedStatuses.cpp

bytecode/ReduceWhitespace.cpp

bytecode/SpeculatedType.cpp

Source/JavaScriptCore/builtins/BuiltinNames.h

@@namespace JSC {

    macro(webAssemblyCompileStreamingInternal) \

    macro(webAssemblyInstantiateStreamingInternal) \

    macro(instanceFieldInitializer) \

172 macro(hasOwnPropertyFunction)

172 macro(hasOwnPropertyFunction) \

173 macro(createPrivateSymbol)

namespace Symbols {

#define DECLARE_BUILTIN_STATIC_SYMBOLS(name) extern JS_EXPORT_PRIVATE SymbolImpl::StaticSymbolImpl name##Symbol;

Source/JavaScriptCore/bytecode/BytecodeList.rb

@@types [

    :ProfileTypeBytecodeFlag,

    :PropertyOffset,

    :PutByIdFlags,

52 :PutByValFlags,

    :ResolveType,

    :Structure,

    :StructureID,

@@op :get_by_val,

        seenIdentifiers: GetByValHistory,

    }

op :get_private_name,

    args: {

        dst: VirtualRegister,

        base: VirtualRegister,

        property: VirtualRegister,

    },

    metadata: {

        profile: ValueProfile,

        structureID: StructureID,

        offset: unsigned,

        property: WriteBarrier[JSCell],

    }

op :put_by_val,

    args: {

        base: VirtualRegister,

@@op :put_by_val_direct,

        base: VirtualRegister,

        property: VirtualRegister,

        value: VirtualRegister,

578 ~~ecmaMode: ECMAMode~~,

592 flags: PutByValFlags,

    },

    metadata: {

        arrayProfile: ArrayProfile,

Source/JavaScriptCore/bytecode/BytecodeUseDef.cpp

@@void computeUsesForBytecodeIndexImpl(VirtualRegister scopeRegister, const Instru

    USES(OpEnumeratorStructurePname, enumerator, index)

    USES(OpEnumeratorGenericPname, enumerator, index)

    USES(OpGetByVal, base, property)

216 USES(OpGetPrivateName, base, property)

    USES(OpInByVal, base, property)

    USES(OpOverridesHasInstance, constructor, hasInstanceValue)

    USES(OpInstanceof, value, prototype)

@@void computeDefsForBytecodeIndexImpl(unsigned numVars, const Instruction* instru

    DEFS(OpInstanceof, dst)

    DEFS(OpInstanceofCustom, dst)

    DEFS(OpGetByVal, dst)

432 DEFS(OpGetPrivateName, dst)

    DEFS(OpTypeof, dst)

    DEFS(OpIdentityWithProfile, srcDst)

    DEFS(OpIsEmpty, dst)

Source/JavaScriptCore/bytecode/CodeBlock.cpp

@@void CodeBlock::finalizeLLIntInlineCaches()

            metadata.m_offset = 0;

        });

        m_metadata->forEach<OpGetPrivateName>([&] (auto& metadata) {

            JSCell* property = metadata.m_property.get();

            StructureID structureID = metadata.m_structureID;

            if ((!property || vm.heap.isMarked(property)) && (!structureID || vm.heap.isMarked(vm.heap.structureIDTable().get(structureID))))

                return;

            dataLogLnIf(Options::verboseOSR(), "Clearing LLInt private property access.");

            metadata.m_structureID = 0;

            metadata.m_offset = 0;

            metadata.m_property.clear();

        });

        m_metadata->forEach<OpPutById>([&] (auto& metadata) {

            StructureID oldStructureID = metadata.m_oldStructureID;

            StructureID newStructureID = metadata.m_newStructureID;

Source/JavaScriptCore/bytecode/Fits.h

#include "OpcodeSize.h"

#include "ProfileTypeBytecodeFlag.h"

#include "PutByIdFlags.h"

34#include "PutByValFlags.h"

#include "ResultType.h"

#include "SymbolTableOrScopeDepth.h"

#include "VirtualRegister.h"

@@struct Fits<PutByIdFlags, size> {

        return isDirect ? PutByIdFlags::createDirect(ecmaMode) : PutByIdFlags::create(ecmaMode);

    }

};

template<OpcodeSize size>

struct Fits<PutByValFlags, size> {

    using TargetType = typename TypeBySize<size>::unsignedType;

    // PutByValFlags is 2 booleans and a 2 bit enum, encoded as:

    //          isStrict

    //             v

    //     0000|00|0|0 < isDirect

    //           ^

    //    PrivateFieldAccessKind {0 = None, 1 = Put, 2 = Create }

    static constexpr int s_isDirectBit = 1;

    static constexpr int s_isStrictBit = 2;

    static constexpr int s_privateFieldAccessKindMask = 12;

    static constexpr int s_privateFieldAccessKindShift = 2;

    static bool check(PutByValFlags)

    {

        return true;

    }

    static TargetType convert(PutByValFlags flags)

    {

        auto isDirect = static_cast<uint8_t>(flags.isDirect());

        auto isStrict = static_cast<uint8_t>(flags.ecmaMode().isStrict());

        auto privateFieldAccessKind = static_cast<uint8_t>(flags.privateFieldAccessKind());

        return (privateFieldAccessKind << s_privateFieldAccessKindShift) | (isStrict << 1) | isDirect;

    }

    static PutByValFlags convert(TargetType gpi)

    {

        auto isDirect = static_cast<bool>(gpi & s_isDirectBit);

        auto isStrict = static_cast<bool>(gpi & s_isStrictBit);

        auto access = static_cast<PrivateFieldAccessKind>((gpi & s_privateFieldAccessKindMask) >> s_privateFieldAccessKindShift);

        auto ecmaMode = isStrict ? ECMAMode::strict() : ECMAMode::sloppy();

        return access == PrivateFieldAccessKind::None ?

            isDirect ? PutByValFlags::createDirect(ecmaMode) : PutByValFlags::create(ecmaMode) :

            access == PrivateFieldAccessKind::Put ? PutByValFlags::createPutPrivateField(ecmaMode) : PutByValFlags::createDefinePrivateField(ecmaMode);

    }

};

template<typename E, OpcodeSize size>

struct Fits<E, size, std::enable_if_t<sizeof(E) != size && std::is_enum<E>::value, std::true_type>> : public Fits<std::underlying_type_t<E>, size> {

    using Base = Fits<std::underlying_type_t<E>, size>;

Source/JavaScriptCore/bytecode/LinkTimeConstant.h

@@class JSGlobalObject;

    v(applyFunction, nullptr) \

    v(callFunction, nullptr) \

    v(hasOwnPropertyFunction, nullptr) \

108 v(createPrivateSymbol, nullptr) \

#define DECLARE_LINK_TIME_CONSTANT(name, code) name,

Source/JavaScriptCore/bytecode/PutByValFlags.cpp

/*

 * Copyright (C) 2020 Apple Inc. All rights reserved.

 * Copyright (C) 2020 Igalia S.L.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#include "config.h"

#include "PutByValFlags.h"

#include <wtf/CommaPrinter.h>

#include <wtf/PrintStream.h>

#include <wtf/StringPrintStream.h>

namespace WTF {

using namespace JSC;

void printInternal(PrintStream& out, PutByValFlags flags)

{

    CommaPrinter comma("|");

    if (flags.isDirect())

        out.print(comma, "Direct");

    if (flags.isPrivateFieldPut())

        out.print(comma, "PrivateField+Put");

    if (flags.isPrivateFieldAdd())

        out.print(comma, "PrivateField+Add");

}

} // namespace WTF

Source/JavaScriptCore/bytecode/PutByValFlags.h

/*

 * Copyright (C) 2020 Apple Inc. All rights reserved.

 * Copyright (C) 2020 Igalia S.L.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#pragma once

#include "StructureIDTable.h"

namespace JSC {

enum class PrivateFieldAccessKind : uint8_t {

    None,

    Put,

    Create,

};

class PutByValFlags {

public:

    constexpr static PutByValFlags create(ECMAMode ecmaMode)

    {

        return PutByValFlags(false, ecmaMode);

    }

    // A direct put_by_id means that we store the property without checking if the

    // prototype chain has a setter.

    constexpr static PutByValFlags createDirect(ECMAMode ecmaMode)

    {

        return PutByValFlags(true, ecmaMode);

    }

    constexpr static PutByValFlags createDefinePrivateField(ECMAMode ecmaMode)

    {

        return PutByValFlags(PrivateFieldAccessKind::Create, ecmaMode);

    }

    constexpr static PutByValFlags createPutPrivateField(ECMAMode ecmaMode)

    {

        return PutByValFlags(PrivateFieldAccessKind::Put, ecmaMode);

    }

    bool isDirect() const { return m_isDirect; }

    ECMAMode ecmaMode() const { return m_ecmaMode; }

    PrivateFieldAccessKind privateFieldAccessKind() const { return m_privateFieldAccessKind; }

    bool isPrivateFieldAccess() const { return m_privateFieldAccessKind != PrivateFieldAccessKind::None; }

    bool isPrivateFieldPut() const { return m_privateFieldAccessKind == PrivateFieldAccessKind::Put; }

    bool isPrivateFieldAdd() const { return m_privateFieldAccessKind == PrivateFieldAccessKind::Create; }

private:

    constexpr PutByValFlags(bool isDirect, ECMAMode ecmaMode)

        : m_isDirect(isDirect)

        , m_privateFieldAccessKind(PrivateFieldAccessKind::None)

        , m_ecmaMode(ecmaMode)

    {

    }

    constexpr PutByValFlags(PrivateFieldAccessKind access, ECMAMode ecmaMode)

        : m_isDirect(true)

        , m_privateFieldAccessKind(access)

        , m_ecmaMode(ecmaMode)

    {

    }

    bool m_isDirect;

    PrivateFieldAccessKind m_privateFieldAccessKind;

    ECMAMode m_ecmaMode;

};

} // namespace JSC

namespace WTF {

class PrintStream;

void printInternal(PrintStream&, JSC::PutByValFlags);

} // namespace WTF

Source/JavaScriptCore/bytecode/PutKind.h

namespace JSC {

30 enum PutKind { Direct, NotDirect };

30enum PutKind { Direct, NotDirect, DirectPrivateFieldCreate, DirectPrivateFieldPut };

3131

3232} // namespace JSC

Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp

@@static UnlinkedFunctionCodeBlock* generateUnlinkedFunctionCodeBlock(

    ASSERT(isFunctionParseMode(executable->parseMode()));

    Vector<JSTextPosition>* instanceFieldLocations = executable->instanceFieldLocations();

    std::unique_ptr<FunctionNode> function = parse<FunctionNode>(

61 vm, source, executable->name(), builtinMode, strictMode, scriptMode, executable->parseMode(), executable->superBinding(), error, nullptr, ConstructorKind::None, DerivedContextType::None, EvalContextType::None, nullptr, instanceFieldLocations);

61 vm, source, executable->name(), builtinMode, strictMode, scriptMode, executable->parseMode(), executable->superBinding(), error, nullptr, ConstructorKind::None, DerivedContextType::None, EvalContextType::None, nullptr, nullptr, instanceFieldLocations);

    if (!function) {

        ASSERT(error.isValid());

Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp

@@bool BytecodeGenerator::instantiateLexicalVariables(const VariableEnvironment& l

            SymbolTableEntry newEntry(varOffset, static_cast<unsigned>(entry.value.isConst() ? PropertyAttribute::ReadOnly : PropertyAttribute::None));

            symbolTable->add(NoLockingNecessary, entry.key.get(), newEntry);

            // FIXME: only do this if there is an eval() within a nested scope --- otherwise it isn't needed.

            // https://bugs.webkit.org/show_bug.cgi?id=206663

            if (entry.value.isPrivateName())

                symbolTable->addPrivateName(entry.key.get());

        }

    }

    return hasCapturedVariables;

@@RegisterID* BytecodeGenerator::emitPutByVal(RegisterID* base, RegisterID* thisVa

    return value;

}

RegisterID* BytecodeGenerator::emitDirectGetByVal(RegisterID* dst, RegisterID* base, RegisterID* property)

{

    OpGetPrivateName::emit(this, dst, base, property);

    return dst;

}

26962707RegisterID* BytecodeGenerator::emitDirectPutByVal(RegisterID* base, RegisterID* property, RegisterID* value)

26972708{

2698 OpPutByValDirect::emit(this, base, property, value, ecmaMode());

2709 OpPutByValDirect::emit(this, base, property, value, PutByValFlags::createDirect(ecmaMode()));

    return value;

}

@@RegisterID* BytecodeGenerator::emitPutInternalField(RegisterID* base, unsigned i

    return value;

}

RegisterID* BytecodeGenerator::emitDefinePrivateField(RegisterID* base, RegisterID* property, RegisterID* value)

{

    OpPutByValDirect::emit(this, base, property, value, PutByValFlags::createDefinePrivateField(ecmaMode()));

    return value;

}

RegisterID* BytecodeGenerator::emitPrivateFieldPut(RegisterID* base, RegisterID* property, RegisterID* value)

{

    OpPutByValDirect::emit(this, base, property, value, PutByValFlags::createPutPrivateField(ecmaMode()));

    return value;

}

void BytecodeGenerator::emitSuperSamplerBegin()

{

    OpSuperSamplerBegin::emit(this);

Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h

@@namespace JSC {

        RegisterID* emitGetByVal(RegisterID* dst, RegisterID* base, RegisterID* thisValue, RegisterID* property);

        RegisterID* emitPutByVal(RegisterID* base, RegisterID* property, RegisterID* value);

        RegisterID* emitPutByVal(RegisterID* base, RegisterID* thisValue, RegisterID* property, RegisterID* value);

816 RegisterID* emitDirectGetByVal(RegisterID* dst, RegisterID* base, RegisterID* property);

        RegisterID* emitDirectPutByVal(RegisterID* base, RegisterID* property, RegisterID* value);

        RegisterID* emitDeleteByVal(RegisterID* dst, RegisterID* base, RegisterID* property);

        RegisterID* emitGetInternalField(RegisterID* dst, RegisterID* base, unsigned index);

        RegisterID* emitPutInternalField(RegisterID* base, unsigned index, RegisterID* value);

822 RegisterID* emitDefinePrivateField(RegisterID* base, RegisterID* property, RegisterID* value);

823 RegisterID* emitPrivateFieldPut(RegisterID* base, RegisterID* property, RegisterID* value);

        void emitSuperSamplerBegin();

        void emitSuperSamplerEnd();

Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp

@@static inline void emitPutHomeObject(BytecodeGenerator& generator, RegisterID* f

    generator.emitPutById(function, generator.propertyNames().builtinNames().homeObjectPrivateName(), homeObject);

}

void PropertyListNode::emitDeclarePrivateFieldNames(BytecodeGenerator& generator, RegisterID* scope)

{

    // Walk the list and declare any Private property names (e.g. `#foo`) in the provided scope.

    RefPtr<RegisterID> createPrivateSymbol;

    for (PropertyListNode* p = this; p; p = p->m_next) {

        const PropertyNode& node = *p->m_node;

        if (node.type() & PropertyNode::Private) {

            if (!createPrivateSymbol)

                createPrivateSymbol = generator.moveLinkTimeConstant(nullptr, LinkTimeConstant::createPrivateSymbol);

            CallArguments arguments(generator, nullptr, 0);

            generator.emitLoad(arguments.thisRegister(), jsUndefined());

            RefPtr<RegisterID> symbol = generator.emitCall(generator.finalDestination(nullptr, createPrivateSymbol.get()), createPrivateSymbol.get(), NoExpectedFunction, arguments, position(), position(), position(), DebuggableCall::No);

            Variable var = generator.variable(*node.name());

            generator.emitPutToScope(scope, var, symbol.get(), DoNotThrowIfNotFound, InitializationMode::ConstInitialization);

        }

    }

}

547567RegisterID* PropertyListNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dstOrConstructor, RegisterID* prototype, Vector<JSTextPosition>* instanceFieldLocations)

548568{

549 // Fast case: this loop just handles regular value properties.

550569 PropertyListNode* p = this;

551570 RegisterID* dst = nullptr;

571

572 // Fast case: this loop just handles regular value properties.

    for (; p && (p->m_node->m_type & PropertyNode::Constant); p = p->m_next) {

        dst = p->m_node->isInstanceClassProperty() ? prototype : dstOrConstructor;

@@RegisterID* PropertyListNode::emitBytecode(BytecodeGenerator& generator, Registe

void PropertyListNode::emitPutConstantProperty(BytecodeGenerator& generator, RegisterID* newObj, PropertyNode& node)

{

    // Private fields are handled in the synthetic instanceFieldInitializer function, not here.

    ASSERT(!(node.type() & PropertyNode::Private));

    bool shouldSetFunctionName = generator.shouldSetFunctionName(node.m_assign);

    RefPtr<RegisterID> propertyName;

@@RegisterID* DotAccessorNode::emitBytecode(BytecodeGenerator& generator, Register

    }

    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());

    RegisterID* ret;

    if (baseIsSuper) {

        RefPtr<RegisterID> thisValue = generator.ensureThis();

        ret = generator.emitGetById(finalDest.get(), base.get(), thisValue.get(), m_ident);

    } else

        ret = generator.emitGetById(finalDest.get(), base.get(), m_ident);

867 RegisterID* ret = emitGetPropertyValue(generator, finalDest.get(), base.get());

868

    generator.emitProfileType(finalDest.get(), divotStart(), divotEnd());

    return ret;

}

RegisterID* BaseDotNode::emitGetPropertyValue(BytecodeGenerator& generator, RegisterID* dst, RegisterID* base, RefPtr<RegisterID>& thisValue)

{

    if (isPrivateField()) {

        Variable var = generator.variable(m_ident);

        ASSERT_WITH_MESSAGE(!var.local(), "Private Field names must be stored in captured variables");

        RefPtr<RegisterID> scope = generator.emitResolveScope(nullptr, var);

        RefPtr<RegisterID> privateName = generator.newTemporary();

        generator.emitGetFromScope(privateName.get(), scope.get(), var, DoNotThrowIfNotFound);

        return generator.emitDirectGetByVal(dst, base, privateName.get());

    }

    if (m_base->isSuperNode()) {

        if (!thisValue)

            thisValue = generator.ensureThis();

        return generator.emitGetById(dst, base, thisValue.get(), m_ident);

    }

    return generator.emitGetById(dst, base, m_ident);

}

RegisterID* BaseDotNode::emitGetPropertyValue(BytecodeGenerator& generator, RegisterID* dst, RegisterID* base)

{

    RefPtr<RegisterID> thisValue;

    return emitGetPropertyValue(generator, dst, base, thisValue);

}

RegisterID* BaseDotNode::emitPutProperty(BytecodeGenerator& generator, RegisterID* base, RegisterID* value, RefPtr<RegisterID>& thisValue)

{

    if (isPrivateField()) {

        Variable var = generator.variable(m_ident);

        ASSERT_WITH_MESSAGE(!var.local(), "Private Field names must be stored in captured variables");

        RefPtr<RegisterID> scope = generator.emitResolveScope(nullptr, var);

        RefPtr<RegisterID> privateName = generator.newTemporary();

        generator.emitGetFromScope(privateName.get(), scope.get(), var, DoNotThrowIfNotFound);

        return generator.emitPrivateFieldPut(base, privateName.get(), value);

    }

    if (m_base->isSuperNode()) {

        if (!thisValue)

            thisValue = generator.ensureThis();

        return generator.emitPutById(base, thisValue.get(), m_ident, value);

    }

    return generator.emitPutById(base, m_ident, value);

}

RegisterID* BaseDotNode::emitPutProperty(BytecodeGenerator& generator, RegisterID* base, RegisterID* value)

{

    RefPtr<RegisterID> thisValue;

    return emitPutProperty(generator, base, value, thisValue);

}

// ------------------------------ ArgumentListNode -----------------------------

RegisterID* ArgumentListNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

@@RegisterID* FunctionCallDotNode::emitBytecode(BytecodeGenerator& generator, Regi

            generator.emitOptionalCheck(callArguments.thisRegister());

    }

    generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());

    if (baseIsSuper) {

        RefPtr<RegisterID> superBase = emitSuperBaseForCallee(generator);

        generator.emitGetById(function.get(), superBase.get(), callArguments.thisRegister(), m_ident);

    } else

        generator.emitGetById(function.get(), callArguments.thisRegister(), m_ident);

    RefPtr<RegisterID> base = baseIsSuper ? emitSuperBaseForCallee(generator) : callArguments.thisRegister();

    emitGetPropertyValue(generator, function.get(), base.get());

    if (isOptionalChainBase())

        generator.emitOptionalCheck(function.get());

@@RegisterID* PostfixNode::emitDot(BytecodeGenerator& generator, RegisterID* dst)

    RefPtr<RegisterID> base = generator.emitNode(baseNode);

    generator.emitExpressionInfo(dotAccessor->divot(), dotAccessor->divotStart(), dotAccessor->divotEnd());

    if (dotAccessor->isPrivateField()) {

        ASSERT(!baseIsSuper);

        Variable var = generator.variable(ident);

        RefPtr<RegisterID> scope = generator.emitResolveScope(nullptr, var);

        RefPtr<RegisterID> privateName = generator.newTemporary();

        generator.emitGetFromScope(privateName.get(), scope.get(), var, DoNotThrowIfNotFound);

        RefPtr<RegisterID> value = generator.emitDirectGetByVal(generator.newTemporary(), base.get(), privateName.get());

        RefPtr<RegisterID> oldValue = emitPostIncOrDec(generator, generator.tempDestination(dst), value.get(), m_operator);

        generator.emitExpressionInfo(divot(), divotStart(), divotEnd());

        generator.emitPrivateFieldPut(base.get(), privateName.get(), value.get());

        generator.emitProfileType(value.get(), divotStart(), divotEnd());

        return generator.move(dst, oldValue.get());

    }

    RefPtr<RegisterID> value;

    RefPtr<RegisterID> thisValue;

    if (baseIsSuper) {

@@RegisterID* PrefixNode::emitDot(BytecodeGenerator& generator, RegisterID* dst)

    generator.emitExpressionInfo(dotAccessor->divot(), dotAccessor->divotStart(), dotAccessor->divotEnd());

    RegisterID* value;

    if (dotAccessor->isPrivateField()) {

        ASSERT(!baseNode->isSuperNode());

        Variable var = generator.variable(ident);

        RefPtr<RegisterID> scope = generator.emitResolveScope(nullptr, var);

        RefPtr<RegisterID> privateName = generator.newTemporary();

        generator.emitGetFromScope(privateName.get(), scope.get(), var, DoNotThrowIfNotFound);

        value = generator.emitDirectGetByVal(propDst.get(), base.get(), privateName.get());

        emitIncOrDec(generator, value, m_operator);

        generator.emitExpressionInfo(divot(), divotStart(), divotEnd());

        generator.emitPrivateFieldPut(base.get(), privateName.get(), value);

        generator.emitProfileType(value, divotStart(), divotEnd());

        return generator.move(dst, propDst.get());

    }

    RefPtr<RegisterID> thisValue;

    if (baseNode->isSuperNode()) {

        thisValue = generator.ensureThis();

@@RegisterID* AssignDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID

    RefPtr<RegisterID> result = generator.emitNode(value.get(), m_right);

    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());

    RefPtr<RegisterID> forwardResult = (dst == generator.ignoredResult()) ? result.get() : generator.move(generator.tempDestination(result.get()), result.get());

    if (m_base->isSuperNode()) {

        RefPtr<RegisterID> thisValue = generator.ensureThis();

        generator.emitPutById(base.get(), thisValue.get(), m_ident, forwardResult.get());

    } else

        generator.emitPutById(base.get(), m_ident, forwardResult.get());

3299 emitPutProperty(generator, base.get(), forwardResult.get());

    generator.emitProfileType(forwardResult.get(), divotStart(), divotEnd());

    return generator.move(dst, forwardResult.get());

}

@@RegisterID* ReadModifyDotNode::emitBytecode(BytecodeGenerator& generator, Regist

    RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base, m_rightHasAssignments, m_right->isPure(generator));

    generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());

3212 RefPtr<RegisterID> value;

32133311 RefPtr<RegisterID> thisValue;

    if (m_base->isSuperNode()) {

        thisValue = generator.ensureThis();

        value = generator.emitGetById(generator.tempDestination(dst), base.get(), thisValue.get(), m_ident);

    } else

        value = generator.emitGetById(generator.tempDestination(dst), base.get(), m_ident);

3312 RefPtr<RegisterID> value = emitGetPropertyValue(generator, generator.tempDestination(dst), base.get(), thisValue);

3313

    RegisterID* updatedValue = emitReadModifyAssignment(generator, generator.finalDestination(dst, value.get()), value.get(), m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()));

    generator.emitExpressionInfo(divot(), divotStart(), divotEnd());

    RegisterID* ret;

    if (m_base->isSuperNode())

        ret = generator.emitPutById(base.get(), thisValue.get(), m_ident, updatedValue);

    else

        ret = generator.emitPutById(base.get(), m_ident, updatedValue);

3317 RefPtr<RegisterID> ret = emitPutProperty(generator, base.get(), updatedValue, thisValue);

32273318 generator.emitProfileType(updatedValue, divotStart(), divotEnd());

3228 return ret;

3319 return ret.get();

}

// ------------------------------ ShortCircuitReadModifyDotNode -----------------------------------

@@void DefineFieldNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)

        generator.emitCallDefineProperty(generator.thisRegister(), propertyName.get(), value.get(), nullptr, nullptr, BytecodeGenerator::PropertyConfigurable | BytecodeGenerator::PropertyWritable | BytecodeGenerator::PropertyEnumerable, m_position);

        break;

    }

    case DefineFieldNode::Type::PrivateName: {

        Variable var = generator.variable(*m_ident);

        ASSERT_WITH_MESSAGE(!var.local(), "Private Field names must be stored in captured variables");

        generator.emitExpressionInfo(position(), position(), position() + m_ident->length());

        RefPtr<RegisterID> scope = generator.emitResolveScope(nullptr, var);

        RefPtr<RegisterID> privateName = generator.newTemporary();

        generator.emitGetFromScope(privateName.get(), scope.get(), var, DoNotThrowIfNotFound);

        generator.emitDefinePrivateField(generator.thisRegister(), privateName.get(), value.get());

        break;

    }

    case DefineFieldNode::Type::ComputedName: {

        // FIXME: Improve performance of public class fields

        // https://bugs.webkit.org/show_bug.cgi?id=198330

@@void DefineFieldNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)

        ASSERT_WITH_MESSAGE(!var.local(), "Computed names must be stored in captured variables");

        generator.emitExpressionInfo(position(), position(), position() + 1);

4711 RefPtr<RegisterID> scope = generator.emitResolveScope(gene~~rator.newTemporary()~~, var);

4813 RefPtr<RegisterID> scope = generator.emitResolveScope(nullptr, var);

        RefPtr<RegisterID> privateName = generator.newTemporary();

        generator.emitGetFromScope(privateName.get(), scope.get(), var, ThrowIfNotFound);

        generator.emitProfileType(privateName.get(), var, m_position, m_position + m_ident->length());

@@RegisterID* ClassExprNode::emitBytecode(BytecodeGenerator& generator, RegisterID

    generator.emitCallDefineProperty(constructor.get(), prototypeNameRegister.get(), prototype.get(), nullptr, nullptr, 0, m_position);

    if (m_classElements) {

4905 m_classElements->emitDeclarePrivateFieldNames(generator, generator.scopeRegister());

4906

        Vector<JSTextPosition> instanceFieldLocations;

        generator.emitDefineClassElements(m_classElements, constructor.get(), prototype.get(), instanceFieldLocations);

        if (!instanceFieldLocations.isEmpty()) {

Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp

#include "PreciseJumpTargets.h"

#include "PutByIdFlags.h"

#include "PutByIdStatus.h"

74#include "PutByValFlags.h"

#include "RegExpPrototype.h"

#include "StackAlignment.h"

#include "StringConstructor.h"

@@private:

    bool m_hasAnyForceOSRExits { false };

};

template<typename Bytecode>

ECMAMode ecmaMode(Bytecode bytecode)

{

    return bytecode.m_ecmaMode;

}

template<>

ALWAYS_INLINE ECMAMode ecmaMode<OpPutByValDirect>(OpPutByValDirect bytecode)

{

    return bytecode.m_flags.ecmaMode();

}

BasicBlock* ByteCodeParser::allocateTargetableBlock(BytecodeIndex bytecodeIndex)

{

    ASSERT(bytecodeIndex);

@@void ByteCodeParser::handlePutByVal(Bytecode bytecode, BytecodeIndex osrExitInde

        }

        if (compiledAsPutById)

8239 handlePutById(base, identifier, identifierNumber, value, putByIdStatus, isDirect, osrExitIndex, bytecode~~.m_ecmaMode~~);

8252 handlePutById(base, identifier, identifierNumber, value, putByIdStatus, isDirect, osrExitIndex, ecmaMode(bytecode));

    }

    if (!compiledAsPutById) {

@@void ByteCodeParser::handlePutByVal(Bytecode bytecode, BytecodeIndex osrExitInde

        addVarArgChild(value);

        addVarArgChild(nullptr); // Leave room for property storage.

        addVarArgChild(nullptr); // Leave room for length.

8250 addToGraph(Node::VarArg, isDirect ? PutByValDirect : PutByVal, OpInfo(arrayMode.asWord()), OpInfo(bytecode~~.m_ecmaMode~~));

8263 addToGraph(Node::VarArg, isDirect ? PutByValDirect : PutByVal, OpInfo(arrayMode.asWord()), OpInfo(ecmaMode(bytecode)));

        m_exitOK = false; // PutByVal and PutByValDirect must be treated as if they clobber exit state, since FixupPhase may make them generic.

    }

}

Source/JavaScriptCore/dfg/DFGCapabilities.cpp

@@CapabilityLevel capabilityLevel(OpcodeID opcodeID, CodeBlock* codeBlock, const I

    case op_yield:

    case op_create_generator_frame_environment:

301 case op_get_private_name: // FIXME: op_get_private_name will need DFG/FTL support to ship class fields. (https://bugs.webkit.org/show_bug.cgi?id=212781)

    case llint_program_prologue:

    case llint_eval_prologue:

    case llint_module_program_prologue:

Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp

@@void SpeculativeJIT::cachedPutById(CodeOrigin codeOrigin, GPRReg baseGPR, JSValu

    JITPutByIdGenerator gen(

        m_jit.codeBlock(), codeOrigin, callSite, usedRegisters, identifier,

        JSValueRegs::payloadOnly(baseGPR), valueRegs,

14384 scratchGPR, ecmaMode, putKind);

14384 scratchGPR, ecmaMode, putKind, PrivateFieldAccessKind::None);

    gen.generateFastPath(m_jit);

Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp

@@private:

                    jit.codeBlock(), node->origin.semantic, callSiteIndex,

                    params.unavailableRegisters(), identifier, JSValueRegs(params[0].gpr()),

                    JSValueRegs(params[1].gpr()), GPRInfo::patchpointScratchRegister, ecmaMode,

4210 node->op() == PutByIdDirect ? Direct : NotDirect);

4210 node->op() == PutByIdDirect ? Direct : NotDirect, PrivateFieldAccessKind::None);

                generator->generateFastPath(jit);

                CCallHelpers::Label done = jit.label();

Source/JavaScriptCore/generator/DSL.rb

@@module DSL

#include "Opcode.h"

#include "PutByIdStatus.h"

#include "PutByIdFlags.h"

144#include "PutByValFlags.h"

#include "ToThisStatus.h"

namespace JSC {

Source/JavaScriptCore/jit/ICStats.h

@@namespace JSC {

    macro(OperationPutByIdNonStrictBuildList) \

    macro(OperationPutByIdDirectStrictBuildList) \

    macro(OperationPutByIdDirectNonStrictBuildList) \

70 macro(OperationPutByIdDefinePrivateFieldFieldStrictOptimize) \

71 macro(OperationPutByIdPutPrivateFieldFieldStrictOptimize) \

    macro(PutByIdAddAccessCase) \

    macro(PutByIdReplaceWithJump) \

    macro(PutByIdSelfPatch) \

Source/JavaScriptCore/jit/JIT.cpp

@@void JIT::privateCompileMainPass()

        DEFINE_SLOW_OP(push_with_scope)

        DEFINE_SLOW_OP(create_lexical_environment)

        DEFINE_SLOW_OP(get_by_val_with_this)

295 DEFINE_SLOW_OP(get_private_name)

        DEFINE_SLOW_OP(put_by_id_with_this)

        DEFINE_SLOW_OP(put_by_val_with_this)

        DEFINE_SLOW_OP(resolve_scope_for_hoisting_func_decl_in_eval)

Source/JavaScriptCore/jit/JIT.h

@@namespace JSC {

        template<typename Op>

        JumpList emitFloatTypedArrayPutByVal(Op, PatchableJump& badType, TypedArrayType);

404 // Identifier check helper for PutByVal.

        template<typename Op>

        ECMAMode ecmaMode(Op);

        // Determines the type of private field access for a bytecode.

        template<typename Op>

        PrivateFieldAccessKind privateFieldAccessKind(Op);

        // Identifier check helper for GetByVal and PutByVal.

        void emitByValIdentifierCheck(RegisterID cell, RegisterID scratch, CacheableIdentifier, JumpList& slowCases);

        template<typename Op>

Source/JavaScriptCore/jit/JITInlineCacheGenerator.cpp

@@void JITGetByIdWithThisGenerator::generateFastPath(MacroAssembler& jit)

JITPutByIdGenerator::JITPutByIdGenerator(

    CodeBlock* codeBlock, CodeOrigin codeOrigin, CallSiteIndex callSite, const RegisterSet& usedRegisters, CacheableIdentifier,

    JSValueRegs base, JSValueRegs value, GPRReg scratch, 

    ECMAMode ecmaMode, PutKind putKind)

    : JITByIdGenerator(

        codeBlock, codeOrigin, callSite, AccessType::Put, usedRegisters, base, value)

    , m_ecmaMode(ecmaMode)

    , m_putKind(putKind)

    ECMAMode ecmaMode, PutKind putKind, PrivateFieldAccessKind privateFieldAccessKind)

        : JITByIdGenerator(codeBlock, codeOrigin, callSite, AccessType::Put, usedRegisters, base, value)

        , m_ecmaMode(ecmaMode)

        , m_putKind(putKind)

        , m_privateFieldAccessKind(privateFieldAccessKind)

{

    m_stubInfo->usedRegisters.clear(scratch);

}

@@void JITPutByIdGenerator::generateFastPath(MacroAssembler& jit)

V_JITOperation_GSsiJJC JITPutByIdGenerator::slowPathFunction()

{

    if (m_privateFieldAccessKind != PrivateFieldAccessKind::None) {

        ASSERT(m_putKind == Direct);

        ASSERT(m_ecmaMode.isStrict());

        if (m_privateFieldAccessKind == PrivateFieldAccessKind::Create)

            return operationPutByIdDefinePrivateFieldStrictOptimize;

        return operationPutByIdPutPrivateFieldStrictOptimize;

    }

    if (m_ecmaMode.isStrict()) {

        if (m_putKind == Direct)

            return operationPutByIdDirectStrictOptimize;

Source/JavaScriptCore/jit/JITInlineCacheGenerator.h

#include "CodeOrigin.h"

#include "JITOperations.h"

#include "JSCJSValue.h"

33#include "PutByValFlags.h"

#include "PutKind.h"

#include "RegisterSet.h"

@@class JITPutByIdGenerator : public JITByIdGenerator {

public:

    JITPutByIdGenerator()

        : m_ecmaMode(ECMAMode::strict())

134 , m_privateFieldAccessKind(PrivateFieldAccessKind::None)

    { }

    JITPutByIdGenerator(

        CodeBlock*, CodeOrigin, CallSiteIndex, const RegisterSet& usedRegisters, CacheableIdentifier, JSValueRegs base,

137 JSValueRegs value, GPRReg scratch, ECMAMode, PutKind);

139 JSValueRegs value, GPRReg scratch, ECMAMode, PutKind, PrivateFieldAccessKind privateAccess);

    
    void generateFastPath(MacroAssembler&);

@@public:

private:

    ECMAMode m_ecmaMode;

    PutKind m_putKind;

148 PrivateFieldAccessKind m_privateFieldAccessKind;

};

class JITDelByValGenerator : public JITInlineCacheGenerator {

Source/JavaScriptCore/jit/JITInlines.h

@@ALWAYS_INLINE BinaryArithProfile JIT::copiedArithProfile(BinaryOp bytecode)

    return arithProfile;

}

template<typename Op>

ALWAYS_INLINE ECMAMode JIT::ecmaMode(Op op)

{

    return op.m_ecmaMode;

}

template<>

ALWAYS_INLINE ECMAMode JIT::ecmaMode<OpPutById>(OpPutById op)

{

    return op.m_flags.ecmaMode();

}

template<>

ALWAYS_INLINE ECMAMode JIT::ecmaMode<OpPutByValDirect>(OpPutByValDirect op)

{

    return op.m_flags.ecmaMode();

}

template<typename Op>

PrivateFieldAccessKind JIT::privateFieldAccessKind(Op)

{

    return PrivateFieldAccessKind::None;

}

template<>

ALWAYS_INLINE PrivateFieldAccessKind JIT::privateFieldAccessKind<OpPutByValDirect>(OpPutByValDirect op)

{

    return op.m_flags.privateFieldAccessKind();

}

} // namespace JSC

#endif // ENABLE(JIT)

Source/JavaScriptCore/jit/JITOperations.cpp

@@void JIT_OPERATION operationPutByIdDirectNonStrictOptimize(JSGlobalObject* globa

        repatchPutByID(globalObject, codeBlock, baseObject, structure, identifier, slot, *stubInfo, Direct);

}

} // extern "C"

using PutPrivateFieldCallback = std::function<void(VM&, CodeBlock*, Structure*, PutPropertySlot&, const Identifier&)>;

ALWAYS_INLINE static void putPrivateField(VM& vm, JSGlobalObject* globalObject, CallFrame* callFrame, JSValue baseValue, CacheableIdentifier identifier, JSValue value, const PutPrivateFieldCallback& callback = PutPrivateFieldCallback())

{

    auto scope = DECLARE_THROW_SCOPE(vm);

    Identifier ident = Identifier::fromUid(vm, identifier.uid());

    ASSERT(ident.isPrivateName());

    JSObject* baseObject = asObject(baseValue);

    CodeBlock* codeBlock = callFrame->codeBlock();

    Structure* oldStructure = baseObject->structure(vm);

    PutPropertySlot putSlot(baseObject, true, codeBlock->putByIdContext());

    baseObject->putPrivateField(globalObject, ident, value, putSlot);

    RETURN_IF_EXCEPTION(scope, void());

    if (callback)

        callback(vm, codeBlock, oldStructure, putSlot, ident);

}

ALWAYS_INLINE static void definePrivateField(VM& vm, JSGlobalObject* globalObject, CallFrame* callFrame, JSValue baseValue, CacheableIdentifier identifier, JSValue value, const PutPrivateFieldCallback& callback = PutPrivateFieldCallback())

{

    auto scope = DECLARE_THROW_SCOPE(vm);

    Identifier ident = Identifier::fromUid(vm, identifier.uid());

    ASSERT(ident.isPrivateName());

    JSObject* baseObject = asObject(baseValue);

    CodeBlock* codeBlock = callFrame->codeBlock();

    Structure* oldStructure = baseObject->structure(vm);

    PutPropertySlot putSlot(baseObject, true, codeBlock->putByIdContext());

    baseObject->definePrivateField(globalObject, ident, value, putSlot);

    RETURN_IF_EXCEPTION(scope, void());

    if (callback)

        callback(vm, codeBlock, oldStructure, putSlot, ident);

}

extern "C" {

void JIT_OPERATION operationPutByIdDefinePrivateFieldStrict(JSGlobalObject* globalObject, StructureStubInfo*, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t rawCacheableIdentifier)

{

    VM& vm = globalObject->vm();

    CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

    CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

    JSValue value = JSValue::decode(encodedValue);

    JSValue baseValue = JSValue::decode(encodedBase);

    definePrivateField(vm, globalObject, callFrame, baseValue, identifier, value);

}

void JIT_OPERATION operationPutByIdDefinePrivateFieldStrictOptimize(JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t rawCacheableIdentifier)

{

    SuperSamplerScope superSamplerScope(false);

    VM& vm = globalObject->vm();

    CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

    JITOperationPrologueCallFrameTracer tracer(vm, callFrame);

    CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

    AccessType accessType = static_cast<AccessType>(stubInfo->accessType);

    JSValue value = JSValue::decode(encodedValue);

    JSObject* baseObject = asObject(JSValue::decode(encodedBase));

    definePrivateField(vm, globalObject, callFrame, baseObject, identifier, value, [=](VM& vm, CodeBlock* codeBlock, Structure* oldStructure, PutPropertySlot& putSlot, const Identifier& ident) {

        LOG_IC((ICEvent::OperationPutByIdDefinePrivateFieldFieldStrictOptimize, baseObject->classInfo(vm), ident, putSlot.base() == baseObject));

        ASSERT_UNUSED(accessType, accessType == static_cast<AccessType>(stubInfo->accessType));

        if (stubInfo->considerCachingBy(vm, codeBlock, oldStructure, identifier))

            repatchPutByID(globalObject, codeBlock, baseObject, oldStructure, identifier, putSlot, *stubInfo, DirectPrivateFieldCreate);

    });

}

void JIT_OPERATION operationPutByIdPutPrivateFieldStrict(JSGlobalObject* globalObject, StructureStubInfo*, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t rawCacheableIdentifier)

{

    VM& vm = globalObject->vm();

    CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

    CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

    JSValue value = JSValue::decode(encodedValue);

    JSValue baseValue = JSValue::decode(encodedBase);

    putPrivateField(vm, globalObject, callFrame, baseValue, identifier, value);

}

void JIT_OPERATION operationPutByIdPutPrivateFieldStrictOptimize(JSGlobalObject* globalObject, StructureStubInfo* stubInfo, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t rawCacheableIdentifier)

{

    SuperSamplerScope superSamplerScope(false);

    VM& vm = globalObject->vm();

    CallFrame* callFrame = DECLARE_CALL_FRAME(vm);

    NativeCallFrameTracer tracer(vm, callFrame);

    CacheableIdentifier identifier = CacheableIdentifier::createFromRawBits(rawCacheableIdentifier);

    AccessType accessType = static_cast<AccessType>(stubInfo->accessType);

    JSValue value = JSValue::decode(encodedValue);

    JSObject* baseObject = asObject(JSValue::decode(encodedBase));

    putPrivateField(vm, globalObject, callFrame, baseObject, identifier, value, [&](VM& vm, CodeBlock* codeBlock, Structure* oldStructure, PutPropertySlot& putSlot, const Identifier& ident) {

        LOG_IC((ICEvent::OperationPutByIdPutPrivateFieldFieldStrictOptimize, baseObject->classInfo(vm), ident, putSlot.base() == baseObject));

        ASSERT_UNUSED(accessType, accessType == static_cast<AccessType>(stubInfo->accessType));

        if (stubInfo->considerCachingBy(vm, codeBlock, oldStructure, identifier))

            repatchPutByID(globalObject, codeBlock, baseObject, oldStructure, identifier, putSlot, *stubInfo, DirectPrivateFieldPut);

    });

}

static void putByVal(JSGlobalObject* globalObject, JSValue baseValue, JSValue subscript, JSValue value, ByValInfo* byValInfo, ECMAMode ecmaMode)

{

    VM& vm = globalObject->vm();

Source/JavaScriptCore/jit/JITOperations.h

@@void JIT_OPERATION operationPutByIdStrictOptimize(JSGlobalObject*, StructureStub

void JIT_OPERATION operationPutByIdNonStrictOptimize(JSGlobalObject*, StructureStubInfo*, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t) WTF_INTERNAL;

void JIT_OPERATION operationPutByIdDirectStrictOptimize(JSGlobalObject*, StructureStubInfo*, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t) WTF_INTERNAL;

void JIT_OPERATION operationPutByIdDirectNonStrictOptimize(JSGlobalObject*, StructureStubInfo*, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t) WTF_INTERNAL;

void JIT_OPERATION operationPutByIdDefinePrivateFieldStrict(JSGlobalObject*, StructureStubInfo*, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t) WTF_INTERNAL;

void JIT_OPERATION operationPutByIdDefinePrivateFieldStrictOptimize(JSGlobalObject*, StructureStubInfo*, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t) WTF_INTERNAL;

void JIT_OPERATION operationPutByIdPutPrivateFieldStrict(JSGlobalObject*, StructureStubInfo*, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t) WTF_INTERNAL;

void JIT_OPERATION operationPutByIdPutPrivateFieldStrictOptimize(JSGlobalObject*, StructureStubInfo*, EncodedJSValue encodedValue, EncodedJSValue encodedBase, uintptr_t) WTF_INTERNAL;

void JIT_OPERATION operationPutByValOptimize(JSGlobalObject*, EncodedJSValue, EncodedJSValue, EncodedJSValue, ByValInfo*, ECMAMode) WTF_INTERNAL;

void JIT_OPERATION operationDirectPutByValOptimize(JSGlobalObject*, EncodedJSValue, EncodedJSValue, EncodedJSValue, ByValInfo*, ECMAMode) WTF_INTERNAL;

Source/JavaScriptCore/jit/JITPropertyAccess.cpp

@@JITPutByIdGenerator JIT::emitPutByValWithCachedId(Op bytecode, PutKind putKind,

    JITPutByIdGenerator gen(

        m_codeBlock, CodeOrigin(m_bytecodeIndex), CallSiteIndex(m_bytecodeIndex), RegisterSet::stubUnavailableRegisters(), propertyName,

278 JSValueRegs(regT0), JSValueRegs(regT1), regT2, bytecode~~.m_ecmaMode~~, putKind);

278 JSValueRegs(regT0), JSValueRegs(regT1), regT2, ecmaMode(bytecode), putKind, privateFieldAccessKind(bytecode));

    gen.generateFastPath(*this);

    // IC can write new Structure without write-barrier if a base is cell.

    // FIXME: Use UnconditionalWriteBarrier in Baseline effectively to reduce code size.

@@void JIT::emitSlow_op_put_by_val(const Instruction* currentInstruction, Vector<S

        base = bytecode.m_base;

        property = bytecode.m_property;

        value = bytecode.m_value;

308 ecmaMode = bytecode~~.m_ecmaMode~~;

308 ecmaMode = JIT::ecmaMode(bytecode);

    };

    if (isDirect)

@@void JIT::emit_op_put_by_id(const Instruction* currentInstruction)

    JITPutByIdGenerator gen(

        m_codeBlock, CodeOrigin(m_bytecodeIndex), CallSiteIndex(m_bytecodeIndex), RegisterSet::stubUnavailableRegisters(),

        CacheableIdentifier::createFromIdentifierOwnedByCodeBlock(m_codeBlock, *ident),

661 JSValueRegs(regT0), JSValueRegs(regT1), regT2, ~~bytecode.m_flags.~~ecmaMode(),

662 direct ? Direct : NotDirect);

661 JSValueRegs(regT0), JSValueRegs(regT1), regT2, ecmaMode(bytecode),

662 direct ? Direct : NotDirect, privateFieldAccessKind(bytecode));

    
    gen.generateFastPath(*this);

    addSlowCase(gen.slowPathJump());

@@JITPutByIdGenerator JIT::emitPutByValWithCachedId(Op bytecode, PutKind putKind,

    JITPutByIdGenerator gen(

        m_codeBlock, CodeOrigin(m_bytecodeIndex), CallSiteIndex(m_bytecodeIndex), RegisterSet::stubUnavailableRegisters(), propertyName,

1320 JSValueRegs::payloadOnly(regT0), JSValueRegs(regT3, regT2), regT1, bytecode~~.m_ecmaMode~~, putKind);

1320 JSValueRegs::payloadOnly(regT0), JSValueRegs(regT3, regT2), regT1, ecmaMode(bytecode), putKind, privateFieldAccessKind(bytecode));

    gen.generateFastPath(*this);

    doneCases.append(jump());

Source/JavaScriptCore/jit/JITPropertyAccess32_64.cpp

@@void JIT::emitSlow_op_put_by_val(const Instruction* currentInstruction, Vector<S

        base = bytecode.m_base;

        property = bytecode.m_property;

        value = bytecode.m_value;

458 ecmaMode = bytecode~~.m_ecmaMode~~;

458 ecmaMode = JIT::ecmaMode(bytecode);

    };

    if (isDirect)

@@void JIT::emit_op_put_by_id(const Instruction* currentInstruction)

        m_codeBlock, CodeOrigin(m_bytecodeIndex), CallSiteIndex(m_bytecodeIndex), RegisterSet::stubUnavailableRegisters(),

        CacheableIdentifier::createFromIdentifierOwnedByCodeBlock(m_codeBlock, *ident),

        JSValueRegs::payloadOnly(regT0), JSValueRegs(regT3, regT2),

667 regT1, bytecode.m_flags.ecmaMode(), direct ? Direct : NotDirect);

667 regT1, bytecode.m_flags.ecmaMode(), direct ? Direct : NotDirect, PrivateFieldAccessKind::None);

    
    gen.generateFastPath(*this);

    addSlowCase(gen.slowPathJump());

Source/JavaScriptCore/jit/Repatch.cpp

@@static auto appropriateGenericPutByIdFunction(const PutPropertySlot &slot, PutKi

    if (slot.isStrictMode()) {

        if (putKind == Direct)

            return operationPutByIdDirectStrict;

        if (putKind == DirectPrivateFieldCreate)

            return operationPutByIdDefinePrivateFieldStrict;

        if (putKind == DirectPrivateFieldPut)

            return operationPutByIdPutPrivateFieldStrict;

        return operationPutByIdStrict;

    }

    if (putKind == Direct)

@@static auto appropriateOptimizingPutByIdFunction(const PutPropertySlot &slot, Pu

    if (slot.isStrictMode()) {

        if (putKind == Direct)

            return operationPutByIdDirectStrictOptimize;

        if (putKind == DirectPrivateFieldCreate)

            return operationPutByIdDefinePrivateFieldStrictOptimize;

        if (putKind == DirectPrivateFieldPut)

            return operationPutByIdPutPrivateFieldStrictOptimize;

        return operationPutByIdStrictOptimize;

    }

    if (putKind == Direct)

@@static InlineCacheAction tryCachePutByID(JSGlobalObject* globalObject, CodeBlock

                std::unique_ptr<PolyProtoAccessChain> prototypeAccessChain;

                ObjectPropertyConditionSet conditionSet;

                if (putKind == NotDirect) {

636 ASSERT(putKind != DirectPrivateFieldPut && putKind != DirectPrivateFieldCreate);

                    auto cacheStatus = prepareChainForCaching(globalObject, baseCell, nullptr);

                    if (!cacheStatus)

                        return GiveUpOnCache;

@@static InlineCacheAction tryCachePutByID(JSGlobalObject* globalObject, CodeBlock

                    }

                }

                if (putKind == DirectPrivateFieldCreate) {

                    ASSERT(ident.isPrivateName());

                    conditionSet = generateConditionsForPropertyMiss(vm, codeBlock, globalObject, newStructure, ident.impl());

                    if (!conditionSet.isValid())

                        return GiveUpOnCache;

                }

                newCase = AccessCase::createTransition(vm, codeBlock, propertyName, offset, oldStructure, newStructure, conditionSet, WTFMove(prototypeAccessChain));

            }

        } else if (slot.isCacheableCustom() || slot.isCacheableSetter()) {

Source/JavaScriptCore/llint/LLIntOffsetsExtractor.cpp

#include "NativeExecutable.h"

#include "PutByIdFlags.h"

#include "ProtoCallFrame.h"

63#include "PutByValFlags.h"

#include "ShadowChicken.h"

#include "Structure.h"

#include "StructureChain.h"

Source/JavaScriptCore/llint/LLIntSlowPaths.cpp

@@LLINT_SLOW_PATH_DECL(slow_path_get_by_val)

    LLINT_RETURN_PROFILED(getByVal(vm, globalObject, codeBlock, baseValue, subscript, bytecode));

}

LLINT_SLOW_PATH_DECL(slow_path_get_private_name)

{

    LLINT_BEGIN();

    auto bytecode = pc->as<OpGetPrivateName>();

    JSValue baseValue = getOperand(callFrame, bytecode.m_base);

    JSValue subscript = getOperand(callFrame, bytecode.m_property);

    ASSERT(subscript.isSymbol());

    baseValue.requireObjectCoercible(globalObject);

    LLINT_CHECK_EXCEPTION();

    auto property = subscript.toPropertyKey(globalObject);

    LLINT_CHECK_EXCEPTION();

    ASSERT(property.isPrivateName());

    PropertySlot slot(baseValue, PropertySlot::InternalMethodType::VMInquiry);

    asObject(baseValue)->getPrivateField(globalObject, property, slot);

    LLINT_CHECK_EXCEPTION();

    if (!LLINT_ALWAYS_ACCESS_SLOW && slot.isCacheable() && !slot.isUnset()) {

        auto& metadata = bytecode.metadata(codeBlock);

        {

            StructureID oldStructureID = metadata.m_structureID;

            if (oldStructureID) {

                Structure* a = vm.heap.structureIDTable().get(oldStructureID);

                Structure* b = baseValue.asCell()->structure(vm);

                if (Structure::shouldConvertToPolyProto(a, b)) {

                    ASSERT(a->rareData()->sharedPolyProtoWatchpoint().get() == b->rareData()->sharedPolyProtoWatchpoint().get());

                    a->rareData()->sharedPolyProtoWatchpoint()->invalidate(vm, StringFireDetail("Detected poly proto opportunity."));

                }

            }

        }

        JSCell* baseCell = baseValue.asCell();

        Structure* structure = baseCell->structure(vm);

        if (slot.isValue()) {

            // Start out by clearing out the old cache.

            metadata.m_structureID = 0;

            metadata.m_offset = 0;

            if (!structure->isUncacheableDictionary()) {

                {

                    ConcurrentJSLocker locker(codeBlock->m_lock);

                    metadata.m_structureID = structure->id();

                    metadata.m_offset = slot.cachedOffset();

                    //  Update the cached private symbol

                    metadata.m_property.set(vm, codeBlock, subscript.asCell());

                }

                vm.heap.writeBarrier(codeBlock);

            }

        }

    }

    LLINT_RETURN_PROFILED(slot.getValue(globalObject, property));

}

LLINT_SLOW_PATH_DECL(slow_path_put_by_val)

{

    LLINT_BEGIN();

@@LLINT_SLOW_PATH_DECL(slow_path_put_by_val_direct)

    JSValue value = getOperand(callFrame, bytecode.m_value);

    RELEASE_ASSERT(baseValue.isObject());

    JSObject* baseObject = asObject(baseValue);

1114 bool isStrictMode = bytecode.m_ecmaMode.isStrict();

1172 bool isStrictMode = bytecode.m_flags.ecmaMode().isStrict();

1173 bool isPrivateFieldAccess = bytecode.m_flags.isPrivateFieldAccess();

11151174 if (Optional<uint32_t> index = subscript.tryGetAsUint32Index()) {

1175 ASSERT(!isPrivateFieldAccess);

        baseObject->putDirectIndex(globalObject, *index, value, 0, isStrictMode ? PutDirectIndexShouldThrow : PutDirectIndexShouldNotThrow);

        LLINT_END();

    }

    if (subscript.isDouble()) {

        ASSERT(!isPrivateFieldAccess);

        double subscriptAsDouble = subscript.asDouble();

        uint32_t subscriptAsUInt32 = static_cast<uint32_t>(subscriptAsDouble);

        if (subscriptAsDouble == subscriptAsUInt32 && isIndex(subscriptAsUInt32)) {

            baseObject->putDirectIndex(globalObject, subscriptAsUInt32, value, 0, isStrictMode ? PutDirectIndexShouldThrow : PutDirectIndexShouldNotThrow);

            LLINT_END();

        }

    }

    // Don't put to an object if toString threw an exception.

    auto property = subscript.toPropertyKey(globalObject);

    if (UNLIKELY(throwScope.exception()))

        LLINT_END();

1195 ASSERT(property.isPrivateName() == isPrivateFieldAccess);

    if (Optional<uint32_t> index = parseIndex(property))

        baseObject->putDirectIndex(globalObject, index.value(), value, 0, isStrictMode ? PutDirectIndexShouldThrow : PutDirectIndexShouldNotThrow);

    else {

        if (isPrivateFieldAccess) {

            PutPropertySlot slot(baseObject, isStrictMode);

            if (bytecode.m_flags.isPrivateFieldAdd())

                baseObject->definePrivateField(globalObject, property, value, slot);

            else

                baseObject->putPrivateField(globalObject, property, value, slot);

            LLINT_END();    

        }

        PutPropertySlot slot(baseObject, isStrictMode);

        CommonSlowPaths::putDirectWithReify(vm, globalObject, baseObject, property, value, slot);

    }

Source/JavaScriptCore/llint/LLIntSlowPaths.h

@@LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_get_by_id);

LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_put_by_id);

LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_del_by_id);

LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_get_by_val);

75LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_get_private_name);

LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_get_argument_by_val);

LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_put_by_val);

LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_put_by_val_direct);

Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm

@@llintOpWithMetadata(op_get_by_val, OpGetByVal, macro (size, get, dispatch, metad

end)

llintOpWithMetadata(op_get_private_name, OpGetPrivateName, macro (size, get, dispatch, metadata, return)

    metadata(t5, t0)

    # Slow path if the private field is stale

    get(m_property, t0)

    loadp OpGetPrivateName::Metadata::m_property[t5], t1

    bpneq t1, t0, .opGetPrivateNameSlow

    get(m_base, t0)

    loadi OpGetPrivateName::Metadata::m_structureID[t5], t1

    loadConstantOrVariablePayload(size, t0, CellTag, t3, .opGetPrivateNameSlow)

    loadi OpGetPrivateName::Metadata::m_offset[t5], t2

    bineq JSCell::m_structureID[t3], t1, .opGetPrivateNameSlow

    loadPropertyAtVariableOffset(t2, t3, t0, t1)

    valueProfile(OpGetPrivateName, m_profile, t5, t0, t1)

    return(t0, t1)

.opGetPrivateNameSlow:

    callSlowPath(_llint_slow_path_get_private_name)

    dispatch()

end)

macro putByValOp(opcodeName, opcodeStruct, osrExitPoint)

    llintOpWithMetadata(op_%opcodeName%, opcodeStruct, macro (size, get, dispatch, metadata, return)

Source/JavaScriptCore/llint/LowLevelInterpreter64.asm

@@llintOpWithMetadata(op_get_by_val, OpGetByVal, macro (size, get, dispatch, metad

end)

llintOpWithMetadata(op_get_private_name, OpGetPrivateName, macro (size, get, dispatch, metadata, return)

    metadata(t2, t0)

    # Slow path if the private field is stale

    get(m_property, t0)

    loadp OpGetPrivateName::Metadata::m_property[t2], t1

    bpneq t1, t0, .opGetPrivateNameSlow

    get(m_base, t0)

    loadConstantOrVariableCell(size, t0, t3, .opGetPrivateNameSlow)

    loadi JSCell::m_structureID[t3], t1

    loadi OpGetPrivateName::Metadata::m_structureID[t2], t0

    bineq t0, t1, .opGetPrivateNameSlow

    loadi OpGetPrivateName::Metadata::m_offset[t2], t1

    loadPropertyAtVariableOffset(t1, t3, t0)

    valueProfile(OpGetPrivateName, m_profile, t2, t0)

    return(t0)

.opGetPrivateNameSlow:

    callSlowPath(_llint_slow_path_get_private_name)

    dispatch()

end)

macro putByValOp(opcodeName, opcodeStruct, osrExitPoint)

    llintOpWithMetadata(op_%opcodeName%, opcodeStruct, macro (size, get, dispatch, metadata, return)

Source/JavaScriptCore/parser/ASTBuilder.h

@@public:

        return node;

    }

273 ExpressionNode* createDotAccess(const JSTokenLocation& location, ExpressionNode* base, const Identifier* property, const JSTextPosition& start, const JSTextPosition& divot, const JSTextPosition& end)

273 ExpressionNode* createDotAccess(const JSTokenLocation& location, ExpressionNode* base, const Identifier* property, DotType type, const JSTextPosition& start, const JSTextPosition& divot, const JSTextPosition& end)

    {

        if (base->isSuperNode())

            usesSuperProperty();

278 DotAccessorNode* node = new (m_parserArena) DotAccessorNode(location, base, *property);

278 DotAccessorNode* node = new (m_parserArena) DotAccessorNode(location, base, *property, type);

        setExceptionLocation(node, start, divot, end);

        return node;

    }

@@public:

        return node->isAssignmentLocation();

    }

    bool isPrivateLocation(const Expression& node)

    {

        return node->isPrivateLocation();

    }

    bool isObjectLiteral(const Expression& node)

    {

        return node->isObjectLiteral();

@@ExpressionNode* ASTBuilder::makeFunctionCallNode(const JSTokenLocation& location

    DotAccessorNode* dot = static_cast<DotAccessorNode*>(func);

    FunctionCallDotNode* node = nullptr;

    if (!previousBaseWasSuper && (dot->identifier() == m_vm.propertyNames->builtinNames().callPublicName() || dot->identifier() == m_vm.propertyNames->builtinNames().callPrivateName()))

1441 node = new (m_parserArena) CallFunctionCallDotNode(location, dot->base(), dot->identifier(), args, divot, divotStart, divotEnd, callOrApplyChildDepth);

1446 node = new (m_parserArena) CallFunctionCallDotNode(location, dot->base(), dot->identifier(), dot->type(), args, divot, divotStart, divotEnd, callOrApplyChildDepth);

    else if (!previousBaseWasSuper && (dot->identifier() == m_vm.propertyNames->builtinNames().applyPublicName() || dot->identifier() == m_vm.propertyNames->builtinNames().applyPrivateName())) {

        // FIXME: This check is only needed because we haven't taught the bytecode generator to inline

        // Reflect.apply yet. See https://bugs.webkit.org/show_bug.cgi?id=190668.

        if (!dot->base()->isResolveNode() || static_cast<ResolveNode*>(dot->base())->identifier() != m_vm.propertyNames->Reflect)

1446 node = new (m_parserArena) ApplyFunctionCallDotNode(location, dot->base(), dot->identifier(), args, divot, divotStart, divotEnd, callOrApplyChildDepth);

1451 node = new (m_parserArena) ApplyFunctionCallDotNode(location, dot->base(), dot->identifier(), dot->type(), args, divot, divotStart, divotEnd, callOrApplyChildDepth);

    } else if (!previousBaseWasSuper 

        && dot->identifier() == m_vm.propertyNames->hasOwnProperty

        && args->m_listNode

@@ExpressionNode* ASTBuilder::makeFunctionCallNode(const JSTokenLocation& location

        // <resolveNode|thisNode>.hasOwnProperty(<resolveNode>)

        // i.e:

        // o.hasOwnProperty(p)

1458 node = new (m_parserArena) HasOwnPropertyFunctionCallDotNode(location, dot->base(), dot->identifier(), args, divot, divotStart, divotEnd);

1463 node = new (m_parserArena) HasOwnPropertyFunctionCallDotNode(location, dot->base(), dot->identifier(), dot->type(), args, divot, divotStart, divotEnd);

14591464 }

14601465 if (!node)

1461 node = new (m_parserArena) FunctionCallDotNode(location, dot->base(), dot->identifier(), args, divot, divotStart, divotEnd);

1466 node = new (m_parserArena) FunctionCallDotNode(location, dot->base(), dot->identifier(), dot->type(), args, divot, divotStart, divotEnd);

    node->setSubexpressionInfo(dot->divot(), dot->divotEnd().offset);

    return node;

}

@@ExpressionNode* ASTBuilder::makeAssignNode(const JSTokenLocation& location, Expr

    DotAccessorNode* dot = static_cast<DotAccessorNode*>(loc);

    if (op == Operator::Equal)

1602 return new (m_parserArena) AssignDotNode(location, dot->base(), dot->identifier(), expr, exprHasAssignments, dot->divot(), start, end);

1607 return new (m_parserArena) AssignDotNode(location, dot->base(), dot->identifier(), dot->type(), expr, exprHasAssignments, dot->divot(), start, end);

    if (op == Operator::CoalesceEq || op == Operator::OrEq || op == Operator::AndEq) {

        auto* node = new (m_parserArena) ShortCircuitReadModifyDotNode(location, dot->base(), dot->identifier(), op, expr, exprHasAssignments, divot, start, end);

@@ExpressionNode* ASTBuilder::makeAssignNode(const JSTokenLocation& location, Expr

        return node;

    }

1610 ReadModifyDotNode* node = new (m_parserArena) ReadModifyDotNode(location, dot->base(), dot->identifier(), op, expr, exprHasAssignments, divot, start, end);

1615 ReadModifyDotNode* node = new (m_parserArena) ReadModifyDotNode(location, dot->base(), dot->identifier(), dot->type(), op, expr, exprHasAssignments, divot, start, end);

    node->setSubexpressionInfo(dot->divot(), dot->divotEnd().offset);

    return node;

}

Source/JavaScriptCore/parser/Lexer.cpp

@@template <bool shouldCreateIdentifier> ALWAYS_INLINE JSTokenType Lexer<LChar>::p

            return keyword == RESERVED_IF_STRICT && !strictMode ? IDENT : keyword;

        }

    }

948

949 bool isPrivateName = m_current == '@' && m_parsingBuiltinFunction;

    bool isPrivateName = m_current == '#';

    bool isBuiltinName = m_current == '@' && m_parsingBuiltinFunction;

950951 bool isWellKnownSymbol = false;

951 if (isPr~~iva~~teName) {

952 if (isBuiltinName) {

        ASSERT(m_parsingBuiltinFunction);

        shift();

        if (m_current == '@') {

@@template <bool shouldCreateIdentifier> ALWAYS_INLINE JSTokenType Lexer<LChar>::p

            shift();

        }

    }

959

960

960961 const LChar* identifierStart = currentSourcePtr();

    if (isPrivateName)

        shift();

    ASSERT(isIdentStart(m_current) || m_current == '\\');

    while (isIdentPart(m_current))

        shift();

@@template <bool shouldCreateIdentifier> ALWAYS_INLINE JSTokenType Lexer<LChar>::p

    
    if (shouldCreateIdentifier || m_parsingBuiltinFunction) {

        int identifierLength = currentSourcePtr() - identifierStart;

972 if (m_parsingBuiltinFunction && isPrivateName) {

977 ident = makeIdentifier(identifierStart, identifierLength);

978 if (m_parsingBuiltinFunction && isBuiltinName) {

            if (isWellKnownSymbol)

                ident = &m_arena->makeIdentifier(m_vm, m_vm.propertyNames->builtinNames().lookUpWellKnownSymbol(identifierStart, identifierLength));

            else

@@template <bool shouldCreateIdentifier> ALWAYS_INLINE JSTokenType Lexer<LChar>::p

    } else

        tokenData->ident = nullptr;

994 if (UNLIKELY((remaining < maxTokenLength) && !lexerFlags.contains(LexerFlags::IgnoreReservedWords)) && !isPrivateName) {

1000 auto identType = isPrivateName ? PRIVATENAME : IDENT;

1001 if (UNLIKELY((remaining < maxTokenLength) && !lexerFlags.contains(LexerFlags::IgnoreReservedWords)) && !isBuiltinName) {

        ASSERT(shouldCreateIdentifier);

        if (remaining < maxTokenLength) {

            const HashTableValue* entry = JSC::mainTable.entry(*ident);

            ASSERT((remaining < maxTokenLength) || !entry);

            if (!entry)

1000 return ~~IDEN~~T;

1007 return identType;

10011008 JSTokenType token = static_cast<JSTokenType>(entry->lexerValue());

1002 return (token != RESERVED_IF_STRICT) || strictMode ? token : ~~IDEN~~T;

1009 return (token != RESERVED_IF_STRICT) || strictMode ? token : identType;

10031010 }

1004 return ~~IDEN~~T;

1011 return identType;

10051012 }

10061013

1007 return ~~IDEN~~T;

1014 return identType;

}

template <>

@@template <bool shouldCreateIdentifier> ALWAYS_INLINE JSTokenType Lexer<UChar>::p

        }

    }

1031 bool isPrivateName = m_current == '#';

10241032 const UChar* identifierStart = currentSourcePtr();

    if (isPrivateName)

        shift();

    UChar orAllChars = 0;

    ASSERT(isSingleCharacterIdentStart(m_current) || U16_IS_SURROGATE(m_current) || m_current == '\\');

    while (isSingleCharacterIdentPart(m_current)) {

@@template <bool shouldCreateIdentifier> ALWAYS_INLINE JSTokenType Lexer<UChar>::p

    } else

        tokenData->ident = nullptr;

    if (isPrivateName)

        return PRIVATENAME;

    if (UNLIKELY((remaining < maxTokenLength) && !lexerFlags.contains(LexerFlags::IgnoreReservedWords))) {

        ASSERT(shouldCreateIdentifier);

        if (remaining < maxTokenLength) {

@@JSTokenType Lexer<CharacterType>::parseIdentifierSlowCase(JSTokenData* tokenData

    ASSERT(m_buffer16.isEmpty());

    ASSERT(!tokenData->escaped);

    auto identCharsStart = identifierStart;

    bool isPrivateName = *identifierStart == '#';

    if (isPrivateName)

        ++identCharsStart;

    JSTokenType identType = isPrivateName ? PRIVATENAME : IDENT;

    ASSERT(!isPrivateName || identifierStart != currentSourcePtr());

    auto fillBuffer = [&] (bool isStart = false) {

        // \uXXXX unicode characters or Surrogate pairs.

        if (identifierStart != currentSourcePtr())

@@JSTokenType Lexer<CharacterType>::parseIdentifierSlowCase(JSTokenData* tokenData

            if (shouldCreateIdentifier)

                recordUnicodeCodePoint(character.value());

            identifierStart = currentSourcePtr();

1091 return ~~IDEN~~T;

1114 return identType;

        }

        ASSERT(U16_IS_SURROGATE(m_current));

@@JSTokenType Lexer<CharacterType>::parseIdentifierSlowCase(JSTokenData* tokenData

        shift();

        shift();

        identifierStart = currentSourcePtr();

1107 return ~~IDEN~~T;

1130 return identType;

11081131 };

11091132

1110 JSTokenType type = fillBuffer(ident~~ifie~~rStart == currentSourcePtr());

1133 JSTokenType type = fillBuffer(identCharsStart == currentSourcePtr());

    if (UNLIKELY(type & ErrorTokenFlag))

        return type;

@@JSTokenType Lexer<CharacterType>::parseIdentifierSlowCase(JSTokenData* tokenData

        ASSERT(shouldCreateIdentifier);

        const HashTableValue* entry = JSC::mainTable.entry(*ident);

        if (!entry)

1143 return ~~IDEN~~T;

1166 return identType;

        JSTokenType token = static_cast<JSTokenType>(entry->lexerValue());

        if ((token != RESERVED_IF_STRICT) || strictMode)

            return UNEXPECTED_ESCAPE_ERRORTOK;

    }

1149 return ~~IDEN~~T;

1172 return identType;

}

static ALWAYS_INLINE bool characterRequiresParseStringSlowCase(LChar character)

@@start:

        m_hasLineTerminatorBeforeToken = true;

        m_lineStart = m_code;

        goto start;

2476 case CharacterHash:

2499 case CharacterHash: {

24772500 // Hashbang is only permitted at the start of the source text.

2478 if (peek(1) == '!' && !currentOffset()) {

2501 auto next = peek(1);

2502 if (next == '!' && !currentOffset()) {

            shift();

            shift();

            goto inSingleLineComment;

        }

        // Otherwise, it could be a valid PrivateName.

        if (Options::usePrivateClassFields() && (isSingleCharacterIdentStart(next) || next == '\\')) {

            lexerFlags.remove(LexerFlags::DontBuildKeywords);

            goto parseIdent;

        }

24832512 goto invalidCharacter;

2513 }

    case CharacterPrivateIdentifierStart:

        if (m_parsingBuiltinFunction)

            goto parseIdent;

Source/JavaScriptCore/parser/NodeConstructors.h

@@namespace JSC {

    {

    }

330 inline Dot~~Accessor~~Node::Dot~~Accessor~~Node(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident)

330 inline BaseDotNode::BaseDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, DotType type)

        : ExpressionNode(location)

        , m_base(base)

        , m_ident(ident)

        , m_type(type)

    {

    }

    inline DotAccessorNode::DotAccessorNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, DotType type)

        : BaseDotNode(location, base, ident, type)

    {

    }

@@namespace JSC {

    {

    }

421 inline FunctionCallDotNode::FunctionCallDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)

422 : ~~Expressi~~onNode(location)

427 inline FunctionCallDotNode::FunctionCallDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, DotType type, ArgumentsNode* args, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)

428 : BaseDotNode(location, base, ident, type)

423429 , ThrowableSubExpressionData(divot, divotStart, divotEnd)

424 , m_base(base)

425 , m_ident(ident)

        , m_args(args)

    {

    }

@@namespace JSC {

    {

    }

440 inline CallFunctionCallDotNode::CallFunctionCallDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd, size_t distanceToInnermostCallOrApply)

441 : FunctionCallDotNode(location, base, ident, args, divot, divotStart, divotEnd)

444 inline CallFunctionCallDotNode::CallFunctionCallDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, DotType type, ArgumentsNode* args, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd, size_t distanceToInnermostCallOrApply)

445 : FunctionCallDotNode(location, base, ident, type, args, divot, divotStart, divotEnd)

        , m_distanceToInnermostCallOrApply(distanceToInnermostCallOrApply)

    {

    }

446 inline ApplyFunctionCallDotNode::ApplyFunctionCallDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd, size_t distanceToInnermostCallOrApply)

447 : FunctionCallDotNode(location, base, ident, args, divot, divotStart, divotEnd)

450 inline ApplyFunctionCallDotNode::ApplyFunctionCallDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, DotType type, ArgumentsNode* args, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd, size_t distanceToInnermostCallOrApply)

451 : FunctionCallDotNode(location, base, ident, type, args, divot, divotStart, divotEnd)

        , m_distanceToInnermostCallOrApply(distanceToInnermostCallOrApply)

    {

    }

452 inline HasOwnPropertyFunctionCallDotNode::HasOwnPropertyFunctionCallDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)

453 : FunctionCallDotNode(location, base, ident, args, divot, divotStart, divotEnd)

456 inline HasOwnPropertyFunctionCallDotNode::HasOwnPropertyFunctionCallDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, DotType type, ArgumentsNode* args, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)

457 : FunctionCallDotNode(location, base, ident, type, args, divot, divotStart, divotEnd)

    {

    }

@@namespace JSC {

    {

    }

780 inline AssignDotNode::AssignDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)

781 : ~~Expressi~~onNode(location)

784 inline AssignDotNode::AssignDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, DotType type, ExpressionNode* right, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)

785 : BaseDotNode(location, base, ident, type)

782786 , ThrowableExpressionData(divot, divotStart, divotEnd)

783 , m_base(base)

784 , m_ident(ident)

        , m_right(right)

        , m_rightHasAssignments(rightHasAssignments)

    {

    }

790 inline ReadModifyDotNode::ReadModifyDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, Operator oper, ExpressionNode* right, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)

791 : ~~Expressi~~onNode(location)

792 inline ReadModifyDotNode::ReadModifyDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, DotType type, Operator oper, ExpressionNode* right, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)

793 : BaseDotNode(location, base, ident, type)

792794 , ThrowableSubExpressionData(divot, divotStart, divotEnd)

793 , m_base(base)

794 , m_ident(ident)

        , m_right(right)

        , m_operator(oper)

        , m_rightHasAssignments(rightHasAssignments)

Source/JavaScriptCore/parser/Nodes.cpp

@@bool PropertyListNode::hasStaticallyNamedProperty(const Identifier& propName)

bool PropertyListNode::shouldCreateLexicalScopeForClass(PropertyListNode* list)

{

    while (list) {

338 if (list->m_node->isComputedClassField())

338 if (list->m_node->isComputedClassField() || list->m_node->isPrivate())

            return true;

        list = list->m_next;

    }

Source/JavaScriptCore/parser/Nodes.h

@@namespace JSC {

        virtual bool isPure(BytecodeGenerator&) const { return false; }        

        virtual bool isConstant() const { return false; }

        virtual bool isLocation() const { return false; }

188 virtual bool isPrivateLocation() const { return false; }

        virtual bool isAssignmentLocation() const { return isLocation(); }

        virtual bool isResolveNode() const { return false; }

        virtual bool isAssignResolveNode() const { return false; }

@@namespace JSC {

    enum class ClassElementTag : uint8_t { No, Instance, Static, LastTag };

    class PropertyNode final : public ParserArenaFreeable {

    public:

724 enum Type : uint8_t { Constant = 1, Getter = 2, Setter = 4, Computed = 8, Shorthand = 16, Spread = 32 };

725 enum Type : uint8_t { Constant = 1, Getter = 2, Setter = 4, Computed = 8, Shorthand = 16, Spread = 32, Private = 64 };

        enum PutType : uint8_t { Unknown, KnownDirect };

        PropertyNode(const Identifier&, ExpressionNode*, Type, PutType, SuperBinding, ClassElementTag);

@@namespace JSC {

        bool isClassField() const { return isClassProperty() && !needsSuperBinding(); }

        bool isInstanceClassField() const { return isInstanceClassProperty() && !needsSuperBinding(); }

        bool isOverriddenByDuplicate() const { return m_isOverriddenByDuplicate; }

744 bool isPrivate() const { return m_type & Private; }

        bool hasComputedName() const { return m_expression; }

        bool isComputedClassField() const { return isClassField() && hasComputedName(); }

        void setIsOverriddenByDuplicate() { m_isOverriddenByDuplicate = true; }

@@namespace JSC {

        const Identifier* m_name;

        ExpressionNode* m_expression;

        ExpressionNode* m_assign;

753 unsigned m_type : 6;

755 unsigned m_type : 7;

        unsigned m_needsSuperBinding : 1;

        unsigned m_putType : 1;

        static_assert(1 << 2 > static_cast<unsigned>(ClassElementTag::LastTag), "ClassElementTag shouldn't use more than two bits");

@@namespace JSC {

        RegisterID* emitBytecode(BytecodeGenerator&, RegisterID*, RegisterID*, Vector<JSTextPosition>*);

783 void emitDeclarePrivateFieldNames(BytecodeGenerator&, RegisterID* scope);

784

    private:

        RegisterID* emitBytecode(BytecodeGenerator& generator, RegisterID* dst = nullptr) final

        {

@@namespace JSC {

        bool m_subscriptHasAssignments;

    };

825 class DotAccessorNode final : public ExpressionNode, public ThrowableExpressionData {

829 enum class DotType { Name, PrivateField };

830 class BaseDotNode : public ExpressionNode {

826831 public:

827 DotAccessorNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&);

        BaseDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, DotType);

        ExpressionNode* base() const { return m_base; }

        const Identifier& identifier() const { return m_ident; }

        DotType type() const { return m_type; }

        bool isPrivateField() const { return m_type == DotType::PrivateField; }

        RegisterID* emitGetPropertyValue(BytecodeGenerator&, RegisterID* dst, RegisterID* base, RefPtr<RegisterID>& thisValue);

        RegisterID* emitGetPropertyValue(BytecodeGenerator&, RegisterID* dst, RegisterID* base);

        RegisterID* emitPutProperty(BytecodeGenerator&, RegisterID* base, RegisterID* value, RefPtr<RegisterID>& thisValue);

        RegisterID* emitPutProperty(BytecodeGenerator&, RegisterID* base, RegisterID* value);

    protected:

        ExpressionNode* m_base;

        const Identifier& m_ident;

        DotType m_type;

    };

    class DotAccessorNode final : public BaseDotNode, public ThrowableExpressionData {

    public:

        DotAccessorNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, DotType);

        ExpressionNode* base() const { return m_base; }

        const Identifier& identifier() const { return m_ident; }

@@namespace JSC {

        RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = nullptr) final;

        bool isLocation() const final { return true; }

861 bool isPrivateLocation() const override { return m_type == DotType::PrivateField; }

836862 bool isDotAccessorNode() const final { return true; }

        ExpressionNode* m_base;

        const Identifier& m_ident;

    };

    class SpreadExpressionNode final : public ExpressionNode, public ThrowableExpressionData {

@@namespace JSC {

        bool m_subscriptHasAssignments;

    };

952 class FunctionCallDotNode : public ~~Expressi~~onNode, public ThrowableSubExpressionData {

975 class FunctionCallDotNode : public BaseDotNode, public ThrowableSubExpressionData {

953976 public:

954 FunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

977 FunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, DotType, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

    private:

        RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = nullptr) override;

@@namespace JSC {

    protected:

        bool isFunctionCall() const override { return true; }

962 ExpressionNode* m_base;

963 const Identifier& m_ident;

        ArgumentsNode* m_args;

    };

@@namespace JSC {

    class CallFunctionCallDotNode final : public FunctionCallDotNode {

    public:

1000 CallFunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd, size_t distanceToInnermostCallOrApply);

1021 CallFunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, DotType, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd, size_t distanceToInnermostCallOrApply);

    private:

        RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = nullptr) final;

@@namespace JSC {

    
    class ApplyFunctionCallDotNode final : public FunctionCallDotNode {

    public:

1009 ApplyFunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd, size_t distanceToInnermostCallOrApply);

1030 ApplyFunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, DotType, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd, size_t distanceToInnermostCallOrApply);

    private:

        RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = nullptr) final;

@@namespace JSC {

    class HasOwnPropertyFunctionCallDotNode final : public FunctionCallDotNode {

    public:

1018 HasOwnPropertyFunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

1039 HasOwnPropertyFunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, DotType, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

    private:

        RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = nullptr) final;

@@namespace JSC {

        bool m_rightHasAssignments : 1;

    };

1480 class AssignDotNode final : public ~~Expressi~~onNode, public ThrowableExpressionData {

1501 class AssignDotNode final : public BaseDotNode, public ThrowableExpressionData {

14811502 public:

1482 AssignDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ExpressionNode* right, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

1503 AssignDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, DotType, ExpressionNode* right, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

    private:

        RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = nullptr) final;

1487 ExpressionNode* m_base;

1488 const Identifier& m_ident;

        ExpressionNode* m_right;

        bool m_rightHasAssignments;

    };

1493 class ReadModifyDotNode final : public ~~Expressi~~onNode, public ThrowableSubExpressionData {

1512 class ReadModifyDotNode final : public BaseDotNode, public ThrowableSubExpressionData {

14941513 public:

1495 ReadModifyDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, Operator, ExpressionNode* right, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

1514 ReadModifyDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, DotType, Operator, ExpressionNode* right, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

    private:

        RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = nullptr) final;

1500 ExpressionNode* m_base;

1501 const Identifier& m_ident;

        ExpressionNode* m_right;

        Operator m_operator;

        bool m_rightHasAssignments : 1;

@@namespace JSC {

    class DefineFieldNode final : public StatementNode {

    public:

2298 enum class Type { Name, ComputedName };

2315 enum class Type { Name, PrivateName, ComputedName };

        DefineFieldNode(const JSTokenLocation&, const Identifier*, ExpressionNode*, Type);

    private:

Source/JavaScriptCore/parser/Parser.cpp

@@template <class TreeBuilder> TreeExpression Parser<LexerType>::parseVariableDecl

        TreeExpression node = 0;

        declarations++;

        bool hasInitializer = false;

829

830 failIfTrue(match(PRIVATENAME), "Cannot use a private name to declare a variable");

        if (matchSpecIdentifier()) {

            failIfTrue(match(LET) && (declarationType == DeclarationType::LetDeclaration || declarationType == DeclarationType::ConstDeclaration), 

                "Cannot use 'let' as an identifier name for a LexicalDeclaration");

@@template <class TreeBuilder> TreeDestructuringPattern Parser<LexerType>::parseDe

            if (kind == DestructuringKind::DestructureToExpressions)

                return 0;

            semanticFailureDueToKeyword(destructuringKindToVariableKindName(kind));

1293 if (kind != DestructuringKind::DestructureToParameters)

1294 failIfTrue(match(PRIVATENAME), "Cannot use a private name as a ", destructuringKindToVariableKindName(kind));

            failWithMessage("Expected a parameter pattern or a ')' in parameter list");

        }

        failIfTrue(match(LET) && (kind == DestructuringKind::DestructureToLet || kind == DestructuringKind::DestructureToConst), "Cannot use 'let' as an identifier name for a LexicalDeclaration");

@@parseMethod:

            failIfFalse(computedPropertyName, "Cannot parse computed property name");

            handleProductionOrFail(CLOSEBRACKET, "]", "end", "computed property name");

            break;

        case PRIVATENAME: {

            ASSERT(Options::usePrivateClassFields());

            JSToken token = m_token;

            ident = m_token.m_data.ident;

            failIfTrue(tag == ClassElementTag::Static, "Static class element cannot be private");

            failIfTrue(isGetter || isSetter, "Cannot parse class method with private name");

            ASSERT(ident);

            next();

            failIfTrue(matchAndUpdate(OPENPAREN, token), "Cannot parse class method with private name");

            semanticFailIfTrue(classScope->declarePrivateName(*ident) & DeclarationResult::InvalidDuplicateDeclaration, "Cannot declare private field twice");

            type = static_cast<PropertyNode::Type>(type | PropertyNode::Private);

            break;

        }

        default:

            if (m_token.m_type & KeywordTokenFlag)

                goto namedKeyword;

@@parseMethod:

            failIfFalse(property, "Cannot parse this method");

        } else if (Options::usePublicClassFields() && !match(OPENPAREN) && tag == ClassElementTag::Instance && parseMode == SourceParseMode::MethodMode) {

            ASSERT(!isGetter && !isSetter);

2971 if (ident)

2988 if (ident) {

29722989 semanticFailIfTrue(*ident == propertyNames.constructor, "Cannot declare class field named 'constructor'");

2990 semanticFailIfTrue(*ident == propertyNames.constructorPrivateField, "Cannot declare private class field named '#constructor'");

2991 }

            if (computedPropertyName) {

                ident = &m_parserArena.identifierArena().makeNumericIdentifier(m_vm, numComputedFields++);

@@parseMethod:

    info.endOffset = tokenLocation().endOffset - 1;

    consumeOrFail(CLOSEBRACE, "Expected a closing '}' after a class body");

    if (Options::usePrivateClassFields()) {

        // Fail if there are no parent private name scopes and any used-but-undeclared private names.

        semanticFailIfFalse(copyUndeclaredPrivateNamesToOuterScope(), "Cannot reference undeclared private names");

    }

    auto classExpression = context.createClassExpr(location, info, classScope->finalizeLexicalEnvironment(), constructor, parentClass, classElements);

    popScope(classScope, TreeBuilder::NeedsFreeVariableInfo);

    return classExpression;

@@template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseInstance

        TreeExpression computedPropertyName = 0;

        DefineFieldNode::Type type = DefineFieldNode::Type::Name;

        switch (m_token.m_type) {

        case PRIVATENAME:

            type = DefineFieldNode::Type::PrivateName;

            FALLTHROUGH;

        case STRING:

        case IDENT:

        namedKeyword:

@@template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseInstance

        if (consume(EQUAL))

            initializer = parseAssignmentExpression(context);

        if (type == DefineFieldNode::Type::PrivateName)

            currentScope()->useVariable(ident, false);

        TreeStatement defineField = context.createDefineField(fieldLocation, ident, initializer, type);

        context.appendStatement(sourceElements, defineField);

    }

@@static inline void recordCallOrApplyDepth(ParserType*, VM&, Optional<typename Pa

{

}

template <typename LexerType>

bool Parser<LexerType>::usePrivateName(const Identifier* ident)

{

    if (m_lexer->isReparsingFunction())

        return true;

    if (auto maybeCurrent = findPrivateNameScope()) {

        ScopeRef current = maybeCurrent.value();

        if (!current->hasPrivateName(*ident))

            current->usePrivateName(*ident);

        return true;

    }

    return false;

}

template <typename LexerType>

template <class TreeBuilder> TreeExpression Parser<LexerType>::parseMemberExpression(TreeBuilder& context)

{

@@template <class TreeBuilder> TreeExpression Parser<LexerType>::parseMemberExpres

                m_parserState.nonTrivialExpressionCount++;

                JSTextPosition expressionEnd = lastTokenEndPosition();

                nextExpectIdentifier(TreeBuilder::DontBuildKeywords | LexerFlags::IgnoreReservedWords);

                const Identifier* ident = m_token.m_data.ident;

                auto type = DotType::Name;

                if (match(PRIVATENAME)) {

                    ASSERT(ident);

                    failIfTrue(baseIsSuper, "Cannot access private names from super");

                    if (UNLIKELY(currentScope()->evalContextType() == EvalContextType::InstanceFieldEvalContext))

                        semanticFailIfFalse(currentScope()->hasPrivateName(*ident), "Cannot reference undeclared private field '", ident->impl(), "'");

                    semanticFailIfFalse(usePrivateName(ident), "Cannot reference private names outside of class");

                    m_parserState.lastPrivateName = ident;

                    currentScope()->useVariable(ident, false);

                    type = DotType::PrivateField;

                    m_token.m_type = IDENT;

                }

50025060 matchOrFail(IDENT, "Expected a property name after ", optionalChainBase ? "'?.'" : "'.'");

5003 base = context.createDotAccess(startLocation, base, ~~m_token.m_data.~~ident, expressionStart, expressionEnd, tokenEndPosition());

5061 base = context.createDotAccess(startLocation, base, ident, type, expressionStart, expressionEnd, tokenEndPosition());

                if (UNLIKELY(baseIsSuper && currentScope()->isArrowFunction()))

                    currentFunctionScope()->setInnerArrowFunctionUsesSuperProperty();

                next();

@@template <class TreeBuilder> TreeExpression Parser<LexerType>::parseUnaryExpress

            break;

        case DELETETOKEN:

            failIfTrueIfStrict(context.isResolve(expr), "Cannot delete unqualified property '", m_parserState.lastIdentifier->impl(), "' in strict mode");

5256 semanticFailIfTrue(context.isPrivateLocation(expr), "Cannot delete private field ", m_parserState.lastPrivateName->impl());

            expr = context.makeDeleteNode(location, expr, context.unaryTokenStackLastStart(tokenStackDepth), end, end);

            break;

        default:

@@template <typename LexerType> void Parser<LexerType>::printUnexpectedTokenText(W

    case INVALID_PRIVATE_NAME_ERRORTOK:

        out.print("Invalid private name '", getToken(), "'");

        return;

5274

    case PRIVATENAME:

        out.print("Unexpected private name ", getToken());

        return;

    case AWAIT:

    case IDENT:

        out.print("Unexpected identifier '", getToken(), "'");

Source/JavaScriptCore/parser/Parser.h

@@public:

    bool isGeneratorBoundary() const { return m_isGeneratorBoundary; }

    bool isAsyncFunction() const { return m_isAsyncFunction; }

    bool isAsyncFunctionBoundary() const { return m_isAsyncFunctionBoundary; }

293 bool isPrivateNameScope() const { return m_isClassScope; }

    bool isClassScope() const { return m_isClassScope; }

    bool hasArguments() const { return m_hasArguments; }

@@public:

        m_allowsLexicalDeclarations = true;

    }

    void setIsPrivateNameScope()

    {

        // FIXME: Currently, isPrivateNameScope is an alias for isClassScope --- This is potentially misleading,

        // particularly when parsing direct eval code which occurs within a class.

        setIsClassScope();

    }

    void setIsClassScope()

    {

        m_isClassScope = true;

@@public:

    {

        return m_lexicalVariables.contains(ident.get());

    }

478

    bool hasPrivateName(const Identifier& ident)

    {

        return m_lexicalVariables.hasPrivateName(ident);

    }

    void copyUndeclaredPrivateNamesTo(Scope& other)

    {

        m_lexicalVariables.copyUndeclaredPrivateNamesTo(other.m_lexicalVariables);

    }

    bool hasUsedButUndeclaredPrivateNames() const

    {

        if (m_lexicalVariables.privateNamesSize() > 0) {

            for (auto entry : m_lexicalVariables.privateNames()) {

                if (entry.value.isUsed() && !entry.value.isDeclared())

                    return true;

            }

        }

        return false;

    }

    void usePrivateName(const Identifier& ident)

    {

        ASSERT(m_allowsLexicalDeclarations);

        m_lexicalVariables.usePrivateName(ident);

    }

    DeclarationResultMask declarePrivateName(const Identifier& ident)

    {

        ASSERT(m_allowsLexicalDeclarations);

        DeclarationResultMask result = DeclarationResult::Valid;

        auto addResult = m_lexicalVariables.declarePrivateName(ident);

        if (!addResult.isNewEntry)

            result |= DeclarationResult::InvalidDuplicateDeclaration;

        return result;

    }

    ALWAYS_INLINE bool hasDeclaredParameter(const Identifier& ident)

    {

        return hasDeclaredParameter(ident.impl());

@@public:

    ~Parser();

    template <class ParsedNode>

913 std::unique_ptr<ParsedNode> parse(ParserError&, const Identifier&, SourceParseMode, ParsingContext, Optional<int> functionConstructorParametersEndPosition = WTF::nullopt, const Vector<JSTextPosition>* = nullptr);

958 std::unique_ptr<ParsedNode> parse(ParserError&, const Identifier&, SourceParseMode, ParsingContext, Optional<int> functionConstructorParametersEndPosition = WTF::nullopt, const VariableEnvironment* = nullptr, const Vector<JSTextPosition>* = nullptr);

    JSTextPosition positionBeforeLastNewline() const { return m_lexer->positionBeforeLastNewline(); }

    JSTokenLocation locationBeforeLastToken() const { return m_lexer->lastTokenLocation(); }

@@private:

        return ScopeRef(&m_scopeStack, i);

    }

    Optional<ScopeRef> findPrivateNameScope()

    {

        ASSERT(m_scopeStack.size());

        unsigned i = m_scopeStack.size() - 1;

        while (i && !m_scopeStack[i].isPrivateNameScope())

            i--;

        if (m_scopeStack[i].isPrivateNameScope())

            return ScopeRef(&m_scopeStack, i);

        return WTF::nullopt;

    }

    ScopeRef privateNameScope()

    {

        ASSERT(m_scopeStack.size());

        unsigned i = m_scopeStack.size() - 1;

        while (i && !m_scopeStack[i].isPrivateNameScope())

            i--;

        ASSERT(m_scopeStack[i].isPrivateNameScope());

        return ScopeRef(&m_scopeStack, i);

    }

    bool copyUndeclaredPrivateNamesToOuterScope()

    {

        ScopeRef current = privateNameScope();

        unsigned i = current.index() - 1;

        while (i && !m_scopeStack[i].isPrivateNameScope())

            i--;

        if (!i)

            return !current->hasUsedButUndeclaredPrivateNames();

        current->copyUndeclaredPrivateNamesTo(m_scopeStack[i]);

        return true;

    }

    ScopeRef closestParentOrdinaryFunctionNonLexicalScope()

    {

        unsigned i = m_scopeStack.size() - 1;

@@private:

    {

        return m_token.m_type == expected;

    }

    ALWAYS_INLINE bool matchAndUpdate(JSTokenType expected, const JSToken& token)

    {

        if (match(expected)) {

            m_token = token;

            return true;

        }

        return false;

    }

    
    ALWAYS_INLINE bool matchContextualKeyword(const Identifier& identifier)

    {

@@private:

    template <class TreeBuilder> ALWAYS_INLINE bool isSimpleAssignmentTarget(TreeBuilder&, TreeExpression);

1811 ALWAYS_INLINE bool usePrivateName(const Identifier*);

1812

    ALWAYS_INLINE int isBinaryOperator(JSTokenType);

    bool allowAutomaticSemicolon();

@@private:

        FunctionParsePhase functionParsePhase { FunctionParsePhase::Body };

        const Identifier* lastIdentifier { nullptr };

        const Identifier* lastFunctionName { nullptr };

1907 const Identifier* lastPrivateName { nullptr };

        bool allowAwait { true };

        bool isParsingClassFieldInitializer { false };

    };

@@private:

template <typename LexerType>

template <class ParsedNode>

1962 std::unique_ptr<ParsedNode> Parser<LexerType>::parse(ParserError& error, const Identifier& calleeName, SourceParseMode parseMode, ParsingContext parsingContext, Optional<int> functionConstructorParametersEndPosition, const Vector<JSTextPosition>* instanceFieldLocations)

2058std::unique_ptr<ParsedNode> Parser<LexerType>::parse(ParserError& error, const Identifier& calleeName, SourceParseMode parseMode, ParsingContext parsingContext, Optional<int> functionConstructorParametersEndPosition, const VariableEnvironment* variablesUnderTDZ, const Vector<JSTextPosition>* instanceFieldLocations)

{

    int errLine;

    String errMsg;

@@std::unique_ptr<ParsedNode> Parser<LexerType>::parse(ParserError& error, const I

    ASSERT(m_source->startColumn() > OrdinalNumber::beforeFirst());

    unsigned startColumn = m_source->startColumn().zeroBasedInt();

    if (isEvalNode<ParsedNode>() && variablesUnderTDZ && variablesUnderTDZ->privateNamesSize()) {

        currentScope()->setIsPrivateNameScope();

        variablesUnderTDZ->copyPrivateNamesTo(currentScope()->lexicalVariables());

    }

    auto parseResult = parseInner(calleeName, parseMode, parsingContext, functionConstructorParametersEndPosition, instanceFieldLocations);

    int lineNumber = m_lexer->lineNumber();

@@std::unique_ptr<ParsedNode> parse(

    DerivedContextType derivedContextType = DerivedContextType::None,

    EvalContextType evalContextType = EvalContextType::None,

    DebuggerParseData* debuggerParseData = nullptr,

2162 const VariableEnvironment* variablesUnderTDZ = nullptr,

    const Vector<JSTextPosition>* instanceFieldLocations = nullptr,

    bool isInsideOrdinaryFunction = false)

{

@@std::unique_ptr<ParsedNode> parse(

    std::unique_ptr<ParsedNode> result;

    if (source.provider()->source().is8Bit()) {

        Parser<Lexer<LChar>> parser(vm, source, builtinMode, strictMode, scriptMode, parseMode, superBinding, defaultConstructorKindForTopLevelFunction, derivedContextType, isEvalNode<ParsedNode>(), evalContextType, debuggerParseData, isInsideOrdinaryFunction);

2073 result = parser.parse<ParsedNode>(error, name, parseMode, isEvalNode<ParsedNode>() ? ParsingContext::Eval : ParsingContext::Program, WTF::nullopt, instanceFieldLocations);

2175 result = parser.parse<ParsedNode>(error, name, parseMode, isEvalNode<ParsedNode>() ? ParsingContext::Eval : ParsingContext::Program, WTF::nullopt, variablesUnderTDZ, instanceFieldLocations);

        if (positionBeforeLastNewline)

            *positionBeforeLastNewline = parser.positionBeforeLastNewline();

        if (builtinMode == JSParserBuiltinMode::Builtin) {

@@std::unique_ptr<ParsedNode> parse(

    } else {

        ASSERT_WITH_MESSAGE(defaultConstructorKindForTopLevelFunction == ConstructorKind::None, "BuiltinExecutables's special constructors should always use a 8-bit string");

        Parser<Lexer<UChar>> parser(vm, source, builtinMode, strictMode, scriptMode, parseMode, superBinding, defaultConstructorKindForTopLevelFunction, derivedContextType, isEvalNode<ParsedNode>(), evalContextType, debuggerParseData, isInsideOrdinaryFunction);

2086 result = parser.parse<ParsedNode>(error, name, parseMode, isEvalNode<ParsedNode>() ? ParsingContext::Eval : ParsingContext::Program, WTF::nullopt, instanceFieldLocations);

2188 result = parser.parse<ParsedNode>(error, name, parseMode, isEvalNode<ParsedNode>() ? ParsingContext::Eval : ParsingContext::Program, WTF::nullopt, variablesUnderTDZ, instanceFieldLocations);

        if (positionBeforeLastNewline)

            *positionBeforeLastNewline = parser.positionBeforeLastNewline();

    }

Source/JavaScriptCore/parser/ParserTokens.h

@@enum JSTokenType {

    DOUBLE,

    BIGINT,

    IDENT,

117 PRIVATENAME,

    STRING,

    TEMPLATE,

    REGEXP,

Source/JavaScriptCore/parser/SyntaxChecker.h

@@public:

        ResolveEvalExpr, ResolveExpr, IntegerExpr, DoubleExpr, StringExpr, BigIntExpr,

        ThisExpr, NullExpr, BoolExpr, RegExpExpr, ObjectLiteralExpr,

        FunctionExpr, ClassExpr, SuperExpr, ImportExpr, BracketExpr, DotExpr, CallExpr,

76 NewExpr, PreExpr, PostExpr, UnaryExpr, BinaryExpr, OptionalChain,

76 NewExpr, PreExpr, PostExpr, UnaryExpr, BinaryExpr, OptionalChain, PrivateDotExpr,

        ConditionalExpr, AssignmentExpr, TypeofExpr,

        DeleteExpr, ArrayLiteralExpr, BindingDestructuring, RestParameter,

        ArrayDestructuring, ObjectDestructuring, SourceElementsResult,

@@public:

    ExpressionType createBoolean(const JSTokenLocation&, bool) { return BoolExpr; }

    ExpressionType createNull(const JSTokenLocation&) { return NullExpr; }

    ExpressionType createBracketAccess(const JSTokenLocation&, ExpressionType, ExpressionType, bool, int, int, int) { return BracketExpr; }

183 ExpressionType createDotAccess(const JSTokenLocation&, ExpressionType, const Identifier*, int, int, int) { return DotExpr; }

183 ExpressionType createDotAccess(const JSTokenLocation&, ExpressionType, const Identifier*, DotType type, int, int, int) { return type == DotType::PrivateField ? PrivateDotExpr : DotExpr; }

    ExpressionType createRegExp(const JSTokenLocation&, const Identifier& pattern, const Identifier& flags, int) { return Yarr::hasError(Yarr::checkSyntax(pattern.string(), flags.string())) ? 0 : RegExpExpr; }

    ExpressionType createNewExpr(const JSTokenLocation&, ExpressionType, int, int, int, int) { return NewExpr; }

    ExpressionType createNewExpr(const JSTokenLocation&, ExpressionType, int, int) { return NewExpr; }

@@public:

    bool isLocation(ExpressionType type)

    {

406 return type == ResolveExpr || type == DotExpr || type == BracketExpr;

        return type == ResolveExpr || type == DotExpr || type == PrivateDotExpr || type == BracketExpr;

    }

    bool isPrivateLocation(ExpressionType type)

    {

        return type == PrivateDotExpr;

    }

    bool isAssignmentLocation(ExpressionType type)

Source/JavaScriptCore/parser/VariableEnvironment.cpp

namespace JSC {

VariableEnvironment& VariableEnvironment::operator=(const VariableEnvironment& other)

{

    VariableEnvironment env(other);

    swap(env);

    return *this;

}

void VariableEnvironment::markVariableAsCapturedIfDefined(const RefPtr<UniquedStringImpl>& identifier)

{

    auto findResult = m_map.find(identifier);

@@void VariableEnvironment::swap(VariableEnvironment& other)

{

    m_map.swap(other.m_map);

    m_isEverythingCaptured = other.m_isEverythingCaptured;

90 m_rareData.swap(other.m_rareData);

}

void VariableEnvironment::markVariableAsImported(const RefPtr<UniquedStringImpl>& identifier)

@@CompactVariableEnvironment::CompactVariableEnvironment(const VariableEnvironment

    : m_isEverythingCaptured(env.isEverythingCaptured())

{

    Vector<std::pair<UniquedStringImpl*, VariableEnvironmentEntry>, 32> sortedEntries;

103 sortedEntries.reserveInitialCapacity(env.size());

111 sortedEntries.reserveInitialCapacity(env.mapSize());

    for (auto& pair : env)

        sortedEntries.append({ pair.key.get(), pair.value });

Source/JavaScriptCore/parser/VariableEnvironment.h

#include "Identifier.h"

#include <wtf/HashMap.h>

30#include <wtf/HashSet.h>

31#include <wtf/IteratorRange.h>

namespace JSC {

@@public:

    ALWAYS_INLINE bool isFunction() const { return m_bits & IsFunction; }

    ALWAYS_INLINE bool isParameter() const { return m_bits & IsParameter; }

    ALWAYS_INLINE bool isSloppyModeHoistingCandidate() const { return m_bits & IsSloppyModeHoistingCandidate; }

47 ALWAYS_INLINE bool isPrivateName() const { return m_bits & IsPrivateName; }

    ALWAYS_INLINE void setIsCaptured() { m_bits |= IsCaptured; }

    ALWAYS_INLINE void setIsConst() { m_bits |= IsConst; }

@@public:

    ALWAYS_INLINE void setIsFunction() { m_bits |= IsFunction; }

    ALWAYS_INLINE void setIsParameter() { m_bits |= IsParameter; }

    ALWAYS_INLINE void setIsSloppyModeHoistingCandidate() { m_bits |= IsSloppyModeHoistingCandidate; }

59 ALWAYS_INLINE void setIsPrivateName() { m_bits |= IsPrivateName; }

    ALWAYS_INLINE void clearIsVar() { m_bits &= ~IsVar; }

@@private:

        IsImportedNamespace = 1 << 6,

        IsFunction = 1 << 7,

        IsParameter = 1 << 8,

77 IsSloppyModeHoistingCandidate = 1 << 9

81 IsSloppyModeHoistingCandidate = 1 << 9,

82 IsPrivateName = 1 << 10,

    };

    uint16_t m_bits { 0 };

};

@@struct VariableEnvironmentEntryHashTraits : HashTraits<VariableEnvironmentEntry>

    static constexpr bool needsDestruction = false;

};

struct PrivateNameEntry {

public:

    PrivateNameEntry(uint16_t traits = 0) { m_bits = traits; }

    ALWAYS_INLINE bool isUsed() const { return m_bits & IsUsed; }

    ALWAYS_INLINE bool isDeclared() const { return m_bits & IsDeclared; }

    ALWAYS_INLINE void setIsUsed() { m_bits |= IsUsed; }

    ALWAYS_INLINE void setIsDeclared() { m_bits |= IsDeclared; }

    uint16_t bits() const { return m_bits; }

    bool operator==(const PrivateNameEntry& other) const

    {

        return m_bits == other.m_bits;

    }

    enum Traits : uint16_t {

        IsUsed = 1 << 0,

        IsDeclared = 1 << 1,

    };

private:

    uint16_t m_bits { 0 };

};

struct PrivateNameEntryHashTraits : HashTraits<PrivateNameEntry> {

    static const bool needsDestruction = false;

};

class VariableEnvironment {

private:

    typedef HashMap<PackedRefPtr<UniquedStringImpl>, VariableEnvironmentEntry, IdentifierRepHash, HashTraits<RefPtr<UniquedStringImpl>>, VariableEnvironmentEntryHashTraits> Map;

124 typedef HashMap<PackedRefPtr<UniquedStringImpl>, PrivateNameEntry, IdentifierRepHash, HashTraits<RefPtr<UniquedStringImpl>>, PrivateNameEntryHashTraits> PrivateNames;

89125public:

    VariableEnvironment() = default;

    VariableEnvironment(VariableEnvironment&& other) = default;

    VariableEnvironment(const VariableEnvironment&) = default;

    VariableEnvironment& operator=(const VariableEnvironment&) = default;

    VariableEnvironment& operator=(VariableEnvironment&&) = default;

    VariableEnvironment() { }

    VariableEnvironment(VariableEnvironment&& other)

        : m_map(WTFMove(other.m_map))

        , m_isEverythingCaptured(other.m_isEverythingCaptured)

        , m_rareData(WTFMove(other.m_rareData))

    {

    }

    VariableEnvironment(const VariableEnvironment& other)

        : m_map(other.m_map)

        , m_isEverythingCaptured(other.m_isEverythingCaptured)

        , m_rareData(other.m_rareData ? WTF::makeUnique<VariableEnvironment::RareData>(*other.m_rareData) : nullptr)

    {

    }

    VariableEnvironment& operator=(const VariableEnvironment& other);

    ALWAYS_INLINE Map::iterator begin() { return m_map.begin(); }

    ALWAYS_INLINE Map::iterator end() { return m_map.end(); }

@@public:

    ALWAYS_INLINE Map::const_iterator end() const { return m_map.end(); }

    ALWAYS_INLINE Map::AddResult add(const RefPtr<UniquedStringImpl>& identifier) { return m_map.add(identifier, VariableEnvironmentEntry()); }

    ALWAYS_INLINE Map::AddResult add(const Identifier& identifier) { return add(identifier.impl()); }

102 ALWAYS_INLINE unsigned size() const { return m_map.size(); }

147 ALWAYS_INLINE unsigned size() const { return m_map.size() + privateNamesSize(); }

148 ALWAYS_INLINE unsigned mapSize() const { return m_map.size(); }

    ALWAYS_INLINE bool contains(const RefPtr<UniquedStringImpl>& identifier) const { return m_map.contains(identifier); }

    ALWAYS_INLINE bool remove(const RefPtr<UniquedStringImpl>& identifier) { return m_map.remove(identifier); }

    ALWAYS_INLINE Map::iterator find(const RefPtr<UniquedStringImpl>& identifier) { return m_map.find(identifier); }

@@public:

    bool isEverythingCaptured() const { return m_isEverythingCaptured; }

    bool isEmpty() const { return !m_map.size(); }

    using PrivateNamesRange = WTF::IteratorRange<PrivateNames::iterator>;

    ALWAYS_INLINE Map::AddResult declarePrivateName(const Identifier& identifier) { return declarePrivateName(identifier.impl()); }

    ALWAYS_INLINE void usePrivateName(const Identifier& identifier) { usePrivateName(identifier.impl()); }

    Map::AddResult declarePrivateName(const RefPtr<UniquedStringImpl>& identifier)

    {

        auto& meta = getOrAddPrivateName(identifier.get());

        meta.setIsDeclared();

        auto entry = VariableEnvironmentEntry();

        entry.setIsPrivateName();

        entry.setIsConst();

        entry.setIsCaptured();

        return m_map.add(identifier, entry);

    }

    void usePrivateName(const RefPtr<UniquedStringImpl>& identifier)

    {

        auto& meta = getOrAddPrivateName(identifier.get());

        meta.setIsUsed();

        if (meta.isDeclared())

            find(identifier)->value.setIsCaptured();

    }

    ALWAYS_INLINE PrivateNamesRange privateNames() const

    {

        // Use of the IteratorRange must be guarded to prevent ASSERT failures in checkValidity().

        ASSERT(privateNamesSize() > 0);

        return makeIteratorRange(m_rareData->m_privateNames.begin(), m_rareData->m_privateNames.end());

    }

    ALWAYS_INLINE unsigned privateNamesSize() const

    {

        if (!m_rareData)

            return 0;

        return m_rareData->m_privateNames.size();

    }

    ALWAYS_INLINE bool hasPrivateName(const Identifier& identifier)

    {

        if (!m_rareData)

            return false;

        return m_rareData->m_privateNames.contains(identifier.impl());

    }

    ALWAYS_INLINE void copyPrivateNamesTo(VariableEnvironment& other) const

    {

        if (!m_rareData)

            return;

        if (!other.m_rareData)

            other.m_rareData = WTF::makeUnique<VariableEnvironment::RareData>();

        if (privateNamesSize() > 0) {

            for (auto entry : privateNames()) {

                if (!(entry.value.isUsed() && entry.value.isDeclared()))

                    other.m_rareData->m_privateNames.add(entry.key, entry.value);

            }

        }

    }

    ALWAYS_INLINE void copyUndeclaredPrivateNamesTo(VariableEnvironment& outer) const {

        // Used by the Parser to transfer recorded uses of PrivateNames from an

        // inner PrivateNameEnvironment into an outer one, in case a PNE is used

        // earlier in the source code than it is defined.

        if (privateNamesSize() > 0) {

            for (auto entry : privateNames()) {

                if (entry.value.isUsed() && !entry.value.isDeclared())

                    outer.getOrAddPrivateName(entry.key.get()).setIsUsed();

            }

        }

    }

    struct RareData {

        WTF_MAKE_STRUCT_FAST_ALLOCATED;

        RareData() { }

        RareData(RareData&& other)

            : m_privateNames(WTFMove(other.m_privateNames))

        {

        }

        RareData(const RareData&) = default;

        RareData& operator=(const RareData&) = default;

        PrivateNames m_privateNames;

    };

private:

    friend class CachedVariableEnvironment;

    Map m_map;

    bool m_isEverythingCaptured { false };

    PrivateNameEntry& getOrAddPrivateName(UniquedStringImpl* impl)

    {

        if (!m_rareData)

            m_rareData = WTF::makeUnique<VariableEnvironment::RareData>();

        return m_rareData->m_privateNames.add(impl, PrivateNameEntry()).iterator->value;

    }

    std::unique_ptr<VariableEnvironment::RareData> m_rareData;

};

class CompactVariableEnvironment {

Source/JavaScriptCore/runtime/CachedTypes.cpp

@@public:

        else

            encode(encoder, { *source });

    }

    SourceType<T>* decodeAsPtr(Decoder& decoder) const

    {

        RELEASE_ASSERT(!this->isEmpty());

        return this->template buffer<T>()->decode(decoder);

    }

};

class CachedSimpleJumpTable : public CachedObject<UnlinkedSimpleJumpTable> {

@@private:

    unsigned m_needsClassFieldInitializer : 1;

};

class CachedVariableEnvironmentRareData : public CachedObject<VariableEnvironment::RareData> {

public:

    void encode(Encoder& encoder, const VariableEnvironment::RareData& rareData)

    {

        m_privateNames.encode(encoder, rareData.m_privateNames);

    }

    void decode(Decoder& decoder, VariableEnvironment::RareData& rareData) const

    {

        m_privateNames.decode(decoder, rareData.m_privateNames);

    }

private:

    CachedHashMap<CachedRefPtr<CachedUniquedStringImpl, UniquedStringImpl, WTF::PackedPtrTraits<UniquedStringImpl>>, PrivateNameEntry, IdentifierRepHash, HashTraits<RefPtr<UniquedStringImpl>>, PrivateNameEntryHashTraits> m_privateNames;

};

class CachedVariableEnvironment : public CachedObject<VariableEnvironment> {

public:

    void encode(Encoder& encoder, const VariableEnvironment& env)

    {

        m_isEverythingCaptured = env.m_isEverythingCaptured;

        m_map.encode(encoder, env.m_map);

1034 m_rareData.encode(encoder, env.m_rareData.get());

    }

    void decode(Decoder& decoder, VariableEnvironment& env) const

    {

        env.m_isEverythingCaptured = m_isEverythingCaptured;

        m_map.decode(decoder, env.m_map);

        if (!m_rareData.isEmpty()) {

            env.m_rareData = WTF::makeUnique<VariableEnvironment::RareData>();

            m_rareData->decode(decoder, *env.m_rareData);

        }

    }

private:

    bool m_isEverythingCaptured;

    CachedHashMap<CachedRefPtr<CachedUniquedStringImpl, UniquedStringImpl, WTF::PackedPtrTraits<UniquedStringImpl>>, VariableEnvironmentEntry, IdentifierRepHash, HashTraits<RefPtr<UniquedStringImpl>>, VariableEnvironmentEntryHashTraits> m_map;

1050 CachedPtr<CachedVariableEnvironmentRareData> m_rareData;

};

class CachedCompactVariableEnvironment : public CachedObject<CompactVariableEnvironment> {

@@private:

    intptr_t m_bits;

};

class CachedSymbolTableRareData : public CachedObject<SymbolTable::SymbolTableRareData> {

public:

    void encode(Encoder& encoder, const SymbolTable::SymbolTableRareData& rareData)

    {

        m_privateNames.encode(encoder, rareData.m_privateNames);

    }

    void decode(Decoder& decoder, SymbolTable::SymbolTableRareData& rareData) const

    {

        m_privateNames.decode(decoder, rareData.m_privateNames);

    }

private:

    CachedHashSet<CachedRefPtr<CachedUniquedStringImpl>, IdentifierRepHash> m_privateNames;

};

class CachedSymbolTable : public CachedObject<SymbolTable> {

public:

    void encode(Encoder& encoder, const SymbolTable& symbolTable)

@@public:

        m_nestedLexicalScope = symbolTable.m_nestedLexicalScope;

        m_scopeType = symbolTable.m_scopeType;

        m_arguments.encode(encoder, symbolTable.m_arguments.get());

1204 m_rareData.encode(encoder, symbolTable.m_rareData.get());

    }

    SymbolTable* decode(Decoder& decoder) const

@@public:

        ScopedArgumentsTable* scopedArgumentsTable = m_arguments.decode(decoder);

        if (scopedArgumentsTable)

            symbolTable->m_arguments.set(decoder.vm(), symbolTable, scopedArgumentsTable);

        if (!m_rareData.isEmpty()) {

            symbolTable->m_rareData = WTF::makeUnique<SymbolTable::SymbolTableRareData>();

            m_rareData->decode(decoder, *symbolTable->m_rareData);

        }

        return symbolTable;

    }

@@private:

    unsigned m_nestedLexicalScope : 1;

    unsigned m_scopeType : 3;

    CachedPtr<CachedScopedArgumentsTable> m_arguments;

1233 CachedPtr<CachedSymbolTableRareData> m_rareData;

};

class CachedJSValue;

Source/JavaScriptCore/runtime/CodeCache.cpp

@@UnlinkedCodeBlockType* generateUnlinkedCodeBlockImpl(VM& vm, const SourceCode& s

    typedef typename CacheTypes<UnlinkedCodeBlockType>::RootNode RootNode;

    bool isInsideOrdinaryFunction = executable && executable->isInsideOrdinaryFunction();

    std::unique_ptr<RootNode> rootNode = parse<RootNode>(

79 vm, source, Identifier(), JSParserBuiltinMode::NotBuiltin, strictMode, scriptMode, CacheTypes<UnlinkedCodeBlockType>::parseMode, SuperBinding::NotNeeded, error, nullptr, ConstructorKind::None, derivedContextType, evalContextType, nullptr, nullptr, isInsideOrdinaryFunction);

79 vm, source, Identifier(), JSParserBuiltinMode::NotBuiltin, strictMode, scriptMode, CacheTypes<UnlinkedCodeBlockType>::parseMode, SuperBinding::NotNeeded, error, nullptr, ConstructorKind::None, derivedContextType, evalContextType, nullptr, variablesUnderTDZ, nullptr, isInsideOrdinaryFunction);

    if (!rootNode)

        return nullptr;

Source/JavaScriptCore/runtime/CommonIdentifiers.cpp

@@namespace JSC {

#define INITIALIZE_KEYWORD(name) , name##Keyword(Identifier::fromString(vm, #name))

#define INITIALIZE_PRIVATE_NAME(name) , name##PrivateName(m_builtinNames->name##PrivateName())

#define INITIALIZE_SYMBOL(name) , name##Symbol(m_builtinNames->name##Symbol())

33#define INITIALIZE_PRIVATE_FIELD_NAME(name) , name##PrivateField(Identifier::fromString(vm, "#" #name))

CommonIdentifiers::CommonIdentifiers(VM& vm)

    : nullIdentifier()

@@CommonIdentifiers::CommonIdentifiers(VM& vm)

    JSC_COMMON_IDENTIFIERS_EACH_KEYWORD(INITIALIZE_KEYWORD)

    JSC_COMMON_IDENTIFIERS_EACH_PROPERTY_NAME(INITIALIZE_PROPERTY_NAME)

    JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_WELL_KNOWN_SYMBOL(INITIALIZE_SYMBOL)

47 JSC_COMMON_IDENTIFIERS_EACH_PRIVATE_FIELD(INITIALIZE_PRIVATE_FIELD_NAME)

{

}

Source/JavaScriptCore/runtime/CommonIdentifiers.h

    macro(writable) \

    macro(year)

#define JSC_COMMON_IDENTIFIERS_EACH_PRIVATE_FIELD(macro) \

    macro(constructor)

#define JSC_COMMON_IDENTIFIERS_EACH_KEYWORD(macro) \

    macro(await) \

    macro(break) \

@@namespace JSC {

        JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_WELL_KNOWN_SYMBOL(JSC_IDENTIFIER_DECLARE_PRIVATE_WELL_KNOWN_SYMBOL_GLOBAL)

#undef JSC_IDENTIFIER_DECLARE_PRIVATE_WELL_KNOWN_SYMBOL_GLOBAL

#define JSC_IDENTIFIER_DECLARE_PRIVATE_FIELD_GLOBAL(name) const Identifier name##PrivateField;

        JSC_COMMON_IDENTIFIERS_EACH_PRIVATE_FIELD(JSC_IDENTIFIER_DECLARE_PRIVATE_FIELD_GLOBAL)

#undef JSC_IDENTIFIER_DECLARE_PRIVATE_FIELD_GLOBAL

        // Callers of this method should make sure that identifiers given to this method 

        // survive the lifetime of CommonIdentifiers and related VM.

        JS_EXPORT_PRIVATE void appendExternalName(const Identifier& publicName, const Identifier& privateName);

Source/JavaScriptCore/runtime/CommonSlowPaths.cpp

@@SLOW_PATH_DECL(slow_path_get_by_val_with_this)

    RETURN_PROFILED(baseValue.get(globalObject, property, slot));

}

SLOW_PATH_DECL(slow_path_get_private_name)

{

    BEGIN();

    auto bytecode = pc->as<OpGetPrivateName>();

    JSValue baseValue = GET_C(bytecode.m_base).jsValue();

    JSValue subscript = GET_C(bytecode.m_property).jsValue();

    ASSERT(subscript.isSymbol());

    baseValue.requireObjectCoercible(globalObject);

    CHECK_EXCEPTION();

    auto property = subscript.toPropertyKey(globalObject);

    CHECK_EXCEPTION();

    ASSERT(property.isPrivateName());

    PropertySlot slot(baseValue, PropertySlot::InternalMethodType::GetOwnProperty);

    asObject(baseValue)->getPrivateField(globalObject, property, slot);

    CHECK_EXCEPTION();

    RETURN_PROFILED(slot.getValue(globalObject, property));

}

SLOW_PATH_DECL(slow_path_put_by_id_with_this)

{

    BEGIN();

Source/JavaScriptCore/runtime/CommonSlowPaths.h

@@SLOW_PATH_HIDDEN_DECL(slow_path_create_async_generator);

SLOW_PATH_HIDDEN_DECL(slow_path_create_rest);

SLOW_PATH_HIDDEN_DECL(slow_path_get_by_id_with_this);

SLOW_PATH_HIDDEN_DECL(slow_path_get_by_val_with_this);

278SLOW_PATH_HIDDEN_DECL(slow_path_get_private_name);

SLOW_PATH_HIDDEN_DECL(slow_path_put_by_id_with_this);

SLOW_PATH_HIDDEN_DECL(slow_path_put_by_val_with_this);

SLOW_PATH_HIDDEN_DECL(slow_path_define_data_property);

Source/JavaScriptCore/runtime/ExceptionHelpers.cpp

@@JSObject* createTDZError(JSGlobalObject* globalObject)

    return createReferenceError(globalObject, "Cannot access uninitialized variable.");

}

JSObject* createInvalidPrivateNameError(JSGlobalObject* globalObject)

{

    return createTypeError(globalObject, makeString("Cannot access invalid private field"), defaultSourceAppender, TypeNothing);

}

JSObject* createRedefinedPrivateNameError(JSGlobalObject* globalObject)

{

    return createTypeError(globalObject, makeString("Cannot redefine existing private field"), defaultSourceAppender, TypeNothing);

}

Exception* throwOutOfMemoryError(JSGlobalObject* globalObject, ThrowScope& scope)

{

    return throwException(globalObject, scope, createOutOfMemoryError(globalObject));

Source/JavaScriptCore/runtime/ExceptionHelpers.h

@@JSObject* createInvalidInstanceofParameterErrorHasInstanceValueNotFunction(JSGlo

JSObject* createNotAConstructorError(JSGlobalObject*, JSValue);

JSObject* createNotAFunctionError(JSGlobalObject*, JSValue);

JSObject* createErrorForInvalidGlobalAssignment(JSGlobalObject*, const String&);

56JSObject* createInvalidPrivateNameError(JSGlobalObject*);

57JSObject* createRedefinedPrivateNameError(JSGlobalObject*);

String errorDescriptionForValue(JSGlobalObject*, JSValue);

JS_EXPORT_PRIVATE Exception* throwOutOfMemoryError(JSGlobalObject*, ThrowScope&);

Source/JavaScriptCore/runtime/JSGlobalObject.cpp

@@static EncodedJSValue JSC_HOST_CALL hasOwnLengthProperty(JSGlobalObject* globalO

    RELEASE_AND_RETURN(scope, JSValue::encode(jsBoolean(target->hasOwnProperty(globalObject, vm.propertyNames->length))));

}

// FIXME: use a bytecode or intrinsic for creating a private symbol.

// https://bugs.webkit.org/show_bug.cgi?id=212782

static EncodedJSValue JSC_HOST_CALL createPrivateSymbol(JSGlobalObject* globalObject, CallFrame*)

{

    VM& vm = globalObject->vm();

    return JSValue::encode(Symbol::create(vm, PrivateSymbolImpl::createNullSymbol().get()));

}

#if ASSERT_ENABLED

static EncodedJSValue JSC_HOST_CALL assertCall(JSGlobalObject* globalObject, CallFrame* callFrame)

{

@@capitalName ## Constructor* lowerName ## Constructor = featureFlag ? capitalName

            init.set(JSFunction::create(init.vm, jsCast<JSGlobalObject*>(init.owner), 0, String(), globalFuncDateTimeFormat));

        });

    // PrivateSymbols / PrivateNames

    m_linkTimeConstants[static_cast<unsigned>(LinkTimeConstant::createPrivateSymbol)].initLater([] (const Initializer<JSCell>& init) {

            init.set(JSFunction::create(init.vm, jsCast<JSGlobalObject*>(init.owner), 0, String(), createPrivateSymbol));

        });

#if ENABLE(WEBASSEMBLY) && ENABLE(WEBASSEMBLY_STREAMING_API)

    // WebAssembly Streaming API

    m_linkTimeConstants[static_cast<unsigned>(LinkTimeConstant::webAssemblyCompileStreamingInternal)].initLater([] (const Initializer<JSCell>& init) {

Source/JavaScriptCore/runtime/JSObject.h

@@public:

    // being returned. Once this is fixed we should migrate code & remove this method.

    JS_EXPORT_PRIVATE bool getOwnPropertyDescriptor(JSGlobalObject*, PropertyName, PropertyDescriptor&);

    static bool getPrivateFieldSlot(JSObject*, JSGlobalObject*, PropertyName, PropertySlot&);

    inline bool getPrivateField(JSGlobalObject*, PropertyName, PropertySlot&);

    inline void putPrivateField(JSGlobalObject*, PropertyName, JSValue, PutPropertySlot&);

    inline void definePrivateField(JSGlobalObject*, PropertyName, JSValue, PutPropertySlot&);

    unsigned getArrayLength() const

    {

        if (!hasIndexedProperties(indexingType()))

Source/JavaScriptCore/runtime/JSObjectInlines.h

@@inline JSValue JSObject::get(JSGlobalObject* globalObject, uint64_t propertyName

    return get(globalObject, Identifier::from(globalObject->vm(), propertyName));

}

JSObject* createInvalidPrivateNameError(JSGlobalObject*);

JSObject* createRedefinedPrivateNameError(JSGlobalObject*);

ALWAYS_INLINE bool JSObject::getPrivateFieldSlot(JSObject* object, JSGlobalObject* globalObject, PropertyName propertyName, PropertySlot& slot)

{

    ASSERT(propertyName.isPrivateName());

    VM& vm = getVM(globalObject);

    Structure* structure = object->structure(vm);

    unsigned attributes;

    PropertyOffset offset = structure->get(vm, propertyName, attributes);

    if (offset == invalidOffset)

        return false;

    JSValue value = object->getDirect(offset);

    ASSERT(value);

    if (value.isCell()) {

        JSCell* cell = value.asCell();

        JSType type = cell->type();

        UNUSED_PARAM(cell);

        ASSERT_UNUSED(type, type != GetterSetterType && type != CustomGetterSetterType);

        // FIXME: For now, private fields do not support getter/setter fields. Later on, we will need to fill in accessor metadata here,

        // as in JSObject::getOwnNonIndexPropertySlot()

        // https://bugs.webkit.org/show_bug.cgi?id=194435

    }

    slot.setValue(object, attributes, value, offset);

    return true;

}

inline bool JSObject::getPrivateField(JSGlobalObject* globalObject, PropertyName propertyName, PropertySlot& slot)

{

    VM& vm = getVM(globalObject);

    auto scope = DECLARE_THROW_SCOPE(vm);

    if (!JSObject::getPrivateFieldSlot(this, globalObject, propertyName, slot)) {

        throwException(globalObject, scope, createInvalidPrivateNameError(globalObject));

        RELEASE_AND_RETURN(scope, false);

    }

    EXCEPTION_ASSERT(!scope.exception());

    RELEASE_AND_RETURN(scope, true);

}

inline void JSObject::putPrivateField(JSGlobalObject* globalObject, PropertyName propertyName, JSValue value, PutPropertySlot& putSlot)

{

    VM& vm = getVM(globalObject);

    auto scope = DECLARE_THROW_SCOPE(vm);

    PropertySlot slot(this, PropertySlot::InternalMethodType::HasProperty);

    if (!JSObject::getPrivateFieldSlot(this, globalObject, propertyName, slot)) {

        throwException(globalObject, scope, createInvalidPrivateNameError(globalObject));

        RELEASE_AND_RETURN(scope, void());

    }

    EXCEPTION_ASSERT(!scope.exception());

    scope.release();

    putDirect(vm, propertyName, value, putSlot);

}

inline void JSObject::definePrivateField(JSGlobalObject* globalObject, PropertyName propertyName, JSValue value, PutPropertySlot& putSlot)

{

    VM& vm = getVM(globalObject);

    auto scope = DECLARE_THROW_SCOPE(vm);

    PropertySlot slot(this, PropertySlot::InternalMethodType::HasProperty);

    if (JSObject::getPrivateFieldSlot(this, globalObject, propertyName, slot)) {

        throwException(globalObject, scope, createRedefinedPrivateNameError(globalObject));

        RELEASE_AND_RETURN(scope, void());

    }

    EXCEPTION_ASSERT(!scope.exception());

    scope.release();

    putDirect(vm, propertyName, value, putSlot);

}

572644} // namespace JSC

Source/JavaScriptCore/runtime/JSScope.cpp

@@void JSScope::collectClosureVariablesUnderTDZ(JSScope* scope, VariableEnvironmen

        ConcurrentJSLocker locker(symbolTable->m_lock);

        for (auto end = symbolTable->end(locker), iter = symbolTable->begin(locker); iter != end; ++iter)

            result.add(iter->key);

        if (symbolTable->hasPrivateNames()) {

            for (auto name : symbolTable->privateNames())

                result.usePrivateName(name);    

        }

    }

}

Source/JavaScriptCore/runtime/OptionsList.h

@@constexpr bool enableWebAssemblyStreamingApi = false;

    v(Bool, usePublicClassFields, true, Normal, "If true, the parser will understand public data fields inside classes.") \

    v(Bool, useRandomizingExecutableIslandAllocation, false, Normal, "For the arm64 ExecutableAllocator, if true, select which region to use randomly. This is useful for testing that jump islands work.") \

    v(Bool, exposeProfilersOnGlobalObject, false, Normal, "If true, we will expose functions to enable/disable both the sampling profiler and the super sampler") \

513 v(Bool, usePrivateClassFields, false, Normal, "If true, the parser will understand private data fields inside classes.") \

enum OptionEquivalence {

    SameOption,

Source/JavaScriptCore/runtime/SymbolTable.cpp

@@SymbolTable* SymbolTable::cloneScopePart(VM& vm)

            for (; iter != end; ++iter)

                result->m_rareData->m_uniqueTypeSetMap.set(iter->key, iter->value);

        }

        {

            for (auto name : m_rareData->m_privateNames)

                result->m_rareData->m_privateNames.add(name);

        }

    }

    return result;

Source/JavaScriptCore/runtime/SymbolTable.h

#include "Watchpoint.h"

#include <memory>

#include <wtf/HashTraits.h>

41 #include <wtf/text/~~UniquedString~~Impl.h>

41#include <wtf/text/SymbolImpl.h>

namespace JSC {

@@public:

    typedef HashMap<RefPtr<UniquedStringImpl>, RefPtr<TypeSet>, IdentifierRepHash> UniqueTypeSetMap;

    typedef HashMap<VarOffset, RefPtr<UniquedStringImpl>> OffsetToVariableMap;

    typedef Vector<SymbolTableEntry*> LocalToEntryVec;

453 typedef HashSet<RefPtr<UniquedStringImpl>, IdentifierRepHash> PrivateNameSet;

454 typedef WTF::IteratorRange<typename PrivateNameSet::iterator> PrivateNameIteratorRange;

    template<typename CellType, SubspaceAccess>

    static IsoSubspace* subspaceFor(VM& vm)

@@public:

        ConcurrentJSLocker locker(m_lock);

        add(locker, key, std::forward<Entry>(entry));

    }

597

    bool hasPrivateNames() const { return m_rareData && m_rareData->m_privateNames.size(); }

    ALWAYS_INLINE PrivateNameIteratorRange privateNames()

    {

        // Use of the IteratorRange must be guarded to prevent ASSERT failures in checkValidity().

        ASSERT(hasPrivateNames());

        return makeIteratorRange(m_rareData->m_privateNames.begin(), m_rareData->m_privateNames.end());

    }

    void addPrivateName(UniquedStringImpl* key)

    {

        ASSERT(key && !key->isSymbol());

        if (!m_rareData)

            m_rareData = WTF::makeUnique<SymbolTableRareData>();

        ASSERT(!m_rareData->m_privateNames.contains(key));

        m_rareData->m_privateNames.add(key);

    }

    template<typename Entry>

    void set(const ConcurrentJSLocker&, UniquedStringImpl* key, Entry&& entry)

    {

@@private:

    ScopeOffset m_maxScopeOffset;

public:

    mutable ConcurrentJSLock m_lock;

private:

    unsigned m_usesNonStrictEval : 1;

    unsigned m_nestedLexicalScope : 1; // Non-function LexicalScope.

    unsigned m_scopeType : 3; // ScopeType

752

    struct SymbolTableRareData {

        WTF_MAKE_STRUCT_FAST_ALLOCATED;

        UniqueIDMap m_uniqueIDMap;

        OffsetToVariableMap m_offsetToVariableMap;

        UniqueTypeSetMap m_uniqueTypeSetMap;

        WriteBarrier<CodeBlock> m_codeBlock;

759 PrivateNameSet m_privateNames;

743760 };

private:

    unsigned m_usesNonStrictEval : 1;

    unsigned m_nestedLexicalScope : 1; // Non-function LexicalScope.

    unsigned m_scopeType : 3; // ScopeType

    std::unique_ptr<SymbolTableRareData> m_rareData;

    WriteBarrier<ScopedArgumentsTable> m_arguments;

JSTests/ChangeLog

2020-06-04  Caitlin Potter  <caitp@igalia.com>

        [JSC] Add support for private class fields

        https://bugs.webkit.org/show_bug.cgi?id=206431

        Reviewed by Saam Barati.

        Expands upon the earlier public fields patch, adding a number of private

        field tests.

        * stress/class-fields-private-as-function.js: Added.

        * stress/class-fields-private-cached-bytecode.js: Added.

        * stress/class-fields-private-freeze-out-of-line.js: Added.

        * stress/class-fields-private-freeze.js: Added.

        * stress/class-fields-private-on-proxy.js: Added.

        * stress/class-fields-private-out-of-line.js: Added.

        * stress/class-fields-private-prevent-extensions-out-of-line.js: Added.

        * stress/class-fields-private-prevent-extensions.js: Added.

        * stress/class-fields-private-seal-out-of-line.js: Added.

        * stress/class-fields-private-seal.js: Added.

        * stress/class-fields-private-use-eval.js: Added.

        * stress/class-fields-stress-instance.js:

        * stress/optional-chaining-and-private-fields.js: Added.

        * stress/private-name-access-in-computed-property.js: Added.

        * stress/put-by-val-direct-addprivate.js: Added.

        * stress/put-by-val-direct-putprivate.js: Added.

        * test262/config.yaml:

2020-06-04  Alexey Shvayka  <shvaikalesh@gmail.com>

        Update test262 to commit 290ceba31fea

JSTests/stress/class-fields-private-as-function.js

//@ requireOptions("--usePrivateClassFields=1")

function assert(a, e) {

    if (a !== e)

        throw new Error("Expected: " + e + " but got: " + a);

}

class C {

    #m = () => 25;

    method() {

        return this.#m();

    }

}

let c = new C();

assert(c.method(), 25);

JSTests/stress/class-fields-private-cached-bytecode.js

//@ runBytecodeCache("--usePrivateClassFields=true")

function assert(a, e) {

    if (a !== e)

        throw new Error("Expected: " + e + " but got: " + a);

}

class C {

    #f = 3;

    method() {

        return this.#f;

    }

}

let c = new C();

assert(c.method(), 3);

JSTests/stress/class-fields-private-freeze-out-of-line.js

//@ requireOptions("--usePrivateClassFields=1")

let assert = Object.assign(

  function assert(expr, message = "") {

    if (expr == false)

      throw new Error(`Expected ${message || "expr"} to be true, but was ${expr}`);

  }, {

  equals(a, b) {

    if (a === b || (a === a && b === b) || (a !== a && b !== b))

      return;

    throw new Error(`Expected ${a} to be ${b}`);

  }

});

// The base class is declared in eval specifically so that it can add enough

// properties to the class to store private fields in out-of-line property storage.

let Base = eval(`(class Base {

  // Methods

  constructor() {

    // Define properties

    ${Array(200).map((_, i) => `  this.x${i} = ${i};\n`).join("")}

  }

})`);

class PrivateFieldAfterPreventExtensions extends Base {

  #i = (Object.freeze(this), 42);

  #assert = (assert(Object.isFrozen(this), "Object.isFrozen(this)"), this.#i + 1);

  get() { return this.#i; }

  set(i) { this.#i = i; }

}

function test(i) {

  let c = new PrivateFieldAfterPreventExtensions;

  assert.equals(c.x150 === 150);

  c.x150 = 0.1;

  assert.equals(c.get(), 42);

  c.set(i);

  assert.equals(c.get(), i);

}

noInline(test);

test(0);

test(1);

test(2);

for (var i = 0; i < 200; ++i)

  test(i);

JSTests/stress/class-fields-private-freeze.js

//@ requireOptions("--usePrivateClassFields=1")

let assert = Object.assign(

  function assert(expr, message = "") {

    if (expr == false)

      throw new Error(`Expected ${message || "expr"} to be true, but was ${expr}`);

  }, {

  equals(a, b) {

    if (a === b || (a === a && b === b) || (a !== a && b !== b))

      return;

    throw new Error(`Expected ${a} to be ${b}`);

  }

});

class Base {

  constructor() {

    this.x = 1;

  }

}

class PrivateFieldAfterPreventExtensions extends Base {

  #i = (Object.freeze(this), 42);

  #assert = (assert(Object.isFrozen(this), "Object.isFrozen(this)"), this.#i + 1);

  get() { return this.#i; }

  set(i) { this.#i = i; }

}

function test(i) {

  let c = new PrivateFieldAfterPreventExtensions;

  c.x = 0.1;

  assert.equals(c.get(), 42);

  c.set(i);

  assert.equals(c.get(), i);

}

noInline(test);

test(0);

test(1);

test(2);

for (var i = 0; i < 200; ++i)

  test(i);

JSTests/stress/class-fields-private-on-proxy.js

//@ requireOptions("--usePrivateClassFields=1")

function assert(a, e, m) {

    if (a !== e)

        throw new Error(m);

}

function assertArrayContent(a, e) {

    assert(a.length, e.length, "Size of arrays doesn't match");

    for (var i = 0; i < a.length; i++)

        assert(a[i], e[i], "a[" + i + "] = " + a[i] + " but e[" + i + "] = " + e[i]);

}

let arr = [];

class ProxyBase {

    constructor() {

        return new Proxy(this, {

            get: function (obj, prop) {

                arr.push(prop);

                return obj[prop];

            }

        });

    }

}

class Test extends ProxyBase {

    #f = 3;

    method() {

        return this.#f;

    }

}

let t = new Test();

let r = t.method();

assert(r, 3, "Expected: 3 but got: " + r);

assertArrayContent(arr, ['method']);

JSTests/stress/class-fields-private-out-of-line.js

//@ requireOptions("--usePrivateClassFields=1")

function assert(a, e) {

    if (a !== e)

        throw new Error("Expected: " + e + " but got: " + a);

}

let klassSource = `

var C = class {

    assertOutOfLineValue() {

        assert(this.#f200, "foo");

    }

`;

for (let i = 0; i < 200; i++) {

    klassSource += "    #f" + i + ";\n";

}

klassSource += "    #f200 = \"foo\";\n}";

eval(klassSource);

for (let i = 0; i < 2; i++) {

    let c = new C();

    c.assertOutOfLineValue();

}

JSTests/stress/class-fields-private-prevent-extensions-out-of-line.js

//@ requireOptions("--usePrivateClassFields=1")

let assert = Object.assign(

  function assert(expr, message = "") {

    if (expr == false)

      throw new Error(`Expected ${message || "expr"} to be true, but was ${expr}`);

  }, {

  false(expr, message = "") {

    if (expr == true)

      throw new Error(`Expected ${message || "expr"} to be false, but was ${expr}`)

  },

  equals(a, b) {

    if (a === b || (a === a && b === b) || (a !== a && b !== b))

      return;

    throw new Error(`Expected ${a} to be ${b}`);

  }

});

// The base class is declared in eval specifically so that it can add enough

// properties to the class to store private fields in out-of-line property storage.

let Base = eval(`(class Base {

  // Methods

  constructor() {

    // Define properties

    ${Array(200).map((_, i) => `  this.x${i} = ${i};\n`).join("")}

  }

})`);

class PrivateFieldAfterPreventExtensions extends Base {

  #i = (Object.preventExtensions(this), 42);

  #assert = (assert.false(Object.isExtensible(this), "Object.isExtensible(this)"), this.#i + 1);

  get() { return this.#i; }

  set(i) { this.#i = i; }

}

function test(i) {

  let c = new PrivateFieldAfterPreventExtensions;

  assert.equals(c.x150 === 150);

  c.x150 = 0.1;

  assert.equals(c.get(), 42);

  c.set(i);

  assert.equals(c.get(), i);

}

noInline(test);

test(0);

test(1);

test(2);

for (var i = 0; i < 200; ++i)

  test(i);

JSTests/stress/class-fields-private-prevent-extensions.js

//@ requireOptions("--usePrivateClassFields=1")

let assert = Object.assign(

  function assert(expr, message = "") {

    if (expr == false)

      throw new Error(`Expected ${message || "expr"} to be true, but was ${expr}`);

  }, {

  false(expr, message = "") {

    if (expr == true)

      throw new Error(`Expected ${message || "expr"} to be false, but was ${expr}`)

  },

  equals(a, b) {

    if (a === b || (a === a && b === b) || (a !== a && b !== b))

      return;

    throw new Error(`Expected ${a} to be ${b}`);

  }

});

class Base {

  constructor() {

    this.x = 1;

  }

}

class PrivateFieldAfterPreventExtensions extends Base {

  #i = (Object.preventExtensions(this), 42);

  #assert = (assert.false(Object.isExtensible(this), "Object.isExtensible(this)"), this.#i + 1);

  get() { return this.#i; }

  set(i) { this.#i = i; }

}

function test(i) {

  let c = new PrivateFieldAfterPreventExtensions;

  c.x = 0.1;

  assert.equals(c.get(), 42);

  c.set(i);

  assert.equals(c.get(), i);

}

noInline(test);

test(0);

test(1);

test(2);

for (var i = 0; i < 200; ++i)

  test(i);

JSTests/stress/class-fields-private-seal-out-of-line.js

//@ requireOptions("--usePrivateClassFields=1")

let assert = Object.assign(

  function assert(expr, message = "") {

    if (expr == false)

      throw new Error(`Expected ${message || "expr"} to be true, but was ${expr}`);

  }, {

  false(expr, message = "") {

    if (expr == true)

      throw new Error(`Expected ${message || "expr"} to be false, but was ${expr}`)

  },

  equals(a, b) {

    if (a === b || (a === a && b === b) || (a !== a && b !== b))

      return;

    throw new Error(`Expected ${a} to be ${b}`);

  }

});

// The base class is declared in eval specifically so that it can add enough

// properties to the class to store private fields in out-of-line property storage.

let Base = eval(`(class Base {

  // Methods

  constructor() {

    // Define properties

    ${Array(200).map((_, i) => `  this.x${i} = ${i};\n`).join("")}

  }

})`);

class PrivateFieldAfterPreventExtensions extends Base {

  #i = (Object.seal(this), 42);

  #assert = (assert(Object.isSealed(this), "Object.isSealed(this)"), this.#i + 1);

  get() { return this.#i; }

  set(i) { this.#i = i; }

}

function test(i) {

  let c = new PrivateFieldAfterPreventExtensions;

  assert.equals(c.x150 === 150);

  c.x150 = 0.1;

  assert.equals(c.get(), 42);

  c.set(i);

  assert.equals(c.get(), i);

}

noInline(test);

test(0);

test(1);

test(2);

for (var i = 0; i < 200; ++i)

  test(i);

JSTests/stress/class-fields-private-seal.js

//@ requireOptions("--usePrivateClassFields=1")

let assert = Object.assign(

  function assert(expr, message = "") {

    if (expr == false)

      throw new Error(`Expected ${message || "expr"} to be true, but was ${expr}`);

  }, {

  equals(a, b) {

    if (a === b || (a === a && b === b) || (a !== a && b !== b))

      return;

    throw new Error(`Expected ${a} to be ${b}`);

  }

});

class Base {

  constructor() {

    this.x = 1;

  }

}

class PrivateFieldAfterPreventExtensions extends Base {

  #i = (Object.seal(this), 42);

  #assert = (assert(Object.isSealed(this), "Object.isSealed(this)"), this.#i + 1);

  get() { return this.#i; }

  set(i) { this.#i = i; }

}

function test(i) {

  let c = new PrivateFieldAfterPreventExtensions;

  c.x = 0.1;

  assert.equals(c.get(), 42);

  c.set(i);

  assert.equals(c.get(), i);

}

noInline(test);

test(0);

test(1);

test(2);

for (var i = 0; i < 200; ++i)

  test(i);

JSTests/stress/class-fields-private-use-eval.js

//@ requireOptions("--usePrivateClassFields=1", "--usePublicClassFields=1")

function assert(a, message) {

    if (!a)

        throw new Error(message);

}

let inst = new class {

  a = eval("(i) => i.#b");

  #b = {};

};

inst.a(inst).x = 1;

assert(inst.a(inst).x == 1);

JSTests/stress/class-fields-stress-instance.js

1 //@ requireOptions("--usePublicClassFields=true")

1//@ requireOptions("--usePublicClassFields=true", "--usePrivateClassFields=true")

class A {

    a = 0;

    b = 1;

6 #c = 0;

7 #d = 1;

68 e = function () { return 0; };

9 #f = function() { return 1; };

710 ["g"] = 0;

811 h = eval("true");

12 #i = eval("false");

}

for (var i = 0; i < 10000; i++)

JSTests/stress/optional-chaining-and-private-fields.js

//@ requireOptions("--usePrivateClassFields=true")

let assert = {

    sameValue: (a, e) => {

        if (a !== e) 

            throw new Error("Expected: " + e + " but got: " + a);

    },

    throws: (expectedException, functor, m) => {

        try {

            functor();

        } catch(e) {

            if (!(e instanceof expectedException))

                throw new Error(m);

        }

    }

};

(() => {

    class C {

        #field = 'test';

        static access(o) {

            return o?.#field;

        }

    }

    let c = new C;

    for (let i = 0; i < 100000; i++) {

        assert.sameValue(C.access(c), 'test');

        assert.sameValue(C.access(undefined), undefined);

        assert.sameValue(C.access(null), undefined);

    }

    assert.throws(TypeError, () => {

        C.access({});

    }, "Object without private field should throw");

})();

// Chained case

(() => {

    class C {

        #field = 'test';

        static chainedAccess(o) {

            return o.private?.#field;

        }

    }

    let c = new C;

    let o = {private: c};

    for (let i = 0; i < 100000; i++) {

        assert.sameValue(C.chainedAccess(o), 'test');

        assert.sameValue(C.chainedAccess({}), undefined);

        assert.sameValue(C.chainedAccess({private: null}), undefined);

    }

    assert.throws(TypeError, () => {

        o.private = {};

        C.chainedAccess(o);

    }, "Object without private field should throw");

})();

(() => {

    class C {

        #field;

        setField(v) {

            this.#field = v;

        }

        static access(o) {

            return o.#field?.property;

        }

    }

    let c = new C;

    for (let i = 0; i < 100000; i++) {

        c.setField({property: 'test'});

        assert.sameValue(C.access(c), 'test');

        c.setField(undefined);

        assert.sameValue(C.access(c), undefined);

        c.setField(null);

        assert.sameValue(C.access(c), undefined);

    }

    assert.throws(TypeError, () => {

        C.access({});

    }, "Object without private field should throw");

})();

JSTests/stress/private-name-access-in-computed-property.js

//@ requireOptions("--usePublicClassFields=1", "--usePrivateClassFields=1")

let assert = {

    throws: (expectedError, functor) => {

        try {

            functor();

        } catch(e) {

            if (!(e instanceof expectedError))

                throw new Error("Expected to throw: " + expectedError.name + " but throws: " + e.name);

        }

    }

}

assert.throws(TypeError, () => {

    class Base {

        [{}.#x] = 1; 

        #x = "foo";

    }

});

JSTests/stress/put-by-val-direct-addprivate.js

// TODO: //@ requireOptions("--usePrivateClassFields=1") -- Currently, eager JIT is not supported for private field access.

//@ runDefault("--usePrivateClassFields=1")

//@ runNoJIT("--usePrivateClassFields=1")

//@ runNoLLInt("--usePrivateClassFields=1")

// PrivateField "Create" access should throw if writing to a non-existent PrivateName.

let c, i = 0, threw = false;

class C {

    constructor() {

        return i < 29 ? this : c;

    }

}

class CC extends C {

    #x = i++;

    x() { return this.#x; }

}

c = new CC;

try {

    for (let j = 1; j < 50; ++j) {

        let x = new CC;

        if (x.x() !== j)

            throw new Error(`Expected x.x() to be ${j}, but found ${x.x()}`);

    }

} catch (e) {

    threw = true;

    if (i !== 30 || e.constructor !== TypeError) {

        throw e;

    }

}

if (!threw)

    throw new Error("Expected TypeError, but no exception was thrown");

JSTests/stress/put-by-val-direct-putprivate.js

// FIXME: //@ requireOptions("--usePrivateClassFields=1") -- Currently, eager JIT is not supported for private field access. https://bugs.webkit.org/show_bug.cgi?id=212784

//@ runDefault("--usePrivateClassFields=1")

//@ runNoJIT("--usePrivateClassFields=1")

//@ runNoLLInt("--usePrivateClassFields=1")

// PrivateField "Put" access should throw if writing to a non-existent PrivateName.

let c, i = 0, threw = false;

class C {

    #x;

    constructor() { return i < 30 ? this : { [Symbol.toStringTag]: "without #x" }; }

    static x(obj) { return obj.#x = i++; }

    get [Symbol.toStringTag]() { return "with #x" }

}

try {

    for (let j = 0; j < 50; ++j) {

        let obj = new C;

        let result = C.x(obj);

        if (result !== j)

            throw new Error(`Expected C.x(${obj}) to be ${j}, but found ${result}`);

    }

} catch (e) {

    threw = true;

    // rval of AssignmentExpression is evaluated before PrivateFieldFind(#x, lref) is performed,

    // thus `i` has already been incremented.

    if (i !== 31 || e.constructor !== TypeError) {

        throw e;

    }

}

if (!threw)

    throw new Error("Expected TypeError, but no exception was thrown");

JSTests/test262/config.yaml

@@flags:

  Intl.RelativeTimeFormat: useIntlRelativeTimeFormat

  WeakRef: useWeakRefs

  class-fields-public: usePublicClassFields

9 class-fields-private: usePrivateClassFields

skip:

  features:

    - SharedArrayBuffer

@@skip:

    # https://bugs.webkit.org/show_bug.cgi?id=174931

    - regexp-lookbehind

17 - class-fields-private

    - class-methods-private

    - class-static-fields-public

    - class-static-fields-private