encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-08-09 05:29:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Start cleaning up tests (2/N)

Browse Source 
Remove Source{} with ast::Builder::create<>
Use Builder helpers where possible

Change-Id: Ia29fe615ac8975252a34f1252c363109ee382d72
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/35508
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: dan sinclair <dsinclair@chromium.org>
This commit is contained in:
Ben Clayton 2020-12-14 22:27:37 +00:00 committed by Commit Bot service account
parent 7eaf4b57ae
commit 5180e16386
28 changed files with 389 additions and 678 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
src/ast/builder.h
View File

@ -144,7 +144,7 @@ class TypesBuilder {
} }
/// @param subtype the array element type /// @param subtype the array element type
/// @param n the array size. 0 represents unbounded /// @param n the array size. 0 represents a runtime-array.
/// @return the tint AST type for a array of size `n` of type `T` /// @return the tint AST type for a array of size `n` of type `T`
type::Array* array(type::Type* subtype, uint32_t n) const { type::Array* array(type::Type* subtype, uint32_t n) const {
return mod_->create<type::Array>(subtype, n, ArrayDecorationList{}); return mod_->create<type::Array>(subtype, n, ArrayDecorationList{});
@ -422,7 +422,7 @@ class Builder {
} }
/// @param args the arguments for the array constructor /// @param args the arguments for the array constructor
/// @return an `TypeConstructorExpression` of a 4x4 matrix of type /// @return an `TypeConstructorExpression` of an array with element type
/// `T`, constructed with the values `args`. /// `T`, constructed with the values `args`.
template <typename T, int N = 0, typename... ARGS> template <typename T, int N = 0, typename... ARGS>
TypeConstructorExpression* array(ARGS&&... args) { TypeConstructorExpression* array(ARGS&&... args) {
@ -430,6 +430,19 @@ class Builder {
Source{}, ty.array<T, N>(), ExprList(std::forward<ARGS>(args)...)); Source{}, ty.array<T, N>(), ExprList(std::forward<ARGS>(args)...));
} }
/// @param subtype the array element type
/// @param n the array size. 0 represents a runtime-array.
/// @param args the arguments for the array constructor
/// @return an `TypeConstructorExpression` of an array with element type
/// `subtype`, constructed with the values `args`.
template <typename... ARGS>
TypeConstructorExpression* array(type::Type* subtype,
uint32_t n,
ARGS&&... args) {
return create<TypeConstructorExpression>(
Source{}, ty.array(subtype, n), ExprList(std::forward<ARGS>(args)...));
}
/// @param name the variable name /// @param name the variable name
/// @param storage the variable storage class /// @param storage the variable storage class
/// @param type the variable type /// @param type the variable type

35
src/writer/wgsl/generator_impl_alias_type_test.cc
View File

@ -31,8 +31,7 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, EmitAlias_F32) { TEST_F(WgslGeneratorImplTest, EmitAlias_F32) {
ast::type::F32 f32; ast::type::Alias alias(mod->RegisterSymbol("a"), "a", ty.f32);
ast::type::Alias alias(mod.RegisterSymbol("a"), "a", &f32);
ASSERT_TRUE(gen.EmitConstructedType(&alias)) << gen.error(); ASSERT_TRUE(gen.EmitConstructedType(&alias)) << gen.error();
EXPECT_EQ(gen.result(), R"(type a = f32; EXPECT_EQ(gen.result(), R"(type a = f32;
@ -40,22 +39,18 @@ TEST_F(WgslGeneratorImplTest, EmitAlias_F32) {
} }
TEST_F(WgslGeneratorImplTest, EmitConstructedType_Struct) { TEST_F(WgslGeneratorImplTest, EmitConstructedType_Struct) {
ast::type::I32 i32;
ast::type::F32 f32;
ast::StructMemberList members; ast::StructMemberList members;
members.push_back(create<ast::StructMember>( members.push_back(create<ast::StructMember>(
Source{}, "a", &f32, ast::StructMemberDecorationList{})); "a", ty.f32, ast::StructMemberDecorationList{}));
ast::StructMemberDecorationList b_deco; ast::StructMemberDecorationList b_deco;
b_deco.push_back(create<ast::StructMemberOffsetDecoration>(Source{}, 4)); b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4));
members.push_back(create<ast::StructMember>(Source{}, "b", &i32, b_deco)); members.push_back(create<ast::StructMember>("b", ty.i32, b_deco));
auto* str = auto* str = create<ast::Struct>(members, ast::StructDecorationList{});
create<ast::Struct>(Source{}, members, ast::StructDecorationList{});
ast::type::Struct s(mod.RegisterSymbol("A"), "A", str); ast::type::Struct s(mod->RegisterSymbol("A"), "A", str);
ast::type::Alias alias(mod.RegisterSymbol("B"), "B", &s); ast::type::Alias alias(mod->RegisterSymbol("B"), "B", &s);
ASSERT_TRUE(gen.EmitConstructedType(&s)) << gen.error(); ASSERT_TRUE(gen.EmitConstructedType(&s)) << gen.error();
ASSERT_TRUE(gen.EmitConstructedType(&alias)) << gen.error(); ASSERT_TRUE(gen.EmitConstructedType(&alias)) << gen.error();
@ -69,22 +64,18 @@ type B = A;
} }
TEST_F(WgslGeneratorImplTest, EmitAlias_ToStruct) { TEST_F(WgslGeneratorImplTest, EmitAlias_ToStruct) {
ast::type::I32 i32;
ast::type::F32 f32;
ast::StructMemberList members; ast::StructMemberList members;
members.push_back(create<ast::StructMember>( members.push_back(create<ast::StructMember>(
Source{}, "a", &f32, ast::StructMemberDecorationList{})); "a", ty.f32, ast::StructMemberDecorationList{}));
ast::StructMemberDecorationList b_deco; ast::StructMemberDecorationList b_deco;
b_deco.push_back(create<ast::StructMemberOffsetDecoration>(Source{}, 4)); b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4));
members.push_back(create<ast::StructMember>(Source{}, "b", &i32, b_deco)); members.push_back(create<ast::StructMember>("b", ty.i32, b_deco));
auto* str = auto* str = create<ast::Struct>(members, ast::StructDecorationList{});
create<ast::Struct>(Source{}, members, ast::StructDecorationList{});
ast::type::Struct s(mod.RegisterSymbol("A"), "A", str); ast::type::Struct s(mod->RegisterSymbol("A"), "A", str);
ast::type::Alias alias(mod.RegisterSymbol("B"), "B", &s); ast::type::Alias alias(mod->RegisterSymbol("B"), "B", &s);
ASSERT_TRUE(gen.EmitConstructedType(&alias)) << gen.error(); ASSERT_TRUE(gen.EmitConstructedType(&alias)) << gen.error();
EXPECT_EQ(gen.result(), R"(type B = A; EXPECT_EQ(gen.result(), R"(type B = A;

22
src/writer/wgsl/generator_impl_array_accessor_test.cc
View File

@ -31,27 +31,23 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, EmitExpression_ArrayAccessor) { TEST_F(WgslGeneratorImplTest, EmitExpression_ArrayAccessor) {
ast::type::I32 i32; auto* lit = create<ast::SintLiteral>(ty.i32, 5);
auto* lit = create<ast::SintLiteral>(Source{}, &i32, 5); auto* idx = create<ast::ScalarConstructorExpression>(lit);
auto* idx = create<ast::ScalarConstructorExpression>(Source{}, lit); auto* ary = Expr("ary");
auto* ary = create<ast::IdentifierExpression>(
Source{}, mod.RegisterSymbol("ary"), "ary");
ast::ArrayAccessorExpression expr(Source{}, ary, idx); auto* expr = create<ast::ArrayAccessorExpression>(ary, idx);
ASSERT_TRUE(gen.EmitExpression(&expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(expr)) << gen.error();
EXPECT_EQ(gen.result(), "ary[5]"); EXPECT_EQ(gen.result(), "ary[5]");
} }
TEST_F(WgslGeneratorImplTest, EmitArrayAccessor) { TEST_F(WgslGeneratorImplTest, EmitArrayAccessor) {
auto* ary = create<ast::IdentifierExpression>( auto* ary = Expr("ary");
Source{}, mod.RegisterSymbol("ary"), "ary"); auto* idx = Expr("idx");
auto* idx = create<ast::IdentifierExpression>(
Source{}, mod.RegisterSymbol("idx"), "idx");
ast::ArrayAccessorExpression expr(Source{}, ary, idx); auto* expr = create<ast::ArrayAccessorExpression>(ary, idx);
ASSERT_TRUE(gen.EmitArrayAccessor(&expr)) << gen.error(); ASSERT_TRUE(gen.EmitArrayAccessor(expr)) << gen.error();
EXPECT_EQ(gen.result(), "ary[idx]"); EXPECT_EQ(gen.result(), "ary[idx]");
} }

10
src/writer/wgsl/generator_impl_assign_test.cc
View File

@ -29,15 +29,13 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, Emit_Assign) { TEST_F(WgslGeneratorImplTest, Emit_Assign) {
auto* lhs = create<ast::IdentifierExpression>( auto* lhs = Expr("lhs");
Source{}, mod.RegisterSymbol("lhs"), "lhs"); auto* rhs = Expr("rhs");
auto* rhs = create<ast::IdentifierExpression>( auto* assign = create<ast::AssignmentStatement>(lhs, rhs);
Source{}, mod.RegisterSymbol("rhs"), "rhs");
ast::AssignmentStatement assign(Source{}, lhs, rhs);
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&assign)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(assign)) << gen.error();
EXPECT_EQ(gen.result(), " lhs = rhs;\n"); EXPECT_EQ(gen.result(), " lhs = rhs;\n");
} }

10
src/writer/wgsl/generator_impl_binary_test.cc
View File

