if (IsLiteral()) return true;

MaterializedLiteral* literal = AsMaterializedLiteral();

if (literal == nullptr) return false;

return literal->IsSimple();

if (IsLiteral() && AsLiteral()->type() == Literal::kUndefined) return true;

const VariableProxy* var_proxy = AsVariableProxy();

if (var_proxy == nullptr) return false;

Variable* var = var_proxy->var();

// The global identifier "undefined" is immutable. Everything

// else could be reassigned.

return var != nullptr && var->IsUnallocated() &&

var_proxy->raw_name()->IsOneByteEqualTo("undefined");

return (IsFunctionLiteral() &&

AsFunctionLiteral()->IsAnonymousFunctionDefinition()) ||

(IsClassLiteral() &&

AsClassLiteral()->IsAnonymousFunctionDefinition());

: Expression(start_position, kVariableProxy),

raw_name_(var->raw_name()),

next_unresolved_(nullptr) {

DCHECK(!var->is_this());

bit_field_ |= IsAssignedField::encode(false) |

IsResolvedField::encode(false) |

HoleCheckModeField::encode(HoleCheckMode::kElided);

BindTo(var);

: Expression(copy_from->position(), kVariableProxy),

next_unresolved_(nullptr) {

bit_field_ = copy_from->bit_field_;

DCHECK(!copy_from->is_resolved());

raw_name_ = copy_from->raw_name_;

DCHECK_EQ(raw_name(), var->raw_name());

set_var(var);

set_is_resolved();

var->set_is_used();

if (is_assigned()) var->SetMaybeAssigned();

Expression* value, int pos)

: Expression(pos, node_type), target_(target), value_(value) {

bit_field_ |= TokenField::encode(op);

DCHECK_NOT_NULL(raw_inferred_name);

DCHECK(shared_function_info_.is_null());

raw_inferred_name_ = raw_inferred_name;

scope()->set_has_inferred_function_name(true);

if (raw_inferred_name_ != nullptr) {

return raw_inferred_name_->GetString(isolate);

}

DCHECK(!shared_function_info_.is_null());

return handle(shared_function_info_->inferred_name(), isolate);

Handle<SharedFunctionInfo> shared_function_info) {

DCHECK(shared_function_info_.is_null());

CHECK_EQ(shared_function_info->function_literal_id(), function_literal_id_);

shared_function_info_ = shared_function_info;

const AstConsString* cons_string;

if (raw_name_ != nullptr && !raw_name_->IsEmpty()) {

cons_string = raw_name_;

} else if (raw_inferred_name_ != nullptr && !raw_inferred_name_->IsEmpty()) {

cons_string = raw_inferred_name_;

} else if (!shared_function_info_.is_null()) {

return shared_function_info_->inferred_name()->ToCString();

} else {

char* empty_str = new char[1];

empty_str[0] = 0;

return std::unique_ptr<char[]>(empty_str);

}

// TODO(rmcilroy): Deal with two-character strings.

std::vector<char> result_vec;

std::forward_list<const AstRawString*> strings = cons_string->ToRawStrings();

for (const AstRawString* string : strings) {

if (!string->is_one_byte()) break;

for (int i = 0; i < string->length(); i++) {

result_vec.push_back(string->raw_data()[i]);

}

}

std::unique_ptr<char[]> result(new char[result_vec.size() + 1]);

if (result_vec.size()) {

memcpy(result.get(), result_vec.data(), result_vec.size());

}

result[result_vec.size()] = '\0';

return result;

Kind kind, bool is_computed_name)

: LiteralProperty(key, value, is_computed_name),

kind_(kind),

Expression* key, Expression* value,

bool is_computed_name)

: LiteralProperty(key, value, is_computed_name), emit_store_(true) {

if (!is_computed_name && key->AsLiteral()->IsRawString() &&

key->AsLiteral()->AsRawString() == ast_value_factory->proto_string()) {

kind_ = PROTOTYPE;

} else if (value_->AsMaterializedLiteral() != nullptr) {

kind_ = MATERIALIZED_LITERAL;

} else if (value_->IsLiteral()) {

kind_ = CONSTANT;

} else {

kind_ = COMPUTED;

}

return is_computed_name() && (value_->IsAnonymousFunctionDefinition() ||

value_->IsConciseMethodDefinition() ||

value_->IsAccessorFunctionDefinition());

Kind kind, bool is_static,

bool is_computed_name,

bool is_private)

