function assert(b) {

if (!b) throw new Error;

function shouldThrowTypeError(func) {

let error;

try {

func();

} catch (e) {

error = e;

}

if (!(error instanceof TypeError))

throw new Error('Expected TypeError!');

class F { #x; static isF(obj) { return #x in obj; } }

class SF { static #x; static isSF(obj) { return #x in obj; } }

class M { #x() {} static isM(obj) { return #x in obj; } }

class SM { static #x() {} static isSM(obj) { return #x in obj; } }

class G { get #x() {} static isG(obj) { return #x in obj; } }

class SG { static get #x() {} static isSG(obj) { return #x in obj; } }

class S { set #x(v) {} static isS(obj) { return #x in obj; } }

class SS { static set #x(v) {} static isSS(obj) { return #x in obj; } }

function test() {

assert(F.isF(new F));

assert(!F.isF(F) && !F.isF(new M) && !F.isF({}));

shouldThrowTypeError(() => F.isF(3));

assert(SF.isSF(SF));

assert(!SF.isSF(new SF) && !SF.isSF(SM) && !SF.isSF({}));

shouldThrowTypeError(() => SF.isSF(3));

assert(M.isM(new M));

assert(!M.isM(M) && !M.isM(new F) && !M.isM({}));

shouldThrowTypeError(() => M.isM(3));

assert(SM.isSM(SM));

assert(!SM.isSM(new SM) && !SM.isSM(SF) && !SM.isSM({}));

shouldThrowTypeError(() => SM.isSM(3));

assert(G.isG(new G));

assert(!G.isG(G) && !G.isG(new F) && !G.isG({}));

shouldThrowTypeError(() => G.isG(3));

assert(SG.isSG(SG));

assert(!SG.isSG(new SG) && !SG.isSG(SF) && !SG.isSG({}));

shouldThrowTypeError(() => SG.isSG(3));

assert(S.isS(new S));

assert(!S.isS(S) && !S.isS(new F) && !S.isS({}));

shouldThrowTypeError(() => S.isS(3));

assert(SS.isSS(SS));

assert(!SS.isSS(new SS) && !SS.isSS(SF) && !SS.isSS({}));

shouldThrowTypeError(() => SS.isSS(3));

for (let i = 0; i < 10000; i++)

test();

class-fields-private-in: usePrivateIn

2021-05-22 Ross Kirsling <ross.kirsling@sony.com>

Support Ergonomic Brand Checks proposal (`#x in obj`)

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

Reviewed by Caio Araujo Neponoceno de Lima.

This patch implements the following Stage 3 proposal (behind a runtime option):

https://github.com/tc39/proposal-private-fields-in-in

Specifically, it extends the `in` keyword to allow the LHS to be a private name,

thereby allowing users to implement Array.isArray-esque brand checks for their own classes

*without* having to wrap a private member get in a try-catch.

For example:

```

class C {

#x;

static isC(obj) { return #x in obj; }

}

```

This is done by adding two new bytecode ops, HasPrivateName and HasPrivateBrand. For the moment,

these are implemented without fast paths, as we should do so for InByVal first and then have these follow suit.

* bytecode/BytecodeList.rb:

* bytecode/BytecodeUseDef.cpp:

(JSC::computeUsesForBytecodeIndexImpl):

(JSC::computeDefsForBytecodeIndexImpl):

* bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::emitHasPrivateName):

(JSC::BytecodeGenerator::emitHasPrivateBrand):

(JSC::BytecodeGenerator::emitCheckPrivateBrand):

* bytecompiler/BytecodeGenerator.h:

* bytecompiler/NodesCodegen.cpp:

(JSC::InNode::emitBytecode):

* dfg/DFGAbstractInterpreterInlines.h:

(JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):

* dfg/DFGByteCodeParser.cpp:

(JSC::DFG::ByteCodeParser::parseBlock):

* dfg/DFGCapabilities.cpp:

(JSC::DFG::capabilityLevel):

* dfg/DFGClobberize.h:

(JSC::DFG::clobberize):

* dfg/DFGDoesGC.cpp:

(JSC::DFG::doesGC):

* dfg/DFGFixupPhase.cpp:

(JSC::DFG::FixupPhase::fixupNode):

* dfg/DFGNodeType.h:

* dfg/DFGPredictionPropagationPhase.cpp:

* dfg/DFGSafeToExecute.h:

(JSC::DFG::safeToExecute):

* dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::compileHasPrivateName):

(JSC::DFG::SpeculativeJIT::compileHasPrivateBrand):

* dfg/DFGSpeculativeJIT.h:

* dfg/DFGSpeculativeJIT32_64.cpp:

(JSC::DFG::SpeculativeJIT::compile):

* dfg/DFGSpeculativeJIT64.cpp:

(JSC::DFG::SpeculativeJIT::compile):

* ftl/FTLCapabilities.cpp:

(JSC::FTL::canCompile):

* ftl/FTLLowerDFGToB3.cpp:

(JSC::FTL::DFG::LowerDFGToB3::compileNode):

(JSC::FTL::DFG::LowerDFGToB3::compileHasPrivateName):

(JSC::FTL::DFG::LowerDFGToB3::compileHasPrivateBrand):

* jit/JIT.cpp:

(JSC::JIT::privateCompileMainPass):

* jit/JITOperations.cpp:

(JSC::JSC_DEFINE_JIT_OPERATION):

* jit/JITOperations.h:

* llint/LowLevelInterpreter.asm:

* parser/ASTBuilder.h:

(JSC::ASTBuilder::createPrivateIdentifierNode):

* parser/NodeConstructors.h:

(JSC::PrivateIdentifierNode::PrivateIdentifierNode):

* parser/Nodes.h:

(JSC::ExpressionNode::isPrivateIdentifier const):

* parser/Parser.cpp:

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

* parser/SyntaxChecker.h:

(JSC::SyntaxChecker::createPrivateIdentifierNode):

* parser/VariableEnvironment.h:

* runtime/CommonSlowPaths.cpp:

(JSC::JSC_DEFINE_COMMON_SLOW_PATH):

* runtime/CommonSlowPaths.h:

* runtime/JSObject.h:

* runtime/JSObjectInlines.h:

(JSC::JSObject::hasPrivateField):

(JSC::JSObject::hasPrivateBrand):

(JSC::JSObject::checkPrivateBrand):

* runtime/OptionsList.h:

op :has_private_name,

args: {

dst: VirtualRegister,

base: VirtualRegister,

property: VirtualRegister,

}

op :has_private_brand,

args: {

dst: VirtualRegister,

base: VirtualRegister,

brand: VirtualRegister,

}

USES(OpHasPrivateName, base, property)

USES(OpHasPrivateBrand, base, brand)

DEFS(OpHasPrivateName, dst)

DEFS(OpHasPrivateBrand, dst)

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

{

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

return dst;

}

RegisterID* BytecodeGenerator::emitHasPrivateBrand(RegisterID* dst, RegisterID* base, RegisterID* brand, bool isStatic)

{

if (isStatic) {

Ref<Label> isObjectLabel = newLabel();

emitJumpIfTrue(emitIsObject(newTemporary(), base), isObjectLabel.get());

emitThrowTypeError("Cannot access static private method or accessor of a non-Object");

emitLabel(isObjectLabel.get());

emitEqualityOp<OpStricteq>(dst, base, brand);

} else

OpHasPrivateBrand::emit(this, dst, base, brand);

return dst;

}

emitThrowTypeError("Cannot access static private method or accessor");

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

RegisterID* emitHasPrivateBrand(RegisterID* dst, RegisterID* base, RegisterID* brand, bool isStatic);

if (m_expr1->isPrivateIdentifier()) {

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

auto identifier = static_cast<PrivateIdentifierNode*>(m_expr1)->value();

auto privateTraits = generator.getPrivateTraits(identifier);

Variable var = generator.variable(identifier);

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

if (privateTraits.isField()) {

RefPtr<RegisterID> privateName = generator.emitGetFromScope(generator.newTemporary(), scope.get(), var, DoNotThrowIfNotFound);

return generator.emitHasPrivateName(generator.finalDestination(dst, base.get()), base.get(), privateName.get());

}

ASSERT(privateTraits.isPrivateMethodOrAccessor());

RefPtr<RegisterID> privateBrand = generator.emitGetPrivateBrand(generator.newTemporary(), scope.get(), privateTraits.isStatic());

return generator.emitHasPrivateBrand(generator.finalDestination(dst, base.get()), base.get(), privateBrand.get(), privateTraits.isStatic());

}

case HasPrivateName:

case HasPrivateBrand: {

clobberWorld();

filter(node->child1(), SpecObject);

filter(node->child2(), SpecSymbol);

setNonCellTypeForNode(node, SpecBoolean);

break;

}