Remove all Source{} smell from tests
Switch all remaining AST stack allocations in tests to using create<T>() which will automatically inject the current Source as the first parameter.
Most remaining uses of Source{} in the codebase are places where we need to fix.
Bug: tint:396
Change-Id: I24655800b50d6ad52e682a7339022972e9b354d9
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/36380
Commit-Queue: Ben Clayton <bclayton@google.com>
Commit-Queue: David Neto <dneto@google.com>
Auto-Submit: Ben Clayton <bclayton@google.com>
Reviewed-by: David Neto <dneto@google.com>
diff --git a/src/reader/wgsl/parser_impl_test_helper.h b/src/reader/wgsl/parser_impl_test_helper.h
index 1c65852..184eddd 100644
--- a/src/reader/wgsl/parser_impl_test_helper.h
+++ b/src/reader/wgsl/parser_impl_test_helper.h
@@ -21,6 +21,7 @@
#include <vector>
#include "gtest/gtest.h"
+#include "src/ast/builder.h"
#include "src/reader/wgsl/parser_impl.h"
namespace tint {
@@ -28,7 +29,7 @@
namespace wgsl {
/// WGSL Parser test class
-class ParserImplTest : public testing::Test {
+class ParserImplTest : public testing::Test, public ast::BuilderWithModule {
public:
/// Constructor
ParserImplTest();
@@ -50,7 +51,8 @@
/// WGSL Parser test class with param
template <typename T>
-class ParserImplTestWithParam : public testing::TestWithParam<T> {
+class ParserImplTestWithParam : public testing::TestWithParam<T>,
+ public ast::BuilderWithModule {
public:
/// Constructor
ParserImplTestWithParam() = default;
diff --git a/src/reader/wgsl/parser_impl_variable_ident_decl_test.cc b/src/reader/wgsl/parser_impl_variable_ident_decl_test.cc
index 5a8c7d3..0e57c1d 100644
--- a/src/reader/wgsl/parser_impl_variable_ident_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_variable_ident_decl_test.cc
@@ -83,23 +83,20 @@
}
TEST_F(ParserImplTest, VariableIdentDecl_ParsesWithAccessDeco_Read) {
- ast::type::I32 i32;
-
auto p = parser("my_var : [[access(read)]] S");
- ast::StructMember mem(Source{}, p->get_module().RegisterSymbol("a"), "a",
- &i32, ast::StructMemberDecorationList{});
+ auto* mem = Member("a", ty.i32, ast::StructMemberDecorationList{});
ast::StructMemberList members;
- members.push_back(&mem);
+ members.push_back(mem);
- ast::StructBlockDecoration block_deco(Source{});
+ auto* block_deco = create<ast::StructBlockDecoration>();
ast::StructDecorationList decos;
- decos.push_back(&block_deco);
+ decos.push_back(block_deco);
- ast::Struct str(Source{}, members, decos);
- ast::type::Struct s(p->get_module().RegisterSymbol("S"), "S", &str);
+ auto* str = create<ast::Struct>(members, decos);
+ auto* s = ty.struct_("S", str);
- p->register_constructed("S", &s);
+ p->register_constructed("S", s);
auto decl = p->expect_variable_ident_decl("test");
ASSERT_FALSE(p->has_error()) << p->error();
@@ -111,23 +108,20 @@
}
TEST_F(ParserImplTest, VariableIdentDecl_ParsesWithAccessDeco_ReadWrite) {
- ast::type::I32 i32;
-
auto p = parser("my_var : [[access(read_write)]] S");
- ast::StructMember mem(Source{}, p->get_module().RegisterSymbol("a"), "a",
- &i32, ast::StructMemberDecorationList{});
+ auto* mem = Member("a", ty.i32, ast::StructMemberDecorationList{});
ast::StructMemberList members;
- members.push_back(&mem);
+ members.push_back(mem);
- ast::StructBlockDecoration block_deco(Source{});
+ auto* block_deco = create<ast::StructBlockDecoration>();
ast::StructDecorationList decos;
- decos.push_back(&block_deco);
+ decos.push_back(block_deco);
- ast::Struct str(Source{}, members, decos);
- ast::type::Struct s(p->get_module().RegisterSymbol("S"), "S", &str);
+ auto* str = create<ast::Struct>(members, decos);
+ auto* s = ty.struct_("S", str);
- p->register_constructed("S", &s);
+ p->register_constructed("S", s);
auto decl = p->expect_variable_ident_decl("test");
ASSERT_FALSE(p->has_error()) << p->error();
@@ -139,23 +133,20 @@
}
TEST_F(ParserImplTest, VariableIdentDecl_MultipleAccessDecoFail) {
- ast::type::I32 i32;
-
auto p = parser("my_var : [[access(read), access(read_write)]] S");
- ast::StructMember mem(Source{}, p->get_module().RegisterSymbol("a"), "a",
- &i32, ast::StructMemberDecorationList{});
+ auto* mem = Member("a", ty.i32, ast::StructMemberDecorationList{});
ast::StructMemberList members;
- members.push_back(&mem);
+ members.push_back(mem);
- ast::StructBlockDecoration block_deco(Source{});
+ auto* block_deco = create<ast::StructBlockDecoration>();
ast::StructDecorationList decos;
- decos.push_back(&block_deco);
+ decos.push_back(block_deco);
- ast::Struct str(Source{}, members, decos);
- ast::type::Struct s(p->get_module().RegisterSymbol("S"), "S", &str);
+ auto* str = create<ast::Struct>(members, decos);
+ auto* s = ty.struct_("S", str);
- p->register_constructed("S", &s);
+ p->register_constructed("S", s);
auto decl = p->expect_variable_ident_decl("test");
ASSERT_TRUE(p->has_error());
@@ -164,23 +155,20 @@
}
TEST_F(ParserImplTest, VariableIdentDecl_MultipleAccessDeco_MultiBlock_Fail) {
- ast::type::I32 i32;
-
auto p = parser("my_var : [[access(read)]][[access(read_write)]] S");
- ast::StructMember mem(Source{}, p->get_module().RegisterSymbol("a"), "a",
- &i32, ast::StructMemberDecorationList{});
+ auto* mem = Member("a", ty.i32, ast::StructMemberDecorationList{});
ast::StructMemberList members;
- members.push_back(&mem);
+ members.push_back(mem);
- ast::StructBlockDecoration block_deco(Source{});
+ auto* block_deco = create<ast::StructBlockDecoration>();
ast::StructDecorationList decos;
- decos.push_back(&block_deco);
+ decos.push_back(block_deco);
- ast::Struct str(Source{}, members, decos);
- ast::type::Struct s(p->get_module().RegisterSymbol("S"), "S", &str);
+ auto* str = create<ast::Struct>(members, decos);
+ auto* s = ty.struct_("S", str);
- p->register_constructed("S", &s);
+ p->register_constructed("S", s);
auto decl = p->expect_variable_ident_decl("test");
ASSERT_TRUE(p->has_error());
@@ -205,23 +193,20 @@
}
TEST_F(ParserImplTest, VariableIdentDecl_NonAccessDecoFail) {
- ast::type::I32 i32;
-
auto p = parser("my_var : [[stride(1)]] S");
- ast::StructMember mem(Source{}, p->get_module().RegisterSymbol("a"), "a",
- &i32, ast::StructMemberDecorationList{});
+ auto* mem = Member("a", ty.i32, ast::StructMemberDecorationList{});
ast::StructMemberList members;
- members.push_back(&mem);
+ members.push_back(mem);
- ast::StructBlockDecoration block_deco(Source{});
+ auto* block_deco = create<ast::StructBlockDecoration>();
ast::StructDecorationList decos;
- decos.push_back(&block_deco);
+ decos.push_back(block_deco);
- ast::Struct str(Source{}, members, decos);
- ast::type::Struct s(p->get_module().RegisterSymbol("S"), "S", &str);
+ auto* str = create<ast::Struct>(members, decos);
+ auto* s = ty.struct_("S", str);
- p->register_constructed("S", &s);
+ p->register_constructed("S", s);
auto decl = p->expect_variable_ident_decl("test");
ASSERT_TRUE(p->has_error());
diff --git a/src/writer/msl/generator_impl_assign_test.cc b/src/writer/msl/generator_impl_assign_test.cc
index 5a723cf..6f7c70f 100644
--- a/src/writer/msl/generator_impl_assign_test.cc
+++ b/src/writer/msl/generator_impl_assign_test.cc
@@ -30,10 +30,10 @@
using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, Emit_Assign) {
- ast::AssignmentStatement assign(Source{}, Expr("lhs"), Expr("rhs"));
+ auto* assign = create<ast::AssignmentStatement>(Expr("lhs"), Expr("rhs"));
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&assign)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(assign)) << gen.error();
EXPECT_EQ(gen.result(), " lhs = rhs;\n");
}
diff --git a/src/writer/msl/generator_impl_binary_test.cc b/src/writer/msl/generator_impl_binary_test.cc
index e85113c..b1b6ed0 100644
--- a/src/writer/msl/generator_impl_binary_test.cc
+++ b/src/writer/msl/generator_impl_binary_test.cc
@@ -38,8 +38,9 @@
TEST_P(MslBinaryTest, Emit) {
auto params = GetParam();
- ast::BinaryExpression expr(Source{}, params.op, Expr("left"), Expr("right"));
- ASSERT_TRUE(gen.EmitExpression(&expr)) << gen.error();
+ auto* expr =
+ create<ast::BinaryExpression>(params.op, Expr("left"), Expr("right"));
+ ASSERT_TRUE(gen.EmitExpression(expr)) << gen.error();
EXPECT_EQ(gen.result(), params.result);
}
INSTANTIATE_TEST_SUITE_P(
diff --git a/src/writer/msl/generator_impl_bitcast_test.cc b/src/writer/msl/generator_impl_bitcast_test.cc
index 04cf30d..de56fd8 100644
--- a/src/writer/msl/generator_impl_bitcast_test.cc
+++ b/src/writer/msl/generator_impl_bitcast_test.cc
@@ -30,8 +30,8 @@
using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, EmitExpression_Bitcast) {
- ast::BitcastExpression bitcast(Source{}, ty.f32, Expr("id"));
- ASSERT_TRUE(gen.EmitExpression(&bitcast)) << gen.error();
+ auto* bitcast = create<ast::BitcastExpression>(ty.f32, Expr("id"));
+ ASSERT_TRUE(gen.EmitExpression(bitcast)) << gen.error();
EXPECT_EQ(gen.result(), "as_type<float>(id)");
}
diff --git a/src/writer/msl/generator_impl_block_test.cc b/src/writer/msl/generator_impl_block_test.cc
index f50bb3e..b355ed2 100644
--- a/src/writer/msl/generator_impl_block_test.cc
+++ b/src/writer/msl/generator_impl_block_test.cc
@@ -28,12 +28,12 @@
using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, Emit_Block) {
- ast::BlockStatement b(Source{}, ast::StatementList{
- create<ast::DiscardStatement>(Source{}),
- });
+ auto* b = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::DiscardStatement>(),
+ });
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&b)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(b)) << gen.error();
EXPECT_EQ(gen.result(), R"( {
discard_fragment();
}
@@ -41,12 +41,12 @@
}
TEST_F(MslGeneratorImplTest, Emit_Block_WithoutNewline) {
- ast::BlockStatement b(Source{}, ast::StatementList{
- create<ast::DiscardStatement>(Source{}),
- });
+ auto* b = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::DiscardStatement>(),
+ });
gen.increment_indent();
- ASSERT_TRUE(gen.EmitBlock(&b)) << gen.error();
+ ASSERT_TRUE(gen.EmitBlock(b)) << gen.error();
EXPECT_EQ(gen.result(), R"({
discard_fragment();
})");
diff --git a/src/writer/msl/generator_impl_break_test.cc b/src/writer/msl/generator_impl_break_test.cc
index 1860910..b0a6410 100644
--- a/src/writer/msl/generator_impl_break_test.cc
+++ b/src/writer/msl/generator_impl_break_test.cc
@@ -29,11 +29,11 @@
using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, Emit_Break) {
- ast::BreakStatement b(Source{});
+ auto* b = create<ast::BreakStatement>();
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&b)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(b)) << gen.error();
EXPECT_EQ(gen.result(), " break;\n");
}
diff --git a/src/writer/msl/generator_impl_call_test.cc b/src/writer/msl/generator_impl_call_test.cc
index 2c96829..3b7c9ed 100644
--- a/src/writer/msl/generator_impl_call_test.cc
+++ b/src/writer/msl/generator_impl_call_test.cc
@@ -57,10 +57,10 @@
ast::StatementList{}, ast::FunctionDecorationList{});
mod->AddFunction(func);
- ast::CallStatement expr(Source{}, call);
+ auto* expr = create<ast::CallStatement>(call);
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&expr)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(expr)) << gen.error();
EXPECT_EQ(gen.result(), " my_func(param1, param2);\n");
}
diff --git a/src/writer/msl/generator_impl_case_test.cc b/src/writer/msl/generator_impl_case_test.cc
index cf868c8..5ab3f25 100644
--- a/src/writer/msl/generator_impl_case_test.cc
+++ b/src/writer/msl/generator_impl_case_test.cc
@@ -35,17 +35,16 @@
TEST_F(MslGeneratorImplTest, Emit_Case) {
ast::type::I32 i32;
- auto* body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{
- create<ast::BreakStatement>(Source{}),
- });
+ auto* body = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::BreakStatement>(),
+ });
ast::CaseSelectorList lit;
- lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
- ast::CaseStatement c(Source{}, lit, body);
+ lit.push_back(create<ast::SintLiteral>(&i32, 5));
+ auto* c = create<ast::CaseStatement>(lit, body);
gen.increment_indent();
- ASSERT_TRUE(gen.EmitCase(&c)) << gen.error();
+ ASSERT_TRUE(gen.EmitCase(c)) << gen.error();
EXPECT_EQ(gen.result(), R"( case 5: {
break;
}
@@ -56,14 +55,13 @@
ast::type::I32 i32;
ast::CaseSelectorList lit;
- lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
- ast::CaseStatement c(
- Source{}, lit,
- create<ast::BlockStatement>(Source{}, ast::StatementList{}));
+ lit.push_back(create<ast::SintLiteral>(&i32, 5));
+ auto* c = create<ast::CaseStatement>(
+ lit, create<ast::BlockStatement>(ast::StatementList{}));
gen.increment_indent();
- ASSERT_TRUE(gen.EmitCase(&c)) << gen.error();
+ ASSERT_TRUE(gen.EmitCase(c)) << gen.error();
EXPECT_EQ(gen.result(), R"( case 5: {
break;
}
@@ -73,17 +71,16 @@
TEST_F(MslGeneratorImplTest, Emit_Case_WithFallthrough) {
ast::type::I32 i32;
- auto* body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{
- create<ast::FallthroughStatement>(Source{}),
- });
+ auto* body = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::FallthroughStatement>(),
+ });
ast::CaseSelectorList lit;
- lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
- ast::CaseStatement c(Source{}, lit, body);
+ lit.push_back(create<ast::SintLiteral>(&i32, 5));
+ auto* c = create<ast::CaseStatement>(lit, body);
gen.increment_indent();
- ASSERT_TRUE(gen.EmitCase(&c)) << gen.error();
+ ASSERT_TRUE(gen.EmitCase(c)) << gen.error();
EXPECT_EQ(gen.result(), R"( case 5: {
/* fallthrough */
}
@@ -93,18 +90,17 @@
TEST_F(MslGeneratorImplTest, Emit_Case_MultipleSelectors) {
ast::type::I32 i32;
- auto* body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{
- create<ast::BreakStatement>(Source{}),
- });
+ auto* body = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::BreakStatement>(),
+ });
ast::CaseSelectorList lit;
- lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 5));
- lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 6));
- ast::CaseStatement c(Source{}, lit, body);
+ lit.push_back(create<ast::SintLiteral>(&i32, 5));
+ lit.push_back(create<ast::SintLiteral>(&i32, 6));
+ auto* c = create<ast::CaseStatement>(lit, body);
gen.increment_indent();
- ASSERT_TRUE(gen.EmitCase(&c)) << gen.error();
+ ASSERT_TRUE(gen.EmitCase(c)) << gen.error();
EXPECT_EQ(gen.result(), R"( case 5:
case 6: {
break;
@@ -113,15 +109,14 @@
}
TEST_F(MslGeneratorImplTest, Emit_Case_Default) {
- auto* body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{
- create<ast::BreakStatement>(Source{}),
- });
- ast::CaseStatement c(Source{}, ast::CaseSelectorList{}, body);
+ auto* body = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::BreakStatement>(),
+ });
+ auto* c = create<ast::CaseStatement>(ast::CaseSelectorList{}, body);
gen.increment_indent();
- ASSERT_TRUE(gen.EmitCase(&c)) << gen.error();
+ ASSERT_TRUE(gen.EmitCase(c)) << gen.error();
EXPECT_EQ(gen.result(), R"( default: {
break;
}
diff --git a/src/writer/msl/generator_impl_cast_test.cc b/src/writer/msl/generator_impl_cast_test.cc
index 9280ed0..73ae2da 100644
--- a/src/writer/msl/generator_impl_cast_test.cc
+++ b/src/writer/msl/generator_impl_cast_test.cc
@@ -34,9 +34,9 @@
ast::ExpressionList params;
params.push_back(Expr("id"));
- ast::TypeConstructorExpression cast(Source{}, ty.f32, params);
+ auto* cast = create<ast::TypeConstructorExpression>(ty.f32, params);
- ASSERT_TRUE(gen.EmitExpression(&cast)) << gen.error();
+ ASSERT_TRUE(gen.EmitExpression(cast)) << gen.error();
EXPECT_EQ(gen.result(), "float(id)");
}
@@ -44,9 +44,9 @@
ast::ExpressionList params;
params.push_back(Expr("id"));
- ast::TypeConstructorExpression cast(Source{}, ty.vec3<f32>(), params);
+ auto* cast = create<ast::TypeConstructorExpression>(ty.vec3<f32>(), params);
- ASSERT_TRUE(gen.EmitExpression(&cast)) << gen.error();
+ ASSERT_TRUE(gen.EmitExpression(cast)) << gen.error();
EXPECT_EQ(gen.result(), "float3(id)");
}
diff --git a/src/writer/msl/generator_impl_constructor_test.cc b/src/writer/msl/generator_impl_constructor_test.cc
index 34cebed..f1a1b1a 100644
--- a/src/writer/msl/generator_impl_constructor_test.cc
+++ b/src/writer/msl/generator_impl_constructor_test.cc
@@ -38,128 +38,113 @@
using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, EmitConstructor_Bool) {
- ast::type::Bool bool_type;
- auto* lit = create<ast::BoolLiteral>(Source{}, &bool_type, false);
- ast::ScalarConstructorExpression expr(Source{}, lit);
+ auto* lit = create<ast::BoolLiteral>(ty.bool_, false);
+ auto* expr = create<ast::ScalarConstructorExpression>(lit);
- ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+ ASSERT_TRUE(gen.EmitConstructor(expr)) << gen.error();
EXPECT_EQ(gen.result(), "false");
}
TEST_F(MslGeneratorImplTest, EmitConstructor_Int) {
- ast::type::I32 i32;
- auto* lit = create<ast::SintLiteral>(Source{}, &i32, -12345);
- ast::ScalarConstructorExpression expr(Source{}, lit);
+ auto* lit = create<ast::SintLiteral>(ty.i32, -12345);
+ auto* expr = create<ast::ScalarConstructorExpression>(lit);
- ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+ ASSERT_TRUE(gen.EmitConstructor(expr)) << gen.error();
EXPECT_EQ(gen.result(), "-12345");
}
TEST_F(MslGeneratorImplTest, EmitConstructor_UInt) {
- ast::type::U32 u32;
- auto* lit = create<ast::UintLiteral>(Source{}, &u32, 56779);
- ast::ScalarConstructorExpression expr(Source{}, lit);
+ auto* lit = create<ast::UintLiteral>(ty.u32, 56779);
+ auto* expr = create<ast::ScalarConstructorExpression>(lit);
- ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+ ASSERT_TRUE(gen.EmitConstructor(expr)) << gen.error();
EXPECT_EQ(gen.result(), "56779u");
}
TEST_F(MslGeneratorImplTest, EmitConstructor_Float) {
- ast::type::F32 f32;
// Use a number close to 1<<30 but whose decimal representation ends in 0.
- auto* lit = create<ast::FloatLiteral>(Source{}, &f32,
- static_cast<float>((1 << 30) - 4));
- ast::ScalarConstructorExpression expr(Source{}, lit);
+ auto* lit =
+ create<ast::FloatLiteral>(ty.f32, static_cast<float>((1 << 30) - 4));
+ auto* expr = create<ast::ScalarConstructorExpression>(lit);
- ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+ ASSERT_TRUE(gen.EmitConstructor(expr)) << gen.error();
EXPECT_EQ(gen.result(), "1073741824.0f");
}
TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Float) {
- ast::type::F32 f32;
-
- auto* lit = create<ast::FloatLiteral>(Source{}, &f32, -1.2e-5);
+ auto* lit = create<ast::FloatLiteral>(ty.f32, -1.2e-5);
ast::ExpressionList values;
- values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit));
+ values.push_back(create<ast::ScalarConstructorExpression>(lit));
- ast::TypeConstructorExpression expr(Source{}, &f32, values);
+ auto* expr = create<ast::TypeConstructorExpression>(ty.f32, values);
- ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+ ASSERT_TRUE(gen.EmitConstructor(expr)) << gen.error();
EXPECT_EQ(gen.result(), "float(-0.000012f)");
}
TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Bool) {
- ast::type::Bool b;
-
- auto* lit = create<ast::BoolLiteral>(Source{}, &b, true);
+ auto* lit = create<ast::BoolLiteral>(ty.bool_, true);
ast::ExpressionList values;
- values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit));
+ values.push_back(create<ast::ScalarConstructorExpression>(lit));
- ast::TypeConstructorExpression expr(Source{}, &b, values);
+ auto* expr = create<ast::TypeConstructorExpression>(ty.bool_, values);
- ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+ ASSERT_TRUE(gen.EmitConstructor(expr)) << gen.error();
EXPECT_EQ(gen.result(), "bool(true)");
}
TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Int) {
- ast::type::I32 i32;
-
- auto* lit = create<ast::SintLiteral>(Source{}, &i32, -12345);
+ auto* lit = create<ast::SintLiteral>(ty.i32, -12345);
ast::ExpressionList values;
- values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit));
+ values.push_back(create<ast::ScalarConstructorExpression>(lit));
- ast::TypeConstructorExpression expr(Source{}, &i32, values);
+ auto* expr = create<ast::TypeConstructorExpression>(ty.i32, values);
- ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+ ASSERT_TRUE(gen.EmitConstructor(expr)) << gen.error();
EXPECT_EQ(gen.result(), "int(-12345)");
}
TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Uint) {
- ast::type::U32 u32;
-
- auto* lit = create<ast::UintLiteral>(Source{}, &u32, 12345);
+ auto* lit = create<ast::UintLiteral>(ty.u32, 12345);
ast::ExpressionList values;
- values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit));
+ values.push_back(create<ast::ScalarConstructorExpression>(lit));
- ast::TypeConstructorExpression expr(Source{}, &u32, values);
+ auto* expr = create<ast::TypeConstructorExpression>(ty.u32, values);
- ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+ ASSERT_TRUE(gen.EmitConstructor(expr)) << gen.error();
EXPECT_EQ(gen.result(), "uint(12345u)");
}
TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Vec) {
- ast::type::F32 f32;
- ast::type::Vector vec(&f32, 3);
+ ast::type::Vector vec(ty.f32, 3);
- auto* lit1 = create<ast::FloatLiteral>(Source{}, &f32, 1.f);
- auto* lit2 = create<ast::FloatLiteral>(Source{}, &f32, 2.f);
- auto* lit3 = create<ast::FloatLiteral>(Source{}, &f32, 3.f);
+ auto* lit1 = create<ast::FloatLiteral>(ty.f32, 1.f);
+ auto* lit2 = create<ast::FloatLiteral>(ty.f32, 2.f);
+ auto* lit3 = create<ast::FloatLiteral>(ty.f32, 3.f);
ast::ExpressionList values;
- values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit1));
- values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit2));
- values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit3));
+ values.push_back(create<ast::ScalarConstructorExpression>(lit1));
+ values.push_back(create<ast::ScalarConstructorExpression>(lit2));
+ values.push_back(create<ast::ScalarConstructorExpression>(lit3));
- ast::TypeConstructorExpression expr(Source{}, &vec, values);
+ auto* expr = create<ast::TypeConstructorExpression>(&vec, values);
- ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+ ASSERT_TRUE(gen.EmitConstructor(expr)) << gen.error();
EXPECT_EQ(gen.result(), "float3(1.0f, 2.0f, 3.0f)");
}
TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Vec_Empty) {
- ast::type::F32 f32;
- ast::type::Vector vec(&f32, 3);
+ ast::type::Vector vec(ty.f32, 3);
ast::ExpressionList values;
- ast::TypeConstructorExpression expr(Source{}, &vec, values);
+ auto* expr = create<ast::TypeConstructorExpression>(&vec, values);
- ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+ ASSERT_TRUE(gen.EmitConstructor(expr)) << gen.error();
EXPECT_EQ(gen.result(), "float3(0.0f)");
}
TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Mat) {
- ast::type::F32 f32;
- ast::type::Matrix mat(&f32, 3, 2); // 3 ROWS, 2 COLUMNS
- ast::type::Vector vec(&f32, 3);
+ ast::type::Matrix mat(ty.f32, 3, 2); // 3 ROWS, 2 COLUMNS
+ ast::type::Vector vec(ty.f32, 3);
// WGSL matrix is mat2x3 (it flips for AST, sigh). With a type constructor
// of <vec3, vec3>
@@ -167,24 +152,23 @@
ast::ExpressionList mat_values;
for (size_t i = 0; i < 2; i++) {
- auto* lit1 = create<ast::FloatLiteral>(Source{}, &f32,
- static_cast<float>(1 + (i * 2)));
- auto* lit2 = create<ast::FloatLiteral>(Source{}, &f32,
- static_cast<float>(2 + (i * 2)));
- auto* lit3 = create<ast::FloatLiteral>(Source{}, &f32,
- static_cast<float>(3 + (i * 2)));
+ auto* lit1 =
+ create<ast::FloatLiteral>(ty.f32, static_cast<float>(1 + (i * 2)));
+ auto* lit2 =
+ create<ast::FloatLiteral>(ty.f32, static_cast<float>(2 + (i * 2)));
+ auto* lit3 =
+ create<ast::FloatLiteral>(ty.f32, static_cast<float>(3 + (i * 2)));
ast::ExpressionList values;
- values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit1));
- values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit2));
- values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit3));
+ values.push_back(create<ast::ScalarConstructorExpression>(lit1));
+ values.push_back(create<ast::ScalarConstructorExpression>(lit2));
+ values.push_back(create<ast::ScalarConstructorExpression>(lit3));
- mat_values.push_back(
- create<ast::TypeConstructorExpression>(Source{}, &vec, values));
+ mat_values.push_back(create<ast::TypeConstructorExpression>(&vec, values));
}
- ast::TypeConstructorExpression expr(Source{}, &mat, mat_values);
- ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+ auto* expr = create<ast::TypeConstructorExpression>(&mat, mat_values);
+ ASSERT_TRUE(gen.EmitConstructor(expr)) << gen.error();
// A matrix of type T with n columns and m rows can also be constructed from
// n vectors of type T with m components.
@@ -193,31 +177,29 @@
}
TEST_F(MslGeneratorImplTest, EmitConstructor_Type_Array) {
- ast::type::F32 f32;
- ast::type::Vector vec(&f32, 3);
+ ast::type::Vector vec(ty.f32, 3);
ast::type::Array ary(&vec, 3, ast::ArrayDecorationList{});
ast::ExpressionList ary_values;
for (size_t i = 0; i < 3; i++) {
- auto* lit1 = create<ast::FloatLiteral>(Source{}, &f32,
- static_cast<float>(1 + (i * 3)));
- auto* lit2 = create<ast::FloatLiteral>(Source{}, &f32,
- static_cast<float>(2 + (i * 3)));
- auto* lit3 = create<ast::FloatLiteral>(Source{}, &f32,
- static_cast<float>(3 + (i * 3)));
+ auto* lit1 =
+ create<ast::FloatLiteral>(ty.f32, static_cast<float>(1 + (i * 3)));
+ auto* lit2 =
+ create<ast::FloatLiteral>(ty.f32, static_cast<float>(2 + (i * 3)));
+ auto* lit3 =
+ create<ast::FloatLiteral>(ty.f32, static_cast<float>(3 + (i * 3)));
ast::ExpressionList values;
- values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit1));
- values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit2));
- values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit3));
+ values.push_back(create<ast::ScalarConstructorExpression>(lit1));
+ values.push_back(create<ast::ScalarConstructorExpression>(lit2));
+ values.push_back(create<ast::ScalarConstructorExpression>(lit3));
- ary_values.push_back(
- create<ast::TypeConstructorExpression>(Source{}, &vec, values));
+ ary_values.push_back(create<ast::TypeConstructorExpression>(&vec, values));
}
- ast::TypeConstructorExpression expr(Source{}, &ary, ary_values);
- ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
+ auto* expr = create<ast::TypeConstructorExpression>(&ary, ary_values);
+ ASSERT_TRUE(gen.EmitConstructor(expr)) << gen.error();
EXPECT_EQ(gen.result(),
"{float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), "
"float3(7.0f, 8.0f, 9.0f)}");
diff --git a/src/writer/msl/generator_impl_continue_test.cc b/src/writer/msl/generator_impl_continue_test.cc
index 2edb073..12719b4 100644
--- a/src/writer/msl/generator_impl_continue_test.cc
+++ b/src/writer/msl/generator_impl_continue_test.cc
@@ -29,11 +29,11 @@
using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, Emit_Continue) {
- ast::ContinueStatement c(Source{});
+ auto* c = create<ast::ContinueStatement>();
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&c)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(c)) << gen.error();
EXPECT_EQ(gen.result(), " continue;\n");
}
diff --git a/src/writer/msl/generator_impl_discard_test.cc b/src/writer/msl/generator_impl_discard_test.cc
index 1aefa7d..0349acf 100644
--- a/src/writer/msl/generator_impl_discard_test.cc
+++ b/src/writer/msl/generator_impl_discard_test.cc
@@ -26,11 +26,11 @@
using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, Emit_Discard) {
- ast::DiscardStatement stmt(Source{});
+ auto* stmt = create<ast::DiscardStatement>();
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), " discard_fragment();\n");
}
diff --git a/src/writer/msl/generator_impl_function_entry_point_data_test.cc b/src/writer/msl/generator_impl_function_entry_point_data_test.cc
index 7828fdd..461035b 100644
--- a/src/writer/msl/generator_impl_function_entry_point_data_test.cc
+++ b/src/writer/msl/generator_impl_function_entry_point_data_test.cc
@@ -65,11 +65,11 @@
create<ast::AssignmentStatement>(Expr("foo"), Expr("foo")),
create<ast::AssignmentStatement>(Expr("bar"), Expr("bar")),
};
- auto* func = Func(
- "vtx_main", ast::VariableList{}, ty.f32, body,
- ast::FunctionDecorationList{
- create<ast::StageDecoration>(Source{}, ast::PipelineStage::kVertex),
- });
+ auto* func =
+ Func("vtx_main", ast::VariableList{}, ty.f32, body,
+ ast::FunctionDecorationList{
+ create<ast::StageDecoration>(ast::PipelineStage::kVertex),
+ });
mod->AddFunction(func);
@@ -111,11 +111,11 @@
create<ast::AssignmentStatement>(Expr("foo"), Expr("foo")),
create<ast::AssignmentStatement>(Expr("bar"), Expr("bar")),
};
- auto* func = Func(
- "vtx_main", ast::VariableList{}, ty.f32, body,
- ast::FunctionDecorationList{
- create<ast::StageDecoration>(Source{}, ast::PipelineStage::kVertex),
- });
+ auto* func =
+ Func("vtx_main", ast::VariableList{}, ty.f32, body,
+ ast::FunctionDecorationList{
+ create<ast::StageDecoration>(ast::PipelineStage::kVertex),
+ });
mod->AddFunction(func);
@@ -157,11 +157,11 @@
create<ast::AssignmentStatement>(Expr("foo"), Expr("foo")),
create<ast::AssignmentStatement>(Expr("bar"), Expr("bar")),
};
- auto* func = Func(
- "main", ast::VariableList{}, ty.f32, body,
- ast::FunctionDecorationList{
- create<ast::StageDecoration>(Source{}, ast::PipelineStage::kFragment),
- });
+ auto* func =
+ Func("main", ast::VariableList{}, ty.f32, body,
+ ast::FunctionDecorationList{
+ create<ast::StageDecoration>(ast::PipelineStage::kFragment),
+ });
mod->AddFunction(func);
@@ -203,11 +203,11 @@
create<ast::AssignmentStatement>(Expr("foo"), Expr("foo")),
create<ast::AssignmentStatement>(Expr("bar"), Expr("bar")),
};
- auto* func = Func(
- "main", ast::VariableList{}, ty.f32, body,
- ast::FunctionDecorationList{
- create<ast::StageDecoration>(Source{}, ast::PipelineStage::kFragment),
- });
+ auto* func =
+ Func("main", ast::VariableList{}, ty.f32, body,
+ ast::FunctionDecorationList{
+ create<ast::StageDecoration>(ast::PipelineStage::kFragment),
+ });
mod->AddFunction(func);
@@ -246,11 +246,11 @@
create<ast::AssignmentStatement>(Expr("foo"), Expr("foo")),
create<ast::AssignmentStatement>(Expr("bar"), Expr("bar")),
};
- auto* func = Func(
- "main", ast::VariableList{}, ty.f32, body,
- ast::FunctionDecorationList{
- create<ast::StageDecoration>(Source{}, ast::PipelineStage::kCompute),
- });
+ auto* func =
+ Func("main", ast::VariableList{}, ty.f32, body,
+ ast::FunctionDecorationList{
+ create<ast::StageDecoration>(ast::PipelineStage::kCompute),
+ });
mod->AddFunction(func);
@@ -284,11 +284,11 @@
create<ast::AssignmentStatement>(Expr("foo"), Expr("foo")),
create<ast::AssignmentStatement>(Expr("bar"), Expr("bar")),
};
- auto* func = Func(
- "main", ast::VariableList{}, ty.f32, body,
- ast::FunctionDecorationList{
- create<ast::StageDecoration>(Source{}, ast::PipelineStage::kCompute),
- });
+ auto* func =
+ Func("main", ast::VariableList{}, ty.f32, body,
+ ast::FunctionDecorationList{
+ create<ast::StageDecoration>(ast::PipelineStage::kCompute),
+ });
mod->AddFunction(func);
@@ -327,11 +327,11 @@
auto body = ast::StatementList{create<ast::AssignmentStatement>(
Expr("depth"), MemberAccessor("coord", "x"))};
- auto* func = Func(
- "main", ast::VariableList{}, ty.void_, body,
- ast::FunctionDecorationList{
- create<ast::StageDecoration>(Source{}, ast::PipelineStage::kFragment),
- });
+ auto* func =
+ Func("main", ast::VariableList{}, ty.void_, body,
+ ast::FunctionDecorationList{
+ create<ast::StageDecoration>(ast::PipelineStage::kFragment),
+ });
mod->AddFunction(func);
diff --git a/src/writer/msl/generator_impl_if_test.cc b/src/writer/msl/generator_impl_if_test.cc
index e764782..7a42ac0 100644
--- a/src/writer/msl/generator_impl_if_test.cc
+++ b/src/writer/msl/generator_impl_if_test.cc
@@ -33,11 +33,11 @@
auto* body = create<ast::BlockStatement>(ast::StatementList{
create<ast::ReturnStatement>(),
});
- ast::IfStatement i(Source{}, cond, body, ast::ElseStatementList{});
+ auto* i = create<ast::IfStatement>(cond, body, ast::ElseStatementList{});
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&i)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(i)) << gen.error();
EXPECT_EQ(gen.result(), R"( if (cond) {
return;
}
@@ -54,12 +54,15 @@
auto* body = create<ast::BlockStatement>(ast::StatementList{
create<ast::ReturnStatement>(),
});
- ast::IfStatement i(Source{}, cond, body,
- {create<ast::ElseStatement>(else_cond, else_body)});
+ auto* i = create<ast::IfStatement>(
+ cond, body,
+ ast::ElseStatementList{
+ create<ast::ElseStatement>(else_cond, else_body),
+ });
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&i)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(i)) << gen.error();
EXPECT_EQ(gen.result(), R"( if (cond) {
return;
} else if (else_cond) {
@@ -77,12 +80,15 @@
auto* body = create<ast::BlockStatement>(ast::StatementList{
create<ast::ReturnStatement>(),
});
- ast::IfStatement i(Source{}, cond, body,
- {create<ast::ElseStatement>(nullptr, else_body)});
+ auto* i = create<ast::IfStatement>(
+ cond, body,
+ ast::ElseStatementList{
+ create<ast::ElseStatement>(nullptr, else_body),
+ });
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&i)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(i)) << gen.error();
EXPECT_EQ(gen.result(), R"( if (cond) {
return;
} else {
@@ -94,30 +100,28 @@
TEST_F(MslGeneratorImplTest, Emit_IfWithMultiple) {
auto* else_cond = Expr("else_cond");
- auto* else_body =
- create<ast::BlockStatement>(Source{}, ast::StatementList{
- create<ast::ReturnStatement>(),
- });
+ auto* else_body = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::ReturnStatement>(),
+ });
- auto* else_body_2 =
- create<ast::BlockStatement>(Source{}, ast::StatementList{
- create<ast::ReturnStatement>(),
- });
+ auto* else_body_2 = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::ReturnStatement>(),
+ });
auto* cond = Expr("cond");
- auto* body =
- create<ast::BlockStatement>(Source{}, ast::StatementList{
- create<ast::ReturnStatement>(),
- });
- ast::IfStatement i(Source{}, cond, body,
- {
- create<ast::ElseStatement>(else_cond, else_body),
- create<ast::ElseStatement>(nullptr, else_body_2),
- });
+ auto* body = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::ReturnStatement>(),
+ });
+ auto* i = create<ast::IfStatement>(
+ cond, body,
+ ast::ElseStatementList{
+ create<ast::ElseStatement>(else_cond, else_body),
+ create<ast::ElseStatement>(nullptr, else_body_2),
+ });
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&i)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(i)) << gen.error();
EXPECT_EQ(gen.result(), R"( if (cond) {
return;
} else if (else_cond) {
diff --git a/src/writer/msl/generator_impl_loop_test.cc b/src/writer/msl/generator_impl_loop_test.cc
index 68e7fe2..76e8a3e 100644
--- a/src/writer/msl/generator_impl_loop_test.cc
+++ b/src/writer/msl/generator_impl_loop_test.cc
@@ -39,11 +39,11 @@
auto* body = create<ast::BlockStatement>(ast::StatementList{
create<ast::DiscardStatement>(),
});
- ast::LoopStatement l(Source{}, body, {});
+ auto* l = create<ast::LoopStatement>(body, nullptr);
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&l)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(l)) << gen.error();
EXPECT_EQ(gen.result(), R"( for(;;) {
discard_fragment();
}
@@ -57,11 +57,11 @@
auto* continuing = create<ast::BlockStatement>(ast::StatementList{
create<ast::ReturnStatement>(),
});
- ast::LoopStatement l(Source{}, body, continuing);
+ auto* l = create<ast::LoopStatement>(body, continuing);
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&l)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(l)) << gen.error();
EXPECT_EQ(gen.result(), R"( {
bool tint_msl_is_first_1 = true;
for(;;) {
@@ -93,11 +93,11 @@
create<ast::AssignmentStatement>(Expr("lhs"), Expr("rhs")),
});
- ast::LoopStatement outer(Source{}, body, continuing);
+ auto* outer = create<ast::LoopStatement>(body, continuing);
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&outer)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(outer)) << gen.error();
EXPECT_EQ(gen.result(), R"( {
bool tint_msl_is_first_1 = true;
for(;;) {
@@ -157,9 +157,9 @@
});
gen.increment_indent();
- ast::LoopStatement outer(Source{}, body, continuing);
+ auto* outer = create<ast::LoopStatement>(body, continuing);
- ASSERT_TRUE(gen.EmitStatement(&outer)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(outer)) << gen.error();
EXPECT_EQ(gen.result(), R"( {
bool tint_msl_is_first_1 = true;
float lhs;
diff --git a/src/writer/msl/generator_impl_module_constant_test.cc b/src/writer/msl/generator_impl_module_constant_test.cc
index 56d1fc1..87389fb 100644
--- a/src/writer/msl/generator_impl_module_constant_test.cc
+++ b/src/writer/msl/generator_impl_module_constant_test.cc
@@ -36,11 +36,11 @@
TEST_F(MslGeneratorImplTest, Emit_ModuleConstant) {
ast::type::Array ary(ty.f32, 3, ast::ArrayDecorationList{});
- auto* var = Const(
- "pos", ast::StorageClass::kNone, &ary,
- create<ast::TypeConstructorExpression>(
- Source{}, &ary, ast::ExpressionList{Expr(1.f), Expr(2.f), Expr(3.f)}),
- ast::VariableDecorationList{});
+ auto* var =
+ Const("pos", ast::StorageClass::kNone, &ary,
+ create<ast::TypeConstructorExpression>(
+ &ary, ast::ExpressionList{Expr(1.f), Expr(2.f), Expr(3.f)}),
+ ast::VariableDecorationList{});
ASSERT_TRUE(gen.EmitProgramConstVariable(var)) << gen.error();
EXPECT_EQ(gen.result(), "constant float pos[3] = {1.0f, 2.0f, 3.0f};\n");
@@ -49,7 +49,7 @@
TEST_F(MslGeneratorImplTest, Emit_SpecConstant) {
auto* var = Const("pos", ast::StorageClass::kNone, ty.f32, Expr(3.f),
ast::VariableDecorationList{
- create<ast::ConstantIdDecoration>(Source{}, 23),
+ create<ast::ConstantIdDecoration>(23),
});
ASSERT_TRUE(gen.EmitProgramConstVariable(var)) << gen.error();
diff --git a/src/writer/msl/generator_impl_return_test.cc b/src/writer/msl/generator_impl_return_test.cc
index 8d1f7ad..e017d6a 100644
--- a/src/writer/msl/generator_impl_return_test.cc
+++ b/src/writer/msl/generator_impl_return_test.cc
@@ -30,18 +30,18 @@
using MslGeneratorImplTest = TestHelper;
TEST_F(MslGeneratorImplTest, Emit_Return) {
- ast::ReturnStatement r(Source{});
+ auto* r = create<ast::ReturnStatement>();
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&r)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(r)) << gen.error();
EXPECT_EQ(gen.result(), " return;\n");
}
TEST_F(MslGeneratorImplTest, Emit_ReturnWithValue) {
- ast::ReturnStatement r(Source{}, Expr("expr"));
+ auto* r = create<ast::ReturnStatement>(Expr("expr"));
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&r)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(r)) << gen.error();
EXPECT_EQ(gen.result(), " return expr;\n");
}
diff --git a/src/writer/msl/generator_impl_switch_test.cc b/src/writer/msl/generator_impl_switch_test.cc
index 60b28b6..c67822a 100644
--- a/src/writer/msl/generator_impl_switch_test.cc
+++ b/src/writer/msl/generator_impl_switch_test.cc
@@ -51,10 +51,10 @@
body.push_back(case_stmt);
body.push_back(def);
- ast::SwitchStatement s(Source{}, Expr("cond"), body);
+ auto* s = create<ast::SwitchStatement>(Expr("cond"), body);
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&s)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(s)) << gen.error();
EXPECT_EQ(gen.result(), R"( switch(cond) {
case 5: {
break;
diff --git a/src/writer/msl/generator_impl_unary_op_test.cc b/src/writer/msl/generator_impl_unary_op_test.cc
index 991a156..c93bee2 100644
--- a/src/writer/msl/generator_impl_unary_op_test.cc
+++ b/src/writer/msl/generator_impl_unary_op_test.cc
@@ -38,8 +38,8 @@
using MslUnaryOpTest = TestParamHelper<UnaryOpData>;
TEST_P(MslUnaryOpTest, Emit) {
auto params = GetParam();
- ast::UnaryOpExpression op(Source{}, params.op, Expr("expr"));
- ASSERT_TRUE(gen.EmitExpression(&op)) << gen.error();
+ auto* op = create<ast::UnaryOpExpression>(params.op, Expr("expr"));
+ ASSERT_TRUE(gen.EmitExpression(op)) << gen.error();
EXPECT_EQ(gen.result(), std::string(params.name) + "(expr)");
}
INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
diff --git a/src/writer/msl/generator_impl_variable_decl_statement_test.cc b/src/writer/msl/generator_impl_variable_decl_statement_test.cc
index ad0d1de..0a89380 100644
--- a/src/writer/msl/generator_impl_variable_decl_statement_test.cc
+++ b/src/writer/msl/generator_impl_variable_decl_statement_test.cc
@@ -42,21 +42,21 @@
TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement) {
auto* var = Var("a", ast::StorageClass::kNone, ty.f32);
- ast::VariableDeclStatement stmt(Source{}, var);
+ auto* stmt = create<ast::VariableDeclStatement>(var);
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), " float a = 0.0f;\n");
}
TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Const) {
auto* var = Const("a", ast::StorageClass::kNone, ty.f32);
- ast::VariableDeclStatement stmt(Source{}, var);
+ auto* stmt = create<ast::VariableDeclStatement>(var);
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), " const float a = 0.0f;\n");
}
@@ -64,11 +64,11 @@
ast::type::Array ary(ty.f32, 5, ast::ArrayDecorationList{});
auto* var = Var("a", ast::StorageClass::kNone, &ary);
- ast::VariableDeclStatement stmt(Source{}, var);
+ auto* stmt = create<ast::VariableDeclStatement>(var);
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), " float a[5] = {0.0f};\n");
}
@@ -80,52 +80,52 @@
auto* s = ty.struct_("S", str);
auto* var = Var("a", ast::StorageClass::kNone, s);
- ast::VariableDeclStatement stmt(Source{}, var);
+ auto* stmt = create<ast::VariableDeclStatement>(var);
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), R"( S a = {};
)");
}
TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Vector) {
auto* var = Var("a", ast::StorageClass::kFunction, ty.vec2<f32>());
- ast::VariableDeclStatement stmt(Source{}, var);
+ auto* stmt = create<ast::VariableDeclStatement>(var);
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), " float2 a = 0.0f;\n");
}
TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Matrix) {
auto* var = Var("a", ast::StorageClass::kFunction, ty.mat3x2<f32>());
- ast::VariableDeclStatement stmt(Source{}, var);
+ auto* stmt = create<ast::VariableDeclStatement>(var);
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), " float3x2 a = 0.0f;\n");
}
TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Private) {
auto* var = Var("a", ast::StorageClass::kPrivate, ty.f32);
- ast::VariableDeclStatement stmt(Source{}, var);
+ auto* stmt = create<ast::VariableDeclStatement>(var);
gen.increment_indent();
- ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), " float a = 0.0f;\n");
}
TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Initializer_Private) {
auto* var = Var("a", ast::StorageClass::kNone, ty.f32, Expr("initializer"),
ast::VariableDecorationList{});
- ast::VariableDeclStatement stmt(Source{}, var);
+ auto* stmt = create<ast::VariableDeclStatement>(var);
- ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), R"(float a = initializer;
)");
}
@@ -133,13 +133,13 @@
TEST_F(MslGeneratorImplTest, Emit_VariableDeclStatement_Initializer_ZeroVec) {
ast::ExpressionList values;
auto* zero_vec =
- create<ast::TypeConstructorExpression>(Source{}, ty.vec3<f32>(), values);
+ create<ast::TypeConstructorExpression>(ty.vec3<f32>(), values);
auto* var = Var("a", ast::StorageClass::kNone, ty.vec3<f32>(), zero_vec,
ast::VariableDecorationList{});
- ast::VariableDeclStatement stmt(Source{}, var);
+ auto* stmt = create<ast::VariableDeclStatement>(var);
- ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error();
+ ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), R"(float3 a = float3(0.0f);
)");
}
diff --git a/src/writer/spirv/builder_assign_test.cc b/src/writer/spirv/builder_assign_test.cc
index 70bb77e..97b744a 100644
--- a/src/writer/spirv/builder_assign_test.cc
+++ b/src/writer/spirv/builder_assign_test.cc
@@ -44,16 +44,16 @@
TEST_F(BuilderTest, Assign_Var) {
auto* v = Var("var", ast::StorageClass::kOutput, ty.f32);
- ast::AssignmentStatement assign(Source{}, Expr("var"), Expr(1.f));
+ auto* assign = create<ast::AssignmentStatement>(Expr("var"), Expr(1.f));
td.RegisterVariableForTesting(v);
- ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(assign)) << td.error();
b.push_function(Function{});
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
ASSERT_FALSE(b.has_error()) << b.error();
- EXPECT_TRUE(b.GenerateAssignStatement(&assign)) << b.error();
+ EXPECT_TRUE(b.GenerateAssignStatement(assign)) << b.error();
EXPECT_FALSE(b.has_error());
EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeFloat 32
@@ -70,15 +70,15 @@
TEST_F(BuilderTest, Assign_Var_OutsideFunction_IsError) {
auto* v = Var("var", ast::StorageClass::kOutput, ty.f32);
- ast::AssignmentStatement assign(Source{}, Expr("var"), Expr(1.f));
+ auto* assign = create<ast::AssignmentStatement>(Expr("var"), Expr(1.f));
td.RegisterVariableForTesting(v);
- ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(assign)) << td.error();
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
ASSERT_FALSE(b.has_error()) << b.error();
- EXPECT_FALSE(b.GenerateAssignStatement(&assign)) << b.error();
+ EXPECT_FALSE(b.GenerateAssignStatement(assign)) << b.error();
EXPECT_TRUE(b.has_error());
EXPECT_EQ(
b.error(),
@@ -88,19 +88,19 @@
TEST_F(BuilderTest, Assign_Var_ZeroConstructor) {
auto* v = Var("var", ast::StorageClass::kOutput, ty.vec3<f32>());
- auto* val = create<ast::TypeConstructorExpression>(Source{}, ty.vec3<f32>(),
+ auto* val = create<ast::TypeConstructorExpression>(ty.vec3<f32>(),
ast::ExpressionList{});
- ast::AssignmentStatement assign(Source{}, Expr("var"), val);
+ auto* assign = create<ast::AssignmentStatement>(Expr("var"), val);
td.RegisterVariableForTesting(v);
- ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(assign)) << td.error();
b.push_function(Function{});
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
ASSERT_FALSE(b.has_error()) << b.error();
- EXPECT_TRUE(b.GenerateAssignStatement(&assign)) << b.error();
+ EXPECT_TRUE(b.GenerateAssignStatement(assign)) << b.error();
EXPECT_FALSE(b.has_error());
EXPECT_EQ(DumpInstructions(b.types()), R"(%4 = OpTypeFloat 32
@@ -116,22 +116,22 @@
TEST_F(BuilderTest, Assign_Var_Complex_ConstructorWithExtract) {
auto* first = create<ast::TypeConstructorExpression>(
- Source{}, ty.vec2<f32>(), ast::ExpressionList{Expr(1.f), Expr(2.f)});
+ ty.vec2<f32>(), ast::ExpressionList{Expr(1.f), Expr(2.f)});
auto* init = create<ast::TypeConstructorExpression>(
- Source{}, ty.vec3<f32>(), ast::ExpressionList{first, Expr(3.f)});
+ ty.vec3<f32>(), ast::ExpressionList{first, Expr(3.f)});
auto* v = Var("var", ast::StorageClass::kOutput, ty.vec3<f32>());
- ast::AssignmentStatement assign(Source{}, Expr("var"), init);
+ auto* assign = create<ast::AssignmentStatement>(Expr("var"), init);
td.RegisterVariableForTesting(v);
- ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(assign)) << td.error();
b.push_function(Function{});
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
ASSERT_FALSE(b.has_error()) << b.error();
- EXPECT_TRUE(b.GenerateAssignStatement(&assign)) << b.error();
+ EXPECT_TRUE(b.GenerateAssignStatement(assign)) << b.error();
EXPECT_FALSE(b.has_error());
EXPECT_EQ(DumpInstructions(b.types()), R"(%4 = OpTypeFloat 32
@@ -155,20 +155,19 @@
TEST_F(BuilderTest, Assign_Var_Complex_Constructor) {
auto* init = create<ast::TypeConstructorExpression>(
- Source{}, ty.vec3<f32>(),
- ast::ExpressionList{Expr(1.f), Expr(2.f), Expr(3.f)});
+ ty.vec3<f32>(), ast::ExpressionList{Expr(1.f), Expr(2.f), Expr(3.f)});
auto* v = Var("var", ast::StorageClass::kOutput, ty.vec3<f32>());
- ast::AssignmentStatement assign(Source{}, Expr("var"), init);
+ auto* assign = create<ast::AssignmentStatement>(Expr("var"), init);
td.RegisterVariableForTesting(v);
- ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(assign)) << td.error();
b.push_function(Function{});
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
ASSERT_FALSE(b.has_error()) << b.error();
- EXPECT_TRUE(b.GenerateAssignStatement(&assign)) << b.error();
+ EXPECT_TRUE(b.GenerateAssignStatement(assign)) << b.error();
EXPECT_FALSE(b.has_error());
EXPECT_EQ(DumpInstructions(b.types()), R"(%4 = OpTypeFloat 32
@@ -200,17 +199,17 @@
auto* s_type = ty.struct_("my_struct", s);
auto* v = Var("ident", ast::StorageClass::kFunction, s_type);
- ast::AssignmentStatement assign(Source{}, MemberAccessor("ident", "b"),
- Expr(4.f));
+ auto* assign =
+ create<ast::AssignmentStatement>(MemberAccessor("ident", "b"), Expr(4.f));
td.RegisterVariableForTesting(v);
- ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(assign)) << td.error();
b.push_function(Function{});
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
ASSERT_FALSE(b.has_error()) << b.error();
- EXPECT_TRUE(b.GenerateAssignStatement(&assign)) << b.error();
+ EXPECT_TRUE(b.GenerateAssignStatement(assign)) << b.error();
EXPECT_FALSE(b.has_error());
EXPECT_EQ(DumpInstructions(b.types()), R"(%4 = OpTypeFloat 32
@@ -233,19 +232,18 @@
auto* v = Var("var", ast::StorageClass::kOutput, ty.vec3<f32>());
auto* val = create<ast::TypeConstructorExpression>(
- Source{}, ty.vec3<f32>(),
- ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(3.f)});
+ ty.vec3<f32>(), ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(3.f)});
- ast::AssignmentStatement assign(Source{}, Expr("var"), val);
+ auto* assign = create<ast::AssignmentStatement>(Expr("var"), val);
td.RegisterVariableForTesting(v);
- ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(assign)) << td.error();
b.push_function(Function{});
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
ASSERT_FALSE(b.has_error()) << b.error();
- EXPECT_TRUE(b.GenerateAssignStatement(&assign)) << b.error();
+ EXPECT_TRUE(b.GenerateAssignStatement(assign)) << b.error();
EXPECT_FALSE(b.has_error());
EXPECT_EQ(DumpInstructions(b.types()), R"(%4 = OpTypeFloat 32
@@ -267,17 +265,17 @@
auto* v = Var("var", ast::StorageClass::kOutput, ty.vec3<f32>());
- ast::AssignmentStatement assign(Source{}, MemberAccessor("var", "y"),
- Expr(1.f));
+ auto* assign =
+ create<ast::AssignmentStatement>(MemberAccessor("var", "y"), Expr(1.f));
td.RegisterVariableForTesting(v);
- ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(assign)) << td.error();
b.push_function(Function{});
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
ASSERT_FALSE(b.has_error()) << b.error();
- EXPECT_TRUE(b.GenerateAssignStatement(&assign)) << b.error();
+ EXPECT_TRUE(b.GenerateAssignStatement(assign)) << b.error();
EXPECT_FALSE(b.has_error());
EXPECT_EQ(DumpInstructions(b.types()), R"(%4 = OpTypeFloat 32
@@ -302,16 +300,17 @@
auto* v = Var("var", ast::StorageClass::kOutput, ty.vec3<f32>());
- ast::AssignmentStatement assign(Source{}, IndexAccessor("var", 1), Expr(1.f));
+ auto* assign =
+ create<ast::AssignmentStatement>(IndexAccessor("var", 1), Expr(1.f));
td.RegisterVariableForTesting(v);
- ASSERT_TRUE(td.DetermineResultType(&assign)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(assign)) << td.error();
b.push_function(Function{});
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
ASSERT_FALSE(b.has_error()) << b.error();
- EXPECT_TRUE(b.GenerateAssignStatement(&assign)) << b.error();
+ EXPECT_TRUE(b.GenerateAssignStatement(assign)) << b.error();
EXPECT_FALSE(b.has_error());
EXPECT_EQ(DumpInstructions(b.types()), R"(%4 = OpTypeFloat 32
diff --git a/src/writer/spirv/builder_binary_expression_test.cc b/src/writer/spirv/builder_binary_expression_test.cc
index a6467a6..425b04c 100644
--- a/src/writer/spirv/builder_binary_expression_test.cc
+++ b/src/writer/spirv/builder_binary_expression_test.cc
@@ -54,20 +54,16 @@
TEST_P(BinaryArithSignedIntegerTest, Scalar) {
auto param = GetParam();
- ast::type::I32 i32;
+ auto* lhs = Expr(3);
+ auto* rhs = Expr(4);
- auto* lhs = create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 3));
- auto* rhs = create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 4));
+ auto* expr = create<ast::BinaryExpression>(param.op, lhs, rhs);
- ast::BinaryExpression expr(Source{}, param.op, lhs, rhs);
-
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 4u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 1
%2 = OpConstant %1 3
%3 = OpConstant %1 4
@@ -78,38 +74,16 @@
TEST_P(BinaryArithSignedIntegerTest, Vector) {
auto param = GetParam();
- ast::type::I32 i32;
- ast::type::Vector vec3(&i32, 3);
+ auto* lhs = vec3<i32>(1, 1, 1);
+ auto* rhs = vec3<i32>(1, 1, 1);
- auto* lhs = create<ast::TypeConstructorExpression>(
- Source{}, &vec3,
- ast::ExpressionList{
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 1)),
- });
+ auto* expr = create<ast::BinaryExpression>(param.op, lhs, rhs);
- auto* rhs = create<ast::TypeConstructorExpression>(
- Source{}, &vec3,
- ast::ExpressionList{
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 1)),
- });
-
- ast::BinaryExpression expr(Source{}, param.op, lhs, rhs);
-
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 5u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
%1 = OpTypeVector %2 3
%3 = OpConstant %2 1
@@ -122,14 +96,15 @@
auto param = GetParam();
auto* var = Var("param", ast::StorageClass::kFunction, ty.i32);
- ast::BinaryExpression expr(Source{}, param.op, Expr("param"), Expr("param"));
+ auto* expr =
+ create<ast::BinaryExpression>(param.op, Expr("param"), Expr("param"));
td.RegisterVariableForTesting(var);
- EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ EXPECT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
EXPECT_TRUE(b.GenerateFunctionVariable(var)) << b.error();
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 7u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 7u) << b.error();
ASSERT_FALSE(b.has_error()) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeInt 32 1
@@ -168,17 +143,17 @@
ast::type::U32 u32;
auto* lhs = create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::UintLiteral>(Source{}, &u32, 3));
+ create<ast::UintLiteral>(&u32, 3));
auto* rhs = create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::UintLiteral>(Source{}, &u32, 4));
+ create<ast::UintLiteral>(&u32, 4));
- ast::BinaryExpression expr(Source{}, param.op, lhs, rhs);
+ auto* expr = create<ast::BinaryExpression>(param.op, lhs, rhs);
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 4u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 0
%2 = OpConstant %1 3
%3 = OpConstant %1 4
@@ -189,38 +164,16 @@
TEST_P(BinaryArithUnsignedIntegerTest, Vector) {
auto param = GetParam();
- ast::type::U32 u32;
- ast::type::Vector vec3(&u32, 3);
+ auto* lhs = vec3<u32>(1u, 1u, 1u);
+ auto* rhs = vec3<u32>(1u, 1u, 1u);
- auto* lhs = create<ast::TypeConstructorExpression>(
- Source{}, &vec3,
- ast::ExpressionList{
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::UintLiteral>(Source{}, &u32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::UintLiteral>(Source{}, &u32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::UintLiteral>(Source{}, &u32, 1)),
- });
+ auto* expr = create<ast::BinaryExpression>(param.op, lhs, rhs);
- auto* rhs = create<ast::TypeConstructorExpression>(
- Source{}, &vec3,
- ast::ExpressionList{
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::UintLiteral>(Source{}, &u32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::UintLiteral>(Source{}, &u32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::UintLiteral>(Source{}, &u32, 1)),
- });
-
- ast::BinaryExpression expr(Source{}, param.op, lhs, rhs);
-
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 5u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 0
%1 = OpTypeVector %2 3
%3 = OpConstant %2 1
@@ -251,16 +204,16 @@
ast::type::F32 f32;
auto* lhs = create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 3.2f));
+ create<ast::FloatLiteral>(&f32, 3.2f));
auto* rhs = create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 4.5f));
+ create<ast::FloatLiteral>(&f32, 4.5f));
- ast::BinaryExpression expr(Source{}, param.op, lhs, rhs);
+ auto* expr = create<ast::BinaryExpression>(param.op, lhs, rhs);
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 4u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32
%2 = OpConstant %1 3.20000005
%3 = OpConstant %1 4.5
@@ -272,38 +225,16 @@
TEST_P(BinaryArithFloatTest, Vector) {
auto param = GetParam();
- ast::type::F32 f32;
- ast::type::Vector vec3(&f32, 3);
+ auto* lhs = vec3<f32>(1.f, 1.f, 1.f);
+ auto* rhs = vec3<f32>(1.f, 1.f, 1.f);
- auto* lhs = create<ast::TypeConstructorExpression>(
- Source{}, &vec3,
- ast::ExpressionList{
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
- });
+ auto* expr = create<ast::BinaryExpression>(param.op, lhs, rhs);
- auto* rhs = create<ast::TypeConstructorExpression>(
- Source{}, &vec3,
- ast::ExpressionList{
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
- });
-
- ast::BinaryExpression expr(Source{}, param.op, lhs, rhs);
-
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 5u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32
%1 = OpTypeVector %2 3
%3 = OpConstant %2 1
@@ -328,17 +259,17 @@
ast::type::U32 u32;
auto* lhs = create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::UintLiteral>(Source{}, &u32, 3));
+ create<ast::UintLiteral>(&u32, 3));
auto* rhs = create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::UintLiteral>(Source{}, &u32, 4));
+ create<ast::UintLiteral>(&u32, 4));
- ast::BinaryExpression expr(Source{}, param.op, lhs, rhs);
+ auto* expr = create<ast::BinaryExpression>(param.op, lhs, rhs);
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 4u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 0
%2 = OpConstant %1 3
%3 = OpConstant %1 4
@@ -351,38 +282,16 @@
TEST_P(BinaryCompareUnsignedIntegerTest, Vector) {
auto param = GetParam();
- ast::type::U32 u32;
- ast::type::Vector vec3(&u32, 3);
+ auto* lhs = vec3<u32>(1u, 1u, 1u);
+ auto* rhs = vec3<u32>(1u, 1u, 1u);
- auto* lhs = create<ast::TypeConstructorExpression>(
- Source{}, &vec3,
- ast::ExpressionList{
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::UintLiteral>(Source{}, &u32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::UintLiteral>(Source{}, &u32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::UintLiteral>(Source{}, &u32, 1)),
- });
+ auto* expr = create<ast::BinaryExpression>(param.op, lhs, rhs);
- auto* rhs = create<ast::TypeConstructorExpression>(
- Source{}, &vec3,
- ast::ExpressionList{
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::UintLiteral>(Source{}, &u32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::UintLiteral>(Source{}, &u32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::UintLiteral>(Source{}, &u32, 1)),
- });
-
- ast::BinaryExpression expr(Source{}, param.op, lhs, rhs);
-
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 5u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 0
%1 = OpTypeVector %2 3
%3 = OpConstant %2 1
@@ -408,20 +317,16 @@
TEST_P(BinaryCompareSignedIntegerTest, Scalar) {
auto param = GetParam();
- ast::type::I32 i32;
+ auto* lhs = Expr(3);
+ auto* rhs = Expr(4);
- auto* lhs = create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 3));
- auto* rhs = create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 4));
+ auto* expr = create<ast::BinaryExpression>(param.op, lhs, rhs);
- ast::BinaryExpression expr(Source{}, param.op, lhs, rhs);
-
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 4u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 1
%2 = OpConstant %1 3
%3 = OpConstant %1 4
@@ -434,38 +339,16 @@
TEST_P(BinaryCompareSignedIntegerTest, Vector) {
auto param = GetParam();
- ast::type::I32 i32;
- ast::type::Vector vec3(&i32, 3);
+ auto* lhs = vec3<i32>(1, 1, 1);
+ auto* rhs = vec3<i32>(1, 1, 1);
- auto* lhs = create<ast::TypeConstructorExpression>(
- Source{}, &vec3,
- ast::ExpressionList{
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 1)),
- });
+ auto* expr = create<ast::BinaryExpression>(param.op, lhs, rhs);
- auto* rhs = create<ast::TypeConstructorExpression>(
- Source{}, &vec3,
- ast::ExpressionList{
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 1)),
- });
-
- ast::BinaryExpression expr(Source{}, param.op, lhs, rhs);
-
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 5u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
%1 = OpTypeVector %2 3
%3 = OpConstant %2 1
@@ -491,20 +374,16 @@
TEST_P(BinaryCompareFloatTest, Scalar) {
auto param = GetParam();
- ast::type::F32 f32;
+ auto* lhs = Expr(3.2f);
+ auto* rhs = Expr(4.5f);
- auto* lhs = create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 3.2f));
- auto* rhs = create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 4.5f));
+ auto* expr = create<ast::BinaryExpression>(param.op, lhs, rhs);
- ast::BinaryExpression expr(Source{}, param.op, lhs, rhs);
-
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 4u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32
%2 = OpConstant %1 3.20000005
%3 = OpConstant %1 4.5
@@ -517,38 +396,16 @@
TEST_P(BinaryCompareFloatTest, Vector) {
auto param = GetParam();
- ast::type::F32 f32;
- ast::type::Vector vec3(&f32, 3);
+ auto* lhs = vec3<f32>(1.f, 1.f, 1.f);
+ auto* rhs = vec3<f32>(1.f, 1.f, 1.f);
- auto* lhs = create<ast::TypeConstructorExpression>(
- Source{}, &vec3,
- ast::ExpressionList{
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
- });
+ auto* expr = create<ast::BinaryExpression>(param.op, lhs, rhs);
- auto* rhs = create<ast::TypeConstructorExpression>(
- Source{}, &vec3,
- ast::ExpressionList{
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
- });
-
- ast::BinaryExpression expr(Source{}, param.op, lhs, rhs);
-
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 5u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32
%1 = OpTypeVector %2 3
%3 = OpConstant %2 1
@@ -571,30 +428,17 @@
BinaryData{ast::BinaryOp::kNotEqual, "OpFOrdNotEqual"}));
TEST_F(BuilderTest, Binary_Multiply_VectorScalar) {
- ast::type::F32 f32;
- ast::type::Vector vec3(&f32, 3);
+ auto* lhs = vec3<f32>(1.f, 1.f, 1.f);
+ auto* rhs = Expr(1.f);
- auto* lhs = create<ast::TypeConstructorExpression>(
- Source{}, &vec3,
- ast::ExpressionList{
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)),
- });
+ auto* expr =
+ create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, lhs, rhs);
- auto* rhs = create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f));
-
- ast::BinaryExpression expr(Source{}, ast::BinaryOp::kMultiply, lhs, rhs);
-
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 5u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32
%1 = OpTypeVector %2 3
%3 = OpConstant %2 1
@@ -605,28 +449,17 @@
}
TEST_F(BuilderTest, Binary_Multiply_ScalarVector) {
- ast::type::F32 f32;
- ast::type::Vector vec3(&f32, 3);
+ auto* lhs = Expr(1.f);
+ auto* rhs = vec3<f32>(1.f, 1.f, 1.f);
- auto* lhs = create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f));
+ auto* expr =
+ create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, lhs, rhs);
- ast::ExpressionList vals;
- vals.push_back(create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
- vals.push_back(create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
- vals.push_back(create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 1.f)));
- auto* rhs = create<ast::TypeConstructorExpression>(Source{}, &vec3, vals);
-
- ast::BinaryExpression expr(Source{}, ast::BinaryOp::kMultiply, lhs, rhs);
-
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 5u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32
%2 = OpConstant %1 1
%3 = OpTypeVector %1 3
@@ -640,14 +473,14 @@
auto* var = Var("mat", ast::StorageClass::kFunction, ty.mat3x3<f32>());
td.RegisterVariableForTesting(var);
- ast::BinaryExpression expr(Source{}, ast::BinaryOp::kMultiply, Expr("mat"),
- Expr(1.f));
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kMultiply,
+ Expr("mat"), Expr(1.f));
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
ASSERT_TRUE(b.GenerateGlobalVariable(var)) << b.error();
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 8u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 8u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%5 = OpTypeFloat 32
%4 = OpTypeVector %5 3
%3 = OpTypeMatrix %4 3
@@ -665,15 +498,15 @@
auto* var = Var("mat", ast::StorageClass::kFunction, ty.mat3x3<f32>());
td.RegisterVariableForTesting(var);
- ast::BinaryExpression expr(Source{}, ast::BinaryOp::kMultiply, Expr(1.f),
- Expr("mat"));
+ auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kMultiply,
+ Expr(1.f), Expr("mat"));
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
ASSERT_TRUE(b.GenerateGlobalVariable(var)) << b.error();
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 8u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 8u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%5 = OpTypeFloat 32
%4 = OpTypeVector %5 3
%3 = OpTypeMatrix %4 3
@@ -690,20 +523,19 @@
TEST_F(BuilderTest, Binary_Multiply_MatrixVector) {
auto* var = Var("mat", ast::StorageClass::kFunction, ty.mat3x3<f32>());
auto* rhs = create<ast::TypeConstructorExpression>(
- Source{}, ty.vec3<f32>(),
- ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(1.f)});
+ ty.vec3<f32>(), ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(1.f)});
td.RegisterVariableForTesting(var);
- ast::BinaryExpression expr(Source{}, ast::BinaryOp::kMultiply, Expr("mat"),
- rhs);
+ auto* expr =
+ create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, Expr("mat"), rhs);
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
ASSERT_TRUE(b.GenerateGlobalVariable(var)) << b.error();
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 9u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 9u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%5 = OpTypeFloat 32
%4 = OpTypeVector %5 3
%3 = OpTypeMatrix %4 3
@@ -721,20 +553,19 @@
TEST_F(BuilderTest, Binary_Multiply_VectorMatrix) {
auto* var = Var("mat", ast::StorageClass::kFunction, ty.mat3x3<f32>());
auto* lhs = create<ast::TypeConstructorExpression>(
- Source{}, ty.vec3<f32>(),
- ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(1.f)});
+ ty.vec3<f32>(), ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(1.f)});
td.RegisterVariableForTesting(var);
- ast::BinaryExpression expr(Source{}, ast::BinaryOp::kMultiply, lhs,
- Expr("mat"));
+ auto* expr =
+ create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, lhs, Expr("mat"));
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
ASSERT_TRUE(b.GenerateGlobalVariable(var)) << b.error();
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 9u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 9u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%5 = OpTypeFloat 32
%4 = OpTypeVector %5 3
%3 = OpTypeMatrix %4 3
@@ -753,15 +584,15 @@
auto* var = Var("mat", ast::StorageClass::kFunction, ty.mat3x3<f32>());
td.RegisterVariableForTesting(var);
- ast::BinaryExpression expr(Source{}, ast::BinaryOp::kMultiply, Expr("mat"),
- Expr("mat"));
+ auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kMultiply,
+ Expr("mat"), Expr("mat"));
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
ASSERT_TRUE(b.GenerateGlobalVariable(var)) << b.error();
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 8u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 8u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%5 = OpTypeFloat 32
%4 = OpTypeVector %5 3
%3 = OpTypeMatrix %4 3
@@ -776,30 +607,21 @@
}
TEST_F(BuilderTest, Binary_LogicalAnd) {
- ast::type::I32 i32;
+ auto* lhs =
+ create<ast::BinaryExpression>(ast::BinaryOp::kEqual, Expr(1), Expr(2));
- auto* lhs = create<ast::BinaryExpression>(
- Source{}, ast::BinaryOp::kEqual,
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 2)));
+ auto* rhs =
+ create<ast::BinaryExpression>(ast::BinaryOp::kEqual, Expr(3), Expr(4));
- auto* rhs = create<ast::BinaryExpression>(
- Source{}, ast::BinaryOp::kEqual,
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 3)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 4)));
+ auto* expr =
+ create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd, lhs, rhs);
- ast::BinaryExpression expr(Source{}, ast::BinaryOp::kLogicalAnd, lhs, rhs);
-
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
b.GenerateLabel(b.next_id());
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 12u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 12u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
%3 = OpConstant %2 1
%4 = OpConstant %2 2
@@ -831,10 +653,10 @@
td.RegisterVariableForTesting(a_var);
td.RegisterVariableForTesting(b_var);
- ast::BinaryExpression expr(Source{}, ast::BinaryOp::kLogicalAnd, Expr("a"),
- Expr("b"));
+ auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd,
+ Expr("a"), Expr("b"));
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
b.GenerateLabel(b.next_id());
@@ -842,7 +664,7 @@
ASSERT_TRUE(b.GenerateGlobalVariable(a_var)) << b.error();
ASSERT_TRUE(b.GenerateGlobalVariable(b_var)) << b.error();
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 12u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 12u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool
%3 = OpConstantTrue %2
%5 = OpTypePointer Function %2
@@ -871,24 +693,24 @@
// From: crbug.com/tint/355
auto* logical_and_expr = create<ast::BinaryExpression>(
- Source{}, ast::BinaryOp::kLogicalAnd,
+ ast::BinaryOp::kLogicalAnd,
create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::BoolLiteral>(Source{}, &bool_ty, true)),
+ create<ast::BoolLiteral>(&bool_ty, true)),
create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::BoolLiteral>(Source{}, &bool_ty, false)));
+ create<ast::BoolLiteral>(&bool_ty, false)));
- ast::BinaryExpression expr(
- Source{}, ast::BinaryOp::kLogicalOr,
+ auto* expr = create<ast::BinaryExpression>(
+ ast::BinaryOp::kLogicalOr,
create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::BoolLiteral>(Source{}, &bool_ty, true)),
+ create<ast::BoolLiteral>(&bool_ty, true)),
logical_and_expr);
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
b.GenerateLabel(b.next_id());
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 10u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 10u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool
%3 = OpConstantTrue %2
%8 = OpConstantFalse %2
@@ -918,24 +740,24 @@
// From: crbug.com/tint/355
auto* logical_or_expr = create<ast::BinaryExpression>(
- Source{}, ast::BinaryOp::kLogicalOr,
+ ast::BinaryOp::kLogicalOr,
create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::BoolLiteral>(Source{}, &bool_ty, true)),
+ create<ast::BoolLiteral>(&bool_ty, true)),
create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::BoolLiteral>(Source{}, &bool_ty, false)));
+ create<ast::BoolLiteral>(&bool_ty, false)));
- ast::BinaryExpression expr(
- Source{}, ast::BinaryOp::kLogicalAnd,
+ auto* expr = create<ast::BinaryExpression>(
+ ast::BinaryOp::kLogicalAnd,
create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::BoolLiteral>(Source{}, &bool_ty, true)),
+ create<ast::BoolLiteral>(&bool_ty, true)),
logical_or_expr);
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
b.GenerateLabel(b.next_id());
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 10u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 10u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool
%3 = OpConstantTrue %2
%8 = OpConstantFalse %2
@@ -958,30 +780,21 @@
}
TEST_F(BuilderTest, Binary_LogicalOr) {
- ast::type::I32 i32;
+ auto* lhs =
+ create<ast::BinaryExpression>(ast::BinaryOp::kEqual, Expr(1), Expr(2));
- auto* lhs = create<ast::BinaryExpression>(
- Source{}, ast::BinaryOp::kEqual,
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 1)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 2)));
+ auto* rhs =
+ create<ast::BinaryExpression>(ast::BinaryOp::kEqual, Expr(3), Expr(4));
- auto* rhs = create<ast::BinaryExpression>(
- Source{}, ast::BinaryOp::kEqual,
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 3)),
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::SintLiteral>(Source{}, &i32, 4)));
+ auto* expr =
+ create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, lhs, rhs);
- ast::BinaryExpression expr(Source{}, ast::BinaryOp::kLogicalOr, lhs, rhs);
-
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
b.GenerateLabel(b.next_id());
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 12u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 12u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
%3 = OpConstant %2 1
%4 = OpConstant %2 2
@@ -1013,10 +826,10 @@
td.RegisterVariableForTesting(a_var);
td.RegisterVariableForTesting(b_var);
- ast::BinaryExpression expr(Source{}, ast::BinaryOp::kLogicalOr, Expr("a"),
- Expr("b"));
+ auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
+ Expr("a"), Expr("b"));
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
b.GenerateLabel(b.next_id());
@@ -1024,7 +837,7 @@
ASSERT_TRUE(b.GenerateGlobalVariable(a_var)) << b.error();
ASSERT_TRUE(b.GenerateGlobalVariable(b_var)) << b.error();
- EXPECT_EQ(b.GenerateBinaryExpression(&expr), 12u) << b.error();
+ EXPECT_EQ(b.GenerateBinaryExpression(expr), 12u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool
%3 = OpConstantTrue %2
%5 = OpTypePointer Function %2
diff --git a/src/writer/spirv/builder_bitcast_expression_test.cc b/src/writer/spirv/builder_bitcast_expression_test.cc
index cb75092..ee068dc 100644
--- a/src/writer/spirv/builder_bitcast_expression_test.cc
+++ b/src/writer/spirv/builder_bitcast_expression_test.cc
@@ -32,18 +32,12 @@
using BuilderTest = TestHelper;
TEST_F(BuilderTest, Bitcast) {
- ast::type::U32 u32;
- ast::type::F32 f32;
+ auto* bitcast = create<ast::BitcastExpression>(ty.u32, Expr(2.4f));
- ast::BitcastExpression bitcast(
- Source{}, &u32,
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 2.4)));
-
- ASSERT_TRUE(td.DetermineResultType(&bitcast)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(bitcast)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateBitcastExpression(&bitcast), 1u);
+ EXPECT_EQ(b.GenerateBitcastExpression(bitcast), 1u);
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 0
%3 = OpTypeFloat 32
@@ -57,15 +51,12 @@
TEST_F(BuilderTest, Bitcast_DuplicateType) {
ast::type::F32 f32;
- ast::BitcastExpression bitcast(
- Source{}, &f32,
- create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::FloatLiteral>(Source{}, &f32, 2.4)));
+ auto* bitcast = create<ast::BitcastExpression>(ty.f32, Expr(2.4f));
- ASSERT_TRUE(td.DetermineResultType(&bitcast)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(bitcast)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateBitcastExpression(&bitcast), 1u);
+ EXPECT_EQ(b.GenerateBitcastExpression(bitcast), 1u);
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32
%3 = OpConstant %2 2.4000001
diff --git a/src/writer/spirv/builder_block_test.cc b/src/writer/spirv/builder_block_test.cc
index e3dc0a1..fe77612 100644
--- a/src/writer/spirv/builder_block_test.cc
+++ b/src/writer/spirv/builder_block_test.cc
@@ -39,27 +39,22 @@
// Note, this test uses shadow variables which aren't allowed in WGSL but
// serves to prove the block code is pushing new scopes as needed.
- auto* inner = create<ast::BlockStatement>(
- Source{},
- ast::StatementList{
- create<ast::VariableDeclStatement>(
- Source{}, Var("var", ast::StorageClass::kFunction, ty.f32)),
- create<ast::AssignmentStatement>(Source{}, Expr("var"), Expr(2.f))});
- ast::BlockStatement outer(
- Source{},
- ast::StatementList{
- create<ast::VariableDeclStatement>(
- Source{}, Var("var", ast::StorageClass::kFunction, ty.f32)),
- create<ast::AssignmentStatement>(Source{}, Expr("var"), Expr(1.f)),
- inner,
- create<ast::AssignmentStatement>(Source{}, Expr("var"), Expr(3.f))});
+ auto* inner = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::VariableDeclStatement>(
+ Var("var", ast::StorageClass::kFunction, ty.f32)),
+ create<ast::AssignmentStatement>(Expr("var"), Expr(2.f))});
+ auto* outer = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::VariableDeclStatement>(
+ Var("var", ast::StorageClass::kFunction, ty.f32)),
+ create<ast::AssignmentStatement>(Expr("var"), Expr(1.f)), inner,
+ create<ast::AssignmentStatement>(Expr("var"), Expr(3.f))});
- ASSERT_TRUE(td.DetermineResultType(&outer)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(outer)) << td.error();
b.push_function(Function{});
ASSERT_FALSE(b.has_error()) << b.error();
- EXPECT_TRUE(b.GenerateStatement(&outer)) << b.error();
+ EXPECT_TRUE(b.GenerateStatement(outer)) << b.error();
EXPECT_FALSE(b.has_error());
EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeFloat 32
diff --git a/src/writer/spirv/builder_call_test.cc b/src/writer/spirv/builder_call_test.cc
index 23de1ae..4788081 100644
--- a/src/writer/spirv/builder_call_test.cc
+++ b/src/writer/spirv/builder_call_test.cc
@@ -47,10 +47,10 @@
func_params.push_back(Var("a", ast::StorageClass::kFunction, ty.f32));
func_params.push_back(Var("b", ast::StorageClass::kFunction, ty.f32));
- auto* a_func = Func(
- "a_func", func_params, ty.f32,
- ast::StatementList{create<ast::ReturnStatement>(Source{}, Add("a", "b"))},
- ast::FunctionDecorationList{});
+ auto* a_func =
+ Func("a_func", func_params, ty.f32,
+ ast::StatementList{create<ast::ReturnStatement>(Add("a", "b"))},
+ ast::FunctionDecorationList{});
auto* func = Func("main", {}, ty.void_, ast::StatementList{},
ast::FunctionDecorationList{});
@@ -95,24 +95,24 @@
func_params.push_back(Var("a", ast::StorageClass::kFunction, ty.f32));
func_params.push_back(Var("b", ast::StorageClass::kFunction, ty.f32));
- auto* a_func = Func(
- "a_func", func_params, ty.void_,
- ast::StatementList{create<ast::ReturnStatement>(Source{}, Add("a", "b"))},
- ast::FunctionDecorationList{});
+ auto* a_func =
+ Func("a_func", func_params, ty.void_,
+ ast::StatementList{create<ast::ReturnStatement>(Add("a", "b"))},
+ ast::FunctionDecorationList{});
auto* func = Func("main", {}, ty.void_, ast::StatementList{},
ast::FunctionDecorationList{});
- ast::CallStatement expr(Source{}, Call("a_func", 1.f, 1.f));
+ auto* expr = create<ast::CallStatement>(Call("a_func", 1.f, 1.f));
ASSERT_TRUE(td.DetermineFunction(func)) << td.error();
ASSERT_TRUE(td.DetermineFunction(a_func)) << td.error();
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
ASSERT_TRUE(b.GenerateFunction(a_func)) << b.error();
ASSERT_TRUE(b.GenerateFunction(func)) << b.error();
- EXPECT_TRUE(b.GenerateStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateStatement(expr)) << b.error();
EXPECT_EQ(DumpBuilder(b), R"(OpName %4 "a_func"
OpName %5 "a"
OpName %6 "b"
diff --git a/src/writer/spirv/builder_constructor_expression_test.cc b/src/writer/spirv/builder_constructor_expression_test.cc
index b544ea4..02c8c75 100644
--- a/src/writer/spirv/builder_constructor_expression_test.cc
+++ b/src/writer/spirv/builder_constructor_expression_test.cc
@@ -115,12 +115,12 @@
// cast<Int>(2.3f)
auto* alias = ty.alias("Int", ty.i32);
- ast::TypeConstructorExpression cast(Source{}, alias, ExprList(2.3f));
+ auto* cast = create<ast::TypeConstructorExpression>(alias, ExprList(2.3f));
- ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(cast)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateExpression(&cast), 1u);
+ EXPECT_EQ(b.GenerateExpression(cast), 1u);
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
%3 = OpTypeFloat 32
@@ -184,8 +184,8 @@
}
TEST_F(SpvBuilderConstructorTest, Type_NonConst_Value_Fails) {
- auto* rel = create<ast::BinaryExpression>(Source{}, ast::BinaryOp::kAdd,
- Expr(3.0f), Expr(3.0f));
+ auto* rel = create<ast::BinaryExpression>(ast::BinaryOp::kAdd, Expr(3.0f),
+ Expr(3.0f));
auto* t = vec2<f32>(1.0f, rel);
@@ -197,13 +197,13 @@
}
TEST_F(SpvBuilderConstructorTest, Type_Bool_With_Bool) {
- ast::TypeConstructorExpression cast(Source{}, ty.bool_, ExprList(true));
+ auto* cast = create<ast::TypeConstructorExpression>(ty.bool_, ExprList(true));
- ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(cast)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateExpression(&cast), 3u);
+ EXPECT_EQ(b.GenerateExpression(cast), 3u);
ASSERT_FALSE(b.has_error()) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool
@@ -213,12 +213,12 @@
}
TEST_F(SpvBuilderConstructorTest, Type_I32_With_I32) {
- ast::TypeConstructorExpression cast(Source{}, ty.i32, ExprList(2));
+ auto* cast = create<ast::TypeConstructorExpression>(ty.i32, ExprList(2));
- ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(cast)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateExpression(&cast), 3u);
+ EXPECT_EQ(b.GenerateExpression(cast), 3u);
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
%3 = OpConstant %2 2
@@ -227,12 +227,12 @@
}
TEST_F(SpvBuilderConstructorTest, Type_U32_With_U32) {
- ast::TypeConstructorExpression cast(Source{}, ty.u32, ExprList(2u));
+ auto* cast = create<ast::TypeConstructorExpression>(ty.u32, ExprList(2u));
- ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(cast)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateExpression(&cast), 3u);
+ EXPECT_EQ(b.GenerateExpression(cast), 3u);
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 0
%3 = OpConstant %2 2
@@ -241,12 +241,12 @@
}
TEST_F(SpvBuilderConstructorTest, Type_F32_With_F32) {
- ast::TypeConstructorExpression cast(Source{}, ty.f32, ExprList(2.0f));
+ auto* cast = create<ast::TypeConstructorExpression>(ty.f32, ExprList(2.0f));
- ASSERT_TRUE(td.DetermineResultType(&cast)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(cast)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateExpression(&cast), 3u);
+ EXPECT_EQ(b.GenerateExpression(cast), 3u);
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32
%3 = OpConstant %2 2
diff --git a/src/writer/spirv/builder_discard_test.cc b/src/writer/spirv/builder_discard_test.cc
index 6b3796a..6031a4c 100644
--- a/src/writer/spirv/builder_discard_test.cc
+++ b/src/writer/spirv/builder_discard_test.cc
@@ -27,10 +27,10 @@
using BuilderTest = TestHelper;
TEST_F(BuilderTest, Discard) {
- ast::DiscardStatement expr(Source{});
+ auto* expr = create<ast::DiscardStatement>();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateStatement(&expr), 1u) << b.error();
+ EXPECT_EQ(b.GenerateStatement(expr), 1u) << b.error();
EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpKill
)");
}
diff --git a/src/writer/spirv/builder_function_decoration_test.cc b/src/writer/spirv/builder_function_decoration_test.cc
index 00b64a5..d3b50fa 100644
--- a/src/writer/spirv/builder_function_decoration_test.cc
+++ b/src/writer/spirv/builder_function_decoration_test.cc
@@ -39,11 +39,11 @@
using BuilderTest = TestHelper;
TEST_F(BuilderTest, FunctionDecoration_Stage) {
- auto* func = Func(
- "main", {}, ty.void_, ast::StatementList{},
- ast::FunctionDecorationList{
- create<ast::StageDecoration>(Source{}, ast::PipelineStage::kVertex),
- });
+ auto* func =
+ Func("main", {}, ty.void_, ast::StatementList{},
+ ast::FunctionDecorationList{
+ create<ast::StageDecoration>(ast::PipelineStage::kVertex),
+ });
ASSERT_TRUE(b.GenerateFunction(func)) << b.error();
EXPECT_EQ(DumpInstructions(b.entry_points()),
@@ -65,7 +65,7 @@
auto* func = Func("main", {}, ty.void_, ast::StatementList{},
ast::FunctionDecorationList{
- create<ast::StageDecoration>(Source{}, params.stage),
+ create<ast::StageDecoration>(params.stage),
});
ASSERT_TRUE(b.GenerateFunction(func)) << b.error();
@@ -91,11 +91,11 @@
ast::type::F32 f32;
ast::type::Void void_type;
- auto* func = Func(
- "main", {}, ty.void_, ast::StatementList{},
- ast::FunctionDecorationList{
- create<ast::StageDecoration>(Source{}, ast::PipelineStage::kVertex),
- });
+ auto* func =
+ Func("main", {}, ty.void_, ast::StatementList{},
+ ast::FunctionDecorationList{
+ create<ast::StageDecoration>(ast::PipelineStage::kVertex),
+ });
auto* v_in = Var("my_in", ast::StorageClass::kInput, ty.f32);
auto* v_out = Var("my_out", ast::StorageClass::kOutput, ty.f32);
@@ -132,19 +132,17 @@
}
TEST_F(BuilderTest, FunctionDecoration_Stage_WithUsedInterfaceIds) {
- auto* func = Func(
- "main", {}, ty.void_,
- ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("my_out"), Expr("my_in")),
- create<ast::AssignmentStatement>(
- Source{}, Expr("my_wg"), Expr("my_wg")),
- // Add duplicate usages so we show they don't get
- // output multiple times.
- create<ast::AssignmentStatement>(
- Source{}, Expr("my_out"), Expr("my_in"))},
- ast::FunctionDecorationList{
- create<ast::StageDecoration>(Source{}, ast::PipelineStage::kVertex),
- });
+ auto* func =
+ Func("main", {}, ty.void_,
+ ast::StatementList{
+ create<ast::AssignmentStatement>(Expr("my_out"), Expr("my_in")),
+ create<ast::AssignmentStatement>(Expr("my_wg"), Expr("my_wg")),
+ // Add duplicate usages so we show they don't get
+ // output multiple times.
+ create<ast::AssignmentStatement>(Expr("my_out"), Expr("my_in"))},
+ ast::FunctionDecorationList{
+ create<ast::StageDecoration>(ast::PipelineStage::kVertex),
+ });
auto* v_in = Var("my_in", ast::StorageClass::kInput, ty.f32);
auto* v_out = Var("my_out", ast::StorageClass::kOutput, ty.f32);
@@ -187,11 +185,11 @@
}
TEST_F(BuilderTest, FunctionDecoration_ExecutionMode_Fragment_OriginUpperLeft) {
- auto* func = Func(
- "main", {}, ty.void_, ast::StatementList{},
- ast::FunctionDecorationList{
- create<ast::StageDecoration>(Source{}, ast::PipelineStage::kFragment),
- });
+ auto* func =
+ Func("main", {}, ty.void_, ast::StatementList{},
+ ast::FunctionDecorationList{
+ create<ast::StageDecoration>(ast::PipelineStage::kFragment),
+ });
ASSERT_TRUE(b.GenerateExecutionModes(func, 3)) << b.error();
EXPECT_EQ(DumpInstructions(b.execution_modes()),
@@ -200,11 +198,11 @@
}
TEST_F(BuilderTest, FunctionDecoration_ExecutionMode_WorkgroupSize_Default) {
- auto* func = Func(
- "main", {}, ty.void_, ast::StatementList{},
- ast::FunctionDecorationList{
- create<ast::StageDecoration>(Source{}, ast::PipelineStage::kCompute),
- });
+ auto* func =
+ Func("main", {}, ty.void_, ast::StatementList{},
+ ast::FunctionDecorationList{
+ create<ast::StageDecoration>(ast::PipelineStage::kCompute),
+ });
ASSERT_TRUE(b.GenerateExecutionModes(func, 3)) << b.error();
EXPECT_EQ(DumpInstructions(b.execution_modes()),
@@ -213,12 +211,12 @@
}
TEST_F(BuilderTest, FunctionDecoration_ExecutionMode_WorkgroupSize) {
- auto* func = Func(
- "main", {}, ty.void_, ast::StatementList{},
- ast::FunctionDecorationList{
- create<ast::WorkgroupDecoration>(Source{}, 2u, 4u, 6u),
- create<ast::StageDecoration>(Source{}, ast::PipelineStage::kCompute),
- });
+ auto* func =
+ Func("main", {}, ty.void_, ast::StatementList{},
+ ast::FunctionDecorationList{
+ create<ast::WorkgroupDecoration>(2u, 4u, 6u),
+ create<ast::StageDecoration>(ast::PipelineStage::kCompute),
+ });
ASSERT_TRUE(b.GenerateExecutionModes(func, 3)) << b.error();
EXPECT_EQ(DumpInstructions(b.execution_modes()),
@@ -227,17 +225,17 @@
}
TEST_F(BuilderTest, FunctionDecoration_ExecutionMode_MultipleFragment) {
- auto* func1 = Func(
- "main1", {}, ty.void_, ast::StatementList{},
- ast::FunctionDecorationList{
- create<ast::StageDecoration>(Source{}, ast::PipelineStage::kFragment),
- });
+ auto* func1 =
+ Func("main1", {}, ty.void_, ast::StatementList{},
+ ast::FunctionDecorationList{
+ create<ast::StageDecoration>(ast::PipelineStage::kFragment),
+ });
- auto* func2 = Func(
- "main2", {}, ty.void_, ast::StatementList{},
- ast::FunctionDecorationList{
- create<ast::StageDecoration>(Source{}, ast::PipelineStage::kFragment),
- });
+ auto* func2 =
+ Func("main2", {}, ty.void_, ast::StatementList{},
+ ast::FunctionDecorationList{
+ create<ast::StageDecoration>(ast::PipelineStage::kFragment),
+ });
ASSERT_TRUE(b.GenerateFunction(func1)) << b.error();
ASSERT_TRUE(b.GenerateFunction(func2)) << b.error();
diff --git a/src/writer/spirv/builder_function_test.cc b/src/writer/spirv/builder_function_test.cc
index 797dcac..a50017b 100644
--- a/src/writer/spirv/builder_function_test.cc
+++ b/src/writer/spirv/builder_function_test.cc
@@ -63,7 +63,7 @@
TEST_F(BuilderTest, Function_Terminator_Return) {
auto* func = Func("a_func", {}, ty.void_,
ast::StatementList{
- create<ast::ReturnStatement>(Source{}),
+ create<ast::ReturnStatement>(),
},
ast::FunctionDecorationList{});
@@ -108,7 +108,7 @@
TEST_F(BuilderTest, Function_Terminator_Discard) {
auto* func = Func("a_func", {}, ty.void_,
ast::StatementList{
- create<ast::DiscardStatement>(Source{}),
+ create<ast::DiscardStatement>(),
},
ast::FunctionDecorationList{});
@@ -155,7 +155,7 @@
TEST_F(BuilderTest, Function_WithBody) {
auto* func = Func("a_func", {}, ty.void_,
ast::StatementList{
- create<ast::ReturnStatement>(Source{}),
+ create<ast::ReturnStatement>(),
},
ast::FunctionDecorationList{});
@@ -211,7 +211,7 @@
// }
ast::StructDecorationList s_decos;
- s_decos.push_back(create<ast::StructBlockDecoration>(Source{}));
+ s_decos.push_back(create<ast::StructBlockDecoration>());
auto* str = create<ast::Struct>(
ast::StructMemberList{Member("d", ty.f32, {MemberOffset(0)})}, s_decos);
@@ -221,8 +221,8 @@
auto* data_var = Var("data", ast::StorageClass::kStorageBuffer, &ac, nullptr,
ast::VariableDecorationList{
- create<ast::BindingDecoration>(Source{}, 0),
- create<ast::SetDecoration>(Source{}, 0),
+ create<ast::BindingDecoration>(0),
+ create<ast::SetDecoration>(0),
});
mod->AddConstructedType(s);
@@ -234,15 +234,15 @@
auto* var = Var("v", ast::StorageClass::kFunction, ty.f32,
MemberAccessor("data", "d"), ast::VariableDecorationList{});
- auto* func = Func("a", ast::VariableList{}, ty.void_,
- ast::StatementList{
- create<ast::VariableDeclStatement>(Source{}, var),
- create<ast::ReturnStatement>(Source{}),
- },
- ast::FunctionDecorationList{
- create<ast::StageDecoration>(
- Source{}, ast::PipelineStage::kCompute),
- });
+ auto* func =
+ Func("a", ast::VariableList{}, ty.void_,
+ ast::StatementList{
+ create<ast::VariableDeclStatement>(var),
+ create<ast::ReturnStatement>(),
+ },
+ ast::FunctionDecorationList{
+ create<ast::StageDecoration>(ast::PipelineStage::kCompute),
+ });
mod->AddFunction(func);
}
@@ -251,15 +251,15 @@
auto* var = Var("v", ast::StorageClass::kFunction, ty.f32,
MemberAccessor("data", "d"), ast::VariableDecorationList{});
- auto* func = Func("b", ast::VariableList{}, ty.void_,
- ast::StatementList{
- create<ast::VariableDeclStatement>(Source{}, var),
- create<ast::ReturnStatement>(Source{}),
- },
- ast::FunctionDecorationList{
- create<ast::StageDecoration>(
- Source{}, ast::PipelineStage::kCompute),
- });
+ auto* func =
+ Func("b", ast::VariableList{}, ty.void_,
+ ast::StatementList{
+ create<ast::VariableDeclStatement>(var),
+ create<ast::ReturnStatement>(),
+ },
+ ast::FunctionDecorationList{
+ create<ast::StageDecoration>(ast::PipelineStage::kCompute),
+ });
mod->AddFunction(func);
}
diff --git a/src/writer/spirv/builder_function_variable_test.cc b/src/writer/spirv/builder_function_variable_test.cc
index 1fa6cae..ee02aea 100644
--- a/src/writer/spirv/builder_function_variable_test.cc
+++ b/src/writer/spirv/builder_function_variable_test.cc
@@ -64,8 +64,7 @@
TEST_F(BuilderTest, FunctionVar_WithConstantConstructor) {
auto* init = create<ast::TypeConstructorExpression>(
- Source{}, ty.vec3<f32>(),
- ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(3.f)});
+ ty.vec3<f32>(), ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(3.f)});
EXPECT_TRUE(td.DetermineResultType(init)) << td.error();
auto* v = Var("var", ast::StorageClass::kOutput, ty.f32, init,
@@ -95,7 +94,7 @@
TEST_F(BuilderTest, FunctionVar_WithNonConstantConstructor) {
auto* init = create<ast::TypeConstructorExpression>(
- Source{}, ty.vec2<f32>(), ast::ExpressionList{Expr(1.f), Add(3.f, 3.f)});
+ ty.vec2<f32>(), ast::ExpressionList{Expr(1.f), Add(3.f, 3.f)});
EXPECT_TRUE(td.DetermineResultType(init)) << td.error();
auto* v = Var("var", ast::StorageClass::kFunction, ty.vec2<f32>(), init,
@@ -205,8 +204,7 @@
TEST_F(BuilderTest, FunctionVar_Const) {
auto* init = create<ast::TypeConstructorExpression>(
- Source{}, ty.vec3<f32>(),
- ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(3.f)});
+ ty.vec3<f32>(), ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(3.f)});
EXPECT_TRUE(td.DetermineResultType(init)) << td.error();
auto* v = Const("var", ast::StorageClass::kOutput, ty.f32, init,
diff --git a/src/writer/spirv/builder_global_variable_test.cc b/src/writer/spirv/builder_global_variable_test.cc
index 8675194..2543a3a 100644
--- a/src/writer/spirv/builder_global_variable_test.cc
+++ b/src/writer/spirv/builder_global_variable_test.cc
@@ -86,8 +86,7 @@
TEST_F(BuilderTest, GlobalVar_WithConstructor) {
auto* init = create<ast::TypeConstructorExpression>(
- Source{}, ty.vec3<f32>(),
- ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(3.f)});
+ ty.vec3<f32>(), ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(3.f)});
EXPECT_TRUE(td.DetermineResultType(init)) << td.error();
auto* v = Var("var", ast::StorageClass::kOutput, ty.f32, init,
@@ -111,8 +110,7 @@
TEST_F(BuilderTest, GlobalVar_Const) {
auto* init = create<ast::TypeConstructorExpression>(
- Source{}, ty.vec3<f32>(),
- ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(3.f)});
+ ty.vec3<f32>(), ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(3.f)});
EXPECT_TRUE(td.DetermineResultType(init)) << td.error();
auto* v = Const("var", ast::StorageClass::kOutput, ty.f32, init,
@@ -134,8 +132,7 @@
TEST_F(BuilderTest, GlobalVar_Complex_Constructor) {
auto* init = create<ast::TypeConstructorExpression>(
- Source{}, ty.vec3<f32>(),
- ast::ExpressionList{Expr(1.f), Expr(2.f), Expr(3.f)});
+ ty.vec3<f32>(), ast::ExpressionList{Expr(1.f), Expr(2.f), Expr(3.f)});
EXPECT_TRUE(td.DetermineResultType(init)) << td.error();
auto* v = Const("var", ast::StorageClass::kOutput, ty.f32, init,
@@ -156,10 +153,10 @@
TEST_F(BuilderTest, GlobalVar_Complex_ConstructorWithExtract) {
auto* first = create<ast::TypeConstructorExpression>(
- Source{}, ty.vec2<f32>(), ast::ExpressionList{Expr(1.f), Expr(2.f)});
+ ty.vec2<f32>(), ast::ExpressionList{Expr(1.f), Expr(2.f)});
auto* init = create<ast::TypeConstructorExpression>(
- Source{}, ty.vec3<f32>(), ast::ExpressionList{first, Expr(3.f)});
+ ty.vec3<f32>(), ast::ExpressionList{first, Expr(3.f)});
EXPECT_TRUE(td.DetermineResultType(init)) << td.error();
@@ -189,7 +186,7 @@
TEST_F(BuilderTest, GlobalVar_WithLocation) {
auto* v = Var("var", ast::StorageClass::kOutput, ty.f32, nullptr,
ast::VariableDecorationList{
- create<ast::LocationDecoration>(Source{}, 5),
+ create<ast::LocationDecoration>(5),
});
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
@@ -207,8 +204,8 @@
TEST_F(BuilderTest, GlobalVar_WithBindingAndSet) {
auto* v = Var("var", ast::StorageClass::kOutput, ty.f32, nullptr,
ast::VariableDecorationList{
- create<ast::BindingDecoration>(Source{}, 2),
- create<ast::SetDecoration>(Source{}, 3),
+ create<ast::BindingDecoration>(2),
+ create<ast::SetDecoration>(3),
});
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
@@ -225,11 +222,10 @@
}
TEST_F(BuilderTest, GlobalVar_WithBuiltin) {
- auto* v =
- Var("var", ast::StorageClass::kOutput, ty.f32, nullptr,
- ast::VariableDecorationList{
- create<ast::BuiltinDecoration>(Source{}, ast::Builtin::kPosition),
- });
+ auto* v = Var("var", ast::StorageClass::kOutput, ty.f32, nullptr,
+ ast::VariableDecorationList{
+ create<ast::BuiltinDecoration>(ast::Builtin::kPosition),
+ });
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %1 "var"
@@ -246,7 +242,7 @@
TEST_F(BuilderTest, GlobalVar_ConstantId_Bool) {
auto* v = Var("var", ast::StorageClass::kNone, ty.bool_, Expr(true),
ast::VariableDecorationList{
- create<ast::ConstantIdDecoration>(Source{}, 1200),
+ create<ast::ConstantIdDecoration>(1200),
});
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
@@ -264,7 +260,7 @@
TEST_F(BuilderTest, GlobalVar_ConstantId_Bool_NoConstructor) {
auto* v = Var("var", ast::StorageClass::kNone, ty.bool_, nullptr,
ast::VariableDecorationList{
- create<ast::ConstantIdDecoration>(Source{}, 1200),
+ create<ast::ConstantIdDecoration>(1200),
});
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
@@ -282,7 +278,7 @@
TEST_F(BuilderTest, GlobalVar_ConstantId_Scalar) {
auto* v = Var("var", ast::StorageClass::kNone, ty.f32, Expr(2.f),
ast::VariableDecorationList{
- create<ast::ConstantIdDecoration>(Source{}, 0),
+ create<ast::ConstantIdDecoration>(0),
});
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
@@ -300,7 +296,7 @@
TEST_F(BuilderTest, GlobalVar_ConstantId_Scalar_F32_NoConstructor) {
auto* v = Var("var", ast::StorageClass::kNone, ty.f32, nullptr,
ast::VariableDecorationList{
- create<ast::ConstantIdDecoration>(Source{}, 0),
+ create<ast::ConstantIdDecoration>(0),
});
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
@@ -318,7 +314,7 @@
TEST_F(BuilderTest, GlobalVar_ConstantId_Scalar_I32_NoConstructor) {
auto* v = Var("var", ast::StorageClass::kNone, ty.i32, nullptr,
ast::VariableDecorationList{
- create<ast::ConstantIdDecoration>(Source{}, 0),
+ create<ast::ConstantIdDecoration>(0),
});
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
@@ -336,7 +332,7 @@
TEST_F(BuilderTest, GlobalVar_ConstantId_Scalar_U32_NoConstructor) {
auto* v = Var("var", ast::StorageClass::kNone, ty.u32, nullptr,
ast::VariableDecorationList{
- create<ast::ConstantIdDecoration>(Source{}, 0),
+ create<ast::ConstantIdDecoration>(0),
});
EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.error();
diff --git a/src/writer/spirv/builder_ident_expression_test.cc b/src/writer/spirv/builder_ident_expression_test.cc
index a5f6dbf..c06fb70 100644
--- a/src/writer/spirv/builder_ident_expression_test.cc
+++ b/src/writer/spirv/builder_ident_expression_test.cc
@@ -39,8 +39,7 @@
TEST_F(BuilderTest, IdentifierExpression_GlobalConst) {
auto* init = create<ast::TypeConstructorExpression>(
- Source{}, ty.vec3<f32>(),
- ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(3.f)});
+ ty.vec3<f32>(), ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(3.f)});
EXPECT_TRUE(td.DetermineResultType(init)) << td.error();
auto* v = Const("var", ast::StorageClass::kOutput, ty.f32, init,
@@ -83,8 +82,7 @@
TEST_F(BuilderTest, IdentifierExpression_FunctionConst) {
auto* init = create<ast::TypeConstructorExpression>(
- Source{}, ty.vec3<f32>(),
- ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(3.f)});
+ ty.vec3<f32>(), ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(3.f)});
EXPECT_TRUE(td.DetermineResultType(init)) << td.error();
auto* v = Const("var", ast::StorageClass::kOutput, ty.f32, init,
diff --git a/src/writer/spirv/builder_if_test.cc b/src/writer/spirv/builder_if_test.cc
index a759428..966c082 100644
--- a/src/writer/spirv/builder_if_test.cc
+++ b/src/writer/spirv/builder_if_test.cc
@@ -46,18 +46,17 @@
// if (true) {
// }
auto* cond = create<ast::ScalarConstructorExpression>(
- Source{}, create<ast::BoolLiteral>(Source{}, &bool_type, true));
+ create<ast::BoolLiteral>(&bool_type, true));
- ast::IfStatement expr(
- Source{}, cond,
- create<ast::BlockStatement>(Source{}, ast::StatementList{}),
+ auto* expr = create<ast::IfStatement>(
+ cond, create<ast::BlockStatement>(ast::StatementList{}),
ast::ElseStatementList{});
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_TRUE(b.GenerateIfStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateIfStatement(expr)) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeBool
%2 = OpConstantTrue %1
)");
@@ -80,12 +79,12 @@
create<ast::BoolLiteral>(&bool_type, true));
ast::ElseStatementList elses;
- auto* block = create<ast::BlockStatement>(Source{}, ast::StatementList{});
- ast::IfStatement expr(Source{}, cond, block, elses);
+ auto* block = create<ast::BlockStatement>(ast::StatementList{});
+ auto* expr = create<ast::IfStatement>(cond, block, elses);
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
- EXPECT_FALSE(b.GenerateIfStatement(&expr)) << b.error();
+ EXPECT_FALSE(b.GenerateIfStatement(expr)) << b.error();
EXPECT_TRUE(b.has_error());
EXPECT_EQ(b.error(),
"Internal error: trying to add SPIR-V instruction 247 outside a "
@@ -99,17 +98,17 @@
auto* var = Var("v", ast::StorageClass::kPrivate, ty.i32);
auto* body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(2))});
- ast::IfStatement expr(Source{}, Expr(true), body, ast::ElseStatementList{});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(2))});
+ auto* expr =
+ create<ast::IfStatement>(Expr(true), body, ast::ElseStatementList{});
td.RegisterVariableForTesting(var);
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
ASSERT_TRUE(b.GenerateGlobalVariable(var)) << b.error();
- EXPECT_TRUE(b.GenerateIfStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateIfStatement(expr)) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeInt 32 1
%2 = OpTypePointer Private %3
%4 = OpConstantNull %3
@@ -137,24 +136,22 @@
auto* var = Var("v", ast::StorageClass::kPrivate, ty.i32);
auto* body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(2))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(2))});
auto* else_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(3))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(3))});
- ast::IfStatement expr(
- Source{}, Expr(true), body,
- {create<ast::ElseStatement>(Source{}, nullptr, else_body)});
+ auto* expr = create<ast::IfStatement>(
+ Expr(true), body,
+ ast::ElseStatementList{create<ast::ElseStatement>(nullptr, else_body)});
td.RegisterVariableForTesting(var);
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
ASSERT_TRUE(b.GenerateGlobalVariable(var)) << b.error();
- EXPECT_TRUE(b.GenerateIfStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateIfStatement(expr)) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeInt 32 1
%2 = OpTypePointer Private %3
%4 = OpConstantNull %3
@@ -186,24 +183,24 @@
auto* var = Var("v", ast::StorageClass::kPrivate, ty.i32);
auto* body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(2))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(2))});
auto* else_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(3))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(3))});
- ast::IfStatement expr(
- Source{}, Expr(true), body,
- {create<ast::ElseStatement>(Source{}, Expr(true), else_body)});
+ auto* expr = create<ast::IfStatement>(
+ Expr(true), body,
+ ast::ElseStatementList{
+ create<ast::ElseStatement>(Expr(true), else_body),
+ });
td.RegisterVariableForTesting(var);
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
ASSERT_TRUE(b.GenerateGlobalVariable(var)) << b.error();
- EXPECT_TRUE(b.GenerateIfStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateIfStatement(expr)) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeInt 32 1
%2 = OpTypePointer Private %3
%4 = OpConstantNull %3
@@ -244,34 +241,30 @@
auto* var = Var("v", ast::StorageClass::kPrivate, ty.i32);
auto* body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(2))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(2))});
auto* elseif_1_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(3))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(3))});
auto* elseif_2_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(4))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(4))});
auto* else_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(5))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(5))});
- ast::IfStatement expr(
- Source{}, Expr(true), body,
- {
- create<ast::ElseStatement>(Source{}, Expr(true), elseif_1_body),
- create<ast::ElseStatement>(Source{}, Expr(false), elseif_2_body),
- create<ast::ElseStatement>(Source{}, nullptr, else_body),
+ auto* expr = create<ast::IfStatement>(
+ Expr(true), body,
+ ast::ElseStatementList{
+ create<ast::ElseStatement>(Expr(true), elseif_1_body),
+ create<ast::ElseStatement>(Expr(false), elseif_2_body),
+ create<ast::ElseStatement>(nullptr, else_body),
});
td.RegisterVariableForTesting(var);
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
ASSERT_TRUE(b.GenerateGlobalVariable(var)) << b.error();
- EXPECT_TRUE(b.GenerateIfStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateIfStatement(expr)) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeInt 32 1
%2 = OpTypePointer Private %3
%4 = OpConstantNull %3
@@ -320,27 +313,25 @@
// }
// }
- auto* if_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{
- create<ast::BreakStatement>(Source{}),
- });
+ auto* if_body = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::BreakStatement>(),
+ });
- auto* if_stmt = create<ast::IfStatement>(Source{}, Expr(true), if_body,
- ast::ElseStatementList{});
+ auto* if_stmt =
+ create<ast::IfStatement>(Expr(true), if_body, ast::ElseStatementList{});
- auto* loop_body = create<ast::BlockStatement>(Source{}, ast::StatementList{
- if_stmt,
- });
+ auto* loop_body = create<ast::BlockStatement>(ast::StatementList{
+ if_stmt,
+ });
- ast::LoopStatement expr(
- Source{}, loop_body,
- create<ast::BlockStatement>(Source{}, ast::StatementList{}));
+ auto* expr = create<ast::LoopStatement>(
+ loop_body, create<ast::BlockStatement>(ast::StatementList{}));
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_TRUE(b.GenerateLoopStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateLoopStatement(expr)) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%5 = OpTypeBool
%6 = OpConstantTrue %5
)");
@@ -369,30 +360,26 @@
// break;
// }
// }
- auto* else_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{
- create<ast::BreakStatement>(Source{}),
- });
+ auto* else_body = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::BreakStatement>(),
+ });
auto* if_stmt = create<ast::IfStatement>(
- Source{}, Expr(true),
- create<ast::BlockStatement>(Source{}, ast::StatementList{}),
- ast::ElseStatementList{
- create<ast::ElseStatement>(Source{}, nullptr, else_body)});
+ Expr(true), create<ast::BlockStatement>(ast::StatementList{}),
+ ast::ElseStatementList{create<ast::ElseStatement>(nullptr, else_body)});
- auto* loop_body = create<ast::BlockStatement>(Source{}, ast::StatementList{
- if_stmt,
- });
+ auto* loop_body = create<ast::BlockStatement>(ast::StatementList{
+ if_stmt,
+ });
- ast::LoopStatement expr(
- Source{}, loop_body,
- create<ast::BlockStatement>(Source{}, ast::StatementList{}));
+ auto* expr = create<ast::LoopStatement>(
+ loop_body, create<ast::BlockStatement>(ast::StatementList{}));
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_TRUE(b.GenerateLoopStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateLoopStatement(expr)) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%5 = OpTypeBool
%6 = OpConstantTrue %5
)");
@@ -422,27 +409,25 @@
// continue;
// }
// }
- auto* if_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{
- create<ast::ContinueStatement>(Source{}),
- });
+ auto* if_body = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::ContinueStatement>(),
+ });
- auto* if_stmt = create<ast::IfStatement>(Source{}, Expr(true), if_body,
- ast::ElseStatementList{});
+ auto* if_stmt =
+ create<ast::IfStatement>(Expr(true), if_body, ast::ElseStatementList{});
- auto* loop_body = create<ast::BlockStatement>(Source{}, ast::StatementList{
- if_stmt,
- });
+ auto* loop_body = create<ast::BlockStatement>(ast::StatementList{
+ if_stmt,
+ });
- ast::LoopStatement expr(
- Source{}, loop_body,
- create<ast::BlockStatement>(Source{}, ast::StatementList{}));
+ auto* expr = create<ast::LoopStatement>(
+ loop_body, create<ast::BlockStatement>(ast::StatementList{}));
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_TRUE(b.GenerateLoopStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateLoopStatement(expr)) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%5 = OpTypeBool
%6 = OpConstantTrue %5
)");
@@ -471,30 +456,26 @@
// continue;
// }
// }
- auto* else_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{
- create<ast::ContinueStatement>(Source{}),
- });
+ auto* else_body = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::ContinueStatement>(),
+ });
auto* if_stmt = create<ast::IfStatement>(
- Source{}, Expr(true),
- create<ast::BlockStatement>(Source{}, ast::StatementList{}),
- ast::ElseStatementList{
- create<ast::ElseStatement>(Source{}, nullptr, else_body)});
+ Expr(true), create<ast::BlockStatement>(ast::StatementList{}),
+ ast::ElseStatementList{create<ast::ElseStatement>(nullptr, else_body)});
- auto* loop_body = create<ast::BlockStatement>(Source{}, ast::StatementList{
- if_stmt,
- });
+ auto* loop_body = create<ast::BlockStatement>(ast::StatementList{
+ if_stmt,
+ });
- ast::LoopStatement expr(
- Source{}, loop_body,
- create<ast::BlockStatement>(Source{}, ast::StatementList{}));
+ auto* expr = create<ast::LoopStatement>(
+ loop_body, create<ast::BlockStatement>(ast::StatementList{}));
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_TRUE(b.GenerateLoopStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateLoopStatement(expr)) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%5 = OpTypeBool
%6 = OpConstantTrue %5
)");
@@ -522,18 +503,17 @@
// if (true) {
// return;
// }
- auto* if_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{
- create<ast::ReturnStatement>(Source{}),
- });
+ auto* if_body = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::ReturnStatement>(),
+ });
- ast::IfStatement expr(Source{}, Expr(true), if_body,
- ast::ElseStatementList{});
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ auto* expr =
+ create<ast::IfStatement>(Expr(true), if_body, ast::ElseStatementList{});
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_TRUE(b.GenerateIfStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateIfStatement(expr)) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeBool
%2 = OpConstantTrue %1
)");
@@ -550,18 +530,17 @@
// if (true) {
// return false;
// }
- auto* if_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{
- create<ast::ReturnStatement>(Source{}, Expr(false)),
- });
+ auto* if_body = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::ReturnStatement>(Expr(false)),
+ });
- ast::IfStatement expr(Source{}, Expr(true), if_body,
- ast::ElseStatementList{});
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ auto* expr =
+ create<ast::IfStatement>(Expr(true), if_body, ast::ElseStatementList{});
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_TRUE(b.GenerateIfStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateIfStatement(expr)) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeBool
%2 = OpConstantTrue %1
%5 = OpConstantFalse %1
@@ -583,17 +562,16 @@
auto* var = Var("a", ast::StorageClass::kFunction, ty.bool_);
td.RegisterVariableForTesting(var);
- ast::IfStatement expr(
- Source{}, Expr("a"),
- create<ast::BlockStatement>(Source{}, ast::StatementList{}),
+ auto* expr = create<ast::IfStatement>(
+ Expr("a"), create<ast::BlockStatement>(ast::StatementList{}),
ast::ElseStatementList{});
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
ASSERT_TRUE(b.GenerateGlobalVariable(var)) << b.error();
- EXPECT_TRUE(b.GenerateIfStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateIfStatement(expr)) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeBool
%2 = OpTypePointer Function %3
%1 = OpVariable %2 Function
diff --git a/src/writer/spirv/builder_intrinsic_texture_test.cc b/src/writer/spirv/builder_intrinsic_texture_test.cc
index f73ff56..a26bedd 100644
--- a/src/writer/spirv/builder_intrinsic_texture_test.cc
+++ b/src/writer/spirv/builder_intrinsic_texture_test.cc
@@ -2793,10 +2793,11 @@
ASSERT_TRUE(b.GenerateGlobalVariable(tex)) << b.error();
ASSERT_TRUE(b.GenerateGlobalVariable(sampler)) << b.error();
- ast::CallExpression call{Source{}, Expr(param.function), param.args(this)};
+ auto* call =
+ create<ast::CallExpression>(Expr(param.function), param.args(this));
- EXPECT_TRUE(td.DetermineResultType(&call)) << td.error();
- EXPECT_EQ(b.GenerateExpression(&call), 0u);
+ EXPECT_TRUE(td.DetermineResultType(call)) << td.error();
+ EXPECT_EQ(b.GenerateExpression(call), 0u);
EXPECT_THAT(b.error(),
::testing::StartsWith(
"Internal error: trying to add SPIR-V instruction "));
diff --git a/src/writer/spirv/builder_literal_test.cc b/src/writer/spirv/builder_literal_test.cc
index acecbde..b641b92 100644
--- a/src/writer/spirv/builder_literal_test.cc
+++ b/src/writer/spirv/builder_literal_test.cc
@@ -34,10 +34,9 @@
using BuilderTest = TestHelper;
TEST_F(BuilderTest, Literal_Bool_True) {
- ast::type::Bool bool_type;
- ast::BoolLiteral b_true(Source{}, &bool_type, true);
+ auto* b_true = create<ast::BoolLiteral>(ty.bool_, true);
- auto id = b.GenerateLiteralIfNeeded(nullptr, &b_true);
+ auto id = b.GenerateLiteralIfNeeded(nullptr, b_true);
ASSERT_FALSE(b.has_error()) << b.error();
EXPECT_EQ(2u, id);
@@ -47,10 +46,9 @@
}
TEST_F(BuilderTest, Literal_Bool_False) {
- ast::type::Bool bool_type;
- ast::BoolLiteral b_false(Source{}, &bool_type, false);
+ auto* b_false = create<ast::BoolLiteral>(ty.bool_, false);
- auto id = b.GenerateLiteralIfNeeded(nullptr, &b_false);
+ auto id = b.GenerateLiteralIfNeeded(nullptr, b_false);
ASSERT_FALSE(b.has_error()) << b.error();
EXPECT_EQ(2u, id);
@@ -60,15 +58,14 @@
}
TEST_F(BuilderTest, Literal_Bool_Dedup) {
- ast::type::Bool bool_type;
- ast::BoolLiteral b_true(Source{}, &bool_type, true);
- ast::BoolLiteral b_false(Source{}, &bool_type, false);
+ auto* b_true = create<ast::BoolLiteral>(ty.bool_, true);
+ auto* b_false = create<ast::BoolLiteral>(ty.bool_, false);
- ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &b_true), 0u);
+ ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, b_true), 0u);
ASSERT_FALSE(b.has_error()) << b.error();
- ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &b_false), 0u);
+ ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, b_false), 0u);
ASSERT_FALSE(b.has_error()) << b.error();
- ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &b_true), 0u);
+ ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, b_true), 0u);
ASSERT_FALSE(b.has_error()) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeBool
@@ -78,10 +75,9 @@
}
TEST_F(BuilderTest, Literal_I32) {
- ast::type::I32 i32;
- ast::SintLiteral i(Source{}, &i32, -23);
+ auto* i = create<ast::SintLiteral>(ty.i32, -23);
- auto id = b.GenerateLiteralIfNeeded(nullptr, &i);
+ auto id = b.GenerateLiteralIfNeeded(nullptr, i);
ASSERT_FALSE(b.has_error()) << b.error();
EXPECT_EQ(2u, id);
@@ -91,12 +87,11 @@
}
TEST_F(BuilderTest, Literal_I32_Dedup) {
- ast::type::I32 i32;
- ast::SintLiteral i1(Source{}, &i32, -23);
- ast::SintLiteral i2(Source{}, &i32, -23);
+ auto* i1 = create<ast::SintLiteral>(ty.i32, -23);
+ auto* i2 = create<ast::SintLiteral>(ty.i32, -23);
- ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i1), 0u);
- ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i2), 0u);
+ ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, i1), 0u);
+ ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, i2), 0u);
ASSERT_FALSE(b.has_error()) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 1
@@ -105,10 +100,9 @@
}
TEST_F(BuilderTest, Literal_U32) {
- ast::type::U32 u32;
- ast::UintLiteral i(Source{}, &u32, 23);
+ auto* i = create<ast::UintLiteral>(ty.u32, 23);
- auto id = b.GenerateLiteralIfNeeded(nullptr, &i);
+ auto id = b.GenerateLiteralIfNeeded(nullptr, i);
ASSERT_FALSE(b.has_error()) << b.error();
EXPECT_EQ(2u, id);
@@ -118,12 +112,11 @@
}
TEST_F(BuilderTest, Literal_U32_Dedup) {
- ast::type::U32 u32;
- ast::UintLiteral i1(Source{}, &u32, 23);
- ast::UintLiteral i2(Source{}, &u32, 23);
+ auto* i1 = create<ast::UintLiteral>(ty.u32, 23);
+ auto* i2 = create<ast::UintLiteral>(ty.u32, 23);
- ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i1), 0u);
- ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i2), 0u);
+ ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, i1), 0u);
+ ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, i2), 0u);
ASSERT_FALSE(b.has_error()) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 0
@@ -132,10 +125,9 @@
}
TEST_F(BuilderTest, Literal_F32) {
- ast::type::F32 f32;
- ast::FloatLiteral i(Source{}, &f32, 23.245f);
+ auto* i = create<ast::FloatLiteral>(ty.f32, 23.245f);
- auto id = b.GenerateLiteralIfNeeded(nullptr, &i);
+ auto id = b.GenerateLiteralIfNeeded(nullptr, i);
ASSERT_FALSE(b.has_error()) << b.error();
EXPECT_EQ(2u, id);
@@ -145,12 +137,11 @@
}
TEST_F(BuilderTest, Literal_F32_Dedup) {
- ast::type::F32 f32;
- ast::FloatLiteral i1(Source{}, &f32, 23.245f);
- ast::FloatLiteral i2(Source{}, &f32, 23.245f);
+ auto* i1 = create<ast::FloatLiteral>(ty.f32, 23.245f);
+ auto* i2 = create<ast::FloatLiteral>(ty.f32, 23.245f);
- ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i1), 0u);
- ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, &i2), 0u);
+ ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, i1), 0u);
+ ASSERT_NE(b.GenerateLiteralIfNeeded(nullptr, i2), 0u);
ASSERT_FALSE(b.has_error()) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32
diff --git a/src/writer/spirv/builder_loop_test.cc b/src/writer/spirv/builder_loop_test.cc
index c7e46d2..b91fa7d 100644
--- a/src/writer/spirv/builder_loop_test.cc
+++ b/src/writer/spirv/builder_loop_test.cc
@@ -39,14 +39,14 @@
// loop {
// }
- ast::LoopStatement loop(
- Source{}, create<ast::BlockStatement>(Source{}, ast::StatementList{}),
- create<ast::BlockStatement>(Source{}, ast::StatementList{}));
+ auto* loop = create<ast::LoopStatement>(
+ create<ast::BlockStatement>(ast::StatementList{}),
+ create<ast::BlockStatement>(ast::StatementList{}));
- ASSERT_TRUE(td.DetermineResultType(&loop)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(loop)) << td.error();
b.push_function(Function{});
- EXPECT_TRUE(b.GenerateLoopStatement(&loop)) << b.error();
+ EXPECT_TRUE(b.GenerateLoopStatement(loop)) << b.error();
EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
R"(OpBranch %1
%1 = OpLabel
@@ -67,20 +67,18 @@
auto* var = Var("v", ast::StorageClass::kPrivate, ty.i32);
auto* body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(2))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(2))});
- ast::LoopStatement loop(
- Source{}, body,
- create<ast::BlockStatement>(Source{}, ast::StatementList{}));
+ auto* loop = create<ast::LoopStatement>(
+ body, create<ast::BlockStatement>(ast::StatementList{}));
td.RegisterVariableForTesting(var);
- ASSERT_TRUE(td.DetermineResultType(&loop)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(loop)) << td.error();
b.push_function(Function{});
ASSERT_TRUE(b.GenerateGlobalVariable(var)) << b.error();
- EXPECT_TRUE(b.GenerateLoopStatement(&loop)) << b.error();
+ EXPECT_TRUE(b.GenerateLoopStatement(loop)) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeInt 32 1
%2 = OpTypePointer Private %3
%4 = OpConstantNull %3
@@ -112,21 +110,19 @@
auto* var = Var("v", ast::StorageClass::kPrivate, ty.i32);
auto* body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(2))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(2))});
auto* continuing = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(3))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(3))});
- ast::LoopStatement loop(Source{}, body, continuing);
+ auto* loop = create<ast::LoopStatement>(body, continuing);
td.RegisterVariableForTesting(var);
- ASSERT_TRUE(td.DetermineResultType(&loop)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(loop)) << td.error();
b.push_function(Function{});
ASSERT_TRUE(b.GenerateGlobalVariable(var)) << b.error();
- EXPECT_TRUE(b.GenerateLoopStatement(&loop)) << b.error();
+ EXPECT_TRUE(b.GenerateLoopStatement(loop)) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeInt 32 1
%2 = OpTypePointer Private %3
%4 = OpConstantNull %3
@@ -153,19 +149,17 @@
// loop {
// continue;
// }
- auto* body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{
- create<ast::ContinueStatement>(Source{}),
- });
- ast::LoopStatement loop(
- Source{}, body,
- create<ast::BlockStatement>(Source{}, ast::StatementList{}));
+ auto* body = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::ContinueStatement>(),
+ });
+ auto* loop = create<ast::LoopStatement>(
+ body, create<ast::BlockStatement>(ast::StatementList{}));
- ASSERT_TRUE(td.DetermineResultType(&loop)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(loop)) << td.error();
b.push_function(Function{});
- EXPECT_TRUE(b.GenerateLoopStatement(&loop)) << b.error();
+ EXPECT_TRUE(b.GenerateLoopStatement(loop)) << b.error();
EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
R"(OpBranch %1
%1 = OpLabel
@@ -183,19 +177,17 @@
// loop {
// break;
// }
- auto* body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{
- create<ast::BreakStatement>(Source{}),
- });
- ast::LoopStatement loop(
- Source{}, body,
- create<ast::BlockStatement>(Source{}, ast::StatementList{}));
+ auto* body = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::BreakStatement>(),
+ });
+ auto* loop = create<ast::LoopStatement>(
+ body, create<ast::BlockStatement>(ast::StatementList{}));
- ASSERT_TRUE(td.DetermineResultType(&loop)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(loop)) << td.error();
b.push_function(Function{});
- EXPECT_TRUE(b.GenerateLoopStatement(&loop)) << b.error();
+ EXPECT_TRUE(b.GenerateLoopStatement(loop)) << b.error();
EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
R"(OpBranch %1
%1 = OpLabel
diff --git a/src/writer/spirv/builder_return_test.cc b/src/writer/spirv/builder_return_test.cc
index d095562..5e71109 100644
--- a/src/writer/spirv/builder_return_test.cc
+++ b/src/writer/spirv/builder_return_test.cc
@@ -35,10 +35,10 @@
using BuilderTest = TestHelper;
TEST_F(BuilderTest, Return) {
- ast::ReturnStatement ret(Source{});
+ auto* ret = create<ast::ReturnStatement>();
b.push_function(Function{});
- EXPECT_TRUE(b.GenerateReturnStatement(&ret));
+ EXPECT_TRUE(b.GenerateReturnStatement(ret));
ASSERT_FALSE(b.has_error()) << b.error();
EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpReturn
@@ -47,15 +47,14 @@
TEST_F(BuilderTest, Return_WithValue) {
auto* val = create<ast::TypeConstructorExpression>(
- Source{}, ty.vec3<f32>(),
- ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(3.f)});
+ ty.vec3<f32>(), ast::ExpressionList{Expr(1.f), Expr(1.f), Expr(3.f)});
- ast::ReturnStatement ret(Source{}, val);
+ auto* ret = create<ast::ReturnStatement>(val);
- EXPECT_TRUE(td.DetermineResultType(&ret)) << td.error();
+ EXPECT_TRUE(td.DetermineResultType(ret)) << td.error();
b.push_function(Function{});
- EXPECT_TRUE(b.GenerateReturnStatement(&ret));
+ EXPECT_TRUE(b.GenerateReturnStatement(ret));
ASSERT_FALSE(b.has_error()) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32
@@ -72,14 +71,14 @@
TEST_F(BuilderTest, Return_WithValue_GeneratesLoad) {
auto* var = Var("param", ast::StorageClass::kFunction, ty.f32);
- ast::ReturnStatement ret(Source{}, Expr("param"));
+ auto* ret = create<ast::ReturnStatement>(Expr("param"));
td.RegisterVariableForTesting(var);
- EXPECT_TRUE(td.DetermineResultType(&ret)) << td.error();
+ EXPECT_TRUE(td.DetermineResultType(ret)) << td.error();
b.push_function(Function{});
EXPECT_TRUE(b.GenerateFunctionVariable(var)) << b.error();
- EXPECT_TRUE(b.GenerateReturnStatement(&ret)) << b.error();
+ EXPECT_TRUE(b.GenerateReturnStatement(ret)) << b.error();
ASSERT_FALSE(b.has_error()) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeFloat 32
diff --git a/src/writer/spirv/builder_switch_test.cc b/src/writer/spirv/builder_switch_test.cc
index d0be541..7150529 100644
--- a/src/writer/spirv/builder_switch_test.cc
+++ b/src/writer/spirv/builder_switch_test.cc
@@ -43,12 +43,12 @@
// switch (1) {
// }
- ast::SwitchStatement expr(Source{}, Expr(1), ast::CaseStatementList{});
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ auto* expr = create<ast::SwitchStatement>(Expr(1), ast::CaseStatementList{});
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_TRUE(b.GenerateSwitchStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateSwitchStatement(expr)) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
%3 = OpConstant %2 1
)");
@@ -73,12 +73,10 @@
auto* a = Var("a", ast::StorageClass::kPrivate, ty.i32);
auto* case_1_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(1))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(1))});
auto* case_2_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(2))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(2))});
ast::CaseSelectorList selector_1;
selector_1.push_back(Literal(1));
@@ -87,16 +85,14 @@
selector_2.push_back(Literal(2));
ast::CaseStatementList cases;
- cases.push_back(
- create<ast::CaseStatement>(Source{}, selector_1, case_1_body));
- cases.push_back(
- create<ast::CaseStatement>(Source{}, selector_2, case_2_body));
+ cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body));
+ cases.push_back(create<ast::CaseStatement>(selector_2, case_2_body));
- ast::SwitchStatement expr(Source{}, Expr("a"), cases);
+ auto* expr = create<ast::SwitchStatement>(Expr("a"), cases);
td.RegisterVariableForTesting(v);
td.RegisterVariableForTesting(a);
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
auto* func = Func("a_func", {}, ty.i32, ast::StatementList{},
ast::FunctionDecorationList{});
@@ -105,7 +101,7 @@
ASSERT_TRUE(b.GenerateGlobalVariable(a)) << b.error();
ASSERT_TRUE(b.GenerateFunction(func)) << b.error();
- EXPECT_TRUE(b.GenerateSwitchStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateSwitchStatement(expr)) << b.error();
EXPECT_EQ(DumpBuilder(b), R"(OpName %1 "v"
OpName %5 "a"
@@ -147,18 +143,17 @@
auto* a = Var("a", ast::StorageClass::kPrivate, ty.i32);
auto* default_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(1))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(1))});
ast::CaseStatementList cases;
- cases.push_back(create<ast::CaseStatement>(Source{}, ast::CaseSelectorList{},
- default_body));
+ cases.push_back(
+ create<ast::CaseStatement>(ast::CaseSelectorList{}, default_body));
- ast::SwitchStatement expr(Source{}, Expr("a"), cases);
+ auto* expr = create<ast::SwitchStatement>(Expr("a"), cases);
td.RegisterVariableForTesting(v);
td.RegisterVariableForTesting(a);
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
auto* func = Func("a_func", {}, ty.i32, ast::StatementList{},
ast::FunctionDecorationList{});
@@ -167,7 +162,7 @@
ASSERT_TRUE(b.GenerateGlobalVariable(a)) << b.error();
ASSERT_TRUE(b.GenerateFunction(func)) << b.error();
- EXPECT_TRUE(b.GenerateSwitchStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateSwitchStatement(expr)) << b.error();
EXPECT_EQ(DumpBuilder(b), R"(OpName %1 "v"
OpName %5 "a"
@@ -207,16 +202,13 @@
auto* a = Var("a", ast::StorageClass::kPrivate, ty.i32);
auto* case_1_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(1))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(1))});
auto* case_2_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(2))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(2))});
auto* default_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(3))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(3))});
ast::CaseSelectorList selector_1;
selector_1.push_back(Literal(1));
@@ -226,18 +218,16 @@
selector_2.push_back(Literal(3));
ast::CaseStatementList cases;
+ cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body));
+ cases.push_back(create<ast::CaseStatement>(selector_2, case_2_body));
cases.push_back(
- create<ast::CaseStatement>(Source{}, selector_1, case_1_body));
- cases.push_back(
- create<ast::CaseStatement>(Source{}, selector_2, case_2_body));
- cases.push_back(create<ast::CaseStatement>(Source{}, ast::CaseSelectorList{},
- default_body));
+ create<ast::CaseStatement>(ast::CaseSelectorList{}, default_body));
- ast::SwitchStatement expr(Source{}, Expr("a"), cases);
+ auto* expr = create<ast::SwitchStatement>(Expr("a"), cases);
td.RegisterVariableForTesting(v);
td.RegisterVariableForTesting(a);
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
auto* func = Func("a_func", {}, ty.i32, ast::StatementList{},
ast::FunctionDecorationList{});
@@ -246,7 +236,7 @@
ASSERT_TRUE(b.GenerateGlobalVariable(a)) << b.error();
ASSERT_TRUE(b.GenerateFunction(func)) << b.error();
- EXPECT_TRUE(b.GenerateSwitchStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateSwitchStatement(expr)) << b.error();
EXPECT_EQ(DumpBuilder(b), R"(OpName %1 "v"
OpName %5 "a"
@@ -295,18 +285,14 @@
auto* a = Var("a", ast::StorageClass::kPrivate, ty.i32);
auto* case_1_body = create<ast::BlockStatement>(
- Source{},
- ast::StatementList{
- create<ast::AssignmentStatement>(Source{}, Expr("v"), Expr(1)),
- create<ast::FallthroughStatement>(Source{})});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(1)),
+ create<ast::FallthroughStatement>()});
auto* case_2_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(2))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(2))});
auto* default_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{create<ast::AssignmentStatement>(
- Source{}, Expr("v"), Expr(3))});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(3))});
ast::CaseSelectorList selector_1;
selector_1.push_back(Literal(1));
@@ -315,18 +301,16 @@
selector_2.push_back(Literal(2));
ast::CaseStatementList cases;
+ cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body));
+ cases.push_back(create<ast::CaseStatement>(selector_2, case_2_body));
cases.push_back(
- create<ast::CaseStatement>(Source{}, selector_1, case_1_body));
- cases.push_back(
- create<ast::CaseStatement>(Source{}, selector_2, case_2_body));
- cases.push_back(create<ast::CaseStatement>(Source{}, ast::CaseSelectorList{},
- default_body));
+ create<ast::CaseStatement>(ast::CaseSelectorList{}, default_body));
- ast::SwitchStatement expr(Source{}, Expr("a"), cases);
+ auto* expr = create<ast::SwitchStatement>(Expr("a"), cases);
td.RegisterVariableForTesting(v);
td.RegisterVariableForTesting(a);
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
auto* func = Func("a_func", {}, ty.i32, ast::StatementList{},
ast::FunctionDecorationList{});
@@ -335,7 +319,7 @@
ASSERT_TRUE(b.GenerateGlobalVariable(a)) << b.error();
ASSERT_TRUE(b.GenerateFunction(func)) << b.error();
- EXPECT_TRUE(b.GenerateSwitchStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateSwitchStatement(expr)) << b.error();
EXPECT_EQ(DumpBuilder(b), R"(OpName %1 "v"
OpName %5 "a"
@@ -380,23 +364,20 @@
auto* a = Var("a", ast::StorageClass::kPrivate, ty.i32);
auto* case_1_body = create<ast::BlockStatement>(
- Source{},
- ast::StatementList{
- create<ast::AssignmentStatement>(Source{}, Expr("v"), Expr(1)),
- create<ast::FallthroughStatement>(Source{})});
+ ast::StatementList{create<ast::AssignmentStatement>(Expr("v"), Expr(1)),
+ create<ast::FallthroughStatement>()});
ast::CaseSelectorList selector_1;
selector_1.push_back(Literal(1));
ast::CaseStatementList cases;
- cases.push_back(
- create<ast::CaseStatement>(Source{}, selector_1, case_1_body));
+ cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body));
- ast::SwitchStatement expr(Source{}, Expr("a"), cases);
+ auto* expr = create<ast::SwitchStatement>(Expr("a"), cases);
td.RegisterVariableForTesting(v);
td.RegisterVariableForTesting(a);
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
auto* func = Func("a_func", {}, ty.i32, ast::StatementList{},
ast::FunctionDecorationList{});
@@ -405,7 +386,7 @@
ASSERT_TRUE(b.GenerateGlobalVariable(a)) << b.error();
ASSERT_TRUE(b.GenerateFunction(func)) << b.error();
- EXPECT_FALSE(b.GenerateSwitchStatement(&expr)) << b.error();
+ EXPECT_FALSE(b.GenerateSwitchStatement(expr)) << b.error();
EXPECT_EQ(b.error(), "fallthrough of last case statement is disallowed");
}
@@ -421,30 +402,25 @@
auto* v = Var("v", ast::StorageClass::kPrivate, ty.i32);
auto* a = Var("a", ast::StorageClass::kPrivate, ty.i32);
- auto* if_body = create<ast::BlockStatement>(
- Source{}, ast::StatementList{
- create<ast::BreakStatement>(Source{}),
- });
+ auto* if_body = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::BreakStatement>(),
+ });
- auto* case_1_body = create<ast::BlockStatement>(
- Source{},
- ast::StatementList{
- create<ast::IfStatement>(Source{}, Expr(true), if_body,
- ast::ElseStatementList{}),
- create<ast::AssignmentStatement>(Source{}, Expr("v"), Expr(1))});
+ auto* case_1_body = create<ast::BlockStatement>(ast::StatementList{
+ create<ast::IfStatement>(Expr(true), if_body, ast::ElseStatementList{}),
+ create<ast::AssignmentStatement>(Expr("v"), Expr(1))});
ast::CaseSelectorList selector_1;
selector_1.push_back(Literal(1));
ast::CaseStatementList cases;
- cases.push_back(
- create<ast::CaseStatement>(Source{}, selector_1, case_1_body));
+ cases.push_back(create<ast::CaseStatement>(selector_1, case_1_body));
- ast::SwitchStatement expr(Source{}, Expr("a"), cases);
+ auto* expr = create<ast::SwitchStatement>(Expr("a"), cases);
td.RegisterVariableForTesting(v);
td.RegisterVariableForTesting(a);
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
auto* func = Func("a_func", {}, ty.i32, ast::StatementList{},
ast::FunctionDecorationList{});
@@ -453,7 +429,7 @@
ASSERT_TRUE(b.GenerateGlobalVariable(a)) << b.error();
ASSERT_TRUE(b.GenerateFunction(func)) << b.error();
- EXPECT_TRUE(b.GenerateSwitchStatement(&expr)) << b.error();
+ EXPECT_TRUE(b.GenerateSwitchStatement(expr)) << b.error();
EXPECT_EQ(DumpBuilder(b), R"(OpName %1 "v"
OpName %5 "a"
diff --git a/src/writer/spirv/builder_type_test.cc b/src/writer/spirv/builder_type_test.cc
index ca97704..db2f45a 100644
--- a/src/writer/spirv/builder_type_test.cc
+++ b/src/writer/spirv/builder_type_test.cc
@@ -114,7 +114,7 @@
TEST_F(BuilderTest_Type, GenerateArray_WithStride) {
ast::type::Array ary(ty.i32, 4,
ast::ArrayDecorationList{
- create<ast::StrideDecoration>(Source{}, 16u),
+ create<ast::StrideDecoration>(16u),
});
auto id = b.GenerateTypeIfNeeded(&ary);
@@ -242,8 +242,8 @@
}
TEST_F(BuilderTest_Type, GenerateStruct_Empty) {
- auto* s = create<ast::Struct>(Source{}, ast::StructMemberList{},
- ast::StructDecorationList{});
+ auto* s =
+ create<ast::Struct>(ast::StructMemberList{}, ast::StructDecorationList{});
auto* s_type = ty.struct_("S", s);
auto id = b.GenerateTypeIfNeeded(s_type);
@@ -276,7 +276,7 @@
TEST_F(BuilderTest_Type, GenerateStruct_Decorated) {
ast::StructDecorationList struct_decos;
- struct_decos.push_back(create<ast::StructBlockDecoration>(Source{}));
+ struct_decos.push_back(create<ast::StructBlockDecoration>());
auto* s = create<ast::Struct>(ast::StructMemberList{Member("a", ty.f32)},
struct_decos);
diff --git a/src/writer/spirv/builder_unary_op_expression_test.cc b/src/writer/spirv/builder_unary_op_expression_test.cc
index 2626f1c..5fc830b 100644
--- a/src/writer/spirv/builder_unary_op_expression_test.cc
+++ b/src/writer/spirv/builder_unary_op_expression_test.cc
@@ -38,11 +38,11 @@
using BuilderTest = TestHelper;
TEST_F(BuilderTest, UnaryOp_Negation_Integer) {
- ast::UnaryOpExpression expr(Source{}, ast::UnaryOp::kNegation, Expr(1));
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ auto* expr = create<ast::UnaryOpExpression>(ast::UnaryOp::kNegation, Expr(1));
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateUnaryOpExpression(&expr), 1u) << b.error();
+ EXPECT_EQ(b.GenerateUnaryOpExpression(expr), 1u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
%3 = OpConstant %2 1
)");
@@ -52,11 +52,12 @@
}
TEST_F(BuilderTest, UnaryOp_Negation_Float) {
- ast::UnaryOpExpression expr(Source{}, ast::UnaryOp::kNegation, Expr(1.f));
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ auto* expr =
+ create<ast::UnaryOpExpression>(ast::UnaryOp::kNegation, Expr(1.f));
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateUnaryOpExpression(&expr), 1u) << b.error();
+ EXPECT_EQ(b.GenerateUnaryOpExpression(expr), 1u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32
%3 = OpConstant %2 1
)");
@@ -66,11 +67,11 @@
}
TEST_F(BuilderTest, UnaryOp_Not) {
- ast::UnaryOpExpression expr(Source{}, ast::UnaryOp::kNot, Expr(false));
- ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ auto* expr = create<ast::UnaryOpExpression>(ast::UnaryOp::kNot, Expr(false));
+ ASSERT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
- EXPECT_EQ(b.GenerateUnaryOpExpression(&expr), 1u) << b.error();
+ EXPECT_EQ(b.GenerateUnaryOpExpression(expr), 1u) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool
%3 = OpConstantFalse %2
)");
@@ -82,14 +83,15 @@
TEST_F(BuilderTest, UnaryOp_LoadRequired) {
auto* var = Var("param", ast::StorageClass::kFunction, ty.vec3<f32>());
- ast::UnaryOpExpression expr(Source{}, ast::UnaryOp::kNegation, Expr("param"));
+ auto* expr =
+ create<ast::UnaryOpExpression>(ast::UnaryOp::kNegation, Expr("param"));
td.RegisterVariableForTesting(var);
- EXPECT_TRUE(td.DetermineResultType(&expr)) << td.error();
+ EXPECT_TRUE(td.DetermineResultType(expr)) << td.error();
b.push_function(Function{});
EXPECT_TRUE(b.GenerateFunctionVariable(var)) << b.error();
- EXPECT_EQ(b.GenerateUnaryOpExpression(&expr), 6u) << b.error();
+ EXPECT_EQ(b.GenerateUnaryOpExpression(expr), 6u) << b.error();
ASSERT_FALSE(b.has_error()) << b.error();
EXPECT_EQ(DumpInstructions(b.types()), R"(%4 = OpTypeFloat 32