@ -37,14 +37,12 @@ using WgslBinaryTest = TestParamHelper<BinaryData>;
TEST_P(WgslBinaryTest, Emit) { TEST_P(WgslBinaryTest, Emit) {
auto params = GetParam(); auto params = GetParam();
auto* left = create<ast::IdentifierExpression>( auto* left = Expr("left");
Source{}, mod.RegisterSymbol("left"), "left"); auto* right = Expr("right");
auto* right = create<ast::IdentifierExpression>(
Source{}, mod.RegisterSymbol("right"), "right");
ast::BinaryExpression expr(Source{}, params.op, left, right); auto* expr = create<ast::BinaryExpression>(params.op, left, right);
ASSERT_TRUE(gen.EmitExpression(&expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(expr)) << gen.error();
EXPECT_EQ(gen.result(), params.result); EXPECT_EQ(gen.result(), params.result);
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(

8
src/writer/wgsl/generator_impl_bitcast_test.cc
View File

@ -29,12 +29,10 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, EmitExpression_Bitcast) { TEST_F(WgslGeneratorImplTest, EmitExpression_Bitcast) {
ast::type::F32 f32; auto* id = Expr("id");
auto* id = create<ast::IdentifierExpression>(Source{}, auto* bitcast = create<ast::BitcastExpression>(ty.f32, id);
mod.RegisterSymbol("id"), "id");
ast::BitcastExpression bitcast(Source{}, &f32, id);
ASSERT_TRUE(gen.EmitExpression(&bitcast)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(bitcast)) << gen.error();
EXPECT_EQ(gen.result(), "bitcast<f32>(id)"); EXPECT_EQ(gen.result(), "bitcast<f32>(id)");
} }

16
src/writer/wgsl/generator_impl_block_test.cc
View File

@ -28,12 +28,12 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, Emit_Block) { TEST_F(WgslGeneratorImplTest, Emit_Block) {
ast::BlockStatement b(Source{}, ast::StatementList{ auto* b = create<ast::BlockStatement>(ast::StatementList{
create<ast::DiscardStatement>(Source{}), create<ast::DiscardStatement>(),
}); });
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&b)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(b)) << gen.error();
EXPECT_EQ(gen.result(), R"( { EXPECT_EQ(gen.result(), R"( {
discard; discard;
} }
@ -41,12 +41,12 @@ TEST_F(WgslGeneratorImplTest, Emit_Block) {
} }
TEST_F(WgslGeneratorImplTest, Emit_Block_WithoutNewline) { TEST_F(WgslGeneratorImplTest, Emit_Block_WithoutNewline) {
ast::BlockStatement b(Source{}, ast::StatementList{ auto* b = create<ast::BlockStatement>(ast::StatementList{
create<ast::DiscardStatement>(Source{}), create<ast::DiscardStatement>(),
}); });
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitBlock(&b)) << gen.error(); ASSERT_TRUE(gen.EmitBlock(b)) << gen.error();
EXPECT_EQ(gen.result(), R"({ EXPECT_EQ(gen.result(), R"({
discard; discard;
})"); })");

4
src/writer/wgsl/generator_impl_break_test.cc
View File

@ -28,11 +28,11 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, Emit_Break) { TEST_F(WgslGeneratorImplTest, Emit_Break) {
ast::BreakStatement b(Source{}); auto* b = create<ast::BreakStatement>();
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&b)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(b)) << gen.error();
EXPECT_EQ(gen.result(), " break;\n"); EXPECT_EQ(gen.result(), " break;\n");
} }

34
src/writer/wgsl/generator_impl_call_test.cc
View File

@ -29,42 +29,30 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, EmitExpression_Call_WithoutParams) { TEST_F(WgslGeneratorImplTest, EmitExpression_Call_WithoutParams) {
auto* id = create<ast::IdentifierExpression>( auto* id = Expr("my_func");
Source{}, mod.RegisterSymbol("my_func"), "my_func"); auto* call = create<ast::CallExpression>(id, ast::ExpressionList{});
ast::CallExpression call(Source{}, id, {});
ASSERT_TRUE(gen.EmitExpression(&call)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(call)) << gen.error();
EXPECT_EQ(gen.result(), "my_func()"); EXPECT_EQ(gen.result(), "my_func()");
} }
TEST_F(WgslGeneratorImplTest, EmitExpression_Call_WithParams) { TEST_F(WgslGeneratorImplTest, EmitExpression_Call_WithParams) {
auto* id = create<ast::IdentifierExpression>( auto* id = Expr("my_func");
Source{}, mod.RegisterSymbol("my_func"), "my_func"); auto* call = create<ast::CallExpression>(
ast::ExpressionList params; id, ast::ExpressionList{Expr("param1"), Expr("param2")});
params.push_back(create<ast::IdentifierExpression>(
Source{}, mod.RegisterSymbol("param1"), "param1"));
params.push_back(create<ast::IdentifierExpression>(
Source{}, mod.RegisterSymbol("param2"), "param2"));
ast::CallExpression call(Source{}, id, params);
ASSERT_TRUE(gen.EmitExpression(&call)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(call)) << gen.error();
EXPECT_EQ(gen.result(), "my_func(param1, param2)"); EXPECT_EQ(gen.result(), "my_func(param1, param2)");
} }
TEST_F(WgslGeneratorImplTest, EmitStatement_Call) { TEST_F(WgslGeneratorImplTest, EmitStatement_Call) {
auto* id = create<ast::IdentifierExpression>( auto* id = Expr("my_func");
Source{}, mod.RegisterSymbol("my_func"), "my_func");
ast::ExpressionList params;
params.push_back(create<ast::IdentifierExpression>(
Source{}, mod.RegisterSymbol("param1"), "param1"));
params.push_back(create<ast::IdentifierExpression>(
Source{}, mod.RegisterSymbol("param2"), "param2"));
ast::CallStatement call(Source{}, auto* call = create<ast::CallStatement>(create<ast::CallExpression>(
create<ast::CallExpression>(Source{}, id, params)); id, ast::ExpressionList{Expr("param1"), Expr("param2")}));
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&call)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(call)) << gen.error();
EXPECT_EQ(gen.result(), " my_func(param1, param2);\n"); EXPECT_EQ(gen.result(), " my_func(param1, param2);\n");
} }

43
src/writer/wgsl/generator_impl_case_test.cc
View File

