Lines Matching refs:name
39 FunctionLiteral* Parser::DefaultConstructor(const AstRawString* name,
84 name, function_scope, body, expected_property_count, parameter_count,
143 const char* name = Token::String(token);
144 DCHECK_NOT_NULL(name);
145 arg = name;
359 Expression* Parser::NewV8Intrinsic(const AstRawString* name,
368 if (!name->is_one_byte()) {
370 ReportMessage(MessageTemplate::kNotDefined, name);
375 Runtime::FunctionForName(name->raw_data(), name->length());
383 // Check for possible name clash.
385 Context::IntrinsicIndexForName(name->raw_data(), name->length()));
397 Context::IntrinsicIndexForName(name->raw_data(), name->length());
401 ReportMessage(MessageTemplate::kNotDefined, name);
927 // We should already be internalized by now, so the debug name will be
1236 // Keep track of the first string literal local name exported for error
1624 // Note that the desugared internal namespace export name (.x above) will
1625 // never conflict with a string literal export name, as literal string export
1626 // names in local name positions (i.e. left of 'as' or in a clause without
1766 for (const AstRawString* name : names) {
1767 descriptor->AddExport(name, name, loc, zone());
1773 void Parser::DeclareUnboundVariable(const AstRawString* name, VariableMode mode,
1776 Variable* var = DeclareVariable(name, NORMAL_VARIABLE, mode, init, scope(),
1783 VariableProxy* Parser::DeclareBoundVariable(const AstRawString* name,
1785 DCHECK_NOT_NULL(name);
1787 factory()->NewVariableProxy(name, NORMAL_VARIABLE, position());
1789 Variable* var = DeclareVariable(name, NORMAL_VARIABLE, mode,
1806 Variable* Parser::DeclareVariable(const AstRawString* name, VariableKind kind,
1817 Declare(declaration, name, kind, mode, init, scope, was_added, begin, end);
1821 void Parser::Declare(Declaration* declaration, const AstRawString* name,
1828 declaration, name, var_begin_pos, mode, variable_kind, init, was_added,
1832 // whole variable name. Pretend its length is 1 so that we highlight at
1900 Statement* Parser::DeclareNative(const AstRawString* name, int pos) {
1910 VariableProxy* proxy = DeclareBoundVariable(name, VariableMode::kVar, pos);
1912 factory()->NewNativeFunctionLiteral(name, extension(), kNoSourcePosition);
2021 void Parser::ReportVarRedeclarationIn(const AstRawString* name, Scope* scope) {
2023 if (decl->var()->raw_name() == name) {
2028 : Scanner::Location(position, position + name->length());
2029 ReportMessageAt(location, MessageTemplate::kVarRedeclaration, name);
2202 const AstRawString* name = decl.pattern->AsVariableProxy()->raw_name();
2203 VariableProxy* single_var = NewUnresolved(name);
2637 // handle as the function name. Remember if we were passed a non-empty
2638 // handle to decide whether to invoke function name inference.
2641 // We want a non-null handle as the function name by default. We will handle
2642 // the "function does not have a shared name" case later.
2792 // Validate function name. We can do this only after parsing the function,
3048 // The function name should have been ignored, giving us the empty string
3113 void Parser::DeclareClassVariable(ClassScope* scope, const AstRawString* name,
3116 scope->SetScopeName(name);
3119 DCHECK_IMPLIES(name == nullptr, class_info->is_anonymous);
3123 scope->DeclareClassVariable(ast_value_factory(), name, class_token_pos);
3132 Variable* Parser::CreateSyntheticContextVariable(const AstRawString* name) {
3134 DeclareBoundVariable(name, VariableMode::kConst, kNoSourcePosition);
3142 const AstRawString* name) {
3143 DCHECK_NOT_NULL(name);
3149 scope->DeclarePrivateName(name, mode, is_static_flag, &was_added);
3170 // We create a synthetic variable name here so that scope
3235 const char* name, DeclarationScope* scope, Statement* initializer_stmt) {
3241 ast_value_factory()->GetOneByteString(name), scope, statements, 0, 0, 0,
3247 scope->SetScopeName(ast_value_factory()->GetOneByteString(name));
3262 const AstRawString* name,
3273 DefaultConstructor(name, has_extends, pos, end_pos);
3276 if (name != nullptr) {
3331 const AstRawString* name = decl->var()->raw_name();
3332 Variable* parameter = function_scope->LookupLocal(name);
3334 VariableProxy* to = NewUnresolved(name);
3592 const AstRawString* name,
3595 // Ensure that the function we are going to create has shared name iff
3598 name = nullptr;
3602 // a concise method or an accessor function which doesn't require the name
3603 // to be set then the shared name must be provided.
3607 name != nullptr);
3611 SetFunctionName(value, name, prefix);
3615 const AstRawString* name,
3617 // Ignore "__proto__" as a name when it's being used to set the [[Prototype]]
3625 SetFunctionNameFromPropertyName(static_cast<LiteralProperty*>(property), name,
3637 void Parser::SetFunctionName(Expression* value, const AstRawString* name,
3650 if (name != nullptr) {
3652 cons_name = ast_value_factory()->NewConsString(prefix, name);
3654 cons_name = ast_value_factory()->NewConsString(name);