diff --git a/CMakeLists.txt b/CMakeLists.txt index 59776f9de6..66e2dcd533 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -157,7 +157,6 @@ option_if_not_defined(TINT_BUILD_MSL_WRITER "Build the MSL output writer" ${DAWN option_if_not_defined(TINT_BUILD_SPV_WRITER "Build the SPIR-V output writer" ${DAWN_ENABLE_VULKAN}) option_if_not_defined(TINT_BUILD_WGSL_WRITER "Build the WGSL output writer" ON) -option_if_not_defined(TINT_BUILD_SYNTAX_TREE_WRITER "Build the syntax tree writer" OFF) option_if_not_defined(TINT_BUILD_IR "Build the IR" ON) option_if_not_defined(TINT_BUILD_FUZZERS "Build fuzzers" OFF) @@ -293,7 +292,6 @@ message(STATUS "Tint build HLSL writer: ${TINT_BUILD_HLSL_WRITER}") message(STATUS "Tint build MSL writer: ${TINT_BUILD_MSL_WRITER}") message(STATUS "Tint build SPIR-V writer: ${TINT_BUILD_SPV_WRITER}") message(STATUS "Tint build WGSL writer: ${TINT_BUILD_WGSL_WRITER}") -message(STATUS "Tint build Syntax Tree writer: ${TINT_BUILD_SYNTAX_TREE_WRITER}") message(STATUS "Tint build IR: ${TINT_BUILD_IR}") message(STATUS "Tint build fuzzers: ${TINT_BUILD_FUZZERS}") message(STATUS "Tint build SPIRV-Tools fuzzer: ${TINT_BUILD_SPIRV_TOOLS_FUZZER}") @@ -523,8 +521,6 @@ function(tint_core_compile_options TARGET) target_compile_definitions(${TARGET} PUBLIC -DTINT_BUILD_MSL_WRITER=$) target_compile_definitions(${TARGET} PUBLIC -DTINT_BUILD_SPV_WRITER=$) target_compile_definitions(${TARGET} PUBLIC -DTINT_BUILD_WGSL_WRITER=$) - target_compile_definitions(${TARGET} PUBLIC - -DTINT_BUILD_SYNTAX_TREE_WRITER=$) target_compile_definitions(${TARGET} PUBLIC -DTINT_BUILD_IR=$) common_compile_options(${TARGET}) diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn index 44b7406d8d..89eb6eef99 100644 --- a/src/tint/BUILD.gn +++ b/src/tint/BUILD.gn @@ -78,12 +78,6 @@ config("tint_public_config") { defines += [ "TINT_BUILD_GLSL_WRITER=0" ] } - if (tint_build_syntax_tree_writer) { - defines += [ "TINT_BUILD_SYNTAX_TREE_WRITER=1" ] - } else { - defines += [ "TINT_BUILD_SYNTAX_TREE_WRITER=0" ] - } - include_dirs = [ "${tint_root_dir}/", "${tint_root_dir}/include/", @@ -1051,25 +1045,6 @@ libtint_source_set("libtint_glsl_writer_src") { ] } -libtint_source_set("libtint_syntax_tree_writer_src") { - sources = [ - "writer/syntax_tree/generator.cc", - "writer/syntax_tree/generator.h", - "writer/syntax_tree/generator_impl.cc", - "writer/syntax_tree/generator_impl.h", - ] - - deps = [ - ":libtint_ast_src", - ":libtint_base_src", - ":libtint_builtins_src", - ":libtint_program_src", - ":libtint_sem_src", - ":libtint_type_src", - ":libtint_writer_src", - ] -} - source_set("libtint") { public_deps = [ ":libtint_ast_src", @@ -1114,10 +1089,6 @@ source_set("libtint") { public_deps += [ ":libtint_glsl_writer_src" ] } - if (tint_build_syntax_tree_writer) { - public_deps += [ ":libtint_syntax_tree_writer_src" ] - } - configs += [ ":tint_common_config" ] public_configs = [ ":tint_public_config" ] diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt index b46c8b1db2..1d31896250 100644 --- a/src/tint/CMakeLists.txt +++ b/src/tint/CMakeLists.txt @@ -677,15 +677,6 @@ if(${TINT_BUILD_HLSL_WRITER}) ) endif() -if(${TINT_BUILD_SYNTAX_TREE_WRITER}) - list(APPEND TINT_LIB_SRCS - writer/syntax_tree/generator.cc - writer/syntax_tree/generator.h - writer/syntax_tree/generator_impl.cc - writer/syntax_tree/generator_impl.h - ) -endif() - if(${TINT_BUILD_IR}) list(APPEND TINT_LIB_SRCS ir/binary.cc diff --git a/src/tint/cmd/main.cc b/src/tint/cmd/main.cc index 22cbf0b885..0b2aad271f 100644 --- a/src/tint/cmd/main.cc +++ b/src/tint/cmd/main.cc @@ -29,10 +29,6 @@ #include "glslang/Public/ShaderLang.h" #endif // TINT_BUILD_GLSL_WRITER -#if TINT_BUILD_SYNTAX_TREE_WRITER -#include "src/tint/writer/syntax_tree/generator.h" -#endif // TINT_BUILD_SYNTAX_TREE_WRITER - #if TINT_BUILD_SPV_READER #include "spirv-tools/libspirv.hpp" #endif // TINT_BUILD_SPV_READER @@ -110,10 +106,6 @@ struct Options { bool dump_ir = false; bool dump_ir_graph = false; #endif // TINT_BUILD_IR - -#if TINT_BUILD_SYNTAX_TREE_WRITER - bool dump_syntax_tree = false; -#endif // TINB_BUILD_SYNTAX_TREE_WRITER }; const char kUsage[] = R"(Usage: tint [options] @@ -391,10 +383,6 @@ bool ParseArgs(const std::vector& args, Options* opts) { } else if (arg == "--dump-ir-graph") { opts->dump_ir_graph = true; #endif // TINT_BUILD_IR -#if TINT_BUILD_SYNTAX_TREE_WRITER - } else if (arg == "--dump-ast") { - opts->dump_syntax_tree = true; -#endif // TINT_BUILD_SYNTAX_TREE_WRITER } else if (arg == "--xcrun") { ++i; if (i >= args.size()) { @@ -1067,9 +1055,6 @@ int main(int argc, const char** argv) { " --dump-ir -- Writes the IR to stdout\n" " --dump-ir-graph -- Writes the IR graph to 'tint.dot' as a dot graph\n"; #endif // TINT_BUILD_IR -#if TINT_BUILD_SYNTAX_TREE_WRITER - usage += " --dump-ast -- Writes the AST to stdout\n"; -#endif // TINT_BUILD_SYNTAX_TREE_WRITER std::cout << usage << std::endl; return 0; @@ -1107,18 +1092,6 @@ int main(int argc, const char** argv) { return 1; } -#if TINT_BUILD_SYNTAX_TREE_WRITER - if (options.dump_syntax_tree) { - tint::writer::syntax_tree::Options gen_options; - auto result = tint::writer::syntax_tree::Generate(program.get(), gen_options); - if (!result.success) { - std::cerr << "Failed to dump AST: " << result.error << std::endl; - } else { - std::cout << result.ast << std::endl; - } - } -#endif // TINT_BUILD_SYNTAX_TREE_WRITER - #if TINT_BUILD_IR if (options.dump_ir || options.dump_ir_graph) { auto result = tint::ir::Module::FromProgram(program.get()); diff --git a/src/tint/writer/syntax_tree/generator.cc b/src/tint/writer/syntax_tree/generator.cc deleted file mode 100644 index 6919d24412..0000000000 --- a/src/tint/writer/syntax_tree/generator.cc +++ /dev/null @@ -1,36 +0,0 @@ -// Copyright 2023 The Tint Authors. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include "src/tint/writer/syntax_tree/generator.h" -#include "src/tint/writer/syntax_tree/generator_impl.h" - -namespace tint::writer::syntax_tree { - -Result::Result() = default; -Result::~Result() = default; -Result::Result(const Result&) = default; - -Result Generate(const Program* program, const Options&) { - Result result; - - // Generate the AST dump. - auto impl = std::make_unique(program); - result.success = impl->Generate(); - result.error = impl->error(); - result.ast = impl->result(); - - return result; -} - -} // namespace tint::writer::syntax_tree diff --git a/src/tint/writer/syntax_tree/generator.h b/src/tint/writer/syntax_tree/generator.h deleted file mode 100644 index ce81c3fdb4..0000000000 --- a/src/tint/writer/syntax_tree/generator.h +++ /dev/null @@ -1,65 +0,0 @@ -// Copyright 2023 The Tint Authors. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#ifndef SRC_TINT_WRITER_SYNTAX_TREE_GENERATOR_H_ -#define SRC_TINT_WRITER_SYNTAX_TREE_GENERATOR_H_ - -#include -#include - -#include "src/tint/writer/text.h" - -// Forward declarations -namespace tint { -class Program; -} // namespace tint - -namespace tint::writer::syntax_tree { - -class GeneratorImpl; - -/// Configuration options used for generating AST. -struct Options {}; - -/// The result produced when generating AST. -struct Result { - /// Constructor - Result(); - - /// Destructor - ~Result(); - - /// Copy constructor - Result(const Result&); - - /// True if generation was successful. - bool success = false; - - /// The errors generated during code generation, if any. - std::string error; - - /// The generated AST. - std::string ast = ""; -}; - -/// Generate an AST dump for a program, according to a set of configuration options. -/// The result will contain the AST, as well as success status and diagnostic information. -/// @param program the program to dump -/// @param options the configuration options to use when dumping -/// @returns the resulting AST dump and supplementary information -Result Generate(const Program* program, const Options& options); - -} // namespace tint::writer::syntax_tree - -#endif // SRC_TINT_WRITER_SYNTAX_TREE_GENERATOR_H_ diff --git a/src/tint/writer/syntax_tree/generator_impl.cc b/src/tint/writer/syntax_tree/generator_impl.cc deleted file mode 100644 index e5e2f2fb7b..0000000000 --- a/src/tint/writer/syntax_tree/generator_impl.cc +++ /dev/null @@ -1,1349 +0,0 @@ -// Copyright 2023 The Tint Authors. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include "src/tint/writer/syntax_tree/generator_impl.h" - -#include - -#include "src/tint/ast/alias.h" -#include "src/tint/ast/bool_literal_expression.h" -#include "src/tint/ast/call_statement.h" -#include "src/tint/ast/float_literal_expression.h" -#include "src/tint/ast/id_attribute.h" -#include "src/tint/ast/internal_attribute.h" -#include "src/tint/ast/interpolate_attribute.h" -#include "src/tint/ast/invariant_attribute.h" -#include "src/tint/ast/module.h" -#include "src/tint/ast/stage_attribute.h" -#include "src/tint/ast/stride_attribute.h" -#include "src/tint/ast/struct_member_align_attribute.h" -#include "src/tint/ast/struct_member_offset_attribute.h" -#include "src/tint/ast/struct_member_size_attribute.h" -#include "src/tint/ast/variable_decl_statement.h" -#include "src/tint/ast/workgroup_attribute.h" -#include "src/tint/sem/struct.h" -#include "src/tint/sem/switch_statement.h" -#include "src/tint/utils/math.h" -#include "src/tint/utils/scoped_assignment.h" -#include "src/tint/writer/float_to_string.h" - -namespace tint::writer::syntax_tree { - -GeneratorImpl::GeneratorImpl(const Program* program) : TextGenerator(program) {} - -GeneratorImpl::~GeneratorImpl() = default; - -bool GeneratorImpl::Generate() { - // Generate global declarations in the order they appear in the module. - for (auto* decl : program_->AST().GlobalDeclarations()) { - if (!Switch( - decl, // - [&](const ast::DiagnosticDirective* dd) { - return EmitDiagnosticControl(dd->control); - }, - [&](const ast::Enable* e) { return EmitEnable(e); }, - [&](const ast::TypeDecl* td) { return EmitTypeDecl(td); }, - [&](const ast::Function* func) { return EmitFunction(func); }, - [&](const ast::Variable* var) { return EmitVariable(var); }, - [&](const ast::ConstAssert* ca) { return EmitConstAssert(ca); }, - [&](Default) { - TINT_UNREACHABLE(Writer, diagnostics_); - return false; - })) { - return false; - } - if (decl != program_->AST().GlobalDeclarations().Back()) { - line(); - } - } - - return true; -} - -bool GeneratorImpl::EmitDiagnosticControl(const ast::DiagnosticControl& diagnostic) { - line() << "DiagnosticControl [severity: " << diagnostic.severity - << ", rule: " << program_->Symbols().NameFor(diagnostic.rule_name->symbol) << "]"; - return true; -} - -bool GeneratorImpl::EmitEnable(const ast::Enable* enable) { - line() << "Enable [" << enable->extension << "]"; - return true; -} - -bool GeneratorImpl::EmitTypeDecl(const ast::TypeDecl* ty) { - return Switch( - ty, - [&](const ast::Alias* alias) { // - line() << "Alias ["; - { - ScopedIndent ai(this); - - line() << "name: " << program_->Symbols().NameFor(alias->name->symbol); - line() << "expr: "; - { - ScopedIndent ex(this); - if (!EmitExpression(alias->type)) { - return false; - } - } - } - line() << "]"; - return true; - }, - [&](const ast::Struct* str) { // - return EmitStructType(str); - }, - [&](Default) { // - diagnostics_.add_error(diag::System::Writer, - "unknown declared type: " + std::string(ty->TypeInfo().name)); - return false; - }); -} - -bool GeneratorImpl::EmitExpression(const ast::Expression* expr) { - return Switch( - expr, - [&](const ast::IndexAccessorExpression* a) { // - return EmitIndexAccessor(a); - }, - [&](const ast::BinaryExpression* b) { // - return EmitBinary(b); - }, - [&](const ast::BitcastExpression* b) { // - return EmitBitcast(b); - }, - [&](const ast::CallExpression* c) { // - return EmitCall(c); - }, - [&](const ast::IdentifierExpression* i) { // - return EmitIdentifier(i); - }, - [&](const ast::LiteralExpression* l) { // - return EmitLiteral(l); - }, - [&](const ast::MemberAccessorExpression* m) { // - return EmitMemberAccessor(m); - }, - [&](const ast::PhonyExpression*) { // - line() << "[PhonyExpression]"; - return true; - }, - [&](const ast::UnaryOpExpression* u) { // - return EmitUnaryOp(u); - }, - [&](Default) { - diagnostics_.add_error(diag::System::Writer, "unknown expression type"); - return false; - }); -} - -bool GeneratorImpl::EmitIndexAccessor(const ast::IndexAccessorExpression* expr) { - line() << "IndexAccessorExpression ["; - { - ScopedIndent iae(this); - line() << "object: "; - { - ScopedIndent obj(this); - if (!EmitExpression(expr->object)) { - return false; - } - } - - line() << "index: "; - { - ScopedIndent idx(this); - if (!EmitExpression(expr->index)) { - return false; - } - } - } - line() << "]"; - - return true; -} - -bool GeneratorImpl::EmitMemberAccessor(const ast::MemberAccessorExpression* expr) { - line() << "MemberAccessorExpression ["; - { - ScopedIndent mae(this); - - line() << "object: "; - { - ScopedIndent obj(this); - if (!EmitExpression(expr->object)) { - return false; - } - } - line() << "member: " << program_->Symbols().NameFor(expr->member->symbol); - } - line() << "]"; - return true; -} - -bool GeneratorImpl::EmitBitcast(const ast::BitcastExpression* expr) { - line() << "BitcastExpression ["; - { - ScopedIndent bc(this); - { - line() << "type: "; - ScopedIndent ty(this); - if (!EmitExpression(expr->type)) { - return false; - } - } - { - line() << "expr: "; - ScopedIndent exp(this); - if (!EmitExpression(expr->expr)) { - return false; - } - } - } - line() << "]"; - return true; -} - -bool GeneratorImpl::EmitCall(const ast::CallExpression* expr) { - line() << "Call ["; - { - ScopedIndent cl(this); - - line() << "target: ["; - { - ScopedIndent tgt(this); - if (!EmitExpression(expr->target)) { - return false; - } - } - line() << "]"; - - if (!expr->args.IsEmpty()) { - line() << "args: ["; - { - ScopedIndent args(this); - for (auto* arg : expr->args) { - line() << "arg: ["; - { - ScopedIndent arg_val(this); - if (!EmitExpression(arg)) { - return false; - } - } - line() << "]"; - } - } - line() << "]"; - } - } - line() << "]"; - return true; -} - -bool GeneratorImpl::EmitLiteral(const ast::LiteralExpression* lit) { - bool ret = false; - line() << "LiteralExpression ["; - { - ScopedIndent le(this); - ret = Switch( - lit, - [&](const ast::BoolLiteralExpression* l) { // - line() << (l->value ? "true" : "false"); - return true; - }, - [&](const ast::FloatLiteralExpression* l) { // - // f16 literals are also emitted as float value with suffix "h". - // Note that all normal and subnormal f16 values are normal f32 values, and since - // NaN and Inf are not allowed to be spelled in literal, it should be fine to emit - // f16 literals in this way. - if (l->suffix == ast::FloatLiteralExpression::Suffix::kNone) { - line() << DoubleToBitPreservingString(l->value); - } else { - line() << FloatToBitPreservingString(static_cast(l->value)) << l->suffix; - } - return true; - }, - [&](const ast::IntLiteralExpression* l) { // - line() << l->value << l->suffix; - return true; - }, - [&](Default) { // - diagnostics_.add_error(diag::System::Writer, "unknown literal type"); - return false; - }); - } - line() << "]"; - return ret; -} - -bool GeneratorImpl::EmitIdentifier(const ast::IdentifierExpression* expr) { - bool ret = false; - line() << "IdentifierExpression ["; - { - ScopedIndent ie(this); - ret = EmitIdentifier(expr->identifier); - } - line() << "]"; - return ret; -} - -bool GeneratorImpl::EmitIdentifier(const ast::Identifier* ident) { - line() << "Identifier ["; - { - ScopedIndent id(this); - if (auto* tmpl_ident = ident->As()) { - line() << "Templated ["; - { - ScopedIndent tmpl(this); - if (!tmpl_ident->attributes.IsEmpty()) { - line() << "attrs: ["; - { - ScopedIndent attrs(this); - EmitAttributes(tmpl_ident->attributes); - } - line() << "]"; - } - line() << "name: " << program_->Symbols().NameFor(ident->symbol); - if (!tmpl_ident->arguments.IsEmpty()) { - line() << "args: ["; - { - ScopedIndent args(this); - for (auto* expr : tmpl_ident->arguments) { - if (!EmitExpression(expr)) { - return false; - } - } - } - line() << "]"; - } - } - line() << "]"; - } else { - line() << program_->Symbols().NameFor(ident->symbol); - } - } - line() << "]"; - return true; -} - -bool GeneratorImpl::EmitFunction(const ast::Function* func) { - line() << "Function ["; - { - ScopedIndent funct(this); - - if (func->attributes.Length()) { - line() << "attrs: ["; - { - ScopedIndent attrs(this); - if (!EmitAttributes(func->attributes)) { - return false; - } - } - line() << "]"; - } - line() << "name: " << program_->Symbols().NameFor(func->name->symbol); - - if (!func->params.IsEmpty()) { - line() << "params: ["; - { - ScopedIndent args(this); - for (auto* v : func->params) { - line() << "param: ["; - { - ScopedIndent param(this); - line() << "name: " << program_->Symbols().NameFor(v->name->symbol); - if (!v->attributes.IsEmpty()) { - line() << "attrs: ["; - { - ScopedIndent attrs(this); - if (!EmitAttributes(v->attributes)) { - return false; - } - } - line() << "]"; - } - line() << "type: ["; - { - ScopedIndent ty(this); - if (!EmitExpression(v->type)) { - return false; - } - } - line() << "]"; - } - line() << "]"; - } - } - line() << "]"; - } - - line() << "return: ["; - { - ScopedIndent ret(this); - - if (func->return_type || !func->return_type_attributes.IsEmpty()) { - if (!func->return_type_attributes.IsEmpty()) { - line() << "attrs: ["; - { - ScopedIndent attrs(this); - if (!EmitAttributes(func->return_type_attributes)) { - return false; - } - } - line() << "]"; - } - - line() << "type: ["; - { - ScopedIndent ty(this); - if (!EmitExpression(func->return_type)) { - return false; - } - } - line() << "]"; - } else { - line() << "void"; - } - } - line() << "]"; - line() << "body: ["; - { - ScopedIndent bdy(this); - if (func->body) { - if (!EmitBlockHeader(func->body)) { - return false; - } - if (!EmitStatementsWithIndent(func->body->statements)) { - return false; - } - } - } - line() << "]"; - } - line() << "]"; - return true; -} - -bool GeneratorImpl::EmitImageFormat(const builtin::TexelFormat fmt) { - line() << "builtin::TexelFormat [" << fmt << "]"; - return true; -} - -bool GeneratorImpl::EmitStructType(const ast::Struct* str) { - line() << "Struct ["; - { - ScopedIndent strct(this); - - if (str->attributes.Length()) { - line() << "attrs: ["; - { - ScopedIndent attrs(this); - if (!EmitAttributes(str->attributes)) { - return false; - } - } - line() << "]"; - } - line() << "name: " << program_->Symbols().NameFor(str->name->symbol); - line() << "members: ["; - { - ScopedIndent membs(this); - - for (auto* mem : str->members) { - line() << "StructMember["; - { - ScopedIndent m(this); - if (!mem->attributes.IsEmpty()) { - line() << "attrs: ["; - { - ScopedIndent attrs(this); - if (!EmitAttributes(mem->attributes)) { - return false; - } - } - line() << "]"; - } - - line() << "name: " << program_->Symbols().NameFor(mem->name->symbol); - line() << "type: ["; - { - ScopedIndent ty(this); - if (!EmitExpression(mem->type)) { - return false; - } - } - line() << "]"; - } - } - line() << "]"; - } - line() << "]"; - } - line() << "]"; - return true; -} - -bool GeneratorImpl::EmitVariable(const ast::Variable* v) { - line() << "Variable ["; - { - ScopedIndent variable(this); - if (!v->attributes.IsEmpty()) { - line() << "attrs: ["; - { - ScopedIndent attr(this); - if (!EmitAttributes(v->attributes)) { - return false; - } - } - line() << "]"; - } - - bool ok = Switch( - v, // - [&](const ast::Var* var) { - if (var->declared_address_space || var->declared_access) { - line() << "Var ["; - { - ScopedIndent vr(this); - line() << "address_space: ["; - { - ScopedIndent addr(this); - if (!EmitExpression(var->declared_address_space)) { - return false; - } - } - line() << "]"; - if (var->declared_access) { - line() << "access: ["; - { - ScopedIndent acs(this); - if (!EmitExpression(var->declared_access)) { - return false; - } - } - line() << "]"; - } - } - line() << "]"; - } else { - line() << "Var []"; - } - return true; - }, - [&](const ast::Let*) { - line() << "Let []"; - return true; - }, - [&](const ast::Override*) { - line() << "Override []"; - return true; - }, - [&](const ast::Const*) { - line() << "Const []"; - return true; - }, - [&](Default) { - TINT_ICE(Writer, diagnostics_) << "unhandled variable type " << v->TypeInfo().name; - return false; - }); - if (!ok) { - return false; - } - - line() << "name: " << program_->Symbols().NameFor(v->name->symbol); - - if (auto ty = v->type) { - line() << "type: ["; - { - ScopedIndent vty(this); - if (!EmitExpression(ty)) { - return false; - } - } - line() << "]"; - } - - if (v->initializer != nullptr) { - line() << "initializer: ["; - { - ScopedIndent init(this); - if (!EmitExpression(v->initializer)) { - return false; - } - } - line() << "]"; - } - } - line() << "]"; - return true; -} - -bool GeneratorImpl::EmitAttributes(utils::VectorRef attrs) { - for (auto* attr : attrs) { - bool ok = Switch( - attr, - [&](const ast::WorkgroupAttribute* workgroup) { - auto values = workgroup->Values(); - line() << "WorkgroupAttribute ["; - { - ScopedIndent wg(this); - for (size_t i = 0; i < 3; i++) { - if (values[i]) { - if (!EmitExpression(values[i])) { - return false; - } - } - } - } - line() << "]"; - return true; - }, - [&](const ast::StageAttribute* stage) { - line() << "StageAttribute [" << stage->stage << "]"; - return true; - }, - [&](const ast::BindingAttribute* binding) { - line() << "BindingAttribute ["; - { - ScopedIndent ba(this); - if (!EmitExpression(binding->expr)) { - return false; - } - } - line() << "]"; - return true; - }, - [&](const ast::GroupAttribute* group) { - line() << "GroupAttribute ["; - { - ScopedIndent ga(this); - if (!EmitExpression(group->expr)) { - return false; - } - } - line() << "]"; - return true; - }, - [&](const ast::LocationAttribute* location) { - line() << "LocationAttribute ["; - { - ScopedIndent la(this); - if (!EmitExpression(location->expr)) { - return false; - } - } - line() << "]"; - return true; - }, - [&](const ast::BuiltinAttribute* builtin) { - line() << "BuiltinAttribute ["; - { - ScopedIndent ba(this); - if (!EmitExpression(builtin->builtin)) { - return false; - } - } - line() << "]"; - return true; - }, - [&](const ast::DiagnosticAttribute* diagnostic) { - return EmitDiagnosticControl(diagnostic->control); - }, - [&](const ast::InterpolateAttribute* interpolate) { - line() << "InterpolateAttribute ["; - { - ScopedIndent ia(this); - line() << "type: ["; - { - ScopedIndent ty(this); - if (!EmitExpression(interpolate->type)) { - return false; - } - } - line() << "]"; - if (interpolate->sampling) { - line() << "sampling: ["; - { - ScopedIndent sa(this); - if (!EmitExpression(interpolate->sampling)) { - return false; - } - } - line() << "]"; - } - } - line() << "]"; - return true; - }, - [&](const ast::InvariantAttribute*) { - line() << "InvariantAttribute []"; - return true; - }, - [&](const ast::IdAttribute* override_deco) { - line() << "IdAttribute ["; - { - ScopedIndent id(this); - if (!EmitExpression(override_deco->expr)) { - return false; - } - } - line() << "]"; - return true; - }, - [&](const ast::MustUseAttribute*) { - line() << "MustUseAttribute []"; - return true; - }, - [&](const ast::StructMemberOffsetAttribute* offset) { - line() << "StructMemberOffsetAttribute ["; - { - ScopedIndent smoa(this); - if (!EmitExpression(offset->expr)) { - return false; - } - } - line() << "]"; - return true; - }, - [&](const ast::StructMemberSizeAttribute* size) { - line() << "StructMemberSizeAttribute ["; - { - ScopedIndent smsa(this); - if (!EmitExpression(size->expr)) { - return false; - } - } - line() << "]"; - return true; - }, - [&](const ast::StructMemberAlignAttribute* align) { - line() << "StructMemberAlignAttribute ["; - { - ScopedIndent smaa(this); - if (!EmitExpression(align->expr)) { - return false; - } - } - line() << "]"; - return true; - }, - [&](const ast::StrideAttribute* stride) { - line() << "StrideAttribute [" << stride->stride << "]"; - return true; - }, - [&](const ast::InternalAttribute* internal) { - line() << "InternalAttribute [" << internal->InternalName() << "]"; - return true; - }, - [&](Default) { - TINT_ICE(Writer, diagnostics_) - << "Unsupported attribute '" << attr->TypeInfo().name << "'"; - return false; - }); - - if (!ok) { - return false; - } - } - return true; -} - -bool GeneratorImpl::EmitBinary(const ast::BinaryExpression* expr) { - line() << "BinaryExpression ["; - { - ScopedIndent be(this); - line() << "lhs: ["; - { - ScopedIndent lhs(this); - - if (!EmitExpression(expr->lhs)) { - return false; - } - } - line() << "]"; - line() << "op: ["; - { - ScopedIndent op(this); - if (!EmitBinaryOp(expr->op)) { - return false; - } - } - line() << "]"; - line() << "rhs: ["; - { - ScopedIndent rhs(this); - if (!EmitExpression(expr->rhs)) { - return false; - } - } - line() << "]"; - } - line() << "]"; - return true; -} - -bool GeneratorImpl::EmitBinaryOp(const ast::BinaryOp op) { - switch (op) { - case ast::BinaryOp::kAnd: - line() << "&"; - break; - case ast::BinaryOp::kOr: - line() << "|"; - break; - case ast::BinaryOp::kXor: - line() << "^"; - break; - case ast::BinaryOp::kLogicalAnd: - line() << "&&"; - break; - case ast::BinaryOp::kLogicalOr: - line() << "||"; - break; - case ast::BinaryOp::kEqual: - line() << "=="; - break; - case ast::BinaryOp::kNotEqual: - line() << "!="; - break; - case ast::BinaryOp::kLessThan: - line() << "<"; - break; - case ast::BinaryOp::kGreaterThan: - line() << ">"; - break; - case ast::BinaryOp::kLessThanEqual: - line() << "<="; - break; - case ast::BinaryOp::kGreaterThanEqual: - line() << ">="; - break; - case ast::BinaryOp::kShiftLeft: - line() << "<<"; - break; - case ast::BinaryOp::kShiftRight: - line() << ">>"; - break; - case ast::BinaryOp::kAdd: - line() << "+"; - break; - case ast::BinaryOp::kSubtract: - line() << "-"; - break; - case ast::BinaryOp::kMultiply: - line() << "*"; - break; - case ast::BinaryOp::kDivide: - line() << "/"; - break; - case ast::BinaryOp::kModulo: - line() << "%"; - break; - case ast::BinaryOp::kNone: - diagnostics_.add_error(diag::System::Writer, "missing binary operation type"); - return false; - } - return true; -} - -bool GeneratorImpl::EmitUnaryOp(const ast::UnaryOpExpression* expr) { - line() << "UnaryOpExpression ["; - { - ScopedIndent uoe(this); - line() << "op: ["; - { - ScopedIndent op(this); - switch (expr->op) { - case ast::UnaryOp::kAddressOf: - line() << "&"; - break; - case ast::UnaryOp::kComplement: - line() << "~"; - break; - case ast::UnaryOp::kIndirection: - line() << "*"; - break; - case ast::UnaryOp::kNot: - line() << "!"; - break; - case ast::UnaryOp::kNegation: - line() << "-"; - break; - } - } - line() << "]"; - line() << "expr: ["; - { - ScopedIndent ex(this); - if (!EmitExpression(expr->expr)) { - return false; - } - } - line() << "]"; - } - line() << "]"; - - return true; -} - -bool GeneratorImpl::EmitBlock(const ast::BlockStatement* stmt) { - { - if (!EmitBlockHeader(stmt)) { - return false; - } - } - if (!EmitStatementsWithIndent(stmt->statements)) { - return false; - } - - return true; -} - -bool GeneratorImpl::EmitBlockHeader(const ast::BlockStatement* stmt) { - if (!stmt->attributes.IsEmpty()) { - line() << "attrs: ["; - { - ScopedIndent attrs(this); - if (!EmitAttributes(stmt->attributes)) { - return false; - } - } - line() << "]"; - } - return true; -} - -bool GeneratorImpl::EmitStatement(const ast::Statement* stmt) { - return Switch( - stmt, // - [&](const ast::AssignmentStatement* a) { return EmitAssign(a); }, - [&](const ast::BlockStatement* b) { return EmitBlock(b); }, - [&](const ast::BreakStatement* b) { return EmitBreak(b); }, - [&](const ast::BreakIfStatement* b) { return EmitBreakIf(b); }, - [&](const ast::CallStatement* c) { return EmitCall(c->expr); }, - [&](const ast::CompoundAssignmentStatement* c) { return EmitCompoundAssign(c); }, - [&](const ast::ContinueStatement* c) { return EmitContinue(c); }, - [&](const ast::DiscardStatement* d) { return EmitDiscard(d); }, - [&](const ast::IfStatement* i) { return EmitIf(i); }, - [&](const ast::IncrementDecrementStatement* l) { return EmitIncrementDecrement(l); }, - [&](const ast::LoopStatement* l) { return EmitLoop(l); }, - [&](const ast::ForLoopStatement* l) { return EmitForLoop(l); }, - [&](const ast::WhileStatement* l) { return EmitWhile(l); }, - [&](const ast::ReturnStatement* r) { return EmitReturn(r); }, - [&](const ast::ConstAssert* c) { return EmitConstAssert(c); }, - [&](const ast::SwitchStatement* s) { return EmitSwitch(s); }, - [&](const ast::VariableDeclStatement* v) { return EmitVariable(v->variable); }, - [&](Default) { - diagnostics_.add_error(diag::System::Writer, - "unknown statement type: " + std::string(stmt->TypeInfo().name)); - return false; - }); -} - -bool GeneratorImpl::EmitStatements(utils::VectorRef stmts) { - for (auto* s : stmts) { - if (!EmitStatement(s)) { - return false; - } - } - return true; -} - -bool GeneratorImpl::EmitStatementsWithIndent(utils::VectorRef stmts) { - ScopedIndent si(this); - return EmitStatements(stmts); -} - -bool GeneratorImpl::EmitAssign(const ast::AssignmentStatement* stmt) { - line() << "AssignmentStatement ["; - { - ScopedIndent as(this); - line() << "lhs: ["; - { - ScopedIndent lhs(this); - if (!EmitExpression(stmt->lhs)) { - return false; - } - } - line() << "]"; - line() << "rhs: ["; - { - ScopedIndent rhs(this); - if (!EmitExpression(stmt->rhs)) { - return false; - } - line() << "]"; - } - } - line() << "]"; - - return true; -} - -bool GeneratorImpl::EmitBreak(const ast::BreakStatement*) { - line() << "BreakStatement []"; - return true; -} - -bool GeneratorImpl::EmitBreakIf(const ast::BreakIfStatement* b) { - line() << "BreakIfStatement ["; - { - ScopedIndent bis(this); - if (!EmitExpression(b->condition)) { - return false; - } - } - line() << "]"; - return true; -} - -bool GeneratorImpl::EmitCase(const ast::CaseStatement* stmt) { - line() << "CaseStatement ["; - { - ScopedIndent cs(this); - if (stmt->selectors.Length() == 1 && stmt->ContainsDefault()) { - line() << "selector: default"; - if (!EmitBlockHeader(stmt->body)) { - return false; - } - } else { - line() << "selectors: ["; - { - ScopedIndent sels(this); - for (auto* sel : stmt->selectors) { - if (sel->IsDefault()) { - line() << "default []"; - } else if (!EmitExpression(sel->expr)) { - return false; - } - } - } - line() << "]"; - if (!EmitBlockHeader(stmt->body)) { - return false; - } - } - if (!EmitStatementsWithIndent(stmt->body->statements)) { - return false; - } - } - line() << "]"; - return true; -} - -bool GeneratorImpl::EmitCompoundAssign(const ast::CompoundAssignmentStatement* stmt) { - line() << "CompoundAssignmentStatement ["; - { - ScopedIndent cas(this); - line() << "lhs: ["; - { - ScopedIndent lhs(this); - if (!EmitExpression(stmt->lhs)) { - return false; - } - } - line() << "]"; - - line() << "op: ["; - { - ScopedIndent op(this); - if (!EmitBinaryOp(stmt->op)) { - return false; - } - } - line() << "]"; - line() << "rhs: ["; - { - ScopedIndent rhs(this); - - if (!EmitExpression(stmt->rhs)) { - return false; - } - } - line() << "]"; - } - line() << "]"; - return true; -} - -bool GeneratorImpl::EmitContinue(const ast::ContinueStatement*) { - line() << "ContinueStatement []"; - return true; -} - -bool GeneratorImpl::EmitIf(const ast::IfStatement* stmt) { - { - line() << "IfStatement ["; - { - ScopedIndent ifs(this); - line() << "condition: ["; - { - ScopedIndent cond(this); - if (!EmitExpression(stmt->condition)) { - return false; - } - } - line() << "]"; - if (!EmitBlockHeader(stmt->body)) { - return false; - } - } - line() << "] "; - } - if (!EmitStatementsWithIndent(stmt->body->statements)) { - return false; - } - - const ast::Statement* e = stmt->else_statement; - while (e) { - if (auto* elseif = e->As()) { - { - line() << "Else IfStatement ["; - { - ScopedIndent ifs(this); - line() << "condition: ["; - if (!EmitExpression(elseif->condition)) { - return false; - } - } - line() << "]"; - if (!EmitBlockHeader(elseif->body)) { - return false; - } - } - line() << "]"; - if (!EmitStatementsWithIndent(elseif->body->statements)) { - return false; - } - e = elseif->else_statement; - } else { - auto* body = e->As(); - { - line() << "Else ["; - { - ScopedIndent els(this); - if (!EmitBlockHeader(body)) { - return false; - } - } - line() << "]"; - } - if (!EmitStatementsWithIndent(body->statements)) { - return false; - } - break; - } - } - return true; -} - -bool GeneratorImpl::EmitIncrementDecrement(const ast::IncrementDecrementStatement* stmt) { - line() << "IncrementDecrementStatement ["; - { - ScopedIndent ids(this); - line() << "expr: ["; - if (!EmitExpression(stmt->lhs)) { - return false; - } - line() << "]"; - line() << "dir: " << (stmt->increment ? "++" : "--"); - } - line() << "]"; - return true; -} - -bool GeneratorImpl::EmitDiscard(const ast::DiscardStatement*) { - line() << "DiscardStatement []"; - return true; -} - -bool GeneratorImpl::EmitLoop(const ast::LoopStatement* stmt) { - line() << "LoopStatement ["; - { - ScopedIndent ls(this); - if (!EmitStatements(stmt->body->statements)) { - return false; - } - - if (stmt->continuing && !stmt->continuing->Empty()) { - line() << "Continuing ["; - { - ScopedIndent cont(this); - if (!EmitStatementsWithIndent(stmt->continuing->statements)) { - return false; - } - } - line() << "]"; - } - } - line() << "]"; - - return true; -} - -bool GeneratorImpl::EmitForLoop(const ast::ForLoopStatement* stmt) { - TextBuffer init_buf; - if (auto* init = stmt->initializer) { - TINT_SCOPED_ASSIGNMENT(current_buffer_, &init_buf); - if (!EmitStatement(init)) { - return false; - } - } - - TextBuffer cont_buf; - if (auto* cont = stmt->continuing) { - TINT_SCOPED_ASSIGNMENT(current_buffer_, &cont_buf); - if (!EmitStatement(cont)) { - return false; - } - } - - line() << "ForLoopStatement ["; - { - ScopedIndent fs(this); - - line() << "initializer: ["; - { - ScopedIndent init(this); - switch (init_buf.lines.size()) { - case 0: // No initializer - break; - case 1: // Single line initializer statement - line() << TrimSuffix(init_buf.lines[0].content, ";"); - break; - default: // Block initializer statement - for (size_t i = 1; i < init_buf.lines.size(); i++) { - // Indent all by the first line - init_buf.lines[i].indent += current_buffer_->current_indent; - } - line() << TrimSuffix(init_buf.String(), "\n"); - break; - } - } - line() << "]"; - line() << "condition: ["; - { - ScopedIndent con(this); - if (auto* cond = stmt->condition) { - if (!EmitExpression(cond)) { - return false; - } - } - } - - line() << "]"; - line() << "continuing: ["; - { - ScopedIndent cont(this); - switch (cont_buf.lines.size()) { - case 0: // No continuing - break; - case 1: // Single line continuing statement - line() << TrimSuffix(cont_buf.lines[0].content, ";"); - break; - default: // Block continuing statement - for (size_t i = 1; i < cont_buf.lines.size(); i++) { - // Indent all by the first line - cont_buf.lines[i].indent += current_buffer_->current_indent; - } - line() << TrimSuffix(cont_buf.String(), "\n"); - break; - } - } - if (!EmitBlockHeader(stmt->body)) { - return false; - } - - if (!EmitStatementsWithIndent(stmt->body->statements)) { - return false; - } - } - line() << "]"; - - return true; -} - -bool GeneratorImpl::EmitWhile(const ast::WhileStatement* stmt) { - line() << "WhileStatement ["; - { - ScopedIndent ws(this); - { - auto* cond = stmt->condition; - if (!EmitExpression(cond)) { - return false; - } - } - if (!EmitBlockHeader(stmt->body)) { - return false; - } - if (!EmitStatementsWithIndent(stmt->body->statements)) { - return false; - } - } - line() << "]"; - return true; -} - -bool GeneratorImpl::EmitReturn(const ast::ReturnStatement* stmt) { - line() << "ReturnStatement ["; - { - ScopedIndent ret(this); - if (stmt->value) { - if (!EmitExpression(stmt->value)) { - return false; - } - } - } - line() << "]"; - return true; -} - -bool GeneratorImpl::EmitConstAssert(const ast::ConstAssert* stmt) { - line() << "ConstAssert ["; - { - ScopedIndent ca(this); - if (!EmitExpression(stmt->condition)) { - return false; - } - } - line() << "]"; - return true; -} - -bool GeneratorImpl::EmitSwitch(const ast::SwitchStatement* stmt) { - line() << "SwitchStatement ["; - { - ScopedIndent ss(this); - line() << "condition: ["; - { - ScopedIndent cond(this); - if (!EmitExpression(stmt->condition)) { - return false; - } - } - line() << "]"; - - { - ScopedIndent si(this); - for (auto* s : stmt->body) { - if (!EmitCase(s)) { - return false; - } - } - } - } - line() << "]"; - return true; -} - -} // namespace tint::writer::syntax_tree diff --git a/src/tint/writer/syntax_tree/generator_impl.h b/src/tint/writer/syntax_tree/generator_impl.h deleted file mode 100644 index 8b9a187128..0000000000 --- a/src/tint/writer/syntax_tree/generator_impl.h +++ /dev/null @@ -1,215 +0,0 @@ -// Copyright 2023 The Tint Authors. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#ifndef SRC_TINT_WRITER_SYNTAX_TREE_GENERATOR_IMPL_H_ -#define SRC_TINT_WRITER_SYNTAX_TREE_GENERATOR_IMPL_H_ - -#include - -#include "src/tint/ast/assignment_statement.h" -#include "src/tint/ast/binary_expression.h" -#include "src/tint/ast/bitcast_expression.h" -#include "src/tint/ast/break_if_statement.h" -#include "src/tint/ast/break_statement.h" -#include "src/tint/ast/compound_assignment_statement.h" -#include "src/tint/ast/continue_statement.h" -#include "src/tint/ast/discard_statement.h" -#include "src/tint/ast/for_loop_statement.h" -#include "src/tint/ast/if_statement.h" -#include "src/tint/ast/index_accessor_expression.h" -#include "src/tint/ast/loop_statement.h" -#include "src/tint/ast/member_accessor_expression.h" -#include "src/tint/ast/return_statement.h" -#include "src/tint/ast/switch_statement.h" -#include "src/tint/ast/unary_op_expression.h" -#include "src/tint/program.h" -#include "src/tint/sem/struct.h" -#include "src/tint/utils/string_stream.h" -#include "src/tint/writer/text_generator.h" - -namespace tint::writer::syntax_tree { - -/// Implementation class for AST generator -class GeneratorImpl : public TextGenerator { - public: - /// Constructor - /// @param program the program - explicit GeneratorImpl(const Program* program); - ~GeneratorImpl(); - - /// Generates the result data - /// @returns true on successful generation; false otherwise - bool Generate(); - - /// Handles generating a diagnostic control - /// @param diagnostic the diagnostic control node - /// @returns true if the diagnostic control was emitted - bool EmitDiagnosticControl(const ast::DiagnosticControl& diagnostic); - /// Handles generating an enable directive - /// @param enable the enable node - /// @returns true if the enable directive was emitted - bool EmitEnable(const ast::Enable* enable); - /// Handles generating a declared type - /// @param ty the declared type to generate - /// @returns true if the declared type was emitted - bool EmitTypeDecl(const ast::TypeDecl* ty); - /// Handles an index accessor expression - /// @param expr the expression to emit - /// @returns true if the index accessor was emitted - bool EmitIndexAccessor(const ast::IndexAccessorExpression* expr); - /// Handles an assignment statement - /// @param stmt the statement to emit - /// @returns true if the statement was emitted successfully - bool EmitAssign(const ast::AssignmentStatement* stmt); - /// Handles generating a binary expression - /// @param expr the binary expression - /// @returns true if the expression was emitted, false otherwise - bool EmitBinary(const ast::BinaryExpression* expr); - /// Handles generating a binary operator - /// @param op the binary operator - /// @returns true if the operator was emitted, false otherwise - bool EmitBinaryOp(const ast::BinaryOp op); - /// Handles generating a bitcast expression - /// @param expr the bitcast expression - /// @returns true if the bitcast was emitted - bool EmitBitcast(const ast::BitcastExpression* expr); - /// Handles a block statement - /// @param stmt the statement to emit - /// @returns true if the statement was emitted successfully - bool EmitBlock(const ast::BlockStatement* stmt); - /// Handles emitting the start of a block statement (including attributes) - /// @param stmt the block statement to emit the header for - /// @returns true if the statement was emitted successfully - bool EmitBlockHeader(const ast::BlockStatement* stmt); - /// Handles a break statement - /// @param stmt the statement to emit - /// @returns true if the statement was emitted successfully - bool EmitBreak(const ast::BreakStatement* stmt); - /// Handles a break-if statement - /// @param stmt the statement to emit - /// @returns true if the statement was emitted successfully - bool EmitBreakIf(const ast::BreakIfStatement* stmt); - /// Handles generating a call expression - /// @param expr the call expression - /// @returns true if the call expression is emitted - bool EmitCall(const ast::CallExpression* expr); - /// Handles a case statement - /// @param stmt the statement - /// @returns true if the statment was emitted successfully - bool EmitCase(const ast::CaseStatement* stmt); - /// Handles a compound assignment statement - /// @param stmt the statement to emit - /// @returns true if the statement was emitted successfully - bool EmitCompoundAssign(const ast::CompoundAssignmentStatement* stmt); - /// Handles generating a literal expression - /// @param expr the literal expression expression - /// @returns true if the literal expression is emitted - bool EmitLiteral(const ast::LiteralExpression* expr); - /// Handles a continue statement - /// @param stmt the statement to emit - /// @returns true if the statement was emitted successfully - bool EmitContinue(const ast::ContinueStatement* stmt); - /// Handles generate an Expression - /// @param expr the expression - /// @returns true if the expression was emitted - bool EmitExpression(const ast::Expression* expr); - /// Handles generating a function - /// @param func the function to generate - /// @returns true if the function was emitted - bool EmitFunction(const ast::Function* func); - /// Handles generating an identifier expression - /// @param expr the identifier expression - /// @returns true if the identifier was emitted - bool EmitIdentifier(const ast::IdentifierExpression* expr); - /// Handles generating an identifier - /// @param ident the identifier - /// @returns true if the identifier was emitted - bool EmitIdentifier(const ast::Identifier* ident); - /// Handles an if statement - /// @param stmt the statement to emit - /// @returns true if the statement was successfully emitted - bool EmitIf(const ast::IfStatement* stmt); - /// Handles an increment/decrement statement - /// @param stmt the statement to emit - /// @returns true if the statement was successfully emitted - bool EmitIncrementDecrement(const ast::IncrementDecrementStatement* stmt); - /// Handles generating a discard statement - /// @param stmt the discard statement - /// @returns true if the statement was successfully emitted - bool EmitDiscard(const ast::DiscardStatement* stmt); - /// Handles a loop statement - /// @param stmt the statement to emit - /// @returns true if the statement was emtited - bool EmitLoop(const ast::LoopStatement* stmt); - /// Handles a for-loop statement - /// @param stmt the statement to emit - /// @returns true if the statement was emtited - bool EmitForLoop(const ast::ForLoopStatement* stmt); - /// Handles a while statement - /// @param stmt the statement to emit - /// @returns true if the statement was emtited - bool EmitWhile(const ast::WhileStatement* stmt); - /// Handles a member accessor expression - /// @param expr the member accessor expression - /// @returns true if the member accessor was emitted - bool EmitMemberAccessor(const ast::MemberAccessorExpression* expr); - /// Handles return statements - /// @param stmt the statement to emit - /// @returns true if the statement was successfully emitted - bool EmitReturn(const ast::ReturnStatement* stmt); - /// Handles const assertion statements - /// @param stmt the statement to emit - /// @returns true if the statement was successfully emitted - bool EmitConstAssert(const ast::ConstAssert* stmt); - /// Handles statement - /// @param stmt the statement to emit - /// @returns true if the statement was emitted - bool EmitStatement(const ast::Statement* stmt); - /// Handles a statement list - /// @param stmts the statements to emit - /// @returns true if the statements were emitted - bool EmitStatements(utils::VectorRef stmts); - /// Handles a statement list with an increased indentation - /// @param stmts the statements to emit - /// @returns true if the statements were emitted - bool EmitStatementsWithIndent(utils::VectorRef stmts); - /// Handles generating a switch statement - /// @param stmt the statement to emit - /// @returns true if the statement was emitted - bool EmitSwitch(const ast::SwitchStatement* stmt); - /// Handles generating a struct declaration - /// @param str the struct - /// @returns true if the struct is emitted - bool EmitStructType(const ast::Struct* str); - /// Handles emitting an image format - /// @param fmt the format to generate - /// @returns true if the format is emitted - bool EmitImageFormat(const builtin::TexelFormat fmt); - /// Handles a unary op expression - /// @param expr the expression to emit - /// @returns true if the expression was emitted - bool EmitUnaryOp(const ast::UnaryOpExpression* expr); - /// Handles generating a variable - /// @param var the variable to generate - /// @returns true if the variable was emitted - bool EmitVariable(const ast::Variable* var); - /// Handles generating a attribute list - /// @param attrs the attribute list - /// @returns true if the attributes were emitted - bool EmitAttributes(utils::VectorRef attrs); -}; - -} // namespace tint::writer::syntax_tree - -#endif // SRC_TINT_WRITER_SYNTAX_TREE_GENERATOR_IMPL_H_ diff --git a/tint_overrides_with_defaults.gni b/tint_overrides_with_defaults.gni index c54915d769..9e39248310 100644 --- a/tint_overrides_with_defaults.gni +++ b/tint_overrides_with_defaults.gni @@ -72,11 +72,6 @@ declare_args() { tint_build_glsl_writer = true } - # Build the Syntax Tree writer - if (!defined(tint_build_syntax_tree_writer)) { - tint_build_syntax_tree_writer = false - } - # Build unittests if (!defined(tint_build_unittests)) { tint_build_unittests = true