@ -31,19 +31,16 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, Emit_Case) { TEST_F(WgslGeneratorImplTest, Emit_Case) {
ast::type::I32 i32; auto* body = create<ast::BlockStatement>(ast::StatementList{
create<ast::BreakStatement>(),
auto* body = create<ast::BlockStatement>( });
Source{}, ast::StatementList{
create<ast::BreakStatement>(Source{}),
});
ast::CaseSelectorList lit; ast::CaseSelectorList lit;
lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 5)); lit.push_back(create<ast::SintLiteral>(ty.i32, 5));
ast::CaseStatement c(Source{}, lit, body); auto* c = create<ast::CaseStatement>(lit, body);
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitCase(&c)) << gen.error(); ASSERT_TRUE(gen.EmitCase(c)) << gen.error();
EXPECT_EQ(gen.result(), R"( case 5: { EXPECT_EQ(gen.result(), R"( case 5: {
break; break;
} }
@ -51,20 +48,17 @@ TEST_F(WgslGeneratorImplTest, Emit_Case) {
} }
TEST_F(WgslGeneratorImplTest, Emit_Case_MultipleSelectors) { TEST_F(WgslGeneratorImplTest, Emit_Case_MultipleSelectors) {
ast::type::I32 i32; auto* body = create<ast::BlockStatement>(ast::StatementList{
create<ast::BreakStatement>(),
auto* body = create<ast::BlockStatement>( });
Source{}, ast::StatementList{
create<ast::BreakStatement>(Source{}),
});
ast::CaseSelectorList lit; ast::CaseSelectorList lit;
lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 5)); lit.push_back(create<ast::SintLiteral>(ty.i32, 5));
lit.push_back(create<ast::SintLiteral>(Source{}, &i32, 6)); lit.push_back(create<ast::SintLiteral>(ty.i32, 6));
ast::CaseStatement c(Source{}, lit, body); auto* c = create<ast::CaseStatement>(lit, body);
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitCase(&c)) << gen.error(); ASSERT_TRUE(gen.EmitCase(c)) << gen.error();
EXPECT_EQ(gen.result(), R"( case 5, 6: { EXPECT_EQ(gen.result(), R"( case 5, 6: {
break; break;
} }
@ -72,15 +66,14 @@ TEST_F(WgslGeneratorImplTest, Emit_Case_MultipleSelectors) {
} }
TEST_F(WgslGeneratorImplTest, Emit_Case_Default) { TEST_F(WgslGeneratorImplTest, Emit_Case_Default) {
auto* body = create<ast::BlockStatement>( auto* body = create<ast::BlockStatement>(ast::StatementList{
Source{}, ast::StatementList{ create<ast::BreakStatement>(),
create<ast::BreakStatement>(Source{}), });
}); auto* c = create<ast::CaseStatement>(ast::CaseSelectorList{}, body);
ast::CaseStatement c(Source{}, ast::CaseSelectorList{}, body);
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitCase(&c)) << gen.error(); ASSERT_TRUE(gen.EmitCase(c)) << gen.error();
EXPECT_EQ(gen.result(), R"( default: { EXPECT_EQ(gen.result(), R"( default: {
break; break;
} }

10
src/writer/wgsl/generator_impl_cast_test.cc
View File

@ -29,15 +29,9 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, EmitExpression_Cast) { TEST_F(WgslGeneratorImplTest, EmitExpression_Cast) {
ast::type::F32 f32; auto* cast = Construct<f32>("id");
ast::ExpressionList params; ASSERT_TRUE(gen.EmitExpression(cast)) << gen.error();
params.push_back(create<ast::IdentifierExpression>(
Source{}, mod.RegisterSymbol("id"), "id"));
ast::TypeConstructorExpression cast(Source{}, &f32, params);
ASSERT_TRUE(gen.EmitExpression(&cast)) << gen.error();
EXPECT_EQ(gen.result(), "f32(id)"); EXPECT_EQ(gen.result(), "f32(id)");
} }

149
src/writer/wgsl/generator_impl_constructor_test.cc
View File

@ -36,172 +36,71 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, EmitConstructor_Bool) { TEST_F(WgslGeneratorImplTest, EmitConstructor_Bool) {
ast::type::Bool bool_type; ASSERT_TRUE(gen.EmitConstructor(Expr(false))) << gen.error();
auto* lit = create<ast::BoolLiteral>(Source{}, &bool_type, false);
ast::ScalarConstructorExpression expr(Source{}, lit);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
EXPECT_EQ(gen.result(), "false"); EXPECT_EQ(gen.result(), "false");
} }
TEST_F(WgslGeneratorImplTest, EmitConstructor_Int) { TEST_F(WgslGeneratorImplTest, EmitConstructor_Int) {
ast::type::I32 i32; ASSERT_TRUE(gen.EmitConstructor(Expr(-12345))) << gen.error();
auto* lit = create<ast::SintLiteral>(Source{}, &i32, -12345);
ast::ScalarConstructorExpression expr(Source{}, lit);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
EXPECT_EQ(gen.result(), "-12345"); EXPECT_EQ(gen.result(), "-12345");
} }
TEST_F(WgslGeneratorImplTest, EmitConstructor_UInt) { TEST_F(WgslGeneratorImplTest, EmitConstructor_UInt) {
ast::type::U32 u32; ASSERT_TRUE(gen.EmitConstructor(Expr(56779u))) << gen.error();
auto* lit = create<ast::UintLiteral>(Source{}, &u32, 56779);
ast::ScalarConstructorExpression expr(Source{}, lit);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
EXPECT_EQ(gen.result(), "56779u"); EXPECT_EQ(gen.result(), "56779u");
} }
TEST_F(WgslGeneratorImplTest, EmitConstructor_Float) { TEST_F(WgslGeneratorImplTest, EmitConstructor_Float) {
ast::type::F32 f32;
// Use a number close to 1<<30 but whose decimal representation ends in 0. // Use a number close to 1<<30 but whose decimal representation ends in 0.
auto* lit = create<ast::FloatLiteral>(Source{}, &f32, ASSERT_TRUE(gen.EmitConstructor(Expr(static_cast<float>((1 << 30) - 4))))
static_cast<float>((1 << 30) - 4)); << gen.error();
ast::ScalarConstructorExpression expr(Source{}, lit);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
EXPECT_EQ(gen.result(), "1073741824.0"); EXPECT_EQ(gen.result(), "1073741824.0");
} }
TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Float) { TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Float) {
ast::type::F32 f32; ASSERT_TRUE(gen.EmitConstructor(Construct<f32>(Expr(-1.2e-5f))))
<< gen.error();
auto* lit = create<ast::FloatLiteral>(Source{}, &f32, -1.2e-5);
ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit));
ast::TypeConstructorExpression expr(Source{}, &f32, values);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
EXPECT_EQ(gen.result(), "f32(-0.000012)"); EXPECT_EQ(gen.result(), "f32(-0.000012)");
} }
TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Bool) { TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Bool) {
ast::type::Bool b; ASSERT_TRUE(gen.EmitConstructor(Construct<bool>(true))) << gen.error();
auto* lit = create<ast::BoolLiteral>(Source{}, &b, true);
ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit));
ast::TypeConstructorExpression expr(Source{}, &b, values);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
EXPECT_EQ(gen.result(), "bool(true)"); EXPECT_EQ(gen.result(), "bool(true)");
} }
TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Int) { TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Int) {
ast::type::I32 i32; ASSERT_TRUE(gen.EmitConstructor(Construct<i32>(-12345))) << gen.error();
auto* lit = create<ast::SintLiteral>(Source{}, &i32, -12345);
ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit));
ast::TypeConstructorExpression expr(Source{}, &i32, values);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
EXPECT_EQ(gen.result(), "i32(-12345)"); EXPECT_EQ(gen.result(), "i32(-12345)");
} }
TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Uint) { TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Uint) {
ast::type::U32 u32; ASSERT_TRUE(gen.EmitConstructor(Construct<u32>(12345u))) << gen.error();
auto* lit = create<ast::UintLiteral>(Source{}, &u32, 12345);
ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit));
ast::TypeConstructorExpression expr(Source{}, &u32, values);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
EXPECT_EQ(gen.result(), "u32(12345u)"); EXPECT_EQ(gen.result(), "u32(12345u)");
} }
TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Vec) { TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Vec) {
ast::type::F32 f32; ASSERT_TRUE(gen.EmitConstructor(vec3<f32>(1.f, 2.f, 3.f))) << gen.error();
ast::type::Vector vec(&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);
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));
ast::TypeConstructorExpression expr(Source{}, &vec, values);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
EXPECT_EQ(gen.result(), "vec3<f32>(1.0, 2.0, 3.0)"); EXPECT_EQ(gen.result(), "vec3<f32>(1.0, 2.0, 3.0)");
} }
TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Mat) { TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Mat) {
ast::type::F32 f32; ASSERT_TRUE(gen.EmitConstructor(
ast::type::Matrix mat(&f32, 3, 2); Construct(ty.mat2x3<f32>(), vec2<f32>(1.0f, 2.0f), vec2<f32>(3.0f, 4.0f),
vec2<f32>(5.0f, 6.0f))))
ast::type::Vector vec(&f32, 2); << gen.error();
EXPECT_EQ(gen.result(),
ast::ExpressionList mat_values; "mat2x3<f32>(vec2<f32>(1.0, 2.0), vec2<f32>(3.0, 4.0), "
"vec2<f32>(5.0, 6.0))");
for (size_t i = 0; i < 3; 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)));
ast::ExpressionList values;
values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit1));
values.push_back(create<ast::ScalarConstructorExpression>(Source{}, lit2));
mat_values.push_back(
create<ast::TypeConstructorExpression>(Source{}, &vec, values));
}
ast::TypeConstructorExpression expr(Source{}, &mat, mat_values);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
EXPECT_EQ(gen.result(), std::string("mat2x3<f32>(vec2<f32>(1.0, 2.0), ") +
"vec2<f32>(3.0, 4.0), " + "vec2<f32>(5.0, 6.0))");
} }
TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Array) { TEST_F(WgslGeneratorImplTest, EmitConstructor_Type_Array) {
ast::type::F32 f32; ASSERT_TRUE(gen.EmitConstructor(
ast::type::Vector vec(&f32, 3); array(ty.vec3<f32>(), 3, vec3<f32>(1.f, 2.f, 3.f),
ast::type::Array ary(&vec, 3, ast::ArrayDecorationList{}); vec3<f32>(4.f, 5.f, 6.f), vec3<f32>(7.f, 8.f, 9.f))))
<< gen.error();
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)));
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));
ary_values.push_back(
create<ast::TypeConstructorExpression>(Source{}, &vec, values));
}
ast::TypeConstructorExpression expr(Source{}, &ary, ary_values);
ASSERT_TRUE(gen.EmitConstructor(&expr)) << gen.error();
EXPECT_EQ(gen.result(), EXPECT_EQ(gen.result(),
std::string("array<vec3<f32>, 3>(") + "vec3<f32>(1.0, 2.0, 3.0), " + "array<vec3<f32>, 3>(vec3<f32>(1.0, 2.0, 3.0), "
"vec3<f32>(4.0, 5.0, 6.0), " + "vec3<f32>(7.0, 8.0, 9.0))"); "vec3<f32>(4.0, 5.0, 6.0), vec3<f32>(7.0, 8.0, 9.0))");
} }
} // namespace } // namespace

4
src/writer/wgsl/generator_impl_continue_test.cc
View File

@ -28,11 +28,11 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, Emit_Continue) { TEST_F(WgslGeneratorImplTest, Emit_Continue) {
ast::ContinueStatement c(Source{}); auto* c = create<ast::ContinueStatement>();
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&c)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(c)) << gen.error();
EXPECT_EQ(gen.result(), " continue;\n"); EXPECT_EQ(gen.result(), " continue;\n");
} }

4
src/writer/wgsl/generator_impl_discard_test.cc
View File

@ -25,11 +25,11 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, Emit_Discard) { TEST_F(WgslGeneratorImplTest, Emit_Discard) {
ast::DiscardStatement k(Source{}); auto* k = create<ast::DiscardStatement>();
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&k)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(k)) << gen.error();
EXPECT_EQ(gen.result(), " discard;\n"); EXPECT_EQ(gen.result(), " discard;\n");
} }

4
src/writer/wgsl/generator_impl_fallthrough_test.cc
View File

@ -25,11 +25,11 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, Emit_Fallthrough) { TEST_F(WgslGeneratorImplTest, Emit_Fallthrough) {
ast::FallthroughStatement f(Source{}); auto* f = create<ast::FallthroughStatement>();
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&f)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(f)) << gen.error();
EXPECT_EQ(gen.result(), " fallthrough;\n"); EXPECT_EQ(gen.result(), " fallthrough;\n");
} }

227
src/writer/wgsl/generator_impl_function_test.cc
View File