: LiteralProperty(key, value, is_computed_name),

kind_(kind),

is_static_(is_static),

is_private_(is_private),

AutoAccessorInfo* info,

bool is_static,

bool is_computed_name,

bool is_private)

: LiteralProperty(key, value, is_computed_name),

kind_(Kind::AUTO_ACCESSOR),

is_static_(is_static),

is_private_(is_private),

auto_accessor_info_(info) {

DCHECK_NOT_NULL(info);

const auto GETTER = ObjectLiteral::Property::GETTER;

const auto SETTER = ObjectLiteral::Property::SETTER;

CustomMatcherZoneHashMap table(Literal::Match,

ZoneHashMap::kDefaultHashMapCapacity,

ZoneAllocationPolicy(zone));

for (int i = properties()->length() - 1; i >= 0; i--) {

ObjectLiteral::Property* property = properties()->at(i);

if (property->is_computed_name()) continue;

if (property->IsPrototype()) continue;

Literal* literal = property->key()->AsLiteral();

DCHECK(!literal->IsNullLiteral());

uint32_t hash = literal->Hash();

ZoneHashMap::Entry* entry = table.LookupOrInsert(literal, hash);

if (entry->value == nullptr) {

entry->value = property;

} else {

// We already have a later definition of this property, so we don't need

// to emit a store for the current one.

//

// There are two subtleties here.

//

// (1) Emitting a store might actually be incorrect. For example, in {get

// foo() {}, foo: 42}, the getter store would override the data property

// (which, being a non-computed compile-time valued property, is already

// part of the initial literal object.

//

// (2) If the later definition is an accessor (say, a getter), and the

// current definition is a complementary accessor (here, a setter), then

// we still must emit a store for the current definition.

auto later_kind =

static_cast<ObjectLiteral::Property*>(entry->value)->kind();

bool complementary_accessors =

(property->kind() == GETTER && later_kind == SETTER) ||

(property->kind() == SETTER && later_kind == GETTER);

if (!complementary_accessors) {

property->set_emit_store(false);

if (later_kind == GETTER || later_kind == SETTER) {

entry->value = property;

}

}

}

}

int flags = LiteralBoilerplateBuilder::ComputeFlags(disable_mementos);

if (fast_elements()) flags |= ObjectLiteral::kFastElements;

if (has_null_prototype()) flags |= ObjectLiteral::kHasNullPrototype;

return flags;

// We still check for __proto__:null after computed property names.

for (; i < properties()->length(); i++) {

if (properties()->at(i)->IsNullPrototype()) {

set_has_null_protoype(true);

break;

}

}

int flags = AggregateLiteral::kNoFlags;

if (fast_elements()) flags |= ObjectLiteral::kFastElements;

if (has_null_prototype()) flags |= ObjectLiteral::kHasNullPrototype;

return flags;

if (is_initialized()) return;

bool is_simple = true;

bool has_seen_prototype = false;

bool needs_initial_allocation_site = false;

DepthKind depth_acc = kShallow;

uint32_t nof_properties = 0;

uint32_t elements = 0;

uint32_t max_element_index = 0;

for (int i = 0; i < properties()->length(); i++) {

ObjectLiteral::Property* property = properties()->at(i);

if (property->IsPrototype()) {

has_seen_prototype = true;

// __proto__:null has no side-effects and is set directly on the

// boilerplate.

if (property->IsNullPrototype()) {

set_has_null_protoype(true);

continue;

}

DCHECK(!has_null_prototype());

is_simple = false;

continue;

}

if (nof_properties == boilerplate_properties_) {

DCHECK(property->is_computed_name());

is_simple = false;

if (!has_seen_prototype) InitFlagsForPendingNullPrototype(i);

break;

}

DCHECK(!property->is_computed_name());

MaterializedLiteral* literal = property->value()->AsMaterializedLiteral();

if (literal != nullptr) {

LiteralBoilerplateBuilder::InitDepthAndFlags(literal);

depth_acc = kNotShallow;

needs_initial_allocation_site |= literal->NeedsInitialAllocationSite();

}

Literal* key = property->key()->AsLiteral();

Expression* value = property->value();

bool is_compile_time_value = value->IsCompileTimeValue();

is_simple = is_simple && is_compile_time_value;

// Keep track of the number of elements in the object literal and

// the largest element index. If the largest element index is

// much larger than the number of elements, creating an object

// literal with fast elements will be a waste of space.

uint32_t element_index = 0;

if (key->AsArrayIndex(&element_index)) {

max_element_index = std::max(element_index, max_element_index);

elements++;

} else {

DCHECK(key->IsPropertyName());

}

nof_properties++;

}

set_depth(depth_acc);

set_is_simple(is_simple);

set_needs_initial_allocation_site(needs_initial_allocation_site);

set_has_elements(elements > 0);

set_fast_elements((max_element_index <= 32) ||

((2 * elements) >= max_element_index));

IsolateT* isolate) {

if (!boilerplate_description_.is_null()) return;

int index_keys = 0;

bool has_seen_proto = false;

for (int i = 0; i < properties()->length(); i++) {

ObjectLiteral::Property* property = properties()->at(i);

if (property->IsPrototype()) {

has_seen_proto = true;

continue;

}

if (property->is_computed_name()) continue;

Literal* key = property->key()->AsLiteral();

if (!key->IsPropertyName()) index_keys++;

}

Handle<ObjectBoilerplateDescription> boilerplate_description =

isolate->factory()->NewObjectBoilerplateDescription(

boilerplate_properties_, properties()->length(), index_keys,

has_seen_proto);

int position = 0;

for (int i = 0; i < properties()->length(); i++) {

ObjectLiteral::Property* property = properties()->at(i);

if (property->IsPrototype()) continue;

if (static_cast<uint32_t>(position) == boilerplate_properties_) {

DCHECK(property->is_computed_name());

break;

}

DCHECK(!property->is_computed_name());

MaterializedLiteral* m_literal = property->value()->AsMaterializedLiteral();

if (m_literal != nullptr) {

BuildConstants(isolate, m_literal);

}

// Add CONSTANT and COMPUTED properties to boilerplate. Use the

// 'uninitialized' Oddball for COMPUTED properties, the real value is filled

// in at runtime. The enumeration order is maintained.

Literal* key_literal = property->key()->AsLiteral();

uint32_t element_index = 0;

DirectHandle<Object> key =

key_literal->AsArrayIndex(&element_index)

? isolate->factory()

->template NewNumberFromUint<AllocationType::kOld>(

element_index)

: Cast<Object>(key_literal->AsRawPropertyName()->string());

DirectHandle<Object> value =

GetBoilerplateValue(property->value(), isolate);

boilerplate_description->set_key_value(position++, *key, *value);

}

boilerplate_description->set_flags(EncodeLiteralType());

boilerplate_description_ = boilerplate_description;

// The CreateShallowObjectLiteratal builtin doesn't copy elements, and object

// literals don't support copy-on-write (COW) elements for now.

// TODO(mvstanton): make object literals support COW elements.

return fast_elements() && is_shallow() &&

properties_count() <=

ConstructorBuiltins::kMaximumClonedShallowObjectProperties;

Expression* expression, IsolateT* isolate) {

if (expression->IsLiteral()) {

return expression->AsLiteral()->BuildValue(isolate);

}

if (expression->IsCompileTimeValue()) {

if (expression->IsObjectLiteral()) {

ObjectLiteral* object_literal = expression->AsObjectLiteral();

DCHECK(object_literal->builder()->is_simple());

return object_literal->builder()->boilerplate_description();

} else {

DCHECK(expression->IsArrayLiteral());

ArrayLiteral* array_literal = expression->AsArrayLiteral();

DCHECK(array_literal->builder()->is_simple());

return array_literal->builder()->boilerplate_description();

}

}

return isolate->factory()->uninitialized_value();

if (is_initialized()) return;

int constants_length =

first_spread_index_ >= 0 ? first_spread_index_ : values_->length();

// Fill in the literals.

bool is_simple = first_spread_index_ < 0;

bool is_holey = false;

ElementsKind kind = FIRST_FAST_ELEMENTS_KIND;

DepthKind depth_acc = kShallow;

int array_index = 0;

for (; array_index < constants_length; array_index++) {

Expression* element = values_->at(array_index);

MaterializedLiteral* materialized_literal =

element->AsMaterializedLiteral();

if (materialized_literal != nullptr) {

LiteralBoilerplateBuilder::InitDepthAndFlags(materialized_literal);

depth_acc = kNotShallow;

}

if (!element->IsCompileTimeValue()) {

is_simple = false;

// Don't change kind here: non-compile time values resolve to an unknown

// elements kind, so we allow them to be considered as any one of them.

// TODO(leszeks): It would be nice to DCHECK here that GetBoilerplateValue

// will return IsUninitialized, but that would require being on the main

// thread which we may not be.

} else {

Literal* literal = element->AsLiteral();

if (!literal) {

// Only arrays and objects are compile-time values but not (primitive)

// literals.

DCHECK(element->IsObjectLiteral() || element->IsArrayLiteral());

kind = PACKED_ELEMENTS;

} else {

switch (literal->type()) {

case Literal::kTheHole:

is_holey = true;

// The hole is allowed in holey double arrays (and holey Smi

// arrays), so ignore it as far as is_all_number is concerned.

break;

case Literal::kHeapNumber:

if (kind == PACKED_SMI_ELEMENTS) kind = PACKED_DOUBLE_ELEMENTS;

DCHECK_EQ(kind,

GetMoreGeneralElementsKind(kind, PACKED_DOUBLE_ELEMENTS));

break;

case Literal::kSmi:

DCHECK_EQ(kind,

GetMoreGeneralElementsKind(kind, PACKED_SMI_ELEMENTS));

break;

case Literal::kBigInt:

case Literal::kString:

case Literal::kConsString:

case Literal::kBoolean:

case Literal::kUndefined:

case Literal::kNull:

kind = PACKED_ELEMENTS;

break;

}

}

}

}

if (is_holey) {

kind = GetHoleyElementsKind(kind);

}

set_depth(depth_acc);

set_is_simple(is_simple);

set_boilerplate_descriptor_kind(kind);

// Array literals always need an initial allocation site to properly track

// elements transitions.

set_needs_initial_allocation_site(true);

IsolateT* isolate) {

if (!boilerplate_description_.is_null()) return;

int constants_length =

first_spread_index_ >= 0 ? first_spread_index_ : values_->length();

ElementsKind kind = boilerplate_descriptor_kind();

bool use_doubles = IsDoubleElementsKind(kind);

DirectHandle<FixedArrayBase> elements;

if (use_doubles) {

elements = isolate->factory()->NewFixedDoubleArray(constants_length,

AllocationType::kOld);

} else {

elements = isolate->factory()->NewFixedArrayWithHoles(constants_length,

AllocationType::kOld);

}

// Fill in the literals.

int array_index = 0;

for (; array_index < constants_length; array_index++) {

Expression* element = values_->at(array_index);

DCHECK(!element->IsSpread());

if (use_doubles) {

Literal* literal = element->AsLiteral();

if (literal && literal->type() == Literal::kTheHole) {

DCHECK(IsHoleyElementsKind(kind));

DCHECK(IsTheHole(*GetBoilerplateValue(element, isolate), isolate));

Cast<FixedDoubleArray>(*elements)->set_the_hole(array_index);

continue;

} else if (literal && literal->IsNumber()) {

Cast<FixedDoubleArray>(*elements)->set(array_index,

literal->AsNumber());

} else {

DCHECK(

IsUninitialized(*GetBoilerplateValue(element, isolate), isolate));

Cast<FixedDoubleArray>(*elements)->set(array_index, 0);

}

} else {

MaterializedLiteral* m_literal = element->AsMaterializedLiteral();

if (m_literal != nullptr) {

BuildConstants(isolate, m_literal);

}

// New handle scope here, needs to be after BuildConstants().

typename IsolateT::HandleScopeType scope(isolate);

Tagged<Object> boilerplate_value = *GetBoilerplateValue(element, isolate);

// We shouldn't allocate after creating the boilerplate value.

DisallowGarbageCollection no_gc;

if (IsTheHole(boilerplate_value, isolate)) {

DCHECK(IsHoleyElementsKind(kind));

continue;

}

if (IsUninitialized(boilerplate_value, isolate)) {

boilerplate_value = Smi::zero();

}

DCHECK_EQ(kind, GetMoreGeneralElementsKind(

kind, Object::OptimalElementsKind(

boilerplate_value,

GetPtrComprCageBase(*elements))));

Cast<FixedArray>(*elements)->set(array_index, boilerplate_value);

}

} // namespace internal

// Simple and shallow arrays can be lazily copied, we transform the

// elements array to a copy-on-write array.

if (is_simple() && depth() == kShallow && array_index > 0 &&

IsSmiOrObjectElementsKind(kind)) {

elements->set_map_safe_transition(

isolate, ReadOnlyRoots(isolate).fixed_cow_array_map(), kReleaseStore);

}

boilerplate_description_ =

isolate->factory()->NewArrayBoilerplateDescription(kind, elements);

return depth() <= kShallow &&

values_->length() <=

ConstructorBuiltins::kMaximumClonedShallowArrayElements;

if (IsArrayLiteral()) return AsArrayLiteral()->builder()->is_simple();

if (IsObjectLiteral()) return AsObjectLiteral()->builder()->is_simple();

DCHECK(IsRegExpLiteral());

return false;

if (expr->IsArrayLiteral()) {

return expr->AsArrayLiteral()->builder()->InitDepthAndFlags();

}

if (expr->IsObjectLiteral()) {

return expr->AsObjectLiteral()->builder()->InitDepthAndFlags();

}

DCHECK(expr->IsRegExpLiteral());

) {

if (IsArrayLiteral()) {

return AsArrayLiteral()->builder()->needs_initial_allocation_site();

}

if (IsObjectLiteral()) {

return AsObjectLiteral()->builder()->needs_initial_allocation_site();

}

DCHECK(IsRegExpLiteral());

return false;

MaterializedLiteral* expr) {

if (expr->IsArrayLiteral()) {

expr->AsArrayLiteral()->builder()->BuildBoilerplateDescription(isolate);

return;

}

if (expr->IsObjectLiteral()) {

expr->AsObjectLiteral()->builder()->BuildBoilerplateDescription(isolate);

return;

}

DCHECK(expr->IsRegExpLiteral());

IsolateT* isolate) {

DirectHandle<FixedArray> raw_strings_handle =

isolate->factory()->NewFixedArray(this->raw_strings()->length(),

AllocationType::kOld);

bool raw_and_cooked_match = true;

{

DisallowGarbageCollection no_gc;

Tagged<FixedArray> raw_strings = *raw_strings_handle;

for (int i = 0; i < raw_strings->length(); ++i) {

if (this->raw_strings()->at(i) != this->cooked_strings()->at(i)) {

// If the AstRawStrings don't match, then neither should the allocated

// Strings, since the AstValueFactory should have deduplicated them

// already.

DCHECK_IMPLIES(this->cooked_strings()->at(i) != nullptr,

*this->cooked_strings()->at(i)->string() !=

*this->raw_strings()->at(i)->string());

raw_and_cooked_match = false;

}

raw_strings->set(i, *this->raw_strings()->at(i)->string());

}

}

DirectHandle<FixedArray> cooked_strings_handle = raw_strings_handle;

if (!raw_and_cooked_match) {

cooked_strings_handle = isolate->factory()->NewFixedArray(

this->cooked_strings()->length(), AllocationType::kOld);

DisallowGarbageCollection no_gc;

Tagged<FixedArray> cooked_strings = *cooked_strings_handle;

ReadOnlyRoots roots(isolate);

for (int i = 0; i < cooked_strings->length(); ++i) {

if (this->cooked_strings()->at(i) != nullptr) {

cooked_strings->set(i, *this->cooked_strings()->at(i)->string());

} else {

cooked_strings->set(i, roots.undefined_value(), SKIP_WRITE_BARRIER);

}

}

}

return isolate->factory()->NewTemplateObjectDescription(

raw_strings_handle, cooked_strings_handle);

// Add is not commutative due to potential for string addition.

return op == Token::kMul || op == Token::kBitAnd || op == Token::kBitOr ||

op == Token::kBitXor;

Expression** expr, Tagged<Smi>* literal) {

if (right->IsSmiLiteral()) {

*expr = left;

*literal = right->AsLiteral()->AsSmiLiteral();

return true;

}

return false;

Tagged<Smi>* literal) {

return MatchSmiLiteralOperation(left_, right_, subexpr, literal) ||

(IsCommutativeOperationWithSmiLiteral(op()) &&

MatchSmiLiteralOperation(right_, left_, subexpr, literal));

UnaryOperation* maybe_unary = expr->AsUnaryOperation();

return maybe_unary != nullptr && maybe_unary->op() == Token::kVoid &&

maybe_unary->expression()->IsLiteral();

Expression* right,

Expression** expr,

Literal** literal) {

if (left->IsBooleanLiteral() && op == Token::kEqStrict) {

*expr = right;

*literal = left->AsLiteral();

return true;

}

return false;

Literal** literal) {

return MatchLiteralStrictCompareBoolean(left_, op(), right_, expr, literal) ||

MatchLiteralStrictCompareBoolean(right_, op(), left_, expr, literal);

Expression* right, Expression** expr) {

if (IsVoidOfLiteral(left) && Token::IsEqualityOp(op)) {

*expr = right;

return true;

}

if (left->IsUndefinedLiteral() && Token::IsEqualityOp(op)) {

*expr = right;

return true;

}

return false;

Expression* right, Expression** expr) {

if (left->IsNullLiteral() && Token::IsEqualityOp(op)) {

*expr = right;

return true;

}

return false;

Expression* right,

Expression** expr,

Literal** literal) {

if (Token::IsEqualityOp(op) && left->AsVariableProxy() &&

right->IsStringLiteral()) {

*expr = left->AsVariableProxy();

*literal = right->AsLiteral();

return true;

}

return false;

Literal** literal) {

return (

MatchLiteralCompareEqualVariable(left_, op(), right_, expr, literal) ||

MatchLiteralCompareEqualVariable(right_, op(), left_, expr, literal));

int arguments_length = arguments_.length();

int first_spread_index = 0;

for (; first_spread_index < arguments_length; first_spread_index++) {

if (arguments_.at(first_spread_index)->IsSpread()) break;

}

SpreadPosition position;

if (first_spread_index == arguments_length - 1) {

position = kHasFinalSpread;

} else {

DCHECK_LT(first_spread_index, arguments_length - 1);

position = kHasNonFinalSpread;

}

bit_field_ |= SpreadPositionField::encode(position);

VariableProxy* proxy = expression()->AsVariableProxy();

if (proxy != nullptr) {

if (proxy->var()->IsUnallocated()) {

return GLOBAL_CALL;

} else if (proxy->var()->IsLookupSlot()) {

// Calls going through 'with' always use VariableMode::kDynamic rather

// than VariableMode::kDynamicLocal or VariableMode::kDynamicGlobal.

return proxy->var()->mode() == VariableMode::kDynamic ? WITH_CALL

: OTHER_CALL;

}

}

if (expression()->IsSuperCallReference()) return SUPER_CALL;

Property* property = expression()->AsProperty();

bool is_optional_chain = false;

if (V8_UNLIKELY(property == nullptr && expression()->IsOptionalChain())) {

is_optional_chain = true;

property = expression()->AsOptionalChain()->expression()->AsProperty();

}

if (property != nullptr) {

if (property->IsPrivateReference()) {

if (is_optional_chain) return PRIVATE_OPTIONAL_CHAIN_CALL;