blob: 0c00452c6a90fb8d8caa480a47bbd44211ecc404 [file] [log] [blame]
// 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 <string>
#include <unordered_set>
#include <utility>
#include "tint/override_id.h"
#include "src/tint/ast/alias.h"
#include "src/tint/ast/assignment_statement.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_literal_expression.h"
#include "src/tint/ast/break_if_statement.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/const_assert.h"
#include "src/tint/ast/continue_statement.h"
#include "src/tint/ast/diagnostic_attribute.h"
#include "src/tint/ast/diagnostic_control.h"
#include "src/tint/ast/diagnostic_directive.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/float_literal_expression.h"
#include "src/tint/ast/for_loop_statement.h"
#include "src/tint/ast/id_attribute.h"
#include "src/tint/ast/identifier.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/int_literal_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/member_accessor_expression.h"
#include "src/tint/ast/module.h"
#include "src/tint/ast/must_use_attribute.h"
#include "src/tint/ast/override.h"
#include "src/tint/ast/parameter.h"
#include "src/tint/ast/phony_expression.h"
#include "src/tint/ast/return_statement.h"
#include "src/tint/ast/stage_attribute.h"
#include "src/tint/ast/stride_attribute.h"
#include "src/tint/ast/struct_member_align_attribute.h"
#include "src/tint/ast/struct_member_offset_attribute.h"
#include "src/tint/ast/struct_member_size_attribute.h"
#include "src/tint/ast/switch_statement.h"
#include "src/tint/ast/templated_identifier.h"
#include "src/tint/ast/type.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/while_statement.h"
#include "src/tint/ast/workgroup_attribute.h"
#include "src/tint/builtin/extension.h"
#include "src/tint/builtin/interpolation_sampling.h"
#include "src/tint/builtin/interpolation_type.h"
#include "src/tint/constant/composite.h"
#include "src/tint/constant/splat.h"
#include "src/tint/constant/value.h"
#include "src/tint/number.h"
#include "src/tint/program.h"
#include "src/tint/program_id.h"
#include "src/tint/sem/array_count.h"
#include "src/tint/sem/struct.h"
#include "src/tint/type/array.h"
#include "src/tint/type/bool.h"
#include "src/tint/type/depth_texture.h"
#include "src/tint/type/external_texture.h"
#include "src/tint/type/f16.h"
#include "src/tint/type/f32.h"
#include "src/tint/type/i32.h"
#include "src/tint/type/matrix.h"
#include "src/tint/type/multisampled_texture.h"
#include "src/tint/type/pointer.h"
#include "src/tint/type/sampled_texture.h"
#include "src/tint/type/sampler_kind.h"
#include "src/tint/type/storage_texture.h"
#include "src/tint/type/texture_dimension.h"
#include "src/tint/type/u32.h"
#include "src/tint/type/vector.h"
#include "src/tint/type/void.h"
#include "src/tint/utils/string.h"
#ifdef CURRENTLY_IN_TINT_PUBLIC_HEADER
#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<T>::value is true if T is a utils::Vector or utils::VectorRef.
template <typename T>
struct IsVectorLike {
/// Non-specialized form of IsVectorLike defaults to false
static constexpr bool value = false;
};
/// IsVectorLike specialization for utils::Vector
template <typename T, size_t N>
struct IsVectorLike<utils::Vector<T, N>> {
/// True for the IsVectorLike specialization of utils::Vector
static constexpr bool value = true;
};
/// IsVectorLike specialization for utils::VectorRef
template <typename T>
struct IsVectorLike<utils::VectorRef<T>> {
/// True for the IsVectorLike specialization of utils::VectorRef
static constexpr bool value = true;
};
} // namespace detail
// A sentinel type used by some template arguments to signal that the a type should be inferred.
struct Infer {};
/// Evaluates to true if T is a Infer, AInt or AFloat.
template <typename T>
static constexpr const bool IsInferOrAbstract =
std::is_same_v<std::decay_t<T>, Infer> || IsAbstract<std::decay_t<T>>;
// Forward declare metafunction that evaluates to true iff T can be wrapped in a statement.
template <typename T, typename = void>
struct CanWrapInStatement;
/// 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 {
/// Evaluates to true if T is a Source
template <typename T>
static constexpr const bool IsSource = std::is_same_v<T, Source>;
/// Evaluates to true if T is a Number or bool.
template <typename T>
static constexpr const bool IsScalar =
std::is_integral_v<UnwrapNumber<T>> || std::is_floating_point_v<UnwrapNumber<T>> ||
std::is_same_v<T, bool>;
/// Evaluates to true if T can be converted to an identifier.
template <typename T>
static constexpr const bool IsIdentifierLike = std::is_same_v<T, Symbol> || // Symbol
std::is_enum_v<T> || // Enum
traits::IsStringLike<T>; // String
/// 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 <typename... TYPES>
using DisableIfSource =
traits::EnableIf<!IsSource<traits::Decay<traits::NthTypeOf<0, TYPES..., void>>>>;
/// A helper used to disable overloads if the first type in `TYPES` is a scalar type. Used to
/// avoid ambiguities in overloads that take a scalar as the first parameter and those that
/// perfectly-forward the first argument.
template <typename... TYPES>
using DisableIfScalar =
traits::EnableIf<!IsScalar<traits::Decay<traits::NthTypeOf<0, TYPES..., void>>>>;
/// A helper used to enable overloads if the first type in `TYPES` is a scalar type. Used to
/// avoid ambiguities in overloads that take a scalar as the first parameter and those that
/// perfectly-forward the first argument.
template <typename... TYPES>
using EnableIfScalar =
traits::EnableIf<IsScalar<traits::Decay<traits::NthTypeOf<0, TYPES..., void>>>>;
/// A helper used to disable overloads if the first type in `TYPES` is a utils::Vector,
/// utils::VectorRef or utils::VectorRef.
template <typename... TYPES>
using DisableIfVectorLike = traits::EnableIf<
!detail::IsVectorLike<traits::Decay<traits::NthTypeOf<0, TYPES..., void>>>::value>;
/// A helper used to enable overloads if the first type in `TYPES` is identifier-like.
template <typename... TYPES>
using EnableIfIdentifierLike =
traits::EnableIf<IsIdentifierLike<traits::Decay<traits::NthTypeOf<0, TYPES..., void>>>>;
/// A helper used to disable overloads if the first type in `TYPES` is Infer or an abstract
/// numeric.
template <typename... TYPES>
using DisableIfInferOrAbstract =
traits::EnableIf<!IsInferOrAbstract<traits::Decay<traits::NthTypeOf<0, TYPES..., void>>>>;
/// A helper used to enable overloads if the first type in `TYPES` is Infer or an abstract
/// numeric.
template <typename... TYPES>
using EnableIfInferOrAbstract =
traits::EnableIf<IsInferOrAbstract<traits::Decay<traits::NthTypeOf<0, TYPES..., void>>>>;
/// VarOptions is a helper for accepting an arbitrary number of order independent options for
/// constructing an ast::Var.
struct VarOptions {
template <typename... ARGS>
explicit VarOptions(ProgramBuilder& b, ARGS&&... args) {
(Set(b, std::forward<ARGS>(args)), ...);
}
~VarOptions();
ast::Type type;
const ast::Expression* address_space = nullptr;
const ast::Expression* access = nullptr;
const ast::Expression* initializer = nullptr;
utils::Vector<const ast::Attribute*, 4> attributes;
private:
void Set(ProgramBuilder&, ast::Type t) { type = t; }
void Set(ProgramBuilder& b, builtin::AddressSpace addr_space) {
if (addr_space != builtin::AddressSpace::kUndefined) {
address_space = b.Expr(addr_space);
}
}
void Set(ProgramBuilder& b, builtin::Access ac) {
if (ac != builtin::Access::kUndefined) {
access = b.Expr(ac);
}
}
void Set(ProgramBuilder&, const ast::Expression* c) { initializer = c; }
void Set(ProgramBuilder&, utils::VectorRef<const ast::Attribute*> l) {
attributes = std::move(l);
}
void Set(ProgramBuilder&, 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 <typename... ARGS>
explicit LetOptions(ARGS&&... args) {
static constexpr bool has_init =
(traits::IsTypeOrDerived<traits::PtrElTy<ARGS>, ast::Expression> || ...);
static_assert(has_init, "Let() must be constructed with an initializer expression");
(Set(std::forward<ARGS>(args)), ...);
}
~LetOptions();
ast::Type type;
const ast::Expression* initializer = nullptr;
utils::Vector<const ast::Attribute*, 4> attributes;
private:
void Set(ast::Type t) { type = t; }
void Set(const ast::Expression* c) { initializer = c; }
void Set(utils::VectorRef<const ast::Attribute*> 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 <typename... ARGS>
explicit ConstOptions(ARGS&&... args) {
static constexpr bool has_init =
(traits::IsTypeOrDerived<traits::PtrElTy<ARGS>, ast::Expression> || ...);
static_assert(has_init, "Const() must be constructed with an initializer expression");
(Set(std::forward<ARGS>(args)), ...);
}
~ConstOptions();
ast::Type type;
const ast::Expression* initializer = nullptr;
utils::Vector<const ast::Attribute*, 4> attributes;
private:
void Set(ast::Type t) { type = t; }
void Set(const ast::Expression* c) { initializer = c; }
void Set(utils::VectorRef<const ast::Attribute*> 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 <typename... ARGS>
explicit OverrideOptions(ARGS&&... args) {
(Set(std::forward<ARGS>(args)), ...);
}
~OverrideOptions();
ast::Type type;
const ast::Expression* initializer = nullptr;
utils::Vector<const ast::Attribute*, 4> attributes;
private:
void Set(ast::Type t) { type = t; }
void Set(const ast::Expression* c) { initializer = c; }
void Set(utils::VectorRef<const ast::Attribute*> l) { attributes = std::move(l); }
void Set(const ast::Attribute* a) { attributes.Push(a); }
};
public:
/// ASTNodeAllocator is an alias to BlockAllocator<ast::Node>
using ASTNodeAllocator = utils::BlockAllocator<ast::Node>;
/// SemNodeAllocator is an alias to BlockAllocator<sem::Node>
using SemNodeAllocator = utils::BlockAllocator<sem::Node>;
/// ConstantAllocator is an alias to BlockAllocator<constant::Value>
using ConstantAllocator = utils::BlockAllocator<constant::Value>;
/// 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
type::Manager& Types() {
AssertNotMoved();
return types_;
}
/// @returns a reference to the program's types
const type::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 constructor
/// @returns the node pointer
template <typename T, typename... ARGS>
traits::EnableIfIsType<T, ast::Node>* create(const Source& source, ARGS&&... args) {
AssertNotMoved();
return ast_nodes_.Create<T>(id_, AllocateNodeID(), source, std::forward<ARGS>(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 <typename T>
traits::EnableIfIsType<T, ast::Node>* create() {
AssertNotMoved();
return ast_nodes_.Create<T>(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 constructor
/// @param args the remaining arguments to pass to the constructor
/// @returns the node pointer
template <typename T, typename ARG0, typename... ARGS>
traits::EnableIf</* T is ast::Node and ARG0 is not Source */
traits::IsTypeOrDerived<T, ast::Node> &&
!traits::IsTypeOrDerived<ARG0, Source>,
T>*
create(ARG0&& arg0, ARGS&&... args) {
AssertNotMoved();
return ast_nodes_.Create<T>(id_, AllocateNodeID(), source_, std::forward<ARG0>(arg0),
std::forward<ARGS>(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 <typename T, typename... ARGS>
traits::EnableIf<traits::IsTypeOrDerived<T, sem::Node> &&
!traits::IsTypeOrDerived<T, type::Node>,
T>*
create(ARGS&&... args) {
AssertNotMoved();
return sem_nodes_.Create<T>(std::forward<ARGS>(args)...);
}
/// Creates a new constant::Value 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 <typename T, typename... ARGS>
traits::EnableIf<traits::IsTypeOrDerived<T, constant::Value> &&
!traits::IsTypeOrDerived<T, constant::Composite> &&
!traits::IsTypeOrDerived<T, constant::Splat>,
T>*
create(ARGS&&... args) {
AssertNotMoved();
return constant_nodes_.Create<T>(std::forward<ARGS>(args)...);
}
/// Constructs a constant of a vector, matrix or array type.
///
/// Examines the element values and will return either a constant::Composite or a
/// constant::Splat, depending on the element types and values.
///
/// @param type the composite type
/// @param elements the composite elements
/// @returns the node pointer
template <typename T,
typename = traits::EnableIf<traits::IsTypeOrDerived<T, constant::Composite> ||
traits::IsTypeOrDerived<T, constant::Splat>>>
const constant::Value* create(const type::Type* type,
utils::VectorRef<const constant::Value*> elements) {
AssertNotMoved();
return createSplatOrComposite(type, elements);
}
/// Constructs a splat constant.
/// @param type the splat type
/// @param element the splat element
/// @param n the number of elements
/// @returns the node pointer
template <typename T, typename = traits::EnableIf<traits::IsTypeOrDerived<T, constant::Splat>>>
const constant::Splat* create(const type::Type* type,
const constant::Value* element,
size_t n) {
AssertNotMoved();
return constant_nodes_.Create<constant::Splat>(type, element, n);
}
/// Creates a new type::Node owned by the ProgramBuilder.
/// When the ProgramBuilder is destructed, owned ProgramBuilder and the returned node will also
/// be destructed. If T derives from type::UniqueNode, then the calling create() for the same
/// `T` and arguments will return the same pointer.
/// @param args the arguments to pass to the constructor
/// @returns the new, or existing node
template <typename T, typename... ARGS>
traits::EnableIfIsType<T, type::Node>* create(ARGS&&... args) {
AssertNotMoved();
return types_.Get<T>(std::forward<ARGS>(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 C type `T`.
template <typename T>
ast::Type Of() const {
return CToAST<T>::get(this);
}
/// @param type the type to return
/// @return type (passthrough)
ast::Type operator()(const ast::Type& type) const { return type; }
/// Creates a type
/// @param name the name
/// @param args the optional template arguments
/// @returns the type
template <typename NAME,
typename... ARGS,
typename = DisableIfSource<NAME>,
typename = std::enable_if_t<!std::is_same_v<std::decay_t<NAME>, ast::Type>>>
ast::Type operator()(NAME&& name, ARGS&&... args) const {
if constexpr (traits::IsTypeOrDerived<traits::PtrElTy<NAME>, ast::Expression>) {
static_assert(sizeof...(ARGS) == 0);
return {name};
} else {
return {builder->Expr(
builder->Ident(std::forward<NAME>(name), std::forward<ARGS>(args)...))};
}
}
/// Creates a type
/// @param source the Source of the node
/// @param name the name
/// @param args the optional template arguments
/// @returns the type
template <typename NAME,
typename... ARGS,
typename = std::enable_if_t<!std::is_same_v<std::decay_t<NAME>, ast::Type>>>
ast::Type operator()(const Source& source, NAME&& name, ARGS&&... args) const {
return {builder->Expr(
builder->Ident(source, std::forward<NAME>(name), std::forward<ARGS>(args)...))};
}
/// @returns a a nullptr expression wrapped in an ast::Type
ast::Type void_() const { return ast::Type{}; }
/// @returns a 'bool' type
ast::Type bool_() const { return (*this)("bool"); }
/// @param source the Source of the node
/// @returns a 'bool' type
ast::Type bool_(const Source& source) const { return (*this)(source, "bool"); }
/// @returns a 'f16' type
ast::Type f16() const { return (*this)("f16"); }
/// @param source the Source of the node
/// @returns a 'f16' type
ast::Type f16(const Source& source) const { return (*this)(source, "f16"); }
/// @returns a 'f32' type
ast::Type f32() const { return (*this)("f32"); }
/// @param source the Source of the node
/// @returns a 'f32' type
ast::Type f32(const Source& source) const { return (*this)(source, "f32"); }
/// @returns a 'i32' type
ast::Type i32() const { return (*this)("i32"); }
/// @param source the Source of the node
/// @returns a 'i32' type
ast::Type i32(const Source& source) const { return (*this)(source, "i32"); }
/// @returns a 'u32' type
ast::Type u32() const { return (*this)("u32"); }
/// @param source the Source of the node
/// @returns a 'u32' type
ast::Type u32(const Source& source) const { return (*this)(source, "u32"); }
/// @param type vector subtype
/// @param n vector width in elements
/// @return a @p n element vector of @p type
ast::Type vec(ast::Type type, uint32_t n) const { return vec(builder->source_, type, n); }
/// @param source the Source of the node
/// @param type vector subtype
/// @param n vector width in elements
/// @return a @p n element vector of @p type
ast::Type vec(const Source& source, ast::Type type, uint32_t n) const {
switch (n) {
case 2:
return vec2(source, type);
case 3:
return vec3(source, type);
case 4:
return vec4(source, type);
}
TINT_ICE(ProgramBuilder, builder->Diagnostics()) << "invalid vector width " << n;
return ast::Type{};
}
/// @param type vector subtype
/// @return a 2-element vector of @p type
ast::Type vec2(ast::Type type) const { return vec2(builder->source_, type); }
/// @param source the vector source
/// @param type vector subtype
/// @return a 2-element vector of @p type
ast::Type vec2(const Source& source, ast::Type type) const {
return (*this)(source, "vec2", type);
}
/// @param type vector subtype
/// @return a 3-element vector of @p type
ast::Type vec3(ast::Type type) const { return vec3(builder->source_, type); }
/// @param source the vector source
/// @param type vector subtype
/// @return a 3-element vector of @p type
ast::Type vec3(const Source& source, ast::Type type) const {
return (*this)(source, "vec3", type);
}
/// @param type vector subtype
/// @return a 4-element vector of @p type
ast::Type vec4(ast::Type type) const { return vec4(builder->source_, type); }
/// @param source the vector source
/// @param type vector subtype
/// @return a 4-element vector of @p type
ast::Type vec4(const Source& source, ast::Type type) const {
return (*this)(source, "vec4", type);
}
/// @param source the Source of the node
/// @return a 2-element vector of the type `T`
template <typename T>
ast::Type vec2(const Source& source) const {
if constexpr (IsInferOrAbstract<T>) {
return (*this)(source, "vec2");
} else {
return (*this)(source, "vec2", Of<T>());
}
}
/// @param source the Source of the node
/// @return a 3-element vector of the type `T`
template <typename T>
ast::Type vec3(const Source& source) const {
if constexpr (IsInferOrAbstract<T>) {
return (*this)(source, "vec3");
} else {
return (*this)(source, "vec3", Of<T>());
}
}
/// @param source the Source of the node
/// @return a 4-element vector of the type `T`
template <typename T>
ast::Type vec4(const Source& source) const {
if constexpr (IsInferOrAbstract<T>) {
return (*this)(source, "vec4");
} else {
return (*this)(source, "vec4", Of<T>());
}
}
/// @return a 2-element vector of the type `T`
template <typename T>
ast::Type vec2() const {
return vec2<T>(builder->source_);
}
/// @return a 3-element vector of the type `T`
template <typename T>
ast::Type vec3() const {
return vec3<T>(builder->source_);
}
/// @return a 4-element vector of the type `T`
template <typename T>
ast::Type vec4() const {
return vec4<T>(builder->source_);
}
/// @param source the Source of the node
/// @param n vector width in elements
/// @return a @p n element vector of @p type
template <typename T>
ast::Type vec(const Source& source, uint32_t n) const {
switch (n) {
case 2:
return vec2<T>(source);
case 3:
return vec3<T>(source);
case 4:
return vec4<T>(source);
}
TINT_ICE(ProgramBuilder, builder->Diagnostics()) << "invalid vector width " << n;
return ast::Type{};
}
/// @return a @p N element vector of @p type
template <typename T, uint32_t N>
ast::Type vec() const {
return vec<T>(builder->source_, N);
}
/// @param n vector width in elements
/// @return a @p n element vector of @p type
template <typename T>
ast::Type vec(uint32_t n) const {
return vec<T>(builder->source_, n);
}
/// @param type matrix subtype
/// @param columns number of columns for the matrix
/// @param rows number of rows for the matrix
/// @return a matrix of @p type
ast::Type mat(ast::Type type, uint32_t columns, uint32_t rows) const {
return mat(builder->source_, type, columns, rows);
}
/// @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 a matrix of @p type
ast::Type mat(const Source& source, ast::Type type, uint32_t columns, uint32_t rows) const {
if (TINT_LIKELY(columns >= 2 && columns <= 4 && rows >= 2 && rows <= 4)) {
static constexpr const char* names[] = {
"mat2x2", "mat2x3", "mat2x4", //
"mat3x2", "mat3x3", "mat3x4", //
"mat4x2", "mat4x3", "mat4x4", //
};
auto i = (columns - 2) * 3 + (rows - 2);
return (*this)(source, names[i], type);
}
TINT_ICE(ProgramBuilder, builder->Diagnostics())
<< "invalid matrix dimensions " << columns << "x" << rows;
return ast::Type{};
}
/// @param type matrix subtype
/// @return a 2x3 matrix of @p type.
ast::Type mat2x2(ast::Type type) const { return (*this)("mat2x2", type); }
/// @param type matrix subtype
/// @return a 2x3 matrix of @p type.
ast::Type mat2x3(ast::Type type) const { return (*this)("mat2x3", type); }
/// @param type matrix subtype
/// @return a 2x4 matrix of @p type.
ast::Type mat2x4(ast::Type type) const { return (*this)("mat2x4", type); }
/// @param type matrix subtype
/// @return a 3x2 matrix of @p type.
ast::Type mat3x2(ast::Type type) const { return (*this)("mat3x2", type); }
/// @param type matrix subtype
/// @return a 3x3 matrix of @p type.
ast::Type mat3x3(ast::Type type) const { return (*this)("mat3x3", type); }
/// @param type matrix subtype
/// @return a 3x4 matrix of @p type.
ast::Type mat3x4(ast::Type type) const { return (*this)("mat3x4", type); }
/// @param type matrix subtype
/// @return a 4x2 matrix of @p type.
ast::Type mat4x2(ast::Type type) const { return (*this)("mat4x2", type); }
/// @param type matrix subtype
/// @return a 4x3 matrix of @p type.
ast::Type mat4x3(ast::Type type) const { return (*this)("mat4x3", type); }
/// @param type matrix subtype
/// @return a 4x4 matrix of @p type.
ast::Type mat4x4(ast::Type type) const { return (*this)("mat4x4", type); }
/// @param source the source of the type
/// @return a 2x2 matrix of the type `T`
template <typename T>
ast::Type mat2x2(const Source& source) const {
if constexpr (IsInferOrAbstract<T>) {
return (*this)(source, "mat2x2");
} else {
return (*this)(source, "mat2x2", Of<T>());
}
}
/// @param source the source of the type
/// @return a 2x3 matrix of the type `T`
template <typename T>
ast::Type mat2x3(const Source& source) const {
if constexpr (IsInferOrAbstract<T>) {
return (*this)(source, "mat2x3");
} else {
return (*this)(source, "mat2x3", Of<T>());
}
}
/// @param source the source of the type
/// @return a 2x4 matrix of the type `T`
template <typename T>
ast::Type mat2x4(const Source& source) const {
if constexpr (IsInferOrAbstract<T>) {
return (*this)(source, "mat2x4");
} else {
return (*this)(source, "mat2x4", Of<T>());
}
}
/// @param source the source of the type
/// @return a 3x2 matrix of the type `T`
template <typename T>
ast::Type mat3x2(const Source& source) const {
if constexpr (IsInferOrAbstract<T>) {
return (*this)(source, "mat3x2");
} else {
return (*this)(source, "mat3x2", Of<T>());
}
}
/// @param source the source of the type
/// @return a 3x3 matrix of the type `T`
template <typename T>
ast::Type mat3x3(const Source& source) const {
if constexpr (IsInferOrAbstract<T>) {
return (*this)(source, "mat3x3");
} else {
return (*this)(source, "mat3x3", Of<T>());
}
}
/// @param source the source of the type
/// @return a 3x4 matrix of the type `T`
template <typename T>
ast::Type mat3x4(const Source& source) const {
if constexpr (IsInferOrAbstract<T>) {
return (*this)(source, "mat3x4");
} else {
return (*this)(source, "mat3x4", Of<T>());
}
}
/// @param source the source of the type
/// @return a 4x2 matrix of the type `T`
template <typename T>
ast::Type mat4x2(const Source& source) const {
if constexpr (IsInferOrAbstract<T>) {
return (*this)(source, "mat4x2");
} else {
return (*this)(source, "mat4x2", Of<T>());
}
}
/// @param source the source of the type
/// @return a 4x3 matrix of the type `T`
template <typename T>
ast::Type mat4x3(const Source& source) const {
if constexpr (IsInferOrAbstract<T>) {
return (*this)(source, "mat4x3");
} else {
return (*this)(source, "mat4x3", Of<T>());
}
}
/// @param source the source of the type
/// @return a 4x4 matrix of the type `T`
template <typename T>
ast::Type mat4x4(const Source& source) const {
if constexpr (IsInferOrAbstract<T>) {
return (*this)(source, "mat4x4");
} else {
return (*this)(source, "mat4x4", Of<T>());
}
}
/// @return a 2x2 matrix of the type `T`
template <typename T>
ast::Type mat2x2() const {
return mat2x2<T>(builder->source_);
}
/// @return a 2x3 matrix of the type `T`
template <typename T>
ast::Type mat2x3() const {
return mat2x3<T>(builder->source_);
}
/// @return a 2x4 matrix of the type `T`
template <typename T>
ast::Type mat2x4() const {
return mat2x4<T>(builder->source_);
}
/// @return a 3x2 matrix of the type `T`
template <typename T>
ast::Type mat3x2() const {
return mat3x2<T>(builder->source_);
}
/// @return a 3x3 matrix of the type `T`
template <typename T>
ast::Type mat3x3() const {
return mat3x3<T>(builder->source_);
}
/// @return a 3x4 matrix of the type `T`
template <typename T>
ast::Type mat3x4() const {
return mat3x4<T>(builder->source_);
}
/// @return a 4x2 matrix of the type `T`
template <typename T>
ast::Type mat4x2() const {
return mat4x2<T>(builder->source_);
}
/// @return a 4x3 matrix of the type `T`
template <typename T>
ast::Type mat4x3() const {
return mat4x3<T>(builder->source_);
}
/// @return a 4x4 matrix of the type `T`
template <typename T>
ast::Type mat4x4() const {
return mat4x4<T>(builder->source_);
}
/// @param source the Source of the node
/// @param columns number of columns for the matrix
/// @param rows number of rows for the matrix
/// @return a matrix of @p type
template <typename T>
ast::Type mat(const Source& source, uint32_t columns, uint32_t rows) const {
switch ((columns - 2) * 3 + (rows - 2)) {
case 0:
return mat2x2<T>(source);
case 1:
return mat2x3<T>(source);
case 2:
return mat2x4<T>(source);
case 3:
return mat3x2<T>(source);
case 4:
return mat3x3<T>(source);
case 5:
return mat3x4<T>(source);
case 6:
return mat4x2<T>(source);
case 7:
return mat4x3<T>(source);
case 8:
return mat4x4<T>(source);
default:
TINT_ICE(ProgramBuilder, builder->Diagnostics())
<< "invalid matrix dimensions " << columns << "x" << rows;
return ast::Type{};
}
}
/// @param columns number of columns for the matrix
/// @param rows number of rows for the matrix
/// @return a matrix of @p type
template <typename T>
ast::Type mat(uint32_t columns, uint32_t rows) const {
return mat<T>(builder->source_, columns, rows);
}
/// @return a matrix of @p type
template <typename T, uint32_t COLUMNS, uint32_t ROWS>
ast::Type mat() const {
return mat<T>(builder->source_, COLUMNS, ROWS);
}
/// @param subtype the array element type
/// @param attrs the optional attributes for the array
/// @return an array of type `T`
ast::Type array(ast::Type subtype,
utils::VectorRef<const ast::Attribute*> attrs = utils::Empty) const {
return array(builder->source_, subtype, std::move(attrs));
}
/// @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 an array of size `n` of type `T`
template <typename COUNT, typename = DisableIfVectorLike<COUNT>>
ast::Type array(ast::Type subtype,
COUNT&& n,
utils::VectorRef<const ast::Attribute*> attrs = utils::Empty) const {
return array(builder->source_, subtype, std::forward<COUNT>(n), std::move(attrs));
}
/// @param source the Source of the node
/// @param subtype the array element type
/// @param attrs the optional attributes for the array
/// @return an array of type `T`
ast::Type array(const Source& source,
ast::Type subtype,
utils::VectorRef<const ast::Attribute*> attrs = utils::Empty) const {
return ast::Type{builder->Expr(
builder->create<ast::TemplatedIdentifier>(source, builder->Sym("array"),
utils::Vector{
subtype.expr,
},
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 an array of size `n` of type `T`
template <typename COUNT, typename = DisableIfVectorLike<COUNT>>
ast::Type array(const Source& source,
ast::Type subtype,
COUNT&& n,
utils::VectorRef<const ast::Attribute*> attrs = utils::Empty) const {
return ast::Type{builder->Expr(
builder->create<ast::TemplatedIdentifier>(source, builder->Sym("array"),
utils::Vector{
subtype.expr,
builder->Expr(std::forward<COUNT>(n)),
},
std::move(attrs)))};
}
/// @param source the Source of the node
/// @return a inferred-size or runtime-sized array of type `T`
template <typename T, typename = EnableIfInferOrAbstract<T>>
ast::Type array(const Source& source) const {
return (*this)(source, "array");
}
/// @return a inferred-size or runtime-sized array of type `T`
template <typename T, typename = EnableIfInferOrAbstract<T>>
ast::Type array() const {
return array<T>(builder->source_);
}
/// @param source the Source of the node
/// @param attrs the optional attributes for the array
/// @return a inferred-size or runtime-sized array of type `T`
template <typename T, typename = DisableIfInferOrAbstract<T>>
ast::Type array(const Source& source,
utils::VectorRef<const ast::Attribute*> attrs = utils::Empty) const {
return ast::Type{builder->Expr(
builder->create<ast::TemplatedIdentifier>(source, builder->Sym("array"),
utils::Vector<const ast::Expression*, 1>{
Of<T>().expr,
},
std::move(attrs)))};
}
/// @param attrs the optional attributes for the array
/// @return a inferred-size or runtime-sized array of type `T`
template <typename T, typename = DisableIfInferOrAbstract<T>>
ast::Type array(utils::VectorRef<const ast::Attribute*> attrs = utils::Empty) const {
return array<T>(builder->source_, std::move(attrs));
}
/// @param source the Source of the node
/// @param attrs the optional attributes for the array
/// @return an array of size `N` of type `T`
template <typename T, int N>
ast::Type array(const Source& source,
utils::VectorRef<const ast::Attribute*> attrs = utils::Empty) const {
static_assert(!IsInferOrAbstract<T>, "arrays with a count cannot be inferred");
return array(source, Of<T>(), tint::u32(N), std::move(attrs));
}
/// @param attrs the optional attributes for the array
/// @return an array of size `N` of type `T`
template <typename T, int N>
ast::Type array(utils::VectorRef<const ast::Attribute*> attrs = utils::Empty) const {
static_assert(!IsInferOrAbstract<T>, "arrays with a count cannot be inferred");
return array<T, N>(builder->source_, std::move(attrs));
}
/// Creates an alias type
/// @param name the alias name
/// @param type the alias type
/// @returns the alias pointer
template <typename NAME>
const ast::Alias* alias(NAME&& name, ast::Type type) const {
return alias(builder->source_, std::forward<NAME>(name), 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 <typename NAME>
const ast::Alias* alias(const Source& source, NAME&& name, ast::Type type) const {
return builder->create<ast::Alias>(source, builder->Ident(std::forward<NAME>(name)),
type);
}
/// @param type the type of the pointer
/// @param address_space the address space of the pointer
/// @param access the optional access control of the pointer
/// @return the pointer to `type` with the given builtin::AddressSpace
ast::Type pointer(ast::Type type,
builtin::AddressSpace address_space,
builtin::Access access = builtin::Access::kUndefined) const {
return pointer(builder->source_, type, address_space, access);
}
/// @param source the Source of the node
/// @param type the type of the pointer
/// @param address_space the address space of the pointer
/// @param access the optional access control of the pointer
/// @return the pointer to `type` with the given builtin::AddressSpace
ast::Type pointer(const Source& source,
ast::Type type,
builtin::AddressSpace address_space,
builtin::Access access = builtin::Access::kUndefined) const {
if (access != builtin::Access::kUndefined) {
return (*this)(source, "ptr", address_space, type, access);
} else {
return (*this)(source, "ptr", address_space, type);
}
}
/// @param address_space the address space of the pointer
/// @param access the optional access control of the pointer
/// @return the pointer to type `T` with the given builtin::AddressSpace.
template <typename T>
ast::Type pointer(builtin::AddressSpace address_space,
builtin::Access access = builtin::Access::kUndefined) const {
return pointer<T>(builder->source_, address_space, access);
}
/// @param source the Source of the node
/// @param address_space the address space of the pointer
/// @param access the optional access control of the pointer
/// @return the pointer to type `T` with the given builtin::AddressSpace.
template <typename T>
ast::Type pointer(const Source& source,
builtin::AddressSpace address_space,
builtin::Access access = builtin::Access::kUndefined) const {
if (access != builtin::Access::kUndefined) {
return (*this)(source, "ptr", address_space, Of<T>(), access);
} else {
return (*this)(source, "ptr", address_space, Of<T>());
}
}
/// @param source the Source of the node
/// @param type the type of the atomic
/// @return the atomic to `type`
ast::Type atomic(const Source& source, ast::Type type) const {
return (*this)(source, "atomic", type);
}
/// @param type the type of the atomic
/// @return the atomic to `type`
ast::Type atomic(ast::Type type) const { return (*this)("atomic", type); }
/// @return the atomic to type `T`
template <typename T>
ast::Type atomic() const {
return atomic(Of<T>());
}
/// @param kind the kind of sampler
/// @returns the sampler
ast::Type sampler(type::SamplerKind kind) const { return sampler(builder->source_, kind); }
/// @param source the Source of the node
/// @param kind the kind of sampler
/// @returns the sampler
ast::Type sampler(const Source& source, type::SamplerKind kind) const {
switch (kind) {
case type::SamplerKind::kSampler:
return (*this)(source, "sampler");
case type::SamplerKind::kComparisonSampler:
return (*this)(source, "sampler_comparison");
}
TINT_ICE(ProgramBuilder, builder->Diagnostics()) << "invalid sampler kind " << kind;
return ast::Type{};
}
/// @param dims the dimensionality of the texture
/// @returns the depth texture
ast::Type depth_texture(type::TextureDimension dims) const {
return depth_texture(builder->source_, dims);
}
/// @param source the Source of the node
/// @param dims the dimensionality of the texture
/// @returns the depth texture
ast::Type depth_texture(const Source& source, type::TextureDimension dims) const {
switch (dims) {
case type::TextureDimension::k2d:
return (*this)(source, "texture_depth_2d");
case type::TextureDimension::k2dArray:
return (*this)(source, "texture_depth_2d_array");
case type::TextureDimension::kCube:
return (*this)(source, "texture_depth_cube");
case type::TextureDimension::kCubeArray:
return (*this)(source, "texture_depth_cube_array");
default:
break;
}
TINT_ICE(ProgramBuilder, builder->Diagnostics())
<< "invalid depth_texture dimensions: " << dims;
return ast::Type{};
}
/// @param dims the dimensionality of the texture
/// @returns the multisampled depth texture
ast::Type depth_multisampled_texture(type::TextureDimension dims) const {
return depth_multisampled_texture(builder->source_, dims);
}
/// @param source the Source of the node
/// @param dims the dimensionality of the texture
/// @returns the multisampled depth texture
ast::Type depth_multisampled_texture(const Source& source,
type::TextureDimension dims) const {
if (dims == type::TextureDimension::k2d) {
return (*this)(source, "texture_depth_multisampled_2d");
}
TINT_ICE(ProgramBuilder, builder->Diagnostics())
<< "invalid depth_multisampled_texture dimensions: " << dims;
return ast::Type{};
}
/// @param dims the dimensionality of the texture
/// @param subtype the texture subtype.
/// @returns the sampled texture
ast::Type sampled_texture(type::TextureDimension dims, ast::Type subtype) const {
return sampled_texture(builder->source_, 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
ast::Type sampled_texture(const Source& source,
type::TextureDimension dims,
ast::Type subtype) const {
switch (dims) {
case type::TextureDimension::k1d:
return (*this)(source, "texture_1d", subtype);
case type::TextureDimension::k2d:
return (*this)(source, "texture_2d", subtype);
case type::TextureDimension::k3d:
return (*this)(source, "texture_3d", subtype);
case type::TextureDimension::k2dArray:
return (*this)(source, "texture_2d_array", subtype);
case type::TextureDimension::kCube:
return (*this)(source, "texture_cube", subtype);
case type::TextureDimension::kCubeArray:
return (*this)(source, "texture_cube_array", subtype);
default:
break;
}
TINT_ICE(ProgramBuilder, builder->Diagnostics())
<< "invalid sampled_texture dimensions: " << dims;
return ast::Type{};
}
/// @param dims the dimensionality of the texture
/// @param subtype the texture subtype.
/// @returns the multisampled texture
ast::Type multisampled_texture(type::TextureDimension dims, ast::Type subtype) const {
return multisampled_texture(builder->source_, 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
ast::Type multisampled_texture(const Source& source,
type::TextureDimension dims,
ast::Type subtype) const {
if (dims == type::TextureDimension::k2d) {
return (*this)(source, "texture_multisampled_2d", subtype);
}
TINT_ICE(ProgramBuilder, builder->Diagnostics())
<< "invalid multisampled_texture dimensions: " << dims;
return ast::Type{};
}
/// @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
ast::Type storage_texture(type::TextureDimension dims,
builtin::TexelFormat format,
builtin::Access access) const {
return storage_texture(builder->source_, dims, format, 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
ast::Type storage_texture(const Source& source,
type::TextureDimension dims,
builtin::TexelFormat format,
builtin::Access access) const {
switch (dims) {
case type::TextureDimension::k1d:
return (*this)(source, "texture_storage_1d", format, access);
case type::TextureDimension::k2d:
return (*this)(source, "texture_storage_2d", format, access);
case type::TextureDimension::k2dArray:
return (*this)(source, "texture_storage_2d_array", format, access);
case type::TextureDimension::k3d:
return (*this)(source, "texture_storage_3d", format, access);
default:
break;
}
TINT_ICE(ProgramBuilder, builder->Diagnostics())
<< "invalid storage_texture dimensions: " << dims;
return ast::Type{};
}
/// @returns the external texture
ast::Type external_texture() const { return (*this)("texture_external"); }
/// @param source the Source of the node
/// @returns the external texture
ast::Type external_texture(const Source& source) const {
return (*this)(source, "texture_external");
}
/// @param type the type
/// @return an ast::Type of the type declaration.
ast::Type Of(const ast::TypeDecl* type) const { return (*this)(type->name->symbol); }
/// The ProgramBuilder
ProgramBuilder* const builder;
private:
/// CToAST<T> 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 ast::Type get(Types* t)`
template <typename T>
struct CToAST {};
};
//////////////////////////////////////////////////////////////////////////////
// AST helper methods
//////////////////////////////////////////////////////////////////////////////
/// @return a new unnamed symbol
Symbol Sym() { return Symbols().New(); }
/// Passthrough
/// @param sym the symbol
/// @return `sym`
Symbol Sym(Symbol sym) { return sym; }
/// @param name the symbol string
/// @return a Symbol with the given name
Symbol Sym(const std::string& name) { return Symbols().Register(name); }
/// @param enumerator the enumerator
/// @return a Symbol with the given enum value
template <typename ENUM, typename = std::enable_if_t<std::is_enum_v<std::decay_t<ENUM>>>>
Symbol Sym(ENUM&& enumerator) {
return Sym(utils::ToString(enumerator));
}
/// @return nullptr
const ast::Identifier* Ident(std::nullptr_t) { return nullptr; }
/// @param identifier the identifier symbol
/// @return an ast::Identifier with the given symbol
template <typename IDENTIFIER>
const ast::Identifier* Ident(IDENTIFIER&& identifier) {
if constexpr (traits::IsTypeOrDerived<traits::PtrElTy<IDENTIFIER>, ast::Identifier>) {
return identifier; // Passthrough
} else {
return Ident(source_, std::forward<IDENTIFIER>(identifier));
}
}
/// @param source the source information
/// @param identifier the identifier symbol
/// @return an ast::Identifier with the given symbol
template <typename IDENTIFIER>
const ast::Identifier* Ident(const Source& source, IDENTIFIER&& identifier) {
return create<ast::Identifier>(source, Sym(std::forward<IDENTIFIER>(identifier)));
}
/// @param identifier the identifier symbol
/// @param args the templated identifier arguments
/// @return an ast::Identifier with the given symbol and template arguments
template <typename IDENTIFIER, typename... ARGS, typename = DisableIfSource<IDENTIFIER>>
const ast::Identifier* Ident(IDENTIFIER&& identifier, ARGS&&... args) {
return Ident(source_, std::forward<IDENTIFIER>(identifier), std::forward<ARGS>(args)...);
}
/// @param source the source information
/// @param identifier the identifier symbol
/// @param args the templated identifier arguments
/// @return an ast::Identifier with the given symbol and template arguments
template <typename IDENTIFIER, typename... ARGS>
const ast::Identifier* Ident(const Source& source, IDENTIFIER&& identifier, ARGS&&... args) {
auto arg_exprs = ExprList(std::forward<ARGS>(args)...);
if (arg_exprs.IsEmpty()) {
return create<ast::Identifier>(source, Sym(std::forward<IDENTIFIER>(identifier)));
}
return create<ast::TemplatedIdentifier>(source, Sym(std::forward<IDENTIFIER>(identifier)),
std::move(arg_exprs), utils::Empty);
}
/// @param expr the expression
/// @return expr (passthrough)
template <typename T, typename = traits::EnableIfIsType<T, ast::Expression>>
const T* Expr(const T* expr) {
return expr;
}
/// @param type an ast::Type
/// @return type.expr
const ast::IdentifierExpression* Expr(ast::Type type) { return type.expr; }
/// @param ident the identifier
/// @return an ast::IdentifierExpression with the given identifier
const ast::IdentifierExpression* Expr(const ast::Identifier* ident) {
return ident ? create<ast::IdentifierExpression>(ident->source, ident) : nullptr;
}
/// Passthrough for nullptr
/// @return nullptr
const ast::IdentifierExpression* Expr(std::nullptr_t) { return nullptr; }
/// @param name the identifier name
/// @return an ast::IdentifierExpression with the given name
template <typename NAME, typename = EnableIfIdentifierLike<NAME>>
const ast::IdentifierExpression* Expr(NAME&& name) {
auto* ident = Ident(source_, name);
return create<ast::IdentifierExpression>(ident->source, ident);
}
/// @param source the source information
/// @param name the identifier name
/// @return an ast::IdentifierExpression with the given name
template <typename NAME, typename = EnableIfIdentifierLike<NAME>>
const ast::IdentifierExpression* Expr(const Source& source, NAME&& name) {
return create<ast::IdentifierExpression>(source, Ident(source, name));
}
/// @param variable the AST variable
/// @return an ast::IdentifierExpression with the variable's symbol
const ast::IdentifierExpression* Expr(const ast::Variable* variable) {
auto* ident = Ident(variable->source, variable->name->symbol);
return create<ast::IdentifierExpression>(ident->source, ident);
}
/// @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<ast::IdentifierExpression>(source, Ident(source, variable->name->symbol));
}
/// @param source the source information
/// @param value the boolean value
/// @return a Scalar constructor for the given value
template <typename BOOL>
std::enable_if_t<std::is_same_v<BOOL, bool>, const ast::BoolLiteralExpression*> Expr(
const Source& source,
BOOL value) {
return create<ast::BoolLiteralExpression>(source, 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<ast::FloatLiteralExpression>(source, static_cast<double>(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<ast::FloatLiteralExpression>(source, static_cast<double>(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<ast::IntLiteralExpression>(source, 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<ast::FloatLiteralExpression>(source, 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<ast::IntLiteralExpression>(source, 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<ast::IntLiteralExpression>(source, value,
ast::IntLiteralExpression::Suffix::kU);
}
/// @param value the scalar value
/// @return literal expression of the appropriate type
template <typename SCALAR, typename = EnableIfScalar<SCALAR>>
const auto* Expr(SCALAR&& value) {
return Expr(source_, std::forward<SCALAR>(value));
}
/// 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 <size_t N, typename ARG>
void Append(utils::Vector<const ast::Expression*, N>& list, ARG&& arg) {
list.Push(Expr(std::forward<ARG>(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 <size_t N, typename ARG0, typename... ARGS>
void Append(utils::Vector<const ast::Expression*, N>& list, ARG0&& arg0, ARGS&&... args) {
Append(list, std::forward<ARG0>(arg0));
Append(list, std::forward<ARGS>(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 <typename... ARGS, typename = DisableIfVectorLike<ARGS...>>
auto ExprList(ARGS&&... args) {
return utils::Vector<const ast::Expression*, sizeof...(ARGS)>{Expr(args)...};
}
/// @param list the list of expressions
/// @return `list`
template <typename T, size_t N>
utils::Vector<T, N> ExprList(utils::Vector<T, N>&& list) {
return std::move(list);
}
/// @param list the list of expressions
/// @return `list`
utils::VectorRef<const ast::Expression*> ExprList(
utils::VectorRef<const ast::Expression*> list) {
return list;
}
/// @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 <typename T, typename EXPR>
const ast::BitcastExpression* Bitcast(EXPR&& expr) {
return Bitcast(ty.Of<T>(), std::forward<EXPR>(expr));
}
/// @param type the type to cast to
/// @param expr the expression for the bitcast
/// @return an `ast::BitcastExpression` of @p type constructed with the values
/// `expr`.
template <typename EXPR>
const ast::BitcastExpression* Bitcast(ast::Type type, EXPR&& expr) {
return Bitcast(source_, type, Expr(std::forward<EXPR>(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 @p type constructed with the values
/// `expr`.
template <typename EXPR>
const ast::BitcastExpression* Bitcast(const Source& source, ast::Type type, EXPR&& expr) {
return create<ast::BitcastExpression>(source, type, Expr(std::forward<EXPR>(expr)));
}
/// @param type the vector type
/// @param size the vector size
/// @param args the arguments for the vector constructor
/// @return an `ast::CallExpression` of a `size`-element vector of
/// type `type`, constructed with the values @p args.
template <typename... ARGS>
const ast::CallExpression* vec(ast::Type type, uint32_t size, ARGS&&... args) {
return vec(source_, type, size, std::forward<ARGS>(args)...);
}
/// @param source the source of the call
/// @param type the vector type
/// @param size the vector size
/// @param args the arguments for the vector constructor
/// @return an `ast::CallExpression` of a `size`-element vector of
/// type `type`, constructed with the values @p args.
template <typename... ARGS>
const ast::CallExpression* vec(const Source& source,
ast::Type type,
uint32_t size,
ARGS&&... args) {
return Call(source, ty.vec(type, size), std::forward<ARGS>(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 @p args.
template <typename T, typename... ARGS, typename = DisableIfSource<ARGS...>>
const ast::CallExpression* vec2(ARGS&&... args) {
return vec2<T>(source_, std::forward<ARGS>(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 @p args.
template <typename T, typename... ARGS>
const ast::CallExpression* vec2(const Source& source, ARGS&&... args) {
return Call(source, ty.vec2<T>(), std::forward<ARGS>(args)...);
}
/// @param type the element type of the vector
/// @param args the arguments for the vector constructor
/// @return an `ast::CallExpression` of a 2-element vector of type @p type, constructed with the
/// values @p args.
template <typename... ARGS>
const ast::CallExpression* vec2(ast::Type type, ARGS&&... args) {
return vec2(source_, type, std::forward<ARGS>(args)...);
}
/// @param source the vector source
/// @param type the element type of the vector
/// @param args the arguments for the vector constructor
/// @return an `ast::CallExpression` of a 2-element vector of type @p type, constructed with the
/// values @p args.
template <typename... ARGS>
const ast::CallExpression* vec2(const Source& source, ast::Type type, ARGS&&... args) {
return Call(source, ty.vec2(type), std::forward<ARGS>(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 @p args.
template <typename T, typename... ARGS, typename = DisableIfSource<ARGS...>>
const ast::CallExpression* vec3(ARGS&&... args) {
return vec3<T>(source_, std::forward<ARGS>(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 @p args.
template <typename T, typename... ARGS>
const ast::CallExpression* vec3(const Source& source, ARGS&&... args) {
return Call(source, ty.vec3<T>(), std::forward<ARGS>(args)...);
}
/// @param type the element type of the vector
/// @param args the arguments for the vector constructor
/// @return an `ast::CallExpression` of a 3-element vector of type @p type, constructed with the
/// values @p args.
template <typename... ARGS>
const ast::CallExpression* vec3(ast::Type type, ARGS&&... args) {
return vec3(source_, type, std::forward<ARGS>(args)...);
}
/// @param source the vector source
/// @param type the element type of the vector
/// @param args the arguments for the vector constructor
/// @return an `ast::CallExpression` of a 3-element vector of type @p type, constructed with the
/// values @p args.
template <typename... ARGS>
const ast::CallExpression* vec3(const Source& source, ast::Type type, ARGS&&... args) {
return Call(source, ty.vec3(type), std::forward<ARGS>(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 @p args.
template <typename T, typename... ARGS, typename = DisableIfSource<ARGS...>>
const ast::CallExpression* vec4(ARGS&&... args) {
return vec4<T>(source_, std::forward<ARGS>(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 @p args.
template <typename T, typename... ARGS>
const ast::CallExpression* vec4(const Source& source, ARGS&&... args) {
return Call(source, ty.vec4<T>(), std::forward<ARGS>(args)...);
}
/// @param type the element type of the vector
/// @param args the arguments for the vector constructor
/// @return an `ast::CallExpression` of a 4-element vector of type @p type, constructed with the
/// values @p args.
template <typename... ARGS>
const ast::CallExpression* vec4(ast::Type type, ARGS&&... args) {
return vec4(source_, type, std::forward<ARGS>(args)...);
}
/// @param source the vector source
/// @param type the element type of the vector
/// @param args the arguments for the vector constructor
/// @return an `ast::CallExpression` of a 4-element vector of type @p type, constructed with the
/// values @p args.
template <typename... ARGS>
const ast::CallExpression* vec4(const Source& source, ast::Type type, ARGS&&... args) {
return Call(source, ty.vec4(type), std::forward<ARGS>(args)...);
}
/// @param args the arguments for the matrix constructor
/// @return an `ast::CallExpression` of a 2x2 matrix of type
/// `T`, constructed with the values @p args.
template <typename T, typename... ARGS, typename = DisableIfSource<ARGS...>>
const ast::CallExpression* mat2x2(ARGS&&... args) {
return mat2x2<T>(source_, std::forward<ARGS>(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 @p args.
template <typename T, typename... ARGS>
const ast::CallExpression* mat2x2(const Source& source, ARGS&&... args) {
return Call(source, ty.mat2x2<T>(), std::forward<ARGS>(args)...);
}
/// @param args the arguments for the matrix constructor
/// @return an `ast::CallExpression` of a 2x3 matrix of type
/// `T`, constructed with the values @p args.
template <typename T, typename... ARGS, typename = DisableIfSource<ARGS...>>
const ast::CallExpression* mat2x3(ARGS&&... args) {
return mat2x3<T>(source_, std::forward<ARGS>(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 @p args.
template <typename T, typename... ARGS>
const ast::CallExpression* mat2x3(const Source& source, ARGS&&... args) {
return Call(source, ty.mat2x3<T>(), std::forward<ARGS>(args)...);
}
/// @param args the arguments for the matrix constructor
/// @return an `ast::CallExpression` of a 2x4 matrix of type
/// `T`, constructed with the values @p args.
template <typename T, typename... ARGS, typename = DisableIfSource<ARGS...>>
const ast::CallExpression* mat2x4(ARGS&&... args) {
return mat2x4<T>(source_, std::forward<ARGS>(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 @p args.
template <typename T, typename... ARGS>
const ast::CallExpression* mat2x4(const Source& source, ARGS&&... args) {
return Call(source, ty.mat2x4<T>(), std::forward<ARGS>(args)...);
}
/// @param args the arguments for the matrix constructor
/// @return an `ast::CallExpression` of a 3x2 matrix of type
/// `T`, constructed with the values @p args.
template <typename T, typename... ARGS, typename = DisableIfSource<ARGS...>>
const ast::CallExpression* mat3x2(ARGS&&... args) {
return mat3x2<T>(source_, std::forward<ARGS>(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 @p args.
template <typename T, typename... ARGS>
const ast::CallExpression* mat3x2(const Source& source, ARGS&&... args) {
return Call(source, ty.mat3x2<T>(), std::forward<ARGS>(args)...);
}
/// @param args the arguments for the matrix constructor
/// @return an `ast::CallExpression` of a 3x3 matrix of type
/// `T`, constructed with the values @p args.
template <typename T, typename... ARGS, typename = DisableIfSource<ARGS...>>
const ast::CallExpression* mat3x3(ARGS&&... args) {
return mat3x3<T>(source_, std::forward<ARGS>(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 @p args.
template <typename T, typename... ARGS>
const ast::CallExpression* mat3x3(const Source& source, ARGS&&... args) {
return Call(source, ty.mat3x3<T>(), std::forward<ARGS>(args)...);
}
/// @param args the arguments for the matrix constructor
/// @return an `ast::CallExpression` of a 3x4 matrix of type
/// `T`, constructed with the values @p args.
template <typename T, typename... ARGS, typename = DisableIfSource<ARGS...>>
const ast::CallExpression* mat3x4(ARGS&&... args) {
return mat3x4<T>(source_, std::forward<ARGS>(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 @p args.
template <typename T, typename... ARGS>
const ast::CallExpression* mat3x4(const Source& source, ARGS&&... args) {
return Call(source, ty.mat3x4<T>(), std::forward<ARGS>(args)...);
}
/// @param args the arguments for the matrix constructor
/// @return an `ast::CallExpression` of a 4x2 matrix of type
/// `T`, constructed with the values @p args.
template <typename T, typename... ARGS, typename = DisableIfSource<ARGS...>>
const ast::CallExpression* mat4x2(ARGS&&... args) {
return mat4x2<T>(source_, std::forward<ARGS>(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 @p args.
template <typename T, typename... ARGS>
const ast::CallExpression* mat4x2(const Source& source, ARGS&&... args) {
return Call(source, ty.mat4x2<T>(), std::forward<ARGS>(args)...);
}
/// @param args the arguments for the matrix constructor
/// @return an `ast::CallExpression` of a 4x3 matrix of type
/// `T`, constructed with the values @p args.
template <typename T, typename... ARGS, typename = DisableIfSource<ARGS...>>
const ast::CallExpression* mat4x3(ARGS&&... args) {
return mat4x3<T>(source_, std::forward<ARGS>(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 @p args.
template <typename T, typename... ARGS>
const ast::CallExpression* mat4x3(const Source& source, ARGS&&... args) {
return Call(source, ty.mat4x3<T>(), std::forward<ARGS>(args)...);
}
/// @param args the arguments for the matrix constructor
/// @return an `ast::CallExpression` of a 4x4 matrix of type
/// `T`, constructed with the values @p args.
template <typename T, typename... ARGS, typename = DisableIfSource<ARGS...>>
const ast::CallExpression* mat4x4(ARGS&&... args) {
return mat4x4<T>(source_, std::forward<ARGS>(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 @p args.
template <typename T, typename... ARGS>
const ast::CallExpression* mat4x4(const Source& source, ARGS&&... args) {
return Call(source, ty.mat4x4<T>(), std::forward<ARGS>(args)...);
}
/// @param args the arguments for the array constructor
/// @return an `ast::CallExpression` of an array with element type `T`, constructed with the
/// values @p args.
template <typename T, typename... ARGS, typename = DisableIfSource<ARGS...>>
const ast::CallExpression* array(ARGS&&... args) {
return Call(ty.array<T>(), std::forward<ARGS>(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`, constructed with the
/// values @p args.
template <typename T, typename... ARGS>
const ast::CallExpression* array(const Source& source, ARGS&&... args) {
return Call(source, ty.array<T>(), std::forward<ARGS>(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 @p args.
template <typename T, int N, typename... ARGS, typename = DisableIfSource<ARGS...>>
const ast::CallExpression* array(ARGS&&... args) {
return Call(ty.array<T, N>(), std::forward<ARGS>(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 @p args.
template <typename T, int N, typename... ARGS>
const ast::CallExpression* array(const Source& source, ARGS&&... args) {
return Call(source, ty.array<T, N>(), std::forward<ARGS>(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 @p args.
template <typename EXPR, typename... ARGS>
const ast::CallExpression* array(ast::Type subtype, EXPR&& n, ARGS&&... args) {
return Call(ty.array(subtype, std::forward<EXPR>(n)), std::forward<ARGS>(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 @p args.
template <typename EXPR, typename... ARGS>
const ast::CallExpression* array(const Source& source,
ast::Type subtype,
EXPR&& n,
ARGS&&... args) {
return Call(source, ty.array(subtype, std::forward<EXPR>(n)), std::forward<ARGS>(args)...);
}
/// Adds the extension to the list of enable directives at the top of the module.
/// @param extension the extension to enable
/// @return an `ast::Enable` enabling the given extension.
const ast::Enable* Enable(builtin::Extension extension) {
auto* ext = create<ast::Extension>(extension);
auto* enable = create<ast::Enable>(utils::Vector{ext});
AST().AddEnable(enable);
return enable;
}
/// Adds the extension to the list of enable directives at the top of the module.
/// @param source the enable source
/// @param extension the extension to enable
/// @return an `ast::Enable` enabling the given extension.
const ast::Enable* Enable(const Source& source, builtin::Extension extension) {
auto* ext = create<ast::Extension>(source, extension);
auto* enable = create<ast::Enable>(source, utils::Vector{ext});
AST().AddEnable(enable);
return enable;
}
/// @param name the variable name
/// @param options the extra options passed to the ast::Var initializer
/// Can be any of the following, in any order:
/// * ast::Type - specifies the variable's type
/// * builtin::AddressSpace - specifies the variable's address space
/// * builtin::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 <typename NAME, typename... OPTIONS, typename = DisableIfSource<NAME>>
const ast::Var* Var(NAME&& name, OPTIONS&&... options) {
return Var(source_, std::forward<NAME>(name), std::forward<OPTIONS>(options)...);
}
/// @param source the variable source
/// @param name the variable name
/// @param options the extra options passed to the ast::Var initializer
/// Can be any of the following, in any order:
/// * ast::Type - specifies the variable's type
/// * builtin::AddressSpace - specifies the variable's address space
/// * builtin::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, address_space and type
template <typename NAME, typename... OPTIONS>
const ast::Var* Var(const Source& source, NAME&& name, OPTIONS&&... options) {
VarOptions opts(*this, std::forward<OPTIONS>(options)...);
return create<ast::Var>(source, Ident(std::forward<NAME>(name)), opts.type,
opts.address_space, opts.access, opts.initializer,
std::move(opts.attributes));
}
/// @param name the variable name
/// @param options the extra options passed to the ast::Var initializer
/// Can be any of the following, in any order:
/// * ast::Expression* - specifies the variable's initializer expression (required)
/// * ast::Type - specifies the variable's 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 <typename NAME, typename... OPTIONS, typename = DisableIfSource<NAME>>
const ast::Const* Const(NAME&& name, OPTIONS&&... options) {
return Const(source_, std::forward<NAME>(name), std::forward<OPTIONS>(options)...);
}
/// @param source the variable source
/// @param name the variable name
/// @param options the extra options passed to the ast::Var initializer
/// Can be any of the following, in any order:
/// * ast::Expression* - specifies the variable's initializer expression (required)
/// * ast::Identifier* - specifies the variable's type
/// * ast::Type - specifies the variable's 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 <typename NAME, typename... OPTIONS>
const ast::Const* Const(const Source& source, NAME&& name, OPTIONS&&... options) {
ConstOptions opts(std::forward<OPTIONS>(options)...);
return create<ast::Const>(source, Ident(std::forward<NAME>(name)), opts.type,
opts.initializer, std::move(opts.attributes));
}
/// @param name the variable name
/// @param options the extra options passed to the ast::Var initializer
/// Can be any of the following, in any order:
/// * ast::Expression* - specifies the variable's initializer expression (required)
/// * ast::Type - specifies the variable's 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 <typename NAME, typename... OPTIONS, typename = DisableIfSource<NAME>>
const ast::Let* Let(NAME&& name, OPTIONS&&... options) {
return Let(source_, std::forward<NAME>(name), std::forward<OPTIONS>(options)...);
}
/// @param source the variable source
/// @param name the variable name
/// @param options the extra options passed to the ast::Var initializer
/// Can be any of the following, in any order:
/// * ast::Expression* - specifies the variable's initializer expression (required)
/// * ast::Type - specifies the variable's 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 <typename NAME, typename... OPTIONS>
const ast::Let* Let(const Source& source, NAME&& name, OPTIONS&&... options) {
LetOptions opts(std::forward<OPTIONS>(options)...);
return create<ast::Let>(source, Ident(std::forward<NAME>(name)), opts.type,
opts.initializer, 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 <typename NAME>
const ast::Parameter* Param(NAME&& name,
ast::Type type,
utils::VectorRef<const ast::Attribute*> attributes = utils::Empty) {
return Param(source_, std::forward<NAME>(name), type, std::move(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 <typename NAME>
const ast::Parameter* Param(const Source& source,
NAME&& name,
ast::Type type,
utils::VectorRef<const ast::Attribute*> attributes = utils::Empty) {
return create<ast::Parameter>(source, Ident(std::forward<NAME>(name)), type,
std::move(attributes));
}
/// @param name the variable name
/// @param options the extra options passed to the ast::Var initializer
/// Can be any of the following, in any order:
/// * ast::Type - specifies the variable's type
/// * builtin::AddressSpace - specifies the variable address space
/// * builtin::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 <typename NAME, typename... OPTIONS, typename = DisableIfSource<NAME>>
const ast::Var* GlobalVar(NAME&& name, OPTIONS&&... options) {
return GlobalVar(source_, std::forward<NAME>(name), std::forward<OPTIONS>(options)...);
}
/// @param source the variable source
/// @param name the variable name
/// @param options the extra options passed to the ast::Var initializer
/// Can be any of the following, in any order:
/// * ast::Type - specifies the variable's type
/// * builtin::AddressSpace - specifies the variable address space
/// * builtin::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 <typename NAME, typename... OPTIONS>
const ast::Var* GlobalVar(const Source& source, NAME&& name, OPTIONS&&... options) {
auto* variable = Var(source, std::forward<NAME>(name), std::forward<OPTIONS>(options)...);
AST().AddGlobalVariable(variable);
return variable;
}
/// @param name the variable name
/// @param options the extra options passed to the ast::Const initializer
/// Can be any of the following, in any order:
/// * ast::Expression* - specifies the variable's initializer expression (required)
/// * ast::Type - specifies the variable's 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 <typename NAME, typename... OPTIONS, typename = DisableIfSource<NAME>>
const ast::Const* GlobalConst(NAME&& name, OPTIONS&&... options) {
return GlobalConst(source_, std::forward<NAME>(name), std::forward<OPTIONS>(options)...);
}
/// @param source the variable source
/// @param name the variable name
/// @param options the extra options passed to the ast::Const initializer
/// Can be any of the following, in any order:
/// * ast::Expression* - specifies the variable's initializer expression (required)
/// * ast::Type - specifies the variable's 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 <typename NAME, typename... OPTIONS>
const ast::Const* GlobalConst(const Source& source, NAME&& name, OPTIONS&&... options) {
auto* variable = Const(source, std::forward<NAME>(name), std::forward<OPTIONS>(options)...);
AST().AddGlobalVariable(variable);
return variable;
}
/// @param name the variable name
/// @param options the extra options passed to the ast::Override initializer
/// Can be any of the following, in any order:
/// * ast::Expression* - specifies the variable's initializer expression (required)
/// * ast::Type - specifies the variable's 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 <typename NAME, typename... OPTIONS, typename = DisableIfSource<NAME>>
const ast::Override* Override(NAME&& name, OPTIONS&&... options) {
return Override(source_, std::forward<NAME>(name), std::forward<OPTIONS>(options)...);
}
/// @param source the variable source
/// @param name the variable name
/// @param options the extra options passed to the ast::Override initializer
/// Can be any of the following, in any order:
/// * ast::Expression* - specifies the variable's initializer expression (required)
/// * ast::Type - specifies the variable's 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 <typename NAME, typename... OPTIONS>
const ast::Override* Override(const Source& source, NAME&& name, OPTIONS&&... options) {
OverrideOptions opts(std::forward<OPTIONS>(options)...);
auto* variable = create<ast::Override>(source, Ident(std::forward<NAME>(name)), opts.type,
opts.initializer, std::move(opts.attributes));
AST().AddGlobalVariable(variable);
return variable;
}
/// @param source the source information
/// @param condition the assertion condition
/// @returns a new `ast::ConstAssert`, which is automatically registered as a global statement
/// with the ast::Module.
template <typename EXPR>
const ast::ConstAssert* GlobalConstAssert(const Source& source, EXPR&& condition) {
auto* sa = ConstAssert(source, std::forward<EXPR>(condition));
AST().AddConstAssert(sa);
return sa;
}
/// @param condition the assertion condition
/// @returns a new `ast::ConstAssert`, which is automatically registered as a global statement
/// with the ast::Module.
template <typename EXPR, typename = DisableIfSource<EXPR>>
const ast::ConstAssert* GlobalConstAssert(EXPR&& condition) {
auto* sa = ConstAssert(std::forward<EXPR>(condition));
AST().AddConstAssert(sa);
return sa;
}
/// @param source the source information
/// @param condition the assertion condition
/// @returns a new `ast::ConstAssert` with the given assertion condition
template <typename EXPR>
const ast::ConstAssert* ConstAssert(const Source& source, EXPR&& condition) {
return create<ast::ConstAssert>(source, Expr(std::forward<EXPR>(condition)));
}
/// @param condition the assertion condition
/// @returns a new `ast::ConstAssert` with the given assertion condition
template <typename EXPR, typename = DisableIfSource<EXPR>>
const ast::ConstAssert* ConstAssert(EXPR&& condition) {
return create<ast::ConstAssert>(Expr(std::forward<EXPR>(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 <typename EXPR>
const ast::UnaryOpExpression* AddressOf(const Source& source, EXPR&& expr) {
return create<ast::UnaryOpExpression>(source, ast::UnaryOp::kAddressOf,
Expr(std::forward<EXPR>(expr)));
}
/// @param expr the expression to take the address of
/// @return an ast::UnaryOpExpression that takes the address of `expr`
template <typename EXPR>
const ast::UnaryOpExpression* AddressOf(EXPR&& expr) {
return create<ast::UnaryOpExpression>(ast::UnaryOp::kAddressOf,
Expr(std::forward<EXPR>(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 <typename EXPR>
const ast::UnaryOpExpression* Deref(const Source& source, EXPR&& expr) {
return create<ast::UnaryOpExpression>(source, ast::UnaryOp::kIndirection,
Expr(std::forward<EXPR>(expr)));
}
/// @param expr the expression to perform an indirection on
/// @return an ast::UnaryOpExpression that dereferences the pointer `expr`
template <typename EXPR>
const ast::UnaryOpExpression* Deref(EXPR&& expr) {
return create<ast::UnaryOpExpression>(ast::UnaryOp::kIndirection,
Expr(std::forward<EXPR>(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 <typename EXPR>
const ast::UnaryOpExpression* Not(EXPR&& expr) {
return create<ast::UnaryOpExpression>(ast::UnaryOp::kNot, Expr(std::forward<EXPR>(expr)));
}
/// @param source the source information
/// @param expr the expression to perform a unary not on
/// @return an ast::UnaryOpExpression that is the unary not of the input
/// expression
template <typename EXPR>
const ast::UnaryOpExpression* Not(const Source& source, EXPR&& expr) {
return create<ast::UnaryOpExpression>(source, ast::UnaryOp::kNot,
Expr(std::forward<EXPR>(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 <typename EXPR>
const ast::UnaryOpExpression* Complement(EXPR&& expr) {
return create<ast::UnaryOpExpression>(ast::UnaryOp::kComplement,
Expr(std::forward<EXPR>(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 <typename EXPR>
const ast::UnaryOpExpression* Negation(EXPR&& expr) {
return create<ast::UnaryOpExpression>(ast::UnaryOp::kNegation,
Expr(std::forward<EXPR>(expr)));
}
/// @param args the arguments for the constructor
/// @returns an ast::CallExpression to the type `T`, with the arguments of @p args converted to
/// `ast::Expression`s using Expr().
template <typename T, typename... ARGS, typename = DisableIfSource<ARGS...>>
const ast::CallExpression* Call(ARGS&&... args) {
return Call(source_, ty.Of<T>(), std::forward<ARGS>(args)...);
}
/// @param source the source of the call
/// @param args the arguments for the constructor
/// @returns an ast::CallExpression to the type `T` with the arguments of @p args converted to
/// `ast::Expression`s using Expr().
template <typename T, typename... ARGS>
const ast::CallExpression* Call(const Source& source, ARGS&&... args) {
return Call(source, ty.Of<T>(), std::forward<ARGS>(args)...);
}
/// @param target the call target
/// @param args the function call arguments
/// @returns an ast::CallExpression to the target @p target, with the arguments of @p args
/// converted to `ast::Expression`s using Expr().
template <typename TARGET,
typename... ARGS,
typename = DisableIfSource<TARGET>,
typename = DisableIfScalar<TARGET>>
const ast::CallExpression* Call(TARGET&& target, ARGS&&... args) {
return Call(source_, Expr(std::forward<TARGET>(target)), std::forward<ARGS>(args)...);
}
/// @param source the source of the call
/// @param target the call target
/// @param args the function call arguments
/// @returns an ast::CallExpression to the target @p target, with the arguments of @p args
/// converted to `ast::Expression`s using Expr().
template <typename TARGET, typename... ARGS, typename = DisableIfScalar<TARGET>>
const ast::CallExpression* Call(const Source& source, TARGET&& target, ARGS&&... args) {
return create<ast::CallExpression>(source, Expr(std::forward<TARGET>(target)),
ExprList(std::forward<ARGS>(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<ast::CallStatement>(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<ast::CallStatement>(call);
}
/// @param source the source information
/// @returns a `ast::PhonyExpression`
const ast::PhonyExpression* Phony(const Source& source) {
return create<ast::PhonyExpression>(source);
}
/// @returns a `ast::PhonyExpression`
const ast::PhonyExpression* Phony() { return create<ast::PhonyExpression>(); }
/// @param expr the expression to ignore
/// @returns a `ast::AssignmentStatement` that assigns 'expr' to the phony
/// (underscore) variable.
template <typename EXPR>
const ast::AssignmentStatement* Ignore(EXPR&& expr) {
return create<ast::AssignmentStatement>(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 <typename LHS, typename RHS>
const ast::BinaryExpression* Add(LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(ast::BinaryOp::kAdd, Expr(std::forward<LHS>(lhs)),
Expr(std::forward<RHS>(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 <typename LHS, typename RHS>
const ast::BinaryExpression* Add(const Source& source, LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(source, ast::BinaryOp::kAdd,
Expr(std::forward<LHS>(lhs)),
Expr(std::forward<RHS>(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 <typename LHS, typename RHS>
const ast::BinaryExpression* And(LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(ast::BinaryOp::kAnd, Expr(std::forward<LHS>(lhs)),
Expr(std::forward<RHS>(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 <typename LHS, typename RHS>
const ast::BinaryExpression* Or(LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(ast::BinaryOp::kOr, Expr(std::forward<LHS>(lhs)),
Expr(std::forward<RHS>(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 <typename LHS, typename RHS>
const ast::BinaryExpression* Sub(LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(ast::BinaryOp::kSubtract, Expr(std::forward<LHS>(lhs)),
Expr(std::forward<RHS>(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 <typename LHS, typename RHS>
const ast::BinaryExpression* Mul(LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, Expr(std::forward<LHS>(lhs)),
Expr(std::forward<RHS>(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 <typename LHS, typename RHS>
const ast::BinaryExpression* Mul(const Source& source, LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(source, ast::BinaryOp::kMultiply,
Expr(std::forward<LHS>(lhs)),
Expr(std::forward<RHS>(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 <typename LHS, typename RHS>
const ast::BinaryExpression* Div(LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(ast::BinaryOp::kDivide, Expr(std::forward<LHS>(lhs)),
Expr(std::forward<RHS>(rhs)));
}
/// @param source the source information
/// @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 <typename LHS, typename RHS>
const ast::BinaryExpression* Div(const Source& source, LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(source, ast::BinaryOp::kDivide,
Expr(std::forward<LHS>(lhs)),
Expr(std::forward<RHS>(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 <typename LHS, typename RHS>
const ast::BinaryExpression* Mod(LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(ast::BinaryOp::kModulo, Expr(std::forward<LHS>(lhs)),
Expr(std::forward<RHS>(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 <typename LHS, typename RHS>
const ast::BinaryExpression* Shr(LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(
ast::BinaryOp::kShiftRight, Expr(std::forward<LHS>(lhs)), Expr(std::forward<RHS>(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 <typename LHS, typename RHS>
const ast::BinaryExpression* Shl(LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(
ast::BinaryOp::kShiftLeft, Expr(std::forward<LHS>(lhs)), Expr(std::forward<RHS>(rhs)));
}
/// @param source the source information
/// @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 <typename LHS, typename RHS>
const ast::BinaryExpression* Shl(const Source& source, LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(source, ast::BinaryOp::kShiftLeft,
Expr(std::forward<LHS>(lhs)),
Expr(std::forward<RHS>(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 <typename LHS, typename RHS>
const ast::BinaryExpression* Xor(LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(ast::BinaryOp::kXor, Expr(std::forward<LHS>(lhs)),
Expr(std::forward<RHS>(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 <typename LHS, typename RHS>
const ast::BinaryExpression* LogicalAnd(LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalAnd, Expr(std::forward<LHS>(lhs)), Expr(std::forward<RHS>(rhs)));
}
/// @param source the source information
/// @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 <typename LHS, typename RHS>
const ast::BinaryExpression* LogicalAnd(const Source& source, LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(source, ast::BinaryOp::kLogicalAnd,
Expr(std::forward<LHS>(lhs)),
Expr(std::forward<RHS>(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 <typename LHS, typename RHS>
const ast::BinaryExpression* LogicalOr(LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalOr, Expr(std::forward<LHS>(lhs)), Expr(std::forward<RHS>(rhs)));
}
/// @param source the source information
/// @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 <typename LHS, typename RHS>
const ast::BinaryExpression* LogicalOr(const Source& source, LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(source, ast::BinaryOp::kLogicalOr,
Expr(std::forward<LHS>(lhs)),
Expr(std::forward<RHS>(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 <typename LHS, typename RHS>
const ast::BinaryExpression* GreaterThan(LHS&& lhs, RHS&& rhs) {
return create<ast::BinaryExpression>(ast::BinaryOp::kGreaterThan,
Expr(std::forward<LHS>(lhs)),
Expr(std::forward<RHS>(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`