@ -41,18 +41,18 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, Emit_Function) { TEST_F(WgslGeneratorImplTest, Emit_Function) {
auto* body = create<ast::BlockStatement>( auto* body = create<ast::BlockStatement>(ast::StatementList{
Source{}, ast::StatementList{ create<ast::DiscardStatement>(),
create<ast::DiscardStatement>(Source{}), create<ast::ReturnStatement>(),
create<ast::ReturnStatement>(Source{}), });
});
ast::type::Void void_type; auto* func = create<ast::Function>(mod->RegisterSymbol("my_func"), "my_func",
ast::Function func(Source{}, mod.RegisterSymbol("my_func"), "my_func", {}, ast::VariableList{}, ty.void_, body,
&void_type, body, ast::FunctionDecorationList{}); ast::FunctionDecorationList{});
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitFunction(&func)); ASSERT_TRUE(gen.EmitFunction(func));
EXPECT_EQ(gen.result(), R"( fn my_func() -> void { EXPECT_EQ(gen.result(), R"( fn my_func() -> void {
discard; discard;
return; return;
@ -61,38 +61,22 @@ TEST_F(WgslGeneratorImplTest, Emit_Function) {
} }
TEST_F(WgslGeneratorImplTest, Emit_Function_WithParams) { TEST_F(WgslGeneratorImplTest, Emit_Function_WithParams) {
auto* body = create<ast::BlockStatement>( auto* body = create<ast::BlockStatement>(ast::StatementList{
Source{}, ast::StatementList{ create<ast::DiscardStatement>(),
create<ast::DiscardStatement>(Source{}), create<ast::ReturnStatement>(),
create<ast::ReturnStatement>(Source{}), });
});
ast::type::F32 f32;
ast::type::I32 i32;
ast::VariableList params;
params.push_back(
create<ast::Variable>(Source{}, // source
"a", // name
ast::StorageClass::kNone, // storage_class
&f32, // type
false, // is_const
nullptr, // constructor
ast::VariableDecorationList{})); // decorations
params.push_back(
create<ast::Variable>(Source{}, // source
"b", // name
ast::StorageClass::kNone, // storage_class
&i32, // type
false, // is_const
nullptr, // constructor
ast::VariableDecorationList{})); // decorations
ast::type::Void void_type; ast::VariableList params;
ast::Function func(Source{}, mod.RegisterSymbol("my_func"), "my_func", params, params.push_back(Var("a", ast::StorageClass::kNone, ty.f32));
&void_type, body, ast::FunctionDecorationList{}); params.push_back(Var("b", ast::StorageClass::kNone, ty.i32));
auto* func =
create<ast::Function>(mod->RegisterSymbol("my_func"), "my_func", params,
ty.void_, body, ast::FunctionDecorationList{});
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitFunction(&func)); ASSERT_TRUE(gen.EmitFunction(func));
EXPECT_EQ(gen.result(), R"( fn my_func(a : f32, b : i32) -> void { EXPECT_EQ(gen.result(), R"( fn my_func(a : f32, b : i32) -> void {
discard; discard;
return; return;
@ -101,21 +85,21 @@ TEST_F(WgslGeneratorImplTest, Emit_Function_WithParams) {
} }
TEST_F(WgslGeneratorImplTest, Emit_Function_WithDecoration_WorkgroupSize) { TEST_F(WgslGeneratorImplTest, Emit_Function_WithDecoration_WorkgroupSize) {
auto* body = create<ast::BlockStatement>( auto* body = create<ast::BlockStatement>(ast::StatementList{
Source{}, ast::StatementList{ create<ast::DiscardStatement>(),
create<ast::DiscardStatement>(Source{}), create<ast::ReturnStatement>(),
create<ast::ReturnStatement>(Source{}), });
});
ast::type::Void void_type; auto* func =
ast::Function func(Source{}, mod.RegisterSymbol("my_func"), "my_func", {}, create<ast::Function>(mod->RegisterSymbol("my_func"), "my_func",
&void_type, body, ast::VariableList{}, ty.void_, body,
ast::FunctionDecorationList{ ast::FunctionDecorationList{
create<ast::WorkgroupDecoration>(Source{}, 2u, 4u, 6u), create<ast::WorkgroupDecoration>(2u, 4u, 6u),
}); });
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitFunction(&func)); ASSERT_TRUE(gen.EmitFunction(func));
EXPECT_EQ(gen.result(), R"( [[workgroup_size(2, 4, 6)]] EXPECT_EQ(gen.result(), R"( [[workgroup_size(2, 4, 6)]]
fn my_func() -> void { fn my_func() -> void {
discard; discard;
@ -125,21 +109,21 @@ TEST_F(WgslGeneratorImplTest, Emit_Function_WithDecoration_WorkgroupSize) {
} }
TEST_F(WgslGeneratorImplTest, Emit_Function_WithDecoration_Stage) { TEST_F(WgslGeneratorImplTest, Emit_Function_WithDecoration_Stage) {
auto* body = create<ast::BlockStatement>( auto* body = create<ast::BlockStatement>(ast::StatementList{
Source{}, ast::StatementList{ create<ast::DiscardStatement>(),
create<ast::DiscardStatement>(Source{}), create<ast::ReturnStatement>(),
create<ast::ReturnStatement>(Source{}), });
});
ast::type::Void void_type; auto* func = create<ast::Function>(
ast::Function func( mod->RegisterSymbol("my_func"), "my_func", ast::VariableList{}, ty.void_,
Source{}, mod.RegisterSymbol("my_func"), "my_func", {}, &void_type, body, body,
ast::FunctionDecorationList{ ast::FunctionDecorationList{
create<ast::StageDecoration>(Source{}, ast::PipelineStage::kFragment), create<ast::StageDecoration>(ast::PipelineStage::kFragment),
}); });
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitFunction(&func)); ASSERT_TRUE(gen.EmitFunction(func));
EXPECT_EQ(gen.result(), R"( [[stage(fragment)]] EXPECT_EQ(gen.result(), R"( [[stage(fragment)]]
fn my_func() -> void { fn my_func() -> void {
discard; discard;
@ -149,22 +133,22 @@ TEST_F(WgslGeneratorImplTest, Emit_Function_WithDecoration_Stage) {
} }
TEST_F(WgslGeneratorImplTest, Emit_Function_WithDecoration_Multiple) { TEST_F(WgslGeneratorImplTest, Emit_Function_WithDecoration_Multiple) {
auto* body = create<ast::BlockStatement>( auto* body = create<ast::BlockStatement>(ast::StatementList{
Source{}, ast::StatementList{ create<ast::DiscardStatement>(),
create<ast::DiscardStatement>(Source{}), create<ast::ReturnStatement>(),
create<ast::ReturnStatement>(Source{}), });
});
ast::type::Void void_type; auto* func = create<ast::Function>(
ast::Function func( mod->RegisterSymbol("my_func"), "my_func", ast::VariableList{}, ty.void_,
Source{}, mod.RegisterSymbol("my_func"), "my_func", {}, &void_type, body, body,
ast::FunctionDecorationList{ ast::FunctionDecorationList{
create<ast::StageDecoration>(Source{}, ast::PipelineStage::kFragment), create<ast::StageDecoration>(ast::PipelineStage::kFragment),
create<ast::WorkgroupDecoration>(Source{}, 2u, 4u, 6u), create<ast::WorkgroupDecoration>(2u, 4u, 6u),
}); });
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitFunction(&func)); ASSERT_TRUE(gen.EmitFunction(func));
EXPECT_EQ(gen.result(), R"( [[stage(fragment)]] EXPECT_EQ(gen.result(), R"( [[stage(fragment)]]
[[workgroup_size(2, 4, 6)]] [[workgroup_size(2, 4, 6)]]
fn my_func() -> void { fn my_func() -> void {
@ -192,105 +176,74 @@ TEST_F(WgslGeneratorImplTest,
// return; // return;
// } // }
ast::type::Void void_type;
ast::type::F32 f32;
ast::StructMemberList members; ast::StructMemberList members;
ast::StructMemberDecorationList a_deco; ast::StructMemberDecorationList a_deco;
a_deco.push_back(create<ast::StructMemberOffsetDecoration>(Source{}, 0)); a_deco.push_back(create<ast::StructMemberOffsetDecoration>(0));
members.push_back(create<ast::StructMember>(Source{}, "d", &f32, a_deco)); members.push_back(create<ast::StructMember>("d", ty.f32, a_deco));
ast::StructDecorationList s_decos; ast::StructDecorationList s_decos;
s_decos.push_back(create<ast::StructBlockDecoration>(Source{})); s_decos.push_back(create<ast::StructBlockDecoration>());
auto* str = create<ast::Struct>(Source{}, members, s_decos); auto* str = create<ast::Struct>(members, s_decos);
ast::type::Struct s(mod.RegisterSymbol("Data"), "Data", str); ast::type::Struct s(mod->RegisterSymbol("Data"), "Data", str);
ast::type::AccessControl ac(ast::AccessControl::kReadWrite, &s); ast::type::AccessControl ac(ast::AccessControl::kReadWrite, &s);
auto* data_var = auto* data_var = Var("data", ast::StorageClass::kStorageBuffer, &ac, nullptr,
create<ast::Variable>(Source{}, // source ast::VariableDecorationList{
"data", // name // decorations
ast::StorageClass::kStorageBuffer, // storage_class create<ast::BindingDecoration>(0),
&ac, // type create<ast::SetDecoration>(0),
false, // is_const });
nullptr, // constructor
ast::VariableDecorationList{
// decorations
create<ast::BindingDecoration>(Source{}, 0),
create<ast::SetDecoration>(Source{}, 0),
});
mod.AddConstructedType(&s); mod->AddConstructedType(&s);
td.RegisterVariableForTesting(data_var); td.RegisterVariableForTesting(data_var);
mod.AddGlobalVariable(data_var); mod->AddGlobalVariable(data_var);
{ {
ast::VariableList params; ast::VariableList params;
auto* var = create<ast::Variable>( auto* var =
Source{}, // source Var("v", ast::StorageClass::kFunction, ty.f32,
"v", // name create<ast::MemberAccessorExpression>(Expr("data"), Expr("d")),
ast::StorageClass::kFunction, // storage_class ast::VariableDecorationList{});
&f32, // type
false, // is_const
create<ast::MemberAccessorExpression>(
Source{},
create<ast::IdentifierExpression>(
Source{}, mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(Source{}, mod.RegisterSymbol("d"),
"d")), // constructor
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>( auto* body = create<ast::BlockStatement>(ast::StatementList{
Source{}, ast::StatementList{ create<ast::VariableDeclStatement>(var),
create<ast::VariableDeclStatement>(Source{}, var), create<ast::ReturnStatement>(),
create<ast::ReturnStatement>(Source{}), });
});
auto* func = create<ast::Function>( auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("a"), "a", params, &void_type, body, mod->RegisterSymbol("a"), "a", params, ty.void_, body,
ast::FunctionDecorationList{ ast::FunctionDecorationList{
create<ast::StageDecoration>(Source{}, create<ast::StageDecoration>(ast::PipelineStage::kCompute),
ast::PipelineStage::kCompute),
}); });
mod.AddFunction(func); mod->AddFunction(func);
} }
{ {
ast::VariableList params; ast::VariableList params;
auto* var = create<ast::Variable>( auto* var =
Source{}, // source Var("v", ast::StorageClass::kFunction, ty.f32,
"v", // name create<ast::MemberAccessorExpression>(Expr("data"), Expr("d")),
ast::StorageClass::kFunction, // storage_class ast::VariableDecorationList{});
&f32, // type
false, // is_const
create<ast::MemberAccessorExpression>(
Source{},
create<ast::IdentifierExpression>(
Source{}, mod.RegisterSymbol("data"), "data"),
create<ast::IdentifierExpression>(Source{}, mod.RegisterSymbol("d"),
"d")), // constructor
ast::VariableDecorationList{}); // decorations
auto* body = create<ast::BlockStatement>( auto* body = create<ast::BlockStatement>(ast::StatementList{
Source{}, ast::StatementList{ create<ast::VariableDeclStatement>(var),
create<ast::VariableDeclStatement>(Source{}, var), create<ast::ReturnStatement>(),
create<ast::ReturnStatement>(Source{}), });
});
auto* func = create<ast::Function>( auto* func = create<ast::Function>(
Source{}, mod.RegisterSymbol("b"), "b", params, &void_type, body, mod->RegisterSymbol("b"), "b", params, ty.void_, body,
ast::FunctionDecorationList{ ast::FunctionDecorationList{
create<ast::StageDecoration>(Source{}, create<ast::StageDecoration>(ast::PipelineStage::kCompute),
ast::PipelineStage::kCompute),
}); });
mod.AddFunction(func); mod->AddFunction(func);
} }
ASSERT_TRUE(td.Determine()) << td.error(); ASSERT_TRUE(td.Determine()) << td.error();
ASSERT_TRUE(gen.Generate(mod)) << gen.error(); ASSERT_TRUE(gen.Generate(*mod)) << gen.error();
EXPECT_EQ(gen.result(), R"([[block]] EXPECT_EQ(gen.result(), R"([[block]]
struct Data { struct Data {
[[offset(0)]] [[offset(0)]]

4
src/writer/wgsl/generator_impl_identifier_test.cc
View File

@ -24,9 +24,9 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, EmitIdentifierExpression_Single) { TEST_F(WgslGeneratorImplTest, EmitIdentifierExpression_Single) {
ast::IdentifierExpression i(Source{}, mod.RegisterSymbol("glsl"), "glsl"); auto* i = Expr("glsl");
ASSERT_TRUE(gen.EmitExpression(&i)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(i)) << gen.error();
EXPECT_EQ(gen.result(), "glsl"); EXPECT_EQ(gen.result(), "glsl");
} }

104
src/writer/wgsl/generator_impl_if_test.cc
View File

@ -28,17 +28,15 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, Emit_If) { TEST_F(WgslGeneratorImplTest, Emit_If) {
auto* cond = create<ast::IdentifierExpression>( auto* cond = Expr("cond");
Source{}, mod.RegisterSymbol("cond"), "cond"); auto* body = create<ast::BlockStatement>(ast::StatementList{
auto* body = create<ast::BlockStatement>( create<ast::DiscardStatement>(),
Source{}, ast::StatementList{ });
create<ast::DiscardStatement>(Source{}), auto* i = create<ast::IfStatement>(cond, body, ast::ElseStatementList{});
});
ast::IfStatement i(Source{}, cond, body, ast::ElseStatementList{});
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&i)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(i)) << gen.error();
EXPECT_EQ(gen.result(), R"( if (cond) { EXPECT_EQ(gen.result(), R"( if (cond) {
discard; discard;
} }
@ -47,25 +45,22 @@ TEST_F(WgslGeneratorImplTest, Emit_If) {
TEST_F(WgslGeneratorImplTest, Emit_IfWithElseIf) { TEST_F(WgslGeneratorImplTest, Emit_IfWithElseIf) {
auto* else_cond = create<ast::IdentifierExpression>( auto* else_cond = create<ast::IdentifierExpression>(
Source{}, mod.RegisterSymbol("else_cond"), "else_cond"); mod->RegisterSymbol("else_cond"), "else_cond");
auto* else_body = create<ast::BlockStatement>( auto* else_body = create<ast::BlockStatement>(ast::StatementList{
Source{}, ast::StatementList{ create<ast::DiscardStatement>(),
create<ast::DiscardStatement>(Source{}), });
});
auto* cond = create<ast::IdentifierExpression>( auto* cond = Expr("cond");
Source{}, mod.RegisterSymbol("cond"), "cond"); auto* body = create<ast::BlockStatement>(ast::StatementList{
auto* body = create<ast::BlockStatement>( create<ast::DiscardStatement>(),
Source{}, ast::StatementList{ });
create<ast::DiscardStatement>(Source{}), auto* i = create<ast::IfStatement>(
}); cond, body,
ast::IfStatement i( ast::ElseStatementList{create<ast::ElseStatement>(else_cond, else_body)});
Source{}, cond, body,
{create<ast::ElseStatement>(Source{}, else_cond, else_body)});
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&i)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(i)) << gen.error();
EXPECT_EQ(gen.result(), R"( if (cond) { EXPECT_EQ(gen.result(), R"( if (cond) {
discard; discard;
} elseif (else_cond) { } elseif (else_cond) {
@ -75,24 +70,21 @@ TEST_F(WgslGeneratorImplTest, Emit_IfWithElseIf) {
} }
TEST_F(WgslGeneratorImplTest, Emit_IfWithElse) { TEST_F(WgslGeneratorImplTest, Emit_IfWithElse) {
auto* else_body = create<ast::BlockStatement>( auto* else_body = create<ast::BlockStatement>(ast::StatementList{
Source{}, ast::StatementList{ create<ast::DiscardStatement>(),
create<ast::DiscardStatement>(Source{}), });
});
auto* cond = create<ast::IdentifierExpression>( auto* cond = Expr("cond");
Source{}, mod.RegisterSymbol("cond"), "cond"); auto* body = create<ast::BlockStatement>(ast::StatementList{
auto* body = create<ast::BlockStatement>( create<ast::DiscardStatement>(),
Source{}, ast::StatementList{ });
create<ast::DiscardStatement>(Source{}), auto* i = create<ast::IfStatement>(
}); cond, body,
ast::IfStatement i( ast::ElseStatementList{create<ast::ElseStatement>(nullptr, else_body)});
Source{}, cond, body,
{create<ast::ElseStatement>(Source{}, nullptr, else_body)});
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&i)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(i)) << gen.error();
EXPECT_EQ(gen.result(), R"( if (cond) { EXPECT_EQ(gen.result(), R"( if (cond) {
discard; discard;
} else { } else {
@ -103,34 +95,30 @@ TEST_F(WgslGeneratorImplTest, Emit_IfWithElse) {
TEST_F(WgslGeneratorImplTest, Emit_IfWithMultiple) { TEST_F(WgslGeneratorImplTest, Emit_IfWithMultiple) {
auto* else_cond = create<ast::IdentifierExpression>( auto* else_cond = create<ast::IdentifierExpression>(
Source{}, mod.RegisterSymbol("else_cond"), "else_cond"); mod->RegisterSymbol("else_cond"), "else_cond");
auto* else_body = create<ast::BlockStatement>( auto* else_body = create<ast::BlockStatement>(ast::StatementList{
Source{}, ast::StatementList{ create<ast::DiscardStatement>(),
create<ast::DiscardStatement>(Source{}), });
});
auto* else_body_2 = create<ast::BlockStatement>( auto* else_body_2 = create<ast::BlockStatement>(ast::StatementList{
Source{}, ast::StatementList{ create<ast::DiscardStatement>(),
create<ast::DiscardStatement>(Source{}), });
});
auto* cond = create<ast::IdentifierExpression>( auto* cond = Expr("cond");
Source{}, mod.RegisterSymbol("cond"), "cond"); auto* body = create<ast::BlockStatement>(ast::StatementList{
auto* body = create<ast::BlockStatement>( create<ast::DiscardStatement>(),
Source{}, ast::StatementList{ });
create<ast::DiscardStatement>(Source{}), auto* i = create<ast::IfStatement>(
}); cond, body,
ast::IfStatement i( ast::ElseStatementList{
Source{}, cond, body, create<ast::ElseStatement>(else_cond, else_body),
{ create<ast::ElseStatement>(nullptr, else_body_2),
create<ast::ElseStatement>(Source{}, else_cond, else_body),
create<ast::ElseStatement>(Source{}, nullptr, else_body_2),
}); });
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&i)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(i)) << gen.error();
EXPECT_EQ(gen.result(), R"( if (cond) { EXPECT_EQ(gen.result(), R"( if (cond) {
discard; discard;
} elseif (else_cond) { } elseif (else_cond) {

29
src/writer/wgsl/generator_impl_loop_test.cc
View File

@ -28,15 +28,14 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, Emit_Loop) { TEST_F(WgslGeneratorImplTest, Emit_Loop) {
auto* body = create<ast::BlockStatement>( auto* body = create<ast::BlockStatement>(ast::StatementList{
Source{}, ast::StatementList{ create<ast::DiscardStatement>(),
create<ast::DiscardStatement>(Source{}), });
}); auto* l = create<ast::LoopStatement>(body, nullptr);
ast::LoopStatement l(Source{}, body, {});
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&l)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(l)) << gen.error();
EXPECT_EQ(gen.result(), R"( loop { EXPECT_EQ(gen.result(), R"( loop {
discard; discard;
} }
@ -44,19 +43,17 @@ TEST_F(WgslGeneratorImplTest, Emit_Loop) {
} }
TEST_F(WgslGeneratorImplTest, Emit_LoopWithContinuing) { TEST_F(WgslGeneratorImplTest, Emit_LoopWithContinuing) {
auto* body = create<ast::BlockStatement>( auto* body = create<ast::BlockStatement>(ast::StatementList{
Source{}, ast::StatementList{ create<ast::DiscardStatement>(),
create<ast::DiscardStatement>(Source{}), });
}); auto* continuing = create<ast::BlockStatement>(ast::StatementList{
auto* continuing = create<ast::BlockStatement>( create<ast::DiscardStatement>(),
Source{}, ast::StatementList{ });
create<ast::DiscardStatement>(Source{}), auto* l = create<ast::LoopStatement>(body, continuing);
});
ast::LoopStatement l(Source{}, body, continuing);
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&l)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(l)) << gen.error();
EXPECT_EQ(gen.result(), R"( loop { EXPECT_EQ(gen.result(), R"( loop {
discard; discard;

10
src/writer/wgsl/generator_impl_member_accessor_test.cc
View File

@ -28,14 +28,12 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, EmitExpression_MemberAccessor) { TEST_F(WgslGeneratorImplTest, EmitExpression_MemberAccessor) {
auto* str = create<ast::IdentifierExpression>( auto* str = Expr("str");
Source{}, mod.RegisterSymbol("str"), "str"); auto* mem = Expr("mem");
auto* mem = create<ast::IdentifierExpression>(
Source{}, mod.RegisterSymbol("mem"), "mem");
ast::MemberAccessorExpression expr(Source{}, str, mem); auto* expr = create<ast::MemberAccessorExpression>(str, mem);
ASSERT_TRUE(gen.EmitExpression(&expr)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(expr)) << gen.error();
EXPECT_EQ(gen.result(), "str.mem"); EXPECT_EQ(gen.result(), "str.mem");
} }

11
src/writer/wgsl/generator_impl_return_test.cc
View File

@ -29,22 +29,21 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, Emit_Return) { TEST_F(WgslGeneratorImplTest, Emit_Return) {
ast::ReturnStatement r(Source{}); auto* r = create<ast::ReturnStatement>();
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&r)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(r)) << gen.error();
EXPECT_EQ(gen.result(), " return;\n"); EXPECT_EQ(gen.result(), " return;\n");
} }
TEST_F(WgslGeneratorImplTest, Emit_ReturnWithValue) { TEST_F(WgslGeneratorImplTest, Emit_ReturnWithValue) {
auto* expr = create<ast::IdentifierExpression>( auto* expr = Expr("expr");
Source{}, mod.RegisterSymbol("expr"), "expr"); auto* r = create<ast::ReturnStatement>(expr);
ast::ReturnStatement r(Source{}, expr);
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&r)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(r)) << gen.error();
EXPECT_EQ(gen.result(), " return expr;\n"); EXPECT_EQ(gen.result(), " return expr;\n");
} }

29
src/writer/wgsl/generator_impl_switch_test.cc
View File

@ -32,35 +32,30 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, Emit_Switch) { TEST_F(WgslGeneratorImplTest, Emit_Switch) {
auto* def_body = create<ast::BlockStatement>( auto* def_body = create<ast::BlockStatement>(ast::StatementList{
Source{}, ast::StatementList{ create<ast::BreakStatement>(),
create<ast::BreakStatement>(Source{}), });
}); auto* def = create<ast::CaseStatement>(ast::CaseSelectorList{}, def_body);
auto* def =
create<ast::CaseStatement>(Source{}, ast::CaseSelectorList{}, def_body);
ast::type::I32 i32;
ast::CaseSelectorList case_val; ast::CaseSelectorList case_val;
case_val.push_back(create<ast::SintLiteral>(Source{}, &i32, 5)); case_val.push_back(create<ast::SintLiteral>(ty.i32, 5));
auto* case_body = create<ast::BlockStatement>( auto* case_body = create<ast::BlockStatement>(ast::StatementList{
Source{}, ast::StatementList{ create<ast::BreakStatement>(),
create<ast::BreakStatement>(Source{}), });
});
auto* case_stmt = create<ast::CaseStatement>(Source{}, case_val, case_body); auto* case_stmt = create<ast::CaseStatement>(case_val, case_body);
ast::CaseStatementList body; ast::CaseStatementList body;
body.push_back(case_stmt); body.push_back(case_stmt);
body.push_back(def); body.push_back(def);
auto* cond = create<ast::IdentifierExpression>( auto* cond = Expr("cond");
Source{}, mod.RegisterSymbol("cond"), "cond"); auto* s = create<ast::SwitchStatement>(cond, body);
ast::SwitchStatement s(Source{}, cond, body);
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&s)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(s)) << gen.error();
EXPECT_EQ(gen.result(), R"( switch(cond) { EXPECT_EQ(gen.result(), R"( switch(cond) {
case 5: { case 5: {
break; break;

8
src/writer/wgsl/generator_impl_test.cc
View File

@ -32,12 +32,12 @@ using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, Generate) { TEST_F(WgslGeneratorImplTest, Generate) {
ast::type::Void void_type; ast::type::Void void_type;
mod.AddFunction(create<ast::Function>( mod->AddFunction(create<ast::Function>(
Source{}, mod.RegisterSymbol("a_func"), "my_func", ast::VariableList{}, mod->RegisterSymbol("a_func"), "my_func", ast::VariableList{}, &void_type,
&void_type, create<ast::BlockStatement>(Source{}, ast::StatementList{}), create<ast::BlockStatement>(ast::StatementList{}),
ast::FunctionDecorationList{})); ast::FunctionDecorationList{}));
ASSERT_TRUE(gen.Generate(mod)) << gen.error(); ASSERT_TRUE(gen.Generate(*mod)) << gen.error();
EXPECT_EQ(gen.result(), R"(fn my_func() -> void { EXPECT_EQ(gen.result(), R"(fn my_func() -> void {
} }

147
src/writer/wgsl/generator_impl_type_test.cc
View File

@ -48,66 +48,59 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, EmitType_Alias) { TEST_F(WgslGeneratorImplTest, EmitType_Alias) {
ast::type::F32 f32; ast::type::Alias alias(mod->RegisterSymbol("alias"), "alias", ty.f32);
ast::type::Alias alias(mod.RegisterSymbol("alias"), "alias", &f32);
ASSERT_TRUE(gen.EmitType(&alias)) << gen.error(); ASSERT_TRUE(gen.EmitType(&alias)) << gen.error();
EXPECT_EQ(gen.result(), "alias"); EXPECT_EQ(gen.result(), "alias");
} }
TEST_F(WgslGeneratorImplTest, EmitType_Array) { TEST_F(WgslGeneratorImplTest, EmitType_Array) {
ast::type::Bool b; ASSERT_TRUE(gen.EmitType(ty.array<bool, 4>())) << gen.error();
ast::type::Array a(&b, 4, ast::ArrayDecorationList{});
ASSERT_TRUE(gen.EmitType(&a)) << gen.error();
EXPECT_EQ(gen.result(), "array<bool, 4>"); EXPECT_EQ(gen.result(), "array<bool, 4>");
} }
TEST_F(WgslGeneratorImplTest, EmitType_AccessControl_Read) { TEST_F(WgslGeneratorImplTest, EmitType_AccessControl_Read) {
ast::type::I32 i32; auto* mem =
create<ast::StructMember>("a", ty.i32, ast::StructMemberDecorationList{});
ast::StructMember mem(Source{}, "a", &i32, ast::StructMemberDecorationList{});
ast::StructMemberList members; 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; ast::StructDecorationList decos;
decos.push_back(&block_deco); decos.push_back(block_deco);
ast::Struct str(Source{}, members, decos); auto* str = create<ast::Struct>(members, decos);
ast::type::Struct s(mod.RegisterSymbol("S"), "S", &str); auto* s = create<ast::type::Struct>(mod->RegisterSymbol("S"), "S", str);
ast::type::AccessControl a(ast::AccessControl::kReadOnly, &s); ast::type::AccessControl a(ast::AccessControl::kReadOnly, s);
ASSERT_TRUE(gen.EmitType(&a)) << gen.error(); ASSERT_TRUE(gen.EmitType(&a)) << gen.error();
EXPECT_EQ(gen.result(), "[[access(read)]]\nS"); EXPECT_EQ(gen.result(), "[[access(read)]]\nS");
} }
TEST_F(WgslGeneratorImplTest, EmitType_AccessControl_ReadWrite) { TEST_F(WgslGeneratorImplTest, EmitType_AccessControl_ReadWrite) {
ast::type::I32 i32; auto* mem =
create<ast::StructMember>("a", ty.i32, ast::StructMemberDecorationList{});
ast::StructMember mem(Source{}, "a", &i32, ast::StructMemberDecorationList{});
ast::StructMemberList members; 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; ast::StructDecorationList decos;
decos.push_back(&block_deco); decos.push_back(block_deco);
ast::Struct str(Source{}, members, decos); auto* str = create<ast::Struct>(members, decos);
ast::type::Struct s(mod.RegisterSymbol("S"), "S", &str); auto* s = create<ast::type::Struct>(mod->RegisterSymbol("S"), "S", str);
ast::type::AccessControl a(ast::AccessControl::kReadWrite, &s); ast::type::AccessControl a(ast::AccessControl::kReadWrite, s);
ASSERT_TRUE(gen.EmitType(&a)) << gen.error(); ASSERT_TRUE(gen.EmitType(&a)) << gen.error();
EXPECT_EQ(gen.result(), "[[access(read_write)]]\nS"); EXPECT_EQ(gen.result(), "[[access(read_write)]]\nS");
} }
TEST_F(WgslGeneratorImplTest, EmitType_Array_Decoration) { TEST_F(WgslGeneratorImplTest, EmitType_Array_Decoration) {
ast::type::Bool b; ast::type::Array a(ty.bool_, 4,
ast::type::Array a(&b, 4,
ast::ArrayDecorationList{ ast::ArrayDecorationList{
create<ast::StrideDecoration>(Source{}, 16u), create<ast::StrideDecoration>(16u),
}); });
ASSERT_TRUE(gen.EmitType(&a)) << gen.error(); ASSERT_TRUE(gen.EmitType(&a)) << gen.error();
@ -115,11 +108,10 @@ TEST_F(WgslGeneratorImplTest, EmitType_Array_Decoration) {
} }
TEST_F(WgslGeneratorImplTest, EmitType_Array_MultipleDecorations) { TEST_F(WgslGeneratorImplTest, EmitType_Array_MultipleDecorations) {
ast::type::Bool b; ast::type::Array a(ty.bool_, 4,
ast::type::Array a(&b, 4,
ast::ArrayDecorationList{ ast::ArrayDecorationList{
create<ast::StrideDecoration>(Source{}, 16u), create<ast::StrideDecoration>(16u),
create<ast::StrideDecoration>(Source{}, 32u), create<ast::StrideDecoration>(32u),
}); });
ASSERT_TRUE(gen.EmitType(&a)) << gen.error(); ASSERT_TRUE(gen.EmitType(&a)) << gen.error();
@ -127,87 +119,68 @@ TEST_F(WgslGeneratorImplTest, EmitType_Array_MultipleDecorations) {
} }
TEST_F(WgslGeneratorImplTest, EmitType_RuntimeArray) { TEST_F(WgslGeneratorImplTest, EmitType_RuntimeArray) {
ast::type::Bool b; ast::type::Array a(ty.bool_, 0, ast::ArrayDecorationList{});
ast::type::Array a(&b, 0, ast::ArrayDecorationList{});
ASSERT_TRUE(gen.EmitType(&a)) << gen.error(); ASSERT_TRUE(gen.EmitType(&a)) << gen.error();
EXPECT_EQ(gen.result(), "array<bool>"); EXPECT_EQ(gen.result(), "array<bool>");
} }
TEST_F(WgslGeneratorImplTest, EmitType_Bool) { TEST_F(WgslGeneratorImplTest, EmitType_Bool) {
ast::type::Bool b; ASSERT_TRUE(gen.EmitType(ty.bool_)) << gen.error();
ASSERT_TRUE(gen.EmitType(&b)) << gen.error();
EXPECT_EQ(gen.result(), "bool"); EXPECT_EQ(gen.result(), "bool");
} }
TEST_F(WgslGeneratorImplTest, EmitType_F32) { TEST_F(WgslGeneratorImplTest, EmitType_F32) {
ast::type::F32 f32; ASSERT_TRUE(gen.EmitType(ty.f32)) << gen.error();
ASSERT_TRUE(gen.EmitType(&f32)) << gen.error();
EXPECT_EQ(gen.result(), "f32"); EXPECT_EQ(gen.result(), "f32");
} }
TEST_F(WgslGeneratorImplTest, EmitType_I32) { TEST_F(WgslGeneratorImplTest, EmitType_I32) {
ast::type::I32 i32; ASSERT_TRUE(gen.EmitType(ty.i32)) << gen.error();
ASSERT_TRUE(gen.EmitType(&i32)) << gen.error();
EXPECT_EQ(gen.result(), "i32"); EXPECT_EQ(gen.result(), "i32");
} }
TEST_F(WgslGeneratorImplTest, EmitType_Matrix) { TEST_F(WgslGeneratorImplTest, EmitType_Matrix) {
ast::type::F32 f32; ASSERT_TRUE(gen.EmitType(ty.mat2x3<f32>())) << gen.error();
ast::type::Matrix m(&f32, 3, 2);
ASSERT_TRUE(gen.EmitType(&m)) << gen.error();
EXPECT_EQ(gen.result(), "mat2x3<f32>"); EXPECT_EQ(gen.result(), "mat2x3<f32>");
} }
TEST_F(WgslGeneratorImplTest, EmitType_Pointer) { TEST_F(WgslGeneratorImplTest, EmitType_Pointer) {
ast::type::F32 f32; ast::type::Pointer p(ty.f32, ast::StorageClass::kWorkgroup);
ast::type::Pointer p(&f32, ast::StorageClass::kWorkgroup);
ASSERT_TRUE(gen.EmitType(&p)) << gen.error(); ASSERT_TRUE(gen.EmitType(&p)) << gen.error();
EXPECT_EQ(gen.result(), "ptr<workgroup, f32>"); EXPECT_EQ(gen.result(), "ptr<workgroup, f32>");
} }
TEST_F(WgslGeneratorImplTest, EmitType_Struct) { TEST_F(WgslGeneratorImplTest, EmitType_Struct) {
ast::type::I32 i32;
ast::type::F32 f32;
ast::StructMemberList members; ast::StructMemberList members;
members.push_back(create<ast::StructMember>( members.push_back(create<ast::StructMember>(
Source{}, "a", &i32, ast::StructMemberDecorationList{})); "a", ty.i32, ast::StructMemberDecorationList{}));
ast::StructMemberDecorationList b_deco; ast::StructMemberDecorationList b_deco;
b_deco.push_back(create<ast::StructMemberOffsetDecoration>(Source{}, 4)); b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4));
members.push_back(create<ast::StructMember>(Source{}, "b", &f32, b_deco)); members.push_back(create<ast::StructMember>("b", ty.f32, b_deco));
auto* str = auto* str = create<ast::Struct>(members, ast::StructDecorationList{});
create<ast::Struct>(Source{}, members, ast::StructDecorationList{});
ast::type::Struct s(mod.RegisterSymbol("S"), "S", str); ast::type::Struct s(mod->RegisterSymbol("S"), "S", str);
ASSERT_TRUE(gen.EmitType(&s)) << gen.error(); ASSERT_TRUE(gen.EmitType(&s)) << gen.error();
EXPECT_EQ(gen.result(), "S"); EXPECT_EQ(gen.result(), "S");
} }
TEST_F(WgslGeneratorImplTest, EmitType_StructDecl) { TEST_F(WgslGeneratorImplTest, EmitType_StructDecl) {
ast::type::I32 i32;
ast::type::F32 f32;
ast::StructMemberList members; ast::StructMemberList members;
members.push_back(create<ast::StructMember>( members.push_back(create<ast::StructMember>(
Source{}, "a", &i32, ast::StructMemberDecorationList{})); "a", ty.i32, ast::StructMemberDecorationList{}));
ast::StructMemberDecorationList b_deco; ast::StructMemberDecorationList b_deco;
b_deco.push_back(create<ast::StructMemberOffsetDecoration>(Source{}, 4)); b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4));
members.push_back(create<ast::StructMember>(Source{}, "b", &f32, b_deco)); members.push_back(create<ast::StructMember>("b", ty.f32, b_deco));
auto* str = auto* str = create<ast::Struct>(members, ast::StructDecorationList{});
create<ast::Struct>(Source{}, members, ast::StructDecorationList{});
ast::type::Struct s(mod.RegisterSymbol("S"), "S", str); ast::type::Struct s(mod->RegisterSymbol("S"), "S", str);
ASSERT_TRUE(gen.EmitStructType(&s)) << gen.error(); ASSERT_TRUE(gen.EmitStructType(&s)) << gen.error();
EXPECT_EQ(gen.result(), R"(struct S { EXPECT_EQ(gen.result(), R"(struct S {
@ -219,23 +192,20 @@ TEST_F(WgslGeneratorImplTest, EmitType_StructDecl) {
} }
TEST_F(WgslGeneratorImplTest, EmitType_Struct_WithDecoration) { TEST_F(WgslGeneratorImplTest, EmitType_Struct_WithDecoration) {
ast::type::I32 i32;
ast::type::F32 f32;
ast::StructMemberList members; ast::StructMemberList members;
members.push_back(create<ast::StructMember>( members.push_back(create<ast::StructMember>(
Source{}, "a", &i32, ast::StructMemberDecorationList{})); "a", ty.i32, ast::StructMemberDecorationList{}));
ast::StructMemberDecorationList b_deco; ast::StructMemberDecorationList b_deco;
b_deco.push_back(create<ast::StructMemberOffsetDecoration>(Source{}, 4)); b_deco.push_back(create<ast::StructMemberOffsetDecoration>(4));
members.push_back(create<ast::StructMember>(Source{}, "b", &f32, b_deco)); members.push_back(create<ast::StructMember>("b", ty.f32, b_deco));
ast::StructDecorationList decos; ast::StructDecorationList decos;
decos.push_back(create<ast::StructBlockDecoration>(Source{})); decos.push_back(create<ast::StructBlockDecoration>());
auto* str = create<ast::Struct>(Source{}, members, decos); auto* str = create<ast::Struct>(members, decos);
ast::type::Struct s(mod.RegisterSymbol("S"), "S", str); ast::type::Struct s(mod->RegisterSymbol("S"), "S", str);
ASSERT_TRUE(gen.EmitStructType(&s)) << gen.error(); ASSERT_TRUE(gen.EmitStructType(&s)) << gen.error();
EXPECT_EQ(gen.result(), R"([[block]] EXPECT_EQ(gen.result(), R"([[block]]
@ -248,17 +218,12 @@ struct S {
} }
TEST_F(WgslGeneratorImplTest, EmitType_U32) { TEST_F(WgslGeneratorImplTest, EmitType_U32) {
ast::type::U32 u32; ASSERT_TRUE(gen.EmitType(ty.u32)) << gen.error();
ASSERT_TRUE(gen.EmitType(&u32)) << gen.error();
EXPECT_EQ(gen.result(), "u32"); EXPECT_EQ(gen.result(), "u32");
} }
TEST_F(WgslGeneratorImplTest, EmitType_Vector) { TEST_F(WgslGeneratorImplTest, EmitType_Vector) {
ast::type::F32 f32; ASSERT_TRUE(gen.EmitType(ty.vec3<f32>())) << gen.error();
ast::type::Vector v(&f32, 3);
ASSERT_TRUE(gen.EmitType(&v)) << gen.error();
EXPECT_EQ(gen.result(), "vec3<f32>"); EXPECT_EQ(gen.result(), "vec3<f32>");
} }
@ -302,8 +267,7 @@ using WgslGenerator_SampledTextureTest = TestParamHelper<TextureData>;
TEST_P(WgslGenerator_SampledTextureTest, EmitType_SampledTexture_F32) { TEST_P(WgslGenerator_SampledTextureTest, EmitType_SampledTexture_F32) {
auto param = GetParam(); auto param = GetParam();
ast::type::F32 f32; ast::type::SampledTexture t(param.dim, ty.f32);
ast::type::SampledTexture t(param.dim, &f32);
ASSERT_TRUE(gen.EmitType(&t)) << gen.error(); ASSERT_TRUE(gen.EmitType(&t)) << gen.error();
EXPECT_EQ(gen.result(), std::string(param.name) + "<f32>"); EXPECT_EQ(gen.result(), std::string(param.name) + "<f32>");
@ -312,8 +276,7 @@ TEST_P(WgslGenerator_SampledTextureTest, EmitType_SampledTexture_F32) {
TEST_P(WgslGenerator_SampledTextureTest, EmitType_SampledTexture_I32) { TEST_P(WgslGenerator_SampledTextureTest, EmitType_SampledTexture_I32) {
auto param = GetParam(); auto param = GetParam();
ast::type::I32 i32; ast::type::SampledTexture t(param.dim, ty.i32);
ast::type::SampledTexture t(param.dim, &i32);
ASSERT_TRUE(gen.EmitType(&t)) << gen.error(); ASSERT_TRUE(gen.EmitType(&t)) << gen.error();
EXPECT_EQ(gen.result(), std::string(param.name) + "<i32>"); EXPECT_EQ(gen.result(), std::string(param.name) + "<i32>");
@ -322,8 +285,7 @@ TEST_P(WgslGenerator_SampledTextureTest, EmitType_SampledTexture_I32) {
TEST_P(WgslGenerator_SampledTextureTest, EmitType_SampledTexture_U32) { TEST_P(WgslGenerator_SampledTextureTest, EmitType_SampledTexture_U32) {
auto param = GetParam(); auto param = GetParam();
ast::type::U32 u32; ast::type::SampledTexture t(param.dim, ty.u32);
ast::type::SampledTexture t(param.dim, &u32);
ASSERT_TRUE(gen.EmitType(&t)) << gen.error(); ASSERT_TRUE(gen.EmitType(&t)) << gen.error();
EXPECT_EQ(gen.result(), std::string(param.name) + "<u32>"); EXPECT_EQ(gen.result(), std::string(param.name) + "<u32>");
@ -345,8 +307,7 @@ using WgslGenerator_MultiampledTextureTest = TestParamHelper<TextureData>;
TEST_P(WgslGenerator_MultiampledTextureTest, EmitType_MultisampledTexture_F32) { TEST_P(WgslGenerator_MultiampledTextureTest, EmitType_MultisampledTexture_F32) {
auto param = GetParam(); auto param = GetParam();
ast::type::F32 f32; ast::type::MultisampledTexture t(param.dim, ty.f32);
ast::type::MultisampledTexture t(param.dim, &f32);
ASSERT_TRUE(gen.EmitType(&t)) << gen.error(); ASSERT_TRUE(gen.EmitType(&t)) << gen.error();
EXPECT_EQ(gen.result(), std::string(param.name) + "<f32>"); EXPECT_EQ(gen.result(), std::string(param.name) + "<f32>");
@ -355,8 +316,7 @@ TEST_P(WgslGenerator_MultiampledTextureTest, EmitType_MultisampledTexture_F32) {
TEST_P(WgslGenerator_MultiampledTextureTest, EmitType_MultisampledTexture_I32) { TEST_P(WgslGenerator_MultiampledTextureTest, EmitType_MultisampledTexture_I32) {
auto param = GetParam(); auto param = GetParam();
ast::type::I32 i32; ast::type::MultisampledTexture t(param.dim, ty.i32);
ast::type::MultisampledTexture t(param.dim, &i32);
ASSERT_TRUE(gen.EmitType(&t)) << gen.error(); ASSERT_TRUE(gen.EmitType(&t)) << gen.error();
EXPECT_EQ(gen.result(), std::string(param.name) + "<i32>"); EXPECT_EQ(gen.result(), std::string(param.name) + "<i32>");
@ -365,8 +325,7 @@ TEST_P(WgslGenerator_MultiampledTextureTest, EmitType_MultisampledTexture_I32) {
TEST_P(WgslGenerator_MultiampledTextureTest, EmitType_MultisampledTexture_U32) { TEST_P(WgslGenerator_MultiampledTextureTest, EmitType_MultisampledTexture_U32) {
auto param = GetParam(); auto param = GetParam();
ast::type::U32 u32; ast::type::MultisampledTexture t(param.dim, ty.u32);
ast::type::MultisampledTexture t(param.dim, &u32);
ASSERT_TRUE(gen.EmitType(&t)) << gen.error(); ASSERT_TRUE(gen.EmitType(&t)) << gen.error();
EXPECT_EQ(gen.result(), std::string(param.name) + "<u32>"); EXPECT_EQ(gen.result(), std::string(param.name) + "<u32>");

7
src/writer/wgsl/generator_impl_unary_op_test.cc
View File

@ -38,11 +38,10 @@ using WgslUnaryOpTest = TestParamHelper<UnaryOpData>;
TEST_P(WgslUnaryOpTest, Emit) { TEST_P(WgslUnaryOpTest, Emit) {
auto params = GetParam(); auto params = GetParam();
auto* expr = create<ast::IdentifierExpression>( auto* expr = Expr("expr");
Source{}, mod.RegisterSymbol("expr"), "expr"); auto* op = create<ast::UnaryOpExpression>(params.op, expr);
ast::UnaryOpExpression op(Source{}, params.op, expr);
ASSERT_TRUE(gen.EmitExpression(&op)) << gen.error(); ASSERT_TRUE(gen.EmitExpression(op)) << gen.error();
EXPECT_EQ(gen.result(), std::string(params.name) + "(expr)"); EXPECT_EQ(gen.result(), std::string(params.name) + "(expr)");
} }
INSTANTIATE_TEST_SUITE_P(WgslGeneratorImplTest, INSTANTIATE_TEST_SUITE_P(WgslGeneratorImplTest,

43
src/writer/wgsl/generator_impl_variable_decl_statement_test.cc
View File

@ -31,21 +31,13 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, Emit_VariableDeclStatement) { TEST_F(WgslGeneratorImplTest, Emit_VariableDeclStatement) {
ast::type::F32 f32; auto* var = Var("a", ast::StorageClass::kNone, ty.f32);
auto* var =
create<ast::Variable>(Source{}, // source
"a", // name
ast::StorageClass::kNone, // storage_class
&f32, // type
false, // is_const
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
ast::VariableDeclStatement stmt(Source{}, var); auto* stmt = create<ast::VariableDeclStatement>(var);
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), " var a : f32;\n"); EXPECT_EQ(gen.result(), " var a : f32;\n");
} }
@ -53,40 +45,25 @@ TEST_F(WgslGeneratorImplTest, Emit_VariableDeclStatement_Function) {
// Variable declarations with Function storage class don't mention their // Variable declarations with Function storage class don't mention their
// storage class. Rely on defaulting. // storage class. Rely on defaulting.
// https://github.com/gpuweb/gpuweb/issues/654 // https://github.com/gpuweb/gpuweb/issues/654
ast::type::F32 f32;
auto* var =
create<ast::Variable>(Source{}, // source
"a", // name
ast::StorageClass::kFunction, // storage_class
&f32, // type
false, // is_const
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
ast::VariableDeclStatement stmt(Source{}, var); auto* var = Var("a", ast::StorageClass::kFunction, ty.f32);
auto* stmt = create<ast::VariableDeclStatement>(var);
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), " var a : f32;\n"); EXPECT_EQ(gen.result(), " var a : f32;\n");
} }
TEST_F(WgslGeneratorImplTest, Emit_VariableDeclStatement_Private) { TEST_F(WgslGeneratorImplTest, Emit_VariableDeclStatement_Private) {
ast::type::F32 f32; auto* var = Var("a", ast::StorageClass::kPrivate, ty.f32);
auto* var =
create<ast::Variable>(Source{}, // source
"a", // name
ast::StorageClass::kPrivate, // storage_class
&f32, // type
false, // is_const
nullptr, // constructor
ast::VariableDecorationList{}); // decorations
ast::VariableDeclStatement stmt(Source{}, var); auto* stmt = create<ast::VariableDeclStatement>(var);
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.EmitStatement(&stmt)) << gen.error(); ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
EXPECT_EQ(gen.result(), " var<private> a : f32;\n"); EXPECT_EQ(gen.result(), " var<private> a : f32;\n");
} }

61
src/writer/wgsl/generator_impl_variable_test.cc
View File

@ -34,52 +34,43 @@ namespace {
using WgslGeneratorImplTest = TestHelper; using WgslGeneratorImplTest = TestHelper;
TEST_F(WgslGeneratorImplTest, EmitVariable) { TEST_F(WgslGeneratorImplTest, EmitVariable) {
ast::type::F32 f32; auto* v = Var("a", ast::StorageClass::kNone, ty.f32);
ast::Variable v(Source{}, "a", ast::StorageClass::kNone, &f32, false, nullptr,
ast::VariableDecorationList{});
ASSERT_TRUE(gen.EmitVariable(&v)) << gen.error(); ASSERT_TRUE(gen.EmitVariable(v)) << gen.error();
EXPECT_EQ(gen.result(), R"(var a : f32; EXPECT_EQ(gen.result(), R"(var a : f32;
)"); )");
} }
TEST_F(WgslGeneratorImplTest, EmitVariable_StorageClass) { TEST_F(WgslGeneratorImplTest, EmitVariable_StorageClass) {
ast::type::F32 f32; auto* v = Var("a", ast::StorageClass::kInput, ty.f32);
ast::Variable v(Source{}, "a", ast::StorageClass::kInput, &f32, false,
nullptr, ast::VariableDecorationList{});
ASSERT_TRUE(gen.EmitVariable(&v)) << gen.error(); ASSERT_TRUE(gen.EmitVariable(v)) << gen.error();
EXPECT_EQ(gen.result(), R"(var<in> a : f32; EXPECT_EQ(gen.result(), R"(var<in> a : f32;
)"); )");
} }
TEST_F(WgslGeneratorImplTest, EmitVariable_Decorated) { TEST_F(WgslGeneratorImplTest, EmitVariable_Decorated) {
ast::type::F32 f32; auto* v = Var("a", ast::StorageClass::kNone, ty.f32, nullptr,
ast::VariableDecorationList{
create<ast::LocationDecoration>(2),
});
ast::Variable v(Source{}, "a", ast::StorageClass::kNone, &f32, false, nullptr, ASSERT_TRUE(gen.EmitVariable(v)) << gen.error();
ast::VariableDecorationList{
create<ast::LocationDecoration>(Source{}, 2),
});
ASSERT_TRUE(gen.EmitVariable(&v)) << gen.error();
EXPECT_EQ(gen.result(), R"([[location(2)]] var a : f32; EXPECT_EQ(gen.result(), R"([[location(2)]] var a : f32;
)"); )");
} }
TEST_F(WgslGeneratorImplTest, EmitVariable_Decorated_Multiple) { TEST_F(WgslGeneratorImplTest, EmitVariable_Decorated_Multiple) {
ast::type::F32 f32; auto* v = Var("a", ast::StorageClass::kNone, ty.f32, nullptr,
ast::VariableDecorationList{
create<ast::BuiltinDecoration>(ast::Builtin::kPosition),
create<ast::BindingDecoration>(0),
create<ast::SetDecoration>(1),
create<ast::LocationDecoration>(2),
create<ast::ConstantIdDecoration>(42),
});
ast::Variable v( ASSERT_TRUE(gen.EmitVariable(v)) << gen.error();
Source{}, "a", ast::StorageClass::kNone, &f32, false, nullptr,
ast::VariableDecorationList{
create<ast::BuiltinDecoration>(Source{}, ast::Builtin::kPosition),
create<ast::BindingDecoration>(Source{}, 0),
create<ast::SetDecoration>(Source{}, 1),
create<ast::LocationDecoration>(Source{}, 2),
create<ast::ConstantIdDecoration>(Source{}, 42),
});
ASSERT_TRUE(gen.EmitVariable(&v)) << gen.error();
EXPECT_EQ( EXPECT_EQ(
gen.result(), gen.result(),
R"([[builtin(position), binding(0), set(1), location(2), constant_id(42)]] var a : f32; R"([[builtin(position), binding(0), set(1), location(2), constant_id(42)]] var a : f32;
@ -88,26 +79,24 @@ TEST_F(WgslGeneratorImplTest, EmitVariable_Decorated_Multiple) {
TEST_F(WgslGeneratorImplTest, EmitVariable_Constructor) { TEST_F(WgslGeneratorImplTest, EmitVariable_Constructor) {
auto* ident = create<ast::IdentifierExpression>( auto* ident = create<ast::IdentifierExpression>(
Source{}, mod.RegisterSymbol("initializer"), "initializer"); mod->RegisterSymbol("initializer"), "initializer");
ast::type::F32 f32; auto* v = Var("a", ast::StorageClass::kNone, ty.f32, ident,
ast::Variable v(Source{}, "a", ast::StorageClass::kNone, &f32, false, ident, ast::VariableDecorationList{});
ast::VariableDecorationList{});
ASSERT_TRUE(gen.EmitVariable(&v)) << gen.error(); ASSERT_TRUE(gen.EmitVariable(v)) << gen.error();
EXPECT_EQ(gen.result(), R"(var a : f32 = initializer; EXPECT_EQ(gen.result(), R"(var a : f32 = initializer;
)"); )");
} }
TEST_F(WgslGeneratorImplTest, EmitVariable_Const) { TEST_F(WgslGeneratorImplTest, EmitVariable_Const) {
auto* ident = create<ast::IdentifierExpression>( auto* ident = create<ast::IdentifierExpression>(
Source{}, mod.RegisterSymbol("initializer"), "initializer"); mod->RegisterSymbol("initializer"), "initializer");
ast::type::F32 f32; auto* v = Const("a", ast::StorageClass::kNone, ty.f32, ident,
ast::Variable v(Source{}, "a", ast::StorageClass::kNone, &f32, true, ident,
ast::VariableDecorationList{}); ast::VariableDecorationList{});
ASSERT_TRUE(gen.EmitVariable(&v)) << gen.error(); ASSERT_TRUE(gen.EmitVariable(v)) << gen.error();
EXPECT_EQ(gen.result(), R"(const a : f32 = initializer; EXPECT_EQ(gen.result(), R"(const a : f32 = initializer;
)"); )");
} }

17
src/writer/wgsl/test_helper.h
View File

@ -19,7 +19,7 @@
#include <utility> #include <utility>
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "src/ast/module.h" #include "src/ast/builder.h"
#include "src/type_determiner.h" #include "src/type_determiner.h"
#include "src/writer/wgsl/generator_impl.h" #include "src/writer/wgsl/generator_impl.h"
@ -29,23 +29,12 @@ namespace wgsl {
/// Helper class for testing /// Helper class for testing
template <typename BASE> template <typename BASE>
class TestHelperBase : public BASE { class TestHelperBase : public BASE, public ast::BuilderWithModule {
public: public:
TestHelperBase() : td(&mod), gen() {} TestHelperBase() : td(mod), gen() {}
~TestHelperBase() = default; ~TestHelperBase() = default;
/// Creates a new `ast::Node` owned by the Module. When the Module is
/// destructed, the `ast::Node` will also be destructed.
/// @param args the arguments to pass to the type constructor
/// @returns the node pointer
template <typename T, typename... ARGS>
T* create(ARGS&&... args) {
return mod.create<T>(std::forward<ARGS>(args)...);
}
/// The module
ast::Module mod;
/// The type determiner /// The type determiner
TypeDeterminer td; TypeDeterminer td;
/// The generator /// The generator