encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-12-21 02:39:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move vector and matrix to type/.

Browse Source 
This CL moves vector and matrix to type/ and updates the namespaces as
needed.

Bug: tint:1718
Change-Id: I48423b37f15cd69c03ab288143b2d36564789fbf
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/113423
Reviewed-by: Ben Clayton <bclayton@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
This commit is contained in:
dan sinclair
2022-12-08 22:21:24 +00:00
committed by Dan Sinclair
parent 100d4bf339
commit 0e780da882
63 changed files with 1144 additions and 1129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/tint/resolver/array_accessor_test.cc
View File

@@ -111,8 +111,8 @@ TEST_F(ResolverIndexAccessorTest, Matrix) {
ASSERT_TRUE(TypeOf(acc)->Is<type::Reference>());
auto* ref = TypeOf(acc)->As<type::Reference>();
ASSERT_TRUE(ref->StoreType()->Is<sem::Vector>());
EXPECT_EQ(ref->StoreType()->As<sem::Vector>()->Width(), 3u);
ASSERT_TRUE(ref->StoreType()->Is<type::Vector>());
EXPECT_EQ(ref->StoreType()->As<type::Vector>()->Width(), 3u);
auto idx_sem = Sem().Get<sem::IndexAccessorExpression>(acc);
ASSERT_NE(idx_sem, nullptr);

208
src/tint/resolver/builtin_test.cc
View File

@@ -117,9 +117,9 @@ TEST_F(ResolverBuiltinTest, Select) {
EXPECT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(expr), nullptr);
EXPECT_TRUE(TypeOf(expr)->Is<sem::Vector>());
EXPECT_EQ(TypeOf(expr)->As<sem::Vector>()->Width(), 3u);
EXPECT_TRUE(TypeOf(expr)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(expr)->Is<type::Vector>());
EXPECT_EQ(TypeOf(expr)->As<type::Vector>()->Width(), 3u);
EXPECT_TRUE(TypeOf(expr)->As<type::Vector>()->type()->Is<type::F32>());
}
TEST_F(ResolverBuiltinTest, Select_Error_NoParams) {
@@ -315,9 +315,9 @@ TEST_P(ResolverBuiltinTest_FloatBuiltin_IdenticalType, OneParam_Vector_f32) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_float_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F32>());
} else {
// Invalid parameter count.
EXPECT_FALSE(r()->Resolve());
@@ -360,9 +360,9 @@ TEST_P(ResolverBuiltinTest_FloatBuiltin_IdenticalType, TwoParams_Vector_f32) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_float_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F32>());
} else {
// Invalid parameter count.
EXPECT_FALSE(r()->Resolve());
@@ -406,9 +406,9 @@ TEST_P(ResolverBuiltinTest_FloatBuiltin_IdenticalType, ThreeParams_Vector_f32) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_float_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F32>());
} else {
// Invalid parameter count.
EXPECT_FALSE(r()->Resolve());
@@ -453,9 +453,9 @@ TEST_P(ResolverBuiltinTest_FloatBuiltin_IdenticalType, FourParams_Vector_f32) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_float_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F32>());
} else {
// Invalid parameter count.
EXPECT_FALSE(r()->Resolve());
@@ -511,9 +511,9 @@ TEST_P(ResolverBuiltinTest_FloatBuiltin_IdenticalType, OneParam_Vector_f16) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_float_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F16>());
} else {
// Invalid parameter count.
EXPECT_FALSE(r()->Resolve());
@@ -560,9 +560,9 @@ TEST_P(ResolverBuiltinTest_FloatBuiltin_IdenticalType, TwoParams_Vector_f16) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_float_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F16>());
} else {
// Invalid parameter count.
EXPECT_FALSE(r()->Resolve());
@@ -610,9 +610,9 @@ TEST_P(ResolverBuiltinTest_FloatBuiltin_IdenticalType, ThreeParams_Vector_f16) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_float_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F16>());
} else {
// Invalid parameter count.
EXPECT_FALSE(r()->Resolve());
@@ -661,9 +661,9 @@ TEST_P(ResolverBuiltinTest_FloatBuiltin_IdenticalType, FourParams_Vector_f16) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_float_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F16>());
} else {
// Invalid parameter count.
EXPECT_FALSE(r()->Resolve());
@@ -738,8 +738,8 @@ TEST_F(ResolverBuiltinFloatTest, Cross_f32) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_float_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F32>());
}
TEST_F(ResolverBuiltinFloatTest, Cross_f16) {
@@ -752,8 +752,8 @@ TEST_F(ResolverBuiltinFloatTest, Cross_f16) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_float_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F16>());
}
TEST_F(ResolverBuiltinFloatTest, Cross_Error_NoArgs) {
@@ -989,18 +989,18 @@ TEST_F(ResolverBuiltinFloatTest, FrexpVector_f32) {
ASSERT_EQ(ty->Members().Length(), 2u);
auto* fract = ty->Members()[0];
ASSERT_TRUE(fract->Type()->Is<sem::Vector>());
EXPECT_EQ(fract->Type()->As<sem::Vector>()->Width(), 3u);
EXPECT_TRUE(fract->Type()->As<sem::Vector>()->type()->Is<type::F32>());
ASSERT_TRUE(fract->Type()->Is<type::Vector>());
EXPECT_EQ(fract->Type()->As<type::Vector>()->Width(), 3u);
EXPECT_TRUE(fract->Type()->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(fract->Offset(), 0u);
EXPECT_EQ(fract->Size(), 12u);
EXPECT_EQ(fract->Align(), 16u);
EXPECT_EQ(fract->Name(), Sym("fract"));
auto* exp = ty->Members()[1];
ASSERT_TRUE(exp->Type()->Is<sem::Vector>());
EXPECT_EQ(exp->Type()->As<sem::Vector>()->Width(), 3u);
EXPECT_TRUE(exp->Type()->As<sem::Vector>()->type()->Is<type::I32>());
ASSERT_TRUE(exp->Type()->Is<type::Vector>());
EXPECT_EQ(exp->Type()->As<type::Vector>()->Width(), 3u);
EXPECT_TRUE(exp->Type()->As<type::Vector>()->type()->Is<type::I32>());
EXPECT_EQ(exp->Offset(), 16u);
EXPECT_EQ(exp->Size(), 12u);
EXPECT_EQ(exp->Align(), 16u);
@@ -1024,18 +1024,18 @@ TEST_F(ResolverBuiltinFloatTest, FrexpVector_f16) {
ASSERT_EQ(ty->Members().Length(), 2u);
auto* fract = ty->Members()[0];
ASSERT_TRUE(fract->Type()->Is<sem::Vector>());
EXPECT_EQ(fract->Type()->As<sem::Vector>()->Width(), 3u);
EXPECT_TRUE(fract->Type()->As<sem::Vector>()->type()->Is<type::F16>());
ASSERT_TRUE(fract->Type()->Is<type::Vector>());
EXPECT_EQ(fract->Type()->As<type::Vector>()->Width(), 3u);
EXPECT_TRUE(fract->Type()->As<type::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(fract->Offset(), 0u);
EXPECT_EQ(fract->Size(), 6u);
EXPECT_EQ(fract->Align(), 8u);
EXPECT_EQ(fract->Name(), Sym("fract"));
auto* exp = ty->Members()[1];
ASSERT_TRUE(exp->Type()->Is<sem::Vector>());
EXPECT_EQ(exp->Type()->As<sem::Vector>()->Width(), 3u);
EXPECT_TRUE(exp->Type()->As<sem::Vector>()->type()->Is<type::I32>());
ASSERT_TRUE(exp->Type()->Is<type::Vector>());
EXPECT_EQ(exp->Type()->As<type::Vector>()->Width(), 3u);
EXPECT_TRUE(exp->Type()->As<type::Vector>()->type()->Is<type::I32>());
EXPECT_EQ(exp->Offset(), 16u);
EXPECT_EQ(exp->Size(), 12u);
EXPECT_EQ(exp->Align(), 16u);
@@ -1167,9 +1167,9 @@ TEST_F(ResolverBuiltinFloatTest, Mix_VectorScalar_f32) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_float_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F32>());
}
TEST_F(ResolverBuiltinFloatTest, Mix_VectorScalar_f16) {
@@ -1182,9 +1182,9 @@ TEST_F(ResolverBuiltinFloatTest, Mix_VectorScalar_f16) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_float_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F16>());
}
// modf: (f32) -> __modf_result, (vecN<f32>) -> __modf_result_vecN, (f16) -> __modf_result_f16,
@@ -1261,18 +1261,18 @@ TEST_F(ResolverBuiltinFloatTest, ModfVector_f32) {
ASSERT_EQ(ty->Members().Length(), 2u);
auto* fract = ty->Members()[0];
ASSERT_TRUE(fract->Type()->Is<sem::Vector>());
EXPECT_EQ(fract->Type()->As<sem::Vector>()->Width(), 3u);
EXPECT_TRUE(fract->Type()->As<sem::Vector>()->type()->Is<type::F32>());
ASSERT_TRUE(fract->Type()->Is<type::Vector>());
EXPECT_EQ(fract->Type()->As<type::Vector>()->Width(), 3u);
EXPECT_TRUE(fract->Type()->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(fract->Offset(), 0u);
EXPECT_EQ(fract->Size(), 12u);
EXPECT_EQ(fract->Align(), 16u);
EXPECT_EQ(fract->Name(), Sym("fract"));
auto* whole = ty->Members()[1];
ASSERT_TRUE(whole->Type()->Is<sem::Vector>());
EXPECT_EQ(whole->Type()->As<sem::Vector>()->Width(), 3u);
EXPECT_TRUE(whole->Type()->As<sem::Vector>()->type()->Is<type::F32>());
ASSERT_TRUE(whole->Type()->Is<type::Vector>());
EXPECT_EQ(whole->Type()->As<type::Vector>()->Width(), 3u);
EXPECT_TRUE(whole->Type()->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(whole->Offset(), 16u);
EXPECT_EQ(whole->Size(), 12u);
EXPECT_EQ(whole->Align(), 16u);
@@ -1296,18 +1296,18 @@ TEST_F(ResolverBuiltinFloatTest, ModfVector_f16) {
ASSERT_EQ(ty->Members().Length(), 2u);
auto* fract = ty->Members()[0];
ASSERT_TRUE(fract->Type()->Is<sem::Vector>());
EXPECT_EQ(fract->Type()->As<sem::Vector>()->Width(), 3u);
EXPECT_TRUE(fract->Type()->As<sem::Vector>()->type()->Is<type::F16>());
ASSERT_TRUE(fract->Type()->Is<type::Vector>());
EXPECT_EQ(fract->Type()->As<type::Vector>()->Width(), 3u);
EXPECT_TRUE(fract->Type()->As<type::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(fract->Offset(), 0u);
EXPECT_EQ(fract->Size(), 6u);
EXPECT_EQ(fract->Align(), 8u);
EXPECT_EQ(fract->Name(), Sym("fract"));
auto* whole = ty->Members()[1];
ASSERT_TRUE(whole->Type()->Is<sem::Vector>());
EXPECT_EQ(whole->Type()->As<sem::Vector>()->Width(), 3u);
EXPECT_TRUE(whole->Type()->As<sem::Vector>()->type()->Is<type::F16>());
ASSERT_TRUE(whole->Type()->Is<type::Vector>());
EXPECT_EQ(whole->Type()->As<type::Vector>()->Width(), 3u);
EXPECT_TRUE(whole->Type()->As<type::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(whole->Offset(), 8u);
EXPECT_EQ(whole->Size(), 6u);
EXPECT_EQ(whole->Align(), 8u);
@@ -1388,8 +1388,8 @@ TEST_F(ResolverBuiltinFloatTest, Normalize_Vector_f32) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_float_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F32>());
}
TEST_F(ResolverBuiltinFloatTest, Normalize_Vector_f16) {
@@ -1402,8 +1402,8 @@ TEST_F(ResolverBuiltinFloatTest, Normalize_Vector_f16) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_float_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F16>());
}
TEST_F(ResolverBuiltinFloatTest, Normalize_Error_NoParams) {
@@ -1486,9 +1486,9 @@ TEST_P(ResolverBuiltinTest_IntegerBuiltin_IdenticalType, OneParams_Vector_i32) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_signed_integer_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::I32>());
} else {
// Invalid parameter count.
EXPECT_FALSE(r()->Resolve());
@@ -1531,9 +1531,9 @@ TEST_P(ResolverBuiltinTest_IntegerBuiltin_IdenticalType, OneParams_Vector_u32) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_unsigned_integer_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::U32>());
} else {
// Invalid parameter count.
EXPECT_FALSE(r()->Resolve());
@@ -1576,9 +1576,9 @@ TEST_P(ResolverBuiltinTest_IntegerBuiltin_IdenticalType, TwoParams_Vector_i32) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_signed_integer_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::I32>());
} else {
// Invalid parameter count.
EXPECT_FALSE(r()->Resolve());
@@ -1621,9 +1621,9 @@ TEST_P(ResolverBuiltinTest_IntegerBuiltin_IdenticalType, TwoParams_Vector_u32) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_unsigned_integer_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::U32>());
} else {
// Invalid parameter count.
EXPECT_FALSE(r()->Resolve());
@@ -1667,9 +1667,9 @@ TEST_P(ResolverBuiltinTest_IntegerBuiltin_IdenticalType, ThreeParams_Vector_i32)
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_signed_integer_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::I32>());
} else {
// Invalid parameter count.
EXPECT_FALSE(r()->Resolve());
@@ -1714,9 +1714,9 @@ TEST_P(ResolverBuiltinTest_IntegerBuiltin_IdenticalType, ThreeParams_Vector_u32)
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_unsigned_integer_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::U32>());
} else {
// Invalid parameter count.
EXPECT_FALSE(r()->Resolve());
@@ -1761,9 +1761,9 @@ TEST_P(ResolverBuiltinTest_IntegerBuiltin_IdenticalType, FourParams_Vector_i32)
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_signed_integer_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::I32>());
} else {
// Invalid parameter count.
EXPECT_FALSE(r()->Resolve());
@@ -1808,9 +1808,9 @@ TEST_P(ResolverBuiltinTest_IntegerBuiltin_IdenticalType, FourParams_Vector_u32)
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_unsigned_integer_vector());
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<sem::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::U32>());
} else {
// Invalid parameter count.
EXPECT_FALSE(r()->Resolve());
@@ -2053,9 +2053,9 @@ TEST_P(ResolverBuiltinDerivativeTest, Vector) {
EXPECT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(expr), nullptr);
ASSERT_TRUE(TypeOf(expr)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(expr)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(expr)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(expr)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(expr)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(expr)->As<type::Vector>()->Width(), 4u);
}
TEST_P(ResolverBuiltinDerivativeTest, MissingParam) {
@@ -2180,15 +2180,15 @@ TEST_P(ResolverBuiltinTest_SampledTextureOperation, TextureLoadSampled) {
EXPECT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(expr), nullptr);
ASSERT_TRUE(TypeOf(expr)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(expr)->Is<type::Vector>());
if (type == Texture::kF32) {
EXPECT_TRUE(TypeOf(expr)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(expr)->As<type::Vector>()->type()->Is<type::F32>());
} else if (type == Texture::kI32) {
EXPECT_TRUE(TypeOf(expr)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(expr)->As<type::Vector>()->type()->Is<type::I32>());
} else {
EXPECT_TRUE(TypeOf(expr)->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(expr)->As<type::Vector>()->type()->Is<type::U32>());
}
EXPECT_EQ(TypeOf(expr)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(expr)->As<type::Vector>()->Width(), 4u);
}
INSTANTIATE_TEST_SUITE_P(ResolverTest,
@@ -2476,14 +2476,14 @@ TEST_P(ResolverBuiltinTest_Texture, Call) {
case ast::TextureDimension::k2dArray:
case ast::TextureDimension::kCube:
case ast::TextureDimension::kCubeArray: {
auto* vec = As<sem::Vector>(TypeOf(call));
auto* vec = As<type::Vector>(TypeOf(call));
ASSERT_NE(vec, nullptr);
EXPECT_EQ(vec->Width(), 2u);
EXPECT_TRUE(vec->type()->Is<type::U32>());
break;
}
case ast::TextureDimension::k3d: {
auto* vec = As<sem::Vector>(TypeOf(call));
auto* vec = As<type::Vector>(TypeOf(call));
ASSERT_NE(vec, nullptr);
EXPECT_EQ(vec->Width(), 3u);
EXPECT_TRUE(vec->type()->Is<type::U32>());
@@ -2499,7 +2499,7 @@ TEST_P(ResolverBuiltinTest_Texture, Call) {
} else if (std::string(param.function) == "textureStore") {
EXPECT_TRUE(TypeOf(call)->Is<type::Void>());
} else if (std::string(param.function) == "textureGather") {
auto* vec = As<sem::Vector>(TypeOf(call));
auto* vec = As<type::Vector>(TypeOf(call));
ASSERT_NE(vec, nullptr);
EXPECT_EQ(vec->Width(), 4u);
switch (param.texture_data_type) {
@@ -2514,7 +2514,7 @@ TEST_P(ResolverBuiltinTest_Texture, Call) {
break;
}
} else if (std::string(param.function) == "textureGatherCompare") {
auto* vec = As<sem::Vector>(TypeOf(call));
auto* vec = As<type::Vector>(TypeOf(call));
ASSERT_NE(vec, nullptr);
EXPECT_EQ(vec->Width(), 4u);
EXPECT_TRUE(vec->type()->Is<type::F32>());
@@ -2523,7 +2523,7 @@ TEST_P(ResolverBuiltinTest_Texture, Call) {
case ast::builtin::test::TextureKind::kRegular:
case ast::builtin::test::TextureKind::kMultisampled:
case ast::builtin::test::TextureKind::kStorage: {
auto* vec = TypeOf(call)->As<sem::Vector>();
auto* vec = TypeOf(call)->As<type::Vector>();
ASSERT_NE(vec, nullptr);
switch (param.texture_data_type) {
case ast::builtin::test::TextureDataType::kF32:
@@ -2646,9 +2646,9 @@ TEST_P(ResolverBuiltinTest_DataUnpacking, InferType) {
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_float_vector());
if (pack4) {
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 4u);
} else {
EXPECT_EQ(TypeOf(call)->As<sem::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 2u);
}
}

72
src/tint/resolver/builtins_validation_test.cc
View File

@@ -907,12 +907,12 @@ TEST_F(ResolverBuiltinsValidationTest, Frexp_Vec2) {
ASSERT_TRUE(res_ty != nullptr);
auto members = res_ty->Members();
ASSERT_EQ(members.Length(), 2u);
ASSERT_TRUE(members[0]->Type()->Is<sem::Vector>());
ASSERT_TRUE(members[1]->Type()->Is<sem::Vector>());
EXPECT_EQ(members[0]->Type()->As<sem::Vector>()->Width(), 2u);
EXPECT_TRUE(members[0]->Type()->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(members[1]->Type()->As<sem::Vector>()->Width(), 2u);
EXPECT_TRUE(members[1]->Type()->As<sem::Vector>()->type()->Is<type::I32>());
ASSERT_TRUE(members[0]->Type()->Is<type::Vector>());
ASSERT_TRUE(members[1]->Type()->Is<type::Vector>());
EXPECT_EQ(members[0]->Type()->As<type::Vector>()->Width(), 2u);
EXPECT_TRUE(members[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(members[1]->Type()->As<type::Vector>()->Width(), 2u);
EXPECT_TRUE(members[1]->Type()->As<type::Vector>()->type()->Is<type::I32>());
}
TEST_F(ResolverBuiltinsValidationTest, Frexp_Vec3) {
@@ -924,12 +924,12 @@ TEST_F(ResolverBuiltinsValidationTest, Frexp_Vec3) {
ASSERT_TRUE(res_ty != nullptr);
auto members = res_ty->Members();
ASSERT_EQ(members.Length(), 2u);
ASSERT_TRUE(members[0]->Type()->Is<sem::Vector>());
ASSERT_TRUE(members[1]->Type()->Is<sem::Vector>());
EXPECT_EQ(members[0]->Type()->As<sem::Vector>()->Width(), 3u);
EXPECT_TRUE(members[0]->Type()->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(members[1]->Type()->As<sem::Vector>()->Width(), 3u);
EXPECT_TRUE(members[1]->Type()->As<sem::Vector>()->type()->Is<type::I32>());
ASSERT_TRUE(members[0]->Type()->Is<type::Vector>());
ASSERT_TRUE(members[1]->Type()->Is<type::Vector>());
EXPECT_EQ(members[0]->Type()->As<type::Vector>()->Width(), 3u);
EXPECT_TRUE(members[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(members[1]->Type()->As<type::Vector>()->Width(), 3u);
EXPECT_TRUE(members[1]->Type()->As<type::Vector>()->type()->Is<type::I32>());
}
TEST_F(ResolverBuiltinsValidationTest, Frexp_Vec4) {
@@ -941,12 +941,12 @@ TEST_F(ResolverBuiltinsValidationTest, Frexp_Vec4) {
ASSERT_TRUE(res_ty != nullptr);
auto members = res_ty->Members();
ASSERT_EQ(members.Length(), 2u);
ASSERT_TRUE(members[0]->Type()->Is<sem::Vector>());
ASSERT_TRUE(members[1]->Type()->Is<sem::Vector>());
EXPECT_EQ(members[0]->Type()->As<sem::Vector>()->Width(), 4u);
EXPECT_TRUE(members[0]->Type()->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(members[1]->Type()->As<sem::Vector>()->Width(), 4u);
EXPECT_TRUE(members[1]->Type()->As<sem::Vector>()->type()->Is<type::I32>());
ASSERT_TRUE(members[0]->Type()->Is<type::Vector>());
ASSERT_TRUE(members[1]->Type()->Is<type::Vector>());
EXPECT_EQ(members[0]->Type()->As<type::Vector>()->Width(), 4u);
EXPECT_TRUE(members[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(members[1]->Type()->As<type::Vector>()->Width(), 4u);
EXPECT_TRUE(members[1]->Type()->As<type::Vector>()->type()->Is<type::I32>());
}
TEST_F(ResolverBuiltinsValidationTest, Modf_Scalar) {
@@ -971,12 +971,12 @@ TEST_F(ResolverBuiltinsValidationTest, Modf_Vec2) {
ASSERT_TRUE(res_ty != nullptr);
auto members = res_ty->Members();
ASSERT_EQ(members.Length(), 2u);
ASSERT_TRUE(members[0]->Type()->Is<sem::Vector>());
ASSERT_TRUE(members[1]->Type()->Is<sem::Vector>());
EXPECT_EQ(members[0]->Type()->As<sem::Vector>()->Width(), 2u);
EXPECT_TRUE(members[0]->Type()->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(members[1]->Type()->As<sem::Vector>()->Width(), 2u);
EXPECT_TRUE(members[1]->Type()->As<sem::Vector>()->type()->Is<type::F32>());
ASSERT_TRUE(members[0]->Type()->Is<type::Vector>());
ASSERT_TRUE(members[1]->Type()->Is<type::Vector>());
EXPECT_EQ(members[0]->Type()->As<type::Vector>()->Width(), 2u);
EXPECT_TRUE(members[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(members[1]->Type()->As<type::Vector>()->Width(), 2u);
EXPECT_TRUE(members[1]->Type()->As<type::Vector>()->type()->Is<type::F32>());
}
TEST_F(ResolverBuiltinsValidationTest, Modf_Vec3) {
@@ -988,12 +988,12 @@ TEST_F(ResolverBuiltinsValidationTest, Modf_Vec3) {
ASSERT_TRUE(res_ty != nullptr);
auto members = res_ty->Members();
ASSERT_EQ(members.Length(), 2u);
ASSERT_TRUE(members[0]->Type()->Is<sem::Vector>());
ASSERT_TRUE(members[1]->Type()->Is<sem::Vector>());
EXPECT_EQ(members[0]->Type()->As<sem::Vector>()->Width(), 3u);
EXPECT_TRUE(members[0]->Type()->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(members[1]->Type()->As<sem::Vector>()->Width(), 3u);
EXPECT_TRUE(members[1]->Type()->As<sem::Vector>()->type()->Is<type::F32>());
ASSERT_TRUE(members[0]->Type()->Is<type::Vector>());
ASSERT_TRUE(members[1]->Type()->Is<type::Vector>());
EXPECT_EQ(members[0]->Type()->As<type::Vector>()->Width(), 3u);
EXPECT_TRUE(members[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(members[1]->Type()->As<type::Vector>()->Width(), 3u);
EXPECT_TRUE(members[1]->Type()->As<type::Vector>()->type()->Is<type::F32>());
}
TEST_F(ResolverBuiltinsValidationTest, Modf_Vec4) {
@@ -1005,12 +1005,12 @@ TEST_F(ResolverBuiltinsValidationTest, Modf_Vec4) {
ASSERT_TRUE(res_ty != nullptr);
auto members = res_ty->Members();
ASSERT_EQ(members.Length(), 2u);
ASSERT_TRUE(members[0]->Type()->Is<sem::Vector>());
ASSERT_TRUE(members[1]->Type()->Is<sem::Vector>());
EXPECT_EQ(members[0]->Type()->As<sem::Vector>()->Width(), 4u);
EXPECT_TRUE(members[0]->Type()->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(members[1]->Type()->As<sem::Vector>()->Width(), 4u);
EXPECT_TRUE(members[1]->Type()->As<sem::Vector>()->type()->Is<type::F32>());
ASSERT_TRUE(members[0]->Type()->Is<type::Vector>());
ASSERT_TRUE(members[1]->Type()->Is<type::Vector>());
EXPECT_EQ(members[0]->Type()->As<type::Vector>()->Width(), 4u);
EXPECT_TRUE(members[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(members[1]->Type()->As<type::Vector>()->Width(), 4u);
EXPECT_TRUE(members[1]->Type()->As<type::Vector>()->type()->Is<type::F32>());
}
TEST_F(ResolverBuiltinsValidationTest, Cross_Float_Vec3) {

54
src/tint/resolver/const_eval.cc
View File

@@ -25,17 +25,17 @@
#include "src/tint/program_builder.h"
#include "src/tint/sem/array.h"
#include "src/tint/sem/constant.h"
#include "src/tint/sem/matrix.h"
#include "src/tint/sem/member_accessor_expression.h"
#include "src/tint/sem/type_initializer.h"
#include "src/tint/sem/vector.h"
#include "src/tint/type/abstract_float.h"
#include "src/tint/type/abstract_int.h"
#include "src/tint/type/bool.h"
#include "src/tint/type/f16.h"
#include "src/tint/type/f32.h"
#include "src/tint/type/i32.h"
#include "src/tint/type/matrix.h"
#include "src/tint/type/u32.h"
#include "src/tint/type/vector.h"
#include "src/tint/utils/bitcast.h"
#include "src/tint/utils/compiler_macros.h"
#include "src/tint/utils/map.h"
@@ -477,11 +477,11 @@ ImplResult CreateElement(ProgramBuilder& builder, const Source& source, const ty
const ImplConstant* ZeroValue(ProgramBuilder& builder, const type::Type* type) {
return Switch(
type, //
[&](const sem::Vector* v) -> const ImplConstant* {
[&](const type::Vector* v) -> const ImplConstant* {
auto* zero_el = ZeroValue(builder, v->type());
return builder.create<Splat>(type, zero_el, v->Width());
},
[&](const sem::Matrix* m) -> const ImplConstant* {
[&](const type::Matrix* m) -> const ImplConstant* {
auto* zero_el = ZeroValue(builder, m->ColumnType());
return builder.create<Splat>(type, zero_el, m->columns());
},
@@ -530,7 +530,7 @@ bool Equal(const sem::Constant* a, const sem::Constant* b) {
}
return Switch(
a->Type(), //
[&](const sem::Vector* vec) {
[&](const type::Vector* vec) {
for (size_t i = 0; i < vec->Width(); i++) {
if (!Equal(a->Index(i), b->Index(i))) {
return false;
@@ -538,7 +538,7 @@ bool Equal(const sem::Constant* a, const sem::Constant* b) {
}
return true;
},
[&](const sem::Matrix* mat) {
[&](const type::Matrix* mat) {
for (size_t i = 0; i < mat->columns(); i++) {
if (!Equal(a->Index(i), b->Index(i))) {
return false;
@@ -1181,7 +1181,7 @@ auto ConstEval::Dot4Func(const Source& source, const type::Type* elem_ty) {
ConstEval::Result ConstEval::Dot(const Source& source,
const sem::Constant* v1,
const sem::Constant* v2) {
auto* vec_ty = v1->Type()->As<sem::Vector>();
auto* vec_ty = v1->Type()->As<type::Vector>();
TINT_ASSERT(Resolver, vec_ty);
auto* elem_ty = vec_ty->type();
switch (vec_ty->Width()) {
@@ -1208,7 +1208,7 @@ ConstEval::Result ConstEval::Dot(const Source& source,
ConstEval::Result ConstEval::Length(const Source& source,
const type::Type* ty,
const sem::Constant* c0) {
auto* vec_ty = c0->Type()->As<sem::Vector>();
auto* vec_ty = c0->Type()->As<type::Vector>();
// Evaluates to the absolute value of e if T is scalar.
if (vec_ty == nullptr) {
auto create = [&](auto e) {
@@ -1358,7 +1358,7 @@ ConstEval::Result ConstEval::VecSplat(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
const Source&) {
if (auto* arg = args[0]) {
return builder.create<Splat>(ty, arg, static_cast<const sem::Vector*>(ty)->Width());
return builder.create<Splat>(ty, arg, static_cast<const type::Vector*>(ty)->Width());
}
return nullptr;
}
@@ -1379,7 +1379,7 @@ ConstEval::Result ConstEval::VecInitM(const type::Type* ty,
return nullptr;
}
auto* arg_ty = arg->Type();
if (auto* arg_vec = arg_ty->As<sem::Vector>()) {
if (auto* arg_vec = arg_ty->As<type::Vector>()) {
// Extract out vector elements.
for (uint32_t j = 0; j < arg_vec->Width(); j++) {
auto* el = val->Index(j);
@@ -1398,7 +1398,7 @@ ConstEval::Result ConstEval::VecInitM(const type::Type* ty,
ConstEval::Result ConstEval::MatInitS(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
const Source&) {
auto* m = static_cast<const sem::Matrix*>(ty);
auto* m = static_cast<const type::Matrix*>(ty);
utils::Vector<const sem::Constant*, 4> els;
for (uint32_t c = 0; c < m->columns(); c++) {
@@ -1550,8 +1550,8 @@ ConstEval::Result ConstEval::OpMultiply(const type::Type* ty,
ConstEval::Result ConstEval::OpMultiplyMatVec(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
const Source& source) {
auto* mat_ty = args[0]->Type()->As<sem::Matrix>();
auto* vec_ty = args[1]->Type()->As<sem::Vector>();
auto* mat_ty = args[0]->Type()->As<type::Matrix>();
auto* vec_ty = args[1]->Type()->As<type::Vector>();
auto* elem_ty = vec_ty->type();
auto dot = [&](const sem::Constant* m, size_t row, const sem::Constant* v) {
@@ -1600,8 +1600,8 @@ ConstEval::Result ConstEval::OpMultiplyMatVec(const type::Type* ty,
ConstEval::Result ConstEval::OpMultiplyVecMat(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
const Source& source) {
auto* vec_ty = args[0]->Type()->As<sem::Vector>();
auto* mat_ty = args[1]->Type()->As<sem::Matrix>();
auto* vec_ty = args[0]->Type()->As<type::Vector>();
auto* mat_ty = args[1]->Type()->As<type::Matrix>();
auto* elem_ty = vec_ty->type();
auto dot = [&](const sem::Constant* v, const sem::Constant* m, size_t col) {
@@ -1653,8 +1653,8 @@ ConstEval::Result ConstEval::OpMultiplyMatMat(const type::Type* ty,
const Source& source) {
auto* mat1 = args[0];
auto* mat2 = args[1];
auto* mat1_ty = mat1->Type()->As<sem::Matrix>();
auto* mat2_ty = mat2->Type()->As<sem::Matrix>();
auto* mat1_ty = mat1->Type()->As<type::Matrix>();
auto* mat2_ty = mat2->Type()->As<type::Matrix>();
auto* elem_ty = mat1_ty->type();
auto dot = [&](const sem::Constant* m1, size_t row, const sem::Constant* m2, size_t col) {
@@ -1706,7 +1706,7 @@ ConstEval::Result ConstEval::OpMultiplyMatMat(const type::Type* ty,
}
// Add column vector to matrix
auto* col_vec_ty = ty->As<sem::Matrix>()->ColumnType();
auto* col_vec_ty = ty->As<type::Matrix>()->ColumnType();
result_mat.Push(CreateComposite(builder, col_vec_ty, col_vec));
}
return CreateComposite(builder, ty, result_mat);
@@ -2283,7 +2283,7 @@ ConstEval::Result ConstEval::cross(const type::Type* ty,
const Source& source) {
auto* u = args[0];
auto* v = args[1];
auto* elem_ty = u->Type()->As<sem::Vector>()->type();
auto* elem_ty = u->Type()->As<type::Vector>()->type();
// cross product of a v3 is the determinant of the 3x3 matrix:
//
@@ -2352,7 +2352,7 @@ ConstEval::Result ConstEval::determinant(const type::Type* ty,
const Source& source) {
auto calculate = [&]() -> ConstEval::Result {
auto* m = args[0];
auto* mat_ty = m->Type()->As<sem::Matrix>();
auto* mat_ty = m->Type()->As<type::Matrix>();
auto me = [&](size_t r, size_t c) { return m->Index(c)->Index(r); };
switch (mat_ty->rows()) {
case 2:
@@ -2674,7 +2674,7 @@ ConstEval::Result ConstEval::frexp(const type::Type* ty,
});
};
if (auto* vec = arg->Type()->As<sem::Vector>()) {
if (auto* vec = arg->Type()->As<type::Vector>()) {
utils::Vector<const sem::Constant*, 4> fract_els;
utils::Vector<const sem::Constant*, 4> exp_els;
for (uint32_t i = 0; i < vec->Width(); i++) {
@@ -2685,8 +2685,8 @@ ConstEval::Result ConstEval::frexp(const type::Type* ty,
fract_els.Push(fe.fract.Get());
exp_els.Push(fe.exp.Get());
}
auto fract_ty = builder.create<sem::Vector>(fract_els[0]->Type(), vec->Width());
auto exp_ty = builder.create<sem::Vector>(exp_els[0]->Type(), vec->Width());
auto fract_ty = builder.create<type::Vector>(fract_els[0]->Type(), vec->Width());
auto exp_ty = builder.create<type::Vector>(exp_els[0]->Type(), vec->Width());
return CreateComposite(builder, ty,
utils::Vector<const sem::Constant*, 2>{
CreateComposite(builder, fract_ty, std::move(fract_els)),
@@ -3044,7 +3044,7 @@ ConstEval::Result ConstEval::reflect(const type::Type* ty,
// e1 - 2 * dot(e2, e1) * e2.
auto* e1 = args[0];
auto* e2 = args[1];
auto* vec_ty = ty->As<sem::Vector>();
auto* vec_ty = ty->As<type::Vector>();
auto* el_ty = vec_ty->type();
// dot(e2, e1)
@@ -3082,7 +3082,7 @@ ConstEval::Result ConstEval::reflect(const type::Type* ty,
ConstEval::Result ConstEval::refract(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
const Source& source) {
auto* vec_ty = ty->As<sem::Vector>();
auto* vec_ty = ty->As<type::Vector>();
auto* el_ty = vec_ty->type();
auto compute_k = [&](auto e3, auto dot_e2_e1) -> ConstEval::Result {
@@ -3436,9 +3436,9 @@ ConstEval::Result ConstEval::transpose(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
const Source&) {
auto* m = args[0];
auto* mat_ty = m->Type()->As<sem::Matrix>();
auto* mat_ty = m->Type()->As<type::Matrix>();
auto me = [&](size_t r, size_t c) { return m->Index(c)->Index(r); };
auto* result_mat_ty = ty->As<sem::Matrix>();
auto* result_mat_ty = ty->As<type::Matrix>();
// Produce column vectors from each row
utils::Vector<const sem::Constant*, 4> result_mat;

135
src/tint/resolver/const_eval_construction_test.cc
View File

@@ -110,7 +110,7 @@ TEST_F(ResolverConstEvalTest, Vec3_ZeroInit_i32) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::I32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -143,7 +143,7 @@ TEST_F(ResolverConstEvalTest, Vec3_ZeroInit_u32) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::U32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -176,7 +176,7 @@ TEST_F(ResolverConstEvalTest, Vec3_ZeroInit_f32) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -211,7 +211,7 @@ TEST_F(ResolverConstEvalTest, Vec3_ZeroInit_f16) {
auto* sem = Sem().Get(expr);
EXPECT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F16>());
EXPECT_EQ(vec->Width(), 3u);
@@ -244,7 +244,7 @@ TEST_F(ResolverConstEvalTest, Vec3_ZeroInit_bool) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::Bool>());
EXPECT_EQ(vec->Width(), 3u);
@@ -277,7 +277,7 @@ TEST_F(ResolverConstEvalTest, Vec3_Splat_i32) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::I32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -310,7 +310,7 @@ TEST_F(ResolverConstEvalTest, Vec3_Splat_u32) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::U32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -343,7 +343,7 @@ TEST_F(ResolverConstEvalTest, Vec3_Splat_f32) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -378,7 +378,7 @@ TEST_F(ResolverConstEvalTest, Vec3_Splat_f16) {
auto* sem = Sem().Get(expr);
EXPECT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F16>());
EXPECT_EQ(vec->Width(), 3u);
@@ -412,7 +412,7 @@ TEST_F(ResolverConstEvalTest, Vec3_Splat_bool) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::Bool>());
EXPECT_EQ(vec->Width(), 3u);
@@ -445,7 +445,7 @@ TEST_F(ResolverConstEvalTest, Vec3_FullConstruct_i32) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::I32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -478,7 +478,7 @@ TEST_F(ResolverConstEvalTest, Vec3_FullConstruct_u32) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::U32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -511,7 +511,7 @@ TEST_F(ResolverConstEvalTest, Vec3_FullConstruct_f32) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -546,7 +546,7 @@ TEST_F(ResolverConstEvalTest, Vec3_FullConstruct_f16) {
auto* sem = Sem().Get(expr);
EXPECT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F16>());
EXPECT_EQ(vec->Width(), 3u);
@@ -579,7 +579,7 @@ TEST_F(ResolverConstEvalTest, Vec3_FullConstruct_bool) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::Bool>());
EXPECT_EQ(vec->Width(), 3u);
@@ -612,7 +612,7 @@ TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_i32) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::I32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -645,7 +645,7 @@ TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_u32) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::U32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -678,7 +678,7 @@ TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f32) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -711,7 +711,7 @@ TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f32_all_10) {
auto* sem = Sem().Get(expr);
EXPECT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -744,7 +744,7 @@ TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f32_all_positive_0) {
auto* sem = Sem().Get(expr);
EXPECT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -777,7 +777,7 @@ TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f32_all_negative_0) {
auto* sem = Sem().Get(expr);
EXPECT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -810,7 +810,7 @@ TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f32_mixed_sign_0) {
auto* sem = Sem().Get(expr);
EXPECT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -845,7 +845,7 @@ TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f16) {
auto* sem = Sem().Get(expr);
EXPECT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F16>());
EXPECT_EQ(vec->Width(), 3u);
@@ -880,7 +880,7 @@ TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f16_all_10) {
auto* sem = Sem().Get(expr);
EXPECT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F16>());
EXPECT_EQ(vec->Width(), 3u);
@@ -915,7 +915,7 @@ TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f16_all_positive_0) {
auto* sem = Sem().Get(expr);
EXPECT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F16>());
EXPECT_EQ(vec->Width(), 3u);
@@ -950,7 +950,7 @@ TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f16_all_negative_0) {
auto* sem = Sem().Get(expr);
EXPECT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F16>());
EXPECT_EQ(vec->Width(), 3u);
@@ -985,7 +985,7 @@ TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f16_mixed_sign_0) {
auto* sem = Sem().Get(expr);
EXPECT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F16>());
EXPECT_EQ(vec->Width(), 3u);
@@ -1018,7 +1018,7 @@ TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_bool) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::Bool>());
EXPECT_EQ(vec->Width(), 3u);
@@ -1051,7 +1051,7 @@ TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_all_true) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::Bool>());
EXPECT_EQ(vec->Width(), 3u);
@@ -1084,7 +1084,7 @@ TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_all_false) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::Bool>());
EXPECT_EQ(vec->Width(), 3u);
@@ -1117,7 +1117,7 @@ TEST_F(ResolverConstEvalTest, Mat2x3_ZeroInit_f32) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* mat = sem->Type()->As<sem::Matrix>();
auto* mat = sem->Type()->As<type::Matrix>();
ASSERT_NE(mat, nullptr);
EXPECT_TRUE(mat->type()->Is<type::F32>());
EXPECT_EQ(mat->columns(), 2u);
@@ -1168,7 +1168,7 @@ TEST_F(ResolverConstEvalTest, Mat2x3_ZeroInit_f16) {
auto* sem = Sem().Get(expr);
EXPECT_NE(sem, nullptr);
auto* mat = sem->Type()->As<sem::Matrix>();
auto* mat = sem->Type()->As<type::Matrix>();
ASSERT_NE(mat, nullptr);
EXPECT_TRUE(mat->type()->Is<type::F16>());
EXPECT_EQ(mat->columns(), 2u);
@@ -1217,7 +1217,7 @@ TEST_F(ResolverConstEvalTest, Mat3x2_Construct_Scalars_af) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* mat = sem->Type()->As<sem::Matrix>();
auto* mat = sem->Type()->As<type::Matrix>();
ASSERT_NE(mat, nullptr);
EXPECT_TRUE(mat->type()->Is<type::F32>());
EXPECT_EQ(mat->columns(), 3u);
@@ -1269,7 +1269,7 @@ TEST_F(ResolverConstEvalTest, Mat3x2_Construct_Columns_af) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* mat = sem->Type()->As<sem::Matrix>();
auto* mat = sem->Type()->As<type::Matrix>();
ASSERT_NE(mat, nullptr);
EXPECT_TRUE(mat->type()->Is<type::F32>());
EXPECT_EQ(mat->columns(), 3u);
@@ -1394,7 +1394,7 @@ TEST_F(ResolverConstEvalTest, Array_vec3_f32_Zero) {
ASSERT_NE(sem, nullptr);
auto* arr = sem->Type()->As<sem::Array>();
ASSERT_NE(arr, nullptr);
EXPECT_TRUE(arr->ElemType()->Is<sem::Vector>());
EXPECT_TRUE(arr->ElemType()->Is<type::Vector>());
EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
EXPECT_TRUE(sem->ConstantValue()->AllEqual());
EXPECT_TRUE(sem->ConstantValue()->AnyZero());
@@ -1557,7 +1557,7 @@ TEST_F(ResolverConstEvalTest, Array_vec3_f32_Elements) {
ASSERT_NE(sem, nullptr);
auto* arr = sem->Type()->As<sem::Array>();
ASSERT_NE(arr, nullptr);
EXPECT_TRUE(arr->ElemType()->Is<sem::Vector>());
EXPECT_TRUE(arr->ElemType()->Is<type::Vector>());
EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
EXPECT_FALSE(sem->ConstantValue()->AllEqual());
EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -1733,8 +1733,9 @@ TEST_F(ResolverConstEvalTest, Struct_VectorF32s_ZeroInit) {
EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<sem::Vector>());
EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::Vector>());
EXPECT_TRUE(
sem->ConstantValue()->Index(0)->Type()->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->As<f32>(), 0._f);
EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->As<f32>(), 0._f);
EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(2)->As<f32>(), 0._f);
@@ -1742,8 +1743,9 @@ TEST_F(ResolverConstEvalTest, Struct_VectorF32s_ZeroInit) {
EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<sem::Vector>());
EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::Vector>());
EXPECT_TRUE(
sem->ConstantValue()->Index(1)->Type()->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->As<f32>(), 0._f);
EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->As<f32>(), 0._f);
EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->As<f32>(), 0._f);
@@ -1751,8 +1753,9 @@ TEST_F(ResolverConstEvalTest, Struct_VectorF32s_ZeroInit) {
EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<sem::Vector>());
EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<type::Vector>());
EXPECT_TRUE(
sem->ConstantValue()->Index(2)->Type()->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(0)->As<f32>(), 0._f);
EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(1)->As<f32>(), 0._f);
EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(2)->As<f32>(), 0._f);
@@ -1787,16 +1790,18 @@ TEST_F(ResolverConstEvalTest, Struct_MixedVectors_ZeroInit) {
EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<sem::Vector>());
EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::Vector>());
EXPECT_TRUE(
sem->ConstantValue()->Index(0)->Type()->As<type::Vector>()->type()->Is<type::I32>());
EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->As<i32>(), 0_i);
EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->As<i32>(), 0_i);
EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<sem::Vector>());
EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::Vector>());
EXPECT_TRUE(
sem->ConstantValue()->Index(1)->Type()->As<type::Vector>()->type()->Is<type::U32>());
EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->As<u32>(), 0_u);
EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->As<u32>(), 0_u);
EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->As<u32>(), 0_u);
@@ -1804,8 +1809,9 @@ TEST_F(ResolverConstEvalTest, Struct_MixedVectors_ZeroInit) {
EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<sem::Vector>());
EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<type::Vector>());
EXPECT_TRUE(
sem->ConstantValue()->Index(2)->Type()->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(0)->As<f32>(), 0._f);
EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(1)->As<f32>(), 0._f);
EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(2)->As<f32>(), 0._f);
@@ -1814,8 +1820,9 @@ TEST_F(ResolverConstEvalTest, Struct_MixedVectors_ZeroInit) {
EXPECT_TRUE(sem->ConstantValue()->Index(3)->AllEqual());
EXPECT_TRUE(sem->ConstantValue()->Index(3)->AnyZero());
EXPECT_TRUE(sem->ConstantValue()->Index(3)->AllZero());
EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<sem::Vector>());
EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<type::Vector>());
EXPECT_TRUE(
sem->ConstantValue()->Index(3)->Type()->As<type::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(sem->ConstantValue()->Index(3)->Index(0)->As<f16>(), 0._h);
EXPECT_EQ(sem->ConstantValue()->Index(3)->Index(1)->As<f16>(), 0._h);
EXPECT_EQ(sem->ConstantValue()->Index(3)->Index(2)->As<f16>(), 0._h);
@@ -1823,9 +1830,9 @@ TEST_F(ResolverConstEvalTest, Struct_MixedVectors_ZeroInit) {
EXPECT_TRUE(sem->ConstantValue()->Index(4)->AllEqual());
EXPECT_TRUE(sem->ConstantValue()->Index(4)->AnyZero());
EXPECT_TRUE(sem->ConstantValue()->Index(4)->AllZero());
EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<sem::Vector>());
EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<type::Vector>());
EXPECT_TRUE(
sem->ConstantValue()->Index(4)->Type()->As<sem::Vector>()->type()->Is<type::Bool>());
sem->ConstantValue()->Index(4)->Type()->As<type::Vector>()->type()->Is<type::Bool>());
EXPECT_EQ(sem->ConstantValue()->Index(4)->Index(0)->As<bool>(), false);
EXPECT_EQ(sem->ConstantValue()->Index(4)->Index(1)->As<bool>(), false);
}
@@ -1961,16 +1968,18 @@ TEST_F(ResolverConstEvalTest, Struct_MixedVectors_Construct) {
EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllEqual());
EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<sem::Vector>());
EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::Vector>());
EXPECT_TRUE(
sem->ConstantValue()->Index(0)->Type()->As<type::Vector>()->type()->Is<type::I32>());
EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->As<i32>(), 1_i);
EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->As<i32>(), 1_i);
EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllEqual());
EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<sem::Vector>());
EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::Vector>());
EXPECT_TRUE(
sem->ConstantValue()->Index(1)->Type()->As<type::Vector>()->type()->Is<type::U32>());
EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->As<u32>(), 2_u);
EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->As<u32>(), 2_u);
EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->As<u32>(), 2_u);
@@ -1978,8 +1987,9 @@ TEST_F(ResolverConstEvalTest, Struct_MixedVectors_Construct) {
EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllEqual());
EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<sem::Vector>());
EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<type::Vector>());
EXPECT_TRUE(
sem->ConstantValue()->Index(2)->Type()->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(0)->As<f32>(), 3._f);
EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(1)->As<f32>(), 3._f);
EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(2)->As<f32>(), 3._f);
@@ -1988,8 +1998,9 @@ TEST_F(ResolverConstEvalTest, Struct_MixedVectors_Construct) {
EXPECT_TRUE(sem->ConstantValue()->Index(3)->AllEqual());
EXPECT_FALSE(sem->ConstantValue()->Index(3)->AnyZero());
EXPECT_FALSE(sem->ConstantValue()->Index(3)->AllZero());
EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<sem::Vector>());
EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<type::Vector>());
EXPECT_TRUE(
sem->ConstantValue()->Index(3)->Type()->As<type::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(sem->ConstantValue()->Index(3)->Index(0)->As<f16>(), 4._h);
EXPECT_EQ(sem->ConstantValue()->Index(3)->Index(1)->As<f16>(), 4._h);
EXPECT_EQ(sem->ConstantValue()->Index(3)->Index(2)->As<f16>(), 4._h);
@@ -1997,9 +2008,9 @@ TEST_F(ResolverConstEvalTest, Struct_MixedVectors_Construct) {
EXPECT_TRUE(sem->ConstantValue()->Index(4)->AllEqual());
EXPECT_TRUE(sem->ConstantValue()->Index(4)->AnyZero());
EXPECT_TRUE(sem->ConstantValue()->Index(4)->AllZero());
EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<sem::Vector>());
EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<type::Vector>());
EXPECT_TRUE(
sem->ConstantValue()->Index(4)->Type()->As<sem::Vector>()->type()->Is<type::Bool>());
sem->ConstantValue()->Index(4)->Type()->As<type::Vector>()->type()->Is<type::Bool>());
EXPECT_EQ(sem->ConstantValue()->Index(4)->Index(0)->As<bool>(), false);
EXPECT_EQ(sem->ConstantValue()->Index(4)->Index(1)->As<bool>(), false);
}

16
src/tint/resolver/const_eval_conversion_test.cc
View File

@@ -79,7 +79,7 @@ TEST_P(ResolverConstEvalConvTest, Test) {
auto* target_sem_ty = type.sem(*this);
if (kind == Kind::kVector) {
target_sem_ty = create<sem::Vector>(target_sem_ty, 3u);
target_sem_ty = create<type::Vector>(target_sem_ty, 3u);
}
if (unrepresentable) {
@@ -230,7 +230,7 @@ TEST_F(ResolverConstEvalTest, Vec3_Convert_f32_to_i32) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::I32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -263,7 +263,7 @@ TEST_F(ResolverConstEvalTest, Vec3_Convert_u32_to_f32) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -298,7 +298,7 @@ TEST_F(ResolverConstEvalTest, Vec3_Convert_f16_to_i32) {
auto* sem = Sem().Get(expr);
EXPECT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::I32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -333,7 +333,7 @@ TEST_F(ResolverConstEvalTest, Vec3_Convert_u32_to_f16) {
auto* sem = Sem().Get(expr);
EXPECT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F16>());
EXPECT_EQ(vec->Width(), 3u);
@@ -366,7 +366,7 @@ TEST_F(ResolverConstEvalTest, Vec3_Convert_Large_f32_to_i32) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::I32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -399,7 +399,7 @@ TEST_F(ResolverConstEvalTest, Vec3_Convert_Large_f32_to_u32) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::U32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -444,7 +444,7 @@ TEST_F(ResolverConstEvalTest, Vec3_Convert_Small_f32_to_f16) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F16>());
EXPECT_EQ(vec->Width(), 3u);

12
src/tint/resolver/const_eval_indexing_test.cc
View File

@@ -75,7 +75,7 @@ TEST_F(ResolverConstEvalTest, Vec3_Swizzle_Vector) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_EQ(vec->Width(), 2u);
EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
@@ -117,7 +117,7 @@ TEST_F(ResolverConstEvalTest, Mat3x2_Index) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_EQ(vec->Width(), 2u);
EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
@@ -163,7 +163,7 @@ TEST_F(ResolverConstEvalTest, Array_vec3_f32_Index) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
auto* vec = sem->Type()->As<sem::Vector>();
auto* vec = sem->Type()->As<type::Vector>();
ASSERT_NE(vec, nullptr);
EXPECT_TRUE(vec->type()->Is<type::F32>());
EXPECT_EQ(vec->Width(), 3u);
@@ -232,9 +232,9 @@ TEST_F(ResolverConstEvalTest, ChainedIndex) {
{
auto* mat = Sem().Get(mat_expr);
EXPECT_NE(mat, nullptr);
auto* ty = mat->Type()->As<sem::Matrix>();
auto* ty = mat->Type()->As<type::Matrix>();
ASSERT_NE(mat->Type(), nullptr);
EXPECT_TRUE(ty->ColumnType()->Is<sem::Vector>());
EXPECT_TRUE(ty->ColumnType()->Is<type::Vector>());
EXPECT_EQ(ty->columns(), 2u);
EXPECT_EQ(ty->rows(), 3u);
EXPECT_EQ(mat->ConstantValue()->Type(), mat->Type());
@@ -275,7 +275,7 @@ TEST_F(ResolverConstEvalTest, ChainedIndex) {
{
auto* vec = Sem().Get(vec_expr);
EXPECT_NE(vec, nullptr);
auto* ty = vec->Type()->As<sem::Vector>();
auto* ty = vec->Type()->As<type::Vector>();
ASSERT_NE(vec->Type(), nullptr);
EXPECT_TRUE(ty->type()->Is<type::F32>());
EXPECT_EQ(ty->Width(), 3u);

4
src/tint/resolver/const_eval_member_access_test.cc
View File

@@ -79,10 +79,10 @@ TEST_F(ResolverConstEvalTest, Matrix_AFloat_Construct_From_AInt_Vectors) {
auto* sem = Sem().Get(c);
ASSERT_NE(sem, nullptr);
EXPECT_TRUE(sem->Type()->Is<sem::Matrix>());
EXPECT_TRUE(sem->Type()->Is<type::Matrix>());
auto* cv = sem->ConstantValue();
EXPECT_TYPE(cv->Type(), sem->Type());
EXPECT_TRUE(cv->Index(0)->Type()->Is<sem::Vector>());
EXPECT_TRUE(cv->Index(0)->Type()->Is<type::Vector>());
EXPECT_TRUE(cv->Index(0)->Index(0)->Type()->Is<type::AbstractFloat>());
EXPECT_FALSE(cv->AllEqual());
EXPECT_FALSE(cv->AnyZero());

50
src/tint/resolver/intrinsic_table.cc
View File

@@ -413,7 +413,7 @@ bool match_vec(MatchState&, const type::Type* ty, Number& N, const type::Type*&
return true;
}
if (auto* v = ty->As<sem::Vector>()) {
if (auto* v = ty->As<type::Vector>()) {
N = v->Width();
T = v->type();
return true;
@@ -428,7 +428,7 @@ bool match_vec(MatchState&, const type::Type* ty, const type::Type*& T) {
return true;
}
if (auto* v = ty->As<sem::Vector>()) {
if (auto* v = ty->As<type::Vector>()) {
if (v->Width() == N) {
T = v->type();
return true;
@@ -437,13 +437,13 @@ bool match_vec(MatchState&, const type::Type* ty, const type::Type*& T) {
return false;
}
const sem::Vector* build_vec(MatchState& state, Number N, const type::Type* el) {
return state.builder.create<sem::Vector>(el, N.Value());
const type::Vector* build_vec(MatchState& state, Number N, const type::Type* el) {
return state.builder.create<type::Vector>(el, N.Value());
}
template <uint32_t N>
const sem::Vector* build_vec(MatchState& state, const type::Type* el) {
return state.builder.create<sem::Vector>(el, N);
const type::Vector* build_vec(MatchState& state, const type::Type* el) {
return state.builder.create<type::Vector>(el, N);
}
constexpr auto match_vec2 = match_vec<2>;
@@ -461,7 +461,7 @@ bool match_mat(MatchState&, const type::Type* ty, Number& M, Number& N, const ty
T = ty;
return true;
}
if (auto* m = ty->As<sem::Matrix>()) {
if (auto* m = ty->As<type::Matrix>()) {
M = m->columns();
N = m->ColumnType()->Width();
T = m->type();
@@ -476,7 +476,7 @@ bool match_mat(MatchState&, const type::Type* ty, const type::Type*& T) {
T = ty;
return true;
}
if (auto* m = ty->As<sem::Matrix>()) {
if (auto* m = ty->As<type::Matrix>()) {
if (m->columns() == C && m->rows() == R) {
T = m->type();
return true;
@@ -485,15 +485,15 @@ bool match_mat(MatchState&, const type::Type* ty, const type::Type*& T) {
return false;
}
const sem::Matrix* build_mat(MatchState& state, Number C, Number R, const type::Type* T) {
auto* column_type = state.builder.create<sem::Vector>(T, R.Value());
return state.builder.create<sem::Matrix>(column_type, C.Value());
const type::Matrix* build_mat(MatchState& state, Number C, Number R, const type::Type* T) {
auto* column_type = state.builder.create<type::Vector>(T, R.Value());
return state.builder.create<type::Matrix>(column_type, C.Value());
}
template <uint32_t C, uint32_t R>
const sem::Matrix* build_mat(MatchState& state, const type::Type* T) {
auto* column_type = state.builder.create<sem::Vector>(T, R);
return state.builder.create<sem::Matrix>(column_type, C);
const type::Matrix* build_mat(MatchState& state, const type::Type* T) {
auto* column_type = state.builder.create<type::Vector>(T, R);
return state.builder.create<type::Matrix>(column_type, C);
}
constexpr auto build_mat2x2 = build_mat<2, 2>;
@@ -862,11 +862,13 @@ const sem::Struct* build_modf_result(MatchState& state, const type::Type* el) {
const sem::Struct* build_modf_result_vec(MatchState& state, Number& n, const type::Type* el) {
auto prefix = "__modf_result_vec" + std::to_string(n.Value());
auto build_f32 = [&] {
auto* vec = state.builder.create<sem::Vector>(state.builder.create<type::F32>(), n.Value());
auto* vec =
state.builder.create<type::Vector>(state.builder.create<type::F32>(), n.Value());
return build_struct(state.builder, prefix + "_f32", {{"fract", vec}, {"whole", vec}});
};
auto build_f16 = [&] {
auto* vec = state.builder.create<sem::Vector>(state.builder.create<type::F16>(), n.Value());
auto* vec =
state.builder.create<type::Vector>(state.builder.create<type::F16>(), n.Value());
return build_struct(state.builder, prefix + "_f16", {{"fract", vec}, {"whole", vec}});
};
@@ -875,7 +877,7 @@ const sem::Struct* build_modf_result_vec(MatchState& state, Number& n, const typ
[&](const type::F32*) { return build_f32(); }, //
[&](const type::F16*) { return build_f16(); }, //
[&](const type::AbstractFloat*) {
auto* vec = state.builder.create<sem::Vector>(el, n.Value());
auto* vec = state.builder.create<type::Vector>(el, n.Value());
auto* abstract =
build_struct(state.builder, prefix + "_abstract", {{"fract", vec}, {"whole", vec}});
abstract->SetConcreteTypes(utils::Vector{build_f32(), build_f16()});
@@ -921,13 +923,13 @@ const sem::Struct* build_frexp_result(MatchState& state, const type::Type* el) {
const sem::Struct* build_frexp_result_vec(MatchState& state, Number& n, const type::Type* el) {
auto prefix = "__frexp_result_vec" + std::to_string(n.Value());
auto build_f32 = [&] {
auto* f = state.builder.create<sem::Vector>(state.builder.create<type::F32>(), n.Value());
auto* e = state.builder.create<sem::Vector>(state.builder.create<type::I32>(), n.Value());
auto* f = state.builder.create<type::Vector>(state.builder.create<type::F32>(), n.Value());
auto* e = state.builder.create<type::Vector>(state.builder.create<type::I32>(), n.Value());
return build_struct(state.builder, prefix + "_f32", {{"fract", f}, {"exp", e}});
};
auto build_f16 = [&] {
auto* f = state.builder.create<sem::Vector>(state.builder.create<type::F16>(), n.Value());
auto* e = state.builder.create<sem::Vector>(state.builder.create<type::I32>(), n.Value());
auto* f = state.builder.create<type::Vector>(state.builder.create<type::F16>(), n.Value());
auto* e = state.builder.create<type::Vector>(state.builder.create<type::I32>(), n.Value());
return build_struct(state.builder, prefix + "_f16", {{"fract", f}, {"exp", e}});
};
@@ -936,9 +938,9 @@ const sem::Struct* build_frexp_result_vec(MatchState& state, Number& n, const ty
[&](const type::F32*) { return build_f32(); }, //
[&](const type::F16*) { return build_f16(); }, //
[&](const type::AbstractFloat*) {
auto* f = state.builder.create<sem::Vector>(el, n.Value());
auto* e = state.builder.create<sem::Vector>(state.builder.create<type::AbstractInt>(),
n.Value());
auto* f = state.builder.create<type::Vector>(el, n.Value());
auto* e = state.builder.create<type::Vector>(state.builder.create<type::AbstractInt>(),
n.Value());
auto* abstract =
build_struct(state.builder, prefix + "_abstract", {{"fract", f}, {"exp", e}});
abstract->SetConcreteTypes(utils::Vector{build_f32(), build_f16()});

82
src/tint/resolver/intrinsic_table_test.cc
View File

@@ -74,7 +74,7 @@ TEST_F(IntrinsicTableTest, MismatchF32) {
TEST_F(IntrinsicTableTest, MatchU32) {
auto* f32 = create<type::F32>();
auto* u32 = create<type::U32>();
auto* vec2_f32 = create<sem::Vector>(f32, 2u);
auto* vec2_f32 = create<type::Vector>(f32, 2u);
auto result = table->Lookup(BuiltinType::kUnpack2X16Float, utils::Vector{u32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
@@ -96,7 +96,7 @@ TEST_F(IntrinsicTableTest, MismatchU32) {
TEST_F(IntrinsicTableTest, MatchI32) {
auto* f32 = create<type::F32>();
auto* i32 = create<type::I32>();
auto* vec4_f32 = create<sem::Vector>(f32, 4u);
auto* vec4_f32 = create<type::Vector>(f32, 4u);
auto* tex = create<type::SampledTexture>(ast::TextureDimension::k1d, f32);
auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, i32, i32},
sem::EvaluationStage::kConstant, Source{});
@@ -278,8 +278,8 @@ TEST_F(IntrinsicTableTest, MismatchArray) {
TEST_F(IntrinsicTableTest, MatchSampler) {
auto* f32 = create<type::F32>();
auto* vec2_f32 = create<sem::Vector>(f32, 2u);
auto* vec4_f32 = create<sem::Vector>(f32, 4u);
auto* vec2_f32 = create<type::Vector>(f32, 2u);
auto* vec4_f32 = create<type::Vector>(f32, 4u);
auto* tex = create<type::SampledTexture>(ast::TextureDimension::k2d, f32);
auto* sampler = create<type::Sampler>(ast::SamplerKind::kSampler);
auto result = table->Lookup(BuiltinType::kTextureSample, utils::Vector{tex, sampler, vec2_f32},
@@ -299,7 +299,7 @@ TEST_F(IntrinsicTableTest, MatchSampler) {
TEST_F(IntrinsicTableTest, MismatchSampler) {
auto* f32 = create<type::F32>();
auto* vec2_f32 = create<sem::Vector>(f32, 2u);
auto* vec2_f32 = create<type::Vector>(f32, 2u);
auto* tex = create<type::SampledTexture>(ast::TextureDimension::k2d, f32);
auto result = table->Lookup(BuiltinType::kTextureSample, utils::Vector{tex, f32, vec2_f32},
sem::EvaluationStage::kConstant, Source{});
@@ -310,8 +310,8 @@ TEST_F(IntrinsicTableTest, MismatchSampler) {
TEST_F(IntrinsicTableTest, MatchSampledTexture) {
auto* i32 = create<type::I32>();
auto* f32 = create<type::F32>();
auto* vec2_i32 = create<sem::Vector>(i32, 2u);
auto* vec4_f32 = create<sem::Vector>(f32, 4u);
auto* vec2_i32 = create<type::Vector>(i32, 2u);
auto* vec4_f32 = create<type::Vector>(f32, 4u);
auto* tex = create<type::SampledTexture>(ast::TextureDimension::k2d, f32);
auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
sem::EvaluationStage::kConstant, Source{});
@@ -331,8 +331,8 @@ TEST_F(IntrinsicTableTest, MatchSampledTexture) {
TEST_F(IntrinsicTableTest, MatchMultisampledTexture) {
auto* i32 = create<type::I32>();
auto* f32 = create<type::F32>();
auto* vec2_i32 = create<sem::Vector>(i32, 2u);
auto* vec4_f32 = create<sem::Vector>(f32, 4u);
auto* vec2_i32 = create<type::Vector>(i32, 2u);
auto* vec4_f32 = create<type::Vector>(f32, 4u);
auto* tex = create<type::MultisampledTexture>(ast::TextureDimension::k2d, f32);
auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
sem::EvaluationStage::kConstant, Source{});
@@ -352,7 +352,7 @@ TEST_F(IntrinsicTableTest, MatchMultisampledTexture) {
TEST_F(IntrinsicTableTest, MatchDepthTexture) {
auto* f32 = create<type::F32>();
auto* i32 = create<type::I32>();
auto* vec2_i32 = create<sem::Vector>(i32, 2u);
auto* vec2_i32 = create<type::Vector>(i32, 2u);
auto* tex = create<type::DepthTexture>(ast::TextureDimension::k2d);
auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
sem::EvaluationStage::kConstant, Source{});
@@ -372,7 +372,7 @@ TEST_F(IntrinsicTableTest, MatchDepthTexture) {
TEST_F(IntrinsicTableTest, MatchDepthMultisampledTexture) {
auto* f32 = create<type::F32>();
auto* i32 = create<type::I32>();
auto* vec2_i32 = create<sem::Vector>(i32, 2u);
auto* vec2_i32 = create<type::Vector>(i32, 2u);
auto* tex = create<type::DepthMultisampledTexture>(ast::TextureDimension::k2d);
auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
sem::EvaluationStage::kConstant, Source{});
@@ -392,8 +392,8 @@ TEST_F(IntrinsicTableTest, MatchDepthMultisampledTexture) {
TEST_F(IntrinsicTableTest, MatchExternalTexture) {
auto* f32 = create<type::F32>();
auto* i32 = create<type::I32>();
auto* vec2_i32 = create<sem::Vector>(i32, 2u);
auto* vec4_f32 = create<sem::Vector>(f32, 4u);
auto* vec2_i32 = create<type::Vector>(i32, 2u);
auto* vec4_f32 = create<type::Vector>(f32, 4u);
auto* tex = create<type::ExternalTexture>();
auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, vec2_i32},
sem::EvaluationStage::kConstant, Source{});
@@ -411,8 +411,8 @@ TEST_F(IntrinsicTableTest, MatchExternalTexture) {
TEST_F(IntrinsicTableTest, MatchWOStorageTexture) {
auto* f32 = create<type::F32>();
auto* i32 = create<type::I32>();
auto* vec2_i32 = create<sem::Vector>(i32, 2u);
auto* vec4_f32 = create<sem::Vector>(f32, 4u);
auto* vec2_i32 = create<type::Vector>(i32, 2u);
auto* vec4_f32 = create<type::Vector>(f32, 4u);
auto* subtype = type::StorageTexture::SubtypeFor(ast::TexelFormat::kR32Float, Types());
auto* tex = create<type::StorageTexture>(
ast::TextureDimension::k2d, ast::TexelFormat::kR32Float, ast::Access::kWrite, subtype);
@@ -435,7 +435,7 @@ TEST_F(IntrinsicTableTest, MatchWOStorageTexture) {
TEST_F(IntrinsicTableTest, MismatchTexture) {
auto* f32 = create<type::F32>();
auto* i32 = create<type::I32>();
auto* vec2_i32 = create<sem::Vector>(i32, 2u);
auto* vec2_i32 = create<type::Vector>(i32, 2u);
auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{f32, vec2_i32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(result.sem, nullptr);
@@ -482,7 +482,7 @@ TEST_F(IntrinsicTableTest, MismatchTemplateType) {
TEST_F(IntrinsicTableTest, MatchOpenSizeVector) {
auto* f32 = create<type::F32>();
auto* vec2_f32 = create<sem::Vector>(f32, 2u);
auto* vec2_f32 = create<type::Vector>(f32, 2u);
auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{vec2_f32, vec2_f32, vec2_f32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
@@ -498,7 +498,7 @@ TEST_F(IntrinsicTableTest, MatchOpenSizeVector) {
TEST_F(IntrinsicTableTest, MismatchOpenSizeVector) {
auto* f32 = create<type::F32>();
auto* u32 = create<type::U32>();
auto* vec2_f32 = create<sem::Vector>(f32, 2u);
auto* vec2_f32 = create<type::Vector>(f32, 2u);
auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{vec2_f32, u32, vec2_f32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(result.sem, nullptr);
@@ -507,8 +507,8 @@ TEST_F(IntrinsicTableTest, MismatchOpenSizeVector) {
TEST_F(IntrinsicTableTest, MatchOpenSizeMatrix) {
auto* f32 = create<type::F32>();
auto* vec3_f32 = create<sem::Vector>(f32, 3u);
auto* mat3_f32 = create<sem::Matrix>(vec3_f32, 3u);
auto* vec3_f32 = create<type::Vector>(f32, 3u);
auto* mat3_f32 = create<type::Matrix>(vec3_f32, 3u);
auto result = table->Lookup(BuiltinType::kDeterminant, utils::Vector{mat3_f32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
@@ -521,8 +521,8 @@ TEST_F(IntrinsicTableTest, MatchOpenSizeMatrix) {
TEST_F(IntrinsicTableTest, MismatchOpenSizeMatrix) {
auto* f32 = create<type::F32>();
auto* vec2_f32 = create<sem::Vector>(f32, 2u);
auto* mat3x2_f32 = create<sem::Matrix>(vec2_f32, 3u);
auto* vec2_f32 = create<type::Vector>(f32, 2u);
auto* mat3x2_f32 = create<type::Matrix>(vec2_f32, 3u);
auto result = table->Lookup(BuiltinType::kDeterminant, utils::Vector{mat3x2_f32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(result.sem, nullptr);
@@ -669,7 +669,7 @@ TEST_F(IntrinsicTableTest, OverloadOrderByMatchingParameter) {
TEST_F(IntrinsicTableTest, SameOverloadReturnsSameBuiltinPointer) {
auto* f32 = create<type::F32>();
auto* vec2_f32 = create<sem::Vector>(create<type::F32>(), 2u);
auto* vec2_f32 = create<type::Vector>(create<type::F32>(), 2u);
auto* bool_ = create<type::Bool>();
auto a = table->Lookup(BuiltinType::kSelect, utils::Vector{f32, f32, bool_},
sem::EvaluationStage::kConstant, Source{});
@@ -692,7 +692,7 @@ TEST_F(IntrinsicTableTest, SameOverloadReturnsSameBuiltinPointer) {
TEST_F(IntrinsicTableTest, MatchUnaryOp) {
auto* i32 = create<type::I32>();
auto* vec3_i32 = create<sem::Vector>(i32, 3u);
auto* vec3_i32 = create<type::Vector>(i32, 3u);
auto result = table->Lookup(ast::UnaryOp::kNegation, vec3_i32, sem::EvaluationStage::kConstant,
Source{{12, 34}});
EXPECT_EQ(result.result, vec3_i32);
@@ -731,7 +731,7 @@ TEST_F(IntrinsicTableTest, MatchUnaryOp_Runtime) {
TEST_F(IntrinsicTableTest, MatchBinaryOp) {
auto* i32 = create<type::I32>();
auto* vec3_i32 = create<sem::Vector>(i32, 3u);
auto* vec3_i32 = create<type::Vector>(i32, 3u);
auto result = table->Lookup(ast::BinaryOp::kMultiply, i32, vec3_i32,
sem::EvaluationStage::kConstant, Source{{12, 34}},
/* is_compound */ false);
@@ -765,7 +765,7 @@ TEST_F(IntrinsicTableTest, MismatchBinaryOp) {
TEST_F(IntrinsicTableTest, MatchCompoundOp) {
auto* i32 = create<type::I32>();
auto* vec3_i32 = create<sem::Vector>(i32, 3u);
auto* vec3_i32 = create<type::Vector>(i32, 3u);
auto result = table->Lookup(ast::BinaryOp::kMultiply, i32, vec3_i32,
sem::EvaluationStage::kConstant, Source{{12, 34}},
/* is_compound */ true);
@@ -799,7 +799,7 @@ TEST_F(IntrinsicTableTest, MismatchCompoundOp) {
TEST_F(IntrinsicTableTest, MatchTypeInitializerImplicit) {
auto* i32 = create<type::I32>();
auto* vec3_i32 = create<sem::Vector>(i32, 3u);
auto* vec3_i32 = create<type::Vector>(i32, 3u);
auto result = table->Lookup(InitConvIntrinsic::kVec3, nullptr, utils::Vector{i32, i32, i32},
sem::EvaluationStage::kConstant, Source{{12, 34}});
ASSERT_NE(result.target, nullptr);
@@ -814,7 +814,7 @@ TEST_F(IntrinsicTableTest, MatchTypeInitializerImplicit) {
TEST_F(IntrinsicTableTest, MatchTypeInitializerExplicit) {
auto* i32 = create<type::I32>();
auto* vec3_i32 = create<sem::Vector>(i32, 3u);
auto* vec3_i32 = create<type::Vector>(i32, 3u);
auto result = table->Lookup(InitConvIntrinsic::kVec3, i32, utils::Vector{i32, i32, i32},
sem::EvaluationStage::kConstant, Source{{12, 34}});
ASSERT_NE(result.target, nullptr);
@@ -881,7 +881,7 @@ TEST_F(IntrinsicTableTest, MismatchTypeInitializerExplicit) {
TEST_F(IntrinsicTableTest, MatchTypeInitializerImplicitVecFromVecAbstract) {
auto* ai = create<type::AbstractInt>();
auto* vec3_ai = create<sem::Vector>(ai, 3u);
auto* vec3_ai = create<type::Vector>(ai, 3u);
auto result = table->Lookup(InitConvIntrinsic::kVec3, nullptr, utils::Vector{vec3_ai},
sem::EvaluationStage::kConstant, Source{{12, 34}});
ASSERT_NE(result.target, nullptr);
@@ -894,9 +894,9 @@ TEST_F(IntrinsicTableTest, MatchTypeInitializerImplicitVecFromVecAbstract) {
TEST_F(IntrinsicTableTest, MatchTypeInitializerImplicitMatFromVec) {
auto* af = create<type::AbstractFloat>();
auto* vec2_ai = create<sem::Vector>(create<type::AbstractInt>(), 2u);
auto* vec2_af = create<sem::Vector>(af, 2u);
auto* mat2x2_af = create<sem::Matrix>(vec2_af, 2u);
auto* vec2_ai = create<type::Vector>(create<type::AbstractInt>(), 2u);
auto* vec2_af = create<type::Vector>(af, 2u);
auto* mat2x2_af = create<type::Matrix>(vec2_af, 2u);
auto result =
table->Lookup(InitConvIntrinsic::kMat2x2, nullptr, utils::Vector{vec2_ai, vec2_ai},
sem::EvaluationStage::kConstant, Source{{12, 34}});
@@ -911,7 +911,7 @@ TEST_F(IntrinsicTableTest, MatchTypeInitializerImplicitMatFromVec) {
TEST_F(IntrinsicTableTest, MatchTypeInitializer_ConstantEval) {
auto* ai = create<type::AbstractInt>();
auto* vec3_ai = create<sem::Vector>(ai, 3u);
auto* vec3_ai = create<type::Vector>(ai, 3u);
auto result = table->Lookup(InitConvIntrinsic::kVec3, nullptr, utils::Vector{ai, ai, ai},
sem::EvaluationStage::kConstant, Source{{12, 34}});
ASSERT_NE(result.target, nullptr);
@@ -930,7 +930,7 @@ TEST_F(IntrinsicTableTest, MatchTypeInitializer_RuntimeEval) {
auto result = table->Lookup(InitConvIntrinsic::kVec3, nullptr, utils::Vector{ai, ai, ai},
sem::EvaluationStage::kRuntime, Source{{12, 34}});
auto* i32 = create<type::I32>();
auto* vec3_i32 = create<sem::Vector>(i32, 3u);
auto* vec3_i32 = create<type::Vector>(i32, 3u);
ASSERT_NE(result.target, nullptr);
EXPECT_EQ(result.target->Stage(), sem::EvaluationStage::kConstant);
EXPECT_EQ(result.target->ReturnType(), vec3_i32);
@@ -944,9 +944,9 @@ TEST_F(IntrinsicTableTest, MatchTypeInitializer_RuntimeEval) {
TEST_F(IntrinsicTableTest, MatchTypeConversion) {
auto* i32 = create<type::I32>();
auto* vec3_i32 = create<sem::Vector>(i32, 3u);
auto* vec3_i32 = create<type::Vector>(i32, 3u);
auto* f32 = create<type::F32>();
auto* vec3_f32 = create<sem::Vector>(f32, 3u);
auto* vec3_f32 = create<type::Vector>(f32, 3u);
auto result = table->Lookup(InitConvIntrinsic::kVec3, i32, utils::Vector{vec3_f32},
sem::EvaluationStage::kConstant, Source{{12, 34}});
ASSERT_NE(result.target, nullptr);
@@ -986,9 +986,9 @@ TEST_F(IntrinsicTableTest, MismatchTypeConversion) {
TEST_F(IntrinsicTableTest, MatchTypeConversion_ConstantEval) {
auto* ai = create<type::AbstractInt>();
auto* af = create<type::AbstractFloat>();
auto* vec3_ai = create<sem::Vector>(ai, 3u);
auto* vec3_ai = create<type::Vector>(ai, 3u);
auto* f32 = create<type::F32>();
auto* vec3_f32 = create<sem::Vector>(f32, 3u);
auto* vec3_f32 = create<type::Vector>(f32, 3u);
auto result = table->Lookup(InitConvIntrinsic::kVec3, af, utils::Vector{vec3_ai},
sem::EvaluationStage::kConstant, Source{{12, 34}});
ASSERT_NE(result.target, nullptr);
@@ -1003,9 +1003,9 @@ TEST_F(IntrinsicTableTest, MatchTypeConversion_ConstantEval) {
TEST_F(IntrinsicTableTest, MatchTypeConversion_RuntimeEval) {
auto* ai = create<type::AbstractInt>();
auto* af = create<type::AbstractFloat>();
auto* vec3_ai = create<sem::Vector>(ai, 3u);
auto* vec3_f32 = create<sem::Vector>(create<type::F32>(), 3u);
auto* vec3_i32 = create<sem::Vector>(create<type::I32>(), 3u);
auto* vec3_ai = create<type::Vector>(ai, 3u);
auto* vec3_f32 = create<type::Vector>(create<type::F32>(), 3u);
auto* vec3_i32 = create<type::Vector>(create<type::I32>(), 3u);
auto result = table->Lookup(InitConvIntrinsic::kVec3, af, utils::Vector{vec3_ai},
sem::EvaluationStage::kRuntime, Source{{12, 34}});
ASSERT_NE(result.target, nullptr);

90
src/tint/resolver/is_host_shareable_test.cc
View File

@@ -39,59 +39,59 @@ TEST_F(ResolverIsHostShareable, NumericScalar) {
}
TEST_F(ResolverIsHostShareable, NumericVector) {
EXPECT_TRUE(r()->IsHostShareable(create<sem::Vector>(create<type::I32>(), 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Vector>(create<type::I32>(), 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Vector>(create<type::I32>(), 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Vector>(create<type::U32>(), 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Vector>(create<type::U32>(), 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Vector>(create<type::U32>(), 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Vector>(create<type::F32>(), 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Vector>(create<type::F32>(), 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Vector>(create<type::F32>(), 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Vector>(create<type::F16>(), 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Vector>(create<type::F16>(), 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Vector>(create<type::F16>(), 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::I32>(), 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::I32>(), 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::I32>(), 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::U32>(), 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::U32>(), 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::U32>(), 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::F32>(), 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::F32>(), 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::F32>(), 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::F16>(), 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::F16>(), 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::F16>(), 4u)));
}
TEST_F(ResolverIsHostShareable, BoolVector) {
EXPECT_FALSE(r()->IsHostShareable(create<sem::Vector>(create<type::Bool>(), 2u)));
EXPECT_FALSE(r()->IsHostShareable(create<sem::Vector>(create<type::Bool>(), 3u)));
EXPECT_FALSE(r()->IsHostShareable(create<sem::Vector>(create<type::Bool>(), 4u)));
EXPECT_FALSE(r()->IsHostShareable(create<sem::Vector>(create<type::Bool>(), 2u)));
EXPECT_FALSE(r()->IsHostShareable(create<sem::Vector>(create<type::Bool>(), 3u)));
EXPECT_FALSE(r()->IsHostShareable(create<sem::Vector>(create<type::Bool>(), 4u)));
EXPECT_FALSE(r()->IsHostShareable(create<sem::Vector>(create<type::Bool>(), 2u)));
EXPECT_FALSE(r()->IsHostShareable(create<sem::Vector>(create<type::Bool>(), 3u)));
EXPECT_FALSE(r()->IsHostShareable(create<sem::Vector>(create<type::Bool>(), 4u)));
EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 2u)));
EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 3u)));
EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 4u)));
EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 2u)));
EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 3u)));
EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 4u)));
EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 2u)));
EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 3u)));
EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 4u)));
}
TEST_F(ResolverIsHostShareable, Matrix) {
auto* vec2_f32 = create<sem::Vector>(create<type::F32>(), 2u);
auto* vec3_f32 = create<sem::Vector>(create<type::F32>(), 3u);
auto* vec4_f32 = create<sem::Vector>(create<type::F32>(), 4u);
auto* vec2_f16 = create<sem::Vector>(create<type::F16>(), 2u);
auto* vec3_f16 = create<sem::Vector>(create<type::F16>(), 3u);
auto* vec4_f16 = create<sem::Vector>(create<type::F16>(), 4u);
auto* vec2_f32 = create<type::Vector>(create<type::F32>(), 2u);
auto* vec3_f32 = create<type::Vector>(create<type::F32>(), 3u);
auto* vec4_f32 = create<type::Vector>(create<type::F32>(), 4u);
auto* vec2_f16 = create<type::Vector>(create<type::F16>(), 2u);
auto* vec3_f16 = create<type::Vector>(create<type::F16>(), 3u);
auto* vec4_f16 = create<type::Vector>(create<type::F16>(), 4u);
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec2_f32, 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec2_f32, 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec2_f32, 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec3_f32, 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec3_f32, 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec3_f32, 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec4_f32, 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec4_f32, 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec4_f32, 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec2_f32, 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec2_f32, 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec2_f32, 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec3_f32, 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec3_f32, 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec3_f32, 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec4_f32, 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec4_f32, 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec4_f32, 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec2_f16, 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec2_f16, 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec2_f16, 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec3_f16, 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec3_f16, 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec3_f16, 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec4_f16, 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec4_f16, 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<sem::Matrix>(vec4_f16, 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec2_f16, 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec2_f16, 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec2_f16, 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec3_f16, 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec3_f16, 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec3_f16, 4u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec4_f16, 2u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec4_f16, 3u)));
EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec4_f16, 4u)));
}
TEST_F(ResolverIsHostShareable, Pointer) {

72
src/tint/resolver/is_storeable_test.cc
View File

@@ -36,45 +36,45 @@ TEST_F(ResolverIsStorableTest, Scalar) {
}
TEST_F(ResolverIsStorableTest, Vector) {
EXPECT_TRUE(r()->IsStorable(create<sem::Vector>(create<type::I32>(), 2u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Vector>(create<type::I32>(), 3u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Vector>(create<type::I32>(), 4u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Vector>(create<type::U32>(), 2u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Vector>(create<type::U32>(), 3u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Vector>(create<type::U32>(), 4u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Vector>(create<type::F32>(), 2u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Vector>(create<type::F32>(), 3u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Vector>(create<type::F32>(), 4u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Vector>(create<type::F16>(), 2u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Vector>(create<type::F16>(), 3u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Vector>(create<type::F16>(), 4u)));
EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::I32>(), 2u)));
EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::I32>(), 3u)));
EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::I32>(), 4u)));
EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::U32>(), 2u)));
EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::U32>(), 3u)));
EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::U32>(), 4u)));
EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::F32>(), 2u)));
EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::F32>(), 3u)));
EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::F32>(), 4u)));
EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::F16>(), 2u)));
EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::F16>(), 3u)));
EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::F16>(), 4u)));
}
TEST_F(ResolverIsStorableTest, Matrix) {
auto* vec2_f32 = create<sem::Vector>(create<type::F32>(), 2u);
auto* vec3_f32 = create<sem::Vector>(create<type::F32>(), 3u);
auto* vec4_f32 = create<sem::Vector>(create<type::F32>(), 4u);
auto* vec2_f16 = create<sem::Vector>(create<type::F16>(), 2u);
auto* vec3_f16 = create<sem::Vector>(create<type::F16>(), 3u);
auto* vec4_f16 = create<sem::Vector>(create<type::F16>(), 4u);
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec2_f32, 2u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec2_f32, 3u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec2_f32, 4u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec3_f32, 2u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec3_f32, 3u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec3_f32, 4u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec4_f32, 2u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec4_f32, 3u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec4_f32, 4u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec2_f16, 2u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec2_f16, 3u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec2_f16, 4u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec3_f16, 2u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec3_f16, 3u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec3_f16, 4u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec4_f16, 2u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec4_f16, 3u)));
EXPECT_TRUE(r()->IsStorable(create<sem::Matrix>(vec4_f16, 4u)));
auto* vec2_f32 = create<type::Vector>(create<type::F32>(), 2u);
auto* vec3_f32 = create<type::Vector>(create<type::F32>(), 3u);
auto* vec4_f32 = create<type::Vector>(create<type::F32>(), 4u);
auto* vec2_f16 = create<type::Vector>(create<type::F16>(), 2u);
auto* vec3_f16 = create<type::Vector>(create<type::F16>(), 3u);
auto* vec4_f16 = create<type::Vector>(create<type::F16>(), 4u);
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec2_f32, 2u)));
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec2_f32, 3u)));
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec2_f32, 4u)));
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec3_f32, 2u)));
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec3_f32, 3u)));
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec3_f32, 4u)));
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec4_f32, 2u)));
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec4_f32, 3u)));
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec4_f32, 4u)));
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec2_f16, 2u)));
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec2_f16, 3u)));
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec2_f16, 4u)));
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec3_f16, 2u)));
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec3_f16, 3u)));
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec3_f16, 4u)));
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec4_f16, 2u)));
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec4_f16, 3u)));
EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec4_f16, 4u)));
}
TEST_F(ResolverIsStorableTest, Pointer) {

48
src/tint/resolver/materialize_test.cc
View File

@@ -96,7 +96,7 @@ class MaterializeTest : public resolver::ResolverTestWithParam<CASE> {
tint::Switch(
expected_sem_ty, //
[&](const sem::Vector* v) {
[&](const type::Vector* v) {
for (uint32_t i = 0; i < v->Width(); i++) {
auto* el = value->Index(i);
ASSERT_NE(el, nullptr);
@@ -104,7 +104,7 @@ class MaterializeTest : public resolver::ResolverTestWithParam<CASE> {
EXPECT_EQ(std::get<T>(el->Value()), expected_value);
}
},
[&](const sem::Matrix* m) {
[&](const type::Matrix* m) {
for (uint32_t c = 0; c < m->columns(); c++) {
auto* column = value->Index(c);
ASSERT_NE(column, nullptr);
@@ -1270,13 +1270,13 @@ TEST_F(MaterializeAbstractStructure, Modf_Vector_DefaultType) {
auto* materialize = sem->As<sem::Materialize>();
ASSERT_TRUE(materialize->Type()->Is<sem::Struct>());
auto* concrete_str = materialize->Type()->As<sem::Struct>();
ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<sem::Vector>());
ASSERT_TRUE(concrete_str->Members()[0]->Type()->As<sem::Vector>()->type()->Is<type::F32>());
ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::Vector>());
ASSERT_TRUE(concrete_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
ASSERT_TRUE(materialize->Expr()->Type()->Is<sem::Struct>());
auto* abstract_str = materialize->Expr()->Type()->As<sem::Struct>();
ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<sem::Vector>());
ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::Vector>());
ASSERT_TRUE(
abstract_str->Members()[0]->Type()->As<sem::Vector>()->type()->Is<type::AbstractFloat>());
abstract_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::AbstractFloat>());
}
TEST_F(MaterializeAbstractStructure, Modf_Scalar_ExplicitType) {
@@ -1311,13 +1311,13 @@ TEST_F(MaterializeAbstractStructure, Modf_Vector_ExplicitType) {
auto* materialize = sem->As<sem::Materialize>();
ASSERT_TRUE(materialize->Type()->Is<sem::Struct>());
auto* concrete_str = materialize->Type()->As<sem::Struct>();
ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<sem::Vector>());
ASSERT_TRUE(concrete_str->Members()[0]->Type()->As<sem::Vector>()->type()->Is<type::F16>());
ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::Vector>());
ASSERT_TRUE(concrete_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::F16>());
ASSERT_TRUE(materialize->Expr()->Type()->Is<sem::Struct>());
auto* abstract_str = materialize->Expr()->Type()->As<sem::Struct>();
ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<sem::Vector>());
ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::Vector>());
ASSERT_TRUE(
abstract_str->Members()[0]->Type()->As<sem::Vector>()->type()->Is<type::AbstractFloat>());
abstract_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::AbstractFloat>());
}
TEST_F(MaterializeAbstractStructure, Frexp_Scalar_DefaultType) {
@@ -1348,17 +1348,17 @@ TEST_F(MaterializeAbstractStructure, Frexp_Vector_DefaultType) {
auto* materialize = sem->As<sem::Materialize>();
ASSERT_TRUE(materialize->Type()->Is<sem::Struct>());
auto* concrete_str = materialize->Type()->As<sem::Struct>();
ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<sem::Vector>());
ASSERT_TRUE(concrete_str->Members()[1]->Type()->Is<sem::Vector>());
ASSERT_TRUE(concrete_str->Members()[0]->Type()->As<sem::Vector>()->type()->Is<type::F32>());
ASSERT_TRUE(concrete_str->Members()[1]->Type()->As<sem::Vector>()->type()->Is<type::I32>());
ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::Vector>());
ASSERT_TRUE(concrete_str->Members()[1]->Type()->Is<type::Vector>());
ASSERT_TRUE(concrete_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
ASSERT_TRUE(concrete_str->Members()[1]->Type()->As<type::Vector>()->type()->Is<type::I32>());
ASSERT_TRUE(materialize->Expr()->Type()->Is<sem::Struct>());
auto* abstract_str = materialize->Expr()->Type()->As<sem::Struct>();
ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<sem::Vector>());
ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::Vector>());
ASSERT_TRUE(
abstract_str->Members()[0]->Type()->As<sem::Vector>()->type()->Is<type::AbstractFloat>());
abstract_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::AbstractFloat>());
ASSERT_TRUE(
abstract_str->Members()[1]->Type()->As<sem::Vector>()->type()->Is<type::AbstractInt>());
abstract_str->Members()[1]->Type()->As<type::Vector>()->type()->Is<type::AbstractInt>());
}
TEST_F(MaterializeAbstractStructure, Frexp_Scalar_ExplicitType) {
@@ -1395,17 +1395,17 @@ TEST_F(MaterializeAbstractStructure, Frexp_Vector_ExplicitType) {
auto* materialize = sem->As<sem::Materialize>();
ASSERT_TRUE(materialize->Type()->Is<sem::Struct>());
auto* concrete_str = materialize->Type()->As<sem::Struct>();
ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<sem::Vector>());
ASSERT_TRUE(concrete_str->Members()[1]->Type()->Is<sem::Vector>());
ASSERT_TRUE(concrete_str->Members()[0]->Type()->As<sem::Vector>()->type()->Is<type::F16>());
ASSERT_TRUE(concrete_str->Members()[1]->Type()->As<sem::Vector>()->type()->Is<type::I32>());
ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::Vector>());
ASSERT_TRUE(concrete_str->Members()[1]->Type()->Is<type::Vector>());
ASSERT_TRUE(concrete_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::F16>());
ASSERT_TRUE(concrete_str->Members()[1]->Type()->As<type::Vector>()->type()->Is<type::I32>());
ASSERT_TRUE(materialize->Expr()->Type()->Is<sem::Struct>());
auto* abstract_str = materialize->Expr()->Type()->As<sem::Struct>();
ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<sem::Vector>());
ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::Vector>());
ASSERT_TRUE(
abstract_str->Members()[0]->Type()->As<sem::Vector>()->type()->Is<type::AbstractFloat>());
abstract_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::AbstractFloat>());
ASSERT_TRUE(
abstract_str->Members()[1]->Type()->As<sem::Vector>()->type()->Is<type::AbstractInt>());
abstract_str->Members()[1]->Type()->As<type::Vector>()->type()->Is<type::AbstractInt>());
}
} // namespace materialize_abstract_structure

