From 165ff1c97837ff6ab9546c6c80ea50bade1a77fc Mon Sep 17 00:00:00 2001 From: Ben Clayton Date: Tue, 17 Nov 2020 15:23:48 +0000 Subject: [PATCH] ast::Builder: Make the interface more fluent Add C++ aliases for the wgsl types `i32`, `u32` and `f32`. Separate types out from the builder and into a `Builder::Types` class. An instance of this is now held by the `Builder::ty` field. Makes it clear when you are referencing a `ast::type` instead of a constructor method. Rework a number of builder methods so they take the type as a template argument instead of a parameter. This more closely resembles wgsl (example: `vec2(1,2)`) Use PascalCase for the constructor methods, but keep the wgsl-like constructors lowercase to imitate the language style. Add `BuilderWithContext` so that `Builder` can be truely immutable, and so we can remove `set_context()`. Change-Id: Idf2d7d5abe7d11e27671b8e80d3d56d6bc4b3ca2 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/32980 Reviewed-by: dan sinclair Commit-Queue: Ben Clayton --- src/ast/builder.cc | 26 +- src/ast/builder.h | 356 ++++++++++++++------- src/type_manager.h | 10 + src/writer/spirv/builder_intrinsic_test.cc | 349 +++++++++----------- 4 files changed, 427 insertions(+), 314 deletions(-) diff --git a/src/ast/builder.cc b/src/ast/builder.cc index c30672aaf3..de6b3ae15e 100644 --- a/src/ast/builder.cc +++ b/src/ast/builder.cc @@ -17,16 +17,28 @@ namespace tint { namespace ast { -Builder::Builder() = default; - -Builder::Builder(tint::Context* ctx) : ctx_(ctx) {} +TypesBuilder::TypesBuilder(TypeManager* tm) + : bool_(tm->Get()), + f32(tm->Get()), + i32(tm->Get()), + u32(tm->Get()), + void_(tm->Get()), + tm_(tm) {} +Builder::Builder(tint::Context* c) : ctx(c), ty(&c->type_mgr()) {} Builder::~Builder() = default; -ast::Variable* Builder::make_var(const std::string& name, - ast::StorageClass storage, - ast::type::Type* type) { - return create(name, storage, type); +ast::Variable* Builder::Var(const std::string& name, + ast::StorageClass storage, + ast::type::Type* type) { + auto* var = create(name, storage, type); + OnVariableBuilt(var); + return var; +} + +BuilderWithContext::BuilderWithContext() : Builder(new Context()) {} +BuilderWithContext::~BuilderWithContext() { + delete ctx; } } // namespace ast diff --git a/src/ast/builder.h b/src/ast/builder.h index 389d6c64c1..39ae9d2cdc 100644 --- a/src/ast/builder.h +++ b/src/ast/builder.h @@ -15,8 +15,6 @@ #ifndef SRC_AST_BUILDER_H_ #define SRC_AST_BUILDER_H_ -#include - #include #include #include @@ -42,175 +40,234 @@ namespace tint { namespace ast { -/// Helper for building common AST constructs -class Builder { +/// TypesBuilder holds basic `ast::tint` types and methods for constructing +/// complex types. +class TypesBuilder { public: /// Constructor - /// Note, the context _must_ be set with |set_context| before the builder - /// is used. - Builder(); + /// @param tm the type manager + explicit TypesBuilder(TypeManager* tm); + + /// A boolean type + ast::type::BoolType* const bool_; + /// A f32 type + ast::type::F32Type* const f32; + /// A i32 type + ast::type::I32Type* const i32; + /// A u32 type + ast::type::U32Type* const u32; + /// A void type + ast::type::VoidType* const void_; + + /// @return the tint AST type for the C type `T`. + template + ast::type::Type* Of() const; + + /// @return the tint AST type for a 2-element vector of the C type `T`. + template + ast::type::Type* vec2() const; + + /// @return the tint AST type for a 3-element vector of the C type `T`. + template + ast::type::Type* vec3() const; + + /// @return the tint AST type for a 4-element vector of the C type `T`. + template + ast::type::Type* vec4() const; + + /// @return the tint AST type for a 3x3 matrix of the C type `T`. + template + ast::type::Type* mat3x3() const; + + /// @return the tint AST type for an array of type `T`. + template + ast::type::Type* arr() const; + + private: + /// CToAST is specialized for various `T` types and each specialization + /// contains a single static `get()` method for obtaining the corresponding + /// AST type for the C type `T`. + /// `get()` has the signature: + /// `static ast::type::Type* get(Types* t)` + template + struct CToAST {}; + + TypeManager* const tm_; +}; + +/// Helper for building common AST constructs. +class Builder { + public: + /// `i32` is a type alias to `int`. + /// Useful for passing to template methods such as `vec2()` to imitate + /// WGSL syntax. + /// Note: this is intentionally not aliased to uint32_t as we want integer + /// literals passed to the builder to match WGSL's integer literal types. + using i32 = decltype(1); + /// `u32` is a type alias to `unsigned int`. + /// Useful for passing to template methods such as `vec2()` to imitate + /// WGSL syntax. + /// Note: this is intentionally not aliased to uint32_t as we want integer + /// literals passed to the builder to match WGSL's integer literal types. + using u32 = decltype(1u); + /// `f32` is a type alias to `float` + /// Useful for passing to template methods such as `vec2()` to imitate + /// WGSL syntax. + using f32 = float; + /// Constructor /// @param ctx the context to use in the builder explicit Builder(tint::Context* ctx); virtual ~Builder(); - /// Sets the given context into the builder - /// @param ctx the context to set - void set_context(tint::Context* ctx) { ctx_ = ctx; } - - /// Creates a new type - /// @param args the arguments to pass to the type constructor - /// @returns a registered pointer to the requested type - template - ast::type::Type* type(ARGS&&... args) { - assert(ctx_); - return ctx_->type_mgr().Get( - std::make_unique(std::forward(args)...)); - } - - /// @returns a pointer to the bool type - ast::type::BoolType* bool_type() { - return type()->AsBool(); - } - - /// @returns a pointer to the f32 type - ast::type::F32Type* f32() { return type()->AsF32(); } - - /// @returns a pointer to the i32 type - ast::type::I32Type* i32() { return type()->AsI32(); } - - /// @param ty the type of the matrix components - /// @param rows the number of rows - /// @param cols the number of columns - /// @returns a pointer to the u32 type - ast::type::MatrixType* mat(ast::type::Type* ty, - uint32_t rows, - uint32_t cols) { - return type(ty, rows, cols)->AsMatrix(); - } - - /// @returns a pointer to the u32 type - ast::type::U32Type* u32() { return type()->AsU32(); } - - /// @param ty the type of the vector components - /// @param size the size of the vector - /// @returns a pointer to the vector type - ast::type::VectorType* vec(ast::type::Type* ty, uint32_t size) { - return type(ty, size)->AsVector(); - } - - /// @returns a pointer to the void type - ast::type::VoidType* void_type() { - return type()->AsVoid(); - } - /// @param expr the expression /// @return expr - ast::Expression* make_expr(ast::Expression* expr) { return expr; } + ast::Expression* Expr(ast::Expression* expr) { return expr; } /// @param name the identifier name /// @return an IdentifierExpression with the given name - ast::IdentifierExpression* make_expr(const std::string& name) { + ast::IdentifierExpression* Expr(const std::string& name) { return create(name); } /// @param name the identifier name /// @return an IdentifierExpression with the given name - ast::IdentifierExpression* make_expr(const char* name) { + ast::IdentifierExpression* Expr(const char* name) { return create(name); } /// @param value the float value /// @return a Scalar constructor for the given value - ast::ScalarConstructorExpression* make_expr(float value) { - return create(make_literal(value)); + ast::ScalarConstructorExpression* Expr(f32 value) { + return create(Literal(value)); } - /// @param value the int value + /// @param value the integer value /// @return a Scalar constructor for the given value - ast::ScalarConstructorExpression* make_expr(int32_t value) { - return create(make_literal(value)); + ast::ScalarConstructorExpression* Expr(i32 value) { + return create(Literal(value)); } /// @param value the unsigned int value /// @return a Scalar constructor for the given value - ast::ScalarConstructorExpression* make_expr(uint32_t value) { - return create(make_literal(value)); + ast::ScalarConstructorExpression* Expr(u32 value) { + return create(Literal(value)); } - /// @param val the boolan value - /// @return a boolean literal with the given value - ast::BoolLiteral* make_literal(bool val) { - return create(bool_type(), val); - } - - /// @param val the float value - /// @return a float literal with the given value - ast::FloatLiteral* make_literal(float val) { - return create(f32(), val); - } - - /// @param val the unsigned int value - /// @return a UintLiteral with the given value - ast::UintLiteral* make_literal(uint32_t val) { - return create(u32(), val); - } - - /// @param val the integer value - /// @return the SintLiteral with the given value - ast::SintLiteral* make_literal(int32_t val) { - return create(i32(), val); - } - - /// Converts `arg` to an `ast::Expression` using `make_expr()`, then appends - /// it to `list`. + /// Converts `arg` to an `ast::Expression` using `Expr()`, then appends it to + /// `list`. /// @param list the list to append too /// @param arg the arg to create template - void append_expr(ast::ExpressionList& list, ARG&& arg) { - list.emplace_back(make_expr(std::forward(arg))); + void Append(ast::ExpressionList& list, ARG&& arg) { + list.emplace_back(Expr(std::forward(arg))); } - /// Converts `arg0` and `args` to `ast::Expression`s using `make_expr()`, + /// Converts `arg0` and `args` to `ast::Expression`s using `Expr()`, /// then appends them to `list`. /// @param list the list to append too /// @param arg0 the first argument /// @param args the rest of the arguments template - void append_expr(ast::ExpressionList& list, ARG0&& arg0, ARGS&&... args) { - append_expr(list, std::forward(arg0)); - append_expr(list, std::forward(args)...); + void Append(ast::ExpressionList& list, ARG0&& arg0, ARGS&&... args) { + Append(list, std::forward(arg0)); + Append(list, std::forward(args)...); + } + + /// @param args the list of expressions + /// @return the list of expressions converted to `ast::Expression`s using + /// `Expr()`, + template + ast::ExpressionList ExprList(ARGS&&... args) { + ast::ExpressionList list; + list.reserve(sizeof...(args)); + Append(list, std::forward(args)...); + return list; + } + + /// @param val the boolan value + /// @return a boolean literal with the given value + ast::BoolLiteral* Literal(bool val) { + return create(ty.bool_, val); + } + + /// @param val the float value + /// @return a float literal with the given value + ast::FloatLiteral* Literal(f32 val) { + return create(ty.f32, val); + } + + /// @param val the unsigned int value + /// @return a UintLiteral with the given value + ast::UintLiteral* Literal(u32 val) { + return create(ty.u32, val); + } + + /// @param val the integer value + /// @return the SintLiteral with the given value + ast::SintLiteral* Literal(i32 val) { + return create(ty.i32, val); } - /// @param ty the type /// @param args the arguments for the type constructor /// @return an `ast::TypeConstructorExpression` of type `ty`, with the values - /// of `args` converted to `ast::Expression`s using `make_expr()` - template - ast::TypeConstructorExpression* construct(ast::type::Type* ty, - ARGS&&... args) { - ast::ExpressionList vals; - append_expr(vals, std::forward(args)...); - return create(ty, std::move(vals)); + /// of `args` converted to `ast::Expression`s using `Expr()` + template + ast::TypeConstructorExpression* Construct(ARGS&&... args) { + return create( + ty.Of(), ExprList(std::forward(args)...)); + } + + /// @param x the first component of the vector + /// @param y the second component of the vector + /// @return an `ast::TypeConstructorExpression` of a 2-element vector of type + /// `T`, constructed with the values `x` and `y`. + template + ast::TypeConstructorExpression* vec2(T&& x, T&& y) { + return create( + ty.vec2(), ExprList(std::move(x), std::move(y))); + } + + /// @param x the first component of the vector + /// @param y the second component of the vector + /// @param z the third component of the vector + /// @return an `ast::TypeConstructorExpression` of a 3-element vector of type + /// `T`, constructed with the values `x`, `y` and `z`. + template + ast::TypeConstructorExpression* vec3(T&& x, T&& y, T&& z) { + return create( + ty.vec3(), ExprList(std::move(x), std::move(y), std::move(z))); + } + + /// @param x the first component of the vector + /// @param y the second component of the vector + /// @param z the third component of the vector + /// @param w the fourth component of the vector + /// @return an `ast::TypeConstructorExpression` of a 4-element vector of type + /// `T`, constructed with the values `x`, `y`, `z` and `w`. + template + ast::TypeConstructorExpression* vec4(T&& x, T&& y, T&& z, T&& w) { + return create( + ty.vec4(), + ExprList(std::move(x), std::move(y), std::move(z), std::move(w))); } /// @param name the variable name /// @param storage the variable storage class /// @param type the variable type /// @returns a `ast::Variable` with the given name, storage and type - virtual ast::Variable* make_var(const std::string& name, - ast::StorageClass storage, - ast::type::Type* type); + ast::Variable* Var(const std::string& name, + ast::StorageClass storage, + ast::type::Type* type); /// @param func the function name /// @param args the function call arguments /// @returns a `ast::CallExpression` to the function `func`, with the - /// arguments of `args` converted to `ast::Expression`s using `make_expr()`. + /// arguments of `args` converted to `ast::Expression`s using `Expr()`. template - ast::CallExpression call_expr(const std::string& func, ARGS&&... args) { - ast::ExpressionList params; - append_expr(params, std::forward(args)...); - return ast::CallExpression{make_expr(func), std::move(params)}; + ast::CallExpression Call(const std::string& func, ARGS&&... args) { + return ast::CallExpression{Expr(func), + ExprList(std::forward(args)...)}; } /// Creates a new `ast::Node` owned by the Context. When the Context is @@ -219,13 +276,76 @@ class Builder { /// @returns the node pointer template T* create(ARGS&&... args) { - return ctx_->create(std::forward(args)...); + return ctx->create(std::forward(args)...); } - private: - tint::Context* ctx_ = nullptr; + /// The builder context + tint::Context* const ctx; + /// The builder types + const TypesBuilder ty; + + protected: + /// Called whenever a new variable is built with `Var()`. + virtual void OnVariableBuilt(ast::Variable*) {} }; +template +ast::type::Type* TypesBuilder::Of() const { + return CToAST::get(this); +} + +template +ast::type::Type* TypesBuilder::vec2() const { + return tm_->Get(Of(), 2); +} +template +ast::type::Type* TypesBuilder::vec3() const { + return tm_->Get(Of(), 3); +} +template +ast::type::Type* TypesBuilder::vec4() const { + return tm_->Get(Of(), 4); +} +template +ast::type::Type* TypesBuilder::mat3x3() const { + return tm_->Get(Of(), 3, 3); +} +template +ast::type::Type* TypesBuilder::arr() const { + return tm_->Get(Of()); +} + +/// BuilderWithContext is a `Builder` that constructs and owns its `Context`. +class BuilderWithContext : public Builder { + public: + BuilderWithContext(); + ~BuilderWithContext() override; +}; + +//! @cond Doxygen_Suppress +// Various template specializations for TypesBuilder::CToAST. +template <> +struct TypesBuilder::CToAST { + static ast::type::Type* get(const TypesBuilder* t) { return t->i32; } +}; +template <> +struct TypesBuilder::CToAST { + static ast::type::Type* get(const TypesBuilder* t) { return t->u32; } +}; +template <> +struct TypesBuilder::CToAST { + static ast::type::Type* get(const TypesBuilder* t) { return t->f32; } +}; +template <> +struct TypesBuilder::CToAST { + static ast::type::Type* get(const TypesBuilder* t) { return t->bool_; } +}; +template <> +struct TypesBuilder::CToAST { + static ast::type::Type* get(const TypesBuilder* t) { return t->void_; } +}; +//! @endcond + } // namespace ast } // namespace tint diff --git a/src/type_manager.h b/src/type_manager.h index 2c82d76d40..f7f5601126 100644 --- a/src/type_manager.h +++ b/src/type_manager.h @@ -18,6 +18,7 @@ #include #include #include +#include #include "src/ast/type/type.h" @@ -37,6 +38,15 @@ class TypeManager { /// @return the pointer to the registered type ast::type::Type* Get(std::unique_ptr type); + /// Get the given type `T` from the type manager + /// @param args the arguments to pass to the type constructor + /// @return the pointer to the registered type + template + T* Get(ARGS&&... args) { + auto ty = Get(std::make_unique(std::forward(args)...)); + return static_cast(ty); + } + /// Returns the type map /// @returns the mapping from name string to type. const std::unordered_map>& diff --git a/src/writer/spirv/builder_intrinsic_test.cc b/src/writer/spirv/builder_intrinsic_test.cc index 695bd85a45..631e604943 100644 --- a/src/writer/spirv/builder_intrinsic_test.cc +++ b/src/writer/spirv/builder_intrinsic_test.cc @@ -45,29 +45,22 @@ #include "src/type_determiner.h" #include "src/writer/spirv/builder.h" #include "src/writer/spirv/spv_dump.h" -#include "src/writer/spirv/test_helper.h" namespace tint { namespace writer { namespace spirv { namespace { -class IntrinsicBuilderTest : public ast::Builder, public testing::Test { - public: - IntrinsicBuilderTest() { set_context(&ctx); } - - ast::Variable* make_var(const std::string& name, - ast::StorageClass storage, - ast::type::Type* type) override { - auto* var = ast::Builder::make_var(name, storage, type); +class IntrinsicBuilderTest : public ast::BuilderWithContext, + public testing::Test { + protected: + void OnVariableBuilt(ast::Variable* var) override { td.RegisterVariableForTesting(var); - return var; } - Context ctx; ast::Module mod; - TypeDeterminer td{&ctx, &mod}; - spirv::Builder b{&ctx, &mod}; + TypeDeterminer td{ctx, &mod}; + spirv::Builder b{ctx, &mod}; }; template @@ -87,8 +80,8 @@ using IntrinsicBoolTest = IntrinsicBuilderTestWithParam; TEST_P(IntrinsicBoolTest, Call_Bool) { auto param = GetParam(); - auto* var = make_var("v", ast::StorageClass::kPrivate, vec(bool_type(), 3)); - auto expr = call_expr(param.name, "v"); + auto* var = Var("v", ast::StorageClass::kPrivate, ty.vec3()); + auto expr = Call(param.name, "v"); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); @@ -116,8 +109,8 @@ using IntrinsicFloatTest = IntrinsicBuilderTestWithParam; TEST_P(IntrinsicFloatTest, Call_Float_Scalar) { auto param = GetParam(); - auto* var = make_var("v", ast::StorageClass::kPrivate, f32()); - auto expr = call_expr(param.name, "v"); + auto* var = Var("v", ast::StorageClass::kPrivate, ty.f32); + auto expr = Call(param.name, "v"); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); @@ -140,8 +133,8 @@ TEST_P(IntrinsicFloatTest, Call_Float_Scalar) { TEST_P(IntrinsicFloatTest, Call_Float_Vector) { auto param = GetParam(); - auto* var = make_var("v", ast::StorageClass::kPrivate, vec(f32(), 3)); - auto expr = call_expr(param.name, "v"); + auto* var = Var("v", ast::StorageClass::kPrivate, ty.vec3()); + auto expr = Call(param.name, "v"); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); @@ -171,8 +164,8 @@ using IntrinsicIntTest = IntrinsicBuilderTestWithParam; TEST_P(IntrinsicIntTest, Call_SInt_Scalar) { auto param = GetParam(); - auto* var = make_var("v", ast::StorageClass::kPrivate, i32()); - auto expr = call_expr(param.name, "v"); + auto* var = Var("v", ast::StorageClass::kPrivate, ty.i32); + auto expr = Call(param.name, "v"); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); @@ -194,8 +187,8 @@ TEST_P(IntrinsicIntTest, Call_SInt_Scalar) { TEST_P(IntrinsicIntTest, Call_SInt_Vector) { auto param = GetParam(); - auto* var = make_var("v", ast::StorageClass::kPrivate, vec(i32(), 3)); - auto expr = call_expr(param.name, "v"); + auto* var = Var("v", ast::StorageClass::kPrivate, ty.vec3()); + auto expr = Call(param.name, "v"); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); @@ -218,8 +211,8 @@ TEST_P(IntrinsicIntTest, Call_SInt_Vector) { TEST_P(IntrinsicIntTest, Call_UInt_Scalar) { auto param = GetParam(); - auto* var = make_var("v", ast::StorageClass::kPrivate, u32()); - auto expr = call_expr(param.name, "v"); + auto* var = Var("v", ast::StorageClass::kPrivate, ty.u32); + auto expr = Call(param.name, "v"); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); @@ -241,8 +234,8 @@ TEST_P(IntrinsicIntTest, Call_UInt_Scalar) { TEST_P(IntrinsicIntTest, Call_UInt_Vector) { auto param = GetParam(); - auto* var = make_var("v", ast::StorageClass::kPrivate, vec(u32(), 3)); - auto expr = call_expr(param.name, "v"); + auto* var = Var("v", ast::StorageClass::kPrivate, ty.vec3()); + auto expr = Call(param.name, "v"); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); @@ -268,8 +261,8 @@ INSTANTIATE_TEST_SUITE_P( IntrinsicData{"reverseBits", "OpBitReverse"})); TEST_F(IntrinsicBuilderTest, Call_Dot) { - auto* var = make_var("v", ast::StorageClass::kPrivate, vec(f32(), 3)); - auto expr = call_expr("dot", "v", "v"); + auto* var = Var("v", ast::StorageClass::kPrivate, ty.vec3()); + auto expr = Call("dot", "v", "v"); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); @@ -294,8 +287,8 @@ using IntrinsicDeriveTest = IntrinsicBuilderTestWithParam; TEST_P(IntrinsicDeriveTest, Call_Derivative_Scalar) { auto param = GetParam(); - auto* var = make_var("v", ast::StorageClass::kPrivate, f32()); - auto expr = call_expr(param.name, "v"); + auto* var = Var("v", ast::StorageClass::kPrivate, ty.f32); + auto expr = Call(param.name, "v"); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); @@ -317,8 +310,8 @@ TEST_P(IntrinsicDeriveTest, Call_Derivative_Scalar) { TEST_P(IntrinsicDeriveTest, Call_Derivative_Vector) { auto param = GetParam(); - auto* var = make_var("v", ast::StorageClass::kPrivate, vec(f32(), 3)); - auto expr = call_expr(param.name, "v"); + auto* var = Var("v", ast::StorageClass::kPrivate, ty.vec3()); + auto expr = Call(param.name, "v"); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); @@ -358,10 +351,10 @@ INSTANTIATE_TEST_SUITE_P( IntrinsicData{"fwidthCoarse", "OpFwidthCoarse"})); TEST_F(IntrinsicBuilderTest, Call_OuterProduct) { - auto* v2 = make_var("v2", ast::StorageClass::kPrivate, vec(f32(), 2)); - auto* v3 = make_var("v3", ast::StorageClass::kPrivate, vec(f32(), 3)); + auto* v2 = Var("v2", ast::StorageClass::kPrivate, ty.vec2()); + auto* v3 = Var("v3", ast::StorageClass::kPrivate, ty.vec3()); - auto expr = call_expr("outerProduct", "v2", "v3"); + auto expr = Call("outerProduct", "v2", "v3"); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); @@ -390,10 +383,9 @@ TEST_F(IntrinsicBuilderTest, Call_OuterProduct) { } TEST_F(IntrinsicBuilderTest, Call_Select) { - auto* v3 = make_var("v3", ast::StorageClass::kPrivate, vec(f32(), 3)); - auto* bool_v3 = - make_var("bool_v3", ast::StorageClass::kPrivate, vec(bool_type(), 3)); - auto expr = call_expr("select", "v3", "v3", "bool_v3"); + auto* v3 = Var("v3", ast::StorageClass::kPrivate, ty.vec3()); + auto* bool_v3 = Var("bool_v3", ast::StorageClass::kPrivate, ty.vec3()); + auto expr = Call("select", "v3", "v3", "bool_v3"); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); @@ -431,10 +423,10 @@ TEST_F(IntrinsicBuilderTest, Call_TextureLoad_Storage_RO_1d) { b.push_function(Function{}); - auto* tex = make_var("texture", ast::StorageClass::kNone, &s); + auto* tex = Var("texture", ast::StorageClass::kNone, &s); ASSERT_TRUE(b.GenerateGlobalVariable(tex)) << b.error(); - auto expr = call_expr("textureLoad", "texture", 1.0f, 2); + auto expr = Call("textureLoad", "texture", 1.0f, 2); EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); EXPECT_EQ(b.GenerateExpression(&expr), 5u) << b.error(); @@ -465,11 +457,10 @@ TEST_F(IntrinsicBuilderTest, Call_TextureLoad_Storage_RO_2d) { b.push_function(Function{}); - auto* tex = make_var("texture", ast::StorageClass::kNone, &s); + auto* tex = Var("texture", ast::StorageClass::kNone, &s); ASSERT_TRUE(b.GenerateGlobalVariable(tex)) << b.error(); - auto expr = call_expr("textureLoad", "texture", - construct(vec(f32(), 2), 1.0f, 2.0f), 2); + auto expr = Call("textureLoad", "texture", vec2(1.0f, 2.0f), 2); EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); EXPECT_EQ(b.GenerateExpression(&expr), 5u) << b.error(); @@ -495,14 +486,14 @@ TEST_F(IntrinsicBuilderTest, Call_TextureLoad_Storage_RO_2d) { } TEST_F(IntrinsicBuilderTest, Call_TextureLoad_Sampled_1d) { - ast::type::SampledTextureType s(ast::type::TextureDimension::k1d, f32()); + ast::type::SampledTextureType s(ast::type::TextureDimension::k1d, ty.f32); b.push_function(Function{}); - auto* tex = make_var("texture", ast::StorageClass::kNone, &s); + auto* tex = Var("texture", ast::StorageClass::kNone, &s); ASSERT_TRUE(b.GenerateGlobalVariable(tex)) << b.error(); - auto expr = call_expr("textureLoad", "texture", 1.0f, 2); + auto expr = Call("textureLoad", "texture", 1.0f, 2); EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); EXPECT_EQ(b.GenerateExpression(&expr), 5u) << b.error(); @@ -525,15 +516,14 @@ TEST_F(IntrinsicBuilderTest, Call_TextureLoad_Sampled_1d) { } TEST_F(IntrinsicBuilderTest, Call_TextureLoad_Sampled_2d) { - ast::type::SampledTextureType s(ast::type::TextureDimension::k2d, f32()); + ast::type::SampledTextureType s(ast::type::TextureDimension::k2d, ty.f32); b.push_function(Function{}); - auto* tex = make_var("texture", ast::StorageClass::kNone, &s); + auto* tex = Var("texture", ast::StorageClass::kNone, &s); ASSERT_TRUE(b.GenerateGlobalVariable(tex)) << b.error(); - auto expr = call_expr("textureLoad", "texture", - construct(vec(f32(), 2), 1.0f, 2.0f), 2); + auto expr = Call("textureLoad", "texture", vec2(1.0f, 2.0f), 2); EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); EXPECT_EQ(b.GenerateExpression(&expr), 5u) << b.error(); @@ -559,15 +549,15 @@ TEST_F(IntrinsicBuilderTest, Call_TextureLoad_Sampled_2d) { } TEST_F(IntrinsicBuilderTest, Call_TextureLoad_Multisampled_2d) { - ast::type::MultisampledTextureType s(ast::type::TextureDimension::k2d, f32()); + ast::type::MultisampledTextureType s(ast::type::TextureDimension::k2d, + ty.f32); b.push_function(Function{}); - auto* tex = make_var("texture", ast::StorageClass::kNone, &s); + auto* tex = Var("texture", ast::StorageClass::kNone, &s); ASSERT_TRUE(b.GenerateGlobalVariable(tex)) << b.error(); - auto expr = call_expr("textureLoad", "texture", - construct(vec(f32(), 2), 1.0f, 2.0f), 2); + auto expr = Call("textureLoad", "texture", vec2(1.0f, 2.0f), 2); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); EXPECT_EQ(b.GenerateExpression(&expr), 5u) << b.error(); @@ -598,13 +588,13 @@ TEST_F(IntrinsicBuilderTest, Call_TextureSample_1d) { b.push_function(Function{}); - auto* tex = make_var("texture", ast::StorageClass::kNone, &t); + auto* tex = Var("texture", ast::StorageClass::kNone, &t); ASSERT_TRUE(b.GenerateGlobalVariable(tex)) << b.error(); - auto* sampler = make_var("sampler", ast::StorageClass::kNone, &s); + auto* sampler = Var("sampler", ast::StorageClass::kNone, &s); ASSERT_TRUE(b.GenerateGlobalVariable(sampler)) << b.error(); - auto expr = call_expr("textureSample", "texture", "sampler", 1.0f); + auto expr = Call("textureSample", "texture", "sampler", 1.0f); EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); EXPECT_EQ(b.GenerateExpression(&expr), 7u) << b.error(); @@ -635,14 +625,14 @@ TEST_F(IntrinsicBuilderTest, Call_TextureSample_2d) { b.push_function(Function{}); - auto* tex = make_var("texture", ast::StorageClass::kNone, &t); + auto* tex = Var("texture", ast::StorageClass::kNone, &t); ASSERT_TRUE(b.GenerateGlobalVariable(tex)) << b.error(); - auto* sampler = make_var("sampler", ast::StorageClass::kNone, &s); + auto* sampler = Var("sampler", ast::StorageClass::kNone, &s); ASSERT_TRUE(b.GenerateGlobalVariable(sampler)) << b.error(); - auto expr = call_expr("textureSample", "texture", "sampler", - construct(vec(f32(), 2), 1.0f, 2.0f)); + auto expr = + Call("textureSample", "texture", "sampler", vec2(1.0f, 2.0f)); EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); EXPECT_EQ(b.GenerateExpression(&expr), 7u) << b.error(); @@ -672,17 +662,17 @@ TEST_F(IntrinsicBuilderTest, Call_TextureSample_2d) { TEST_F(IntrinsicBuilderTest, Call_TextureSampleLevel_1d) { ast::type::SamplerType s(ast::type::SamplerKind::kSampler); - ast::type::SampledTextureType t(ast::type::TextureDimension::k1d, f32()); + ast::type::SampledTextureType t(ast::type::TextureDimension::k1d, ty.f32); b.push_function(Function{}); - auto* tex = make_var("texture", ast::StorageClass::kNone, &t); + auto* tex = Var("texture", ast::StorageClass::kNone, &t); ASSERT_TRUE(b.GenerateGlobalVariable(tex)) << b.error(); - auto* sampler = make_var("sampler", ast::StorageClass::kNone, &s); + auto* sampler = Var("sampler", ast::StorageClass::kNone, &s); ASSERT_TRUE(b.GenerateGlobalVariable(sampler)) << b.error(); - auto expr = call_expr("textureSampleLevel", "texture", "sampler", 1.0f, 2.0f); + auto expr = Call("textureSampleLevel", "texture", "sampler", 1.0f, 2.0f); EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); EXPECT_EQ(b.GenerateExpression(&expr), 8u) << b.error(); @@ -711,18 +701,18 @@ TEST_F(IntrinsicBuilderTest, Call_TextureSampleLevel_1d) { TEST_F(IntrinsicBuilderTest, Call_TextureSampleLevel_2d) { ast::type::SamplerType s(ast::type::SamplerKind::kSampler); - ast::type::SampledTextureType t(ast::type::TextureDimension::k2d, f32()); + ast::type::SampledTextureType t(ast::type::TextureDimension::k2d, ty.f32); b.push_function(Function{}); - auto* tex = make_var("texture", ast::StorageClass::kNone, &t); + auto* tex = Var("texture", ast::StorageClass::kNone, &t); ASSERT_TRUE(b.GenerateGlobalVariable(tex)) << b.error(); - auto* sampler = make_var("sampler", ast::StorageClass::kNone, &s); + auto* sampler = Var("sampler", ast::StorageClass::kNone, &s); ASSERT_TRUE(b.GenerateGlobalVariable(sampler)) << b.error(); - auto expr = call_expr("textureSampleLevel", "texture", "sampler", - construct(vec(f32(), 2), 1.0f, 2.0f), 2.0f); + auto expr = Call("textureSampleLevel", "texture", "sampler", + vec2(1.0f, 2.0f), 2.0f); EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); EXPECT_EQ(b.GenerateExpression(&expr), 8u) << b.error(); @@ -753,17 +743,17 @@ TEST_F(IntrinsicBuilderTest, Call_TextureSampleLevel_2d) { TEST_F(IntrinsicBuilderTest, Call_TextureSampleBias_1d) { ast::type::SamplerType s(ast::type::SamplerKind::kSampler); - ast::type::SampledTextureType t(ast::type::TextureDimension::k1d, f32()); + ast::type::SampledTextureType t(ast::type::TextureDimension::k1d, ty.f32); b.push_function(Function{}); - auto* tex = make_var("texture", ast::StorageClass::kNone, &t); + auto* tex = Var("texture", ast::StorageClass::kNone, &t); ASSERT_TRUE(b.GenerateGlobalVariable(tex)) << b.error(); - auto* sampler = make_var("sampler", ast::StorageClass::kNone, &s); + auto* sampler = Var("sampler", ast::StorageClass::kNone, &s); ASSERT_TRUE(b.GenerateGlobalVariable(sampler)) << b.error(); - auto expr = call_expr("textureSampleBias", "texture", "sampler", 1.0f, 2.0f); + auto expr = Call("textureSampleBias", "texture", "sampler", 1.0f, 2.0f); EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); EXPECT_EQ(b.GenerateExpression(&expr), 8u) << b.error(); @@ -792,18 +782,18 @@ TEST_F(IntrinsicBuilderTest, Call_TextureSampleBias_1d) { TEST_F(IntrinsicBuilderTest, Call_TextureSampleBias_2d) { ast::type::SamplerType s(ast::type::SamplerKind::kSampler); - ast::type::SampledTextureType t(ast::type::TextureDimension::k1d, f32()); + ast::type::SampledTextureType t(ast::type::TextureDimension::k1d, ty.f32); b.push_function(Function{}); - auto* tex = make_var("texture", ast::StorageClass::kNone, &t); + auto* tex = Var("texture", ast::StorageClass::kNone, &t); ASSERT_TRUE(b.GenerateGlobalVariable(tex)) << b.error(); - auto* sampler = make_var("sampler", ast::StorageClass::kNone, &s); + auto* sampler = Var("sampler", ast::StorageClass::kNone, &s); ASSERT_TRUE(b.GenerateGlobalVariable(sampler)) << b.error(); - auto expr = call_expr("textureSampleBias", "texture", "sampler", - construct(vec(f32(), 2), 1.0f, 2.0f), 2.0f); + auto expr = Call("textureSampleBias", "texture", "sampler", + vec2(1.0f, 2.0f), 2.0f); EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); EXPECT_EQ(b.GenerateExpression(&expr), 8u) << b.error(); @@ -838,14 +828,14 @@ TEST_F(IntrinsicBuilderTest, Call_TextureSampleCompare) { b.push_function(Function{}); - auto* tex = make_var("texture", ast::StorageClass::kNone, &t); + auto* tex = Var("texture", ast::StorageClass::kNone, &t); ASSERT_TRUE(b.GenerateGlobalVariable(tex)) << b.error(); - auto* sampler = make_var("sampler", ast::StorageClass::kNone, &s); + auto* sampler = Var("sampler", ast::StorageClass::kNone, &s); ASSERT_TRUE(b.GenerateGlobalVariable(sampler)) << b.error(); - auto expr = call_expr("textureSampleCompare", "texture", "sampler", - construct(vec(f32(), 2), 1.0f, 2.0f), 2.0f); + auto expr = Call("textureSampleCompare", "texture", "sampler", + vec2(1.0f, 2.0f), 2.0f); EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error(); EXPECT_EQ(b.GenerateExpression(&expr), 8u) << b.error(); @@ -875,24 +865,22 @@ TEST_F(IntrinsicBuilderTest, Call_TextureSampleCompare) { // This tests that we do not push OpTypeSampledImage and float_0 type twice. TEST_F(IntrinsicBuilderTest, Call_TextureSampleCompare_Twice) { - auto* vec2 = vec(f32(), 2); - ast::type::SamplerType s(ast::type::SamplerKind::kComparisonSampler); ast::type::DepthTextureType t(ast::type::TextureDimension::k2d); b.push_function(Function{}); - auto* tex = make_var("texture", ast::StorageClass::kNone, &t); + auto* tex = Var("texture", ast::StorageClass::kNone, &t); ASSERT_TRUE(b.GenerateGlobalVariable(tex)) << b.error(); - auto* sampler = make_var("sampler", ast::StorageClass::kNone, &s); + auto* sampler = Var("sampler", ast::StorageClass::kNone, &s); ASSERT_TRUE(b.GenerateGlobalVariable(sampler)) << b.error(); - auto expr1 = call_expr("textureSampleCompare", "texture", "sampler", - construct(vec2, 1.0f, 2.0f), 2.0f); + auto expr1 = Call("textureSampleCompare", "texture", "sampler", + vec2(1.0f, 2.0f), 2.0f); - auto expr2 = call_expr("textureSampleCompare", "texture", "sampler", - construct(vec2, 1.0f, 2.0f), 2.0f); + auto expr2 = Call("textureSampleCompare", "texture", "sampler", + vec2(1.0f, 2.0f), 2.0f); EXPECT_TRUE(td.DetermineResultType(&expr1)) << td.error(); EXPECT_TRUE(td.DetermineResultType(&expr2)) << td.error(); @@ -928,12 +916,12 @@ TEST_F(IntrinsicBuilderTest, Call_TextureSampleCompare_Twice) { } TEST_F(IntrinsicBuilderTest, Call_GLSLMethod_WithLoad) { - auto* var = make_var("ident", ast::StorageClass::kPrivate, f32()); - auto expr = call_expr("round", "ident"); + auto* var = Var("ident", ast::StorageClass::kPrivate, ty.f32); + auto expr = Call("round", "ident"); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateGlobalVariable(var)) << b.error(); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -961,10 +949,10 @@ using Intrinsic_Builtin_SingleParam_Float_Test = TEST_P(Intrinsic_Builtin_SingleParam_Float_Test, Call_Scalar) { auto param = GetParam(); - auto expr = call_expr(param.name, 1.0f); + auto expr = Call(param.name, 1.0f); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -986,10 +974,10 @@ OpFunctionEnd TEST_P(Intrinsic_Builtin_SingleParam_Float_Test, Call_Vector) { auto param = GetParam(); - auto expr = call_expr(param.name, construct(vec(f32(), 2), 1.0f, 1.0f)); + auto expr = Call(param.name, vec2(1.0f, 1.0f)); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1036,11 +1024,11 @@ INSTANTIATE_TEST_SUITE_P(IntrinsicBuilderTest, IntrinsicData{"trunc", "Trunc"})); TEST_F(IntrinsicBuilderTest, Call_Length_Scalar) { - auto expr = call_expr("length", 1.0f); + auto expr = Call("length", 1.0f); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1059,10 +1047,10 @@ OpFunctionEnd } TEST_F(IntrinsicBuilderTest, Call_Length_Vector) { - auto expr = call_expr("length", construct(vec(f32(), 2), 1.0f, 1.0f)); + auto expr = Call("length", vec2(1.0f, 1.0f)); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1083,10 +1071,10 @@ OpFunctionEnd } TEST_F(IntrinsicBuilderTest, Call_Normalize) { - auto expr = call_expr("normalize", construct(vec(f32(), 2), 1.0f, 1.0f)); + auto expr = Call("normalize", vec2(1.0f, 1.0f)); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1111,10 +1099,11 @@ using Intrinsic_Builtin_DualParam_Float_Test = TEST_P(Intrinsic_Builtin_DualParam_Float_Test, Call_Scalar) { auto param = GetParam(); - auto expr = call_expr(param.name, 1.0f, 1.0f); + auto expr = Call(param.name, 1.0f, 1.0f); + ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1136,13 +1125,11 @@ OpFunctionEnd TEST_P(Intrinsic_Builtin_DualParam_Float_Test, Call_Vector) { auto param = GetParam(); - auto* vec2 = vec(f32(), 2); - auto expr = call_expr(param.name, construct(vec2, 1.0f, 1.0f), - construct(vec2, 1.0f, 1.0f)); + auto expr = Call(param.name, vec2(1.0f, 1.0f), vec2(1.0f, 1.0f)); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1172,10 +1159,11 @@ INSTANTIATE_TEST_SUITE_P(IntrinsicBuilderTest, IntrinsicData{"step", "Step"})); TEST_F(IntrinsicBuilderTest, Call_Distance_Scalar) { - auto expr = call_expr("distance", 1.0f, 1.0f); + auto expr = Call("distance", 1.0f, 1.0f); + ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1194,13 +1182,11 @@ OpFunctionEnd } TEST_F(IntrinsicBuilderTest, Call_Distance_Vector) { - auto* vec3 = vec(f32(), 2); - auto expr = call_expr("distance", construct(vec3, 1.0f, 1.0f), - construct(vec3, 1.0f, 1.0f)); + auto expr = Call("distance", vec2(1.0f, 1.0f), vec2(1.0f, 1.0f)); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1221,13 +1207,12 @@ OpFunctionEnd } TEST_F(IntrinsicBuilderTest, Call_Cross) { - auto* vec3 = vec(f32(), 3); - auto expr = call_expr("cross", construct(vec3, 1.0f, 1.0f, 1.0f), - construct(vec3, 1.0f, 1.0f, 1.0f)); + auto expr = + Call("cross", vec3(1.0f, 1.0f, 1.0f), vec3(1.0f, 1.0f, 1.0f)); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1252,10 +1237,10 @@ using Intrinsic_Builtin_ThreeParam_Float_Test = TEST_P(Intrinsic_Builtin_ThreeParam_Float_Test, Call_Scalar) { auto param = GetParam(); - auto expr = call_expr(param.name, 1.0f, 1.0f, 1.0f); + auto expr = Call(param.name, 1.0f, 1.0f, 1.0f); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1277,14 +1262,12 @@ OpFunctionEnd TEST_P(Intrinsic_Builtin_ThreeParam_Float_Test, Call_Vector) { auto param = GetParam(); - auto* vec3 = vec(f32(), 2); - auto expr = - call_expr(param.name, construct(vec3, 1.0f, 1.0f), - construct(vec3, 1.0f, 1.0f), construct(vec3, 1.0f, 1.0f)); + auto expr = Call(param.name, vec2(1.0f, 1.0f), vec2(1.0f, 1.0f), + vec2(1.0f, 1.0f)); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1319,10 +1302,10 @@ using Intrinsic_Builtin_SingleParam_Sint_Test = TEST_P(Intrinsic_Builtin_SingleParam_Sint_Test, Call_Scalar) { auto param = GetParam(); - auto expr = call_expr(param.name, 1); + auto expr = Call(param.name, 1); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1344,10 +1327,10 @@ OpFunctionEnd TEST_P(Intrinsic_Builtin_SingleParam_Sint_Test, Call_Vector) { auto param = GetParam(); - auto expr = call_expr(param.name, construct(vec(i32(), 2), 1, 1)); + auto expr = Call(param.name, vec2(1, 1)); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1376,10 +1359,10 @@ using Intrinsic_Builtin_SingleParam_Uint_Test = TEST_P(Intrinsic_Builtin_SingleParam_Uint_Test, Call_Scalar) { auto param = GetParam(); - auto expr = call_expr(param.name, 1u); + auto expr = Call(param.name, 1u); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1401,10 +1384,10 @@ OpFunctionEnd TEST_P(Intrinsic_Builtin_SingleParam_Uint_Test, Call_Vector) { auto param = GetParam(); - auto expr = call_expr(param.name, construct(vec(u32(), 2), 1u, 1u)); + auto expr = Call(param.name, vec2(1u, 1u)); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1433,10 +1416,10 @@ using Intrinsic_Builtin_DualParam_SInt_Test = TEST_P(Intrinsic_Builtin_DualParam_SInt_Test, Call_Scalar) { auto param = GetParam(); - auto expr = call_expr(param.name, 1, 1); + auto expr = Call(param.name, 1, 1); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1458,12 +1441,10 @@ OpFunctionEnd TEST_P(Intrinsic_Builtin_DualParam_SInt_Test, Call_Vector) { auto param = GetParam(); - auto* vec2 = vec(i32(), 2); - auto expr = - call_expr(param.name, construct(vec2, 1, 1), construct(vec2, 1, 1)); + auto expr = Call(param.name, vec2(1, 1), vec2(1, 1)); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1493,10 +1474,10 @@ using Intrinsic_Builtin_DualParam_UInt_Test = TEST_P(Intrinsic_Builtin_DualParam_UInt_Test, Call_Scalar) { auto param = GetParam(); - auto expr = call_expr(param.name, 1u, 1u); + auto expr = Call(param.name, 1u, 1u); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1518,13 +1499,10 @@ OpFunctionEnd TEST_P(Intrinsic_Builtin_DualParam_UInt_Test, Call_Vector) { auto param = GetParam(); - auto* vec2 = vec(u32(), 2); - auto expr = - call_expr(param.name, construct(vec2, 1u, 1u), construct(vec2, 1u, 1u)); - + auto expr = Call(param.name, vec2(1u, 1u), vec2(1u, 1u)); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1554,10 +1532,10 @@ using Intrinsic_Builtin_ThreeParam_Sint_Test = TEST_P(Intrinsic_Builtin_ThreeParam_Sint_Test, Call_Scalar) { auto param = GetParam(); - auto expr = call_expr(param.name, 1, 1, 1); + auto expr = Call(param.name, 1, 1, 1); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1579,13 +1557,12 @@ OpFunctionEnd TEST_P(Intrinsic_Builtin_ThreeParam_Sint_Test, Call_Vector) { auto param = GetParam(); - auto* vec2 = vec(i32(), 2); - auto expr = call_expr(param.name, construct(vec2, 1, 1), - construct(vec2, 1, 1), construct(vec2, 1, 1)); + auto expr = + Call(param.name, vec2(1, 1), vec2(1, 1), vec2(1, 1)); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1614,10 +1591,10 @@ using Intrinsic_Builtin_ThreeParam_Uint_Test = TEST_P(Intrinsic_Builtin_ThreeParam_Uint_Test, Call_Scalar) { auto param = GetParam(); - auto expr = call_expr(param.name, 1u, 1u, 1u); + auto expr = Call(param.name, 1u, 1u, 1u); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1639,13 +1616,12 @@ OpFunctionEnd TEST_P(Intrinsic_Builtin_ThreeParam_Uint_Test, Call_Vector) { auto param = GetParam(); - auto* vec2 = vec(u32(), 2); - auto expr = call_expr(param.name, construct(vec2, 1u, 1u), - construct(vec2, 1u, 1u), construct(vec2, 1u, 1u)); + auto expr = + Call(param.name, vec2(1u, 1u), vec2(1u, 1u), vec2(1u, 1u)); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1670,12 +1646,12 @@ INSTANTIATE_TEST_SUITE_P(IntrinsicBuilderTest, testing::Values(IntrinsicData{"clamp", "UClamp"})); TEST_F(IntrinsicBuilderTest, Call_Determinant) { - auto* var = make_var("var", ast::StorageClass::kPrivate, mat(f32(), 3, 3)); - auto expr = call_expr("determinant", "var"); + auto* var = Var("var", ast::StorageClass::kPrivate, ty.mat3x3()); + auto expr = Call("determinant", "var"); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); @@ -1702,23 +1678,21 @@ OpFunctionEnd } TEST_F(IntrinsicBuilderTest, Call_ArrayLength) { - ast::type::ArrayType ary(f32()); - ast::StructMemberDecorationList decos; ast::StructMemberList members; - members.push_back(create("a", &ary, decos)); + members.push_back(create("a", ty.arr(), decos)); auto* s = create(members); ast::type::StructType s_type("my_struct", s); - auto* var = make_var("b", ast::StorageClass::kPrivate, &s_type); + auto* var = Var("b", ast::StorageClass::kPrivate, &s_type); - auto expr = call_expr("arrayLength", create( - make_expr("b"), make_expr("a"))); + auto expr = Call("arrayLength", + create(Expr("b"), Expr("a"))); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); ASSERT_TRUE(b.GenerateGlobalVariable(var)) << b.error(); @@ -1742,23 +1716,21 @@ TEST_F(IntrinsicBuilderTest, Call_ArrayLength) { } TEST_F(IntrinsicBuilderTest, Call_ArrayLength_OtherMembersInStruct) { - ast::type::ArrayType ary(f32()); - ast::StructMemberDecorationList decos; ast::StructMemberList members; - members.push_back(create("z", f32(), decos)); - members.push_back(create("a", &ary, decos)); + members.push_back(create("z", ty.f32, decos)); + members.push_back(create("a", ty.arr(), decos)); auto* s = create(members); ast::type::StructType s_type("my_struct", s); - auto* var = make_var("b", ast::StorageClass::kPrivate, &s_type); - auto expr = call_expr("arrayLength", create( - make_expr("b"), make_expr("a"))); + auto* var = Var("b", ast::StorageClass::kPrivate, &s_type); + auto expr = Call("arrayLength", + create(Expr("b"), Expr("a"))); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); ASSERT_TRUE(b.GenerateGlobalVariable(var)) << b.error(); @@ -1783,27 +1755,26 @@ TEST_F(IntrinsicBuilderTest, Call_ArrayLength_OtherMembersInStruct) { // TODO(dsinclair): https://bugs.chromium.org/p/tint/issues/detail?id=266 TEST_F(IntrinsicBuilderTest, DISABLED_Call_ArrayLength_Ptr) { - ast::type::ArrayType ary(f32()); - ast::type::PointerType ptr(&ary, ast::StorageClass::kStorageBuffer); + ast::type::PointerType ptr(ty.arr(), ast::StorageClass::kStorageBuffer); ast::StructMemberDecorationList decos; ast::StructMemberList members; - members.push_back(create("z", f32(), decos)); - members.push_back(create("a", &ary, decos)); + members.push_back(create("z", ty.f32, decos)); + members.push_back(create("a", ty.arr(), decos)); auto* s = create(members); ast::type::StructType s_type("my_struct", s); - auto* var = make_var("b", ast::StorageClass::kPrivate, &s_type); + auto* var = Var("b", ast::StorageClass::kPrivate, &s_type); - auto* ptr_var = make_var("ptr_var", ast::StorageClass::kPrivate, &ptr); + auto* ptr_var = Var("ptr_var", ast::StorageClass::kPrivate, &ptr); ptr_var->set_constructor( - create(make_expr("b"), make_expr("a"))); + create(Expr("b"), Expr("a"))); - auto expr = call_expr("arrayLength", "ptr_var"); + auto expr = Call("arrayLength", "ptr_var"); ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error(); - ast::Function func("a_func", {}, void_type(), create()); + ast::Function func("a_func", {}, ty.void_, create()); ASSERT_TRUE(b.GenerateFunction(&func)) << b.error(); ASSERT_TRUE(b.GenerateGlobalVariable(var)) << b.error();