// Copyright 2021 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_PROGRAM_BUILDER_H_ #define SRC_TINT_PROGRAM_BUILDER_H_ #include #include #include #include "tint/override_id.h" #include "src/tint/ast/alias.h" #include "src/tint/ast/array.h" #include "src/tint/ast/assignment_statement.h" #include "src/tint/ast/atomic.h" #include "src/tint/ast/binary_expression.h" #include "src/tint/ast/binding_attribute.h" #include "src/tint/ast/bitcast_expression.h" #include "src/tint/ast/bool.h" #include "src/tint/ast/bool_literal_expression.h" #include "src/tint/ast/break_statement.h" #include "src/tint/ast/call_expression.h" #include "src/tint/ast/call_statement.h" #include "src/tint/ast/case_statement.h" #include "src/tint/ast/compound_assignment_statement.h" #include "src/tint/ast/const.h" #include "src/tint/ast/continue_statement.h" #include "src/tint/ast/depth_multisampled_texture.h" #include "src/tint/ast/depth_texture.h" #include "src/tint/ast/disable_validation_attribute.h" #include "src/tint/ast/discard_statement.h" #include "src/tint/ast/enable.h" #include "src/tint/ast/extension.h" #include "src/tint/ast/external_texture.h" #include "src/tint/ast/f16.h" #include "src/tint/ast/f32.h" #include "src/tint/ast/fallthrough_statement.h" #include "src/tint/ast/float_literal_expression.h" #include "src/tint/ast/for_loop_statement.h" #include "src/tint/ast/i32.h" #include "src/tint/ast/id_attribute.h" #include "src/tint/ast/if_statement.h" #include "src/tint/ast/increment_decrement_statement.h" #include "src/tint/ast/index_accessor_expression.h" #include "src/tint/ast/interpolate_attribute.h" #include "src/tint/ast/invariant_attribute.h" #include "src/tint/ast/let.h" #include "src/tint/ast/loop_statement.h" #include "src/tint/ast/matrix.h" #include "src/tint/ast/member_accessor_expression.h" #include "src/tint/ast/module.h" #include "src/tint/ast/multisampled_texture.h" #include "src/tint/ast/override.h" #include "src/tint/ast/parameter.h" #include "src/tint/ast/phony_expression.h" #include "src/tint/ast/pointer.h" #include "src/tint/ast/return_statement.h" #include "src/tint/ast/sampled_texture.h" #include "src/tint/ast/sampler.h" #include "src/tint/ast/stage_attribute.h" #include "src/tint/ast/static_assert.h" #include "src/tint/ast/storage_texture.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/switch_statement.h" #include "src/tint/ast/type_name.h" #include "src/tint/ast/u32.h" #include "src/tint/ast/unary_op_expression.h" #include "src/tint/ast/var.h" #include "src/tint/ast/variable_decl_statement.h" #include "src/tint/ast/vector.h" #include "src/tint/ast/void.h" #include "src/tint/ast/while_statement.h" #include "src/tint/ast/workgroup_attribute.h" #include "src/tint/number.h" #include "src/tint/program.h" #include "src/tint/program_id.h" #include "src/tint/sem/array.h" #include "src/tint/sem/bool.h" #include "src/tint/sem/constant.h" #include "src/tint/sem/depth_texture.h" #include "src/tint/sem/external_texture.h" #include "src/tint/sem/f16.h" #include "src/tint/sem/f32.h" #include "src/tint/sem/i32.h" #include "src/tint/sem/matrix.h" #include "src/tint/sem/multisampled_texture.h" #include "src/tint/sem/pointer.h" #include "src/tint/sem/sampled_texture.h" #include "src/tint/sem/storage_texture.h" #include "src/tint/sem/struct.h" #include "src/tint/sem/u32.h" #include "src/tint/sem/vector.h" #include "src/tint/sem/void.h" #ifdef INCLUDE_TINT_TINT_H_ #error "internal tint header being #included from tint.h" #endif // Forward declarations namespace tint { class CloneContext; } // namespace tint namespace tint::ast { class VariableDeclStatement; } // namespace tint::ast namespace tint { namespace detail { /// IsVectorLike::value is true if T is a utils::Vector or utils::VectorRef. template struct IsVectorLike { /// Non-specialized form of IsVectorLike defaults to false static constexpr bool value = false; }; /// IsVectorLike specialization for utils::Vector template struct IsVectorLike> { /// True for the IsVectorLike specialization of utils::Vector static constexpr bool value = true; }; /// IsVectorLike specialization for utils::VectorRef template struct IsVectorLike> { /// True for the IsVectorLike specialization of utils::VectorRef static constexpr bool value = true; }; } // namespace detail /// ProgramBuilder is a mutable builder for a Program. /// To construct a Program, populate the builder and then `std::move` it to a /// Program. class ProgramBuilder { /// A helper used to disable overloads if the first type in `TYPES` is a /// Source. Used to avoid ambiguities in overloads that take a Source as the /// first parameter and those that perfectly-forward the first argument. template using DisableIfSource = traits::EnableIfIsNotType>, Source>; /// A helper used to disable overloads if the first type in `TYPES` is a utils::Vector, /// utils::VectorRef or utils::VectorRef. template using DisableIfVectorLike = traits::EnableIf< !detail::IsVectorLike>>::value>; /// VarOptions is a helper for accepting an arbitrary number of order independent options for /// constructing an ast::Var. struct VarOptions { template explicit VarOptions(ARGS&&... args) { (Set(std::forward(args)), ...); } ~VarOptions(); const ast::Type* type = nullptr; ast::StorageClass storage = ast::StorageClass::kNone; ast::Access access = ast::Access::kUndefined; const ast::Expression* constructor = nullptr; utils::Vector attributes; private: void Set(const ast::Type* t) { type = t; } void Set(ast::StorageClass sc) { storage = sc; } void Set(ast::Access ac) { access = ac; } void Set(const ast::Expression* c) { constructor = c; } void Set(utils::VectorRef l) { attributes = std::move(l); } void Set(const ast::Attribute* a) { attributes.Push(a); } }; /// LetOptions is a helper for accepting an arbitrary number of order independent options for /// constructing an ast::Let. struct LetOptions { template explicit LetOptions(ARGS&&... args) { static constexpr bool has_init = (traits::IsTypeOrDerived>, ast::Expression> || ...); static_assert(has_init, "Let() must be constructed with an initializer expression"); (Set(std::forward(args)), ...); } ~LetOptions(); const ast::Type* type = nullptr; const ast::Expression* constructor = nullptr; utils::Vector attributes; private: void Set(const ast::Type* t) { type = t; } void Set(const ast::Expression* c) { constructor = c; } void Set(utils::VectorRef l) { attributes = std::move(l); } void Set(const ast::Attribute* a) { attributes.Push(a); } }; /// ConstOptions is a helper for accepting an arbitrary number of order independent options for /// constructing an ast::Const. struct ConstOptions { template explicit ConstOptions(ARGS&&... args) { static constexpr bool has_init = (traits::IsTypeOrDerived>, ast::Expression> || ...); static_assert(has_init, "Const() must be constructed with an initializer expression"); (Set(std::forward(args)), ...); } ~ConstOptions(); const ast::Type* type = nullptr; const ast::Expression* constructor = nullptr; utils::Vector attributes; private: void Set(const ast::Type* t) { type = t; } void Set(const ast::Expression* c) { constructor = c; } void Set(utils::VectorRef l) { attributes = std::move(l); } void Set(const ast::Attribute* a) { attributes.Push(a); } }; /// OverrideOptions is a helper for accepting an arbitrary number of order independent options /// for constructing an ast::Override. struct OverrideOptions { template explicit OverrideOptions(ARGS&&... args) { (Set(std::forward(args)), ...); } ~OverrideOptions(); const ast::Type* type = nullptr; const ast::Expression* constructor = nullptr; utils::Vector attributes; private: void Set(const ast::Type* t) { type = t; } void Set(const ast::Expression* c) { constructor = c; } void Set(utils::VectorRef l) { attributes = std::move(l); } void Set(const ast::Attribute* a) { attributes.Push(a); } }; public: /// ASTNodeAllocator is an alias to BlockAllocator using ASTNodeAllocator = utils::BlockAllocator; /// SemNodeAllocator is an alias to BlockAllocator using SemNodeAllocator = utils::BlockAllocator; /// ConstantAllocator is an alias to BlockAllocator using ConstantAllocator = utils::BlockAllocator; /// Constructor ProgramBuilder(); /// Move constructor /// @param rhs the builder to move ProgramBuilder(ProgramBuilder&& rhs); /// Destructor virtual ~ProgramBuilder(); /// Move assignment operator /// @param rhs the builder to move /// @return this builder ProgramBuilder& operator=(ProgramBuilder&& rhs); /// Wrap returns a new ProgramBuilder wrapping the Program `program` without /// making a deep clone of the Program contents. /// ProgramBuilder returned by Wrap() is intended to temporarily extend an /// existing immutable program. /// As the returned ProgramBuilder wraps `program`, `program` must not be /// destructed or assigned while using the returned ProgramBuilder. /// TODO(bclayton) - Evaluate whether there are safer alternatives to this /// function. See crbug.com/tint/460. /// @param program the immutable Program to wrap /// @return the ProgramBuilder that wraps `program` static ProgramBuilder Wrap(const Program* program); /// @returns the unique identifier for this program ProgramID ID() const { return id_; } /// @returns a reference to the program's types sem::Manager& Types() { AssertNotMoved(); return types_; } /// @returns a reference to the program's types const sem::Manager& Types() const { AssertNotMoved(); return types_; } /// @returns a reference to the program's AST nodes storage ASTNodeAllocator& ASTNodes() { AssertNotMoved(); return ast_nodes_; } /// @returns a reference to the program's AST nodes storage const ASTNodeAllocator& ASTNodes() const { AssertNotMoved(); return ast_nodes_; } /// @returns a reference to the program's semantic nodes storage SemNodeAllocator& SemNodes() { AssertNotMoved(); return sem_nodes_; } /// @returns a reference to the program's semantic nodes storage const SemNodeAllocator& SemNodes() const { AssertNotMoved(); return sem_nodes_; } /// @returns a reference to the program's semantic constant storage ConstantAllocator& ConstantNodes() { AssertNotMoved(); return constant_nodes_; } /// @returns a reference to the program's AST root Module ast::Module& AST() { AssertNotMoved(); return *ast_; } /// @returns a reference to the program's AST root Module const ast::Module& AST() const { AssertNotMoved(); return *ast_; } /// @returns a reference to the program's semantic info sem::Info& Sem() { AssertNotMoved(); return sem_; } /// @returns a reference to the program's semantic info const sem::Info& Sem() const { AssertNotMoved(); return sem_; } /// @returns a reference to the program's SymbolTable SymbolTable& Symbols() { AssertNotMoved(); return symbols_; } /// @returns a reference to the program's SymbolTable const SymbolTable& Symbols() const { AssertNotMoved(); return symbols_; } /// @returns a reference to the program's diagnostics diag::List& Diagnostics() { AssertNotMoved(); return diagnostics_; } /// @returns a reference to the program's diagnostics const diag::List& Diagnostics() const { AssertNotMoved(); return diagnostics_; } /// Controls whether the Resolver will be run on the program when it is built. /// @param enable the new flag value (defaults to true) void SetResolveOnBuild(bool enable) { resolve_on_build_ = enable; } /// @return true if the Resolver will be run on the program when it is /// built. bool ResolveOnBuild() const { return resolve_on_build_; } /// @returns true if the program has no error diagnostics and is not missing /// information bool IsValid() const; /// @returns the last allocated (numerically highest) AST node identifier. ast::NodeID LastAllocatedNodeID() const { return last_ast_node_id_; } /// @returns the next sequentially unique node identifier. ast::NodeID AllocateNodeID() { auto out = ast::NodeID{last_ast_node_id_.value + 1}; last_ast_node_id_ = out; return out; } /// Creates a new ast::Node owned by the ProgramBuilder. When the /// ProgramBuilder is destructed, the ast::Node will also be destructed. /// @param source the Source of the node /// @param args the arguments to pass to the type constructor /// @returns the node pointer template traits::EnableIfIsType* create(const Source& source, ARGS&&... args) { AssertNotMoved(); return ast_nodes_.Create(id_, AllocateNodeID(), source, std::forward(args)...); } /// Creates a new ast::Node owned by the ProgramBuilder, injecting the current /// Source as set by the last call to SetSource() as the only argument to the /// constructor. /// When the ProgramBuilder is destructed, the ast::Node will also be /// destructed. /// @returns the node pointer template traits::EnableIfIsType* create() { AssertNotMoved(); return ast_nodes_.Create(id_, AllocateNodeID(), source_); } /// Creates a new ast::Node owned by the ProgramBuilder, injecting the current /// Source as set by the last call to SetSource() as the first argument to the /// constructor. /// When the ProgramBuilder is destructed, the ast::Node will also be /// destructed. /// @param arg0 the first arguments to pass to the type constructor /// @param args the remaining arguments to pass to the type constructor /// @returns the node pointer template traits::EnableIf && !traits::IsTypeOrDerived, T>* create(ARG0&& arg0, ARGS&&... args) { AssertNotMoved(); return ast_nodes_.Create(id_, AllocateNodeID(), source_, std::forward(arg0), std::forward(args)...); } /// Creates a new sem::Node owned by the ProgramBuilder. /// When the ProgramBuilder is destructed, the sem::Node will also be destructed. /// @param args the arguments to pass to the constructor /// @returns the node pointer template traits::EnableIf && !traits::IsTypeOrDerived, T>* create(ARGS&&... args) { AssertNotMoved(); return sem_nodes_.Create(std::forward(args)...); } /// Creates a new sem::Constant owned by the ProgramBuilder. /// When the ProgramBuilder is destructed, the sem::Node will also be destructed. /// @param args the arguments to pass to the constructor /// @returns the node pointer template traits::EnableIf, T>* create(ARGS&&... args) { AssertNotMoved(); return constant_nodes_.Create(std::forward(args)...); } /// Creates a new sem::Type owned by the ProgramBuilder. /// When the ProgramBuilder is destructed, owned ProgramBuilder and the /// returned`Type` will also be destructed. /// Types are unique (de-aliased), and so calling create() for the same `T` /// and arguments will return the same pointer. /// @warning Use this method to acquire a type only if all of its type /// information is provided in the constructor arguments `args`.
/// If the type requires additional configuration after construction that /// affect its fundamental type, build the type with `std::make_unique`, make /// any necessary alterations and then call unique_type() instead. /// @param args the arguments to pass to the type constructor /// @returns the de-aliased type pointer template traits::EnableIfIsType* create(ARGS&&... args) { static_assert(std::is_base_of::value, "T does not derive from sem::Type"); AssertNotMoved(); return types_.Get(std::forward(args)...); } /// Marks this builder as moved, preventing any further use of the builder. void MarkAsMoved(); ////////////////////////////////////////////////////////////////////////////// // TypesBuilder ////////////////////////////////////////////////////////////////////////////// /// TypesBuilder holds basic `tint` types and methods for constructing /// complex types. class TypesBuilder { public: /// Constructor /// @param builder the program builder explicit TypesBuilder(ProgramBuilder* builder); /// @return the tint AST type for the C type `T`. template const ast::Type* Of() const { return CToAST::get(this); } /// @returns a boolean type const ast::Bool* bool_() const { return builder->create(); } /// @param source the Source of the node /// @returns a boolean type const ast::Bool* bool_(const Source& source) const { return builder->create(source); } /// @returns a f16 type const ast::F16* f16() const { return builder->create(); } /// @param source the Source of the node /// @returns a f16 type const ast::F16* f16(const Source& source) const { return builder->create(source); } /// @returns a f32 type const ast::F32* f32() const { return builder->create(); } /// @param source the Source of the node /// @returns a f32 type const ast::F32* f32(const Source& source) const { return builder->create(source); } /// @returns a i32 type const ast::I32* i32() const { return builder->create(); } /// @param source the Source of the node /// @returns a i32 type const ast::I32* i32(const Source& source) const { return builder->create(source); } /// @returns a u32 type const ast::U32* u32() const { return builder->create(); } /// @param source the Source of the node /// @returns a u32 type const ast::U32* u32(const Source& source) const { return builder->create(source); } /// @returns a void type const ast::Void* void_() const { return builder->create(); } /// @param source the Source of the node /// @returns a void type const ast::Void* void_(const Source& source) const { return builder->create(source); } /// @param type vector subtype /// @param n vector width in elements /// @return the tint AST type for a `n`-element vector of `type`. const ast::Vector* vec(const ast::Type* type, uint32_t n) const { return builder->create(type, n); } /// @param source the Source of the node /// @param type vector subtype /// @param n vector width in elements /// @return the tint AST type for a `n`-element vector of `type`. const ast::Vector* vec(const Source& source, const ast::Type* type, uint32_t n) const { return builder->create(source, type, n); } /// @param type vector subtype /// @return the tint AST type for a 2-element vector of `type`. const ast::Vector* vec2(const ast::Type* type) const { return vec(type, 2u); } /// @param source the vector source /// @param type vector subtype /// @return the tint AST type for a 2-element vector of `type`. const ast::Vector* vec2(const Source& source, const ast::Type* type) const { return vec(source, type, 2u); } /// @param type vector subtype /// @return the tint AST type for a 3-element vector of `type`. const ast::Vector* vec3(const ast::Type* type) const { return vec(type, 3u); } /// @param source the vector source /// @param type vector subtype /// @return the tint AST type for a 3-element vector of `type`. const ast::Vector* vec3(const Source& source, const ast::Type* type) const { return vec(source, type, 3u); } /// @param type vector subtype /// @return the tint AST type for a 4-element vector of `type`. const ast::Vector* vec4(const ast::Type* type) const { return vec(type, 4u); } /// @param source the vector source /// @param type vector subtype /// @return the tint AST type for a 4-element vector of `type`. const ast::Vector* vec4(const Source& source, const ast::Type* type) const { return vec(source, type, 4u); } /// @param n vector width in elements /// @return the tint AST type for a `n`-element vector of `type`. template const ast::Vector* vec(uint32_t n) const { return vec(Of(), n); } /// @return the tint AST type for a 2-element vector of the C type `T`. template const ast::Vector* vec2() const { return vec2(Of()); } /// @param source the Source of the node /// @return the tint AST type for a 2-element vector of the C type `T`. template const ast::Vector* vec2(const Source& source) const { return vec2(source, Of()); } /// @return the tint AST type for a 3-element vector of the C type `T`. template const ast::Vector* vec3() const { return vec3(Of()); } /// @param source the Source of the node /// @return the tint AST type for a 3-element vector of the C type `T`. template const ast::Vector* vec3(const Source& source) const { return vec3(source, Of()); } /// @return the tint AST type for a 4-element vector of the C type `T`. template const ast::Vector* vec4() const { return vec4(Of()); } /// @param source the Source of the node /// @return the tint AST type for a 4-element vector of the C type `T`. template const ast::Vector* vec4(const Source& source) const { return vec4(source, Of()); } /// @param type matrix subtype /// @param columns number of columns for the matrix /// @param rows number of rows for the matrix /// @return the tint AST type for a matrix of `type` const ast::Matrix* mat(const ast::Type* type, uint32_t columns, uint32_t rows) const { return builder->create(type, rows, columns); } /// @param source the Source of the node /// @param type matrix subtype /// @param columns number of columns for the matrix /// @param rows number of rows for the matrix /// @return the tint AST type for a matrix of `type` const ast::Matrix* mat(const Source& source, const ast::Type* type, uint32_t columns, uint32_t rows) const { return builder->create(source, type, rows, columns); } /// @param type matrix subtype /// @return the tint AST type for a 2x3 matrix of `type`. const ast::Matrix* mat2x2(const ast::Type* type) const { return mat(type, 2u, 2u); } /// @param type matrix subtype /// @return the tint AST type for a 2x3 matrix of `type`. const ast::Matrix* mat2x3(const ast::Type* type) const { return mat(type, 2u, 3u); } /// @param type matrix subtype /// @return the tint AST type for a 2x4 matrix of `type`. const ast::Matrix* mat2x4(const ast::Type* type) const { return mat(type, 2u, 4u); } /// @param type matrix subtype /// @return the tint AST type for a 3x2 matrix of `type`. const ast::Matrix* mat3x2(const ast::Type* type) const { return mat(type, 3u, 2u); } /// @param type matrix subtype /// @return the tint AST type for a 3x3 matrix of `type`. const ast::Matrix* mat3x3(const ast::Type* type) const { return mat(type, 3u, 3u); } /// @param type matrix subtype /// @return the tint AST type for a 3x4 matrix of `type`. const ast::Matrix* mat3x4(const ast::Type* type) const { return mat(type, 3u, 4u); } /// @param type matrix subtype /// @return the tint AST type for a 4x2 matrix of `type`. const ast::Matrix* mat4x2(const ast::Type* type) const { return mat(type, 4u, 2u); } /// @param type matrix subtype /// @return the tint AST type for a 4x3 matrix of `type`. const ast::Matrix* mat4x3(const ast::Type* type) const { return mat(type, 4u, 3u); } /// @param type matrix subtype /// @return the tint AST type for a 4x4 matrix of `type`. const ast::Matrix* mat4x4(const ast::Type* type) const { return mat(type, 4u, 4u); } /// @param columns number of columns for the matrix /// @param rows number of rows for the matrix /// @return the tint AST type for a matrix of `type` template const ast::Matrix* mat(uint32_t columns, uint32_t rows) const { return mat(Of(), columns, rows); } /// @return the tint AST type for a 2x3 matrix of the C type `T`. template const ast::Matrix* mat2x2() const { return mat2x2(Of()); } /// @return the tint AST type for a 2x3 matrix of the C type `T`. template const ast::Matrix* mat2x3() const { return mat2x3(Of()); } /// @return the tint AST type for a 2x4 matrix of the C type `T`. template const ast::Matrix* mat2x4() const { return mat2x4(Of()); } /// @return the tint AST type for a 3x2 matrix of the C type `T`. template const ast::Matrix* mat3x2() const { return mat3x2(Of()); } /// @return the tint AST type for a 3x3 matrix of the C type `T`. template const ast::Matrix* mat3x3() const { return mat3x3(Of()); } /// @return the tint AST type for a 3x4 matrix of the C type `T`. template const ast::Matrix* mat3x4() const { return mat3x4(Of()); } /// @return the tint AST type for a 4x2 matrix of the C type `T`. template const ast::Matrix* mat4x2() const { return mat4x2(Of()); } /// @return the tint AST type for a 4x3 matrix of the C type `T`. template const ast::Matrix* mat4x3() const { return mat4x3(Of()); } /// @return the tint AST type for a 4x4 matrix of the C type `T`. template const ast::Matrix* mat4x4() const { return mat4x4(Of()); } /// @param subtype the array element type /// @param n the array size. nullptr represents a runtime-array /// @param attrs the optional attributes for the array /// @return the tint AST type for a array of size `n` of type `T` template const ast::Array* array( const ast::Type* subtype, EXPR&& n = nullptr, utils::VectorRef attrs = utils::Empty) const { return builder->create(subtype, builder->Expr(std::forward(n)), std::move(attrs)); } /// @param source the Source of the node /// @param subtype the array element type /// @param n the array size. nullptr represents a runtime-array /// @param attrs the optional attributes for the array /// @return the tint AST type for a array of size `n` of type `T` template const ast::Array* array( const Source& source, const ast::Type* subtype, EXPR&& n = nullptr, utils::VectorRef attrs = utils::Empty) const { return builder->create( source, subtype, builder->Expr(std::forward(n)), std::move(attrs)); } /// @param subtype the array element type /// @param n the array size. nullptr represents a runtime-array /// @param stride the array stride. 0 represents implicit stride /// @return the tint AST type for a array of size `n` of type `T` template const ast::Array* array(const ast::Type* subtype, EXPR&& n, uint32_t stride) const { utils::Vector attrs; if (stride) { attrs.Push(builder->create(stride)); } return array(subtype, std::forward(n), std::move(attrs)); } /// @param source the Source of the node /// @param subtype the array element type /// @param n the array size. nullptr represents a runtime-array /// @param stride the array stride. 0 represents implicit stride /// @return the tint AST type for a array of size `n` of type `T` template const ast::Array* array(const Source& source, const ast::Type* subtype, EXPR&& n, uint32_t stride) const { utils::Vector attrs; if (stride) { attrs.Push(builder->create(stride)); } return array(source, subtype, std::forward(n), std::move(attrs)); } /// @return the tint AST type for a runtime-sized array of type `T` template const ast::Array* array() const { return array(Of(), nullptr); } /// @return the tint AST type for an array of size `N` of type `T` template const ast::Array* array() const { return array(Of(), builder->Expr(tint::u32(N))); } /// @param stride the array stride /// @return the tint AST type for a runtime-sized array of type `T` template const ast::Array* array(uint32_t stride) const { return array(Of(), nullptr, stride); } /// @param stride the array stride /// @return the tint AST type for an array of size `N` of type `T` template const ast::Array* array(uint32_t stride) const { return array(Of(), builder->Expr(tint::u32(N)), stride); } /// Creates a type name /// @param name the name /// @returns the type name template const ast::TypeName* type_name(NAME&& name) const { return builder->create(builder->Sym(std::forward(name))); } /// Creates a type name /// @param source the Source of the node /// @param name the name /// @returns the type name template const ast::TypeName* type_name(const Source& source, NAME&& name) const { return builder->create(source, builder->Sym(std::forward(name))); } /// Creates an alias type /// @param name the alias name /// @param type the alias type /// @returns the alias pointer template const ast::Alias* alias(NAME&& name, const ast::Type* type) const { auto sym = builder->Sym(std::forward(name)); return builder->create(sym, type); } /// Creates an alias type /// @param source the Source of the node /// @param name the alias name /// @param type the alias type /// @returns the alias pointer template const ast::Alias* alias(const Source& source, NAME&& name, const ast::Type* type) const { auto sym = builder->Sym(std::forward(name)); return builder->create(source, sym, type); } /// @param type the type of the pointer /// @param storage_class the storage class of the pointer /// @param access the optional access control of the pointer /// @return the pointer to `type` with the given ast::StorageClass const ast::Pointer* pointer(const ast::Type* type, ast::StorageClass storage_class, ast::Access access = ast::Access::kUndefined) const { return builder->create(type, storage_class, access); } /// @param source the Source of the node /// @param type the type of the pointer /// @param storage_class the storage class of the pointer /// @param access the optional access control of the pointer /// @return the pointer to `type` with the given ast::StorageClass const ast::Pointer* pointer(const Source& source, const ast::Type* type, ast::StorageClass storage_class, ast::Access access = ast::Access::kUndefined) const { return builder->create(source, type, storage_class, access); } /// @param storage_class the storage class of the pointer /// @param access the optional access control of the pointer /// @return the pointer to type `T` with the given ast::StorageClass. template const ast::Pointer* pointer(ast::StorageClass storage_class, ast::Access access = ast::Access::kUndefined) const { return pointer(Of(), storage_class, access); } /// @param source the Source of the node /// @param storage_class the storage class of the pointer /// @param access the optional access control of the pointer /// @return the pointer to type `T` with the given ast::StorageClass. template const ast::Pointer* pointer(const Source& source, ast::StorageClass storage_class, ast::Access access = ast::Access::kUndefined) const { return pointer(source, Of(), storage_class, access); } /// @param source the Source of the node /// @param type the type of the atomic /// @return the atomic to `type` const ast::Atomic* atomic(const Source& source, const ast::Type* type) const { return builder->create(source, type); } /// @param type the type of the atomic /// @return the atomic to `type` const ast::Atomic* atomic(const ast::Type* type) const { return builder->create(type); } /// @return the atomic to type `T` template const ast::Atomic* atomic() const { return atomic(Of()); } /// @param kind the kind of sampler /// @returns the sampler const ast::Sampler* sampler(ast::SamplerKind kind) const { return builder->create(kind); } /// @param source the Source of the node /// @param kind the kind of sampler /// @returns the sampler const ast::Sampler* sampler(const Source& source, ast::SamplerKind kind) const { return builder->create(source, kind); } /// @param dims the dimensionality of the texture /// @returns the depth texture const ast::DepthTexture* depth_texture(ast::TextureDimension dims) const { return builder->create(dims); } /// @param source the Source of the node /// @param dims the dimensionality of the texture /// @returns the depth texture const ast::DepthTexture* depth_texture(const Source& source, ast::TextureDimension dims) const { return builder->create(source, dims); } /// @param dims the dimensionality of the texture /// @returns the multisampled depth texture const ast::DepthMultisampledTexture* depth_multisampled_texture( ast::TextureDimension dims) const { return builder->create(dims); } /// @param source the Source of the node /// @param dims the dimensionality of the texture /// @returns the multisampled depth texture const ast::DepthMultisampledTexture* depth_multisampled_texture( const Source& source, ast::TextureDimension dims) const { return builder->create(source, dims); } /// @param dims the dimensionality of the texture /// @param subtype the texture subtype. /// @returns the sampled texture const ast::SampledTexture* sampled_texture(ast::TextureDimension dims, const ast::Type* subtype) const { return builder->create(dims, subtype); } /// @param source the Source of the node /// @param dims the dimensionality of the texture /// @param subtype the texture subtype. /// @returns the sampled texture const ast::SampledTexture* sampled_texture(const Source& source, ast::TextureDimension dims, const ast::Type* subtype) const { return builder->create(source, dims, subtype); } /// @param dims the dimensionality of the texture /// @param subtype the texture subtype. /// @returns the multisampled texture const ast::MultisampledTexture* multisampled_texture(ast::TextureDimension dims, const ast::Type* subtype) const { return builder->create(dims, subtype); } /// @param source the Source of the node /// @param dims the dimensionality of the texture /// @param subtype the texture subtype. /// @returns the multisampled texture const ast::MultisampledTexture* multisampled_texture(const Source& source, ast::TextureDimension dims, const ast::Type* subtype) const { return builder->create(source, dims, subtype); } /// @param dims the dimensionality of the texture /// @param format the texel format of the texture /// @param access the access control of the texture /// @returns the storage texture const ast::StorageTexture* storage_texture(ast::TextureDimension dims, ast::TexelFormat format, ast::Access access) const { auto* subtype = ast::StorageTexture::SubtypeFor(format, *builder); return builder->create(dims, format, subtype, access); } /// @param source the Source of the node /// @param dims the dimensionality of the texture /// @param format the texel format of the texture /// @param access the access control of the texture /// @returns the storage texture const ast::StorageTexture* storage_texture(const Source& source, ast::TextureDimension dims, ast::TexelFormat format, ast::Access access) const { auto* subtype = ast::StorageTexture::SubtypeFor(format, *builder); return builder->create(source, dims, format, subtype, access); } /// @returns the external texture const ast::ExternalTexture* external_texture() const { return builder->create(); } /// @param source the Source of the node /// @returns the external texture const ast::ExternalTexture* external_texture(const Source& source) const { return builder->create(source); } /// Constructs a TypeName for the type declaration. /// @param type the type /// @return either type or a pointer to a new ast::TypeName const ast::TypeName* Of(const ast::TypeDecl* type) const; /// The ProgramBuilder ProgramBuilder* const builder; private: /// CToAST is specialized for various `T` types and each specialization /// contains a single static `get()` method for obtaining the corresponding /// AST type for the C type `T`. /// `get()` has the signature: /// `static const ast::Type* get(Types* t)` template struct CToAST {}; }; ////////////////////////////////////////////////////////////////////////////// // AST helper methods ////////////////////////////////////////////////////////////////////////////// /// @return a new unnamed symbol Symbol Sym() { return Symbols().New(); } /// @param name the symbol string /// @return a Symbol with the given name Symbol Sym(const std::string& name) { return Symbols().Register(name); } /// @param sym the symbol /// @return `sym` Symbol Sym(Symbol sym) { return sym; } /// @param expr the expression /// @return expr template traits::EnableIfIsType* Expr(T* expr) { return expr; } /// Passthrough for nullptr /// @return nullptr const ast::IdentifierExpression* Expr(std::nullptr_t) { return nullptr; } /// @param source the source information /// @param symbol the identifier symbol /// @return an ast::IdentifierExpression with the given symbol const ast::IdentifierExpression* Expr(const Source& source, Symbol symbol) { return create(source, symbol); } /// @param symbol the identifier symbol /// @return an ast::IdentifierExpression with the given symbol const ast::IdentifierExpression* Expr(Symbol symbol) { return create(symbol); } /// @param source the source information /// @param variable the AST variable /// @return an ast::IdentifierExpression with the variable's symbol const ast::IdentifierExpression* Expr(const Source& source, const ast::Variable* variable) { return create(source, variable->symbol); } /// @param variable the AST variable /// @return an ast::IdentifierExpression with the variable's symbol const ast::IdentifierExpression* Expr(const ast::Variable* variable) { return create(variable->symbol); } /// @param source the source information /// @param name the identifier name /// @return an ast::IdentifierExpression with the given name const ast::IdentifierExpression* Expr(const Source& source, const char* name) { return create(source, Symbols().Register(name)); } /// @param name the identifier name /// @return an ast::IdentifierExpression with the given name const ast::IdentifierExpression* Expr(const char* name) { return create(Symbols().Register(name)); } /// @param source the source information /// @param name the identifier name /// @return an ast::IdentifierExpression with the given name const ast::IdentifierExpression* Expr(const Source& source, const std::string& name) { return create(source, Symbols().Register(name)); } /// @param name the identifier name /// @return an ast::IdentifierExpression with the given name const ast::IdentifierExpression* Expr(const std::string& name) { return create(Symbols().Register(name)); } /// @param source the source information /// @param value the boolean value /// @return a Scalar constructor for the given value template std::enable_if_t, const ast::BoolLiteralExpression*> Expr( const Source& source, BOOL value) { return create(source, value); } /// @param value the boolean value /// @return a Scalar constructor for the given value template std::enable_if_t, const ast::BoolLiteralExpression*> Expr( BOOL value) { return create(value); } /// @param source the source information /// @param value the float value /// @return a 'f'-suffixed FloatLiteralExpression for the f32 value const ast::FloatLiteralExpression* Expr(const Source& source, f32 value) { return create(source, static_cast(value.value), ast::FloatLiteralExpression::Suffix::kF); } /// @param value the float value /// @return a 'f'-suffixed FloatLiteralExpression for the f32 value const ast::FloatLiteralExpression* Expr(f32 value) { return create(static_cast(value.value), ast::FloatLiteralExpression::Suffix::kF); } /// @param source the source information /// @param value the float value /// @return a 'h'-suffixed FloatLiteralExpression for the f16 value const ast::FloatLiteralExpression* Expr(const Source& source, f16 value) { return create(source, static_cast(value.value), ast::FloatLiteralExpression::Suffix::kH); } /// @param value the float value /// @return a 'h'-suffixed FloatLiteralExpression for the f16 value const ast::FloatLiteralExpression* Expr(f16 value) { return create(static_cast(value.value), ast::FloatLiteralExpression::Suffix::kH); } /// @param source the source information /// @param value the integer value /// @return an unsuffixed IntLiteralExpression for the AInt value const ast::IntLiteralExpression* Expr(const Source& source, AInt value) { return create(source, value, ast::IntLiteralExpression::Suffix::kNone); } /// @param value the integer value /// @return an unsuffixed IntLiteralExpression for the AInt value const ast::IntLiteralExpression* Expr(AInt value) { return create(value, ast::IntLiteralExpression::Suffix::kNone); } /// @param source the source information /// @param value the integer value /// @return an unsuffixed FloatLiteralExpression for the AFloat value const ast::FloatLiteralExpression* Expr(const Source& source, AFloat value) { return create(source, value.value, ast::FloatLiteralExpression::Suffix::kNone); } /// @param value the integer value /// @return an unsuffixed FloatLiteralExpression for the AFloat value const ast::FloatLiteralExpression* Expr(AFloat value) { return create(value.value, ast::FloatLiteralExpression::Suffix::kNone); } /// @param source the source information /// @param value the integer value /// @return a signed 'i'-suffixed IntLiteralExpression for the i32 value const ast::IntLiteralExpression* Expr(const Source& source, i32 value) { return create(source, value, ast::IntLiteralExpression::Suffix::kI); } /// @param value the integer value /// @return a signed 'i'-suffixed IntLiteralExpression for the i32 value const ast::IntLiteralExpression* Expr(i32 value) { return create(value, ast::IntLiteralExpression::Suffix::kI); } /// @param source the source information /// @param value the unsigned int value /// @return an unsigned 'u'-suffixed IntLiteralExpression for the u32 value const ast::IntLiteralExpression* Expr(const Source& source, u32 value) { return create(source, value, ast::IntLiteralExpression::Suffix::kU); } /// @param value the unsigned int value /// @return an unsigned 'u'-suffixed IntLiteralExpression for the u32 value const ast::IntLiteralExpression* Expr(u32 value) { return create(value, ast::IntLiteralExpression::Suffix::kU); } /// Converts `arg` to an `ast::Expression` using `Expr()`, then appends it to /// `list`. /// @param list the list to append too /// @param arg the arg to create template void Append(utils::Vector& list, ARG&& arg) { list.Push(Expr(std::forward(arg))); } /// Converts `arg0` and `args` to `ast::Expression`s using `Expr()`, /// then appends them to `list`. /// @param list the list to append too /// @param arg0 the first argument /// @param args the rest of the arguments template void Append(utils::Vector& list, ARG0&& arg0, ARGS&&... args) { Append(list, std::forward(arg0)); Append(list, std::forward(args)...); } /// @return utils::EmptyType utils::EmptyType ExprList() { return utils::Empty; } /// @param args the list of expressions /// @return the list of expressions converted to `ast::Expression`s using /// `Expr()`, template > auto ExprList(ARGS&&... args) { utils::Vector list; Append(list, std::forward(args)...); return list; } /// @param list the list of expressions /// @return `list` template utils::Vector ExprList(utils::Vector&& list) { return std::move(list); } /// @param list the list of expressions /// @return `list` utils::VectorRef ExprList( utils::VectorRef list) { return list; } /// @param args the arguments for the type constructor /// @return an `ast::CallExpression` of type `ty`, with the values /// of `args` converted to `ast::Expression`s using `Expr()` template const ast::CallExpression* Construct(ARGS&&... args) { return Construct(ty.Of(), std::forward(args)...); } /// @param type the type to construct /// @param args the arguments for the constructor /// @return an `ast::CallExpression` of `type` constructed with the /// values `args`. template const ast::CallExpression* Construct(const ast::Type* type, ARGS&&... args) { return Construct(source_, type, std::forward(args)...); } /// @param source the source information /// @param type the type to construct /// @param args the arguments for the constructor /// @return an `ast::CallExpression` of `type` constructed with the /// values `args`. template const ast::CallExpression* Construct(const Source& source, const ast::Type* type, ARGS&&... args) { return create(source, type, ExprList(std::forward(args)...)); } /// @param expr the expression for the bitcast /// @return an `ast::BitcastExpression` of type `ty`, with the values of /// `expr` converted to `ast::Expression`s using `Expr()` template const ast::BitcastExpression* Bitcast(EXPR&& expr) { return Bitcast(ty.Of(), std::forward(expr)); } /// @param type the type to cast to /// @param expr the expression for the bitcast /// @return an `ast::BitcastExpression` of `type` constructed with the values /// `expr`. template const ast::BitcastExpression* Bitcast(const ast::Type* type, EXPR&& expr) { return create(type, Expr(std::forward(expr))); } /// @param source the source information /// @param type the type to cast to /// @param expr the expression for the bitcast /// @return an `ast::BitcastExpression` of `type` constructed with the values /// `expr`. template const ast::BitcastExpression* Bitcast(const Source& source, const ast::Type* type, EXPR&& expr) { return create(source, type, Expr(std::forward(expr))); } /// @param args the arguments for the vector constructor /// @param type the vector type /// @param size the vector size /// @return an `ast::CallExpression` of a `size`-element vector of /// type `type`, constructed with the values `args`. template const ast::CallExpression* vec(const ast::Type* type, uint32_t size, ARGS&&... args) { return Construct(ty.vec(type, size), std::forward(args)...); } /// @param args the arguments for the vector constructor /// @return an `ast::CallExpression` of a 2-element vector of type /// `T`, constructed with the values `args`. template > const ast::CallExpression* vec2(ARGS&&... args) { return Construct(ty.vec2(), std::forward(args)...); } /// @param source the vector source /// @param args the arguments for the vector constructor /// @return an `ast::CallExpression` of a 2-element vector of type /// `T`, constructed with the values `args`. template const ast::CallExpression* vec2(const Source& source, ARGS&&... args) { return Construct(source, ty.vec2(), std::forward(args)...); } /// @param args the arguments for the vector constructor /// @return an `ast::CallExpression` of a 3-element vector of type /// `T`, constructed with the values `args`. template > const ast::CallExpression* vec3(ARGS&&... args) { return Construct(ty.vec3(), std::forward(args)...); } /// @param source the vector source /// @param args the arguments for the vector constructor /// @return an `ast::CallExpression` of a 3-element vector of type /// `T`, constructed with the values `args`. template const ast::CallExpression* vec3(const Source& source, ARGS&&... args) { return Construct(source, ty.vec3(), std::forward(args)...); } /// @param args the arguments for the vector constructor /// @return an `ast::CallExpression` of a 4-element vector of type /// `T`, constructed with the values `args`. template > const ast::CallExpression* vec4(ARGS&&... args) { return Construct(ty.vec4(), std::forward(args)...); } /// @param source the vector source /// @param args the arguments for the vector constructor /// @return an `ast::CallExpression` of a 4-element vector of type /// `T`, constructed with the values `args`. template const ast::CallExpression* vec4(const Source& source, ARGS&&... args) { return Construct(source, ty.vec4(), std::forward(args)...); } /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 2x2 matrix of type /// `T`, constructed with the values `args`. template > const ast::CallExpression* mat2x2(ARGS&&... args) { return Construct(ty.mat2x2(), std::forward(args)...); } /// @param source the matrix source /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 2x2 matrix of type /// `T`, constructed with the values `args`. template const ast::CallExpression* mat2x2(const Source& source, ARGS&&... args) { return Construct(source, ty.mat2x2(), std::forward(args)...); } /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 2x3 matrix of type /// `T`, constructed with the values `args`. template > const ast::CallExpression* mat2x3(ARGS&&... args) { return Construct(ty.mat2x3(), std::forward(args)...); } /// @param source the matrix source /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 2x3 matrix of type /// `T`, constructed with the values `args`. template const ast::CallExpression* mat2x3(const Source& source, ARGS&&... args) { return Construct(source, ty.mat2x3(), std::forward(args)...); } /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 2x4 matrix of type /// `T`, constructed with the values `args`. template > const ast::CallExpression* mat2x4(ARGS&&... args) { return Construct(ty.mat2x4(), std::forward(args)...); } /// @param source the matrix source /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 2x4 matrix of type /// `T`, constructed with the values `args`. template const ast::CallExpression* mat2x4(const Source& source, ARGS&&... args) { return Construct(source, ty.mat2x4(), std::forward(args)...); } /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 3x2 matrix of type /// `T`, constructed with the values `args`. template > const ast::CallExpression* mat3x2(ARGS&&... args) { return Construct(ty.mat3x2(), std::forward(args)...); } /// @param source the matrix source /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 3x2 matrix of type /// `T`, constructed with the values `args`. template const ast::CallExpression* mat3x2(const Source& source, ARGS&&... args) { return Construct(source, ty.mat3x2(), std::forward(args)...); } /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 3x3 matrix of type /// `T`, constructed with the values `args`. template > const ast::CallExpression* mat3x3(ARGS&&... args) { return Construct(ty.mat3x3(), std::forward(args)...); } /// @param source the matrix source /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 3x3 matrix of type /// `T`, constructed with the values `args`. template const ast::CallExpression* mat3x3(const Source& source, ARGS&&... args) { return Construct(source, ty.mat3x3(), std::forward(args)...); } /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 3x4 matrix of type /// `T`, constructed with the values `args`. template > const ast::CallExpression* mat3x4(ARGS&&... args) { return Construct(ty.mat3x4(), std::forward(args)...); } /// @param source the matrix source /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 3x4 matrix of type /// `T`, constructed with the values `args`. template const ast::CallExpression* mat3x4(const Source& source, ARGS&&... args) { return Construct(source, ty.mat3x4(), std::forward(args)...); } /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 4x2 matrix of type /// `T`, constructed with the values `args`. template > const ast::CallExpression* mat4x2(ARGS&&... args) { return Construct(ty.mat4x2(), std::forward(args)...); } /// @param source the matrix source /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 4x2 matrix of type /// `T`, constructed with the values `args`. template const ast::CallExpression* mat4x2(const Source& source, ARGS&&... args) { return Construct(source, ty.mat4x2(), std::forward(args)...); } /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 4x3 matrix of type /// `T`, constructed with the values `args`. template > const ast::CallExpression* mat4x3(ARGS&&... args) { return Construct(ty.mat4x3(), std::forward(args)...); } /// @param source the matrix source /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 4x3 matrix of type /// `T`, constructed with the values `args`. template const ast::CallExpression* mat4x3(const Source& source, ARGS&&... args) { return Construct(source, ty.mat4x3(), std::forward(args)...); } /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 4x4 matrix of type /// `T`, constructed with the values `args`. template > const ast::CallExpression* mat4x4(ARGS&&... args) { return Construct(ty.mat4x4(), std::forward(args)...); } /// @param source the matrix source /// @param args the arguments for the matrix constructor /// @return an `ast::CallExpression` of a 4x4 matrix of type /// `T`, constructed with the values `args`. template const ast::CallExpression* mat4x4(const Source& source, ARGS&&... args) { return Construct(source, ty.mat4x4(), std::forward(args)...); } /// @param args the arguments for the array constructor /// @return an `ast::CallExpression` of an array with element type /// `T` and size `N`, constructed with the values `args`. template const ast::CallExpression* array(ARGS&&... args) { return Construct(ty.array(), std::forward(args)...); } /// @param source the array source /// @param args the arguments for the array constructor /// @return an `ast::CallExpression` of an array with element type /// `T` and size `N`, constructed with the values `args`. template const ast::CallExpression* array(const Source& source, ARGS&&... args) { return Construct(source, ty.array(), std::forward(args)...); } /// @param subtype the array element type /// @param n the array size. nullptr represents a runtime-array. /// @param args the arguments for the array constructor /// @return an `ast::CallExpression` of an array with element type /// `subtype`, constructed with the values `args`. template const ast::CallExpression* array(const ast::Type* subtype, EXPR&& n, ARGS&&... args) { return Construct(ty.array(subtype, std::forward(n)), std::forward(args)...); } /// @param source the array source /// @param subtype the array element type /// @param n the array size. nullptr represents a runtime-array. /// @param args the arguments for the array constructor /// @return an `ast::CallExpression` of an array with element type /// `subtype`, constructed with the values `args`. template const ast::CallExpression* array(const Source& source, const ast::Type* subtype, EXPR&& n, ARGS&&... args) { return Construct(source, ty.array(subtype, std::forward(n)), std::forward(args)...); } /// Adds the extension to the list of enable directives at the top of the module. /// @param ext the extension to enable /// @return an `ast::Enable` enabling the given extension. const ast::Enable* Enable(ast::Extension ext) { auto* enable = create(ext); AST().AddEnable(enable); return enable; } /// @param name the variable name /// @param options the extra options passed to the ast::Var constructor /// Can be any of the following, in any order: /// * ast::Type* - specifies the variable type /// * ast::StorageClass - specifies the variable storage class /// * ast::Access - specifies the variable's access control /// * ast::Expression* - specifies the variable's initializer expression /// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector) /// Note that non-repeatable arguments of the same type will use the last argument's value. /// @returns a `ast::Var` with the given name, type and additional /// options template > const ast::Var* Var(NAME&& name, OPTIONS&&... options) { VarOptions opts(std::forward(options)...); return create(Sym(std::forward(name)), opts.type, opts.storage, opts.access, opts.constructor, std::move(opts.attributes)); } /// @param source the variable source /// @param name the variable name /// @param options the extra options passed to the ast::Var constructor /// Can be any of the following, in any order: /// * ast::Type* - specifies the variable type /// * ast::StorageClass - specifies the variable storage class /// * ast::Access - specifies the variable's access control /// * ast::Expression* - specifies the variable's initializer expression /// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector) /// Note that non-repeatable arguments of the same type will use the last argument's value. /// @returns a `ast::Var` with the given name, storage and type template const ast::Var* Var(const Source& source, NAME&& name, OPTIONS&&... options) { VarOptions opts(std::forward(options)...); return create(source, Sym(std::forward(name)), opts.type, opts.storage, opts.access, opts.constructor, std::move(opts.attributes)); } /// @param name the variable name /// @param options the extra options passed to the ast::Var constructor /// Can be any of the following, in any order: /// * ast::Expression* - specifies the variable's initializer expression (required) /// * ast::Type* - specifies the variable type /// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector) /// Note that non-repeatable arguments of the same type will use the last argument's value. /// @returns an `ast::Const` with the given name, type and additional options template > const ast::Const* Const(NAME&& name, OPTIONS&&... options) { ConstOptions opts(std::forward(options)...); return create(Sym(std::forward(name)), opts.type, opts.constructor, std::move(opts.attributes)); } /// @param source the variable source /// @param name the variable name /// @param options the extra options passed to the ast::Var constructor /// Can be any of the following, in any order: /// * ast::Expression* - specifies the variable's initializer expression (required) /// * ast::Type* - specifies the variable type /// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector) /// Note that non-repeatable arguments of the same type will use the last argument's value. /// @returns an `ast::Const` with the given name, type and additional options template const ast::Const* Const(const Source& source, NAME&& name, OPTIONS&&... options) { ConstOptions opts(std::forward(options)...); return create(source, Sym(std::forward(name)), opts.type, opts.constructor, std::move(opts.attributes)); } /// @param name the variable name /// @param options the extra options passed to the ast::Var constructor /// Can be any of the following, in any order: /// * ast::Expression* - specifies the variable's initializer expression (required) /// * ast::Type* - specifies the variable type /// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector) /// Note that non-repeatable arguments of the same type will use the last argument's value. /// @returns an `ast::Let` with the given name, type and additional options template > const ast::Let* Let(NAME&& name, OPTIONS&&... options) { LetOptions opts(std::forward(options)...); return create(Sym(std::forward(name)), opts.type, opts.constructor, std::move(opts.attributes)); } /// @param source the variable source /// @param name the variable name /// @param options the extra options passed to the ast::Var constructor /// Can be any of the following, in any order: /// * ast::Expression* - specifies the variable's initializer expression (required) /// * ast::Type* - specifies the variable type /// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector) /// Note that non-repeatable arguments of the same type will use the last argument's value. /// @returns an `ast::Let` with the given name, type and additional options template const ast::Let* Let(const Source& source, NAME&& name, OPTIONS&&... options) { LetOptions opts(std::forward(options)...); return create(source, Sym(std::forward(name)), opts.type, opts.constructor, std::move(opts.attributes)); } /// @param name the parameter name /// @param type the parameter type /// @param attributes optional parameter attributes /// @returns an `ast::Parameter` with the given name and type template const ast::Parameter* Param(NAME&& name, const ast::Type* type, utils::VectorRef attributes = utils::Empty) { return create(Sym(std::forward(name)), type, attributes); } /// @param source the parameter source /// @param name the parameter name /// @param type the parameter type /// @param attributes optional parameter attributes /// @returns an `ast::Parameter` with the given name and type template const ast::Parameter* Param(const Source& source, NAME&& name, const ast::Type* type, utils::VectorRef attributes = utils::Empty) { return create(source, Sym(std::forward(name)), type, attributes); } /// @param name the variable name /// @param options the extra options passed to the ast::Var constructor /// Can be any of the following, in any order: /// * ast::Type* - specifies the variable type /// * ast::StorageClass - specifies the variable storage class /// * ast::Access - specifies the variable's access control /// * ast::Expression* - specifies the variable's initializer expression /// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector) /// Note that non-repeatable arguments of the same type will use the last argument's value. /// @returns a new `ast::Var`, which is automatically registered as a global variable with the /// ast::Module. template > const ast::Var* GlobalVar(NAME&& name, OPTIONS&&... options) { auto* variable = Var(std::forward(name), std::forward(options)...); AST().AddGlobalVariable(variable); return variable; } /// @param source the variable source /// @param name the variable name /// @param options the extra options passed to the ast::Var constructor /// Can be any of the following, in any order: /// * ast::Type* - specifies the variable type /// * ast::StorageClass - specifies the variable storage class /// * ast::Access - specifies the variable's access control /// * ast::Expression* - specifies the variable's initializer expression /// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector) /// Note that non-repeatable arguments of the same type will use the last argument's value. /// @returns a new `ast::Var`, which is automatically registered as a global variable with the /// ast::Module. template const ast::Var* GlobalVar(const Source& source, NAME&& name, OPTIONS&&... options) { auto* variable = Var(source, std::forward(name), std::forward(options)...); AST().AddGlobalVariable(variable); return variable; } /// @param name the variable name /// @param options the extra options passed to the ast::Const constructor /// Can be any of the following, in any order: /// * ast::Expression* - specifies the variable's initializer expression (required) /// * ast::Type* - specifies the variable type /// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector) /// Note that non-repeatable arguments of the same type will use the last argument's value. /// @returns an `ast::Const` with the given name, type and additional options, which is /// automatically registered as a global variable with the ast::Module. template > const ast::Const* GlobalConst(NAME&& name, OPTIONS&&... options) { auto* variable = Const(std::forward(name), std::forward(options)...); AST().AddGlobalVariable(variable); return variable; } /// @param source the variable source /// @param name the variable name /// @param options the extra options passed to the ast::Const constructor /// Can be any of the following, in any order: /// * ast::Expression* - specifies the variable's initializer expression (required) /// * ast::Type* - specifies the variable type /// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector) /// Note that non-repeatable arguments of the same type will use the last argument's value. /// @returns an `ast::Const` with the given name, type and additional options, which is /// automatically registered as a global variable with the ast::Module. template const ast::Const* GlobalConst(const Source& source, NAME&& name, OPTIONS&&... options) { auto* variable = Const(source, std::forward(name), std::forward(options)...); AST().AddGlobalVariable(variable); return variable; } /// @param name the variable name /// @param options the extra options passed to the ast::Override constructor /// Can be any of the following, in any order: /// * ast::Expression* - specifies the variable's initializer expression (required) /// * ast::Type* - specifies the variable type /// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector) /// Note that non-repeatable arguments of the same type will use the last argument's value. /// @returns an `ast::Override` with the given name, type and additional options, which is /// automatically registered as a global variable with the ast::Module. template > const ast::Override* Override(NAME&& name, OPTIONS&&... options) { OverrideOptions opts(std::forward(options)...); auto* variable = create(Sym(std::forward(name)), opts.type, opts.constructor, std::move(opts.attributes)); AST().AddGlobalVariable(variable); return variable; } /// @param source the variable source /// @param name the variable name /// @param options the extra options passed to the ast::Override constructor /// Can be any of the following, in any order: /// * ast::Expression* - specifies the variable's initializer expression (required) /// * ast::Type* - specifies the variable type /// * ast::Attribute* - specifies the variable's attributes (repeatable, or vector) /// Note that non-repeatable arguments of the same type will use the last argument's value. /// @returns an `ast::Override` with the given name, type and additional options, which is /// automatically registered as a global variable with the ast::Module. template const ast::Override* Override(const Source& source, NAME&& name, OPTIONS&&... options) { OverrideOptions opts(std::forward(options)...); auto* variable = create(source, Sym(std::forward(name)), opts.type, opts.constructor, std::move(opts.attributes)); AST().AddGlobalVariable(variable); return variable; } /// @param source the source information /// @param condition the assertion condition /// @returns a new `ast::StaticAssert`, which is automatically registered as a global statement /// with the ast::Module. template const ast::StaticAssert* GlobalStaticAssert(const Source& source, EXPR&& condition) { auto* sa = StaticAssert(source, std::forward(condition)); AST().AddStaticAssert(sa); return sa; } /// @param condition the assertion condition /// @returns a new `ast::StaticAssert`, which is automatically registered as a global statement /// with the ast::Module. template > const ast::StaticAssert* GlobalStaticAssert(EXPR&& condition) { auto* sa = StaticAssert(std::forward(condition)); AST().AddStaticAssert(sa); return sa; } /// @param source the source information /// @param condition the assertion condition /// @returns a new `ast::StaticAssert` with the given assertion condition template const ast::StaticAssert* StaticAssert(const Source& source, EXPR&& condition) { return create(source, Expr(std::forward(condition))); } /// @param condition the assertion condition /// @returns a new `ast::StaticAssert` with the given assertion condition template > const ast::StaticAssert* StaticAssert(EXPR&& condition) { return create(Expr(std::forward(condition))); } /// @param source the source information /// @param expr the expression to take the address of /// @return an ast::UnaryOpExpression that takes the address of `expr` template const ast::UnaryOpExpression* AddressOf(const Source& source, EXPR&& expr) { return create(source, ast::UnaryOp::kAddressOf, Expr(std::forward(expr))); } /// @param expr the expression to take the address of /// @return an ast::UnaryOpExpression that takes the address of `expr` template const ast::UnaryOpExpression* AddressOf(EXPR&& expr) { return create(ast::UnaryOp::kAddressOf, Expr(std::forward(expr))); } /// @param source the source information /// @param expr the expression to perform an indirection on /// @return an ast::UnaryOpExpression that dereferences the pointer `expr` template const ast::UnaryOpExpression* Deref(const Source& source, EXPR&& expr) { return create(source, ast::UnaryOp::kIndirection, Expr(std::forward(expr))); } /// @param expr the expression to perform an indirection on /// @return an ast::UnaryOpExpression that dereferences the pointer `expr` template const ast::UnaryOpExpression* Deref(EXPR&& expr) { return create(ast::UnaryOp::kIndirection, Expr(std::forward(expr))); } /// @param expr the expression to perform a unary not on /// @return an ast::UnaryOpExpression that is the unary not of the input /// expression template const ast::UnaryOpExpression* Not(EXPR&& expr) { return create(ast::UnaryOp::kNot, Expr(std::forward(expr))); } /// @param expr the expression to perform a unary complement on /// @return an ast::UnaryOpExpression that is the unary complement of the /// input expression template const ast::UnaryOpExpression* Complement(EXPR&& expr) { return create(ast::UnaryOp::kComplement, Expr(std::forward(expr))); } /// @param expr the expression to perform a unary negation on /// @return an ast::UnaryOpExpression that is the unary negation of the /// input expression template const ast::UnaryOpExpression* Negation(EXPR&& expr) { return create(ast::UnaryOp::kNegation, Expr(std::forward(expr))); } /// @param source the source information /// @param func the function name /// @param args the function call arguments /// @returns a `ast::CallExpression` to the function `func`, with the /// arguments of `args` converted to `ast::Expression`s using `Expr()`. template const ast::CallExpression* Call(const Source& source, NAME&& func, ARGS&&... args) { return create(source, Expr(func), ExprList(std::forward(args)...)); } /// @param func the function name /// @param args the function call arguments /// @returns a `ast::CallExpression` to the function `func`, with the /// arguments of `args` converted to `ast::Expression`s using `Expr()`. template > const ast::CallExpression* Call(NAME&& func, ARGS&&... args) { return create(Expr(func), ExprList(std::forward(args)...)); } /// @param source the source information /// @param call the call expression to wrap in a call statement /// @returns a `ast::CallStatement` for the given call expression const ast::CallStatement* CallStmt(const Source& source, const ast::CallExpression* call) { return create(source, call); } /// @param call the call expression to wrap in a call statement /// @returns a `ast::CallStatement` for the given call expression const ast::CallStatement* CallStmt(const ast::CallExpression* call) { return create(call); } /// @param source the source information /// @returns a `ast::PhonyExpression` const ast::PhonyExpression* Phony(const Source& source) { return create(source); } /// @returns a `ast::PhonyExpression` const ast::PhonyExpression* Phony() { return create(); } /// @param expr the expression to ignore /// @returns a `ast::AssignmentStatement` that assigns 'expr' to the phony /// (underscore) variable. template const ast::AssignmentStatement* Ignore(EXPR&& expr) { return create(Phony(), Expr(expr)); } /// @param lhs the left hand argument to the addition operation /// @param rhs the right hand argument to the addition operation /// @returns a `ast::BinaryExpression` summing the arguments `lhs` and `rhs` template const ast::BinaryExpression* Add(LHS&& lhs, RHS&& rhs) { return create(ast::BinaryOp::kAdd, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param source the source information /// @param lhs the left hand argument to the addition operation /// @param rhs the right hand argument to the addition operation /// @returns a `ast::BinaryExpression` summing the arguments `lhs` and `rhs` template const ast::BinaryExpression* Add(const Source& source, LHS&& lhs, RHS&& rhs) { return create(source, ast::BinaryOp::kAdd, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param lhs the left hand argument to the and operation /// @param rhs the right hand argument to the and operation /// @returns a `ast::BinaryExpression` bitwise anding `lhs` and `rhs` template const ast::BinaryExpression* And(LHS&& lhs, RHS&& rhs) { return create(ast::BinaryOp::kAnd, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param lhs the left hand argument to the or operation /// @param rhs the right hand argument to the or operation /// @returns a `ast::BinaryExpression` bitwise or-ing `lhs` and `rhs` template const ast::BinaryExpression* Or(LHS&& lhs, RHS&& rhs) { return create(ast::BinaryOp::kOr, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param lhs the left hand argument to the subtraction operation /// @param rhs the right hand argument to the subtraction operation /// @returns a `ast::BinaryExpression` subtracting `rhs` from `lhs` template const ast::BinaryExpression* Sub(LHS&& lhs, RHS&& rhs) { return create(ast::BinaryOp::kSubtract, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param lhs the left hand argument to the multiplication operation /// @param rhs the right hand argument to the multiplication operation /// @returns a `ast::BinaryExpression` multiplying `rhs` from `lhs` template const ast::BinaryExpression* Mul(LHS&& lhs, RHS&& rhs) { return create(ast::BinaryOp::kMultiply, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param source the source information /// @param lhs the left hand argument to the multiplication operation /// @param rhs the right hand argument to the multiplication operation /// @returns a `ast::BinaryExpression` multiplying `rhs` from `lhs` template const ast::BinaryExpression* Mul(const Source& source, LHS&& lhs, RHS&& rhs) { return create(source, ast::BinaryOp::kMultiply, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param lhs the left hand argument to the division operation /// @param rhs the right hand argument to the division operation /// @returns a `ast::BinaryExpression` dividing `lhs` by `rhs` template const ast::BinaryExpression* Div(LHS&& lhs, RHS&& rhs) { return create(ast::BinaryOp::kDivide, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param lhs the left hand argument to the modulo operation /// @param rhs the right hand argument to the modulo operation /// @returns a `ast::BinaryExpression` applying modulo of `lhs` by `rhs` template const ast::BinaryExpression* Mod(LHS&& lhs, RHS&& rhs) { return create(ast::BinaryOp::kModulo, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param lhs the left hand argument to the bit shift right operation /// @param rhs the right hand argument to the bit shift right operation /// @returns a `ast::BinaryExpression` bit shifting right `lhs` by `rhs` template const ast::BinaryExpression* Shr(LHS&& lhs, RHS&& rhs) { return create( ast::BinaryOp::kShiftRight, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param lhs the left hand argument to the bit shift left operation /// @param rhs the right hand argument to the bit shift left operation /// @returns a `ast::BinaryExpression` bit shifting left `lhs` by `rhs` template const ast::BinaryExpression* Shl(LHS&& lhs, RHS&& rhs) { return create( ast::BinaryOp::kShiftLeft, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param lhs the left hand argument to the xor operation /// @param rhs the right hand argument to the xor operation /// @returns a `ast::BinaryExpression` bitwise xor-ing `lhs` and `rhs` template const ast::BinaryExpression* Xor(LHS&& lhs, RHS&& rhs) { return create(ast::BinaryOp::kXor, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param lhs the left hand argument to the logical and operation /// @param rhs the right hand argument to the logical and operation /// @returns a `ast::BinaryExpression` of `lhs` && `rhs` template const ast::BinaryExpression* LogicalAnd(LHS&& lhs, RHS&& rhs) { return create( ast::BinaryOp::kLogicalAnd, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param lhs the left hand argument to the logical or operation /// @param rhs the right hand argument to the logical or operation /// @returns a `ast::BinaryExpression` of `lhs` || `rhs` template const ast::BinaryExpression* LogicalOr(LHS&& lhs, RHS&& rhs) { return create( ast::BinaryOp::kLogicalOr, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param lhs the left hand argument to the greater than operation /// @param rhs the right hand argument to the greater than operation /// @returns a `ast::BinaryExpression` of `lhs` > `rhs` template const ast::BinaryExpression* GreaterThan(LHS&& lhs, RHS&& rhs) { return create(ast::BinaryOp::kGreaterThan, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param lhs the left hand argument to the greater than or equal operation /// @param rhs the right hand argument to the greater than or equal operation /// @returns a `ast::BinaryExpression` of `lhs` >= `rhs` template const ast::BinaryExpression* GreaterThanEqual(LHS&& lhs, RHS&& rhs) { return create(ast::BinaryOp::kGreaterThanEqual, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param lhs the left hand argument to the less than operation /// @param rhs the right hand argument to the less than operation /// @returns a `ast::BinaryExpression` of `lhs` < `rhs` template const ast::BinaryExpression* LessThan(LHS&& lhs, RHS&& rhs) { return create(ast::BinaryOp::kLessThan, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param lhs the left hand argument to the less than or equal operation /// @param rhs the right hand argument to the less than or equal operation /// @returns a `ast::BinaryExpression` of `lhs` <= `rhs` template const ast::BinaryExpression* LessThanEqual(LHS&& lhs, RHS&& rhs) { return create(ast::BinaryOp::kLessThanEqual, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param lhs the left hand argument to the equal expression /// @param rhs the right hand argument to the equal expression /// @returns a `ast::BinaryExpression` comparing `lhs` equal to `rhs` template const ast::BinaryExpression* Equal(LHS&& lhs, RHS&& rhs) { return create(ast::BinaryOp::kEqual, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param lhs the left hand argument to the not-equal expression /// @param rhs the right hand argument to the not-equal expression /// @returns a `ast::BinaryExpression` comparing `lhs` equal to `rhs` for /// disequality template const ast::BinaryExpression* NotEqual(LHS&& lhs, RHS&& rhs) { return create(ast::BinaryOp::kNotEqual, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// @param source the source information /// @param obj the object for the index accessor expression /// @param idx the index argument for the index accessor expression /// @returns a `ast::IndexAccessorExpression` that indexes `arr` with `idx` template const ast::IndexAccessorExpression* IndexAccessor(const Source& source, OBJ&& obj, IDX&& idx) { return create(source, Expr(std::forward(obj)), Expr(std::forward(idx))); } /// @param obj the object for the index accessor expression /// @param idx the index argument for the index accessor expression /// @returns a `ast::IndexAccessorExpression` that indexes `arr` with `idx` template const ast::IndexAccessorExpression* IndexAccessor(OBJ&& obj, IDX&& idx) { return create(Expr(std::forward(obj)), Expr(std::forward(idx))); } /// @param source the source information /// @param obj the object for the member accessor expression /// @param idx the index argument for the member accessor expression /// @returns a `ast::MemberAccessorExpression` that indexes `obj` with `idx` template const ast::MemberAccessorExpression* MemberAccessor(const Source& source, OBJ&& obj, IDX&& idx) { return create(source, Expr(std::forward(obj)), Expr(std::forward(idx))); } /// @param obj the object for the member accessor expression /// @param idx the index argument for the member accessor expression /// @returns a `ast::MemberAccessorExpression` that indexes `obj` with `idx` template const ast::MemberAccessorExpression* MemberAccessor(OBJ&& obj, IDX&& idx) { return create(Expr(std::forward(obj)), Expr(std::forward(idx))); } /// Creates a ast::StructMemberOffsetAttribute /// @param val the offset value /// @returns the offset attribute pointer const ast::StructMemberOffsetAttribute* MemberOffset(uint32_t val) { return create(source_, val); } /// Creates a ast::StructMemberSizeAttribute /// @param source the source information /// @param val the size value /// @returns the size attribute pointer const ast::StructMemberSizeAttribute* MemberSize(const Source& source, uint32_t val) { return create(source, val); } /// Creates a ast::StructMemberSizeAttribute /// @param val the size value /// @returns the size attribute pointer const ast::StructMemberSizeAttribute* MemberSize(uint32_t val) { return create(source_, val); } /// Creates a ast::StructMemberAlignAttribute /// @param source the source information /// @param val the align value expression /// @returns the align attribute pointer template const ast::StructMemberAlignAttribute* MemberAlign(const Source& source, EXPR&& val) { return create(source, Expr(std::forward(val))); } /// Creates a ast::StructMemberAlignAttribute /// @param val the align value expression /// @returns the align attribute pointer template const ast::StructMemberAlignAttribute* MemberAlign(EXPR&& val) { return create(source_, Expr(std::forward(val))); } /// Creates the ast::GroupAttribute /// @param value group attribute index /// @returns the group attribute pointer const ast::GroupAttribute* Group(uint32_t value) { return create(value); } /// Creates the ast::BindingAttribute /// @param value the binding index /// @returns the binding deocration pointer const ast::BindingAttribute* Binding(uint32_t value) { return create(value); } /// Creates an ast::Function and registers it with the ast::Module. /// @param source the source information /// @param name the function name /// @param params the function parameters /// @param type the function return type /// @param body the function body /// @param attributes the optional function attributes /// @param return_type_attributes the optional function return type /// attributes /// @returns the function pointer template const ast::Function* Func( const Source& source, NAME&& name, utils::VectorRef params, const ast::Type* type, utils::VectorRef body, utils::VectorRef attributes = utils::Empty, utils::VectorRef return_type_attributes = utils::Empty) { auto* func = create(source, Sym(std::forward(name)), std::move(params), type, create(std::move(body)), std::move(attributes), std::move(return_type_attributes)); AST().AddFunction(func); return func; } /// Creates an ast::Function and registers it with the ast::Module. /// @param name the function name /// @param params the function parameters /// @param type the function return type /// @param body the function body /// @param attributes the optional function attributes /// @param return_type_attributes the optional function return type /// attributes /// @returns the function pointer template const ast::Function* Func( NAME&& name, utils::VectorRef params, const ast::Type* type, utils::VectorRef body, utils::VectorRef attributes = utils::Empty, utils::VectorRef return_type_attributes = utils::Empty) { auto* func = create(Sym(std::forward(name)), std::move(params), type, create(std::move(body)), std::move(attributes), std::move(return_type_attributes)); AST().AddFunction(func); return func; } /// Creates an ast::BreakStatement /// @param source the source information /// @returns the break statement pointer const ast::BreakStatement* Break(const Source& source) { return create(source); } /// Creates an ast::BreakStatement /// @returns the break statement pointer const ast::BreakStatement* Break() { return create(); } /// Creates an ast::ContinueStatement /// @param source the source information /// @returns the continue statement pointer const ast::ContinueStatement* Continue(const Source& source) { return create(source); } /// Creates an ast::ContinueStatement /// @returns the continue statement pointer const ast::ContinueStatement* Continue() { return create(); } /// Creates an ast::ReturnStatement with no return value /// @param source the source information /// @returns the return statement pointer const ast::ReturnStatement* Return(const Source& source) { return create(source); } /// Creates an ast::ReturnStatement with no return value /// @returns the return statement pointer const ast::ReturnStatement* Return() { return create(); } /// Creates an ast::ReturnStatement with the given return value /// @param source the source information /// @param val the return value /// @returns the return statement pointer template const ast::ReturnStatement* Return(const Source& source, EXPR&& val) { return create(source, Expr(std::forward(val))); } /// Creates an ast::ReturnStatement with the given return value /// @param val the return value /// @returns the return statement pointer template > const ast::ReturnStatement* Return(EXPR&& val) { return create(Expr(std::forward(val))); } /// Creates an ast::DiscardStatement /// @param source the source information /// @returns the discard statement pointer const ast::DiscardStatement* Discard(const Source& source) { return create(source); } /// Creates an ast::DiscardStatement /// @returns the discard statement pointer const ast::DiscardStatement* Discard() { return create(); } /// Creates a ast::Alias registering it with the AST().TypeDecls(). /// @param source the source information /// @param name the alias name /// @param type the alias target type /// @returns the alias type template const ast::Alias* Alias(const Source& source, NAME&& name, const ast::Type* type) { auto* out = ty.alias(source, std::forward(name), type); AST().AddTypeDecl(out); return out; } /// Creates a ast::Alias registering it with the AST().TypeDecls(). /// @param name the alias name /// @param type the alias target type /// @returns the alias type template const ast::Alias* Alias(NAME&& name, const ast::Type* type) { auto* out = ty.alias(std::forward(name), type); AST().AddTypeDecl(out); return out; } /// Creates a ast::Struct registering it with the AST().TypeDecls(). /// @param source the source information /// @param name the struct name /// @param members the struct members /// @returns the struct type template const ast::Struct* Structure(const Source& source, NAME&& name, utils::VectorRef members) { auto sym = Sym(std::forward(name)); auto* type = create(source, sym, std::move(members), utils::Empty); AST().AddTypeDecl(type); return type; } /// Creates a ast::Struct registering it with the AST().TypeDecls(). /// @param name the struct name /// @param members the struct members /// @returns the struct type template const ast::Struct* Structure(NAME&& name, utils::VectorRef members) { auto sym = Sym(std::forward(name)); auto* type = create(sym, std::move(members), utils::Empty); AST().AddTypeDecl(type); return type; } /// Creates a ast::StructMember /// @param source the source information /// @param name the struct member name /// @param type the struct member type /// @param attributes the optional struct member attributes /// @returns the struct member pointer template const ast::StructMember* Member( const Source& source, NAME&& name, const ast::Type* type, utils::VectorRef attributes = utils::Empty) { return create(source, Sym(std::forward(name)), type, std::move(attributes)); } /// Creates a ast::StructMember /// @param name the struct member name /// @param type the struct member type /// @param attributes the optional struct member attributes /// @returns the struct member pointer template const ast::StructMember* Member( NAME&& name, const ast::Type* type, utils::VectorRef attributes = utils::Empty) { return create(source_, Sym(std::forward(name)), type, std::move(attributes)); } /// Creates a ast::StructMember with the given byte offset /// @param offset the offset to use in the StructMemberOffsetAttribute /// @param name the struct member name /// @param type the struct member type /// @returns the struct member pointer template const ast::StructMember* Member(uint32_t offset, NAME&& name, const ast::Type* type) { return create(source_, Sym(std::forward(name)), type, utils::Vector{ create(offset), }); } /// Creates a ast::BlockStatement with input statements /// @param source the source information for the block /// @param statements statements of block /// @returns the block statement pointer template const ast::BlockStatement* Block(const Source& source, Statements&&... statements) { return create( source, utils::Vector{ std::forward(statements)..., }); } /// Creates a ast::BlockStatement with input statements /// @param statements statements of block /// @returns the block statement pointer template > const ast::BlockStatement* Block(STATEMENTS&&... statements) { return create( utils::Vector{ std::forward(statements)..., }); } /// A wrapper type for the Else statement used to create If statements. struct ElseStmt { /// Default constructor - no else statement. ElseStmt() : stmt(nullptr) {} /// Constructor /// @param s The else statement explicit ElseStmt(const ast::Statement* s) : stmt(s) {} /// The else statement, or nullptr. const ast::Statement* stmt; }; /// Creates a ast::IfStatement with input condition, body, and optional /// else statement /// @param source the source information for the if statement /// @param condition the if statement condition expression /// @param body the if statement body /// @param else_stmt optional else statement /// @returns the if statement pointer template const ast::IfStatement* If(const Source& source, CONDITION&& condition, const ast::BlockStatement* body, const ElseStmt else_stmt = ElseStmt()) { return create(source, Expr(std::forward(condition)), body, else_stmt.stmt); } /// Creates a ast::IfStatement with input condition, body, and optional /// else statement /// @param condition the if statement condition expression /// @param body the if statement body /// @param else_stmt optional else statement /// @returns the if statement pointer template const ast::IfStatement* If(CONDITION&& condition, const ast::BlockStatement* body, const ElseStmt else_stmt = ElseStmt()) { return create(Expr(std::forward(condition)), body, else_stmt.stmt); } /// Creates an Else object. /// @param stmt else statement /// @returns the Else object ElseStmt Else(const ast::Statement* stmt) { return ElseStmt(stmt); } /// Creates a ast::AssignmentStatement with input lhs and rhs expressions /// @param source the source information /// @param lhs the left hand side expression initializer /// @param rhs the right hand side expression initializer /// @returns the assignment statement pointer template const ast::AssignmentStatement* Assign(const Source& source, LhsExpressionInit&& lhs, RhsExpressionInit&& rhs) { return create(source, Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// Creates a ast::AssignmentStatement with input lhs and rhs expressions /// @param lhs the left hand side expression initializer /// @param rhs the right hand side expression initializer /// @returns the assignment statement pointer template const ast::AssignmentStatement* Assign(LhsExpressionInit&& lhs, RhsExpressionInit&& rhs) { return create(Expr(std::forward(lhs)), Expr(std::forward(rhs))); } /// Creates a ast::CompoundAssignmentStatement with input lhs and rhs /// expressions, and a binary operator. /// @param source the source information /// @param lhs the left hand side expression initializer /// @param rhs the right hand side expression initializer /// @param op the binary operator /// @returns the compound assignment statement pointer template const ast::CompoundAssignmentStatement* CompoundAssign(const Source& source, LhsExpressionInit&& lhs, RhsExpressionInit&& rhs, ast::BinaryOp op) { return create( source, Expr(std::forward(lhs)), Expr(std::forward(rhs)), op); } /// Creates a ast::CompoundAssignmentStatement with input lhs and rhs /// expressions, and a binary operator. /// @param lhs the left hand side expression initializer /// @param rhs the right hand side expression initializer /// @param op the binary operator /// @returns the compound assignment statement pointer template const ast::CompoundAssignmentStatement* CompoundAssign(LhsExpressionInit&& lhs, RhsExpressionInit&& rhs, ast::BinaryOp op) { return create(Expr(std::forward(lhs)), Expr(std::forward(rhs)), op); } /// Creates an ast::IncrementDecrementStatement with input lhs. /// @param source the source information /// @param lhs the left hand side expression initializer /// @returns the increment decrement statement pointer template const ast::IncrementDecrementStatement* Increment(const Source& source, LhsExpressionInit&& lhs) { return create( source, Expr(std::forward(lhs)), true); } /// Creates a ast::IncrementDecrementStatement with input lhs. /// @param lhs the left hand side expression initializer /// @returns the increment decrement statement pointer template const ast::IncrementDecrementStatement* Increment(LhsExpressionInit&& lhs) { return create(Expr(std::forward(lhs)), true); } /// Creates an ast::IncrementDecrementStatement with input lhs. /// @param source the source information /// @param lhs the left hand side expression initializer /// @returns the increment decrement statement pointer template const ast::IncrementDecrementStatement* Decrement(const Source& source, LhsExpressionInit&& lhs) { return create( source, Expr(std::forward(lhs)), false); } /// Creates a ast::IncrementDecrementStatement with input lhs. /// @param lhs the left hand side expression initializer /// @returns the increment decrement statement pointer template const ast::IncrementDecrementStatement* Decrement(LhsExpressionInit&& lhs) { return create(Expr(std::forward(lhs)), false); } /// Creates a ast::LoopStatement with input body and optional continuing /// @param source the source information /// @param body the loop body /// @param continuing the optional continuing block /// @returns the loop statement pointer const ast::LoopStatement* Loop(const Source& source, const ast::BlockStatement* body, const ast::BlockStatement* continuing = nullptr) { return create(source, body, continuing); } /// Creates a ast::LoopStatement with input body and optional continuing /// @param body the loop body /// @param continuing the optional continuing block /// @returns the loop statement pointer const ast::LoopStatement* Loop(const ast::BlockStatement* body, const ast::BlockStatement* continuing = nullptr) { return create(body, continuing); } /// Creates a ast::ForLoopStatement with input body and optional initializer, /// condition and continuing. /// @param source the source information /// @param init the optional loop initializer /// @param cond the optional loop condition /// @param cont the optional loop continuing /// @param body the loop body /// @returns the for loop statement pointer template const ast::ForLoopStatement* For(const Source& source, const ast::Statement* init, COND&& cond, const ast::Statement* cont, const ast::BlockStatement* body) { return create(source, init, Expr(std::forward(cond)), cont, body); } /// Creates a ast::ForLoopStatement with input body and optional initializer, /// condition and continuing. /// @param init the optional loop initializer /// @param cond the optional loop condition /// @param cont the optional loop continuing /// @param body the loop body /// @returns the for loop statement pointer template const ast::ForLoopStatement* For(const ast::Statement* init, COND&& cond, const ast::Statement* cont, const ast::BlockStatement* body) { return create(init, Expr(std::forward(cond)), cont, body); } /// Creates a ast::WhileStatement with input body and condition. /// @param source the source information /// @param cond the loop condition /// @param body the loop body /// @returns the while statement pointer template const ast::WhileStatement* While(const Source& source, COND&& cond, const ast::BlockStatement* body) { return create(source, Expr(std::forward(cond)), body); } /// Creates a ast::WhileStatement with given condition and body. /// @param cond the condition /// @param body the loop body /// @returns the while loop statement pointer template const ast::WhileStatement* While(COND&& cond, const ast::BlockStatement* body) { return create(Expr(std::forward(cond)), body); } /// Creates a ast::VariableDeclStatement for the input variable /// @param source the source information /// @param var the variable to wrap in a decl statement /// @returns the variable decl statement pointer const ast::VariableDeclStatement* Decl(const Source& source, const ast::Variable* var) { return create(source, var); } /// Creates a ast::VariableDeclStatement for the input variable /// @param var the variable to wrap in a decl statement /// @returns the variable decl statement pointer const ast::VariableDeclStatement* Decl(const ast::Variable* var) { return create(var); } /// Creates a ast::SwitchStatement with input expression and cases /// @param source the source information /// @param condition the condition expression initializer /// @param cases case statements /// @returns the switch statement pointer template const ast::SwitchStatement* Switch(const Source& source, ExpressionInit&& condition, Cases&&... cases) { return create( source, Expr(std::forward(condition)), utils::Vector{ std::forward(cases)...}); } /// Creates a ast::SwitchStatement with input expression and cases /// @param condition the condition expression initializer /// @param cases case statements /// @returns the switch statement pointer template > const ast::SwitchStatement* Switch(ExpressionInit&& condition, Cases&&... cases) { return create( Expr(std::forward(condition)), utils::Vector{ std::forward(cases)...}); } /// Creates a ast::CaseStatement with input list of selectors, and body /// @param source the source information /// @param selectors list of selectors /// @param body the case body /// @returns the case statement pointer const ast::CaseStatement* Case(const Source& source, utils::VectorRef selectors, const ast::BlockStatement* body = nullptr) { return create(source, std::move(selectors), body ? body : Block()); } /// Creates a ast::CaseStatement with input list of selectors, and body /// @param selectors list of selectors /// @param body the case body /// @returns the case statement pointer const ast::CaseStatement* Case(utils::VectorRef selectors, const ast::BlockStatement* body = nullptr) { return create(std::move(selectors), body ? body : Block()); } /// Convenient overload that takes a single selector /// @param selector a single case selector /// @param body the case body /// @returns the case statement pointer const ast::CaseStatement* Case(const ast::IntLiteralExpression* selector, const ast::BlockStatement* body = nullptr) { return Case(utils::Vector{selector}, body); } /// Convenience function that creates a 'default' ast::CaseStatement /// @param source the source information /// @param body the case body /// @returns the case statement pointer const ast::CaseStatement* DefaultCase(const Source& source, const ast::BlockStatement* body = nullptr) { return Case(source, utils::Empty, body); } /// Convenience function that creates a 'default' ast::CaseStatement /// @param body the case body /// @returns the case statement pointer const ast::CaseStatement* DefaultCase(const ast::BlockStatement* body = nullptr) { return Case(utils::Empty, body); } /// Creates an ast::FallthroughStatement /// @param source the source information /// @returns the fallthrough statement pointer const ast::FallthroughStatement* Fallthrough(const Source& source) { return create(source); } /// Creates an ast::FallthroughStatement /// @returns the fallthrough statement pointer const ast::FallthroughStatement* Fallthrough() { return create(); } /// Creates an ast::BuiltinAttribute /// @param source the source information /// @param builtin the builtin value /// @returns the builtin attribute pointer const ast::BuiltinAttribute* Builtin(const Source& source, ast::BuiltinValue builtin) { return create(source, builtin); } /// Creates an ast::BuiltinAttribute /// @param builtin the builtin value /// @returns the builtin attribute pointer const ast::BuiltinAttribute* Builtin(ast::BuiltinValue builtin) { return create(source_, builtin); } /// Creates an ast::InterpolateAttribute /// @param source the source information /// @param type the interpolation type /// @param sampling the interpolation sampling /// @returns the interpolate attribute pointer const ast::InterpolateAttribute* Interpolate( const Source& source, ast::InterpolationType type, ast::InterpolationSampling sampling = ast::InterpolationSampling::kNone) { return create(source, type, sampling); } /// Creates an ast::InterpolateAttribute /// @param type the interpolation type /// @param sampling the interpolation sampling /// @returns the interpolate attribute pointer const ast::InterpolateAttribute* Interpolate( ast::InterpolationType type, ast::InterpolationSampling sampling = ast::InterpolationSampling::kNone) { return create(source_, type, sampling); } /// Creates an ast::InterpolateAttribute using flat interpolation /// @param source the source information /// @returns the interpolate attribute pointer const ast::InterpolateAttribute* Flat(const Source& source) { return Interpolate(source, ast::InterpolationType::kFlat); } /// Creates an ast::InterpolateAttribute using flat interpolation /// @returns the interpolate attribute pointer const ast::InterpolateAttribute* Flat() { return Interpolate(ast::InterpolationType::kFlat); } /// Creates an ast::InvariantAttribute /// @param source the source information /// @returns the invariant attribute pointer const ast::InvariantAttribute* Invariant(const Source& source) { return create(source); } /// Creates an ast::InvariantAttribute /// @returns the invariant attribute pointer const ast::InvariantAttribute* Invariant() { return create(source_); } /// Creates an ast::LocationAttribute /// @param source the source information /// @param location the location value /// @returns the location attribute pointer const ast::LocationAttribute* Location(const Source& source, uint32_t location) { return create(source, location); } /// Creates an ast::LocationAttribute /// @param location the location value /// @returns the location attribute pointer const ast::LocationAttribute* Location(uint32_t location) { return create(source_, location); } /// Creates an ast::IdAttribute /// @param source the source information /// @param id the id value /// @returns the override attribute pointer const ast::IdAttribute* Id(const Source& source, OverrideId id) { return create(source, id.value); } /// Creates an ast::IdAttribute with an override identifier /// @param id the optional id value /// @returns the override attribute pointer const ast::IdAttribute* Id(OverrideId id) { return Id(source_, id); } /// Creates an ast::IdAttribute /// @param source the source information /// @param id the id value /// @returns the override attribute pointer const ast::IdAttribute* Id(const Source& source, uint32_t id) { return create(source, id); } /// Creates an ast::IdAttribute with an override identifier /// @param id the optional id value /// @returns the override attribute pointer const ast::IdAttribute* Id(uint32_t id) { return Id(source_, id); } /// Creates an ast::StageAttribute /// @param source the source information /// @param stage the pipeline stage /// @returns the stage attribute pointer const ast::StageAttribute* Stage(const Source& source, ast::PipelineStage stage) { return create(source, stage); } /// Creates an ast::StageAttribute /// @param stage the pipeline stage /// @returns the stage attribute pointer const ast::StageAttribute* Stage(ast::PipelineStage stage) { return create(source_, stage); } /// Creates an ast::WorkgroupAttribute /// @param x the x dimension expression /// @returns the workgroup attribute pointer template const ast::WorkgroupAttribute* WorkgroupSize(EXPR_X&& x) { return WorkgroupSize(std::forward(x), nullptr, nullptr); } /// Creates an ast::WorkgroupAttribute /// @param source the source information /// @param x the x dimension expression /// @returns the workgroup attribute pointer template const ast::WorkgroupAttribute* WorkgroupSize(const Source& source, EXPR_X&& x) { return WorkgroupSize(source, std::forward(x), nullptr, nullptr); } /// Creates an ast::WorkgroupAttribute /// @param source the source information /// @param x the x dimension expression /// @param y the y dimension expression /// @returns the workgroup attribute pointer template const ast::WorkgroupAttribute* WorkgroupSize(const Source& source, EXPR_X&& x, EXPR_Y&& y) { return WorkgroupSize(source, std::forward(x), std::forward(y), nullptr); } /// Creates an ast::WorkgroupAttribute /// @param x the x dimension expression /// @param y the y dimension expression /// @returns the workgroup attribute pointer template > const ast::WorkgroupAttribute* WorkgroupSize(EXPR_X&& x, EXPR_Y&& y) { return WorkgroupSize(std::forward(x), std::forward(y), nullptr); } /// Creates an ast::WorkgroupAttribute /// @param source the source information /// @param x the x dimension expression /// @param y the y dimension expression /// @param z the z dimension expression /// @returns the workgroup attribute pointer template const ast::WorkgroupAttribute* WorkgroupSize(const Source& source, EXPR_X&& x, EXPR_Y&& y, EXPR_Z&& z) { return create(source, Expr(std::forward(x)), Expr(std::forward(y)), Expr(std::forward(z))); } /// Creates an ast::WorkgroupAttribute /// @param x the x dimension expression /// @param y the y dimension expression /// @param z the z dimension expression /// @returns the workgroup attribute pointer template > const ast::WorkgroupAttribute* WorkgroupSize(EXPR_X&& x, EXPR_Y&& y, EXPR_Z&& z) { return create(source_, Expr(std::forward(x)), Expr(std::forward(y)), Expr(std::forward(z))); } /// Creates an ast::DisableValidationAttribute /// @param validation the validation to disable /// @returns the disable validation attribute pointer const ast::DisableValidationAttribute* Disable(ast::DisabledValidation validation) { return ASTNodes().Create(ID(), AllocateNodeID(), validation); } /// Sets the current builder source to `src` /// @param src the Source used for future create() calls void SetSource(const Source& src) { AssertNotMoved(); source_ = src; } /// Sets the current builder source to `loc` /// @param loc the Source used for future create() calls void SetSource(const Source::Location& loc) { AssertNotMoved(); source_ = Source(loc); } /// Helper for returning the resolved semantic type of the expression `expr`. /// @note As the Resolver is run when the Program is built, this will only be /// useful for the Resolver itself and tests that use their own Resolver. /// @param expr the AST expression /// @return the resolved semantic type for the expression, or nullptr if the /// expression has no resolved type. const sem::Type* TypeOf(const ast::Expression* expr) const; /// Helper for returning the resolved semantic type of the variable `var`. /// @note As the Resolver is run when the Program is built, this will only be /// useful for the Resolver itself and tests that use their own Resolver. /// @param var the AST variable /// @return the resolved semantic type for the variable, or nullptr if the /// variable has no resolved type. const sem::Type* TypeOf(const ast::Variable* var) const; /// Helper for returning the resolved semantic type of the AST type `type`. /// @note As the Resolver is run when the Program is built, this will only be /// useful for the Resolver itself and tests that use their own Resolver. /// @param type the AST type /// @return the resolved semantic type for the type, or nullptr if the type /// has no resolved type. const sem::Type* TypeOf(const ast::Type* type) const; /// Helper for returning the resolved semantic type of the AST type /// declaration `type_decl`. /// @note As the Resolver is run when the Program is built, this will only be /// useful for the Resolver itself and tests that use their own Resolver. /// @param type_decl the AST type declaration /// @return the resolved semantic type for the type declaration, or nullptr if /// the type declaration has no resolved type. const sem::Type* TypeOf(const ast::TypeDecl* type_decl) const; /// @param type a type /// @returns the name for `type` that closely resembles how it would be /// declared in WGSL. std::string FriendlyName(const ast::Type* type) { return type ? type->FriendlyName(Symbols()) : ""; } /// @param type a type /// @returns the name for `type` that closely resembles how it would be /// declared in WGSL. std::string FriendlyName(const sem::Type* type) { return type ? type->FriendlyName(Symbols()) : ""; } /// Overload of FriendlyName, which removes an ambiguity when passing nullptr. /// Simplifies test code. /// @returns "" std::string FriendlyName(std::nullptr_t) { return ""; } /// Wraps the ast::Expression in a statement. This is used by tests that /// construct a partial AST and require the Resolver to reach these /// nodes. /// @param expr the ast::Expression to be wrapped by an ast::Statement /// @return the ast::Statement that wraps the ast::Expression const ast::Statement* WrapInStatement(const ast::Expression* expr); /// Wraps the ast::Variable in a ast::VariableDeclStatement. This is used by /// tests that construct a partial AST and require the Resolver to reach /// these nodes. /// @param v the ast::Variable to be wrapped by an ast::VariableDeclStatement /// @return the ast::VariableDeclStatement that wraps the ast::Variable const ast::VariableDeclStatement* WrapInStatement(const ast::Variable* v); /// Returns the statement argument. Used as a passthrough-overload by /// WrapInFunction(). /// @param stmt the ast::Statement /// @return `stmt` const ast::Statement* WrapInStatement(const ast::Statement* stmt); /// Wraps the list of arguments in a simple function so that each is reachable /// by the Resolver. /// @param args a mix of ast::Expression, ast::Statement, ast::Variables. /// @returns the function template const ast::Function* WrapInFunction(ARGS&&... args) { utils::Vector stmts{ WrapInStatement(std::forward(args))..., }; return WrapInFunction(utils::VectorRef{std::move(stmts)}); } /// @param stmts a list of ast::Statement that will be wrapped by a function, /// so that each statement is reachable by the Resolver. /// @returns the function const ast::Function* WrapInFunction(utils::VectorRef stmts); /// The builder types TypesBuilder const ty{this}; protected: /// Asserts that the builder has not been moved. void AssertNotMoved() const; private: ProgramID id_; ast::NodeID last_ast_node_id_ = ast::NodeID{static_cast(0) - 1}; sem::Manager types_; ASTNodeAllocator ast_nodes_; SemNodeAllocator sem_nodes_; ConstantAllocator constant_nodes_; ast::Module* ast_; sem::Info sem_; SymbolTable symbols_{id_}; diag::List diagnostics_; /// The source to use when creating AST nodes without providing a Source as /// the first argument. Source source_; /// Set by SetResolveOnBuild(). If set, the Resolver will be run on the /// program when built. bool resolve_on_build_ = true; /// Set by MarkAsMoved(). Once set, no methods may be called on this builder. bool moved_ = false; }; //! @cond Doxygen_Suppress // Various template specializations for ProgramBuilder::TypesBuilder::CToAST. template <> struct ProgramBuilder::TypesBuilder::CToAST { static const ast::Type* get(const ProgramBuilder::TypesBuilder* t) { return t->i32(); } }; template <> struct ProgramBuilder::TypesBuilder::CToAST { static const ast::Type* get(const ProgramBuilder::TypesBuilder* t) { return t->u32(); } }; template <> struct ProgramBuilder::TypesBuilder::CToAST { static const ast::Type* get(const ProgramBuilder::TypesBuilder* t) { return t->f32(); } }; template <> struct ProgramBuilder::TypesBuilder::CToAST { static const ast::Type* get(const ProgramBuilder::TypesBuilder* t) { return t->f16(); } }; template <> struct ProgramBuilder::TypesBuilder::CToAST { static const ast::Type* get(const ProgramBuilder::TypesBuilder* t) { return t->bool_(); } }; template <> struct ProgramBuilder::TypesBuilder::CToAST { static const ast::Type* get(const ProgramBuilder::TypesBuilder* t) { return t->void_(); } }; //! @endcond /// @param builder the ProgramBuilder /// @returns the ProgramID of the ProgramBuilder inline ProgramID ProgramIDOf(const ProgramBuilder* builder) { return builder->ID(); } } // namespace tint #endif // SRC_TINT_PROGRAM_BUILDER_H_