// Copyright 2018 the V8 project authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

#include "src/torque/torque-parser.h"

#include <algorithm>

#include <cctype>

#include <optional>

#include <set>

#include <stdexcept>

#include <unordered_map>

#include "include/v8config.h"

#include "src/common/globals.h"

#include "src/flags/flags.h"

#include "src/torque/ast.h"

#include "src/torque/constants.h"

#include "src/torque/declarations.h"

#include "src/torque/earley-parser.h"

#include "src/torque/global-context.h"

#include "src/torque/utils.h"

namespace v8::internal::torque {

using TypeList = std::vector<TypeExpression*>;

struct ExpressionWithSource {

Expression* expression;

std::string source;

};

struct TypeswitchCase {

SourcePosition pos;

std::optional<Identifier*> name;

TypeExpression* type;

Statement* block;

};

struct EnumEntry {

Identifier* name;

std::optional<TypeExpression*> type;

std::optional<std::string> alias_entry;

};

class BuildFlags : public base::ContextualClass<BuildFlags> {

public:

BuildFlags() {

build_flags_["V8_EXTERNAL_CODE_SPACE"] = V8_EXTERNAL_CODE_SPACE_BOOL;

build_flags_["TAGGED_SIZE_8_BYTES"] = TargetArchitecture::TaggedSize() == 8;

build_flags_["V8_ENABLE_EXPERIMENTAL_UNDEFINED_DOUBLE"] =

V8_EXPERIMENTAL_UNDEFINED_DOUBLE_BOOL;

#ifdef V8_INTL_SUPPORT

build_flags_["V8_INTL_SUPPORT"] = true;

#else

build_flags_["V8_INTL_SUPPORT"] = false;

#endif

build_flags_["V8_ENABLE_SWISS_NAME_DICTIONARY"] =

V8_ENABLE_SWISS_NAME_DICTIONARY_BOOL;

#ifdef V8_ENABLE_JAVASCRIPT_PROMISE_HOOKS

build_flags_["V8_ENABLE_JAVASCRIPT_PROMISE_HOOKS"] = true;

#else

build_flags_["V8_ENABLE_JAVASCRIPT_PROMISE_HOOKS"] = false;

#endif

#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA

build_flags_["V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA"] = true;

#else

build_flags_["V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA"] = false;

#endif

build_flags_["TRUE_FOR_TESTING"] = true;

build_flags_["FALSE_FOR_TESTING"] = false;

#ifdef V8_SCRIPTORMODULE_LEGACY_LIFETIME

build_flags_["V8_SCRIPTORMODULE_LEGACY_LIFETIME"] = true;

#else

build_flags_["V8_SCRIPTORMODULE_LEGACY_LIFETIME"] = false;

#endif

#ifdef V8_ENABLE_WEBASSEMBLY

build_flags_["V8_ENABLE_WEBASSEMBLY"] = true;

build_flags_["WASM_CODE_POINTER_NEEDS_PADDING"] =

TargetArchitecture::TaggedSize() == 8;

#else

build_flags_["V8_ENABLE_WEBASSEMBLY"] = false;

#endif

build_flags_["V8_ENABLE_SANDBOX"] = V8_ENABLE_SANDBOX_BOOL;

build_flags_["V8_ENABLE_LEAPTIERING"] = V8_ENABLE_LEAPTIERING_BOOL;

build_flags_["V8_ENABLE_LEAPTIERING_TAGGED_SIZE_8_BYTES"] =

V8_ENABLE_LEAPTIERING_BOOL && build_flags_["TAGGED_SIZE_8_BYTES"];

build_flags_["DEBUG"] = DEBUG_BOOL;

#ifdef V8_ENABLE_DRUMBRAKE

build_flags_["V8_ENABLE_DRUMBRAKE"] = true;

#else

build_flags_["V8_ENABLE_DRUMBRAKE"] = false;

#endif

}

static bool GetFlag(const std::string& name, const char* production) {

auto it = Get().build_flags_.find(name);

if (it == Get().build_flags_.end()) {

ReportError("Unknown flag used in ", production, ": ", name,

". Please add it to the list in BuildFlags.");

}

return it->second;

}

private:

std::unordered_map<std::string, bool> build_flags_;

};

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId ParseResultHolder<std::string>::id =

ParseResultTypeId::kStdString;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId ParseResultHolder<bool>::id =

ParseResultTypeId::kBool;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId ParseResultHolder<int32_t>::id =

ParseResultTypeId::kInt32;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId ParseResultHolder<double>::id =

ParseResultTypeId::kDouble;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<IntegerLiteral>::id = ParseResultTypeId::kIntegerLiteral;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::vector<std::string>>::id =

ParseResultTypeId::kStdVectorOfString;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId ParseResultHolder<Declaration*>::id =

ParseResultTypeId::kDeclarationPtr;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<TypeExpression*>::id =

ParseResultTypeId::kTypeExpressionPtr;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::optional<TypeExpression*>>::id =

ParseResultTypeId::kOptionalTypeExpressionPtr;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId ParseResultHolder<TryHandler*>::id =

ParseResultTypeId::kTryHandlerPtr;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId ParseResultHolder<Expression*>::id =

ParseResultTypeId::kExpressionPtr;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId ParseResultHolder<Identifier*>::id =

ParseResultTypeId::kIdentifierPtr;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::optional<Identifier*>>::id =

ParseResultTypeId::kOptionalIdentifierPtr;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId ParseResultHolder<Statement*>::id =

ParseResultTypeId::kStatementPtr;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<NameAndTypeExpression>::id =

ParseResultTypeId::kNameAndTypeExpression;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId ParseResultHolder<EnumEntry>::id =

ParseResultTypeId::kEnumEntry;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::vector<EnumEntry>>::id =

ParseResultTypeId::kStdVectorOfEnumEntry;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<NameAndExpression>::id =

ParseResultTypeId::kNameAndExpression;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId ParseResultHolder<Annotation>::id =

ParseResultTypeId::kAnnotation;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::vector<Annotation>>::id =

ParseResultTypeId::kVectorOfAnnotation;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<AnnotationParameter>::id =

ParseResultTypeId::kAnnotationParameter;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::optional<AnnotationParameter>>::id =

ParseResultTypeId::kOptionalAnnotationParameter;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<ClassFieldExpression>::id =

ParseResultTypeId::kClassFieldExpression;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<StructFieldExpression>::id =

ParseResultTypeId::kStructFieldExpression;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<BitFieldDeclaration>::id =

ParseResultTypeId::kBitFieldDeclaration;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::vector<NameAndTypeExpression>>::id =

ParseResultTypeId::kStdVectorOfNameAndTypeExpression;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<ImplicitParameters>::id =

ParseResultTypeId::kImplicitParameters;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::optional<ImplicitParameters>>::id =

ParseResultTypeId::kOptionalImplicitParameters;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::vector<NameAndExpression>>::id =

ParseResultTypeId::kStdVectorOfNameAndExpression;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::vector<ClassFieldExpression>>::id =

ParseResultTypeId::kStdVectorOfClassFieldExpression;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::vector<StructFieldExpression>>::id =

ParseResultTypeId::kStdVectorOfStructFieldExpression;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::vector<BitFieldDeclaration>>::id =

ParseResultTypeId::kStdVectorOfBitFieldDeclaration;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<IncrementDecrementOperator>::id =

ParseResultTypeId::kIncrementDecrementOperator;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::optional<std::string>>::id =

ParseResultTypeId::kOptionalStdString;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::vector<Statement*>>::id =

ParseResultTypeId::kStdVectorOfStatementPtr;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::vector<Declaration*>>::id =

ParseResultTypeId::kStdVectorOfDeclarationPtr;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::vector<std::vector<Declaration*>>>::id =

ParseResultTypeId::kStdVectorOfStdVectorOfDeclarationPtr;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::vector<Expression*>>::id =

ParseResultTypeId::kStdVectorOfExpressionPtr;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<ExpressionWithSource>::id =

ParseResultTypeId::kExpressionWithSource;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId ParseResultHolder<ParameterList>::id =

ParseResultTypeId::kParameterList;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId ParseResultHolder<TypeList>::id =

ParseResultTypeId::kTypeList;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::optional<TypeList>>::id =

ParseResultTypeId::kOptionalTypeList;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId ParseResultHolder<LabelAndTypes>::id =

ParseResultTypeId::kLabelAndTypes;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::vector<LabelAndTypes>>::id =

ParseResultTypeId::kStdVectorOfLabelAndTypes;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::vector<TryHandler*>>::id =

ParseResultTypeId::kStdVectorOfTryHandlerPtr;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::optional<Statement*>>::id =

ParseResultTypeId::kOptionalStatementPtr;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::optional<Expression*>>::id =

ParseResultTypeId::kOptionalExpressionPtr;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<TypeswitchCase>::id = ParseResultTypeId::kTypeswitchCase;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::vector<TypeswitchCase>>::id =

ParseResultTypeId::kStdVectorOfTypeswitchCase;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::vector<Identifier*>>::id =

ParseResultTypeId::kStdVectorOfIdentifierPtr;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<std::optional<ClassBody*>>::id =

ParseResultTypeId::kOptionalClassBody;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<GenericParameter>::id =

ParseResultTypeId::kGenericParameter;

template <>

V8_EXPORT_PRIVATE const ParseResultTypeId

ParseResultHolder<GenericParameters>::id =

ParseResultTypeId::kGenericParameters;

namespace {

bool ProcessIfAnnotation(ParseResultIterator* child_results);

class AnnotationSet;

bool ProcessIfAnnotation(const AnnotationSet& annotations);

std::optional<ParseResult> AddGlobalDeclarations(

ParseResultIterator* child_results) {

auto declarations = child_results->NextAs<std::vector<Declaration*>>();

for (Declaration* declaration : declarations) {

CurrentAst::Get().declarations().push_back(declaration);

}

return std::nullopt;

}

void NamingConventionError(const std::string& type, const std::string& name,

const std::string& convention,

SourcePosition pos = CurrentSourcePosition::Get()) {

Lint(type, " \"", name, "\" does not follow \"", convention,

"\" naming convention.")

.Position(pos);

}

void NamingConventionError(const std::string& type, const Identifier* name,

const std::string& convention) {

NamingConventionError(type, name->value, convention, name->pos);

}

void LintGenericParameters(const GenericParameters& parameters) {

for (auto parameter : parameters) {

if (!IsUpperCamelCase(parameter.name->value)) {

NamingConventionError("Generic parameter", parameter.name,

"UpperCamelCase");

}

}

}

std::optional<ParseResult> ConcatList(ParseResultIterator* child_results) {

auto list_of_lists =

child_results->NextAs<std::vector<std::vector<Declaration*>>>();

std::vector<Declaration*> result;

for (auto& list : list_of_lists) {

result.insert(result.end(), list.begin(), list.end());

}

return ParseResult{std::move(result)};

}

void CheckNotDeferredStatement(Statement* statement) {

CurrentSourcePosition::Scope source_position(statement->pos);

if (BlockStatement* block = BlockStatement::DynamicCast(statement)) {

if (block->deferred) {

Lint(

"cannot use deferred with a statement block here, it will have no "

"effect");

}

}

}

TypeExpression* AddConstexpr(TypeExpression* type) {

BasicTypeExpression* basic = BasicTypeExpression::DynamicCast(type);

if (!basic) Error("Unsupported extends clause.").Throw();

return MakeNode<BasicTypeExpression>(

basic->namespace_qualification,

MakeNode<Identifier>(CONSTEXPR_TYPE_PREFIX + basic->name->value),

basic->generic_arguments);

}

Expression* MakeCall(IdentifierExpression* callee,

std::optional<Expression*> target,

std::vector<Expression*> arguments,

const std::vector<Statement*>& otherwise) {

std::vector<Identifier*> labels;

// All IdentifierExpressions are treated as label names and can be directly

// used as labels identifiers. All other statements in a call's otherwise

// must create intermediate Labels for the otherwise's statement code.

size_t label_id_count = 0;

std::vector<TryHandler*> temp_labels;

for (auto* statement : otherwise) {

if (auto* e = ExpressionStatement::DynamicCast(statement)) {

if (auto* id = IdentifierExpression::DynamicCast(e->expression)) {

if (!id->generic_arguments.empty()) {

ReportError("An otherwise label cannot have generic parameters");

}

labels.push_back(id->name);

continue;

}

}

auto label_name = std::string("__label") + std::to_string(label_id_count++);

auto label_id = MakeNode<Identifier>(label_name);

label_id->pos = SourcePosition::Invalid();

labels.push_back(label_id);

auto* handler =

MakeNode<TryHandler>(TryHandler::HandlerKind::kLabel, label_id,

ParameterList::Empty(), statement);

temp_labels.push_back(handler);

}

// Create nested try-label expression for all of the temporary Labels that

// were created.

Expression* result = nullptr;

if (target) {

result = MakeNode<CallMethodExpression>(

*target, callee, std::move(arguments), std::move(labels));

} else {

result = MakeNode<CallExpression>(callee, std::move(arguments),

std::move(labels));

}

for (auto* label : temp_labels) {

result = MakeNode<TryLabelExpression>(result, label);

}

return result;

}

Expression* MakeCall(Identifier* callee,

const std::vector<TypeExpression*>& generic_arguments,

const std::vector<Expression*>& arguments,

const std::vector<Statement*>& otherwise) {

return MakeCall(MakeNode<IdentifierExpression>(callee, generic_arguments),

std::nullopt, arguments, otherwise);

}

std::optional<ParseResult> MakeCall(ParseResultIterator* child_results) {

auto callee = child_results->NextAs<Expression*>();

auto args = child_results->NextAs<std::vector<Expression*>>();

auto otherwise = child_results->NextAs<std::vector<Statement*>>();

IdentifierExpression* target = IdentifierExpression::cast(callee);

return ParseResult{

MakeCall(target, std::nullopt, std::move(args), otherwise)};

}

std::optional<ParseResult> MakeMethodCall(ParseResultIterator* child_results) {

auto this_arg = child_results->NextAs<Expression*>();

auto callee = child_results->NextAs<Identifier*>();

auto args = child_results->NextAs<std::vector<Expression*>>();

auto otherwise = child_results->NextAs<std::vector<Statement*>>();

return ParseResult{MakeCall(MakeNode<IdentifierExpression>(callee), this_arg,

std::move(args), otherwise)};

}

std::optional<ParseResult> MakeNewExpression(

ParseResultIterator* child_results) {

bool pretenured = child_results->NextAs<bool>();

bool clear_padding = child_results->NextAs<bool>();

auto type = child_results->NextAs<TypeExpression*>();

auto initializers = child_results->NextAs<std::vector<NameAndExpression>>();

Expression* result = MakeNode<NewExpression>(type, std::move(initializers),

pretenured, clear_padding);

return ParseResult{result};

}

std::optional<ParseResult> MakeBinaryOperator(

ParseResultIterator* child_results) {

auto left = child_results->NextAs<Expression*>();

auto op = child_results->NextAs<Identifier*>();

auto right = child_results->NextAs<Expression*>();

return ParseResult{MakeCall(op, TypeList{},

std::vector<Expression*>{left, right},

std::vector<Statement*>{})};

}

std::optional<ParseResult> MakeIntrinsicCallExpression(

ParseResultIterator* child_results) {

auto callee = child_results->NextAs<Identifier*>();

auto generic_arguments =

child_results->NextAs<std::vector<TypeExpression*>>();

auto args = child_results->NextAs<std::vector<Expression*>>();

Expression* result = MakeNode<IntrinsicCallExpression>(

callee, std::move(generic_arguments), std::move(args));

return ParseResult{result};

}

std::optional<ParseResult> MakeUnaryOperator(

ParseResultIterator* child_results) {

auto op = child_results->NextAs<Identifier*>();

auto e = child_results->NextAs<Expression*>();

return ParseResult{MakeCall(op, TypeList{}, std::vector<Expression*>{e},

std::vector<Statement*>{})};

}

std::optional<ParseResult> MakeSpreadExpression(

ParseResultIterator* child_results) {

auto spreadee = child_results->NextAs<Expression*>();

Expression* result = MakeNode<SpreadExpression>(spreadee);

return ParseResult{result};

}

std::optional<ParseResult> MakeImplicitParameterList(

ParseResultIterator* child_results) {

auto kind = child_results->NextAs<Identifier*>();

auto parameters = child_results->NextAs<std::vector<NameAndTypeExpression>>();

return ParseResult{ImplicitParameters{kind, std::move(parameters)}};

}

void AddParameter(ParameterList* parameter_list,

const NameAndTypeExpression& param) {

if (!IsLowerCamelCase(param.name->value)) {

NamingConventionError("Parameter", param.name, "lowerCamelCase");

}

parameter_list->names.push_back(param.name);

parameter_list->types.push_back(param.type);

}

template <bool has_varargs, bool has_explicit_parameter_names>

std::optional<ParseResult> MakeParameterList(

ParseResultIterator* child_results) {

auto implicit_params =

child_results->NextAs<std::optional<ImplicitParameters>>();

ParameterList result;

result.has_varargs = has_varargs;

result.implicit_count = 0;

result.implicit_kind = ImplicitKind::kNoImplicit;

if (implicit_params) {

result.implicit_count = implicit_params->parameters.size();

if (implicit_params->kind->value == "implicit") {

result.implicit_kind = ImplicitKind::kImplicit;

} else {

DCHECK_EQ(implicit_params->kind->value, "js-implicit");

result.implicit_kind = ImplicitKind::kJSImplicit;

}

result.implicit_kind_pos = implicit_params->kind->pos;

for (NameAndTypeExpression& implicit_param : implicit_params->parameters) {

AddParameter(&result, implicit_param);

}

}

if (has_explicit_parameter_names) {

auto explicit_params =

child_results->NextAs<std::vector<NameAndTypeExpression>>();

std::string arguments_variable = "";

if (has_varargs) {

arguments_variable = child_results->NextAs<std::string>();

}

for (NameAndTypeExpression& param : explicit_params) {

AddParameter(&result, param);

}

result.arguments_variable = arguments_variable;

} else {

auto explicit_types = child_results->NextAs<TypeList>();

for (auto* explicit_type : explicit_types) {

result.types.push_back(explicit_type);

}

}

return ParseResult{std::move(result)};

}

std::optional<ParseResult> MakeAssertStatement(

ParseResultIterator* child_results) {

auto kind_string = child_results->NextAs<Identifier*>()->value;

auto expr_with_source = child_results->NextAs<ExpressionWithSource>();

AssertStatement::AssertKind kind;

if (kind_string == "dcheck") {

kind = AssertStatement::AssertKind::kDcheck;

} else if (kind_string == "check") {

kind = AssertStatement::AssertKind::kCheck;

} else if (kind_string == "sbxcheck") {

#ifdef V8_ENABLE_SANDBOX

kind = AssertStatement::AssertKind::kSbxCheck;

#else

kind = AssertStatement::AssertKind::kDcheck;

#endif // V8_ENABLE_SANDBOX

} else if (kind_string == "static_assert") {

kind = AssertStatement::AssertKind::kStaticAssert;

} else {

UNREACHABLE();

}

Statement* result = MakeNode<AssertStatement>(

kind, expr_with_source.expression, expr_with_source.source);

return ParseResult{result};

}

std::optional<ParseResult> MakeDebugStatement(

ParseResultIterator* child_results) {

auto kind = child_results->NextAs<Identifier*>()->value;

DCHECK(kind == "unreachable" || kind == "debug");

Statement* result = MakeNode<DebugStatement>(

kind == "unreachable" ? DebugStatement::Kind::kUnreachable

: DebugStatement::Kind::kDebug);

return ParseResult{result};

}

std::optional<ParseResult> DeprecatedMakeVoidType(

ParseResultIterator* child_results) {

Error("Default void return types are deprecated. Add `: void`.");

TypeExpression* result = MakeNode<BasicTypeExpression>(

std::vector<std::string>{}, MakeNode<Identifier>("void"),

std::vector<TypeExpression*>{});

return ParseResult{result};

}

std::optional<ParseResult> MakeExternalMacro(

ParseResultIterator* child_results) {

bool enabled = ProcessIfAnnotation(child_results);

auto transitioning = child_results->NextAs<bool>();

auto operator_name = child_results->NextAs<std::optional<std::string>>();

auto external_assembler_name =

child_results->NextAs<std::optional<std::string>>();

auto name = child_results->NextAs<Identifier*>();

auto generic_parameters = child_results->NextAs<GenericParameters>();

LintGenericParameters(generic_parameters);

auto args = child_results->NextAs<ParameterList>();

auto return_type = child_results->NextAs<TypeExpression*>();

auto labels = child_results->NextAs<LabelAndTypesVector>();

std::vector<Declaration*> result = {};

if (enabled) {

result = {MakeNode<ExternalMacroDeclaration>(

transitioning,

external_assembler_name ? *external_assembler_name

: "CodeStubAssembler",

name, operator_name, args, return_type, std::move(labels))};

}

if (!generic_parameters.empty()) {

Error("External builtins cannot be generic.");

}

return ParseResult{std::move(result)};

}

std::optional<ParseResult> MakeIntrinsicDeclaration(

ParseResultIterator* child_results) {

auto name = child_results->NextAs<Identifier*>();

auto generic_parameters = child_results->NextAs<GenericParameters>();

LintGenericParameters(generic_parameters);

auto args = child_results->NextAs<ParameterList>();

auto return_type = child_results->NextAs<TypeExpression*>();

auto body = child_results->NextAs<std::optional<Statement*>>();

CallableDeclaration* declaration;

if (body) {

declaration = MakeNode<TorqueMacroDeclaration>(

false, name, std::optional<std::string>{}, args, return_type,

LabelAndTypesVector{}, false, body);

} else {

declaration = MakeNode<IntrinsicDeclaration>(name, args, return_type);

}

Declaration* result = declaration;

if (!generic_parameters.empty()) {

result = MakeNode<GenericCallableDeclaration>(std::move(generic_parameters),

declaration);

}

return ParseResult{result};

}

namespace {

bool HasAnnotation(ParseResultIterator* child_results, const char* annotation,

const char* declaration) {

auto annotations = child_results->NextAs<std::vector<Annotation>>();

if (!annotations.empty()) {

if (annotations.size() > 1 || annotations[0].name->value != annotation) {

Error(declaration, " declarations only support a single ", annotation,

" annotation");

}

return true;

}

return false;

}

bool HasExportAnnotation(ParseResultIterator* child_results,

const char* declaration) {

return HasAnnotation(child_results, ANNOTATION_EXPORT, declaration);

}

} // namespace

class AnnotationSet {

public:

AnnotationSet(ParseResultIterator* iter,

const std::set<std::string>& allowed_without_param,

const std::set<std::string>& allowed_with_param) {

auto list = iter->NextAs<std::vector<Annotation>>();

for (const Annotation& a : list) {

if (a.param.has_value()) {

if (allowed_with_param.find(a.name->value) ==

allowed_with_param.end()) {

const char* error_message =

allowed_without_param.find(a.name->value) ==

allowed_without_param.end()

? " is not allowed here"

: " cannot have parameter here";

Lint("Annotation ", a.name->value, error_message)

.Position(a.name->pos);

}

if (!map_.insert({a.name->value, {*a.param, a.name->pos}}).second) {

Lint("Duplicate annotation ", a.name->value).Position(a.name->pos);

}

} else {

if (allowed_without_param.find(a.name->value) ==

allowed_without_param.end()) {

const char* error_message =

allowed_with_param.find(a.name->value) == allowed_with_param.end()

? " is not allowed here"

: " requires a parameter here";

Lint("Annotation ", a.name->value, error_message)

.Position(a.name->pos);

}

if (!set_.insert(a.name->value).second) {

Lint("Duplicate annotation ", a.name->value).Position(a.name->pos);

}

}

}

}

bool Contains(const std::string& s) const {

return set_.find(s) != set_.end();

}

std::optional<std::string> GetStringParam(const std::string& s) const {

auto it = map_.find(s);

if (it == map_.end()) {

return {};

}

if (it->second.first.is_int) {

Error("Annotation ", s, " requires a string parameter but has an int")

.Position(it->second.second);

}

return it->second.first.string_value;

}

std::optional<int32_t> GetIntParam(const std::string& s) const {

auto it = map_.find(s);

if (it == map_.end()) {

return {};

}

if (!it->second.first.is_int) {

Error("Annotation ", s, " requires an int parameter but has a string")

.Position(it->second.second);

}

return it->second.first.int_value;

}

private:

std::set<std::string> set_;

std::map<std::string, std::pair<AnnotationParameter, SourcePosition>> map_;

};

std::optional<ParseResult> MakeTorqueMacroDeclaration(

ParseResultIterator* child_results) {

AnnotationSet annotations(child_results, {ANNOTATION_EXPORT},

{ANNOTATION_IF, ANNOTATION_IFNOT});

bool enabled = ProcessIfAnnotation(annotations);

bool export_to_csa = annotations.Contains(ANNOTATION_EXPORT);

auto transitioning = child_results->NextAs<bool>();

auto operator_name = child_results->NextAs<std::optional<std::string>>();

auto name = child_results->NextAs<Identifier*>();

if (!IsUpperCamelCase(name->value)) {

NamingConventionError("Macro", name, "UpperCamelCase");

}

auto generic_parameters = child_results->NextAs<GenericParameters>();

LintGenericParameters(generic_parameters);

auto args = child_results->NextAs<ParameterList>();

auto return_type = child_results->NextAs<TypeExpression*>();

auto labels = child_results->NextAs<LabelAndTypesVector>();

auto body = child_results->NextAs<std::optional<Statement*>>();

std::vector<Declaration*> result = {};

if (enabled) {

CallableDeclaration* declaration = MakeNode<TorqueMacroDeclaration>(

transitioning, name, operator_name, args, return_type,

std::move(labels), export_to_csa, body);

result = {declaration};

if (generic_parameters.empty()) {

if (!body) ReportError("A non-generic declaration needs a body.");

} else {

if (export_to_csa) ReportError("Cannot export generics to CSA.");

result = {MakeNode<GenericCallableDeclaration>(

std::move(generic_parameters), declaration)};

}

}

return ParseResult{std::move(result)};

}

std::optional<ParseResult> MakeConstDeclaration(

ParseResultIterator* child_results) {

bool enabled = ProcessIfAnnotation(child_results);

auto name = child_results->NextAs<Identifier*>();

if (!IsValidNamespaceConstName(name->value)) {

NamingConventionError("Constant", name, "kUpperCamelCase");

}

auto type = child_results->NextAs<TypeExpression*>();

auto expression = child_results->NextAs<Expression*>();

std::vector<Declaration*> result = {};

if (enabled) result = {MakeNode<ConstDeclaration>(name, type, expression)};

return ParseResult{std::move(result)};

}

std::optional<ParseResult> MakeExternConstDeclaration(

ParseResultIterator* child_results) {

auto name = child_results->NextAs<Identifier*>();

auto type = child_results->NextAs<TypeExpression*>();

auto literal = child_results->NextAs<std::string>();

Declaration* result =

MakeNode<ExternConstDeclaration>(name, type, std::move(literal));

return ParseResult{result};

}

std::optional<ParseResult> MakeTypeAliasDeclaration(

ParseResultIterator* child_results) {

bool enabled = ProcessIfAnnotation(child_results);

auto name = child_results->NextAs<Identifier*>();

auto type = child_results->NextAs<TypeExpression*>();

std::vector<Declaration*> result = {};

if (enabled) result = {MakeNode<TypeAliasDeclaration>(name, type)};

return ParseResult{std::move(result)};

}

std::optional<ParseResult> MakeAbstractTypeDeclaration(

ParseResultIterator* child_results) {

bool use_parent_type_checker = HasAnnotation(

child_results, ANNOTATION_USE_PARENT_TYPE_CHECKER, "abstract type");

auto transient = child_results->NextAs<bool>();

auto name = child_results->NextAs<Identifier*>();

if (!IsValidTypeName(name->value)) {

NamingConventionError("Type", name, "UpperCamelCase");

}

auto generic_parameters = child_results->NextAs<GenericParameters>();

auto extends = child_results->NextAs<std::optional<TypeExpression*>>();

auto generates = child_results->NextAs<std::optional<std::string>>();

AbstractTypeFlags flags(AbstractTypeFlag::kNone);

if (transient) flags |= AbstractTypeFlag::kTransient;

if (use_parent_type_checker) flags |= AbstractTypeFlag::kUseParentTypeChecker;

TypeDeclaration* type_decl = MakeNode<AbstractTypeDeclaration>(

name, flags, extends, std::move(generates));

Declaration* decl = type_decl;

if (!generic_parameters.empty()) {

decl = MakeNode<GenericTypeDeclaration>(generic_parameters, type_decl);

}

auto constexpr_generates =

child_results->NextAs<std::optional<std::string>>();

std::vector<Declaration*> result{decl};

if (constexpr_generates) {

// Create a AbstractTypeDeclaration for the associated constexpr type.

Identifier* constexpr_name =

MakeNode<Identifier>(CONSTEXPR_TYPE_PREFIX + name->value);

constexpr_name->pos = name->pos;

std::optional<TypeExpression*> constexpr_extends;

if (extends) {

constexpr_extends = AddConstexpr(*extends);

}

TypeDeclaration* constexpr_decl = MakeNode<AbstractTypeDeclaration>(

constexpr_name, flags | AbstractTypeFlag::kConstexpr, constexpr_extends,

constexpr_generates);

constexpr_decl->pos = name->pos;

decl = constexpr_decl;

if (!generic_parameters.empty()) {

decl = MakeNode<GenericTypeDeclaration>(std::move(generic_parameters),

constexpr_decl);

}

result.push_back(decl);

}

return ParseResult{std::move(result)};

}

std::optional<ParseResult> MakeMethodDeclaration(

ParseResultIterator* child_results) {

auto transitioning = child_results->NextAs<bool>();

auto operator_name = child_results->NextAs<std::optional<std::string>>();

auto name = child_results->NextAs<Identifier*>();

if (!IsUpperCamelCase(name->value)) {

NamingConventionError("Method", name, "UpperCamelCase");

}

auto args = child_results->NextAs<ParameterList>();

auto return_type = child_results->NextAs<TypeExpression*>();

auto labels = child_results->NextAs<LabelAndTypesVector>();

auto body = child_results->NextAs<Statement*>();

Declaration* result = MakeNode<TorqueMacroDeclaration>(

transitioning, name, operator_name, args, return_type, std::move(labels),

false, body);

return ParseResult{result};

}

bool ProcessIfAnnotation(const AnnotationSet& annotations) {

if (std::optional<std::string> condition =

annotations.GetStringParam(ANNOTATION_IF)) {

if (!BuildFlags::GetFlag(*condition, ANNOTATION_IF)) return false;

}

if (std::optional<std::string> condition =

annotations.GetStringParam(ANNOTATION_IFNOT)) {

if (BuildFlags::GetFlag(*condition, ANNOTATION_IFNOT)) return false;

}

return true;

}

bool ProcessIfAnnotation(ParseResultIterator* child_results) {

AnnotationSet annotations(child_results, {},

{ANNOTATION_IF, ANNOTATION_IFNOT});

return ProcessIfAnnotation(annotations);

}

std::optional<ParseResult> YieldInt32(ParseResultIterator* child_results) {

std::string value = child_results->matched_input().ToString();

size_t num_chars_converted = 0;

int result = 0;

try {

result = std::stoi(value, &num_chars_converted, 0);

} catch (const std::invalid_argument&) {

Error("Expected an integer");

return ParseResult{result};

} catch (const std::out_of_range&) {

Error("Integer out of 32-bit range");

return ParseResult{result};

}

// Tokenizer shouldn't have included extra trailing characters.

DCHECK_EQ(num_chars_converted, value.size());

return ParseResult{result};

}

std::optional<ParseResult> YieldDouble(ParseResultIterator* child_results) {

std::string value = child_results->matched_input().ToString();

size_t num_chars_converted = 0;

double result = 0;

try {

result = std::stod(value, &num_chars_converted);

} catch (const std::out_of_range&) {

Error("double literal out-of-range");

return ParseResult{result};

}

// Tokenizer shouldn't have included extra trailing characters.

DCHECK_EQ(num_chars_converted, value.size());

return ParseResult{result};

}

std::optional<ParseResult> YieldIntegerLiteral(

ParseResultIterator* child_results) {

std::string value = child_results->matched_input().ToString();

// Consume a leading minus.

bool negative = false;

if (!value.empty() && value[0] == '-') {

negative = true;

value = value.substr(1);

}

uint64_t absolute_value;

try {

size_t parsed = 0;

absolute_value = std::stoull(value, &parsed, 0);

DCHECK_EQ(parsed, value.size());

} catch (const std::invalid_argument&) {

Error("integer literal could not be parsed").Throw();

} catch (const std::out_of_range&) {

Error("integer literal value out of range").Throw();

}

return ParseResult(IntegerLiteral(negative, absolute_value));

}

std::optional<ParseResult> MakeStringAnnotationParameter(

ParseResultIterator* child_results) {

std::string value = child_results->NextAs<std::string>();

AnnotationParameter result{value, 0, false};

return ParseResult{result};

}

std::optional<ParseResult> MakeIntAnnotationParameter(

ParseResultIterator* child_results) {

int32_t value = child_results->NextAs<int32_t>();

AnnotationParameter result{"", value, true};

return ParseResult{result};

}

int GetAnnotationValue(const AnnotationSet& annotations, const char* name,

int default_value) {

auto opt_value = annotations.GetIntParam(name);

return opt_value.has_value() ? *opt_value : default_value;

}

std::optional<ParseResult> MakeTorqueBuiltinDeclaration(

ParseResultIterator* child_results) {

AnnotationSet annotations(child_results,

{ANNOTATION_CUSTOM_INTERFACE_DESCRIPTOR},

{ANNOTATION_IF, ANNOTATION_INCREMENT_USE_COUNTER});

const bool has_custom_interface_descriptor =

annotations.Contains(ANNOTATION_CUSTOM_INTERFACE_DESCRIPTOR);

std::optional<std::string> use_counter_name =

annotations.GetStringParam(ANNOTATION_INCREMENT_USE_COUNTER);

auto transitioning = child_results->NextAs<bool>();

auto javascript_linkage = child_results->NextAs<bool>();

auto name = child_results->NextAs<Identifier*>();

if (!IsUpperCamelCase(name->value)) {

NamingConventionError("Builtin", name, "UpperCamelCase");

}

auto generic_parameters = child_results->NextAs<GenericParameters>();

LintGenericParameters(generic_parameters);

auto args = child_results->NextAs<ParameterList>();

auto return_type = child_results->NextAs<TypeExpression*>();

auto body = child_results->NextAs<std::optional<Statement*>>();

CallableDeclaration* declaration = MakeNode<TorqueBuiltinDeclaration>(

transitioning, javascript_linkage, name, args, return_type,

has_custom_interface_descriptor, use_counter_name, body);

Declaration* result = declaration;