62
src/tint/resolver/resolver.cc
View File

@@ -216,13 +216,13 @@ type::Type* Resolver::Type(const ast::Type* ty) {
return builder_->create<type::F16>();
},
[&](const ast::F32*) { return builder_->create<type::F32>(); },
[&](const ast::Vector* t) -> sem::Vector* {
[&](const ast::Vector* t) -> type::Vector* {
if (!t->type) {
AddError("missing vector element type", t->source.End());
return nullptr;
}
if (auto* el = Type(t->type)) {
if (auto* vector = builder_->create<sem::Vector>(el, t->width)) {
if (auto* vector = builder_->create<type::Vector>(el, t->width)) {
if (validator_.Vector(vector, t->source)) {
return vector;
}
@@ -230,14 +230,14 @@ type::Type* Resolver::Type(const ast::Type* ty) {
}
return nullptr;
},
[&](const ast::Matrix* t) -> sem::Matrix* {
[&](const ast::Matrix* t) -> type::Matrix* {
if (!t->type) {
AddError("missing matrix element type", t->source.End());
return nullptr;
}
if (auto* el = Type(t->type)) {
if (auto* column_type = builder_->create<sem::Vector>(el, t->rows)) {
if (auto* matrix = builder_->create<sem::Matrix>(column_type, t->columns)) {
if (auto* column_type = builder_->create<type::Vector>(el, t->rows)) {
if (auto* matrix = builder_->create<type::Matrix>(column_type, t->columns)) {
if (validator_.Matrix(matrix, t->source)) {
return matrix;
}
@@ -1718,17 +1718,17 @@ const type::Type* Resolver::ConcreteType(const type::Type* ty,
const Source& source) {
auto i32 = [&] { return builder_->create<type::I32>(); };
auto f32 = [&] { return builder_->create<type::F32>(); };
auto i32v = [&](uint32_t width) { return builder_->create<sem::Vector>(i32(), width); };
auto f32v = [&](uint32_t width) { return builder_->create<sem::Vector>(f32(), width); };
auto i32v = [&](uint32_t width) { return builder_->create<type::Vector>(i32(), width); };
auto f32v = [&](uint32_t width) { return builder_->create<type::Vector>(f32(), width); };
auto f32m = [&](uint32_t columns, uint32_t rows) {
return builder_->create<sem::Matrix>(f32v(rows), columns);
return builder_->create<type::Matrix>(f32v(rows), columns);
};
return Switch(
ty, //
[&](const type::AbstractInt*) { return target_ty ? target_ty : i32(); },
[&](const type::AbstractFloat*) { return target_ty ? target_ty : f32(); },
[&](const sem::Vector* v) {
[&](const type::Vector* v) {
return Switch(
v->type(), //
[&](const type::AbstractInt*) { return target_ty ? target_ty : i32v(v->Width()); },
@@ -1736,7 +1736,7 @@ const type::Type* Resolver::ConcreteType(const type::Type* ty,
return target_ty ? target_ty : f32v(v->Width());
});
},
[&](const sem::Matrix* m) {
[&](const type::Matrix* m) {
return Switch(m->type(), //
[&](const type::AbstractFloat*) {
return target_ty ? target_ty : f32m(m->columns(), m->rows());
@@ -1870,9 +1870,9 @@ sem::Expression* Resolver::IndexAccessor(const ast::IndexAccessorExpression* exp
auto* ty = Switch(
obj_ty, //
[&](const sem::Array* arr) { return arr->ElemType(); },
[&](const sem::Vector* vec) { return vec->type(); },
[&](const sem::Matrix* mat) {
return builder_->create<sem::Vector>(mat->type(), mat->rows());
[&](const type::Vector* vec) { return vec->type(); },
[&](const type::Matrix* mat) {
return builder_->create<type::Vector>(mat->type(), mat->rows());
},
[&](Default) {
AddError("cannot index type '" + sem_.TypeNameOf(obj_ty) + "'", expr->source);
@@ -2034,10 +2034,10 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) {
auto ty_init_or_conv = [&](const type::Type* ty) {
return Switch(
ty, //
[&](const sem::Vector* v) {
[&](const type::Vector* v) {
return ct_init_or_conv(VectorInitConvIntrinsic(v->Width()), v->type());
},
[&](const sem::Matrix* m) {
[&](const type::Matrix* m) {
return ct_init_or_conv(MatrixInitConvIntrinsic(m->columns(), m->rows()), m->type());
},
[&](const type::I32*) { return ct_init_or_conv(InitConvIntrinsic::kI32, nullptr); },
@@ -2351,29 +2351,29 @@ type::Type* Resolver::BuiltinTypeAlias(Symbol sym) const {
auto& b = *builder_;
switch (type::ParseShortName(name)) {
case type::ShortName::kVec2F:
return b.create<sem::Vector>(b.create<type::F32>(), 2u);
return b.create<type::Vector>(b.create<type::F32>(), 2u);
case type::ShortName::kVec3F:
return b.create<sem::Vector>(b.create<type::F32>(), 3u);
return b.create<type::Vector>(b.create<type::F32>(), 3u);
case type::ShortName::kVec4F:
return b.create<sem::Vector>(b.create<type::F32>(), 4u);
return b.create<type::Vector>(b.create<type::F32>(), 4u);
case type::ShortName::kVec2H:
return b.create<sem::Vector>(b.create<type::F16>(), 2u);
return b.create<type::Vector>(b.create<type::F16>(), 2u);
case type::ShortName::kVec3H:
return b.create<sem::Vector>(b.create<type::F16>(), 3u);
return b.create<type::Vector>(b.create<type::F16>(), 3u);
case type::ShortName::kVec4H:
return b.create<sem::Vector>(b.create<type::F16>(), 4u);
return b.create<type::Vector>(b.create<type::F16>(), 4u);
case type::ShortName::kVec2I:
return b.create<sem::Vector>(b.create<type::I32>(), 2u);
return b.create<type::Vector>(b.create<type::I32>(), 2u);
case type::ShortName::kVec3I:
return b.create<sem::Vector>(b.create<type::I32>(), 3u);
return b.create<type::Vector>(b.create<type::I32>(), 3u);
case type::ShortName::kVec4I:
return b.create<sem::Vector>(b.create<type::I32>(), 4u);
return b.create<type::Vector>(b.create<type::I32>(), 4u);
case type::ShortName::kVec2U:
return b.create<sem::Vector>(b.create<type::U32>(), 2u);
return b.create<type::Vector>(b.create<type::U32>(), 2u);
case type::ShortName::kVec3U:
return b.create<sem::Vector>(b.create<type::U32>(), 3u);
return b.create<type::Vector>(b.create<type::U32>(), 3u);
case type::ShortName::kVec4U:
return b.create<sem::Vector>(b.create<type::U32>(), 4u);
return b.create<type::Vector>(b.create<type::U32>(), 4u);
case type::ShortName::kUndefined:
break;
}
@@ -2677,7 +2677,7 @@ sem::Expression* Resolver::MemberAccessor(const ast::MemberAccessorExpression* e
has_side_effects, root_ident);
},
[&](const sem::Vector* vec) -> sem::Expression* {
[&](const type::Vector* vec) -> sem::Expression* {
Mark(expr->member);
std::string s = builder_->Symbols().NameFor(expr->member->symbol);
auto size = s.size();
@@ -2739,7 +2739,7 @@ sem::Expression* Resolver::MemberAccessor(const ast::MemberAccessorExpression* e
} else {
// The vector will have a number of components equal to the length of
// the swizzle.
ty = builder_->create<sem::Vector>(vec->type(), static_cast<uint32_t>(size));
ty = builder_->create<type::Vector>(vec->type(), static_cast<uint32_t>(size));
}
auto val = const_eval_.Swizzle(ty, object, swizzle);
if (!val) {
@@ -2837,8 +2837,8 @@ sem::Expression* Resolver::UnaryOp(const ast::UnaryOpExpression* unary) {
auto* array = unary->expr->As<ast::IndexAccessorExpression>();
auto* member = unary->expr->As<ast::MemberAccessorExpression>();
if ((array && sem_.TypeOf(array->object)->UnwrapRef()->Is<sem::Vector>()) ||
(member && sem_.TypeOf(member->structure)->UnwrapRef()->Is<sem::Vector>())) {
if ((array && sem_.TypeOf(array->object)->UnwrapRef()->Is<type::Vector>()) ||
(member && sem_.TypeOf(member->structure)->UnwrapRef()->Is<type::Vector>())) {
AddError("cannot take the address of a vector component", unary->expr->source);
return nullptr;
}

48
src/tint/resolver/resolver_test.cc
View File

@@ -669,9 +669,9 @@ TEST_F(ResolverTest, Expr_Initializer_Type_Vec2) {
EXPECT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 2u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
}
TEST_F(ResolverTest, Expr_Initializer_Type_Vec3) {
@@ -681,9 +681,9 @@ TEST_F(ResolverTest, Expr_Initializer_Type_Vec3) {
EXPECT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 3u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
}
TEST_F(ResolverTest, Expr_Initializer_Type_Vec4) {
@@ -693,9 +693,9 @@ TEST_F(ResolverTest, Expr_Initializer_Type_Vec4) {
EXPECT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
}
TEST_F(ResolverTest, Expr_Identifier_GlobalVariable) {
@@ -1294,9 +1294,9 @@ TEST_F(ResolverTest, Expr_MemberAccessor_VectorSwizzle) {
EXPECT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(mem), nullptr);
ASSERT_TRUE(TypeOf(mem)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(mem)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(mem)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(mem)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(mem)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(mem)->As<type::Vector>()->Width(), 4u);
auto* sma = Sem().Get(mem)->As<sem::Swizzle>();
ASSERT_NE(sma, nullptr);
EXPECT_EQ(sma->Object()->Declaration(), mem->structure);
@@ -1349,9 +1349,9 @@ TEST_F(ResolverTest, Expr_Accessor_MultiLevel) {
EXPECT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(mem), nullptr);
ASSERT_TRUE(TypeOf(mem)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(mem)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(mem)->As<sem::Vector>()->Width(), 2u);
ASSERT_TRUE(TypeOf(mem)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(mem)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(mem)->As<type::Vector>()->Width(), 2u);
ASSERT_TRUE(Sem().Get(mem)->Is<sem::Swizzle>());
}
@@ -1773,12 +1773,12 @@ TEST_P(Expr_Binary_Test_Invalid_VectorMatrixMultiply, All) {
if (vec_by_mat) {
lhs_type = ty.vec<f32>(vec_size);
rhs_type = ty.mat<f32>(mat_cols, mat_rows);
result_type = create<sem::Vector>(create<type::F32>(), mat_cols);
result_type = create<type::Vector>(create<type::F32>(), mat_cols);
is_valid_expr = vec_size == mat_rows;
} else {
lhs_type = ty.mat<f32>(mat_cols, mat_rows);
rhs_type = ty.vec<f32>(vec_size);
result_type = create<sem::Vector>(create<type::F32>(), mat_rows);
result_type = create<type::Vector>(create<type::F32>(), mat_rows);
is_valid_expr = vec_size == mat_cols;
}
@@ -1816,8 +1816,8 @@ TEST_P(Expr_Binary_Test_Invalid_MatrixMatrixMultiply, All) {
auto* rhs_type = ty.mat<f32>(rhs_mat_cols, rhs_mat_rows);
auto* f32 = create<type::F32>();
auto* col = create<sem::Vector>(f32, lhs_mat_rows);
auto* result_type = create<sem::Matrix>(col, rhs_mat_cols);
auto* col = create<type::Vector>(f32, lhs_mat_rows);
auto* result_type = create<type::Matrix>(col, rhs_mat_cols);
GlobalVar("lhs", lhs_type, ast::AddressSpace::kPrivate);
GlobalVar("rhs", rhs_type, ast::AddressSpace::kPrivate);
@@ -1860,15 +1860,15 @@ TEST_P(UnaryOpExpressionTest, Expr_UnaryOp) {
EXPECT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(der), nullptr);
ASSERT_TRUE(TypeOf(der)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(der)->Is<type::Vector>());
if (op == ast::UnaryOp::kNot) {
EXPECT_TRUE(TypeOf(der)->As<sem::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(der)->As<type::Vector>()->type()->Is<type::Bool>());
} else if (op == ast::UnaryOp::kNegation || op == ast::UnaryOp::kComplement) {
EXPECT_TRUE(TypeOf(der)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(der)->As<type::Vector>()->type()->Is<type::I32>());
} else {
EXPECT_TRUE(TypeOf(der)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(der)->As<type::Vector>()->type()->Is<type::F32>());
}
EXPECT_EQ(TypeOf(der)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(der)->As<type::Vector>()->Width(), 4u);
}
INSTANTIATE_TEST_SUITE_P(ResolverTest,
UnaryOpExpressionTest,

6
src/tint/resolver/resolver_test_helper.h
View File

@@ -452,7 +452,7 @@ struct DataType<vec<N, T>> {
/// @param b the ProgramBuilder
/// @return the semantic vector type
static inline const type::Type* Sem(ProgramBuilder& b) {
return b.create<sem::Vector>(DataType<T>::Sem(b), N);
return b.create<type::Vector>(DataType<T>::Sem(b), N);
}
/// @param b the ProgramBuilder
/// @param args args of size 1 or N with values of type T to initialize with
@@ -500,8 +500,8 @@ struct DataType<mat<N, M, T>> {
/// @param b the ProgramBuilder
/// @return the semantic matrix type
static inline const type::Type* Sem(ProgramBuilder& b) {
auto* column_type = b.create<sem::Vector>(DataType<T>::Sem(b), M);
return b.create<sem::Matrix>(column_type, N);
auto* column_type = b.create<type::Vector>(DataType<T>::Sem(b), M);
return b.create<type::Matrix>(column_type, N);
}
/// @param b the ProgramBuilder
/// @param args args of size 1 or N*M with values of type T to initialize with

496
src/tint/resolver/type_initializer_validation_test.cc
View File

@@ -631,10 +631,10 @@ TEST_F(ResolverTypeInitializerValidationTest, InferredArrayU32_VecI32_VecAI) {
ASSERT_NE(ctor, nullptr);
EXPECT_EQ(call->Type(), ctor->ReturnType());
ASSERT_EQ(ctor->Parameters().Length(), 2u);
ASSERT_TRUE(ctor->Parameters()[0]->Type()->Is<sem::Vector>());
EXPECT_TRUE(ctor->Parameters()[0]->Type()->As<sem::Vector>()->type()->Is<type::I32>());
ASSERT_TRUE(ctor->Parameters()[1]->Type()->Is<sem::Vector>());
EXPECT_TRUE(ctor->Parameters()[1]->Type()->As<sem::Vector>()->type()->Is<type::I32>());
ASSERT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
EXPECT_TRUE(ctor->Parameters()[0]->Type()->As<type::Vector>()->type()->Is<type::I32>());
ASSERT_TRUE(ctor->Parameters()[1]->Type()->Is<type::Vector>());
EXPECT_TRUE(ctor->Parameters()[1]->Type()->As<type::Vector>()->type()->Is<type::I32>());
}
TEST_F(ResolverTypeInitializerValidationTest, InferredArrayU32_VecAI_VecF32) {
@@ -653,10 +653,10 @@ TEST_F(ResolverTypeInitializerValidationTest, InferredArrayU32_VecAI_VecF32) {
ASSERT_NE(ctor, nullptr);
EXPECT_EQ(call->Type(), ctor->ReturnType());
ASSERT_EQ(ctor->Parameters().Length(), 2u);
ASSERT_TRUE(ctor->Parameters()[0]->Type()->Is<sem::Vector>());
EXPECT_TRUE(ctor->Parameters()[0]->Type()->As<sem::Vector>()->type()->Is<type::F32>());
ASSERT_TRUE(ctor->Parameters()[1]->Type()->Is<sem::Vector>());
EXPECT_TRUE(ctor->Parameters()[1]->Type()->As<sem::Vector>()->type()->Is<type::F32>());
ASSERT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
EXPECT_TRUE(ctor->Parameters()[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
ASSERT_TRUE(ctor->Parameters()[1]->Type()->Is<type::Vector>());
EXPECT_TRUE(ctor->Parameters()[1]->Type()->As<type::Vector>()->type()->Is<type::F32>());
}
TEST_F(ResolverTypeInitializerValidationTest, ArrayArgumentTypeMismatch_U32F32) {
@@ -1141,9 +1141,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec2_Success_ZeroValue) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 2u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1160,9 +1160,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec2F32_Success_Scalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 2u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1183,9 +1183,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec2F16_Success_Scalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 2u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1204,9 +1204,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec2U32_Success_Scalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 2u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::U32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1225,9 +1225,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec2I32_Success_Scalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 2u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::I32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1246,9 +1246,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec2Bool_Success_Scalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::Bool>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 2u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::Bool>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1267,9 +1267,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec2_Success_Identity) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 2u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1277,7 +1277,7 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec2_Success_Identity) {
ASSERT_NE(ctor, nullptr);
EXPECT_EQ(call->Type(), ctor->ReturnType());
ASSERT_EQ(ctor->Parameters().Length(), 1u);
EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<sem::Vector>());
EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
}
TEST_F(ResolverTypeInitializerValidationTest, Vec2_Success_Vec2TypeConversion) {
@@ -1287,9 +1287,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec2_Success_Vec2TypeConversion) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 2u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1297,7 +1297,7 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec2_Success_Vec2TypeConversion) {
ASSERT_NE(ctor, nullptr);
EXPECT_EQ(call->Type(), ctor->ReturnType());
ASSERT_EQ(ctor->Parameters().Length(), 1u);
EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<sem::Vector>());
EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
}
TEST_F(ResolverTypeInitializerValidationTest, Vec3F32_Error_ScalarArgumentTypeMismatch) {
@@ -1416,9 +1416,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec3_Success_ZeroValue) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 3u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1435,9 +1435,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec3F32_Success_Scalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 3u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1459,9 +1459,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec3F16_Success_Scalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 3u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1481,9 +1481,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec3U32_Success_Scalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 3u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::U32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1503,9 +1503,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec3I32_Success_Scalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 3u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::I32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1525,9 +1525,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec3Bool_Success_Scalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::Bool>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 3u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::Bool>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1547,9 +1547,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec3_Success_Vec2AndScalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 3u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1557,7 +1557,7 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec3_Success_Vec2AndScalar) {
ASSERT_NE(ctor, nullptr);
EXPECT_EQ(call->Type(), ctor->ReturnType());
ASSERT_EQ(ctor->Parameters().Length(), 2u);
EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<sem::Vector>());
EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::F32>());
}
@@ -1568,9 +1568,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec3_Success_ScalarAndVec2) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 3u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1579,7 +1579,7 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec3_Success_ScalarAndVec2) {
EXPECT_EQ(call->Type(), ctor->ReturnType());
ASSERT_EQ(ctor->Parameters().Length(), 2u);
EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::F32>());
EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<sem::Vector>());
EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::Vector>());
}
TEST_F(ResolverTypeInitializerValidationTest, Vec3_Success_Identity) {
@@ -1589,9 +1589,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec3_Success_Identity) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 3u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1599,7 +1599,7 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec3_Success_Identity) {
ASSERT_NE(ctor, nullptr);
EXPECT_EQ(call->Type(), ctor->ReturnType());
ASSERT_EQ(ctor->Parameters().Length(), 1u);
EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<sem::Vector>());
EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
}
TEST_F(ResolverTypeInitializerValidationTest, Vec3_Success_Vec3TypeConversion) {
@@ -1609,9 +1609,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec3_Success_Vec3TypeConversion) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 3u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
auto* call = Sem().Get<sem::Call>(tc);
ASSERT_NE(call, nullptr);
@@ -1619,7 +1619,7 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec3_Success_Vec3TypeConversion) {
ASSERT_NE(ctor, nullptr);
EXPECT_EQ(call->Type(), ctor->ReturnType());
ASSERT_EQ(ctor->Parameters().Length(), 1u);
EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<sem::Vector>());
EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
}
TEST_F(ResolverTypeInitializerValidationTest, Vec4F32_Error_ScalarArgumentTypeMismatch) {
@@ -1781,9 +1781,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec4_Success_ZeroValue) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
}
TEST_F(ResolverTypeInitializerValidationTest, Vec4F32_Success_Scalar) {
@@ -1793,9 +1793,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec4F32_Success_Scalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
}
TEST_F(ResolverTypeInitializerValidationTest, Vec4F16_Success_Scalar) {
@@ -1807,9 +1807,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec4F16_Success_Scalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
}
TEST_F(ResolverTypeInitializerValidationTest, Vec4U32_Success_Scalar) {
@@ -1819,9 +1819,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec4U32_Success_Scalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::U32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
}
TEST_F(ResolverTypeInitializerValidationTest, Vec4I32_Success_Scalar) {
@@ -1831,9 +1831,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec4I32_Success_Scalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::I32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
}
TEST_F(ResolverTypeInitializerValidationTest, Vec4Bool_Success_Scalar) {
@@ -1843,9 +1843,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec4Bool_Success_Scalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::Bool>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::Bool>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
}
TEST_F(ResolverTypeInitializerValidationTest, Vec4_Success_Vec2ScalarScalar) {
@@ -1855,9 +1855,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec4_Success_Vec2ScalarScalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
}
TEST_F(ResolverTypeInitializerValidationTest, Vec4_Success_ScalarVec2Scalar) {
@@ -1867,9 +1867,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec4_Success_ScalarVec2Scalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
}
TEST_F(ResolverTypeInitializerValidationTest, Vec4_Success_ScalarScalarVec2) {
@@ -1879,9 +1879,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec4_Success_ScalarScalarVec2) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
}
TEST_F(ResolverTypeInitializerValidationTest, Vec4_Success_Vec2AndVec2) {
@@ -1891,9 +1891,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec4_Success_Vec2AndVec2) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
}
TEST_F(ResolverTypeInitializerValidationTest, Vec4_Success_Vec3AndScalar) {
@@ -1903,9 +1903,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec4_Success_Vec3AndScalar) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
}
TEST_F(ResolverTypeInitializerValidationTest, Vec4_Success_ScalarAndVec3) {
@@ -1915,9 +1915,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec4_Success_ScalarAndVec3) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
}
TEST_F(ResolverTypeInitializerValidationTest, Vec4_Success_Identity) {
@@ -1927,9 +1927,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec4_Success_Identity) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
}
TEST_F(ResolverTypeInitializerValidationTest, Vec4_Success_Vec4TypeConversion) {
@@ -1939,9 +1939,9 @@ TEST_F(ResolverTypeInitializerValidationTest, Vec4_Success_Vec4TypeConversion) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
}
TEST_F(ResolverTypeInitializerValidationTest, NestedVectorInitializers_InnerError) {
@@ -1961,9 +1961,9 @@ TEST_F(ResolverTypeInitializerValidationTest, NestedVectorInitializers_Success)
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(tc), nullptr);
ASSERT_TRUE(TypeOf(tc)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
}
TEST_F(ResolverTypeInitializerValidationTest, Vector_Alias_Argument_Error) {
@@ -2046,21 +2046,21 @@ TEST_F(ResolverTypeInitializerValidationTest, InferVec2ElementTypeFromScalars) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_TRUE(TypeOf(vec2_bool)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec2_i32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec2_u32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec2_f32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec2_f16)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(vec2_bool)->As<sem::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec2_i32)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec2_u32)->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec2_f32)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec2_f16)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec2_bool)->As<sem::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_i32)->As<sem::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_u32)->As<sem::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_f32)->As<sem::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_f16)->As<sem::Vector>()->Width(), 2u);
ASSERT_TRUE(TypeOf(vec2_bool)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec2_i32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec2_u32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec2_f32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec2_f16)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(vec2_bool)->As<type::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec2_i32)->As<type::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec2_u32)->As<type::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec2_f32)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec2_f16)->As<type::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec2_bool)->As<type::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_i32)->As<type::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_u32)->As<type::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_f32)->As<type::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_f16)->As<type::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_bool), TypeOf(vec2_bool->target.type));
EXPECT_EQ(TypeOf(vec2_i32), TypeOf(vec2_i32->target.type));
EXPECT_EQ(TypeOf(vec2_u32), TypeOf(vec2_u32->target.type));
@@ -2080,21 +2080,21 @@ TEST_F(ResolverTypeInitializerValidationTest, InferVec2ElementTypeFromVec2) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_TRUE(TypeOf(vec2_bool)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec2_i32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec2_u32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec2_f32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec2_f16)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(vec2_bool)->As<sem::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec2_i32)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec2_u32)->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec2_f32)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec2_f16)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec2_bool)->As<sem::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_i32)->As<sem::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_u32)->As<sem::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_f32)->As<sem::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_f16)->As<sem::Vector>()->Width(), 2u);
ASSERT_TRUE(TypeOf(vec2_bool)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec2_i32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec2_u32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec2_f32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec2_f16)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(vec2_bool)->As<type::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec2_i32)->As<type::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec2_u32)->As<type::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec2_f32)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec2_f16)->As<type::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec2_bool)->As<type::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_i32)->As<type::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_u32)->As<type::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_f32)->As<type::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_f16)->As<type::Vector>()->Width(), 2u);
EXPECT_EQ(TypeOf(vec2_bool), TypeOf(vec2_bool->target.type));
EXPECT_EQ(TypeOf(vec2_i32), TypeOf(vec2_i32->target.type));
EXPECT_EQ(TypeOf(vec2_u32), TypeOf(vec2_u32->target.type));
@@ -2115,21 +2115,21 @@ TEST_F(ResolverTypeInitializerValidationTest, InferVec3ElementTypeFromScalars) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_TRUE(TypeOf(vec3_bool)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec3_i32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec3_u32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec3_f32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec3_f16)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(vec3_bool)->As<sem::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec3_i32)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec3_u32)->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec3_f32)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec3_f16)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec3_bool)->As<sem::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_i32)->As<sem::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_u32)->As<sem::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_f32)->As<sem::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_f16)->As<sem::Vector>()->Width(), 3u);
ASSERT_TRUE(TypeOf(vec3_bool)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec3_i32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec3_u32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec3_f32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec3_f16)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(vec3_bool)->As<type::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec3_i32)->As<type::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec3_u32)->As<type::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec3_f32)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec3_f16)->As<type::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec3_bool)->As<type::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_i32)->As<type::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_u32)->As<type::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_f32)->As<type::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_f16)->As<type::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_bool), TypeOf(vec3_bool->target.type));
EXPECT_EQ(TypeOf(vec3_i32), TypeOf(vec3_i32->target.type));
EXPECT_EQ(TypeOf(vec3_u32), TypeOf(vec3_u32->target.type));
@@ -2149,21 +2149,21 @@ TEST_F(ResolverTypeInitializerValidationTest, InferVec3ElementTypeFromVec3) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_TRUE(TypeOf(vec3_bool)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec3_i32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec3_u32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec3_f32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec3_f16)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(vec3_bool)->As<sem::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec3_i32)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec3_u32)->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec3_f32)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec3_f16)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec3_bool)->As<sem::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_i32)->As<sem::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_u32)->As<sem::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_f32)->As<sem::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_f16)->As<sem::Vector>()->Width(), 3u);
ASSERT_TRUE(TypeOf(vec3_bool)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec3_i32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec3_u32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec3_f32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec3_f16)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(vec3_bool)->As<type::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec3_i32)->As<type::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec3_u32)->As<type::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec3_f32)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec3_f16)->As<type::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec3_bool)->As<type::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_i32)->As<type::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_u32)->As<type::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_f32)->As<type::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_f16)->As<type::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_bool), TypeOf(vec3_bool->target.type));
EXPECT_EQ(TypeOf(vec3_i32), TypeOf(vec3_i32->target.type));
EXPECT_EQ(TypeOf(vec3_u32), TypeOf(vec3_u32->target.type));
@@ -2184,21 +2184,21 @@ TEST_F(ResolverTypeInitializerValidationTest, InferVec3ElementTypeFromScalarAndV
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_TRUE(TypeOf(vec3_bool)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec3_i32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec3_u32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec3_f32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec3_f16)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(vec3_bool)->As<sem::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec3_i32)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec3_u32)->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec3_f32)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec3_f16)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec3_bool)->As<sem::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_i32)->As<sem::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_u32)->As<sem::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_f32)->As<sem::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_f16)->As<sem::Vector>()->Width(), 3u);
ASSERT_TRUE(TypeOf(vec3_bool)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec3_i32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec3_u32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec3_f32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec3_f16)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(vec3_bool)->As<type::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec3_i32)->As<type::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec3_u32)->As<type::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec3_f32)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec3_f16)->As<type::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec3_bool)->As<type::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_i32)->As<type::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_u32)->As<type::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_f32)->As<type::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_f16)->As<type::Vector>()->Width(), 3u);
EXPECT_EQ(TypeOf(vec3_bool), TypeOf(vec3_bool->target.type));
EXPECT_EQ(TypeOf(vec3_i32), TypeOf(vec3_i32->target.type));
EXPECT_EQ(TypeOf(vec3_u32), TypeOf(vec3_u32->target.type));
@@ -2223,21 +2223,21 @@ TEST_F(ResolverTypeInitializerValidationTest, InferVec4ElementTypeFromScalars) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_TRUE(TypeOf(vec4_bool)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec4_i32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec4_u32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec4_f32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec4_f16)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(vec4_bool)->As<sem::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec4_i32)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec4_u32)->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec4_f32)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec4_f16)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec4_bool)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_i32)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_u32)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_f32)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_f16)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(vec4_bool)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec4_i32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec4_u32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec4_f32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec4_f16)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(vec4_bool)->As<type::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec4_i32)->As<type::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec4_u32)->As<type::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec4_f32)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec4_f16)->As<type::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec4_bool)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_i32)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_u32)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_f32)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_f16)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_bool), TypeOf(vec4_bool->target.type));
EXPECT_EQ(TypeOf(vec4_i32), TypeOf(vec4_i32->target.type));
EXPECT_EQ(TypeOf(vec4_u32), TypeOf(vec4_u32->target.type));
@@ -2258,21 +2258,21 @@ TEST_F(ResolverTypeInitializerValidationTest, InferVec4ElementTypeFromVec4) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_TRUE(TypeOf(vec4_bool)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec4_i32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec4_u32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec4_f32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec4_f16)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(vec4_bool)->As<sem::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec4_i32)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec4_u32)->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec4_f32)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec4_f16)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec4_bool)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_i32)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_u32)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_f32)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_f16)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(vec4_bool)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec4_i32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec4_u32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec4_f32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec4_f16)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(vec4_bool)->As<type::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec4_i32)->As<type::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec4_u32)->As<type::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec4_f32)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec4_f16)->As<type::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec4_bool)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_i32)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_u32)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_f32)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_f16)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_bool), TypeOf(vec4_bool->target.type));
EXPECT_EQ(TypeOf(vec4_i32), TypeOf(vec4_i32->target.type));
EXPECT_EQ(TypeOf(vec4_u32), TypeOf(vec4_u32->target.type));
@@ -2297,21 +2297,21 @@ TEST_F(ResolverTypeInitializerValidationTest, InferVec4ElementTypeFromScalarAndV
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_TRUE(TypeOf(vec4_bool)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec4_i32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec4_u32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec4_f32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec4_f16)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(vec4_bool)->As<sem::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec4_i32)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec4_u32)->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec4_f32)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec4_f16)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec4_bool)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_i32)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_u32)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_f32)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_f16)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(vec4_bool)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec4_i32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec4_u32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec4_f32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec4_f16)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(vec4_bool)->As<type::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec4_i32)->As<type::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec4_u32)->As<type::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec4_f32)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec4_f16)->As<type::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec4_bool)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_i32)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_u32)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_f32)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_f16)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_bool), TypeOf(vec4_bool->target.type));
EXPECT_EQ(TypeOf(vec4_i32), TypeOf(vec4_i32->target.type));
EXPECT_EQ(TypeOf(vec4_u32), TypeOf(vec4_u32->target.type));
@@ -2336,21 +2336,21 @@ TEST_F(ResolverTypeInitializerValidationTest, InferVec4ElementTypeFromVec2AndVec
ASSERT_TRUE(r()->Resolve()) << r()->error();
ASSERT_TRUE(TypeOf(vec4_bool)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec4_i32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec4_u32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec4_f32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(vec4_f16)->Is<sem::Vector>());
EXPECT_TRUE(TypeOf(vec4_bool)->As<sem::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec4_i32)->As<sem::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec4_u32)->As<sem::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec4_f32)->As<sem::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec4_f16)->As<sem::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec4_bool)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_i32)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_u32)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_f32)->As<sem::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_f16)->As<sem::Vector>()->Width(), 4u);
ASSERT_TRUE(TypeOf(vec4_bool)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec4_i32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec4_u32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec4_f32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(vec4_f16)->Is<type::Vector>());
EXPECT_TRUE(TypeOf(vec4_bool)->As<type::Vector>()->type()->Is<type::Bool>());
EXPECT_TRUE(TypeOf(vec4_i32)->As<type::Vector>()->type()->Is<type::I32>());
EXPECT_TRUE(TypeOf(vec4_u32)->As<type::Vector>()->type()->Is<type::U32>());
EXPECT_TRUE(TypeOf(vec4_f32)->As<type::Vector>()->type()->Is<type::F32>());
EXPECT_TRUE(TypeOf(vec4_f16)->As<type::Vector>()->type()->Is<type::F16>());
EXPECT_EQ(TypeOf(vec4_bool)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_i32)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_u32)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_f32)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_f16)->As<type::Vector>()->Width(), 4u);
EXPECT_EQ(TypeOf(vec4_bool), TypeOf(vec4_bool->target.type));
EXPECT_EQ(TypeOf(vec4_i32), TypeOf(vec4_i32->target.type));
EXPECT_EQ(TypeOf(vec4_u32), TypeOf(vec4_u32->target.type));

