tint: Change all ProgramBuilder literals to 'i' or 'u' suffix
Unsuffixed integer literals are currently treated as i32,
but will shortly become AbstractInteger. To keep tests behaving
identically to how they are currently, change all test literals
to using either 'i' or 'u' suffixes.
Bug: tint:1504
Change-Id: Ic373d18ce1c718a16b6905568aec89da3641d36b
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/88845
Reviewed-by: Dan Sinclair <dsinclair@chromium.org>
Commit-Queue: Ben Clayton <bclayton@google.com>
diff --git a/src/tint/resolver/array_accessor_test.cc b/src/tint/resolver/array_accessor_test.cc
index d227ce4..1704699 100644
--- a/src/tint/resolver/array_accessor_test.cc
+++ b/src/tint/resolver/array_accessor_test.cc
@@ -18,6 +18,8 @@
#include "src/tint/resolver/resolver_test_helper.h"
#include "src/tint/sem/reference.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -43,8 +45,8 @@
TEST_F(ResolverIndexAccessorTest, Matrix_BothDimensions_Dynamic_Ref) {
Global("my_var", ty.mat4x4<f32>(), ast::StorageClass::kPrivate);
- auto* idx = Var("idx", ty.u32(), Expr(3u));
- auto* idy = Var("idy", ty.u32(), Expr(2u));
+ auto* idx = Var("idx", ty.u32(), Expr(3_u));
+ auto* idy = Var("idy", ty.u32(), Expr(2_u));
auto* acc = IndexAccessor(IndexAccessor("my_var", idx), idy);
WrapInFunction(Decl(idx), Decl(idy), acc);
@@ -63,7 +65,7 @@
TEST_F(ResolverIndexAccessorTest, Matrix_XDimension_Dynamic) {
GlobalConst("my_var", ty.mat4x4<f32>(), Construct(ty.mat4x4<f32>()));
- auto* idx = Var("idx", ty.u32(), Expr(3u));
+ auto* idx = Var("idx", ty.u32(), Expr(3_u));
auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, idx));
WrapInFunction(Decl(idx), acc);
@@ -73,8 +75,8 @@
TEST_F(ResolverIndexAccessorTest, Matrix_BothDimension_Dynamic) {
GlobalConst("my_var", ty.mat4x4<f32>(), Construct(ty.mat4x4<f32>()));
- auto* idx = Var("idy", ty.u32(), Expr(2u));
- auto* acc = IndexAccessor(IndexAccessor("my_var", Expr(Source{{12, 34}}, idx)), 1);
+ auto* idx = Var("idy", ty.u32(), Expr(2_u));
+ auto* acc = IndexAccessor(IndexAccessor("my_var", Expr(Source{{12, 34}}, idx)), 1_i);
WrapInFunction(Decl(idx), acc);
EXPECT_TRUE(r()->Resolve());
@@ -84,7 +86,7 @@
TEST_F(ResolverIndexAccessorTest, Matrix) {
Global("my_var", ty.mat2x3<f32>(), ast::StorageClass::kPrivate);
- auto* acc = IndexAccessor("my_var", 2);
+ auto* acc = IndexAccessor("my_var", 2_i);
WrapInFunction(acc);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -100,7 +102,7 @@
TEST_F(ResolverIndexAccessorTest, Matrix_BothDimensions) {
Global("my_var", ty.mat2x3<f32>(), ast::StorageClass::kPrivate);
- auto* acc = IndexAccessor(IndexAccessor("my_var", 2), 1);
+ auto* acc = IndexAccessor(IndexAccessor("my_var", 2_i), 1_i);
WrapInFunction(acc);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -123,7 +125,7 @@
TEST_F(ResolverIndexAccessorTest, Vector_Dynamic_Ref) {
Global("my_var", ty.vec3<f32>(), ast::StorageClass::kPrivate);
- auto* idx = Var("idx", ty.i32(), Expr(2));
+ auto* idx = Var("idx", ty.i32(), Expr(2_i));
auto* acc = IndexAccessor("my_var", idx);
WrapInFunction(Decl(idx), acc);
@@ -132,7 +134,7 @@
TEST_F(ResolverIndexAccessorTest, Vector_Dynamic) {
GlobalConst("my_var", ty.vec3<f32>(), Construct(ty.vec3<f32>()));
- auto* idx = Var("idx", ty.i32(), Expr(2));
+ auto* idx = Var("idx", ty.i32(), Expr(2_i));
auto* acc = IndexAccessor("my_var", Expr(Source{{12, 34}}, idx));
WrapInFunction(Decl(idx), acc);
@@ -142,7 +144,7 @@
TEST_F(ResolverIndexAccessorTest, Vector) {
Global("my_var", ty.vec3<f32>(), ast::StorageClass::kPrivate);
- auto* acc = IndexAccessor("my_var", 2);
+ auto* acc = IndexAccessor("my_var", 2_i);
WrapInFunction(acc);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -155,7 +157,7 @@
}
TEST_F(ResolverIndexAccessorTest, Array) {
- auto* idx = Expr(2);
+ auto* idx = Expr(2_i);
Global("my_var", ty.array<f32, 3>(), ast::StorageClass::kPrivate);
auto* acc = IndexAccessor("my_var", idx);
@@ -175,7 +177,7 @@
Global("my_var", ty.Of(aary), ast::StorageClass::kPrivate);
- auto* acc = IndexAccessor("my_var", 2);
+ auto* acc = IndexAccessor("my_var", 2_i);
WrapInFunction(acc);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -190,7 +192,7 @@
TEST_F(ResolverIndexAccessorTest, Array_Constant) {
GlobalConst("my_var", ty.array<f32, 3>(), array<f32, 3>());
- auto* acc = IndexAccessor("my_var", 2);
+ auto* acc = IndexAccessor("my_var", 2_i);
WrapInFunction(acc);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -235,9 +237,9 @@
TEST_F(ResolverIndexAccessorTest, Array_Literal_I32) {
// let a : array<f32, 3>;
- // var f : f32 = a[2];
+ // var f : f32 = a[2i];
auto* a = Let("a", ty.array<f32, 3>(), array<f32, 3>());
- auto* f = Var("a_2", ty.f32(), IndexAccessor("a", 2));
+ auto* f = Var("a_2", ty.f32(), IndexAccessor("a", 2_i));
Func("my_func", ast::VariableList{}, ty.void_(),
{
Decl(a),
diff --git a/src/tint/resolver/assignment_validation_test.cc b/src/tint/resolver/assignment_validation_test.cc
index 36ea1ed..f12f804 100644
--- a/src/tint/resolver/assignment_validation_test.cc
+++ b/src/tint/resolver/assignment_validation_test.cc
@@ -18,6 +18,8 @@
#include "src/tint/resolver/resolver_test_helper.h"
#include "src/tint/sem/storage_texture.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -34,7 +36,7 @@
create<ast::GroupAttribute>(0),
});
- WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("a", "m"), 1));
+ WrapInFunction(Assign(Source{{56, 78}}, MemberAccessor("a", "m"), 1_i));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -44,11 +46,11 @@
TEST_F(ResolverAssignmentValidationTest, AssignIncompatibleTypes) {
// {
- // var a : i32 = 2;
+ // var a : i32 = 2i;
// a = 2.3;
// }
- auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
+ auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
auto* assign = Assign(Source{{12, 34}}, "a", 2.3f);
WrapInFunction(var, assign);
@@ -61,14 +63,14 @@
TEST_F(ResolverAssignmentValidationTest, AssignArraysWithDifferentSizeExpressions_Pass) {
// let len = 4u;
// {
- // var a : array<f32, 4>;
+ // var a : array<f32, 4u>;
// var b : array<f32, len>;
// a = b;
// }
- GlobalConst("len", nullptr, Expr(4u));
+ GlobalConst("len", nullptr, Expr(4_u));
- auto* a = Var("a", ty.array(ty.f32(), 4));
+ auto* a = Var("a", ty.array(ty.f32(), 4_u));
auto* b = Var("b", ty.array(ty.f32(), "len"));
auto* assign = Assign(Source{{12, 34}}, "a", "b");
@@ -80,14 +82,14 @@
TEST_F(ResolverAssignmentValidationTest, AssignArraysWithDifferentSizeExpressions_Fail) {
// let len = 5u;
// {
- // var a : array<f32, 4>;
+ // var a : array<f32, 4u>;
// var b : array<f32, len>;
// a = b;
// }
- GlobalConst("len", nullptr, Expr(5u));
+ GlobalConst("len", nullptr, Expr(5_u));
- auto* a = Var("a", ty.array(ty.f32(), 4));
+ auto* a = Var("a", ty.array(ty.f32(), 4_u));
auto* b = Var("b", ty.array(ty.f32(), "len"));
auto* assign = Assign(Source{{12, 34}}, "a", "b");
@@ -100,22 +102,22 @@
TEST_F(ResolverAssignmentValidationTest, AssignCompatibleTypesInBlockStatement_Pass) {
// {
- // var a : i32 = 2;
- // a = 2
+ // var a : i32 = 2i;
+ // a = 2i
// }
- auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
- WrapInFunction(var, Assign("a", 2));
+ auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
+ WrapInFunction(var, Assign("a", 2_i));
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverAssignmentValidationTest, AssignIncompatibleTypesInBlockStatement_Fail) {
// {
- // var a : i32 = 2;
+ // var a : i32 = 2i;
// a = 2.3;
// }
- auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
+ auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
WrapInFunction(var, Assign(Source{{12, 34}}, "a", 2.3f));
ASSERT_FALSE(r()->Resolve());
@@ -126,12 +128,12 @@
TEST_F(ResolverAssignmentValidationTest, AssignIncompatibleTypesInNestedBlockStatement_Fail) {
// {
// {
- // var a : i32 = 2;
+ // var a : i32 = 2i;
// a = 2.3;
// }
// }
- auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
+ auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
auto* inner_block = Block(Decl(var), Assign(Source{{12, 34}}, "a", 2.3f));
auto* outer_block = Block(inner_block);
WrapInFunction(outer_block);
@@ -142,42 +144,42 @@
}
TEST_F(ResolverAssignmentValidationTest, AssignToScalar_Fail) {
- // var my_var : i32 = 2;
+ // var my_var : i32 = 2i;
// 1 = my_var;
- auto* var = Var("my_var", ty.i32(), ast::StorageClass::kNone, Expr(2));
- WrapInFunction(var, Assign(Expr(Source{{12, 34}}, 1), "my_var"));
+ auto* var = Var("my_var", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
+ WrapInFunction(var, Assign(Expr(Source{{12, 34}}, 1_i), "my_var"));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: cannot assign to value of type 'i32'");
}
TEST_F(ResolverAssignmentValidationTest, AssignCompatibleTypes_Pass) {
- // var a : i32 = 2;
- // a = 2
- auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
- WrapInFunction(var, Assign(Source{{12, 34}}, "a", 2));
+ // var a : i32 = 2i;
+ // a = 2i
+ auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
+ WrapInFunction(var, Assign(Source{{12, 34}}, "a", 2_i));
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverAssignmentValidationTest, AssignCompatibleTypesThroughAlias_Pass) {
// alias myint = i32;
- // var a : myint = 2;
+ // var a : myint = 2i;
// a = 2
auto* myint = Alias("myint", ty.i32());
- auto* var = Var("a", ty.Of(myint), ast::StorageClass::kNone, Expr(2));
- WrapInFunction(var, Assign(Source{{12, 34}}, "a", 2));
+ auto* var = Var("a", ty.Of(myint), ast::StorageClass::kNone, Expr(2_i));
+ WrapInFunction(var, Assign(Source{{12, 34}}, "a", 2_i));
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverAssignmentValidationTest, AssignCompatibleTypesInferRHSLoad_Pass) {
- // var a : i32 = 2;
- // var b : i32 = 3;
+ // var a : i32 = 2i;
+ // var b : i32 = 3i;
// a = b;
- auto* var_a = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
- auto* var_b = Var("b", ty.i32(), ast::StorageClass::kNone, Expr(3));
+ auto* var_a = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
+ auto* var_b = Var("b", ty.i32(), ast::StorageClass::kNone, Expr(3_i));
WrapInFunction(var_a, var_b, Assign(Source{{12, 34}}, "a", "b"));
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -186,22 +188,22 @@
TEST_F(ResolverAssignmentValidationTest, AssignThroughPointer_Pass) {
// var a : i32;
// let b : ptr<function,i32> = &a;
- // *b = 2;
+ // *b = 2i;
const auto func = ast::StorageClass::kFunction;
- auto* var_a = Var("a", ty.i32(), func, Expr(2));
- auto* var_b = Let("b", ty.pointer<int>(func), AddressOf(Expr("a")));
- WrapInFunction(var_a, var_b, Assign(Source{{12, 34}}, Deref("b"), 2));
+ auto* var_a = Var("a", ty.i32(), func, Expr(2_i));
+ auto* var_b = Let("b", ty.pointer<i32>(func), AddressOf(Expr("a")));
+ WrapInFunction(var_a, var_b, Assign(Source{{12, 34}}, Deref("b"), 2_i));
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverAssignmentValidationTest, AssignToConstant_Fail) {
// {
- // let a : i32 = 2;
- // a = 2
+ // let a : i32 = 2i;
+ // a = 2i
// }
- auto* var = Let("a", ty.i32(), Expr(2));
- WrapInFunction(var, Assign(Expr(Source{{12, 34}}, "a"), 2));
+ auto* var = Let("a", ty.i32(), Expr(2_i));
+ WrapInFunction(var, Assign(Expr(Source{{12, 34}}, "a"), 2_i));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: cannot assign to const\nnote: 'a' is declared here:");
@@ -324,7 +326,7 @@
// @group(0) @binding(3) var<storage, read_write> s : S;
// var<workgroup> wg : array<f32, 10>
// fn f() {
- // _ = 1;
+ // _ = 1i;
// _ = 2u;
// _ = 3.0;
// _ = vec2<bool>();
@@ -336,7 +338,7 @@
// _ = u;
// _ = u.i;
// _ = wg;
- // _ = wg[3];
+ // _ = wg[3i];
// }
auto* S = Structure("S", {
Member("i", ty.i32()),
@@ -349,9 +351,9 @@
Global("s", ty.Of(S), ast::StorageClass::kStorage, GroupAndBinding(0, 3));
Global("wg", ty.array<f32, 10>(), ast::StorageClass::kWorkgroup);
- WrapInFunction(Assign(Phony(), 1), //
- Assign(Phony(), 2), //
- Assign(Phony(), 3), //
+ WrapInFunction(Assign(Phony(), 1_i), //
+ Assign(Phony(), 2_u), //
+ Assign(Phony(), 3.f), //
Assign(Phony(), vec2<bool>()), //
Assign(Phony(), "tex"), //
Assign(Phony(), "smp"), //
@@ -361,7 +363,7 @@
Assign(Phony(), "u"), //
Assign(Phony(), MemberAccessor("u", "i")), //
Assign(Phony(), "wg"), //
- Assign(Phony(), IndexAccessor("wg", 3)));
+ Assign(Phony(), IndexAccessor("wg", 3_i)));
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
diff --git a/src/tint/resolver/atomics_validation_test.cc b/src/tint/resolver/atomics_validation_test.cc
index de8d0ac..78c1fb9 100644
--- a/src/tint/resolver/atomics_validation_test.cc
+++ b/src/tint/resolver/atomics_validation_test.cc
@@ -19,6 +19,8 @@
#include "gmock/gmock.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -131,10 +133,10 @@
// struct S{
// m: atomic<u32>;
// };
- // var<private> v: array<S, 5>;
+ // var<private> v: array<S, 5u>;
auto* s = Structure("S", {Member("m", ty.atomic<u32>())});
- Global(Source{{56, 78}}, "v", ty.array(ty.Of(s), 5), ast::StorageClass::kPrivate);
+ Global(Source{{56, 78}}, "v", ty.array(ty.Of(s), 5_u), ast::StorageClass::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -144,16 +146,16 @@
}
TEST_F(ResolverAtomicValidationTest, InvalidStorageClass_ArrayOfStructOfArray) {
- // type AtomicArray = array<atomic<i32>, 5>;
+ // type AtomicArray = array<atomic<i32>, 5u>;
// struct S{
// m: AtomicArray;
// };
- // var<private> v: array<S, 5>;
+ // var<private> v: array<S, 5u>;
auto* atomic_array =
Alias(Source{{12, 34}}, "AtomicArray", ty.atomic(Source{{12, 34}}, ty.i32()));
auto* s = Structure("S", {Member("m", ty.Of(atomic_array))});
- Global(Source{{56, 78}}, "v", ty.array(ty.Of(s), 5), ast::StorageClass::kPrivate);
+ Global(Source{{56, 78}}, "v", ty.array(ty.Of(s), 5_u), ast::StorageClass::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -163,14 +165,14 @@
}
TEST_F(ResolverAtomicValidationTest, InvalidStorageClass_Complex) {
- // type AtomicArray = array<atomic<i32>, 5>;
+ // type AtomicArray = array<atomic<i32>, 5u>;
// struct S6 { x: array<i32, 4>; };
// struct S5 { x: S6;
// y: AtomicArray;
- // z: array<atomic<u32>, 8>; };
+ // z: array<atomic<u32>, 8u>; };
// struct S4 { x: S6;
// y: S5;
- // z: array<atomic<i32>, 4>; };
+ // z: array<atomic<i32>, 4u>; };
// struct S3 { x: S4; };
// struct S2 { x: S3; };
// struct S1 { x: S2; };
@@ -179,9 +181,9 @@
auto* atomic_array =
Alias(Source{{12, 34}}, "AtomicArray", ty.atomic(Source{{12, 34}}, ty.i32()));
- auto* array_i32_4 = ty.array(ty.i32(), 4);
- auto* array_atomic_u32_8 = ty.array(ty.atomic(ty.u32()), 8);
- auto* array_atomic_i32_4 = ty.array(ty.atomic(ty.i32()), 4);
+ auto* array_i32_4 = ty.array(ty.i32(), 4_u);
+ auto* array_atomic_u32_8 = ty.array(ty.atomic(ty.u32()), 8_u);
+ auto* array_atomic_i32_4 = ty.array(ty.atomic(ty.i32()), 4_u);
auto* s6 = Structure("S6", {Member("x", array_i32_4)});
auto* s5 = Structure("S5", {Member("x", ty.Of(s6)), //
@@ -263,13 +265,13 @@
TEST_F(ResolverAtomicValidationTest, InvalidAccessMode_Complex) {
// type AtomicArray = array<atomic<i32>, 5>;
- // struct S6 { x: array<i32, 4>; };
+ // struct S6 { x: array<i32, 4u>; };
// struct S5 { x: S6;
// y: AtomicArray;
- // z: array<atomic<u32>, 8>; };
+ // z: array<atomic<u32>, 8u>; };
// struct S4 { x: S6;
// y: S5;
- // z: array<atomic<i32>, 4>; };
+ // z: array<atomic<i32>, 4u>; };
// struct S3 { x: S4; };
// struct S2 { x: S3; };
// struct S1 { x: S2; };
@@ -278,9 +280,9 @@
auto* atomic_array =
Alias(Source{{12, 34}}, "AtomicArray", ty.atomic(Source{{12, 34}}, ty.i32()));
- auto* array_i32_4 = ty.array(ty.i32(), 4);
- auto* array_atomic_u32_8 = ty.array(ty.atomic(ty.u32()), 8);
- auto* array_atomic_i32_4 = ty.array(ty.atomic(ty.i32()), 4);
+ auto* array_i32_4 = ty.array(ty.i32(), 4_u);
+ auto* array_atomic_u32_8 = ty.array(ty.atomic(ty.u32()), 8_u);
+ auto* array_atomic_i32_4 = ty.array(ty.atomic(ty.i32()), 4_u);
auto* s6 = Structure("S6", {Member("x", array_i32_4)});
auto* s5 = Structure("S5", {Member("x", ty.Of(s6)), //
diff --git a/src/tint/resolver/attribute_validation_test.cc b/src/tint/resolver/attribute_validation_test.cc
index f9f5ea9..dbefb14 100644
--- a/src/tint/resolver/attribute_validation_test.cc
+++ b/src/tint/resolver/attribute_validation_test.cc
@@ -19,6 +19,8 @@
#include "gmock/gmock.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
// Helpers and typedefs
@@ -44,9 +46,6 @@
using alias2 = builder::alias2<T>;
template <typename T>
using alias3 = builder::alias3<T>;
-using f32 = builder::f32;
-using i32 = builder::i32;
-using u32 = builder::u32;
namespace AttributeTests {
namespace {
@@ -115,10 +114,10 @@
case AttributeKind::kStride:
return {builder.create<ast::StrideAttribute>(source, 4u)};
case AttributeKind::kWorkgroup:
- return {builder.create<ast::WorkgroupAttribute>(source, builder.Expr(1))};
+ return {builder.create<ast::WorkgroupAttribute>(source, builder.Expr(1_i))};
case AttributeKind::kBindingAndGroup:
- return {builder.create<ast::BindingAttribute>(source, 1u),
- builder.create<ast::GroupAttribute>(source, 1u)};
+ return {builder.create<ast::BindingAttribute>(source, 1_u),
+ builder.create<ast::GroupAttribute>(source, 1_u)};
}
return {};
}
@@ -198,7 +197,7 @@
auto& params = GetParam();
auto* p = Param("a", ty.vec4<f32>(), createAttributes(Source{{12, 34}}, *this, params.kind));
Func("main", ast::VariableList{p}, ty.void_(), {},
- {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1)});
+ {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
if (params.should_pass) {
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -318,7 +317,7 @@
TEST_P(ComputeShaderReturnTypeAttributeTest, IsValid) {
auto& params = GetParam();
Func("main", ast::VariableList{}, ty.vec4<f32>(), {Return(Construct(ty.vec4<f32>(), 1.f))},
- {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1)},
+ {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)},
createAttributes(Source{{12, 34}}, *this, params.kind));
if (params.should_pass) {
@@ -493,7 +492,7 @@
}
TEST_F(EntryPointReturnTypeAttributeTest, DuplicateInternalAttribute) {
- Func("f", {}, ty.i32(), {Return(1)}, {Stage(ast::PipelineStage::kFragment)},
+ Func("f", {}, ty.i32(), {Return(1_i)}, {Stage(ast::PipelineStage::kFragment)},
ast::AttributeList{
Disable(ast::DisabledValidation::kBindingPointCollision),
Disable(ast::DisabledValidation::kEntryPointParameter),
@@ -794,7 +793,7 @@
<< ", should_pass: " << params.should_pass;
SCOPED_TRACE(ss.str());
- auto* arr = ty.array(Source{{12, 34}}, el_ty, 4, params.stride);
+ auto* arr = ty.array(Source{{12, 34}}, el_ty, 4_u, params.stride);
Global("myarray", arr, ast::StorageClass::kPrivate);
@@ -873,10 +872,10 @@
ParamsFor<mat4x4<f32>>((default_mat4x4.align - 1) * 7, false)));
TEST_F(ArrayStrideTest, DuplicateAttribute) {
- auto* arr = ty.array(Source{{12, 34}}, ty.i32(), 4,
+ auto* arr = ty.array(Source{{12, 34}}, ty.i32(), 4_u,
{
- create<ast::StrideAttribute>(Source{{12, 34}}, 4),
- create<ast::StrideAttribute>(Source{{56, 78}}, 4),
+ create<ast::StrideAttribute>(Source{{12, 34}}, 4_i),
+ create<ast::StrideAttribute>(Source{{56, 78}}, 4_i),
});
Global("myarray", arr, ast::StorageClass::kPrivate);
@@ -968,9 +967,9 @@
Func("F", {}, ty.void_(),
{
Decl(Var("a", ty.vec4<f32>(), ast::StorageClass::kNone,
- Call("textureLoad", "A", vec2<i32>(1, 2), 0))),
+ Call("textureLoad", "A", vec2<i32>(1_i, 2_i), 0_i))),
Decl(Var("b", ty.vec4<f32>(), ast::StorageClass::kNone,
- Call("textureLoad", "B", vec2<i32>(1, 2), 0))),
+ Call("textureLoad", "B", vec2<i32>(1_i, 2_i), 0_i))),
},
{Stage(ast::PipelineStage::kFragment)});
@@ -998,13 +997,13 @@
Func("F_A", {}, ty.void_(),
{
Decl(Var("a", ty.vec4<f32>(), ast::StorageClass::kNone,
- Call("textureLoad", "A", vec2<i32>(1, 2), 0))),
+ Call("textureLoad", "A", vec2<i32>(1_i, 2_i), 0_i))),
},
{Stage(ast::PipelineStage::kFragment)});
Func("F_B", {}, ty.void_(),
{
Decl(Var("b", ty.vec4<f32>(), ast::StorageClass::kNone,
- Call("textureLoad", "B", vec2<i32>(1, 2), 0))),
+ Call("textureLoad", "B", vec2<i32>(1_i, 2_i), 0_i))),
},
{Stage(ast::PipelineStage::kFragment)});
@@ -1065,7 +1064,7 @@
TEST_F(WorkgroupAttribute, ComputeShaderPass) {
Func("main", {}, ty.void_(), {},
{Stage(ast::PipelineStage::kCompute),
- create<ast::WorkgroupAttribute>(Source{{12, 34}}, Expr(1))});
+ create<ast::WorkgroupAttribute>(Source{{12, 34}}, Expr(1_i))});
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
@@ -1080,7 +1079,8 @@
}
TEST_F(WorkgroupAttribute, NotAnEntryPoint) {
- Func("main", {}, ty.void_(), {}, {create<ast::WorkgroupAttribute>(Source{{12, 34}}, Expr(1))});
+ Func("main", {}, ty.void_(), {},
+ {create<ast::WorkgroupAttribute>(Source{{12, 34}}, Expr(1_i))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -1091,7 +1091,7 @@
TEST_F(WorkgroupAttribute, NotAComputeShader) {
Func("main", {}, ty.void_(), {},
{Stage(ast::PipelineStage::kFragment),
- create<ast::WorkgroupAttribute>(Source{{12, 34}}, Expr(1))});
+ create<ast::WorkgroupAttribute>(Source{{12, 34}}, Expr(1_i))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -1103,8 +1103,8 @@
Func(Source{{12, 34}}, "main", {}, ty.void_(), {},
{
Stage(ast::PipelineStage::kCompute),
- WorkgroupSize(Source{{12, 34}}, 1, nullptr, nullptr),
- WorkgroupSize(Source{{56, 78}}, 2, nullptr, nullptr),
+ WorkgroupSize(Source{{12, 34}}, 1_i, nullptr, nullptr),
+ WorkgroupSize(Source{{56, 78}}, 2_i, nullptr, nullptr),
});
EXPECT_FALSE(r()->Resolve());
diff --git a/src/tint/resolver/bitcast_validation_test.cc b/src/tint/resolver/bitcast_validation_test.cc
index f7799b5..78223fc 100644
--- a/src/tint/resolver/bitcast_validation_test.cc
+++ b/src/tint/resolver/bitcast_validation_test.cc
@@ -34,24 +34,24 @@
};
static constexpr Type kNumericScalars[] = {
- Type::Create<builder::f32>(),
- Type::Create<builder::i32>(),
- Type::Create<builder::u32>(),
+ Type::Create<f32>(),
+ Type::Create<i32>(),
+ Type::Create<u32>(),
};
static constexpr Type kVec2NumericScalars[] = {
- Type::Create<builder::vec2<builder::f32>>(),
- Type::Create<builder::vec2<builder::i32>>(),
- Type::Create<builder::vec2<builder::u32>>(),
+ Type::Create<builder::vec2<f32>>(),
+ Type::Create<builder::vec2<i32>>(),
+ Type::Create<builder::vec2<u32>>(),
};
static constexpr Type kVec3NumericScalars[] = {
- Type::Create<builder::vec3<builder::f32>>(),
- Type::Create<builder::vec3<builder::i32>>(),
- Type::Create<builder::vec3<builder::u32>>(),
+ Type::Create<builder::vec3<f32>>(),
+ Type::Create<builder::vec3<i32>>(),
+ Type::Create<builder::vec3<u32>>(),
};
static constexpr Type kVec4NumericScalars[] = {
- Type::Create<builder::vec4<builder::f32>>(),
- Type::Create<builder::vec4<builder::i32>>(),
- Type::Create<builder::vec4<builder::u32>>(),
+ Type::Create<builder::vec4<f32>>(),
+ Type::Create<builder::vec4<i32>>(),
+ Type::Create<builder::vec4<u32>>(),
};
static constexpr Type kInvalid[] = {
// A non-exhaustive selection of uncastable types
@@ -59,16 +59,16 @@
Type::Create<builder::vec2<bool>>(),
Type::Create<builder::vec3<bool>>(),
Type::Create<builder::vec4<bool>>(),
- Type::Create<builder::array<2, builder::i32>>(),
- Type::Create<builder::array<3, builder::u32>>(),
- Type::Create<builder::array<4, builder::f32>>(),
+ Type::Create<builder::array<2, i32>>(),
+ Type::Create<builder::array<3, u32>>(),
+ Type::Create<builder::array<4, f32>>(),
Type::Create<builder::array<5, bool>>(),
- Type::Create<builder::mat2x2<builder::f32>>(),
- Type::Create<builder::mat3x3<builder::f32>>(),
- Type::Create<builder::mat4x4<builder::f32>>(),
- Type::Create<builder::ptr<builder::i32>>(),
- Type::Create<builder::ptr<builder::array<2, builder::i32>>>(),
- Type::Create<builder::ptr<builder::mat2x2<builder::f32>>>(),
+ Type::Create<builder::mat2x2<f32>>(),
+ Type::Create<builder::mat3x3<f32>>(),
+ Type::Create<builder::mat4x4<f32>>(),
+ Type::Create<builder::ptr<i32>>(),
+ Type::Create<builder::ptr<builder::array<2, i32>>>(),
+ Type::Create<builder::ptr<builder::mat2x2<f32>>>(),
};
using ResolverBitcastValidationTest = ResolverTestWithParam<std::tuple<Type, Type>>;
diff --git a/src/tint/resolver/builtin_test.cc b/src/tint/resolver/builtin_test.cc
index 3b5a03b..94684ba 100644
--- a/src/tint/resolver/builtin_test.cc
+++ b/src/tint/resolver/builtin_test.cc
@@ -39,6 +39,8 @@
using ::testing::ElementsAre;
using ::testing::HasSubstr;
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -331,7 +333,7 @@
}
TEST_F(ResolverBuiltinTest, Select_Error_SelectorInt) {
- auto* expr = Call("select", 1, 1, 1);
+ auto* expr = Call("select", 1_i, 1_i, 1_i);
WrapInFunction(expr);
EXPECT_FALSE(r()->Resolve());
@@ -456,8 +458,8 @@
bool pack4 =
param.builtin == BuiltinType::kPack4x8snorm || param.builtin == BuiltinType::kPack4x8unorm;
- auto* call =
- pack4 ? Call(param.name, vec4<i32>(1, 2, 3, 4)) : Call(param.name, vec2<i32>(1, 2));
+ auto* call = pack4 ? Call(param.name, vec4<i32>(1_i, 2_i, 3_i, 4_i))
+ : Call(param.name, vec2<i32>(1_i, 2_i));
WrapInFunction(call);
EXPECT_FALSE(r()->Resolve());
@@ -507,7 +509,7 @@
bool pack4 = param.builtin == BuiltinType::kUnpack4x8snorm ||
param.builtin == BuiltinType::kUnpack4x8unorm;
- auto* call = Call(param.name, 1u);
+ auto* call = Call(param.name, 1_u);
WrapInFunction(call);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -573,7 +575,7 @@
TEST_P(ResolverBuiltinTest_SingleParam, Error_TooManyParams) {
auto param = GetParam();
- auto* call = Call(param.name, 1, 2, 3);
+ auto* call = Call(param.name, 1_i, 2_i, 3_i);
WrapInFunction(call);
EXPECT_FALSE(r()->Resolve());
@@ -630,7 +632,7 @@
}
TEST_F(ResolverBuiltinDataTest, ArrayLength_Error_ArraySized) {
- Global("arr", ty.array<int, 4>(), ast::StorageClass::kPrivate);
+ Global("arr", ty.array<i32, 4>(), ast::StorageClass::kPrivate);
auto* call = Call("arrayLength", AddressOf("arr"));
WrapInFunction(call);
@@ -732,7 +734,7 @@
TEST_F(ResolverBuiltinDataTest, Frexp_Error_FirstParamInt) {
Global("v", ty.i32(), ast::StorageClass::kWorkgroup);
- auto* call = Call("frexp", 1, AddressOf("v"));
+ auto* call = Call("frexp", 1_i, AddressOf("v"));
WrapInFunction(call);
EXPECT_FALSE(r()->Resolve());
@@ -763,7 +765,7 @@
}
TEST_F(ResolverBuiltinDataTest, Frexp_Error_SecondParamNotAPointer) {
- auto* call = Call("frexp", 1.0f, 1);
+ auto* call = Call("frexp", 1.0f, 1_i);
WrapInFunction(call);
EXPECT_FALSE(r()->Resolve());
@@ -856,7 +858,7 @@
TEST_F(ResolverBuiltinDataTest, Modf_Error_FirstParamInt) {
Global("whole", ty.f32(), ast::StorageClass::kWorkgroup);
- auto* call = Call("modf", 1, AddressOf("whole"));
+ auto* call = Call("modf", 1_i, AddressOf("whole"));
WrapInFunction(call);
EXPECT_FALSE(r()->Resolve());
@@ -945,7 +947,7 @@
TEST_P(ResolverBuiltinTest_SingleParam_FloatOrInt, Sint_Scalar) {
auto param = GetParam();
- auto* call = Call(param.name, -1);
+ auto* call = Call(param.name, i32(-1));
WrapInFunction(call);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -957,7 +959,7 @@
TEST_P(ResolverBuiltinTest_SingleParam_FloatOrInt, Sint_Vector) {
auto param = GetParam();
- auto* call = Call(param.name, vec3<i32>(1, 1, 3));
+ auto* call = Call(param.name, vec3<i32>(1_i, 1_i, 3_i));
WrapInFunction(call);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -970,7 +972,7 @@
TEST_P(ResolverBuiltinTest_SingleParam_FloatOrInt, Uint_Scalar) {
auto param = GetParam();
- auto* call = Call(param.name, 1u);
+ auto* call = Call(param.name, 1_u);
WrapInFunction(call);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -982,7 +984,7 @@
TEST_P(ResolverBuiltinTest_SingleParam_FloatOrInt, Uint_Vector) {
auto param = GetParam();
- auto* call = Call(param.name, vec3<u32>(1u, 1u, 3u));
+ auto* call = Call(param.name, vec3<u32>(1_u, 1_u, 3_u));
WrapInFunction(call);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1061,7 +1063,7 @@
TEST_P(ResolverBuiltinTest_TwoParam, Error_NoTooManyParams) {
auto param = GetParam();
- auto* call = Call(param.name, 1, 2, 3);
+ auto* call = Call(param.name, 1_i, 2_i, 3_i);
WrapInFunction(call);
EXPECT_FALSE(r()->Resolve());
@@ -1152,7 +1154,7 @@
}
TEST_F(ResolverBuiltinTest, Cross_Error_Vec3Int) {
- auto* call = Call("cross", vec3<i32>(1, 2, 3), vec3<i32>(1, 2, 3));
+ auto* call = Call("cross", vec3<i32>(1_i, 2_i, 3_i), vec3<i32>(1_i, 2_i, 3_i));
WrapInFunction(call);
EXPECT_FALSE(r()->Resolve());
@@ -1295,7 +1297,7 @@
TEST_P(ResolverBuiltinTest_ThreeParam_FloatOrInt, Sint_Scalar) {
auto param = GetParam();
- auto* call = Call(param.name, 1, 1, 1);
+ auto* call = Call(param.name, 1_i, 1_i, 1_i);
WrapInFunction(call);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1307,7 +1309,8 @@
TEST_P(ResolverBuiltinTest_ThreeParam_FloatOrInt, Sint_Vector) {
auto param = GetParam();
- auto* call = Call(param.name, vec3<i32>(1, 1, 3), vec3<i32>(1, 1, 3), vec3<i32>(1, 1, 3));
+ auto* call = Call(param.name, vec3<i32>(1_i, 1_i, 3_i), vec3<i32>(1_i, 1_i, 3_i),
+ vec3<i32>(1_i, 1_i, 3_i));
WrapInFunction(call);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1320,7 +1323,7 @@
TEST_P(ResolverBuiltinTest_ThreeParam_FloatOrInt, Uint_Scalar) {
auto param = GetParam();
- auto* call = Call(param.name, 1u, 1u, 1u);
+ auto* call = Call(param.name, 1_u, 1_u, 1_u);
WrapInFunction(call);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1332,8 +1335,8 @@
TEST_P(ResolverBuiltinTest_ThreeParam_FloatOrInt, Uint_Vector) {
auto param = GetParam();
- auto* call =
- Call(param.name, vec3<u32>(1u, 1u, 3u), vec3<u32>(1u, 1u, 3u), vec3<u32>(1u, 1u, 3u));
+ auto* call = Call(param.name, vec3<u32>(1_u, 1_u, 3_u), vec3<u32>(1_u, 1_u, 3_u),
+ vec3<u32>(1_u, 1_u, 3_u));
WrapInFunction(call);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1369,7 +1372,7 @@
TEST_P(ResolverBuiltinTest_Int_SingleParam, Scalar) {
auto param = GetParam();
- auto* call = Call(param.name, 1);
+ auto* call = Call(param.name, 1_i);
WrapInFunction(call);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1381,7 +1384,7 @@
TEST_P(ResolverBuiltinTest_Int_SingleParam, Vector) {
auto param = GetParam();
- auto* call = Call(param.name, vec3<i32>(1, 1, 3));
+ auto* call = Call(param.name, vec3<i32>(1_i, 1_i, 3_i));
WrapInFunction(call);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1416,7 +1419,7 @@
TEST_P(ResolverBuiltinTest_FloatOrInt_TwoParam, Scalar_Signed) {
auto param = GetParam();
- auto* call = Call(param.name, 1, 1);
+ auto* call = Call(param.name, 1_i, 1_i);
WrapInFunction(call);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1428,7 +1431,7 @@
TEST_P(ResolverBuiltinTest_FloatOrInt_TwoParam, Scalar_Unsigned) {
auto param = GetParam();
- auto* call = Call(param.name, 1u, 1u);
+ auto* call = Call(param.name, 1_u, 1_u);
WrapInFunction(call);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1452,7 +1455,7 @@
TEST_P(ResolverBuiltinTest_FloatOrInt_TwoParam, Vector_Signed) {
auto param = GetParam();
- auto* call = Call(param.name, vec3<i32>(1, 1, 3), vec3<i32>(1, 1, 3));
+ auto* call = Call(param.name, vec3<i32>(1_i, 1_i, 3_i), vec3<i32>(1_i, 1_i, 3_i));
WrapInFunction(call);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1465,7 +1468,7 @@
TEST_P(ResolverBuiltinTest_FloatOrInt_TwoParam, Vector_Unsigned) {
auto param = GetParam();
- auto* call = Call(param.name, vec3<u32>(1u, 1u, 3u), vec3<u32>(1u, 1u, 3u));
+ auto* call = Call(param.name, vec3<u32>(1_u, 1_u, 3_u), vec3<u32>(1_u, 1_u, 3_u));
WrapInFunction(call);
EXPECT_TRUE(r()->Resolve()) << r()->error();
diff --git a/src/tint/resolver/builtin_validation_test.cc b/src/tint/resolver/builtin_validation_test.cc
index f0bd8de..98e29fa 100644
--- a/src/tint/resolver/builtin_validation_test.cc
+++ b/src/tint/resolver/builtin_validation_test.cc
@@ -15,6 +15,8 @@
#include "src/tint/ast/builtin_texture_helper_test.h"
#include "src/tint/resolver/resolver_test_helper.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -37,7 +39,7 @@
auto* dpdx =
create<ast::CallExpression>(Source{{3, 4}}, Expr("dpdx"), ast::ExpressionList{Expr(1.0f)});
Func(Source{{1, 2}}, "func", ast::VariableList{}, ty.void_(), {CallStmt(dpdx)},
- {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1)});
+ {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "3:4 error: built-in cannot be used by compute pipeline stage");
@@ -58,7 +60,7 @@
Func(Source{{5, 6}}, "f2", {}, ty.void_(), {CallStmt(Call("f1"))});
Func(Source{{7, 8}}, "main", {}, ty.void_(), {CallStmt(Call("f2"))},
- {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1)});
+ {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -78,7 +80,7 @@
}
TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalLet) {
- GlobalConst(Source{{12, 34}}, "mix", ty.i32(), Expr(1));
+ GlobalConst(Source{{12, 34}}, "mix", ty.i32(), Expr(1_i));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -86,7 +88,7 @@
}
TEST_F(ResolverBuiltinValidationTest, BuiltinRedeclaredAsGlobalVar) {
- Global(Source{{12, 34}}, "mix", ty.i32(), Expr(1), ast::StorageClass::kPrivate);
+ Global(Source{{12, 34}}, "mix", ty.i32(), Expr(1_i), ast::StorageClass::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -115,9 +117,6 @@
using ValidTextureOverload = ast::builtin::test::ValidTextureOverload;
using TextureKind = ast::builtin::test::TextureKind;
using TextureDataType = ast::builtin::test::TextureDataType;
-using u32 = ProgramBuilder::u32;
-using i32 = ProgramBuilder::i32;
-using f32 = ProgramBuilder::f32;
static std::vector<TextureOverloadCase> TextureCases(
std::unordered_set<ValidTextureOverload> overloads) {
@@ -160,17 +159,18 @@
const ast::Expression* operator()(Source src, ProgramBuilder& b) {
switch (kind) {
case Kind::kScalar:
- return b.Expr(src, values[0]);
+ return b.Expr(src, i32(values[0]));
case Kind::kVec2:
- return b.Construct(src, b.ty.vec2<i32>(), values[0], values[1]);
+ return b.Construct(src, b.ty.vec2<i32>(), i32(values[0]), i32(values[1]));
case Kind::kVec3:
- return b.Construct(src, b.ty.vec3<i32>(), values[0], values[1], values[2]);
+ return b.Construct(src, b.ty.vec3<i32>(), i32(values[0]), i32(values[1]),
+ i32(values[2]));
case Kind::kVec3_Scalar_Vec2:
- return b.Construct(src, b.ty.vec3<i32>(), values[0],
- b.vec2<i32>(values[1], values[2]));
+ return b.Construct(src, b.ty.vec3<i32>(), i32(values[0]),
+ b.vec2<i32>(i32(values[1]), i32(values[2])));
case Kind::kVec3_Vec2_Scalar:
- return b.Construct(src, b.ty.vec3<i32>(), b.vec2<i32>(values[0], values[1]),
- values[2]);
+ return b.Construct(src, b.ty.vec3<i32>(),
+ b.vec2<i32>(i32(values[0]), i32(values[1])), i32(values[2]));
case Kind::kEmptyVec2:
return b.Construct(src, b.ty.vec2<i32>());
case Kind::kEmptyVec3:
diff --git a/src/tint/resolver/builtins_validation_test.cc b/src/tint/resolver/builtins_validation_test.cc
index 804ccb4..87835d6 100644
--- a/src/tint/resolver/builtins_validation_test.cc
+++ b/src/tint/resolver/builtins_validation_test.cc
@@ -15,6 +15,8 @@
#include "src/tint/ast/call_statement.h"
#include "src/tint/resolver/resolver_test_helper.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -26,9 +28,6 @@
using vec3 = builder::vec3<T>;
template <typename T>
using vec4 = builder::vec4<T>;
-using f32 = builder::f32;
-using i32 = builder::i32;
-using u32 = builder::u32;
class ResolverBuiltinsValidationTest : public resolver::TestHelper, public testing::Test {};
namespace StageTest {
@@ -106,7 +105,7 @@
break;
case ast::PipelineStage::kCompute:
Func("main", {input}, ty.void_(), {},
- ast::AttributeList{Stage(ast::PipelineStage::kCompute), WorkgroupSize(1)});
+ ast::AttributeList{Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
break;
default:
break;
@@ -243,7 +242,7 @@
TEST_F(ResolverBuiltinsValidationTest, SampleMaskNotU32_ReturnType_Fail) {
// @stage(fragment)
// fn main() -> @builtin(sample_mask) i32 { return 1; }
- Func("main", {}, ty.i32(), {Return(1)}, {Stage(ast::PipelineStage::kFragment)},
+ Func("main", {}, ty.i32(), {Return(1_i)}, {Stage(ast::PipelineStage::kFragment)},
{Builtin(Source{{12, 34}}, ast::Builtin::kSampleMask)});
EXPECT_FALSE(r()->Resolve());
@@ -414,7 +413,7 @@
Func("main", ast::VariableList{li_id, li_index, gi, wi, nwgs}, ty.void_(), {},
ast::AttributeList{Stage(ast::PipelineStage::kCompute),
- WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2))});
+ WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
@@ -424,7 +423,7 @@
ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kWorkgroupId)});
Func("main", ast::VariableList{wi}, ty.void_(), {},
ast::AttributeList{Stage(ast::PipelineStage::kCompute),
- WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2))});
+ WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -437,7 +436,7 @@
ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kNumWorkgroups)});
Func("main", ast::VariableList{nwgs}, ty.void_(), {},
ast::AttributeList{Stage(ast::PipelineStage::kCompute),
- WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2))});
+ WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -451,7 +450,7 @@
ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kGlobalInvocationId)});
Func("main", ast::VariableList{gi}, ty.void_(), {},
ast::AttributeList{Stage(ast::PipelineStage::kCompute),
- WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2))});
+ WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -465,7 +464,7 @@
ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kLocalInvocationIndex)});
Func("main", ast::VariableList{li_index}, ty.void_(), {},
ast::AttributeList{Stage(ast::PipelineStage::kCompute),
- WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2))});
+ WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -479,7 +478,7 @@
ast::AttributeList{Builtin(Source{{12, 34}}, ast::Builtin::kLocalInvocationId)});
Func("main", ast::VariableList{li_id}, ty.void_(), {},
ast::AttributeList{Stage(ast::PipelineStage::kCompute),
- WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2))});
+ WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -791,7 +790,7 @@
}
TEST_F(ResolverBuiltinsValidationTest, Select_Integer_Scalar) {
- auto* builtin = Call("select", Expr(1), Expr(1), Expr(true));
+ auto* builtin = Call("select", Expr(1_i), Expr(1_i), Expr(true));
WrapInFunction(builtin);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -813,7 +812,8 @@
}
TEST_F(ResolverBuiltinsValidationTest, Select_Integer_Vec2) {
- auto* builtin = Call("select", vec2<int>(1, 1), vec2<int>(1, 1), vec2<bool>(true, true));
+ auto* builtin =
+ Call("select", vec2<i32>(1_i, 1_i), vec2<i32>(1_i, 1_i), vec2<bool>(true, true));
WrapInFunction(builtin);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -950,7 +950,7 @@
ast::ExpressionList params;
for (uint32_t i = 0; i < num_params; ++i) {
- params.push_back(Construct<uint32_t>(1));
+ params.push_back(Construct<u32>(1_i));
}
auto* builtin = Call(name, params);
WrapInFunction(builtin);
@@ -965,7 +965,7 @@
ast::ExpressionList params;
for (uint32_t i = 0; i < num_params; ++i) {
- params.push_back(vec2<uint32_t>(1u, 1u));
+ params.push_back(vec2<u32>(1_u, 1_u));
}
auto* builtin = Call(name, params);
WrapInFunction(builtin);
@@ -980,7 +980,7 @@
ast::ExpressionList params;
for (uint32_t i = 0; i < num_params; ++i) {
- params.push_back(vec3<uint32_t>(1u, 1u, 1u));
+ params.push_back(vec3<u32>(1_u, 1_u, 1_u));
}
auto* builtin = Call(name, params);
WrapInFunction(builtin);
@@ -995,7 +995,7 @@
ast::ExpressionList params;
for (uint32_t i = 0; i < num_params; ++i) {
- params.push_back(vec4<uint32_t>(1u, 1u, 1u, 1u));
+ params.push_back(vec4<u32>(1_u, 1_u, 1_u, 1_u));
}
auto* builtin = Call(name, params);
WrapInFunction(builtin);
@@ -1010,7 +1010,7 @@
ast::ExpressionList params;
for (uint32_t i = 0; i < num_params; ++i) {
- params.push_back(Construct<int32_t>(1));
+ params.push_back(Construct<i32>(1_i));
}
auto* builtin = Call(name, params);
WrapInFunction(builtin);
@@ -1025,7 +1025,7 @@
ast::ExpressionList params;
for (uint32_t i = 0; i < num_params; ++i) {
- params.push_back(vec2<int32_t>(1, 1));
+ params.push_back(vec2<i32>(1_i, 1_i));
}
auto* builtin = Call(name, params);
WrapInFunction(builtin);
@@ -1040,7 +1040,7 @@
ast::ExpressionList params;
for (uint32_t i = 0; i < num_params; ++i) {
- params.push_back(vec3<int32_t>(1, 1, 1));
+ params.push_back(vec3<i32>(1_i, 1_i, 1_i));
}
auto* builtin = Call(name, params);
WrapInFunction(builtin);
@@ -1055,7 +1055,7 @@
ast::ExpressionList params;
for (uint32_t i = 0; i < num_params; ++i) {
- params.push_back(vec4<int32_t>(1, 1, 1, 1));
+ params.push_back(vec4<i32>(1_i, 1_i, 1_i, 1_i));
}
auto* builtin = Call(name, params);
WrapInFunction(builtin);
diff --git a/src/tint/resolver/call_test.cc b/src/tint/resolver/call_test.cc
index 0b622f1..c8b9856 100644
--- a/src/tint/resolver/call_test.cc
+++ b/src/tint/resolver/call_test.cc
@@ -51,9 +51,6 @@
using alias2 = builder::alias2<T>;
template <typename T>
using alias3 = builder::alias3<T>;
-using f32 = builder::f32;
-using i32 = builder::i32;
-using u32 = builder::u32;
using ResolverCallTest = ResolverTest;
diff --git a/src/tint/resolver/call_validation_test.cc b/src/tint/resolver/call_validation_test.cc
index c470bf5..756ba5c 100644
--- a/src/tint/resolver/call_validation_test.cc
+++ b/src/tint/resolver/call_validation_test.cc
@@ -18,6 +18,8 @@
#include "src/tint/ast/call_statement.h"
#include "src/tint/resolver/resolver_test_helper.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -25,7 +27,7 @@
TEST_F(ResolverCallValidationTest, TooFewArgs) {
Func("foo", {Param(Sym(), ty.i32()), Param(Sym(), ty.f32())}, ty.void_(), {Return()});
- auto* call = Call(Source{{12, 34}}, "foo", 1);
+ auto* call = Call(Source{{12, 34}}, "foo", 1_i);
WrapInFunction(call);
EXPECT_FALSE(r()->Resolve());
@@ -34,7 +36,7 @@
TEST_F(ResolverCallValidationTest, TooManyArgs) {
Func("foo", {Param(Sym(), ty.i32()), Param(Sym(), ty.f32())}, ty.void_(), {Return()});
- auto* call = Call(Source{{12, 34}}, "foo", 1, 1.0f, 1.0f);
+ auto* call = Call(Source{{12, 34}}, "foo", 1_i, 1.0f, 1.0f);
WrapInFunction(call);
EXPECT_FALSE(r()->Resolve());
@@ -70,14 +72,14 @@
TEST_F(ResolverCallValidationTest, PointerArgument_VariableIdentExpr) {
// fn foo(p: ptr<function, i32>) {}
// fn main() {
- // var z: i32 = 1;
+ // var z: i32 = 1i;
// foo(&z);
// }
auto* param = Param("p", ty.pointer<i32>(ast::StorageClass::kFunction));
Func("foo", {param}, ty.void_(), {});
Func("main", {}, ty.void_(),
{
- Decl(Var("z", ty.i32(), Expr(1))),
+ Decl(Var("z", ty.i32(), Expr(1_i))),
CallStmt(Call("foo", AddressOf(Source{{12, 34}}, Expr("z")))),
});
@@ -87,14 +89,14 @@
TEST_F(ResolverCallValidationTest, PointerArgument_ConstIdentExpr) {
// fn foo(p: ptr<function, i32>) {}
// fn main() {
- // let z: i32 = 1;
+ // let z: i32 = 1i;
// foo(&z);
// }
auto* param = Param("p", ty.pointer<i32>(ast::StorageClass::kFunction));
Func("foo", {param}, ty.void_(), {});
Func("main", {}, ty.void_(),
{
- Decl(Let("z", ty.i32(), Expr(1))),
+ Decl(Let("z", ty.i32(), Expr(1_i))),
CallStmt(Call("foo", AddressOf(Expr(Source{{12, 34}}, "z")))),
});
@@ -171,7 +173,7 @@
ast::StatementList{CallStmt(Call("foo", Expr("p")))});
Func("main", ast::VariableList{}, ty.void_(),
{
- Decl(Var("v", ty.i32(), Expr(1))),
+ Decl(Var("v", ty.i32(), Expr(1_i))),
CallStmt(Call("foo", AddressOf(Expr("v")))),
},
{
diff --git a/src/tint/resolver/compound_assignment_validation_test.cc b/src/tint/resolver/compound_assignment_validation_test.cc
index bf1ed07..a3f124d 100644
--- a/src/tint/resolver/compound_assignment_validation_test.cc
+++ b/src/tint/resolver/compound_assignment_validation_test.cc
@@ -18,6 +18,8 @@
#include "src/tint/resolver/resolver_test_helper.h"
#include "src/tint/sem/storage_texture.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -26,8 +28,8 @@
TEST_F(ResolverCompoundAssignmentValidationTest, CompatibleTypes) {
// var a : i32 = 2;
// a += 2
- auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
- WrapInFunction(var, CompoundAssign(Source{{12, 34}}, "a", 2, ast::BinaryOp::kAdd));
+ auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
+ WrapInFunction(var, CompoundAssign(Source{{12, 34}}, "a", 2_i, ast::BinaryOp::kAdd));
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
@@ -37,8 +39,8 @@
// var a : myint = 2;
// a += 2
auto* myint = Alias("myint", ty.i32());
- auto* var = Var("a", ty.Of(myint), ast::StorageClass::kNone, Expr(2));
- WrapInFunction(var, CompoundAssign(Source{{12, 34}}, "a", 2, ast::BinaryOp::kAdd));
+ auto* var = Var("a", ty.Of(myint), ast::StorageClass::kNone, Expr(2_i));
+ WrapInFunction(var, CompoundAssign(Source{{12, 34}}, "a", 2_i, ast::BinaryOp::kAdd));
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
@@ -48,10 +50,10 @@
// let b : ptr<function,i32> = &a;
// *b += 2;
const auto func = ast::StorageClass::kFunction;
- auto* var_a = Var("a", ty.i32(), func, Expr(2));
- auto* var_b = Let("b", ty.pointer<int>(func), AddressOf(Expr("a")));
+ auto* var_a = Var("a", ty.i32(), func, Expr(2_i));
+ auto* var_b = Let("b", ty.pointer<i32>(func), AddressOf(Expr("a")));
WrapInFunction(var_a, var_b,
- CompoundAssign(Source{{12, 34}}, Deref("b"), 2, ast::BinaryOp::kAdd));
+ CompoundAssign(Source{{12, 34}}, Deref("b"), 2_i, ast::BinaryOp::kAdd));
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
@@ -62,7 +64,7 @@
// a += 2.3;
// }
- auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
+ auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
auto* assign = CompoundAssign(Source{{12, 34}}, "a", 2.3f, ast::BinaryOp::kAdd);
WrapInFunction(var, assign);
@@ -217,9 +219,9 @@
TEST_F(ResolverCompoundAssignmentValidationTest, Phony) {
// {
- // _ += 1;
+ // _ += 1i;
// }
- WrapInFunction(CompoundAssign(Source{{56, 78}}, Phony(), 1, ast::BinaryOp::kAdd));
+ WrapInFunction(CompoundAssign(Source{{56, 78}}, Phony(), 1_i, ast::BinaryOp::kAdd));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
"56:78 error: compound assignment operand types are invalid: void "
@@ -229,11 +231,11 @@
TEST_F(ResolverCompoundAssignmentValidationTest, ReadOnlyBuffer) {
// @group(0) @binding(0) var<storage,read> a : i32;
// {
- // a += 1;
+ // a += 1i;
// }
Global(Source{{12, 34}}, "a", ty.i32(), ast::StorageClass::kStorage, ast::Access::kRead,
GroupAndBinding(0, 0));
- WrapInFunction(CompoundAssign(Source{{56, 78}}, "a", 1, ast::BinaryOp::kAdd));
+ WrapInFunction(CompoundAssign(Source{{56, 78}}, "a", 1_i, ast::BinaryOp::kAdd));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -242,10 +244,10 @@
}
TEST_F(ResolverCompoundAssignmentValidationTest, LhsConstant) {
- // let a = 1;
- // a += 1;
- auto* a = Let(Source{{12, 34}}, "a", nullptr, Expr(1));
- WrapInFunction(a, CompoundAssign(Expr(Source{{56, 78}}, "a"), 1, ast::BinaryOp::kAdd));
+ // let a = 1i;
+ // a += 1i;
+ auto* a = Let(Source{{12, 34}}, "a", nullptr, Expr(1_i));
+ WrapInFunction(a, CompoundAssign(Expr(Source{{56, 78}}, "a"), 1_i, ast::BinaryOp::kAdd));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), R"(56:78 error: cannot assign to const
@@ -253,8 +255,8 @@
}
TEST_F(ResolverCompoundAssignmentValidationTest, LhsLiteral) {
- // 1 += 1;
- WrapInFunction(CompoundAssign(Expr(Source{{56, 78}}, 1), 1, ast::BinaryOp::kAdd));
+ // 1i += 1i;
+ WrapInFunction(CompoundAssign(Expr(Source{{56, 78}}, 1_i), 1_i, ast::BinaryOp::kAdd));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "56:78 error: cannot assign to value of type 'i32'");
diff --git a/src/tint/resolver/compound_statement_test.cc b/src/tint/resolver/compound_statement_test.cc
index 1358b38..4061a62 100644
--- a/src/tint/resolver/compound_statement_test.cc
+++ b/src/tint/resolver/compound_statement_test.cc
@@ -22,6 +22,8 @@
#include "src/tint/sem/loop_statement.h"
#include "src/tint/sem/switch_statement.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -87,7 +89,7 @@
// }
// }
auto* brk = Break();
- auto* stmt = Ignore(1);
+ auto* stmt = Ignore(1_i);
auto* loop = Loop(Block(brk), Block(stmt));
auto* f = Func("F", {}, ty.void_(), {loop});
@@ -150,7 +152,7 @@
// }
auto* init = Decl(Var("i", ty.u32()));
auto* cond = Expr(true);
- auto* cont = Assign("i", Add("i", 1u));
+ auto* cont = Assign("i", Add("i", 1_u));
auto* stmt = Return();
auto* body = Block(stmt);
auto* for_ = For(init, cond, cont, body);
@@ -220,10 +222,10 @@
// }
auto* cond_a = Expr(true);
- auto* stmt_a = Ignore(1);
+ auto* stmt_a = Ignore(1_i);
auto* cond_b = Expr(true);
- auto* stmt_b = Ignore(1);
- auto* stmt_c = Ignore(1);
+ auto* stmt_b = Ignore(1_i);
+ auto* stmt_c = Ignore(1_i);
auto* if_stmt = If(cond_a, Block(stmt_a), Else(If(cond_b, Block(stmt_b), Else(Block(stmt_c)))));
WrapInFunction(if_stmt);
@@ -293,10 +295,10 @@
TEST_F(ResolverCompoundStatementTest, Switch) {
// fn F() {
// switch (expr) {
- // case 1: {
+ // case 1i: {
// stmt_a;
// }
- // case 2: {
+ // case 2i: {
// stmt_b;
// }
// default: {
@@ -305,11 +307,11 @@
// }
// }
- auto* expr = Expr(5);
- auto* stmt_a = Ignore(1);
- auto* stmt_b = Ignore(1);
- auto* stmt_c = Ignore(1);
- auto* swi = Switch(expr, Case(Expr(1), Block(stmt_a)), Case(Expr(2), Block(stmt_b)),
+ auto* expr = Expr(5_i);
+ auto* stmt_a = Ignore(1_i);
+ auto* stmt_b = Ignore(1_i);
+ auto* stmt_c = Ignore(1_i);
+ auto* swi = Switch(expr, Case(Expr(1_i), Block(stmt_a)), Case(Expr(2_i), Block(stmt_b)),
DefaultCase(Block(stmt_c)));
WrapInFunction(swi);
diff --git a/src/tint/resolver/control_block_validation_test.cc b/src/tint/resolver/control_block_validation_test.cc
index 3630d5c..b4742c9 100644
--- a/src/tint/resolver/control_block_validation_test.cc
+++ b/src/tint/resolver/control_block_validation_test.cc
@@ -18,6 +18,8 @@
#include "src/tint/ast/switch_statement.h"
#include "src/tint/resolver/resolver_test_helper.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -46,11 +48,11 @@
// switch (a) {
// case 1: {}
// }
- auto* var = Var("a", ty.i32(), Expr(2));
+ auto* var = Var("a", ty.i32(), Expr(2_i));
auto* block = Block(Decl(var), //
Switch(Source{{12, 34}}, "a", //
- Case(Expr(1))));
+ Case(Expr(1_i))));
WrapInFunction(block);
@@ -65,12 +67,12 @@
// case 1: {}
// default: {}
// }
- auto* var = Var("a", ty.i32(), Expr(2));
+ auto* var = Var("a", ty.i32(), Expr(2_i));
- auto* block = Block(Decl(var), //
- Switch("a", //
- DefaultCase(), //
- Case(Expr(1)), //
+ auto* block = Block(Decl(var), //
+ Switch("a", //
+ DefaultCase(), //
+ Case(Expr(1_i)), //
DefaultCase(Source{{12, 34}})));
WrapInFunction(block);
@@ -88,7 +90,7 @@
// }
auto* decl_z = Decl(Var("z", ty.i32()));
auto* cont = Continue();
- auto* assign_z = Assign(Source{{12, 34}}, "z", 1);
+ auto* assign_z = Assign(Source{{12, 34}}, "z", 1_i);
WrapInFunction(Loop(Block(If(false, Block(Break())), decl_z, cont, assign_z)));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -107,7 +109,7 @@
// }
auto* decl_z = Decl(Var("z", ty.i32()));
auto* cont = Continue();
- auto* assign_z = Assign(Source{{12, 34}}, "z", 1);
+ auto* assign_z = Assign(Source{{12, 34}}, "z", 1_i);
WrapInFunction(
Loop(Block(If(false, Block(Break())), decl_z, Block(Block(Block(cont))), assign_z)));
@@ -126,7 +128,7 @@
// }
auto* decl_z = Decl(Var("z", ty.i32()));
auto* cont = Continue();
- auto* assign_z = Assign(Source{{12, 34}}, "z", 1);
+ auto* assign_z = Assign(Source{{12, 34}}, "z", 1_i);
WrapInFunction(For(nullptr, false, nullptr, //
Block(decl_z, cont, assign_z)));
@@ -145,7 +147,7 @@
// }
auto* decl_z = Decl(Var("z", ty.i32()));
auto* cont = Continue();
- auto* assign_z = Assign(Source{{12, 34}}, "z", 1);
+ auto* assign_z = Assign(Source{{12, 34}}, "z", 1_i);
WrapInFunction(
For(nullptr, false, nullptr, Block(decl_z, Block(Block(Block(cont))), assign_z)));
@@ -157,19 +159,19 @@
}
TEST_F(ResolverControlBlockValidationTest, UnreachableCode_break) {
- // switch (1) {
- // case 1: {
+ // switch (1i) {
+ // case 1i: {
// var z: i32;
// break;
- // z = 1;
+ // z = 1i;
// default: {}
// }
auto* decl_z = Decl(Var("z", ty.i32()));
auto* brk = Break();
- auto* assign_z = Assign(Source{{12, 34}}, "z", 1);
- WrapInFunction( //
- Block(Switch(1, //
- Case(Expr(1), Block(decl_z, brk, assign_z)), //
+ auto* assign_z = Assign(Source{{12, 34}}, "z", 1_i);
+ WrapInFunction( //
+ Block(Switch(1_i, //
+ Case(Expr(1_i), Block(decl_z, brk, assign_z)), //
DefaultCase())));
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -181,18 +183,18 @@
TEST_F(ResolverControlBlockValidationTest, UnreachableCode_break_InBlocks) {
// loop {
- // switch (1) {
- // case 1: { {{{break;}}} var a : u32 = 2;}
+ // switch (1i) {
+ // case 1i: { {{{break;}}} var a : u32 = 2;}
// default: {}
// }
// break;
// }
auto* decl_z = Decl(Var("z", ty.i32()));
auto* brk = Break();
- auto* assign_z = Assign(Source{{12, 34}}, "z", 1);
+ auto* assign_z = Assign(Source{{12, 34}}, "z", 1_i);
WrapInFunction(
- Loop(Block(Switch(1, //
- Case(Expr(1), Block(decl_z, Block(Block(Block(brk))), assign_z)),
+ Loop(Block(Switch(1_i, //
+ Case(Expr(1_i), Block(decl_z, Block(Block(Block(brk))), assign_z)),
DefaultCase()), //
Break())));
@@ -206,13 +208,13 @@
TEST_F(ResolverControlBlockValidationTest, SwitchConditionTypeMustMatchSelectorType2_Fail) {
// var a : u32 = 2;
// switch (a) {
- // case 1: {}
+ // case 1i: {}
// default: {}
// }
- auto* var = Var("a", ty.i32(), Expr(2));
+ auto* var = Var("a", ty.i32(), Expr(2_i));
- auto* block = Block(Decl(var), Switch("a", //
- Case(Source{{12, 34}}, {Expr(1u)}), //
+ auto* block = Block(Decl(var), Switch("a", //
+ Case(Source{{12, 34}}, {Expr(1_u)}), //
DefaultCase()));
WrapInFunction(block);
@@ -225,14 +227,14 @@
TEST_F(ResolverControlBlockValidationTest, SwitchConditionTypeMustMatchSelectorType_Fail) {
// var a : u32 = 2;
// switch (a) {
- // case -1: {}
+ // case -1i: {}
// default: {}
// }
- auto* var = Var("a", ty.u32(), Expr(2u));
+ auto* var = Var("a", ty.u32(), Expr(2_u));
- auto* block = Block(Decl(var), //
- Switch("a", //
- Case(Source{{12, 34}}, {Expr(-1)}), //
+ auto* block = Block(Decl(var), //
+ Switch("a", //
+ Case(Source{{12, 34}}, {Expr(i32(-1))}), //
DefaultCase()));
WrapInFunction(block);
@@ -249,15 +251,15 @@
// case 2u, 3u, 2u: {}
// default: {}
// }
- auto* var = Var("a", ty.u32(), Expr(3u));
+ auto* var = Var("a", ty.u32(), Expr(3_u));
auto* block = Block(Decl(var), //
Switch("a", //
- Case(Expr(0u)),
+ Case(Expr(0_u)),
Case({
- Expr(Source{{12, 34}}, 2u),
- Expr(3u),
- Expr(Source{{56, 78}}, 2u),
+ Expr(Source{{12, 34}}, 2_u),
+ Expr(3_u),
+ Expr(Source{{56, 78}}, 2_u),
}),
DefaultCase()));
WrapInFunction(block);
@@ -275,16 +277,16 @@
// case 0,1,2,-10: {}
// default: {}
// }
- auto* var = Var("a", ty.i32(), Expr(2));
+ auto* var = Var("a", ty.i32(), Expr(2_i));
auto* block = Block(Decl(var), //
Switch("a", //
- Case(Expr(Source{{12, 34}}, -10)),
+ Case(Expr(Source{{12, 34}}, i32(-10))),
Case({
- Expr(0),
- Expr(1),
- Expr(2),
- Expr(Source{{56, 78}}, -10),
+ Expr(0_i),
+ Expr(1_i),
+ Expr(2_i),
+ Expr(Source{{56, 78}}, i32(-10)),
}),
DefaultCase()));
WrapInFunction(block);
@@ -300,7 +302,7 @@
// switch (a) {
// default: { fallthrough; }
// }
- auto* var = Var("a", ty.i32(), Expr(2));
+ auto* var = Var("a", ty.i32(), Expr(2_i));
auto* fallthrough = create<ast::FallthroughStatement>(Source{{12, 34}});
auto* block = Block(Decl(var), //
Switch("a", //
@@ -319,12 +321,12 @@
// default: {}
// case 5: {}
// }
- auto* var = Var("a", ty.i32(), Expr(2));
+ auto* var = Var("a", ty.i32(), Expr(2_i));
auto* block = Block(Decl(var), //
Switch("a", //
DefaultCase(Source{{12, 34}}), //
- Case(Expr(5))));
+ Case(Expr(5_i))));
WrapInFunction(block);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -338,7 +340,7 @@
// }
auto* my_int = Alias("MyInt", ty.u32());
- auto* var = Var("a", ty.Of(my_int), Expr(2u));
+ auto* var = Var("a", ty.Of(my_int), Expr(2_u));
auto* block = Block(Decl(var), //
Switch("a", DefaultCase(Source{{12, 34}})));
diff --git a/src/tint/resolver/dependency_graph_test.cc b/src/tint/resolver/dependency_graph_test.cc
index a0a6edd..248dc87 100644
--- a/src/tint/resolver/dependency_graph_test.cc
+++ b/src/tint/resolver/dependency_graph_test.cc
@@ -20,6 +20,8 @@
#include "src/tint/resolver/dependency_graph.h"
#include "src/tint/resolver/resolver_test_helper.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -425,7 +427,7 @@
case SymbolDeclKind::GlobalVar:
return b.Global(source, symbol, b.ty.i32(), ast::StorageClass::kPrivate);
case SymbolDeclKind::GlobalConst:
- return b.GlobalConst(source, symbol, b.ty.i32(), b.Expr(1));
+ return b.GlobalConst(source, symbol, b.ty.i32(), b.Expr(1_i));
case SymbolDeclKind::Alias:
return b.Alias(source, symbol, b.ty.i32());
case SymbolDeclKind::Struct:
@@ -443,7 +445,7 @@
return node;
}
case SymbolDeclKind::LocalLet: {
- auto* node = b.Let(source, symbol, b.ty.i32(), b.Expr(1));
+ auto* node = b.Let(source, symbol, b.ty.i32(), b.Expr(1_i));
statements.emplace_back(b.Decl(node));
return node;
}
@@ -453,7 +455,7 @@
return node;
}
case SymbolDeclKind::NestedLocalLet: {
- auto* node = b.Let(source, symbol, b.ty.i32(), b.Expr(1));
+ auto* node = b.Let(source, symbol, b.ty.i32(), b.Expr(1_i));
nested_statements.emplace_back(b.Decl(node));
return node;
}
@@ -471,7 +473,7 @@
}
case SymbolUseKind::GlobalVarArrayElemType: {
auto* node = b.ty.type_name(source, symbol);
- b.Global(b.Sym(), b.ty.array(node, 4), ast::StorageClass::kPrivate);
+ b.Global(b.Sym(), b.ty.array(node, 4_i), ast::StorageClass::kPrivate);
return node;
}
case SymbolUseKind::GlobalVarArraySizeValue: {
@@ -506,27 +508,27 @@
}
case SymbolUseKind::GlobalLetType: {
auto* node = b.ty.type_name(source, symbol);
- b.GlobalConst(b.Sym(), node, b.Expr(1));
+ b.GlobalConst(b.Sym(), node, b.Expr(1_i));
return node;
}
case SymbolUseKind::GlobalLetArrayElemType: {
auto* node = b.ty.type_name(source, symbol);
- b.GlobalConst(b.Sym(), b.ty.array(node, 4), b.Expr(1));
+ b.GlobalConst(b.Sym(), b.ty.array(node, 4_i), b.Expr(1_i));
return node;
}
case SymbolUseKind::GlobalLetArraySizeValue: {
auto* node = b.Expr(source, symbol);
- b.GlobalConst(b.Sym(), b.ty.array(b.ty.i32(), node), b.Expr(1));
+ b.GlobalConst(b.Sym(), b.ty.array(b.ty.i32(), node), b.Expr(1_i));
return node;
}
case SymbolUseKind::GlobalLetVectorElemType: {
auto* node = b.ty.type_name(source, symbol);
- b.GlobalConst(b.Sym(), b.ty.vec3(node), b.Expr(1));
+ b.GlobalConst(b.Sym(), b.ty.vec3(node), b.Expr(1_i));
return node;
}
case SymbolUseKind::GlobalLetMatrixElemType: {
auto* node = b.ty.type_name(source, symbol);
- b.GlobalConst(b.Sym(), b.ty.mat3x4(node), b.Expr(1));
+ b.GlobalConst(b.Sym(), b.ty.mat3x4(node), b.Expr(1_i));
return node;
}
case SymbolUseKind::GlobalLetValue: {
@@ -561,13 +563,13 @@
}
case SymbolUseKind::LocalVarArrayElemType: {
auto* node = b.ty.type_name(source, symbol);
- statements.emplace_back(b.Decl(b.Var(b.Sym(), b.ty.array(node, 4), b.Expr(1))));
+ statements.emplace_back(b.Decl(b.Var(b.Sym(), b.ty.array(node, 4_u), b.Expr(1_i))));
return node;
}
case SymbolUseKind::LocalVarArraySizeValue: {
auto* node = b.Expr(source, symbol);
statements.emplace_back(
- b.Decl(b.Var(b.Sym(), b.ty.array(b.ty.i32(), node), b.Expr(1))));
+ b.Decl(b.Var(b.Sym(), b.ty.array(b.ty.i32(), node), b.Expr(1_i))));
return node;
}
case SymbolUseKind::LocalVarVectorElemType: {
@@ -587,7 +589,7 @@
}
case SymbolUseKind::LocalLetType: {
auto* node = b.ty.type_name(source, symbol);
- statements.emplace_back(b.Decl(b.Let(b.Sym(), node, b.Expr(1))));
+ statements.emplace_back(b.Decl(b.Let(b.Sym(), node, b.Expr(1_i))));
return node;
}
case SymbolUseKind::LocalLetValue: {
@@ -607,7 +609,7 @@
}
case SymbolUseKind::NestedLocalLetType: {
auto* node = b.ty.type_name(source, symbol);
- nested_statements.emplace_back(b.Decl(b.Let(b.Sym(), node, b.Expr(1))));
+ nested_statements.emplace_back(b.Decl(b.Let(b.Sym(), node, b.Expr(1_i))));
return node;
}
case SymbolUseKind::NestedLocalLetValue: {
@@ -617,7 +619,7 @@
}
case SymbolUseKind::WorkgroupSizeValue: {
auto* node = b.Expr(source, symbol);
- func_attrs.emplace_back(b.WorkgroupSize(1, node, 2));
+ func_attrs.emplace_back(b.WorkgroupSize(1_i, node, 2_i));
return node;
}
}
@@ -767,27 +769,27 @@
TEST_F(ResolverDependencyGraphDeclSelfUse, GlobalVar) {
const Symbol symbol = Sym("SYMBOL");
- Global(symbol, ty.i32(), Mul(Expr(Source{{12, 34}}, symbol), 123));
+ Global(symbol, ty.i32(), Mul(Expr(Source{{12, 34}}, symbol), 123_i));
Build(R"(error: cyclic dependency found: 'SYMBOL' -> 'SYMBOL'
12:34 note: var 'SYMBOL' references var 'SYMBOL' here)");
}
TEST_F(ResolverDependencyGraphDeclSelfUse, GlobalConst) {
const Symbol symbol = Sym("SYMBOL");
- GlobalConst(symbol, ty.i32(), Mul(Expr(Source{{12, 34}}, symbol), 123));
+ GlobalConst(symbol, ty.i32(), Mul(Expr(Source{{12, 34}}, symbol), 123_i));
Build(R"(error: cyclic dependency found: 'SYMBOL' -> 'SYMBOL'
12:34 note: let 'SYMBOL' references let 'SYMBOL' here)");
}
TEST_F(ResolverDependencyGraphDeclSelfUse, LocalVar) {
const Symbol symbol = Sym("SYMBOL");
- WrapInFunction(Decl(Var(symbol, ty.i32(), Mul(Expr(Source{{12, 34}}, symbol), 123))));
+ WrapInFunction(Decl(Var(symbol, ty.i32(), Mul(Expr(Source{{12, 34}}, symbol), 123_i))));
Build("12:34 error: unknown identifier: 'SYMBOL'");
}
TEST_F(ResolverDependencyGraphDeclSelfUse, LocalLet) {
const Symbol symbol = Sym("SYMBOL");
- WrapInFunction(Decl(Let(symbol, ty.i32(), Mul(Expr(Source{{12, 34}}, symbol), 123))));
+ WrapInFunction(Decl(Let(symbol, ty.i32(), Mul(Expr(Source{{12, 34}}, symbol), 123_i))));
Build("12:34 error: unknown identifier: 'SYMBOL'");
}
@@ -1229,9 +1231,9 @@
Loop(Block(Assign(V, V)), //
Block(Assign(V, V))), //
Switch(V, //
- Case(Expr(1), //
+ Case(Expr(1_i), //
Block(Assign(V, V))), //
- Case(Expr(2), //
+ Case(Expr(2_i), //
Block(Fallthrough())), //
DefaultCase(Block(Assign(V, V)))), //
Return(V), //
@@ -1270,10 +1272,10 @@
TEST_F(ResolverDependencyGraphTraversalTest, InferredType) {
// Check that the nullptr of the var / let type doesn't make things explode
- Global("a", nullptr, Expr(1));
- GlobalConst("b", nullptr, Expr(1));
- WrapInFunction(Var("c", nullptr, Expr(1)), //
- Let("d", nullptr, Expr(1)));
+ Global("a", nullptr, Expr(1_i));
+ GlobalConst("b", nullptr, Expr(1_i));
+ WrapInFunction(Var("c", nullptr, Expr(1_i)), //
+ Let("d", nullptr, Expr(1_i)));
Build();
}
diff --git a/src/tint/resolver/entry_point_validation_test.cc b/src/tint/resolver/entry_point_validation_test.cc
index 5a10bf2..d1d9a48 100644
--- a/src/tint/resolver/entry_point_validation_test.cc
+++ b/src/tint/resolver/entry_point_validation_test.cc
@@ -21,6 +21,8 @@
#include "gmock/gmock.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -41,9 +43,6 @@
using mat4x4 = builder::mat4x4<T>;
template <typename T>
using alias = builder::alias<T>;
-using f32 = builder::f32;
-using i32 = builder::i32;
-using u32 = builder::u32;
class ResolverEntryPointValidationTest : public TestHelper, public testing::Test {};
@@ -648,9 +647,9 @@
}
TEST_F(LocationAttributeTests, ComputeShaderLocation_Input) {
- Func("main", {}, ty.i32(), {Return(Expr(1))},
+ Func("main", {}, ty.i32(), {Return(Expr(1_i))},
{Stage(ast::PipelineStage::kCompute),
- create<ast::WorkgroupAttribute>(Source{{12, 34}}, Expr(1))},
+ create<ast::WorkgroupAttribute>(Source{{12, 34}}, Expr(1_i))},
ast::AttributeList{Location(Source{{12, 34}}, 1)});
EXPECT_FALSE(r()->Resolve());
@@ -661,7 +660,7 @@
auto* input = Param("input", ty.i32(), ast::AttributeList{Location(Source{{12, 34}}, 0u)});
Func("main", {input}, ty.void_(), {},
{Stage(ast::PipelineStage::kCompute),
- create<ast::WorkgroupAttribute>(Source{{12, 34}}, Expr(1))});
+ create<ast::WorkgroupAttribute>(Source{{12, 34}}, Expr(1_i))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for compute shader inputs");
@@ -673,7 +672,7 @@
Func(Source{{56, 78}}, "main", {}, ty.Of(s),
ast::StatementList{Return(Expr(Construct(ty.Of(s))))},
{Stage(ast::PipelineStage::kCompute),
- create<ast::WorkgroupAttribute>(Source{{12, 34}}, Expr(1))});
+ create<ast::WorkgroupAttribute>(Source{{12, 34}}, Expr(1_i))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -687,7 +686,7 @@
auto* input = Param("input", ty.Of(s));
Func(Source{{56, 78}}, "main", {input}, ty.void_(), {},
{Stage(ast::PipelineStage::kCompute),
- create<ast::WorkgroupAttribute>(Source{{12, 34}}, Expr(1))});
+ create<ast::WorkgroupAttribute>(Source{{12, 34}}, Expr(1_i))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
diff --git a/src/tint/resolver/function_validation_test.cc b/src/tint/resolver/function_validation_test.cc
index 0df7d3f..1bc70a5 100644
--- a/src/tint/resolver/function_validation_test.cc
+++ b/src/tint/resolver/function_validation_test.cc
@@ -20,6 +20,8 @@
#include "gmock/gmock.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -45,10 +47,10 @@
TEST_F(ResolverFunctionValidationTest, LocalConflictsWithParameter) {
// fn func(common_name : f32) {
- // let common_name = 1;
+ // let common_name = 1i;
// }
Func("func", {Param(Source{{12, 34}}, "common_name", ty.f32())}, ty.void_(),
- {Decl(Let(Source{{56, 78}}, "common_name", nullptr, Expr(1)))});
+ {Decl(Let(Source{{56, 78}}, "common_name", nullptr, Expr(1_i)))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), R"(56:78 error: redeclaration of 'common_name'
@@ -58,18 +60,18 @@
TEST_F(ResolverFunctionValidationTest, NestedLocalMayShadowParameter) {
// fn func(common_name : f32) {
// {
- // let common_name = 1;
+ // let common_name = 1i;
// }
// }
Func("func", {Param(Source{{12, 34}}, "common_name", ty.f32())}, ty.void_(),
- {Block(Decl(Let(Source{{56, 78}}, "common_name", nullptr, Expr(1))))});
+ {Block(Decl(Let(Source{{56, 78}}, "common_name", nullptr, Expr(1_i))))});
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverFunctionValidationTest, VoidFunctionEndWithoutReturnStatement_Pass) {
- // fn func { var a:i32 = 2; }
- auto* var = Var("a", ty.i32(), Expr(2));
+ // fn func { var a:i32 = 2i; }
+ auto* var = Var("a", ty.i32(), Expr(2_i));
Func(Source{{12, 34}}, "func", ast::VariableList{}, ty.void_(),
ast::StatementList{
@@ -81,11 +83,11 @@
TEST_F(ResolverFunctionValidationTest, FunctionUsingSameVariableName_Pass) {
// fn func() -> i32 {
- // var func:i32 = 0;
+ // var func:i32 = 0i;
// return func;
// }
- auto* var = Var("func", ty.i32(), Expr(0));
+ auto* var = Var("func", ty.i32(), Expr(0_i));
Func("func", ast::VariableList{}, ty.i32(),
ast::StatementList{
Decl(var),
@@ -97,10 +99,10 @@
}
TEST_F(ResolverFunctionValidationTest, FunctionNameSameAsFunctionScopeVariableName_Pass) {
- // fn a() -> void { var b:i32 = 0; }
+ // fn a() -> void { var b:i32 = 0i; }
// fn b() -> i32 { return 2; }
- auto* var = Var("b", ty.i32(), Expr(0));
+ auto* var = Var("b", ty.i32(), Expr(0_i));
Func("a", ast::VariableList{}, ty.void_(),
ast::StatementList{
Decl(var),
@@ -109,7 +111,7 @@
Func(Source{{12, 34}}, "b", ast::VariableList{}, ty.i32(),
ast::StatementList{
- Return(2),
+ Return(2_i),
},
ast::AttributeList{});
@@ -120,12 +122,12 @@
// fn func() -> {
// var a : i32;
// return;
- // a = 2;
+ // a = 2i;
//}
auto* decl_a = Decl(Var("a", ty.i32()));
auto* ret = Return();
- auto* assign_a = Assign(Source{{12, 34}}, "a", 2);
+ auto* assign_a = Assign(Source{{12, 34}}, "a", 2_i);
Func("func", ast::VariableList{}, ty.void_(), {decl_a, ret, assign_a});
@@ -141,12 +143,12 @@
// fn func() -> {
// var a : i32;
// {{{return;}}}
- // a = 2;
+ // a = 2i;
//}
auto* decl_a = Decl(Var("a", ty.i32()));
auto* ret = Return();
- auto* assign_a = Assign(Source{{12, 34}}, "a", 2);
+ auto* assign_a = Assign(Source{{12, 34}}, "a", 2_i);
Func("func", ast::VariableList{}, ty.void_(), {decl_a, Block(Block(Block(ret))), assign_a});
@@ -161,12 +163,12 @@
// fn func() -> {
// var a : i32;
// discard;
- // a = 2;
+ // a = 2i;
//}
auto* decl_a = Decl(Var("a", ty.i32()));
auto* discard = Discard();
- auto* assign_a = Assign(Source{{12, 34}}, "a", 2);
+ auto* assign_a = Assign(Source{{12, 34}}, "a", 2_i);
Func("func", ast::VariableList{}, ty.void_(), {decl_a, discard, assign_a});
@@ -181,12 +183,12 @@
// fn func() -> {
// var a : i32;
// {{{discard;}}}
- // a = 2;
+ // a = 2i;
//}
auto* decl_a = Decl(Var("a", ty.i32()));
auto* discard = Discard();
- auto* assign_a = Assign(Source{{12, 34}}, "a", 2);
+ auto* assign_a = Assign(Source{{12, 34}}, "a", 2_i);
Func("func", ast::VariableList{}, ty.void_(), {decl_a, Block(Block(Block(discard))), assign_a});
@@ -198,9 +200,9 @@
}
TEST_F(ResolverFunctionValidationTest, FunctionEndWithoutReturnStatement_Fail) {
- // fn func() -> int { var a:i32 = 2; }
+ // fn func() -> int { var a:i32 = 2i; }
- auto* var = Var("a", ty.i32(), Expr(2));
+ auto* var = Var("a", ty.i32(), Expr(2_i));
Func(Source{{12, 34}}, "func", ast::VariableList{}, ty.i32(),
ast::StatementList{
@@ -242,10 +244,10 @@
}
TEST_F(ResolverFunctionValidationTest, FunctionTypeMustMatchReturnStatementType_fail) {
- // fn func { return 2; }
+ // fn func { return 2i; }
Func("func", ast::VariableList{}, ty.void_(),
ast::StatementList{
- Return(Source{{12, 34}}, Expr(2)),
+ Return(Source{{12, 34}}, Expr(2_i)),
},
ast::AttributeList{});
@@ -294,10 +296,10 @@
}
TEST_F(ResolverFunctionValidationTest, FunctionTypeMustMatchReturnStatementTypeF32_fail) {
- // fn func() -> f32 { return 2; }
+ // fn func() -> f32 { return 2i; }
Func("func", ast::VariableList{}, ty.f32(),
ast::StatementList{
- Return(Source{{12, 34}}, Expr(2)),
+ Return(Source{{12, 34}}, Expr(2_i)),
},
ast::AttributeList{});
@@ -322,11 +324,11 @@
TEST_F(ResolverFunctionValidationTest, FunctionTypeMustMatchReturnStatementTypeF32Alias_fail) {
// type myf32 = f32;
- // fn func() -> myf32 { return 2; }
+ // fn func() -> myf32 { return 2u; }
auto* myf32 = Alias("myf32", ty.f32());
Func("func", ast::VariableList{}, ty.Of(myf32),
ast::StatementList{
- Return(Source{{12, 34}}, Expr(2u)),
+ Return(Source{{12, 34}}, Expr(2_u)),
},
ast::AttributeList{});
@@ -340,7 +342,7 @@
// @stage(compute) @workgroup_size(1) fn entrypoint() {}
// fn func() { return entrypoint(); }
Func("entrypoint", ast::VariableList{}, ty.void_(), {},
- {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1)});
+ {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
Func("func", ast::VariableList{}, ty.void_(),
{
@@ -412,7 +414,7 @@
TEST_F(ResolverFunctionValidationTest, FunctionParamsConst) {
Func("foo", {Param(Sym("arg"), ty.i32())}, ty.void_(),
- {Assign(Expr(Source{{12, 34}}, "arg"), Expr(1)), Return()});
+ {Assign(Expr(Source{{12, 34}}, "arg"), Expr(1_i)), Return()});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -425,11 +427,11 @@
// let x = 8u;
// @stage(compute) @workgroup_size(x, y, 16u)
// fn main() {}
- auto* x = GlobalConst("x", ty.u32(), Expr(4u));
- auto* y = GlobalConst("y", ty.u32(), Expr(8u));
- auto* func =
- Func("main", {}, ty.void_(), {},
- {Stage(ast::PipelineStage::kCompute), WorkgroupSize(Expr("x"), Expr("y"), Expr(16u))});
+ auto* x = GlobalConst("x", ty.u32(), Expr(4_u));
+ auto* y = GlobalConst("y", ty.u32(), Expr(8_u));
+ auto* func = Func(
+ "main", {}, ty.void_(), {},
+ {Stage(ast::PipelineStage::kCompute), WorkgroupSize(Expr("x"), Expr("y"), Expr(16_u))});
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -451,18 +453,18 @@
Func("main", {}, ty.void_(), {},
{Stage(ast::PipelineStage::kCompute),
- WorkgroupSize(Source{{12, 34}}, Expr(1u), Expr(2u), Expr(3u))});
+ WorkgroupSize(Source{{12, 34}}, Expr(1_u), Expr(2_u), Expr(3_u))});
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverFunctionValidationTest, WorkgroupSize_MismatchTypeU32) {
- // @stage(compute) @workgroup_size(1u, 2u, 3)
+ // @stage(compute) @workgroup_size(1u, 2u, 3_i)
// fn main() {}
Func("main", {}, ty.void_(), {},
{Stage(ast::PipelineStage::kCompute),
- WorkgroupSize(Expr(1u), Expr(2u), Expr(Source{{12, 34}}, 3))});
+ WorkgroupSize(Expr(1_u), Expr(2_u), Expr(Source{{12, 34}}, 3_i))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -471,12 +473,12 @@
}
TEST_F(ResolverFunctionValidationTest, WorkgroupSize_MismatchTypeI32) {
- // @stage(compute) @workgroup_size(1, 2u, 3)
+ // @stage(compute) @workgroup_size(1_i, 2u, 3_i)
// fn main() {}
Func("main", {}, ty.void_(), {},
{Stage(ast::PipelineStage::kCompute),
- WorkgroupSize(Expr(1), Expr(Source{{12, 34}}, 2u), Expr(3))});
+ WorkgroupSize(Expr(1_i), Expr(Source{{12, 34}}, 2_u), Expr(3_i))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -486,12 +488,12 @@
TEST_F(ResolverFunctionValidationTest, WorkgroupSize_Const_TypeMismatch) {
// let x = 64u;
- // @stage(compute) @workgroup_size(1, x)
+ // @stage(compute) @workgroup_size(1i, x)
// fn main() {}
- GlobalConst("x", ty.u32(), Expr(64u));
- Func(
- "main", {}, ty.void_(), {},
- {Stage(ast::PipelineStage::kCompute), WorkgroupSize(Expr(1), Expr(Source{{12, 34}}, "x"))});
+ GlobalConst("x", ty.u32(), Expr(64_u));
+ Func("main", {}, ty.void_(), {},
+ {Stage(ast::PipelineStage::kCompute),
+ WorkgroupSize(Expr(1_i), Expr(Source{{12, 34}}, "x"))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -501,11 +503,11 @@
TEST_F(ResolverFunctionValidationTest, WorkgroupSize_Const_TypeMismatch2) {
// let x = 64u;
- // let y = 32;
+ // let y = 32i;
// @stage(compute) @workgroup_size(x, y)
// fn main() {}
- GlobalConst("x", ty.u32(), Expr(64u));
- GlobalConst("y", ty.i32(), Expr(32));
+ GlobalConst("x", ty.u32(), Expr(64_u));
+ GlobalConst("y", ty.i32(), Expr(32_i));
Func("main", {}, ty.void_(), {},
{Stage(ast::PipelineStage::kCompute),
WorkgroupSize(Expr("x"), Expr(Source{{12, 34}}, "y"))});
@@ -518,13 +520,13 @@
TEST_F(ResolverFunctionValidationTest, WorkgroupSize_Mismatch_ConstU32) {
// let x = 4u;
// let x = 8u;
- // @stage(compute) @workgroup_size(x, y, 16
+ // @stage(compute) @workgroup_size(x, y, 16i)
// fn main() {}
- GlobalConst("x", ty.u32(), Expr(4u));
- GlobalConst("y", ty.u32(), Expr(8u));
+ GlobalConst("x", ty.u32(), Expr(4_u));
+ GlobalConst("y", ty.u32(), Expr(8_u));
Func("main", {}, ty.void_(), {},
{Stage(ast::PipelineStage::kCompute),
- WorkgroupSize(Expr("x"), Expr("y"), Expr(Source{{12, 34}}, 16))});
+ WorkgroupSize(Expr("x"), Expr("y"), Expr(Source{{12, 34}}, 16_i))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -546,22 +548,22 @@
}
TEST_F(ResolverFunctionValidationTest, WorkgroupSize_Literal_Negative) {
- // @stage(compute) @workgroup_size(-2)
+ // @stage(compute) @workgroup_size(-2i)
// fn main() {}
Func("main", {}, ty.void_(), {},
- {Stage(ast::PipelineStage::kCompute), WorkgroupSize(Expr(Source{{12, 34}}, -2))});
+ {Stage(ast::PipelineStage::kCompute), WorkgroupSize(Expr(Source{{12, 34}}, i32(-2)))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: workgroup_size argument must be at least 1");
}
TEST_F(ResolverFunctionValidationTest, WorkgroupSize_Literal_Zero) {
- // @stage(compute) @workgroup_size(0)
+ // @stage(compute) @workgroup_size(0i)
// fn main() {}
Func("main", {}, ty.void_(), {},
- {Stage(ast::PipelineStage::kCompute), WorkgroupSize(Expr(Source{{12, 34}}, 0))});
+ {Stage(ast::PipelineStage::kCompute), WorkgroupSize(Expr(Source{{12, 34}}, 0_i))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: workgroup_size argument must be at least 1");
@@ -582,10 +584,10 @@
}
TEST_F(ResolverFunctionValidationTest, WorkgroupSize_Const_Negative) {
- // let x = -2;
+ // let x = -2i;
// @stage(compute) @workgroup_size(x)
// fn main() {}
- GlobalConst("x", ty.i32(), Expr(-2));
+ GlobalConst("x", ty.i32(), Expr(i32(-2)));
Func("main", {}, ty.void_(), {},
{Stage(ast::PipelineStage::kCompute), WorkgroupSize(Expr(Source{{12, 34}}, "x"))});
@@ -594,10 +596,10 @@
}
TEST_F(ResolverFunctionValidationTest, WorkgroupSize_Const_Zero) {
- // let x = 0;
+ // let x = 0i;
// @stage(compute) @workgroup_size(x)
// fn main() {}
- GlobalConst("x", ty.i32(), Expr(0));
+ GlobalConst("x", ty.i32(), Expr(0_i));
Func("main", {}, ty.void_(), {},
{Stage(ast::PipelineStage::kCompute), WorkgroupSize(Expr(Source{{12, 34}}, "x"))});
@@ -618,10 +620,10 @@
}
TEST_F(ResolverFunctionValidationTest, WorkgroupSize_NonConst) {
- // var<private> x = 0;
+ // var<private> x = 64i;
// @stage(compute) @workgroup_size(x)
// fn main() {}
- Global("x", ty.i32(), ast::StorageClass::kPrivate, Expr(64));
+ Global("x", ty.i32(), ast::StorageClass::kPrivate, Expr(64_i));
Func("main", {}, ty.void_(), {},
{Stage(ast::PipelineStage::kCompute), WorkgroupSize(Expr(Source{{12, 34}}, "x"))});
@@ -636,7 +638,7 @@
// fn main() {}
Func("main", {}, ty.void_(), {},
{Stage(ast::PipelineStage::kCompute),
- WorkgroupSize(Construct(Source{{12, 34}}, ty.i32(), 1))});
+ WorkgroupSize(Construct(Source{{12, 34}}, ty.i32(), 1_i))});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -661,7 +663,7 @@
}
TEST_F(ResolverFunctionValidationTest, ReturnIsConstructible_ArrayOfAtomic) {
- auto* ret_type = ty.array(Source{{12, 34}}, ty.atomic(ty.i32()), 10);
+ auto* ret_type = ty.array(Source{{12, 34}}, ty.atomic(ty.i32()), 10_u);
Func("f", {}, ret_type, {});
EXPECT_FALSE(r()->Resolve());
diff --git a/src/tint/resolver/increment_decrement_validation_test.cc b/src/tint/resolver/increment_decrement_validation_test.cc
index e6f760b..37033c5 100644
--- a/src/tint/resolver/increment_decrement_validation_test.cc
+++ b/src/tint/resolver/increment_decrement_validation_test.cc
@@ -17,6 +17,8 @@
#include "gmock/gmock.h"
#include "src/tint/resolver/resolver_test_helper.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -25,7 +27,7 @@
TEST_F(ResolverIncrementDecrementValidationTest, Increment_Signed) {
// var a : i32 = 2;
// a++;
- auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
+ auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
WrapInFunction(var, Increment(Source{{12, 34}}, "a"));
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -34,7 +36,7 @@
TEST_F(ResolverIncrementDecrementValidationTest, Decrement_Signed) {
// var a : i32 = 2;
// a--;
- auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
+ auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
WrapInFunction(var, Decrement(Source{{12, 34}}, "a"));
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -43,7 +45,7 @@
TEST_F(ResolverIncrementDecrementValidationTest, Increment_Unsigned) {
// var a : u32 = 2u;
// a++;
- auto* var = Var("a", ty.u32(), ast::StorageClass::kNone, Expr(2u));
+ auto* var = Var("a", ty.u32(), ast::StorageClass::kNone, Expr(2_u));
WrapInFunction(var, Increment(Source{{12, 34}}, "a"));
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -52,7 +54,7 @@
TEST_F(ResolverIncrementDecrementValidationTest, Decrement_Unsigned) {
// var a : u32 = 2u;
// a--;
- auto* var = Var("a", ty.u32(), ast::StorageClass::kNone, Expr(2u));
+ auto* var = Var("a", ty.u32(), ast::StorageClass::kNone, Expr(2_u));
WrapInFunction(var, Decrement(Source{{12, 34}}, "a"));
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -63,26 +65,26 @@
// let b : ptr<function,i32> = &a;
// *b++;
auto* var_a = Var("a", ty.i32(), ast::StorageClass::kFunction);
- auto* var_b = Let("b", ty.pointer<int>(ast::StorageClass::kFunction), AddressOf(Expr("a")));
+ auto* var_b = Let("b", ty.pointer<i32>(ast::StorageClass::kFunction), AddressOf(Expr("a")));
WrapInFunction(var_a, var_b, Increment(Source{{12, 34}}, Deref("b")));
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverIncrementDecrementValidationTest, ThroughArray) {
- // var a : array<i32, 4>;
- // a[1]++;
- auto* var_a = Var("a", ty.array(ty.i32(), 4), ast::StorageClass::kNone);
- WrapInFunction(var_a, Increment(Source{{12, 34}}, IndexAccessor("a", 1)));
+ // var a : array<i32, 4_u>;
+ // a[1i]++;
+ auto* var_a = Var("a", ty.array(ty.i32(), 4_u), ast::StorageClass::kNone);
+ WrapInFunction(var_a, Increment(Source{{12, 34}}, IndexAccessor("a", 1_i)));
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverIncrementDecrementValidationTest, ThroughVector_Index) {
// var a : vec4<i32>;
- // a.y++;
+ // a[1i]++;
auto* var_a = Var("a", ty.vec4(ty.i32()), ast::StorageClass::kNone);
- WrapInFunction(var_a, Increment(Source{{12, 34}}, IndexAccessor("a", 1)));
+ WrapInFunction(var_a, Increment(Source{{12, 34}}, IndexAccessor("a", 1_i)));
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
@@ -136,7 +138,7 @@
TEST_F(ResolverIncrementDecrementValidationTest, Literal) {
// 1++;
- WrapInFunction(Increment(Expr(Source{{56, 78}}, 1)));
+ WrapInFunction(Increment(Expr(Source{{56, 78}}, 1_i)));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "56:78 error: cannot modify value of type 'i32'");
@@ -145,7 +147,7 @@
TEST_F(ResolverIncrementDecrementValidationTest, Constant) {
// let a = 1;
// a++;
- auto* a = Let(Source{{12, 34}}, "a", nullptr, Expr(1));
+ auto* a = Let(Source{{12, 34}}, "a", nullptr, Expr(1_i));
WrapInFunction(a, Increment(Expr(Source{{56, 78}}, "a")));
EXPECT_FALSE(r()->Resolve());
@@ -173,7 +175,7 @@
// {
// a++;
// }
- Func("func", {}, ty.i32(), {Return(0)});
+ Func("func", {}, ty.i32(), {Return(0_i)});
WrapInFunction(Increment(Call(Source{{56, 78}}, "func")));
EXPECT_FALSE(r()->Resolve());
@@ -205,7 +207,7 @@
// for (a++; ; ) {
// break;
// }
- auto* a = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
+ auto* a = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
auto* loop = For(Increment(Source{{56, 78}}, "a"), nullptr, nullptr, Block(Break()));
WrapInFunction(a, loop);
@@ -217,7 +219,7 @@
// for (; ; a++) {
// break;
// }
- auto* a = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
+ auto* a = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
auto* loop = For(nullptr, nullptr, Increment(Source{{56, 78}}, "a"), Block(Break()));
WrapInFunction(a, loop);
diff --git a/src/tint/resolver/inferred_type_test.cc b/src/tint/resolver/inferred_type_test.cc
index bafdd80..d8cc649 100644
--- a/src/tint/resolver/inferred_type_test.cc
+++ b/src/tint/resolver/inferred_type_test.cc
@@ -17,6 +17,8 @@
#include "gmock/gmock.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -37,9 +39,6 @@
using mat4x4 = builder::mat4x4<T>;
template <typename T>
using alias = builder::alias<T>;
-using f32 = builder::f32;
-using i32 = builder::i32;
-using u32 = builder::u32;
struct ResolverInferredTypeTest : public resolver::TestHelper, public testing::Test {};
@@ -133,7 +132,7 @@
INSTANTIATE_TEST_SUITE_P(ResolverTest, ResolverInferredTypeParamTest, testing::ValuesIn(all_cases));
TEST_F(ResolverInferredTypeTest, InferArray_Pass) {
- auto* type = ty.array(ty.u32(), 10);
+ auto* type = ty.array(ty.u32(), 10_u);
auto* expected_type = create<sem::Array>(create<sem::U32>(), 10u, 4u, 4u * 10u, 4u, 4u);
auto* ctor_expr = Construct(type);
diff --git a/src/tint/resolver/ptr_ref_validation_test.cc b/src/tint/resolver/ptr_ref_validation_test.cc
index 328b35d..b011dd0 100644
--- a/src/tint/resolver/ptr_ref_validation_test.cc
+++ b/src/tint/resolver/ptr_ref_validation_test.cc
@@ -19,6 +19,8 @@
#include "gmock/gmock.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -27,7 +29,7 @@
TEST_F(ResolverPtrRefValidationTest, AddressOfLiteral) {
// &1
- auto* expr = AddressOf(Expr(Source{{12, 34}}, 1));
+ auto* expr = AddressOf(Expr(Source{{12, 34}}, 1_i));
WrapInFunction(expr);
@@ -39,7 +41,7 @@
TEST_F(ResolverPtrRefValidationTest, AddressOfLet) {
// let l : i32 = 1;
// &l
- auto* l = Let("l", ty.i32(), Expr(1));
+ auto* l = Let("l", ty.i32(), Expr(1_i));
auto* expr = AddressOf(Expr(Source{{12, 34}}, "l"));
WrapInFunction(l, expr);
@@ -77,9 +79,9 @@
TEST_F(ResolverPtrRefValidationTest, AddressOfVectorComponent_IndexAccessor) {
// var v : vec4<i32>;
- // &v[2]
+ // &v[2i]
auto* v = Var("v", ty.vec4<i32>());
- auto* expr = AddressOf(IndexAccessor(Source{{12, 34}}, "v", 2));
+ auto* expr = AddressOf(IndexAccessor(Source{{12, 34}}, "v", 2_i));
WrapInFunction(v, expr);
@@ -104,7 +106,7 @@
TEST_F(ResolverPtrRefValidationTest, DerefOfLiteral) {
// *1
- auto* expr = Deref(Expr(Source{{12, 34}}, 1));
+ auto* expr = Deref(Expr(Source{{12, 34}}, 1_i));
WrapInFunction(expr);
@@ -114,8 +116,8 @@
}
TEST_F(ResolverPtrRefValidationTest, DerefOfVar) {
- // var v : i32 = 1;
- // *1
+ // var v : i32;
+ // *v
auto* v = Var("v", ty.i32());
auto* expr = Deref(Expr(Source{{12, 34}}, "v"));
@@ -128,14 +130,14 @@
TEST_F(ResolverPtrRefValidationTest, InferredPtrAccessMismatch) {
// struct Inner {
- // arr: array<i32, 4>;
+ // arr: array<i32, 4u>;
// }
// struct S {
// inner: Inner;
// }
// @group(0) @binding(0) var<storage, read_write> s : S;
// fn f() {
- // let p : pointer<storage, i32> = &s.inner.arr[2];
+ // let p : pointer<storage, i32> = &s.inner.arr[2i];
// }
auto* inner = Structure("Inner", {Member("arr", ty.array<i32, 4>())});
auto* buf = Structure("S", {Member("inner", ty.Of(inner))});
@@ -145,7 +147,7 @@
create<ast::GroupAttribute>(0),
});
- auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 4);
+ auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 2_i);
auto* ptr =
Let(Source{{12, 34}}, "p", ty.pointer<i32>(ast::StorageClass::kStorage), AddressOf(expr));
diff --git a/src/tint/resolver/resolver_behavior_test.cc b/src/tint/resolver/resolver_behavior_test.cc
index 03729c5..9cb26dc 100644
--- a/src/tint/resolver/resolver_behavior_test.cc
+++ b/src/tint/resolver/resolver_behavior_test.cc
@@ -20,6 +20,8 @@
#include "src/tint/sem/for_loop_statement.h"
#include "src/tint/sem/if_statement.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -32,13 +34,13 @@
Func("DiscardOrNext", {}, ty.i32(),
{
If(true, Block(Discard())),
- Return(1),
+ Return(1_i),
});
}
};
TEST_F(ResolverBehaviorTest, ExprBinaryOp_LHS) {
- auto* stmt = Decl(Var("lhs", ty.i32(), Add(Call("DiscardOrNext"), 1)));
+ auto* stmt = Decl(Var("lhs", ty.i32(), Add(Call("DiscardOrNext"), 1_i)));
WrapInFunction(stmt);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -48,7 +50,7 @@
}
TEST_F(ResolverBehaviorTest, ExprBinaryOp_RHS) {
- auto* stmt = Decl(Var("lhs", ty.i32(), Add(1, Call("DiscardOrNext"))));
+ auto* stmt = Decl(Var("lhs", ty.i32(), Add(1_i, Call("DiscardOrNext"))));
WrapInFunction(stmt);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -74,7 +76,7 @@
Return(Construct(ty.array<i32, 4>())),
});
- auto* stmt = Decl(Var("lhs", ty.i32(), IndexAccessor(Call("ArrayDiscardOrNext"), 1)));
+ auto* stmt = Decl(Var("lhs", ty.i32(), IndexAccessor(Call("ArrayDiscardOrNext"), 1_i)));
WrapInFunction(stmt);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -119,7 +121,7 @@
}
TEST_F(ResolverBehaviorTest, StmtAssign_LHSDiscardOrNext) {
- auto* stmt = Assign(IndexAccessor("lhs", Call("DiscardOrNext")), 1);
+ auto* stmt = Assign(IndexAccessor("lhs", Call("DiscardOrNext")), 1_i);
WrapInFunction(Decl(Var("lhs", ty.array<i32, 4>())), //
stmt);
@@ -302,7 +304,7 @@
}
TEST_F(ResolverBehaviorTest, StmtForLoopEmpty_CondCallFuncMayDiscard) {
- auto* stmt = For(nullptr, Equal(Call("DiscardOrNext"), 1), nullptr, Block());
+ auto* stmt = For(nullptr, Equal(Call("DiscardOrNext"), 1_i), nullptr, Block());
WrapInFunction(stmt);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -352,7 +354,7 @@
}
TEST_F(ResolverBehaviorTest, StmtIfCallFuncMayDiscard_ThenEmptyBlock) {
- auto* stmt = If(Equal(Call("DiscardOrNext"), 1), Block());
+ auto* stmt = If(Equal(Call("DiscardOrNext"), 1_i), Block());
WrapInFunction(stmt);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -363,7 +365,7 @@
TEST_F(ResolverBehaviorTest, StmtIfTrue_ThenEmptyBlock_ElseCallFuncMayDiscard) {
auto* stmt = If(true, Block(), //
- Else(If(Equal(Call("DiscardOrNext"), 1), Block())));
+ Else(If(Equal(Call("DiscardOrNext"), 1_i), Block())));
WrapInFunction(stmt);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -373,7 +375,7 @@
}
TEST_F(ResolverBehaviorTest, StmtLetDecl) {
- auto* stmt = Decl(Let("v", ty.i32(), Expr(1)));
+ auto* stmt = Decl(Let("v", ty.i32(), Expr(1_i)));
WrapInFunction(stmt);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -477,7 +479,7 @@
}
TEST_F(ResolverBehaviorTest, StmtSwitch_CondTrue_DefaultEmpty) {
- auto* stmt = Switch(1, DefaultCase(Block()));
+ auto* stmt = Switch(1_i, DefaultCase(Block()));
WrapInFunction(stmt);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -487,7 +489,7 @@
}
TEST_F(ResolverBehaviorTest, StmtSwitch_CondLiteral_DefaultEmpty) {
- auto* stmt = Switch(1, DefaultCase(Block()));
+ auto* stmt = Switch(1_i, DefaultCase(Block()));
WrapInFunction(stmt);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -497,7 +499,7 @@
}
TEST_F(ResolverBehaviorTest, StmtSwitch_CondLiteral_DefaultDiscard) {
- auto* stmt = Switch(1, DefaultCase(Block(Discard())));
+ auto* stmt = Switch(1_i, DefaultCase(Block(Discard())));
WrapInFunction(stmt);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -507,7 +509,7 @@
}
TEST_F(ResolverBehaviorTest, StmtSwitch_CondLiteral_DefaultReturn) {
- auto* stmt = Switch(1, DefaultCase(Block(Return())));
+ auto* stmt = Switch(1_i, DefaultCase(Block(Return())));
WrapInFunction(stmt);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -517,7 +519,7 @@
}
TEST_F(ResolverBehaviorTest, StmtSwitch_CondLiteral_Case0Empty_DefaultEmpty) {
- auto* stmt = Switch(1, Case(Expr(0), Block()), DefaultCase(Block()));
+ auto* stmt = Switch(1_i, Case(Expr(0_i), Block()), DefaultCase(Block()));
WrapInFunction(stmt);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -527,7 +529,7 @@
}
TEST_F(ResolverBehaviorTest, StmtSwitch_CondLiteral_Case0Empty_DefaultDiscard) {
- auto* stmt = Switch(1, Case(Expr(0), Block()), DefaultCase(Block(Discard())));
+ auto* stmt = Switch(1_i, Case(Expr(0_i), Block()), DefaultCase(Block(Discard())));
WrapInFunction(stmt);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -537,7 +539,7 @@
}
TEST_F(ResolverBehaviorTest, StmtSwitch_CondLiteral_Case0Empty_DefaultReturn) {
- auto* stmt = Switch(1, Case(Expr(0), Block()), DefaultCase(Block(Return())));
+ auto* stmt = Switch(1_i, Case(Expr(0_i), Block()), DefaultCase(Block(Return())));
WrapInFunction(stmt);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -547,7 +549,7 @@
}
TEST_F(ResolverBehaviorTest, StmtSwitch_CondLiteral_Case0Discard_DefaultEmpty) {
- auto* stmt = Switch(1, Case(Expr(0), Block(Discard())), DefaultCase(Block()));
+ auto* stmt = Switch(1_i, Case(Expr(0_i), Block(Discard())), DefaultCase(Block()));
WrapInFunction(stmt);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -557,7 +559,7 @@
}
TEST_F(ResolverBehaviorTest, StmtSwitch_CondLiteral_Case0Discard_DefaultDiscard) {
- auto* stmt = Switch(1, Case(Expr(0), Block(Discard())), DefaultCase(Block(Discard())));
+ auto* stmt = Switch(1_i, Case(Expr(0_i), Block(Discard())), DefaultCase(Block(Discard())));
WrapInFunction(stmt);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -567,7 +569,7 @@
}
TEST_F(ResolverBehaviorTest, StmtSwitch_CondLiteral_Case0Discard_DefaultReturn) {
- auto* stmt = Switch(1, Case(Expr(0), Block(Discard())), DefaultCase(Block(Return())));
+ auto* stmt = Switch(1_i, Case(Expr(0_i), Block(Discard())), DefaultCase(Block(Return())));
WrapInFunction(stmt);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -577,9 +579,9 @@
}
TEST_F(ResolverBehaviorTest, StmtSwitch_CondLiteral_Case0Discard_Case1Return_DefaultEmpty) {
- auto* stmt = Switch(1, //
- Case(Expr(0), Block(Discard())), //
- Case(Expr(1), Block(Return())), //
+ auto* stmt = Switch(1_i, //
+ Case(Expr(0_i), Block(Discard())), //
+ Case(Expr(1_i), Block(Return())), //
DefaultCase(Block()));
WrapInFunction(stmt);
diff --git a/src/tint/resolver/resolver_constants.cc b/src/tint/resolver/resolver_constants.cc
index 69ee798..f5346d1 100644
--- a/src/tint/resolver/resolver_constants.cc
+++ b/src/tint/resolver/resolver_constants.cc
@@ -18,14 +18,9 @@
#include "src/tint/sem/type_constructor.h"
#include "src/tint/utils/map.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
-namespace {
-
-using i32 = ProgramBuilder::i32;
-using u32 = ProgramBuilder::u32;
-using f32 = ProgramBuilder::f32;
-
-} // namespace
sem::Constant Resolver::EvaluateConstantValue(const ast::Expression* expr, const sem::Type* type) {
if (auto* e = expr->As<ast::LiteralExpression>()) {
@@ -43,9 +38,9 @@
literal,
[&](const ast::IntLiteralExpression* lit) {
if (lit->suffix == ast::IntLiteralExpression::Suffix::kU) {
- return sem::Constant{type, {static_cast<uint32_t>(lit->value)}};
+ return sem::Constant{type, {u32(static_cast<uint32_t>(lit->value))}};
}
- return sem::Constant{type, {static_cast<int32_t>(lit->value)}};
+ return sem::Constant{type, {i32(static_cast<int32_t>(lit->value))}};
},
[&](const ast::FloatLiteralExpression* lit) {
return sem::Constant{type, {lit->value}};
@@ -70,10 +65,10 @@
// For zero value init, return 0s
if (call->args.empty()) {
if (elem_type->Is<sem::I32>()) {
- return sem::Constant(type, sem::Constant::Scalars(result_size, 0));
+ return sem::Constant(type, sem::Constant::Scalars(result_size, 0_i));
}
if (elem_type->Is<sem::U32>()) {
- return sem::Constant(type, sem::Constant::Scalars(result_size, 0u));
+ return sem::Constant(type, sem::Constant::Scalars(result_size, 0_u));
}
if (elem_type->Is<sem::F32>()) {
return sem::Constant(type, sem::Constant::Scalars(result_size, 0.f));
@@ -113,16 +108,34 @@
sem::Constant::Scalars elems;
for (size_t i = 0; i < value.Elements().size(); ++i) {
- if (target_elem_type->Is<sem::I32>()) {
- elems.emplace_back(value.WithScalarAt(i, [](auto&& s) { return static_cast<i32>(s); }));
- } else if (target_elem_type->Is<sem::U32>()) {
- elems.emplace_back(value.WithScalarAt(i, [](auto&& s) { return static_cast<u32>(s); }));
- } else if (target_elem_type->Is<sem::F32>()) {
- elems.emplace_back(value.WithScalarAt(i, [](auto&& s) { return static_cast<f32>(s); }));
- } else if (target_elem_type->Is<sem::Bool>()) {
- elems.emplace_back(
- value.WithScalarAt(i, [](auto&& s) { return static_cast<bool>(s); }));
- }
+ elems.emplace_back(Switch<sem::Constant::Scalar>(
+ target_elem_type,
+ [&](const sem::I32*) {
+ return value.WithScalarAt(i, [](auto&& s) { //
+ return i32(static_cast<int32_t>(s));
+ });
+ },
+ [&](const sem::U32*) {
+ return value.WithScalarAt(i, [](auto&& s) { //
+ return u32(static_cast<uint32_t>(s));
+ });
+ },
+ [&](const sem::F32*) {
+ return value.WithScalarAt(i, [](auto&& s) { //
+ return static_cast<f32>(s);
+ });
+ },
+ [&](const sem::Bool*) {
+ return value.WithScalarAt(i, [](auto&& s) { //
+ return static_cast<bool>(s);
+ });
+ },
+ [&](Default) {
+ diag::List diags;
+ TINT_UNREACHABLE(Semantic, diags)
+ << "invalid element type " << target_elem_type->TypeInfo().name;
+ return sem::Constant::Scalar(false);
+ }));
}
auto* target_type =
diff --git a/src/tint/resolver/resolver_constants_test.cc b/src/tint/resolver/resolver_constants_test.cc
index ceb0822..798de0a 100644
--- a/src/tint/resolver/resolver_constants_test.cc
+++ b/src/tint/resolver/resolver_constants_test.cc
@@ -18,6 +18,8 @@
#include "src/tint/resolver/resolver_test_helper.h"
#include "src/tint/sem/expression.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -26,7 +28,7 @@
using ResolverConstantsTest = ResolverTest;
TEST_F(ResolverConstantsTest, Scalar_i32) {
- auto* expr = Expr(99);
+ auto* expr = Expr(99_i);
WrapInFunction(expr);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -41,7 +43,7 @@
}
TEST_F(ResolverConstantsTest, Scalar_u32) {
- auto* expr = Expr(99u);
+ auto* expr = Expr(99_u);
WrapInFunction(expr);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -162,7 +164,7 @@
}
TEST_F(ResolverConstantsTest, Vec3_Splat_i32) {
- auto* expr = vec3<i32>(99);
+ auto* expr = vec3<i32>(99_i);
WrapInFunction(expr);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -181,7 +183,7 @@
}
TEST_F(ResolverConstantsTest, Vec3_Splat_u32) {
- auto* expr = vec3<u32>(99u);
+ auto* expr = vec3<u32>(99_u);
WrapInFunction(expr);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -238,7 +240,7 @@
}
TEST_F(ResolverConstantsTest, Vec3_FullConstruct_i32) {
- auto* expr = vec3<i32>(1, 2, 3);
+ auto* expr = vec3<i32>(1_i, 2_i, 3_i);
WrapInFunction(expr);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -257,7 +259,7 @@
}
TEST_F(ResolverConstantsTest, Vec3_FullConstruct_u32) {
- auto* expr = vec3<u32>(1u, 2u, 3u);
+ auto* expr = vec3<u32>(1_u, 2_u, 3_u);
WrapInFunction(expr);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -314,7 +316,7 @@
}
TEST_F(ResolverConstantsTest, Vec3_MixConstruct_i32) {
- auto* expr = vec3<i32>(1, vec2<i32>(2, 3));
+ auto* expr = vec3<i32>(1_i, vec2<i32>(2_i, 3_i));
WrapInFunction(expr);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -333,7 +335,7 @@
}
TEST_F(ResolverConstantsTest, Vec3_MixConstruct_u32) {
- auto* expr = vec3<u32>(vec2<u32>(1u, 2u), 3u);
+ auto* expr = vec3<u32>(vec2<u32>(1_u, 2_u), 3_u);
WrapInFunction(expr);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -409,7 +411,7 @@
}
TEST_F(ResolverConstantsTest, Vec3_Cast_u32_to_f32) {
- auto* expr = vec3<f32>(vec3<u32>(10u, 20u, 30u));
+ auto* expr = vec3<f32>(vec3<u32>(10_u, 20_u, 30_u));
WrapInFunction(expr);
EXPECT_TRUE(r()->Resolve()) << r()->error();
diff --git a/src/tint/resolver/resolver_test.cc b/src/tint/resolver/resolver_test.cc
index 45b5694..f9055fd 100644
--- a/src/tint/resolver/resolver_test.cc
+++ b/src/tint/resolver/resolver_test.cc
@@ -47,6 +47,8 @@
using ::testing::ElementsAre;
using ::testing::HasSubstr;
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -81,9 +83,6 @@
using alias2 = builder::alias2<T>;
template <typename T>
using alias3 = builder::alias3<T>;
-using f32 = builder::f32;
-using i32 = builder::i32;
-using u32 = builder::u32;
using Op = ast::BinaryOp;
TEST_F(ResolverTest, Stmt_Assign) {
@@ -113,7 +112,7 @@
auto* assign = Assign(lhs, rhs);
auto* block = Block(assign);
ast::CaseSelectorList lit;
- lit.push_back(Expr(3));
+ lit.push_back(Expr(3_i));
auto* cse = create<ast::CaseStatement>(lit, block);
auto* cond_var = Var("c", ty.i32());
auto* sw = Switch(cond_var, cse, DefaultCase());
@@ -223,7 +222,7 @@
}
TEST_F(ResolverTest, Stmt_Return) {
- auto* cond = Expr(2);
+ auto* cond = Expr(2_i);
auto* ret = Return(cond);
Func("test", {}, ty.i32(), {ret}, {});
@@ -246,7 +245,7 @@
auto* lhs = Expr("v");
auto* rhs = Expr(2.3f);
auto* case_block = Block(Assign(lhs, rhs));
- auto* stmt = Switch(Expr(2), Case(Expr(3), case_block), DefaultCase());
+ auto* stmt = Switch(Expr(2_i), Case(Expr(3_i), case_block), DefaultCase());
WrapInFunction(v, stmt);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -279,7 +278,7 @@
}
TEST_F(ResolverTest, Stmt_VariableDecl) {
- auto* var = Var("my_var", ty.i32(), ast::StorageClass::kNone, Expr(2));
+ auto* var = Var("my_var", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
auto* init = var->constructor;
auto* decl = Decl(var);
@@ -293,7 +292,7 @@
TEST_F(ResolverTest, Stmt_VariableDecl_Alias) {
auto* my_int = Alias("MyInt", ty.i32());
- auto* var = Var("my_var", ty.Of(my_int), ast::StorageClass::kNone, Expr(2));
+ auto* var = Var("my_var", ty.Of(my_int), ast::StorageClass::kNone, Expr(2_i));
auto* init = var->constructor;
auto* decl = Decl(var);
@@ -306,7 +305,7 @@
}
TEST_F(ResolverTest, Stmt_VariableDecl_ModuleScope) {
- auto* init = Expr(2);
+ auto* init = Expr(2_i);
Global("my_var", ty.i32(), ast::StorageClass::kPrivate, init);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -329,7 +328,7 @@
ast::VariableList params;
// Declare i32 "foo" inside a block
- auto* foo_i32 = Var("foo", ty.i32(), ast::StorageClass::kNone, Expr(2));
+ auto* foo_i32 = Var("foo", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
auto* foo_i32_init = foo_i32->constructor;
auto* foo_i32_decl = Decl(foo_i32);
@@ -385,7 +384,7 @@
ast::VariableList params;
// Declare i32 "foo" inside a function
- auto* fn_i32 = Var("foo", ty.i32(), ast::StorageClass::kNone, Expr(2));
+ auto* fn_i32 = Var("foo", ty.i32(), ast::StorageClass::kNone, Expr(2_i));
auto* fn_i32_init = fn_i32->constructor;
auto* fn_i32_decl = Decl(fn_i32);
Func("func_i32", params, ty.void_(), {fn_i32_decl}, ast::AttributeList{});
@@ -419,7 +418,7 @@
TEST_F(ResolverTest, ArraySize_UnsignedLiteral) {
// var<private> a : array<f32, 10u>;
- auto* a = Global("a", ty.array(ty.f32(), Expr(10u)), ast::StorageClass::kPrivate);
+ auto* a = Global("a", ty.array(ty.f32(), Expr(10_u)), ast::StorageClass::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -431,8 +430,8 @@
}
TEST_F(ResolverTest, ArraySize_SignedLiteral) {
- // var<private> a : array<f32, 10>;
- auto* a = Global("a", ty.array(ty.f32(), Expr(10)), ast::StorageClass::kPrivate);
+ // var<private> a : array<f32, 10i>;
+ auto* a = Global("a", ty.array(ty.f32(), Expr(10_i)), ast::StorageClass::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -445,8 +444,8 @@
TEST_F(ResolverTest, ArraySize_UnsignedConstant) {
// let size = 0u;
- // var<private> a : array<f32, 10u>;
- GlobalConst("size", nullptr, Expr(10u));
+ // var<private> a : array<f32, size>;
+ GlobalConst("size", nullptr, Expr(10_u));
auto* a = Global("a", ty.array(ty.f32(), Expr("size")), ast::StorageClass::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -460,8 +459,8 @@
TEST_F(ResolverTest, ArraySize_SignedConstant) {
// let size = 0;
- // var<private> a : array<f32, 10>;
- GlobalConst("size", nullptr, Expr(10));
+ // var<private> a : array<f32, size>;
+ GlobalConst("size", nullptr, Expr(10_i));
auto* a = Global("a", ty.array(ty.f32(), Expr("size")), ast::StorageClass::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -650,7 +649,7 @@
}
TEST_F(ResolverTest, IndexAccessor_Dynamic_Ref_F32) {
- // var a : array<bool, 10> = 0;
+ // var a : array<bool, 10u> = 0;
// var idx : f32 = f32();
// var f : f32 = a[idx];
auto* a = Var("a", ty.array<bool, 10>(), array<bool, 10>());
@@ -926,7 +925,7 @@
// @stage(compute) @workgroup_size(8, 2, 3)
// fn main() {}
auto* func = Func("main", ast::VariableList{}, ty.void_(), {},
- {Stage(ast::PipelineStage::kCompute), WorkgroupSize(8, 2, 3)});
+ {Stage(ast::PipelineStage::kCompute), WorkgroupSize(8_i, 2_i, 3_i)});
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -942,14 +941,14 @@
}
TEST_F(ResolverTest, Function_WorkgroupSize_Consts) {
- // let width = 16;
- // let height = 8;
- // let depth = 2;
+ // let width = 16i;
+ // let height = 8i;
+ // let depth = 2i;
// @stage(compute) @workgroup_size(width, height, depth)
// fn main() {}
- GlobalConst("width", ty.i32(), Expr(16));
- GlobalConst("height", ty.i32(), Expr(8));
- GlobalConst("depth", ty.i32(), Expr(2));
+ GlobalConst("width", ty.i32(), Expr(16_i));
+ GlobalConst("height", ty.i32(), Expr(8_i));
+ GlobalConst("depth", ty.i32(), Expr(2_i));
auto* func =
Func("main", ast::VariableList{}, ty.void_(), {},
{Stage(ast::PipelineStage::kCompute), WorkgroupSize("width", "height", "depth")});
@@ -968,14 +967,14 @@
}
TEST_F(ResolverTest, Function_WorkgroupSize_Consts_NestedInitializer) {
- // let width = i32(i32(i32(8)));
- // let height = i32(i32(i32(4)));
+ // let width = i32(i32(i32(8i)));
+ // let height = i32(i32(i32(4i)));
// @stage(compute) @workgroup_size(width, height)
// fn main() {}
GlobalConst("width", ty.i32(),
- Construct(ty.i32(), Construct(ty.i32(), Construct(ty.i32(), 8))));
+ Construct(ty.i32(), Construct(ty.i32(), Construct(ty.i32(), 8_i))));
GlobalConst("height", ty.i32(),
- Construct(ty.i32(), Construct(ty.i32(), Construct(ty.i32(), 4))));
+ Construct(ty.i32(), Construct(ty.i32(), Construct(ty.i32(), 4_i))));
auto* func = Func("main", ast::VariableList{}, ty.void_(), {},
{Stage(ast::PipelineStage::kCompute), WorkgroupSize("width", "height")});
@@ -993,14 +992,14 @@
}
TEST_F(ResolverTest, Function_WorkgroupSize_OverridableConsts) {
- // @id(0) override width = 16;
- // @id(1) override height = 8;
- // @id(2) override depth = 2;
+ // @id(0) override width = 16i;
+ // @id(1) override height = 8i;
+ // @id(2) override depth = 2i;
// @stage(compute) @workgroup_size(width, height, depth)
// fn main() {}
- auto* width = Override("width", ty.i32(), Expr(16), {Id(0)});
- auto* height = Override("height", ty.i32(), Expr(8), {Id(1)});
- auto* depth = Override("depth", ty.i32(), Expr(2), {Id(2)});
+ auto* width = Override("width", ty.i32(), Expr(16_i), {Id(0)});
+ auto* height = Override("height", ty.i32(), Expr(8_i), {Id(1)});
+ auto* depth = Override("depth", ty.i32(), Expr(2_i), {Id(2)});
auto* func =
Func("main", ast::VariableList{}, ty.void_(), {},
{Stage(ast::PipelineStage::kCompute), WorkgroupSize("width", "height", "depth")});
@@ -1045,14 +1044,14 @@
}
TEST_F(ResolverTest, Function_WorkgroupSize_Mixed) {
- // @id(1) override height = 2;
- // let depth = 3;
+ // @id(1) override height = 2i;
+ // let depth = 3i;
// @stage(compute) @workgroup_size(8, height, depth)
// fn main() {}
- auto* height = Override("height", ty.i32(), Expr(2), {Id(0)});
- GlobalConst("depth", ty.i32(), Expr(3));
+ auto* height = Override("height", ty.i32(), Expr(2_i), {Id(0)});
+ GlobalConst("depth", ty.i32(), Expr(3_i));
auto* func = Func("main", ast::VariableList{}, ty.void_(), {},
- {Stage(ast::PipelineStage::kCompute), WorkgroupSize(8, "height", "depth")});
+ {Stage(ast::PipelineStage::kCompute), WorkgroupSize(8_i, "height", "depth")});
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1149,7 +1148,7 @@
// vec4<f32> foo
// }
// struct A {
- // array<b, 3> mem
+ // array<b, 3u> mem
// }
// var c : A
// c.mem[0].foo.yx
@@ -1161,11 +1160,11 @@
//
auto* stB = Structure("B", {Member("foo", ty.vec4<f32>())});
- auto* stA = Structure("A", {Member("mem", ty.array(ty.Of(stB), 3))});
+ auto* stA = Structure("A", {Member("mem", ty.array(ty.Of(stB), 3_i))});
Global("c", ty.Of(stA), ast::StorageClass::kPrivate);
auto* mem =
- MemberAccessor(MemberAccessor(IndexAccessor(MemberAccessor("c", "mem"), 0), "foo"), "yx");
+ MemberAccessor(MemberAccessor(IndexAccessor(MemberAccessor("c", "mem"), 0_i), "foo"), "yx");
WrapInFunction(mem);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1820,13 +1819,13 @@
Assign("call_a", Call("a")),
Assign("call_b", Call("b")),
},
- ast::AttributeList{Stage(ast::PipelineStage::kCompute), WorkgroupSize(1)});
+ ast::AttributeList{Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
auto* ep_2 = Func("ep_2", params, ty.void_(),
{
Assign("call_c", Call("c")),
},
- ast::AttributeList{Stage(ast::PipelineStage::kCompute), WorkgroupSize(1)});
+ ast::AttributeList{Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -1903,7 +1902,7 @@
CallStmt(Call(fn_a(0))),
CallStmt(Call(fn_b(0))),
},
- {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1)});
+ {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
ASSERT_TRUE(r()->Resolve()) << r()->error();
}
@@ -1930,7 +1929,7 @@
EXPECT_FATAL_FAILURE(
{
ProgramBuilder b;
- auto* expr = b.Expr(1);
+ auto* expr = b.Expr(1_i);
b.Global("a", b.ty.i32(), ast::StorageClass::kPrivate, expr);
b.Global("b", b.ty.i32(), ast::StorageClass::kPrivate, expr);
Resolver(&b).Resolve();
diff --git a/src/tint/resolver/resolver_test_helper.h b/src/tint/resolver/resolver_test_helper.h
index e6dcf96..d54e57c 100644
--- a/src/tint/resolver/resolver_test_helper.h
+++ b/src/tint/resolver/resolver_test_helper.h
@@ -119,10 +119,6 @@
namespace builder {
-using i32 = ProgramBuilder::i32;
-using u32 = ProgramBuilder::u32;
-using f32 = ProgramBuilder::f32;
-
template <uint32_t N, typename T>
struct vec {};
@@ -409,7 +405,7 @@
/// @param b the ProgramBuilder
/// @return a new AST array type
static inline const ast::Type* AST(ProgramBuilder& b) {
- return b.ty.array(DataType<T>::AST(b), N);
+ return b.ty.array(DataType<T>::AST(b), u32(N));
}
/// @param b the ProgramBuilder
/// @return the semantic array type
diff --git a/src/tint/resolver/side_effects_test.cc b/src/tint/resolver/side_effects_test.cc
index 4057e6a..a50d904 100644
--- a/src/tint/resolver/side_effects_test.cc
+++ b/src/tint/resolver/side_effects_test.cc
@@ -19,6 +19,8 @@
#include "src/tint/sem/expression.h"
#include "src/tint/sem/member_accessor_expression.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -52,7 +54,7 @@
TEST_F(SideEffectsTest, Phony) {
auto* expr = Phony();
- auto* body = Assign(expr, 1);
+ auto* body = Assign(expr, 1_i);
WrapInFunction(body);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -62,7 +64,7 @@
}
TEST_F(SideEffectsTest, Literal) {
- auto* expr = Expr(1);
+ auto* expr = Expr(1_i);
WrapInFunction(expr);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -111,7 +113,7 @@
TEST_F(SideEffectsTest, Call_Builtin_SE) {
Global("a", ty.atomic(ty.i32()), ast::StorageClass::kWorkgroup);
- auto* expr = Call("atomicAdd", AddressOf("a"), 1);
+ auto* expr = Call("atomicAdd", AddressOf("a"), 1_i);
WrapInFunction(expr);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -122,7 +124,7 @@
}
TEST_F(SideEffectsTest, Call_Function) {
- Func("f", {}, ty.i32(), {Return(1)});
+ Func("f", {}, ty.i32(), {Return(1_i)});
auto* expr = Call("f");
WrapInFunction(expr);
@@ -313,7 +315,7 @@
TEST_F(SideEffectsTest, IndexAccessor_NoSE) {
auto* var = Decl(Var("a", ty.array<i32, 10>()));
- auto* expr = IndexAccessor("a", 0);
+ auto* expr = IndexAccessor("a", 0_i);
WrapInFunction(var, expr);
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -324,7 +326,7 @@
TEST_F(SideEffectsTest, IndexAccessor_ObjSE) {
MakeSideEffectFunc("se", [&] { return ty.array<i32, 10>(); });
- auto* expr = IndexAccessor(Call("se"), 0);
+ auto* expr = IndexAccessor(Call("se"), 0_i);
WrapInFunction(expr);
EXPECT_TRUE(r()->Resolve()) << r()->error();
diff --git a/src/tint/resolver/source_variable_test.cc b/src/tint/resolver/source_variable_test.cc
index 6d10f84..f9fe2fb 100644
--- a/src/tint/resolver/source_variable_test.cc
+++ b/src/tint/resolver/source_variable_test.cc
@@ -17,6 +17,8 @@
#include "src/tint/resolver/resolver_test_helper.h"
#include "src/tint/sem/member_accessor_expression.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -190,12 +192,12 @@
}
TEST_F(ResolverSourceVariableTest, ThroughIndexAccessor) {
- // var<private> a : array<f32, 4>;
+ // var<private> a : array<f32, 4u>;
// {
- // a[2]
+ // a[2i]
// }
- auto* a = Global("a", ty.array(ty.f32(), 4), ast::StorageClass::kPrivate);
- auto* expr = IndexAccessor(a, 2);
+ auto* a = Global("a", ty.array(ty.f32(), 4_u), ast::StorageClass::kPrivate);
+ auto* expr = IndexAccessor(a, 2_i);
WrapInFunction(expr);
EXPECT_TRUE(r()->Resolve()) << r()->error();
diff --git a/src/tint/resolver/storage_class_layout_validation_test.cc b/src/tint/resolver/storage_class_layout_validation_test.cc
index e5f8a40..db379a0 100644
--- a/src/tint/resolver/storage_class_layout_validation_test.cc
+++ b/src/tint/resolver/storage_class_layout_validation_test.cc
@@ -17,6 +17,8 @@
#include "gmock/gmock.h"
#include "src/tint/resolver/resolver_test_helper.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -140,7 +142,7 @@
// Detect unaligned array member for uniform buffers
TEST_F(ResolverStorageClassLayoutValidationTest, UniformBuffer_UnalignedMember_Array) {
- // type Inner = @stride(16) array<f32, 10>;
+ // type Inner = @stride(16) array<f32, 10u>;
//
// struct Outer {
// scalar : f32;
@@ -149,7 +151,7 @@
//
// @group(0) @binding(0)
// var<uniform> a : Outer;
- Alias("Inner", ty.array(ty.f32(), 10, 16));
+ Alias("Inner", ty.array(ty.f32(), 10_u, 16));
Structure(Source{{12, 34}}, "Outer",
{
@@ -173,7 +175,7 @@
}
TEST_F(ResolverStorageClassLayoutValidationTest, UniformBuffer_UnalignedMember_Array_SuggestedFix) {
- // type Inner = @stride(16) array<f32, 10>;
+ // type Inner = @stride(16) array<f32, 10u>;
//
// struct Outer {
// scalar : f32;
@@ -182,7 +184,7 @@
//
// @group(0) @binding(0)
// var<uniform> a : Outer;
- Alias("Inner", ty.array(ty.f32(), 10, 16));
+ Alias("Inner", ty.array(ty.f32(), 10_u, 16));
Structure(Source{{12, 34}}, "Outer",
{
@@ -347,7 +349,7 @@
// Detect array stride must be a multiple of 16 bytes for uniform buffers
TEST_F(ResolverStorageClassLayoutValidationTest, UniformBuffer_InvalidArrayStride_Scalar) {
- // type Inner = array<f32, 10>;
+ // type Inner = array<f32, 10u>;
//
// struct Outer {
// inner : Inner;
@@ -357,7 +359,7 @@
// @group(0) @binding(0)
// var<uniform> a : Outer;
- Alias("Inner", ty.array(ty.f32(), 10));
+ Alias("Inner", ty.array(ty.f32(), 10_u));
Structure(Source{{12, 34}}, "Outer",
{
@@ -381,7 +383,7 @@
}
TEST_F(ResolverStorageClassLayoutValidationTest, UniformBuffer_InvalidArrayStride_Vector) {
- // type Inner = array<vec2<f32>, 10>;
+ // type Inner = array<vec2<f32>, 10u>;
//
// struct Outer {
// inner : Inner;
@@ -391,7 +393,7 @@
// @group(0) @binding(0)
// var<uniform> a : Outer;
- Alias("Inner", ty.array(ty.vec2<f32>(), 10));
+ Alias("Inner", ty.array(ty.vec2<f32>(), 10_u));
Structure(Source{{12, 34}}, "Outer",
{
@@ -420,7 +422,7 @@
// a : f32;
// b : i32;
// }
- // type Inner = array<ArrayElem, 10>;
+ // type Inner = array<ArrayElem, 10u>;
//
// struct Outer {
// inner : Inner;
@@ -434,7 +436,7 @@
Member("a", ty.f32()),
Member("b", ty.i32()),
});
- Alias("Inner", ty.array(ty.Of(array_elem), 10));
+ Alias("Inner", ty.array(ty.Of(array_elem), 10_u));
Structure(Source{{12, 34}}, "Outer",
{
@@ -459,8 +461,8 @@
TEST_F(ResolverStorageClassLayoutValidationTest, UniformBuffer_InvalidArrayStride_TopLevelArray) {
// @group(0) @binding(0)
- // var<uniform> a : array<f32, 4>;
- Global(Source{{78, 90}}, "a", ty.array(Source{{34, 56}}, ty.f32(), 4),
+ // var<uniform> a : array<f32, 4u>;
+ Global(Source{{78, 90}}, "a", ty.array(Source{{34, 56}}, ty.f32(), 4_u),
ast::StorageClass::kUniform, GroupAndBinding(0, 0));
ASSERT_FALSE(r()->Resolve());
@@ -471,15 +473,15 @@
TEST_F(ResolverStorageClassLayoutValidationTest, UniformBuffer_InvalidArrayStride_NestedArray) {
// struct Outer {
- // inner : array<array<f32, 4>, 4>
+ // inner : array<array<f32, 4u>, 4u>
// };
//
// @group(0) @binding(0)
- // var<uniform> a : array<Outer, 4>;
+ // var<uniform> a : array<Outer, 4u>;
Structure(Source{{12, 34}}, "Outer",
{
- Member("inner", ty.array(Source{{34, 56}}, ty.array(ty.f32(), 4), 4)),
+ Member("inner", ty.array(Source{{34, 56}}, ty.array(ty.f32(), 4_u), 4_u)),
});
Global(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::StorageClass::kUniform,
@@ -497,7 +499,7 @@
}
TEST_F(ResolverStorageClassLayoutValidationTest, UniformBuffer_InvalidArrayStride_SuggestedFix) {
- // type Inner = @stride(16) array<f32, 10>;
+ // type Inner = @stride(16) array<f32, 10u>;
//
// struct Outer {
// inner : Inner;
@@ -507,7 +509,7 @@
// @group(0) @binding(0)
// var<uniform> a : Outer;
- Alias("Inner", ty.array(ty.f32(), 10, 16));
+ Alias("Inner", ty.array(ty.f32(), 10_u, 16));
Structure(Source{{12, 34}}, "Outer",
{
diff --git a/src/tint/resolver/storage_class_validation_test.cc b/src/tint/resolver/storage_class_validation_test.cc
index ed4e6b8..2d75167 100644
--- a/src/tint/resolver/storage_class_validation_test.cc
+++ b/src/tint/resolver/storage_class_validation_test.cc
@@ -18,6 +18,8 @@
#include "src/tint/resolver/resolver_test_helper.h"
#include "src/tint/sem/struct.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -137,9 +139,9 @@
}
TEST_F(ResolverStorageClassValidationTest, StorageBufferArray) {
- // var<storage, read> g : array<S, 3>;
+ // var<storage, read> g : array<S, 3u>;
auto* s = Structure("S", {Member("a", ty.f32())});
- auto* a = ty.array(ty.Of(s), 3);
+ auto* a = ty.array(ty.Of(s), 3_u);
Global(Source{{56, 78}}, "g", a, ast::StorageClass::kStorage, ast::Access::kRead,
ast::AttributeList{
create<ast::BindingAttribute>(0),
@@ -285,9 +287,9 @@
// struct S {
// @size(16) f : f32;
// }
- // var<uniform> g : array<S, 3>;
+ // var<uniform> g : array<S, 3u>;
auto* s = Structure("S", {Member("a", ty.f32(), {MemberSize(16)})});
- auto* a = ty.array(ty.Of(s), 3);
+ auto* a = ty.array(ty.Of(s), 3_u);
Global(Source{{56, 78}}, "g", a, ast::StorageClass::kUniform,
ast::AttributeList{
create<ast::BindingAttribute>(0),
diff --git a/src/tint/resolver/struct_layout_test.cc b/src/tint/resolver/struct_layout_test.cc
index 04b1389..854e87a 100644
--- a/src/tint/resolver/struct_layout_test.cc
+++ b/src/tint/resolver/struct_layout_test.cc
@@ -18,6 +18,8 @@
#include "src/tint/resolver/resolver_test_helper.h"
#include "src/tint/sem/struct.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -164,7 +166,7 @@
TEST_F(ResolverStructLayoutTest, ImplicitStrideArrayOfExplicitStrideArray) {
auto* inner = ty.array<i32, 2>(/*stride*/ 16); // size: 32
- auto* outer = ty.array(inner, 12); // size: 12 * 32
+ auto* outer = ty.array(inner, 12_u); // size: 12 * 32
auto* s = Structure("S", {
Member("c", outer),
});
@@ -187,8 +189,8 @@
Member("a", ty.vec2<i32>()),
Member("b", ty.vec3<i32>()),
Member("c", ty.vec4<i32>()),
- }); // size: 48
- auto* outer = ty.array(ty.Of(inner), 12); // size: 12 * 48
+ }); // size: 48
+ auto* outer = ty.array(ty.Of(inner), 12_u); // size: 12 * 48
auto* s = Structure("S", {
Member("c", outer),
});
diff --git a/src/tint/resolver/struct_pipeline_stage_use_test.cc b/src/tint/resolver/struct_pipeline_stage_use_test.cc
index 2857ec8..6b9ede9 100644
--- a/src/tint/resolver/struct_pipeline_stage_use_test.cc
+++ b/src/tint/resolver/struct_pipeline_stage_use_test.cc
@@ -21,6 +21,8 @@
using ::testing::UnorderedElementsAre;
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -120,7 +122,7 @@
Structure("S", {Member("a", ty.u32(), {Builtin(ast::Builtin::kLocalInvocationIndex)})});
Func("main", {Param("param", ty.Of(s))}, ty.void_(), {},
- {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1)});
+ {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
ASSERT_TRUE(r()->Resolve()) << r()->error();
diff --git a/src/tint/resolver/struct_storage_class_use_test.cc b/src/tint/resolver/struct_storage_class_use_test.cc
index 8971bae..72ed546 100644
--- a/src/tint/resolver/struct_storage_class_use_test.cc
+++ b/src/tint/resolver/struct_storage_class_use_test.cc
@@ -20,6 +20,8 @@
using ::testing::UnorderedElementsAre;
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -97,7 +99,7 @@
TEST_F(ResolverStorageClassUseTest, StructReachableViaGlobalArray) {
auto* s = Structure("S", {Member("a", ty.f32())});
- auto* a = ty.array(ty.Of(s), 3);
+ auto* a = ty.array(ty.Of(s), 3_u);
Global("g", a, ast::StorageClass::kPrivate);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -145,7 +147,7 @@
TEST_F(ResolverStorageClassUseTest, StructReachableViaLocalArray) {
auto* s = Structure("S", {Member("a", ty.f32())});
- auto* a = ty.array(ty.Of(s), 3);
+ auto* a = ty.array(ty.Of(s), 3_u);
WrapInFunction(Var("g", a));
ASSERT_TRUE(r()->Resolve()) << r()->error();
diff --git a/src/tint/resolver/type_constructor_validation_test.cc b/src/tint/resolver/type_constructor_validation_test.cc
index d886b2e..edfce46 100644
--- a/src/tint/resolver/type_constructor_validation_test.cc
+++ b/src/tint/resolver/type_constructor_validation_test.cc
@@ -18,6 +18,8 @@
#include "src/tint/sem/type_constructor.h"
#include "src/tint/sem/type_conversion.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -31,14 +33,11 @@
using builder::CreatePtrs;
using builder::CreatePtrsFor;
using builder::DataType;
-using builder::f32;
-using builder::i32;
using builder::mat2x2;
using builder::mat2x3;
using builder::mat3x2;
using builder::mat3x3;
using builder::mat4x4;
-using builder::u32;
using builder::vec2;
using builder::vec3;
using builder::vec4;
@@ -60,7 +59,7 @@
TEST_F(ResolverTypeConstructorValidationTest, InferTypeTest_Simple) {
// var a = 1;
// var b = a;
- auto* a = Var("a", nullptr, ast::StorageClass::kNone, Expr(1));
+ auto* a = Var("a", nullptr, ast::StorageClass::kNone, Expr(1_i));
auto* b = Var("b", nullptr, ast::StorageClass::kNone, Expr("a"));
auto* a_ident = Expr("a");
auto* b_ident = Expr("b");
@@ -428,7 +427,7 @@
namespace ArrayConstructor {
TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Array_ZeroValue_Pass) {
- // array<u32, 10>();
+ // array<u32, 10u>();
auto* tc = array<u32, 10>();
WrapInFunction(tc);
@@ -444,8 +443,8 @@
}
TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Array_type_match) {
- // array<u32, 3>(0u, 10u. 20u);
- auto* tc = array<u32, 3>(Expr(0u), Expr(10u), Expr(20u));
+ // array<u32, 3u>(0u, 10u. 20u);
+ auto* tc = array<u32, 3>(Expr(0_u), Expr(10_u), Expr(20_u));
WrapInFunction(tc);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -463,8 +462,8 @@
}
TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Array_type_Mismatch_U32F32) {
- // array<u32, 3>(0u, 1.0f, 20u);
- auto* tc = array<u32, 3>(Expr(0u), Expr(Source{{12, 34}}, 1.0f), Expr(20u));
+ // array<u32, 3u>(0u, 1.0f, 20u);
+ auto* tc = array<u32, 3>(Expr(0_u), Expr(Source{{12, 34}}, 1.0f), Expr(20_u));
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -475,8 +474,8 @@
TEST_F(ResolverTypeConstructorValidationTest,
Expr_Constructor_Array_ScalarArgumentTypeMismatch_F32I32) {
- // array<f32, 1>(1);
- auto* tc = array<f32, 1>(Expr(Source{{12, 34}}, 1));
+ // array<f32, 1u>(1i);
+ auto* tc = array<f32, 1>(Expr(Source{{12, 34}}, 1_i));
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -487,8 +486,9 @@
TEST_F(ResolverTypeConstructorValidationTest,
Expr_Constructor_Array_ScalarArgumentTypeMismatch_U32I32) {
- // array<u32, 6>(1, 0u, 0u, 0u, 0u, 0u);
- auto* tc = array<u32, 1>(Expr(Source{{12, 34}}, 1), Expr(0u), Expr(0u), Expr(0u), Expr(0u));
+ // array<u32, 1u>(1i, 0u, 0u, 0u, 0u, 0u);
+ auto* tc =
+ array<u32, 1>(Expr(Source{{12, 34}}, 1_i), Expr(0_u), Expr(0_u), Expr(0_u), Expr(0_u));
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -499,8 +499,8 @@
TEST_F(ResolverTypeConstructorValidationTest,
Expr_Constructor_Array_ScalarArgumentTypeMismatch_Vec2) {
- // array<i32, 3>(1, vec2<i32>());
- auto* tc = array<i32, 3>(Expr(1), Construct(Source{{12, 34}}, ty.vec2<i32>()));
+ // array<i32, 3u>(1i, vec2<i32>());
+ auto* tc = array<i32, 3>(Expr(1_i), Construct(Source{{12, 34}}, ty.vec2<i32>()));
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -510,11 +510,11 @@
TEST_F(ResolverTypeConstructorValidationTest,
Expr_Constructor_ArrayOfVector_SubElemTypeMismatch_I32U32) {
- // array<vec3<i32>, 2>(vec3<i32>(), vec3<u32>());
+ // array<vec3<i32>, 2u>(vec3<i32>(), vec3<u32>());
auto* e0 = vec3<i32>();
SetSource(Source::Location({12, 34}));
auto* e1 = vec3<u32>();
- auto* t = Construct(ty.array(ty.vec3<i32>(), 2), e0, e1);
+ auto* t = Construct(ty.array(ty.vec3<i32>(), 2_i), e0, e1);
WrapInFunction(t);
EXPECT_FALSE(r()->Resolve());
@@ -525,11 +525,11 @@
TEST_F(ResolverTypeConstructorValidationTest,
Expr_Constructor_ArrayOfVector_SubElemTypeMismatch_I32Bool) {
- // array<vec3<i32>, 2>(vec3<i32>(), vec3<bool>(true, true, false));
+ // array<vec3<i32>, 2u>(vec3<i32>(), vec3<bool>(true, true, false));
SetSource(Source::Location({12, 34}));
auto* e0 = vec3<bool>(true, true, false);
auto* e1 = vec3<i32>();
- auto* t = Construct(ty.array(ty.vec3<i32>(), 2), e0, e1);
+ auto* t = Construct(ty.array(ty.vec3<i32>(), 2_i), e0, e1);
WrapInFunction(t);
EXPECT_FALSE(r()->Resolve());
@@ -539,11 +539,11 @@
}
TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_ArrayOfArray_SubElemSizeMismatch) {
- // array<array<i32, 2>, 2>(array<i32, 3>(), array<i32, 2>());
+ // array<array<i32, 2u>, 2u>(array<i32, 3u>(), array<i32, 2u>());
SetSource(Source::Location({12, 34}));
auto* e0 = array<i32, 3>();
auto* e1 = array<i32, 2>();
- auto* t = Construct(ty.array(ty.array<i32, 2>(), 2), e0, e1);
+ auto* t = Construct(ty.array(ty.array<i32, 2>(), 2_i), e0, e1);
WrapInFunction(t);
EXPECT_FALSE(r()->Resolve());
@@ -553,11 +553,11 @@
}
TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_ArrayOfArray_SubElemTypeMismatch) {
- // array<array<i32, 2>, 2>(array<i32, 2>(), array<u32, 2>());
+ // array<array<i32, 2u>, 2u>(array<i32, 2u>(), array<u32, 2u>());
auto* e0 = array<i32, 2>();
SetSource(Source::Location({12, 34}));
auto* e1 = array<u32, 2>();
- auto* t = Construct(ty.array(ty.array<i32, 2>(), 2), e0, e1);
+ auto* t = Construct(ty.array(ty.array<i32, 2>(), 2_i), e0, e1);
WrapInFunction(t);
EXPECT_FALSE(r()->Resolve());
@@ -567,9 +567,9 @@
}
TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Array_TooFewElements) {
- // array<i32, 4>(1, 2, 3);
+ // array<i32, 4u>(1i, 2i, 3i);
SetSource(Source::Location({12, 34}));
- auto* tc = array<i32, 4>(Expr(1), Expr(2), Expr(3));
+ auto* tc = array<i32, 4>(Expr(1_i), Expr(2_i), Expr(3_i));
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -579,9 +579,9 @@
}
TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Array_TooManyElements) {
- // array<i32, 4>(1, 2, 3, 4, 5);
+ // array<i32, 4u>(1i, 2i, 3i, 4i, 5i);
SetSource(Source::Location({12, 34}));
- auto* tc = array<i32, 4>(Expr(1), Expr(2), Expr(3), Expr(4), Expr(5));
+ auto* tc = array<i32, 4>(Expr(1_i), Expr(2_i), Expr(3_i), Expr(4_i), Expr(5_i));
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -592,8 +592,8 @@
}
TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Array_Runtime) {
- // array<i32>(1);
- auto* tc = array(ty.i32(), nullptr, Expr(Source{{12, 34}}, 1));
+ // array<i32>(1i);
+ auto* tc = array(ty.i32(), nullptr, Expr(Source{{12, 34}}, 1_i));
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -614,7 +614,7 @@
namespace ScalarConstructor {
TEST_F(ResolverTypeConstructorValidationTest, Expr_Construct_i32_Success) {
- auto* expr = Construct<i32>(Expr(123));
+ auto* expr = Construct<i32>(Expr(123_i));
WrapInFunction(expr);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -632,7 +632,7 @@
}
TEST_F(ResolverTypeConstructorValidationTest, Expr_Construct_u32_Success) {
- auto* expr = Construct<u32>(Expr(123u));
+ auto* expr = Construct<u32>(Expr(123_u));
WrapInFunction(expr);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -686,7 +686,7 @@
}
TEST_F(ResolverTypeConstructorValidationTest, Expr_Convert_i32_to_u32_Success) {
- auto* expr = Construct<u32>(123);
+ auto* expr = Construct<u32>(123_i);
WrapInFunction(expr);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -704,7 +704,7 @@
}
TEST_F(ResolverTypeConstructorValidationTest, Expr_Convert_u32_to_f32_Success) {
- auto* expr = Construct<f32>(123u);
+ auto* expr = Construct<f32>(123_u);
WrapInFunction(expr);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -727,7 +727,7 @@
TEST_F(ResolverTypeConstructorValidationTest,
Expr_Constructor_Vec2F32_Error_ScalarArgumentTypeMismatch) {
- auto* tc = vec2<f32>(Expr(Source{{12, 34}}, 1), 1.0f);
+ auto* tc = vec2<f32>(Expr(Source{{12, 34}}, 1_i), 1.0f);
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -738,7 +738,7 @@
TEST_F(ResolverTypeConstructorValidationTest,
Expr_Constructor_Vec2U32_Error_ScalarArgumentTypeMismatch) {
- auto* tc = vec2<u32>(1u, Expr(Source{{12, 34}}, 1));
+ auto* tc = vec2<u32>(1_u, Expr(Source{{12, 34}}, 1_i));
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -749,7 +749,7 @@
TEST_F(ResolverTypeConstructorValidationTest,
Expr_Constructor_Vec2I32_Error_ScalarArgumentTypeMismatch) {
- auto* tc = vec2<i32>(Expr(Source{{12, 34}}, 1u), 1);
+ auto* tc = vec2<i32>(Expr(Source{{12, 34}}, 1_u), 1_i);
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -760,7 +760,7 @@
TEST_F(ResolverTypeConstructorValidationTest,
Expr_Constructor_Vec2Bool_Error_ScalarArgumentTypeMismatch) {
- auto* tc = vec2<bool>(true, Expr(Source{{12, 34}}, 1));
+ auto* tc = vec2<bool>(true, Expr(Source{{12, 34}}, 1_i));
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -865,7 +865,7 @@
}
TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec2U32_Success_Scalar) {
- auto* tc = vec2<u32>(1u, 1u);
+ auto* tc = vec2<u32>(1_u, 1_u);
WrapInFunction(tc);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -886,7 +886,7 @@
}
TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec2I32_Success_Scalar) {
- auto* tc = vec2<i32>(1, 1);
+ auto* tc = vec2<i32>(1_i, 1_i);
WrapInFunction(tc);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -969,7 +969,7 @@
TEST_F(ResolverTypeConstructorValidationTest,
Expr_Constructor_Vec3F32_Error_ScalarArgumentTypeMismatch) {
- auto* tc = vec3<f32>(1.0f, 1.0f, Expr(Source{{12, 34}}, 1));
+ auto* tc = vec3<f32>(1.0f, 1.0f, Expr(Source{{12, 34}}, 1_i));
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -980,7 +980,7 @@
TEST_F(ResolverTypeConstructorValidationTest,
Expr_Constructor_Vec3U32_Error_ScalarArgumentTypeMismatch) {
- auto* tc = vec3<u32>(1u, Expr(Source{{12, 34}}, 1), 1u);
+ auto* tc = vec3<u32>(1_u, Expr(Source{{12, 34}}, 1_i), 1_u);
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -991,7 +991,7 @@
TEST_F(ResolverTypeConstructorValidationTest,
Expr_Constructor_Vec3I32_Error_ScalarArgumentTypeMismatch) {
- auto* tc = vec3<i32>(1, Expr(Source{{12, 34}}, 1u), 1);
+ auto* tc = vec3<i32>(1_i, Expr(Source{{12, 34}}, 1_u), 1_i);
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -1002,7 +1002,7 @@
TEST_F(ResolverTypeConstructorValidationTest,
Expr_Constructor_Vec3Bool_Error_ScalarArgumentTypeMismatch) {
- auto* tc = vec3<bool>(true, Expr(Source{{12, 34}}, 1), false);
+ auto* tc = vec3<bool>(true, Expr(Source{{12, 34}}, 1_i), false);
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -1124,7 +1124,7 @@
}
TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec3U32_Success_Scalar) {
- auto* tc = vec3<u32>(1u, 1u, 1u);
+ auto* tc = vec3<u32>(1_u, 1_u, 1_u);
WrapInFunction(tc);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -1146,7 +1146,7 @@
}
TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec3I32_Success_Scalar) {
- auto* tc = vec3<i32>(1, 1, 1);
+ auto* tc = vec3<i32>(1_i, 1_i, 1_i);
WrapInFunction(tc);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -1273,7 +1273,7 @@
TEST_F(ResolverTypeConstructorValidationTest,
Expr_Constructor_Vec4F32_Error_ScalarArgumentTypeMismatch) {
- auto* tc = vec4<f32>(1.0f, 1.0f, Expr(Source{{12, 34}}, 1), 1.0f);
+ auto* tc = vec4<f32>(1.0f, 1.0f, Expr(Source{{12, 34}}, 1_i), 1.0f);
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -1284,7 +1284,7 @@
TEST_F(ResolverTypeConstructorValidationTest,
Expr_Constructor_Vec4U32_Error_ScalarArgumentTypeMismatch) {
- auto* tc = vec4<u32>(1u, 1u, Expr(Source{{12, 34}}, 1), 1u);
+ auto* tc = vec4<u32>(1_u, 1_u, Expr(Source{{12, 34}}, 1_i), 1_u);
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -1295,7 +1295,7 @@
TEST_F(ResolverTypeConstructorValidationTest,
Expr_Constructor_Vec4I32_Error_ScalarArgumentTypeMismatch) {
- auto* tc = vec4<i32>(1, 1, Expr(Source{{12, 34}}, 1u), 1);
+ auto* tc = vec4<i32>(1_i, 1_i, Expr(Source{{12, 34}}, 1_u), 1_i);
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -1306,7 +1306,7 @@
TEST_F(ResolverTypeConstructorValidationTest,
Expr_Constructor_Vec4Bool_Error_ScalarArgumentTypeMismatch) {
- auto* tc = vec4<bool>(true, false, Expr(Source{{12, 34}}, 1), true);
+ auto* tc = vec4<bool>(true, false, Expr(Source{{12, 34}}, 1_i), true);
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -1457,7 +1457,7 @@
}
TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4U32_Success_Scalar) {
- auto* tc = vec4<u32>(1u, 1u, 1u, 1u);
+ auto* tc = vec4<u32>(1_u, 1_u, 1_u, 1_u);
WrapInFunction(tc);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -1469,7 +1469,7 @@
}
TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4I32_Success_Scalar) {
- auto* tc = vec4<i32>(1, 1, 1, 1);
+ auto* tc = vec4<i32>(1_i, 1_i, 1_i, 1_i);
WrapInFunction(tc);
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -1641,7 +1641,7 @@
// vec2<Float32>(1.0f, 1u)
auto* vec_type = ty.vec(ty.Of(f32_alias), 2);
- auto* tc = Construct(Source{{12, 34}}, vec_type, 1.0f, Expr(Source{{12, 40}}, 1u));
+ auto* tc = Construct(Source{{12, 34}}, vec_type, 1.0f, Expr(Source{{12, 40}}, 1_u));
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
@@ -1690,8 +1690,8 @@
TEST_F(ResolverTypeConstructorValidationTest, InferVec2ElementTypeFromScalars) {
auto* vec2_bool = Construct(create<ast::Vector>(nullptr, 2), Expr(true), Expr(false));
- auto* vec2_i32 = Construct(create<ast::Vector>(nullptr, 2), Expr(1), Expr(2));
- auto* vec2_u32 = Construct(create<ast::Vector>(nullptr, 2), Expr(1u), Expr(2u));
+ auto* vec2_i32 = Construct(create<ast::Vector>(nullptr, 2), Expr(1_i), Expr(2_i));
+ auto* vec2_u32 = Construct(create<ast::Vector>(nullptr, 2), Expr(1_u), Expr(2_u));
auto* vec2_f32 = Construct(create<ast::Vector>(nullptr, 2), Expr(1.0f), Expr(2.0f));
WrapInFunction(vec2_bool, vec2_i32, vec2_u32, vec2_f32);
@@ -1717,8 +1717,8 @@
TEST_F(ResolverTypeConstructorValidationTest, InferVec2ElementTypeFromVec2) {
auto* vec2_bool = Construct(create<ast::Vector>(nullptr, 2), vec2<bool>(true, false));
- auto* vec2_i32 = Construct(create<ast::Vector>(nullptr, 2), vec2<i32>(1, 2));
- auto* vec2_u32 = Construct(create<ast::Vector>(nullptr, 2), vec2<u32>(1u, 2u));
+ auto* vec2_i32 = Construct(create<ast::Vector>(nullptr, 2), vec2<i32>(1_i, 2_i));
+ auto* vec2_u32 = Construct(create<ast::Vector>(nullptr, 2), vec2<u32>(1_u, 2_u));
auto* vec2_f32 = Construct(create<ast::Vector>(nullptr, 2), vec2<f32>(1.0f, 2.0f));
WrapInFunction(vec2_bool, vec2_i32, vec2_u32, vec2_f32);
@@ -1745,8 +1745,8 @@
TEST_F(ResolverTypeConstructorValidationTest, InferVec3ElementTypeFromScalars) {
auto* vec3_bool =
Construct(create<ast::Vector>(nullptr, 3), Expr(true), Expr(false), Expr(true));
- auto* vec3_i32 = Construct(create<ast::Vector>(nullptr, 3), Expr(1), Expr(2), Expr(3));
- auto* vec3_u32 = Construct(create<ast::Vector>(nullptr, 3), Expr(1u), Expr(2u), Expr(3u));
+ auto* vec3_i32 = Construct(create<ast::Vector>(nullptr, 3), Expr(1_i), Expr(2_i), Expr(3_i));
+ auto* vec3_u32 = Construct(create<ast::Vector>(nullptr, 3), Expr(1_u), Expr(2_u), Expr(3_u));
auto* vec3_f32 = Construct(create<ast::Vector>(nullptr, 3), Expr(1.0f), Expr(2.0f), Expr(3.0f));
WrapInFunction(vec3_bool, vec3_i32, vec3_u32, vec3_f32);
@@ -1772,8 +1772,8 @@
TEST_F(ResolverTypeConstructorValidationTest, InferVec3ElementTypeFromVec3) {
auto* vec3_bool = Construct(create<ast::Vector>(nullptr, 3), vec3<bool>(true, false, true));
- auto* vec3_i32 = Construct(create<ast::Vector>(nullptr, 3), vec3<i32>(1, 2, 3));
- auto* vec3_u32 = Construct(create<ast::Vector>(nullptr, 3), vec3<u32>(1u, 2u, 3u));
+ auto* vec3_i32 = Construct(create<ast::Vector>(nullptr, 3), vec3<i32>(1_i, 2_i, 3_i));
+ auto* vec3_u32 = Construct(create<ast::Vector>(nullptr, 3), vec3<u32>(1_u, 2_u, 3_u));
auto* vec3_f32 = Construct(create<ast::Vector>(nullptr, 3), vec3<f32>(1.0f, 2.0f, 3.0f));
WrapInFunction(vec3_bool, vec3_i32, vec3_u32, vec3_f32);
@@ -1800,8 +1800,8 @@
TEST_F(ResolverTypeConstructorValidationTest, InferVec3ElementTypeFromScalarAndVec2) {
auto* vec3_bool =
Construct(create<ast::Vector>(nullptr, 3), Expr(true), vec2<bool>(false, true));
- auto* vec3_i32 = Construct(create<ast::Vector>(nullptr, 3), Expr(1), vec2<i32>(2, 3));
- auto* vec3_u32 = Construct(create<ast::Vector>(nullptr, 3), Expr(1u), vec2<u32>(2u, 3u));
+ auto* vec3_i32 = Construct(create<ast::Vector>(nullptr, 3), Expr(1_i), vec2<i32>(2_i, 3_i));
+ auto* vec3_u32 = Construct(create<ast::Vector>(nullptr, 3), Expr(1_u), vec2<u32>(2_u, 3_u));
auto* vec3_f32 = Construct(create<ast::Vector>(nullptr, 3), Expr(1.0f), vec2<f32>(2.0f, 3.0f));
WrapInFunction(vec3_bool, vec3_i32, vec3_u32, vec3_f32);
@@ -1828,9 +1828,10 @@
TEST_F(ResolverTypeConstructorValidationTest, InferVec4ElementTypeFromScalars) {
auto* vec4_bool = Construct(create<ast::Vector>(nullptr, 4), Expr(true), Expr(false),
Expr(true), Expr(false));
- auto* vec4_i32 = Construct(create<ast::Vector>(nullptr, 4), Expr(1), Expr(2), Expr(3), Expr(4));
+ auto* vec4_i32 =
+ Construct(create<ast::Vector>(nullptr, 4), Expr(1_i), Expr(2_i), Expr(3_i), Expr(4_i));
auto* vec4_u32 =
- Construct(create<ast::Vector>(nullptr, 4), Expr(1u), Expr(2u), Expr(3u), Expr(4u));
+ Construct(create<ast::Vector>(nullptr, 4), Expr(1_u), Expr(2_u), Expr(3_u), Expr(4_u));
auto* vec4_f32 =
Construct(create<ast::Vector>(nullptr, 4), Expr(1.0f), Expr(2.0f), Expr(3.0f), Expr(4.0f));
WrapInFunction(vec4_bool, vec4_i32, vec4_u32, vec4_f32);
@@ -1858,8 +1859,8 @@
TEST_F(ResolverTypeConstructorValidationTest, InferVec4ElementTypeFromVec4) {
auto* vec4_bool =
Construct(create<ast::Vector>(nullptr, 4), vec4<bool>(true, false, true, false));
- auto* vec4_i32 = Construct(create<ast::Vector>(nullptr, 4), vec4<i32>(1, 2, 3, 4));
- auto* vec4_u32 = Construct(create<ast::Vector>(nullptr, 4), vec4<u32>(1u, 2u, 3u, 4u));
+ auto* vec4_i32 = Construct(create<ast::Vector>(nullptr, 4), vec4<i32>(1_i, 2_i, 3_i, 4_i));
+ auto* vec4_u32 = Construct(create<ast::Vector>(nullptr, 4), vec4<u32>(1_u, 2_u, 3_u, 4_u));
auto* vec4_f32 = Construct(create<ast::Vector>(nullptr, 4), vec4<f32>(1.0f, 2.0f, 3.0f, 4.0f));
WrapInFunction(vec4_bool, vec4_i32, vec4_u32, vec4_f32);
@@ -1886,8 +1887,10 @@
TEST_F(ResolverTypeConstructorValidationTest, InferVec4ElementTypeFromScalarAndVec3) {
auto* vec4_bool =
Construct(create<ast::Vector>(nullptr, 4), Expr(true), vec3<bool>(false, true, false));
- auto* vec4_i32 = Construct(create<ast::Vector>(nullptr, 4), Expr(1), vec3<i32>(2, 3, 4));
- auto* vec4_u32 = Construct(create<ast::Vector>(nullptr, 4), Expr(1u), vec3<u32>(2u, 3u, 4u));
+ auto* vec4_i32 =
+ Construct(create<ast::Vector>(nullptr, 4), Expr(1_i), vec3<i32>(2_i, 3_i, 4_i));
+ auto* vec4_u32 =
+ Construct(create<ast::Vector>(nullptr, 4), Expr(1_u), vec3<u32>(2_u, 3_u, 4_u));
auto* vec4_f32 =
Construct(create<ast::Vector>(nullptr, 4), Expr(1.0f), vec3<f32>(2.0f, 3.0f, 4.0f));
WrapInFunction(vec4_bool, vec4_i32, vec4_u32, vec4_f32);
@@ -1915,9 +1918,10 @@
TEST_F(ResolverTypeConstructorValidationTest, InferVec4ElementTypeFromVec2AndVec2) {
auto* vec4_bool = Construct(create<ast::Vector>(nullptr, 4), vec2<bool>(true, false),
vec2<bool>(true, false));
- auto* vec4_i32 = Construct(create<ast::Vector>(nullptr, 4), vec2<i32>(1, 2), vec2<i32>(3, 4));
+ auto* vec4_i32 =
+ Construct(create<ast::Vector>(nullptr, 4), vec2<i32>(1_i, 2_i), vec2<i32>(3_i, 4_i));
auto* vec4_u32 =
- Construct(create<ast::Vector>(nullptr, 4), vec2<u32>(1u, 2u), vec2<u32>(3u, 4u));
+ Construct(create<ast::Vector>(nullptr, 4), vec2<u32>(1_u, 2_u), vec2<u32>(3_u, 4_u));
auto* vec4_f32 =
Construct(create<ast::Vector>(nullptr, 4), vec2<f32>(1.0f, 2.0f), vec2<f32>(3.0f, 4.0f));
WrapInFunction(vec4_bool, vec4_i32, vec4_u32, vec4_f32);
@@ -1951,8 +1955,8 @@
TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec2ElementTypeFromScalarsMismatch) {
WrapInFunction(Construct(Source{{1, 1}}, create<ast::Vector>(nullptr, 2),
- Expr(Source{{1, 2}}, 1), //
- Expr(Source{{1, 3}}, 2u)));
+ Expr(Source{{1, 2}}, 1_i), //
+ Expr(Source{{1, 3}}, 2_u)));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(
@@ -1964,9 +1968,9 @@
TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec3ElementTypeFromScalarsMismatch) {
WrapInFunction(Construct(Source{{1, 1}}, create<ast::Vector>(nullptr, 3),
- Expr(Source{{1, 2}}, 1), //
- Expr(Source{{1, 3}}, 2u), //
- Expr(Source{{1, 4}}, 3)));
+ Expr(Source{{1, 2}}, 1_i), //
+ Expr(Source{{1, 3}}, 2_u), //
+ Expr(Source{{1, 4}}, 3_i)));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(
@@ -1979,7 +1983,7 @@
TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec3ElementTypeFromScalarAndVec2Mismatch) {
WrapInFunction(Construct(Source{{1, 1}}, create<ast::Vector>(nullptr, 3),
- Expr(Source{{1, 2}}, 1), //
+ Expr(Source{{1, 2}}, 1_i), //
Construct(Source{{1, 3}}, ty.vec2<f32>(), 2.0f, 3.0f)));
EXPECT_FALSE(r()->Resolve());
@@ -1992,10 +1996,10 @@
TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec4ElementTypeFromScalarsMismatch) {
WrapInFunction(Construct(Source{{1, 1}}, create<ast::Vector>(nullptr, 4),
- Expr(Source{{1, 2}}, 1), //
- Expr(Source{{1, 3}}, 2), //
+ Expr(Source{{1, 2}}, 1_i), //
+ Expr(Source{{1, 3}}, 2_i), //
Expr(Source{{1, 4}}, 3.0f), //
- Expr(Source{{1, 5}}, 4)));
+ Expr(Source{{1, 5}}, 4_i)));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(
@@ -2009,8 +2013,8 @@
TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec4ElementTypeFromScalarAndVec3Mismatch) {
WrapInFunction(Construct(Source{{1, 1}}, create<ast::Vector>(nullptr, 4),
- Expr(Source{{1, 2}}, 1), //
- Construct(Source{{1, 3}}, ty.vec3<u32>(), 2u, 3u, 4u)));
+ Expr(Source{{1, 2}}, 1_i), //
+ Construct(Source{{1, 3}}, ty.vec3<u32>(), 2_u, 3_u, 4_u)));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(
@@ -2022,8 +2026,8 @@
TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec4ElementTypeFromVec2AndVec2Mismatch) {
WrapInFunction(Construct(Source{{1, 1}}, create<ast::Vector>(nullptr, 4),
- Construct(Source{{1, 2}}, ty.vec2<i32>(), 3, 4), //
- Construct(Source{{1, 3}}, ty.vec2<u32>(), 3u, 4u)));
+ Construct(Source{{1, 2}}, ty.vec2<i32>(), 3_i, 4_i), //
+ Construct(Source{{1, 3}}, ty.vec2<u32>(), 3_u, 4_u)));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(
@@ -2179,7 +2183,7 @@
std::stringstream args_tys;
ast::ExpressionList args;
for (uint32_t i = 1; i <= param.columns; i++) {
- args.push_back(Expr(Source{{12, i}}, 1u));
+ args.push_back(Expr(Source{{12, i}}, 1_u));
if (i > 1) {
args_tys << ", ";
}
@@ -2527,12 +2531,9 @@
namespace StructConstructor {
using builder::CreatePtrs;
using builder::CreatePtrsFor;
-using builder::f32;
-using builder::i32;
using builder::mat2x2;
using builder::mat3x3;
using builder::mat4x4;
-using builder::u32;
using builder::vec2;
using builder::vec3;
using builder::vec4;
@@ -2659,7 +2660,7 @@
auto* m2 = Member("m2", ty.i32());
auto* s = Structure("s", {m0, m1, m2});
- auto* tc = Construct(Source{{12, 34}}, ty.Of(s), 1, 1, 1);
+ auto* tc = Construct(Source{{12, 34}}, ty.Of(s), 1_i, 1_i, 1_i);
WrapInFunction(tc);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -2695,7 +2696,8 @@
}
TEST_F(ResolverTypeConstructorValidationTest, NonConstructibleType_AtomicArray) {
- WrapInFunction(Assign(Phony(), Construct(Source{{12, 34}}, ty.array(ty.atomic(ty.i32()), 4))));
+ WrapInFunction(
+ Assign(Phony(), Construct(Source{{12, 34}}, ty.array(ty.atomic(ty.i32()), 4_i))));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array constructor has non-constructible element type");
@@ -2725,7 +2727,7 @@
}
TEST_F(ResolverTypeConstructorValidationTest, TypeConversionAsStatement) {
- WrapInFunction(CallStmt(Construct(Source{{12, 34}}, ty.f32(), 1)));
+ WrapInFunction(CallStmt(Construct(Source{{12, 34}}, ty.f32(), 1_i)));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: type cast evaluated but not used");
diff --git a/src/tint/resolver/type_validation_test.cc b/src/tint/resolver/type_validation_test.cc
index bfd4249..2af2c0e 100644
--- a/src/tint/resolver/type_validation_test.cc
+++ b/src/tint/resolver/type_validation_test.cc
@@ -22,6 +22,8 @@
#include "gmock/gmock.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -50,9 +52,6 @@
using alias2 = builder::alias2<T>;
template <typename T>
using alias3 = builder::alias3<T>;
-using f32 = builder::f32;
-using i32 = builder::i32;
-using u32 = builder::u32;
class ResolverTypeValidationTest : public resolver::TestHelper, public testing::Test {};
@@ -63,7 +62,7 @@
// }
auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, nullptr);
auto* lhs = Expr("a");
- auto* rhs = Expr(2);
+ auto* rhs = Expr(2_i);
auto* body = Block(Decl(var), Assign(Source{Source::Location{12, 34}}, lhs, rhs));
@@ -191,49 +190,49 @@
TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedLiteral_Pass) {
// var<private> a : array<f32, 4u>;
- Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4u)), ast::StorageClass::kPrivate);
+ Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_u)), ast::StorageClass::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Pass) {
- // var<private> a : array<f32, 4>;
- Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4)), ast::StorageClass::kPrivate);
+ // var<private> a : array<f32, 4i>;
+ Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_i)), ast::StorageClass::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedConstant_Pass) {
// let size = 4u;
// var<private> a : array<f32, size>;
- GlobalConst("size", nullptr, Expr(4u));
+ GlobalConst("size", nullptr, Expr(4_u));
Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::StorageClass::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverTypeValidationTest, ArraySize_SignedConstant_Pass) {
- // let size = 4;
+ // let size = 4i;
// var<private> a : array<f32, size>;
- GlobalConst("size", nullptr, Expr(4));
+ GlobalConst("size", nullptr, Expr(4_i));
Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::StorageClass::kPrivate);
EXPECT_TRUE(r()->Resolve()) << r()->error();
}
TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedLiteral_Zero) {
// var<private> a : array<f32, 0u>;
- Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0u)), ast::StorageClass::kPrivate);
+ Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_u)), ast::StorageClass::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array size must be at least 1");
}
TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Zero) {
- // var<private> a : array<f32, 0>;
- Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0)), ast::StorageClass::kPrivate);
+ // var<private> a : array<f32, 0i>;
+ Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_i)), ast::StorageClass::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array size must be at least 1");
}
TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Negative) {
- // var<private> a : array<f32, -10>;
- Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, -10)), ast::StorageClass::kPrivate);
+ // var<private> a : array<f32, -10i>;
+ Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, i32(-10))), ast::StorageClass::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array size must be at least 1");
}
@@ -241,25 +240,25 @@
TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedConstant_Zero) {
// let size = 0u;
// var<private> a : array<f32, size>;
- GlobalConst("size", nullptr, Expr(0u));
+ GlobalConst("size", nullptr, Expr(0_u));
Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::StorageClass::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array size must be at least 1");
}
TEST_F(ResolverTypeValidationTest, ArraySize_SignedConstant_Zero) {
- // let size = 0;
+ // let size = 0i;
// var<private> a : array<f32, size>;
- GlobalConst("size", nullptr, Expr(0));
+ GlobalConst("size", nullptr, Expr(0_i));
Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::StorageClass::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array size must be at least 1");
}
TEST_F(ResolverTypeValidationTest, ArraySize_SignedConstant_Negative) {
- // let size = -10;
+ // let size = -10i;
// var<private> a : array<f32, size>;
- GlobalConst("size", nullptr, Expr(-10));
+ GlobalConst("size", nullptr, Expr(i32(-10)));
Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::StorageClass::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array size must be at least 1");
@@ -274,7 +273,7 @@
TEST_F(ResolverTypeValidationTest, ArraySize_IVecLiteral) {
// var<private> a : array<f32, vec2<i32>(10, 10)>;
- Global("a", ty.array(ty.f32(), Construct(Source{{12, 34}}, ty.vec2<i32>(), 10, 10)),
+ Global("a", ty.array(ty.f32(), Construct(Source{{12, 34}}, ty.vec2<i32>(), 10_i, 10_i)),
ast::StorageClass::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array size must be integer scalar");
@@ -292,15 +291,15 @@
TEST_F(ResolverTypeValidationTest, ArraySize_IVecConstant) {
// let size = vec2<i32>(100, 100);
// var<private> a : array<f32, size>;
- GlobalConst("size", nullptr, Construct(ty.vec2<i32>(), 100, 100));
+ GlobalConst("size", nullptr, Construct(ty.vec2<i32>(), 100_i, 100_i));
Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::StorageClass::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array size must be integer scalar");
}
TEST_F(ResolverTypeValidationTest, ArraySize_TooBig_ImplicitStride) {
- // var<private> a : array<f32, 0x40000000>;
- Global("a", ty.array(Source{{12, 34}}, ty.f32(), 0x40000000), ast::StorageClass::kPrivate);
+ // var<private> a : array<f32, 0x40000000u>;
+ Global("a", ty.array(Source{{12, 34}}, ty.f32(), 0x40000000_u), ast::StorageClass::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
"12:34 error: array size in bytes must not exceed 0xffffffff, but "
@@ -308,8 +307,8 @@
}
TEST_F(ResolverTypeValidationTest, ArraySize_TooBig_ExplicitStride) {
- // var<private> a : @stride(8) array<f32, 0x20000000>;
- Global("a", ty.array(Source{{12, 34}}, ty.f32(), 0x20000000, 8), ast::StorageClass::kPrivate);
+ // var<private> a : @stride(8) array<f32, 0x20000000u>;
+ Global("a", ty.array(Source{{12, 34}}, ty.f32(), 0x20000000_u, 8), ast::StorageClass::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
"12:34 error: array size in bytes must not exceed 0xffffffff, but "
@@ -317,18 +316,18 @@
}
TEST_F(ResolverTypeValidationTest, ArraySize_OverridableConstant) {
- // override size = 10;
+ // override size = 10i;
// var<private> a : array<f32, size>;
- Override("size", nullptr, Expr(10));
+ Override("size", nullptr, Expr(10_i));
Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::StorageClass::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array size expression must not be pipeline-overridable");
}
TEST_F(ResolverTypeValidationTest, ArraySize_ModuleVar) {
- // var<private> size : i32 = 10;
+ // var<private> size : i32 = 10i;
// var<private> a : array<f32, size>;
- Global("size", ty.i32(), Expr(10), ast::StorageClass::kPrivate);
+ Global("size", ty.i32(), Expr(10_i), ast::StorageClass::kPrivate);
Global("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), ast::StorageClass::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "12:34 error: array size identifier must be a module-scope constant");
@@ -339,7 +338,7 @@
// let size = 10;
// var a : array<f32, size>;
// }
- auto* size = Let("size", nullptr, Expr(10));
+ auto* size = Let("size", nullptr, Expr(10_i));
auto* a = Var("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")));
WrapInFunction(Block(Decl(size), Decl(a)));
EXPECT_FALSE(r()->Resolve());
@@ -347,10 +346,9 @@
}
TEST_F(ResolverTypeValidationTest, ArraySize_InvalidExpr) {
- // var a : array<f32, i32(4)>;
- auto* size = Let("size", nullptr, Expr(10));
- auto* a = Var("a", ty.array(ty.f32(), Construct(Source{{12, 34}}, ty.i32(), 4)));
- WrapInFunction(Block(Decl(size), Decl(a)));
+ // var a : array<f32, i32(4i)>;
+ auto* a = Var("a", ty.array(ty.f32(), Construct(Source{{12, 34}}, ty.i32(), 4_i)));
+ WrapInFunction(Block(Decl(a)));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
"12:34 error: array size expression must be either a literal or a "
@@ -457,10 +455,10 @@
TEST_F(ResolverTypeValidationTest, RuntimeArrayInArray) {
// struct Foo {
- // rt : array<array<f32>, 4>;
+ // rt : array<array<f32>, 4u>;
// };
- Structure("Foo", {Member("rt", ty.array(Source{{12, 34}}, ty.array<f32>(), 4))});
+ Structure("Foo", {Member("rt", ty.array(Source{{12, 34}}, ty.array<f32>(), 4_u))});
EXPECT_FALSE(r()->Resolve()) << r()->error();
EXPECT_EQ(r()->error(),
@@ -475,7 +473,7 @@
// var<private> a : array<Foo, 4>;
auto* foo = Structure("Foo", {Member("rt", ty.array<f32>())});
- Global("v", ty.array(Source{{12, 34}}, ty.Of(foo), 4), ast::StorageClass::kPrivate);
+ Global("v", ty.array(Source{{12, 34}}, ty.Of(foo), 4_u), ast::StorageClass::kPrivate);
EXPECT_FALSE(r()->Resolve()) << r()->error();
EXPECT_EQ(r()->error(),
@@ -624,7 +622,7 @@
TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableType) {
auto* tex_ty = ty.sampled_texture(ast::TextureDimension::k2d, ty.f32());
- Global("arr", ty.array(Source{{12, 34}}, tex_ty, 4), ast::StorageClass::kPrivate);
+ Global("arr", ty.array(Source{{12, 34}}, tex_ty, 4_i), ast::StorageClass::kPrivate);
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
diff --git a/src/tint/resolver/validation_test.cc b/src/tint/resolver/validation_test.cc
index 0e7cfff..65d73c4 100644
--- a/src/tint/resolver/validation_test.cc
+++ b/src/tint/resolver/validation_test.cc
@@ -41,6 +41,8 @@
using ::testing::ElementsAre;
using ::testing::HasSubstr;
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -169,7 +171,7 @@
// normalize = 2;
auto* lhs = Expr(Source{{12, 34}}, "normalize");
- auto* rhs = Expr(2);
+ auto* rhs = Expr(2_i);
auto* assign = Assign(lhs, rhs);
WrapInFunction(assign);
@@ -181,7 +183,7 @@
// b = 2;
auto* lhs = Expr(Source{{12, 34}}, "b");
- auto* rhs = Expr(2);
+ auto* rhs = Expr(2_i);
auto* assign = Assign(lhs, rhs);
WrapInFunction(assign);
@@ -195,7 +197,7 @@
// }
auto* lhs = Expr(Source{{12, 34}}, "b");
- auto* rhs = Expr(2);
+ auto* rhs = Expr(2_i);
auto* body = Block(Assign(lhs, rhs));
WrapInFunction(body);
@@ -444,7 +446,7 @@
auto error_loc = Source{{12, 34}};
auto* body = Block(Continue(), Decl(error_loc, Var("z", ty.i32(), ast::StorageClass::kNone)));
- auto* continuing = Block(Assign(Expr("z"), 2));
+ auto* continuing = Block(Assign(Expr("z"), 2_i));
auto* loop_stmt = Loop(body, continuing);
WrapInFunction(loop_stmt);
@@ -464,14 +466,14 @@
// continue; // Ok
//
// continuing {
- // z = 2;
+ // z = 2i;
// }
// }
auto* body =
Block(If(false, Block(Break())), //
Decl(Var("z", ty.i32(), ast::StorageClass::kNone)), Block(Block(Block(Continue()))));
- auto* continuing = Block(Assign(Expr("z"), 2));
+ auto* continuing = Block(Assign(Expr("z"), 2_i));
auto* loop_stmt = Loop(body, continuing);
WrapInFunction(loop_stmt);
@@ -485,7 +487,7 @@
// }
// var z : i32;
// continuing {
- // z = 2;
+ // z = 2i;
// }
// }
@@ -494,7 +496,7 @@
auto ref_loc = Source{{90, 12}};
auto* body = Block(If(Expr(true), Block(Continue(cont_loc))),
Decl(Var(decl_loc, "z", ty.i32(), ast::StorageClass::kNone)));
- auto* continuing = Block(Assign(Expr(ref_loc, "z"), 2));
+ auto* continuing = Block(Assign(Expr(ref_loc, "z"), 2_i));
auto* loop_stmt = Loop(body, continuing);
WrapInFunction(loop_stmt);
@@ -514,7 +516,7 @@
// var z : i32;
// continuing {
// if (true) {
- // z = 2; // Must fail even if z is in a sub-scope
+ // z = 2i; // Must fail even if z is in a sub-scope
// }
// }
// }
@@ -525,7 +527,7 @@
auto* body = Block(If(Expr(true), Block(Continue(cont_loc))),
Decl(Var(decl_loc, "z", ty.i32(), ast::StorageClass::kNone)));
- auto* continuing = Block(If(Expr(true), Block(Assign(Expr(ref_loc, "z"), 2))));
+ auto* continuing = Block(If(Expr(true), Block(Assign(Expr(ref_loc, "z"), 2_i))));
auto* loop_stmt = Loop(body, continuing);
WrapInFunction(loop_stmt);
@@ -545,7 +547,7 @@
// continuing {
// // Must fail even if z is used in an expression that isn't
// // directly contained inside a block.
- // if (z < 2) {
+ // if (z < 2i) {
// }
// }
// }
@@ -556,7 +558,7 @@
auto* body = Block(If(Expr(true), Block(Continue(cont_loc))),
Decl(Var(decl_loc, "z", ty.i32(), ast::StorageClass::kNone)));
auto* compare =
- create<ast::BinaryExpression>(ast::BinaryOp::kLessThan, Expr(ref_loc, "z"), Expr(2));
+ create<ast::BinaryExpression>(ast::BinaryOp::kLessThan, Expr(ref_loc, "z"), Expr(2_i));
auto* continuing = Block(If(compare, Block()));
auto* loop_stmt = Loop(body, continuing);
WrapInFunction(loop_stmt);
@@ -577,7 +579,7 @@
// var z : i32;
// continuing {
// loop {
- // z = 2; // Must fail even if z is in a sub-scope
+ // z = 2i; // Must fail even if z is in a sub-scope
// }
// }
// }
@@ -588,7 +590,7 @@
auto* body = Block(If(Expr(true), Block(Continue(cont_loc))),
Decl(Var(decl_loc, "z", ty.i32(), ast::StorageClass::kNone)));
- auto* continuing = Block(Loop(Block(Assign(Expr(ref_loc, "z"), 2))));
+ auto* continuing = Block(Loop(Block(Assign(Expr(ref_loc, "z"), 2_i))));
auto* loop_stmt = Loop(body, continuing);
WrapInFunction(loop_stmt);
@@ -608,7 +610,7 @@
// var z : i32;
// break;
// continuing {
- // z = 2;
+ // z = 2i;
// }
// }
@@ -618,7 +620,7 @@
auto* body = Block(inner_loop, //
Decl(Var("z", ty.i32(), ast::StorageClass::kNone)), //
Break());
- auto* continuing = Block(Assign("z", 2));
+ auto* continuing = Block(Assign("z", 2_i));
auto* loop_stmt = Loop(body, continuing);
WrapInFunction(loop_stmt);
@@ -636,7 +638,7 @@
// break;
// continuing {
// if (true) {
- // z = 2;
+ // z = 2i;
// }
// }
// }
@@ -646,7 +648,7 @@
auto* body = Block(inner_loop, //
Decl(Var("z", ty.i32(), ast::StorageClass::kNone)), //
Break());
- auto* continuing = Block(If(Expr(true), Block(Assign("z", 2))));
+ auto* continuing = Block(If(Expr(true), Block(Assign("z", 2_i))));
auto* loop_stmt = Loop(body, continuing);
WrapInFunction(loop_stmt);
@@ -663,7 +665,7 @@
// break;
// continuing {
// loop {
- // z = 2;
+ // z = 2i;
// break;
// }
// }
@@ -674,7 +676,7 @@
auto* body = Block(inner_loop, //
Decl(Var("z", ty.i32(), ast::StorageClass::kNone)), //
Break());
- auto* continuing = Block(Loop(Block(Assign("z", 2), //
+ auto* continuing = Block(Loop(Block(Assign("z", 2_i), //
Break())));
auto* loop_stmt = Loop(body, continuing);
WrapInFunction(loop_stmt);
@@ -688,7 +690,7 @@
// if (true) { continue; }
// break;
// continuing {
- // z = 2;
+ // z = 2i;
// }
// }
@@ -696,7 +698,7 @@
auto* body =
Block(Decl(Var("z", ty.i32(), ast::StorageClass::kNone)), If(true, Block(Continue())), //
Break());
- auto* continuing = Block(Assign(Expr(error_loc, "z"), 2));
+ auto* continuing = Block(Assign(Expr(error_loc, "z"), 2_i));
auto* loop_stmt = Loop(body, continuing);
WrapInFunction(loop_stmt);
@@ -988,8 +990,8 @@
}
TEST_F(ResolverValidationTest, Stmt_BreakInSwitch) {
- WrapInFunction(Loop(Block(Switch(Expr(1), //
- Case(Expr(1), //
+ WrapInFunction(Loop(Block(Switch(Expr(1_i), //
+ Case(Expr(1_i), //
Block(Break())), //
DefaultCase()), //
Break()))); //
@@ -1051,7 +1053,7 @@
TEST_F(ResolverValidationTest, Stmt_BreakInIfTrueMultipleStmtsInContinuing) {
auto* cont = Block( // continuing {
If(true, Block(Source{{56, 78}}, // if(true) {
- Assign(Phony(), 1), // _ = 1;
+ Assign(Phony(), 1_i), // _ = 1i;
Break(Source{{12, 34}})))); // break;
// }
// }
@@ -1068,7 +1070,7 @@
auto* cont = Block( // continuing {
If(true, Block(), // if(true) {
Else(Block(Source{{56, 78}}, // } else {
- Assign(Phony(), 1), // _ = 1;
+ Assign(Phony(), 1_i), // _ = 1i;
Break(Source{{12, 34}}))))); // break;
// }
// }
@@ -1098,13 +1100,13 @@
}
TEST_F(ResolverValidationTest, Stmt_BreakInIfNonEmptyElseInContinuing) {
- auto* cont = Block( // continuing {
- If(true, // if(true) {
- Block(Break(Source{{12, 34}})), // break;
- Else(Block(Source{{56, 78}}, // } else {
- Assign(Phony(), 1))))); // _ = 1;
- // }
- // }
+ auto* cont = Block( // continuing {
+ If(true, // if(true) {
+ Block(Break(Source{{12, 34}})), // break;
+ Else(Block(Source{{56, 78}}, // } else {
+ Assign(Phony(), 1_i))))); // _ = 1i;
+ // }
+ // }
WrapInFunction(Loop(Block(), cont));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -1115,13 +1117,13 @@
}
TEST_F(ResolverValidationTest, Stmt_BreakInIfElseNonEmptyTrueInContinuing) {
- auto* cont = Block( // continuing {
- If(true, // if(true) {
- Block(Source{{56, 78}}, Assign(Phony(), 1)), // _ = 1;
- Else(Block( // } else {
- Break(Source{{12, 34}}))))); // break;
- // }
- // }
+ auto* cont = Block( // continuing {
+ If(true, // if(true) {
+ Block(Source{{56, 78}}, Assign(Phony(), 1_i)), // _ = 1i;
+ Else(Block( // } else {
+ Break(Source{{12, 34}}))))); // break;
+ // }
+ // }
WrapInFunction(Loop(Block(), cont));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -1136,7 +1138,7 @@
If(Source{{56, 78}}, true, // if(true) {
Block(Break(Source{{12, 34}}))), // break;
// }
- Assign(Phony(), 1)); // _ = 1;
+ Assign(Phony(), 1_i)); // _ = 1i;
// }
WrapInFunction(Loop(Block(), cont));
EXPECT_FALSE(r()->Resolve());
diff --git a/src/tint/resolver/var_let_test.cc b/src/tint/resolver/var_let_test.cc
index 4e6eaa7..a59855a 100644
--- a/src/tint/resolver/var_let_test.cc
+++ b/src/tint/resolver/var_let_test.cc
@@ -18,6 +18,8 @@
#include "gmock/gmock.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -95,12 +97,12 @@
auto* S = Structure("S", {Member("i", ty.i32())});
auto* A = Alias("A", ty.Of(S));
- auto* i_c = Expr(1);
- auto* u_c = Expr(1u);
+ auto* i_c = Expr(1_i);
+ auto* u_c = Expr(1_u);
auto* f_c = Expr(1.f);
auto* b_c = Expr(true);
- auto* s_c = Construct(ty.Of(S), Expr(1));
- auto* a_c = Construct(ty.Of(A), Expr(1));
+ auto* s_c = Construct(ty.Of(S), Expr(1_i));
+ auto* a_c = Construct(ty.Of(A), Expr(1_i));
auto* i = Var("i", ty.i32(), ast::StorageClass::kNone, i_c);
auto* u = Var("u", ty.u32(), ast::StorageClass::kNone, u_c);
@@ -148,7 +150,7 @@
// struct S { i : i32; }
// fn F(){
// var v : i32;
- // let i : i32 = 1;
+ // let i : i32 = 1i;
// let u : u32 = 1u;
// let f : f32 = 1.;
// let b : bool = true;
@@ -161,12 +163,12 @@
auto* A = Alias("A", ty.Of(S));
auto* v = Var("v", ty.i32(), ast::StorageClass::kNone);
- auto* i_c = Expr(1);
- auto* u_c = Expr(1u);
+ auto* i_c = Expr(1_i);
+ auto* u_c = Expr(1_u);
auto* f_c = Expr(1.f);
auto* b_c = Expr(true);
- auto* s_c = Construct(ty.Of(S), Expr(1));
- auto* a_c = Construct(ty.Of(A), Expr(1));
+ auto* s_c = Construct(ty.Of(S), Expr(1_i));
+ auto* a_c = Construct(ty.Of(A), Expr(1_i));
auto* p_c = AddressOf(v);
auto* i = Let("i", ty.i32(), i_c);
@@ -278,7 +280,7 @@
// }
// @group(0) @binding(0) var<storage, read_write> s : S;
// fn f() {
- // let p = &s.inner.arr[2];
+ // let p = &s.inner.arr[4];
// }
auto* inner = Structure("Inner", {Member("arr", ty.array<i32, 4>())});
auto* buf = Structure("S", {Member("inner", ty.Of(inner))});
@@ -288,7 +290,7 @@
create<ast::GroupAttribute>(0),
});
- auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 4);
+ auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 4_i);
auto* ptr = Let("p", nullptr, AddressOf(expr));
WrapInFunction(ptr);
@@ -444,7 +446,7 @@
// let a = (a == 321);
// }
- auto* g = GlobalConst("a", ty.i32(), Expr(1));
+ auto* g = GlobalConst("a", ty.i32(), Expr(1_i));
auto* v = Var("a", nullptr, Expr("a"));
auto* l = Let("a", nullptr, Expr("a"));
Func("X", {}, ty.void_(), {Decl(v)});
@@ -483,7 +485,7 @@
// }
// }
- auto* s = Var("a", ty.i32(), Expr(1));
+ auto* s = Var("a", ty.i32(), Expr(1_i));
auto* v = Var("a", nullptr, Expr("a"));
auto* l = Let("a", nullptr, Expr("a"));
Func("X", {}, ty.void_(), {Decl(s), Block(Decl(v)), Block(Decl(l))});
@@ -522,7 +524,7 @@
// }
// }
- auto* s = Let("a", ty.i32(), Expr(1));
+ auto* s = Let("a", ty.i32(), Expr(1_i));
auto* v = Var("a", nullptr, Expr("a"));
auto* l = Let("a", nullptr, Expr("a"));
Func("X", {}, ty.void_(), {Decl(s), Block(Decl(v)), Block(Decl(l))});
@@ -633,7 +635,7 @@
// fn F(a : bool) {
// }
- auto* g = GlobalConst("a", ty.i32(), Expr(1));
+ auto* g = GlobalConst("a", ty.i32(), Expr(1_i));
auto* p = Param("a", ty.bool_());
Func("F", {p}, ty.void_(), {});
diff --git a/src/tint/resolver/var_let_validation_test.cc b/src/tint/resolver/var_let_validation_test.cc
index caa47d0..ff63918 100644
--- a/src/tint/resolver/var_let_validation_test.cc
+++ b/src/tint/resolver/var_let_validation_test.cc
@@ -17,6 +17,8 @@
#include "gmock/gmock.h"
+using namespace tint::number_suffixes; // NOLINT
+
namespace tint::resolver {
namespace {
@@ -86,7 +88,7 @@
TEST_F(ResolverVarLetValidationTest, LetConstructorWrongType) {
// var v : i32 = 2u
- WrapInFunction(Let(Source{{3, 3}}, "v", ty.i32(), Expr(2u)));
+ WrapInFunction(Let(Source{{3, 3}}, "v", ty.i32(), Expr(2_u)));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -95,7 +97,7 @@
TEST_F(ResolverVarLetValidationTest, VarConstructorWrongType) {
// var v : i32 = 2u
- WrapInFunction(Var(Source{{3, 3}}, "v", ty.i32(), ast::StorageClass::kNone, Expr(2u)));
+ WrapInFunction(Var(Source{{3, 3}}, "v", ty.i32(), ast::StorageClass::kNone, Expr(2_u)));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -104,7 +106,7 @@
TEST_F(ResolverVarLetValidationTest, LetConstructorWrongTypeViaAlias) {
auto* a = Alias("I32", ty.i32());
- WrapInFunction(Let(Source{{3, 3}}, "v", ty.Of(a), Expr(2u)));
+ WrapInFunction(Let(Source{{3, 3}}, "v", ty.Of(a), Expr(2_u)));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -113,7 +115,7 @@
TEST_F(ResolverVarLetValidationTest, VarConstructorWrongTypeViaAlias) {
auto* a = Alias("I32", ty.i32());
- WrapInFunction(Var(Source{{3, 3}}, "v", ty.Of(a), ast::StorageClass::kNone, Expr(2u)));
+ WrapInFunction(Var(Source{{3, 3}}, "v", ty.Of(a), ast::StorageClass::kNone, Expr(2_u)));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
@@ -139,7 +141,7 @@
// let l : f32 = 1.;
// let l : i32 = 0;
auto* l1 = Let("l", ty.f32(), Expr(1.f));
- auto* l2 = Let(Source{{12, 34}}, "l", ty.i32(), Expr(0));
+ auto* l2 = Let(Source{{12, 34}}, "l", ty.i32(), Expr(0_i));
WrapInFunction(l1, l2);
EXPECT_FALSE(r()->Resolve());
@@ -204,7 +206,7 @@
// }
// @group(0) @binding(0) var<storage> s : S;
// fn f() {
- // let p : pointer<storage, i32, read_write> = &s.inner.arr[2];
+ // let p : pointer<storage, i32, read_write> = &s.inner.arr[2i];
// }
auto* inner = Structure("Inner", {Member("arr", ty.array<i32, 4>())});
auto* buf = Structure("S", {Member("inner", ty.Of(inner))});
@@ -214,7 +216,7 @@
create<ast::GroupAttribute>(0),
});
- auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 4);
+ auto* expr = IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 2_i);
auto* ptr =
Let(Source{{12, 34}}, "p",
ty.pointer<i32>(ast::StorageClass::kStorage, ast::Access::kReadWrite), AddressOf(expr));