28
src/tint/resolver/validator.cc
View File

@@ -183,15 +183,15 @@ void Validator::AddNote(const std::string& msg, const Source& source) const {
// https://gpuweb.github.io/gpuweb/wgsl/#plain-types-section
bool Validator::IsPlain(const type::Type* type) const {
return type->is_scalar() ||
type->IsAnyOf<sem::Atomic, sem::Vector, sem::Matrix, sem::Array, sem::Struct>();
type->IsAnyOf<sem::Atomic, type::Vector, type::Matrix, sem::Array, sem::Struct>();
}
// https://gpuweb.github.io/gpuweb/wgsl/#fixed-footprint-types
bool Validator::IsFixedFootprint(const type::Type* type) const {
return Switch(
type, //
[&](const sem::Vector*) { return true; }, //
[&](const sem::Matrix*) { return true; }, //
type, //
[&](const type::Vector*) { return true; }, //
[&](const type::Matrix*) { return true; }, //
[&](const sem::Atomic*) { return true; },
[&](const sem::Array* arr) {
return !arr->Count()->Is<type::RuntimeArrayCount>() &&
@@ -215,8 +215,8 @@ bool Validator::IsHostShareable(const type::Type* type) const {
}
return Switch(
type, //
[&](const sem::Vector* vec) { return IsHostShareable(vec->type()); },
[&](const sem::Matrix* mat) { return IsHostShareable(mat->type()); },
[&](const type::Vector* vec) { return IsHostShareable(vec->type()); },
[&](const type::Matrix* mat) { return IsHostShareable(mat->type()); },
[&](const sem::Array* arr) { return IsHostShareable(arr->ElemType()); },
[&](const sem::Struct* str) {
for (auto* member : str->Members()) {
@@ -522,7 +522,7 @@ bool Validator::AddressSpaceLayout(const type::Type* store_ty,
std::string hint;
if (arr->ElemType()->is_scalar()) {
hint = "Consider using a vector or struct as the element type instead.";
} else if (auto* vec = arr->ElemType()->As<sem::Vector>();
} else if (auto* vec = arr->ElemType()->As<type::Vector>();
vec && vec->type()->Size() == 4) {
hint = "Consider using a vec4 instead.";
} else if (arr->ElemType()->Is<sem::Struct>()) {
@@ -857,7 +857,7 @@ bool Validator::BuiltinAttribute(const ast::BuiltinAttribute* attr,
(is_output && stage == ast::PipelineStage::kVertex))) {
is_stage_mismatch = true;
}
if (!(type->is_float_vector() && type->As<sem::Vector>()->Width() == 4)) {
if (!(type->is_float_vector() && type->As<type::Vector>()->Width() == 4)) {
AddError("store type of " + attr_to_str(attr) + " must be 'vec4<f32>'",
attr->source);
return false;
@@ -871,7 +871,7 @@ bool Validator::BuiltinAttribute(const ast::BuiltinAttribute* attr,
!(stage == ast::PipelineStage::kCompute && is_input)) {
is_stage_mismatch = true;
}
if (!(type->is_unsigned_integer_vector() && type->As<sem::Vector>()->Width() == 3)) {
if (!(type->is_unsigned_integer_vector() && type->As<type::Vector>()->Width() == 3)) {
AddError("store type of " + attr_to_str(attr) + " must be 'vec3<u32>'",
attr->source);
return false;
@@ -1371,7 +1371,7 @@ bool Validator::Bitcast(const ast::BitcastExpression* cast, const type::Type* to
}
auto width = [&](const type::Type* ty) {
if (auto* vec = ty->As<sem::Vector>()) {
if (auto* vec = ty->As<type::Vector>()) {
return vec->Width();
}
return 1u;
@@ -1566,7 +1566,7 @@ bool Validator::TextureBuiltinFunction(const sem::Call* call) const {
std::string name = sem::str(usage);
auto* arg = call->Arguments()[index];
if (auto values = arg->ConstantValue()) {
if (auto* vector = values->Type()->As<sem::Vector>()) {
if (auto* vector = values->Type()->As<type::Vector>()) {
for (size_t i = 0; i < vector->Width(); i++) {
auto value = values->Index(i)->As<AInt>();
if (value < min || value > max) {
@@ -1790,7 +1790,7 @@ bool Validator::ArrayInitializer(const ast::CallExpression* ctor,
return true;
}
bool Validator::Vector(const sem::Vector* ty, const Source& source) const {
bool Validator::Vector(const type::Vector* ty, const Source& source) const {
if (!ty->type()->is_scalar()) {
AddError("vector element type must be 'bool', 'f32', 'f16', 'i32' or 'u32'", source);
return false;
@@ -1798,7 +1798,7 @@ bool Validator::Vector(const sem::Vector* ty, const Source& source) const {
return true;
}
bool Validator::Matrix(const sem::Matrix* ty, const Source& source) const {
bool Validator::Matrix(const type::Matrix* ty, const Source& source) const {
if (!ty->is_float_matrix()) {
AddError("matrix element type must be 'f32' or 'f16'", source);
return false;
@@ -2409,7 +2409,7 @@ void Validator::RaiseArrayWithOverrideCountError(const Source& source) const {
}
std::string Validator::VectorPretty(uint32_t size, const type::Type* element_type) const {
sem::Vector vec_type(element_type, size);
type::Vector vec_type(element_type, size);
return vec_type.FriendlyName(symbols_);
}

4
src/tint/resolver/validator.h
View File

@@ -328,7 +328,7 @@ class Validator {
/// @param ty the matrix to validate
/// @param source the source of the matrix
/// @returns true on success, false otherwise
bool Matrix(const sem::Matrix* ty, const Source& source) const;
bool Matrix(const type::Matrix* ty, const Source& source) const;
/// Validates a function parameter
/// @param func the function the variable is for
@@ -424,7 +424,7 @@ class Validator {
/// @param ty the vector to validate
/// @param source the source of the vector
/// @returns true on success, false otherwise
bool Vector(const sem::Vector* ty, const Source& source) const;
bool Vector(const type::Vector* ty, const Source& source) const;
/// Validates an array initializer
/// @param ctor the call expresion to validate

72
src/tint/resolver/validator_is_storeable_test.cc
View File

@@ -36,45 +36,45 @@ TEST_F(ValidatorIsStorableTest, Scalar) {
}
TEST_F(ValidatorIsStorableTest, Vector) {
EXPECT_TRUE(v()->IsStorable(create<sem::Vector>(create<type::I32>(), 2u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Vector>(create<type::I32>(), 3u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Vector>(create<type::I32>(), 4u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Vector>(create<type::U32>(), 2u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Vector>(create<type::U32>(), 3u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Vector>(create<type::U32>(), 4u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Vector>(create<type::F32>(), 2u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Vector>(create<type::F32>(), 3u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Vector>(create<type::F32>(), 4u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Vector>(create<type::F16>(), 2u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Vector>(create<type::F16>(), 3u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Vector>(create<type::F16>(), 4u)));
EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::I32>(), 2u)));
EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::I32>(), 3u)));
EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::I32>(), 4u)));
EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::U32>(), 2u)));
EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::U32>(), 3u)));
EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::U32>(), 4u)));
EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::F32>(), 2u)));
EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::F32>(), 3u)));
EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::F32>(), 4u)));
EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::F16>(), 2u)));
EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::F16>(), 3u)));
EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::F16>(), 4u)));
}
TEST_F(ValidatorIsStorableTest, Matrix) {
auto* vec2_f32 = create<sem::Vector>(create<type::F32>(), 2u);
auto* vec3_f32 = create<sem::Vector>(create<type::F32>(), 3u);
auto* vec4_f32 = create<sem::Vector>(create<type::F32>(), 4u);
auto* vec2_f16 = create<sem::Vector>(create<type::F16>(), 2u);
auto* vec3_f16 = create<sem::Vector>(create<type::F16>(), 3u);
auto* vec4_f16 = create<sem::Vector>(create<type::F16>(), 4u);
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec2_f32, 2u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec2_f32, 3u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec2_f32, 4u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec3_f32, 2u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec3_f32, 3u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec3_f32, 4u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec4_f32, 2u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec4_f32, 3u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec4_f32, 4u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec2_f16, 2u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec2_f16, 3u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec2_f16, 4u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec3_f16, 2u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec3_f16, 3u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec3_f16, 4u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec4_f16, 2u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec4_f16, 3u)));
EXPECT_TRUE(v()->IsStorable(create<sem::Matrix>(vec4_f16, 4u)));
auto* vec2_f32 = create<type::Vector>(create<type::F32>(), 2u);
auto* vec3_f32 = create<type::Vector>(create<type::F32>(), 3u);
auto* vec4_f32 = create<type::Vector>(create<type::F32>(), 4u);
auto* vec2_f16 = create<type::Vector>(create<type::F16>(), 2u);
auto* vec3_f16 = create<type::Vector>(create<type::F16>(), 3u);
auto* vec4_f16 = create<type::Vector>(create<type::F16>(), 4u);
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec2_f32, 2u)));
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec2_f32, 3u)));
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec2_f32, 4u)));
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec3_f32, 2u)));
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec3_f32, 3u)));
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec3_f32, 4u)));
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec4_f32, 2u)));
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec4_f32, 3u)));
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec4_f32, 4u)));
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec2_f16, 2u)));
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec2_f16, 3u)));
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec2_f16, 4u)));
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec3_f16, 2u)));
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec3_f16, 3u)));
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec3_f16, 4u)));
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec4_f16, 2u)));
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec4_f16, 3u)));
EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec4_f16, 4u)));
}
TEST_F(ValidatorIsStorableTest, Pointer) {

44
src/tint/resolver/variable_test.cc
View File

@@ -916,10 +916,10 @@ TEST_F(ResolverVariableTest, LocalConst_ExplicitType_Decls) {
ASSERT_TRUE(TypeOf(c_i32)->Is<type::I32>());
ASSERT_TRUE(TypeOf(c_u32)->Is<type::U32>());
ASSERT_TRUE(TypeOf(c_f32)->Is<type::F32>());
ASSERT_TRUE(TypeOf(c_vi32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(c_vu32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(c_vf32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(c_mf32)->Is<sem::Matrix>());
ASSERT_TRUE(TypeOf(c_vi32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(c_vu32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(c_vf32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(c_mf32)->Is<type::Matrix>());
ASSERT_TRUE(TypeOf(c_s)->Is<sem::Struct>());
EXPECT_TRUE(Sem().Get(c_i32)->ConstantValue()->AllZero());
@@ -976,13 +976,13 @@ TEST_F(ResolverVariableTest, LocalConst_ImplicitType_Decls) {
ASSERT_TRUE(TypeOf(c_f32)->Is<type::F32>());
ASSERT_TRUE(TypeOf(c_ai)->Is<type::AbstractInt>());
ASSERT_TRUE(TypeOf(c_af)->Is<type::AbstractFloat>());
ASSERT_TRUE(TypeOf(c_vi32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(c_vu32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(c_vf32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(c_vai)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(c_vaf)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(c_mf32)->Is<sem::Matrix>());
ASSERT_TRUE(TypeOf(c_maf32)->Is<sem::Matrix>());
ASSERT_TRUE(TypeOf(c_vi32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(c_vu32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(c_vf32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(c_vai)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(c_vaf)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(c_mf32)->Is<type::Matrix>());
ASSERT_TRUE(TypeOf(c_maf32)->Is<type::Matrix>());
ASSERT_TRUE(TypeOf(c_s)->Is<sem::Struct>());
EXPECT_TRUE(Sem().Get(c_i32)->ConstantValue()->AllZero());
@@ -1096,10 +1096,10 @@ TEST_F(ResolverVariableTest, GlobalConst_ExplicitType_Decls) {
ASSERT_TRUE(TypeOf(c_i32)->Is<type::I32>());
ASSERT_TRUE(TypeOf(c_u32)->Is<type::U32>());
ASSERT_TRUE(TypeOf(c_f32)->Is<type::F32>());
ASSERT_TRUE(TypeOf(c_vi32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(c_vu32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(c_vf32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(c_mf32)->Is<sem::Matrix>());
ASSERT_TRUE(TypeOf(c_vi32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(c_vu32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(c_vf32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(c_mf32)->Is<type::Matrix>());
EXPECT_TRUE(Sem().Get(c_i32)->ConstantValue()->AllZero());
EXPECT_TRUE(Sem().Get(c_u32)->ConstantValue()->AllZero());
@@ -1147,13 +1147,13 @@ TEST_F(ResolverVariableTest, GlobalConst_ImplicitType_Decls) {
ASSERT_TRUE(TypeOf(c_f32)->Is<type::F32>());
ASSERT_TRUE(TypeOf(c_ai)->Is<type::AbstractInt>());
ASSERT_TRUE(TypeOf(c_af)->Is<type::AbstractFloat>());
ASSERT_TRUE(TypeOf(c_vi32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(c_vu32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(c_vf32)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(c_vai)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(c_vaf)->Is<sem::Vector>());
ASSERT_TRUE(TypeOf(c_mf32)->Is<sem::Matrix>());
ASSERT_TRUE(TypeOf(c_maf32)->Is<sem::Matrix>());
ASSERT_TRUE(TypeOf(c_vi32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(c_vu32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(c_vf32)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(c_vai)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(c_vaf)->Is<type::Vector>());
ASSERT_TRUE(TypeOf(c_mf32)->Is<type::Matrix>());
ASSERT_TRUE(TypeOf(c_maf32)->Is<type::Matrix>());
EXPECT_TRUE(Sem().Get(c_i32)->ConstantValue()->AllZero());
EXPECT_TRUE(Sem().Get(c_u32)->ConstantValue()->AllZero());