| // Copyright 2021 The Tint Authors. | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| #include "src/tint/ast/id_attribute.h" | |
| #include "src/tint/ast/return_statement.h" | |
| #include "src/tint/ast/stage_attribute.h" | |
| #include "src/tint/resolver/resolver.h" | |
| #include "src/tint/resolver/resolver_test_helper.h" | |
| #include "src/tint/type/multisampled_texture.h" | |
| #include "src/tint/type/storage_texture.h" | |
| #include "src/tint/type/texture_dimension.h" | |
| #include "gmock/gmock.h" | |
| namespace tint::resolver { | |
| namespace { | |
| using namespace tint::builtin::fluent_types; // NOLINT | |
| using namespace tint::number_suffixes; // NOLINT | |
| // Helpers and typedefs | |
| template <typename T> | |
| using DataType = builder::DataType<T>; | |
| template <typename T> | |
| using alias = builder::alias<T>; | |
| template <typename T> | |
| using alias1 = builder::alias1<T>; | |
| template <typename T> | |
| using alias2 = builder::alias2<T>; | |
| template <typename T> | |
| using alias3 = builder::alias3<T>; | |
| class ResolverTypeValidationTest : public resolver::TestHelper, public testing::Test {}; | |
| TEST_F(ResolverTypeValidationTest, VariableDeclNoInitializer_Pass) { | |
| // { | |
| // var a :i32; | |
| // a = 2; | |
| // } | |
| auto* var = Var("a", ty.i32()); | |
| auto* lhs = Expr("a"); | |
| auto* rhs = Expr(2_i); | |
| auto* body = Block(Decl(var), Assign(Source{Source::Location{12, 34}}, lhs, rhs)); | |
| WrapInFunction(body); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| ASSERT_NE(TypeOf(lhs), nullptr); | |
| ASSERT_NE(TypeOf(rhs), nullptr); | |
| } | |
| TEST_F(ResolverTypeValidationTest, GlobalOverrideNoInitializer_Pass) { | |
| // @id(0) override a :i32; | |
| Override(Source{{12, 34}}, "a", ty.i32(), Id(0_u)); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, GlobalVariableWithAddressSpace_Pass) { | |
| // var<private> global_var: f32; | |
| GlobalVar(Source{{12, 34}}, "global_var", ty.f32(), builtin::AddressSpace::kPrivate); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, GlobalConstNoAddressSpace_Pass) { | |
| // const global_const: f32 = f32(); | |
| GlobalConst(Source{{12, 34}}, "global_const", ty.f32(), Call<f32>()); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, GlobalVariableUnique_Pass) { | |
| // var global_var0 : f32 = 0.1; | |
| // var global_var1 : i32 = 0; | |
| GlobalVar("global_var0", ty.f32(), builtin::AddressSpace::kPrivate, Expr(0.1_f)); | |
| GlobalVar(Source{{12, 34}}, "global_var1", ty.f32(), builtin::AddressSpace::kPrivate, | |
| Expr(1_f)); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, GlobalVariableFunctionVariableNotUnique_Pass) { | |
| // fn my_func() { | |
| // var a: f32 = 2.0; | |
| // } | |
| // var a: f32 = 2.1; | |
| Func("my_func", utils::Empty, ty.void_(), | |
| utils::Vector{ | |
| Decl(Var("a", ty.f32(), Expr(2_f))), | |
| }); | |
| GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate, Expr(2.1_f)); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, RedeclaredIdentifierInnerScope_Pass) { | |
| // { | |
| // if (true) { var a : f32 = 2.0; } | |
| // var a : f32 = 3.14; | |
| // } | |
| auto* var = Var("a", ty.f32(), Expr(2_f)); | |
| auto* cond = Expr(true); | |
| auto* body = Block(Decl(var)); | |
| auto* var_a_float = Var("a", ty.f32(), Expr(3.1_f)); | |
| auto* outer_body = Block(If(cond, body), Decl(Source{{12, 34}}, var_a_float)); | |
| WrapInFunction(outer_body); | |
| EXPECT_TRUE(r()->Resolve()); | |
| } | |
| TEST_F(ResolverTypeValidationTest, RedeclaredIdentifierInnerScopeBlock_Pass) { | |
| // { | |
| // { var a : f32; } | |
| // var a : f32; | |
| // } | |
| auto* var_inner = Var("a", ty.f32()); | |
| auto* inner = Block(Decl(Source{{12, 34}}, var_inner)); | |
| auto* var_outer = Var("a", ty.f32()); | |
| auto* outer_body = Block(inner, Decl(var_outer)); | |
| WrapInFunction(outer_body); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, RedeclaredIdentifierDifferentFunctions_Pass) { | |
| // func0 { var a : f32 = 2.0; return; } | |
| // func1 { var a : f32 = 3.0; return; } | |
| auto* var0 = Var("a", ty.f32(), Expr(2_f)); | |
| auto* var1 = Var("a", ty.f32(), Expr(1_f)); | |
| Func("func0", utils::Empty, ty.void_(), | |
| utils::Vector{ | |
| Decl(Source{{12, 34}}, var0), | |
| Return(), | |
| }); | |
| Func("func1", utils::Empty, ty.void_(), | |
| utils::Vector{ | |
| Decl(Source{{13, 34}}, var1), | |
| Return(), | |
| }); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_AIntLiteral_Pass) { | |
| // var<private> a : array<f32, 4>; | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_a)), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedLiteral_Pass) { | |
| // var<private> a : array<f32, 4u>; | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_u)), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Pass) { | |
| // var<private> a : array<f32, 4i>; | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 4_i)), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedConst_Pass) { | |
| // const size = 4u; | |
| // var<private> a : array<f32, size>; | |
| GlobalConst("size", Expr(4_u)); | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_SignedConst_Pass) { | |
| // const size = 4i; | |
| // var<private> a : array<f32, size>; | |
| GlobalConst("size", Expr(4_i)); | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_AIntLiteral_Zero) { | |
| // var<private> a : array<f32, 0>; | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_a)), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedLiteral_Zero) { | |
| // var<private> a : array<f32, 0u>; | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_u)), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Zero) { | |
| // var<private> a : array<f32, 0i>; | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 0_i)), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_SignedLiteral_Negative) { | |
| // var<private> a : array<f32, -10i>; | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, -10_i)), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: array count (-10) must be greater than 0"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_UnsignedConst_Zero) { | |
| // const size = 0u; | |
| // var<private> a : array<f32, size>; | |
| GlobalConst("size", Expr(0_u)); | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_SignedConst_Zero) { | |
| // const size = 0i; | |
| // var<private> a : array<f32, size>; | |
| GlobalConst("size", Expr(0_i)); | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: array count (0) must be greater than 0"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_SignedConst_Negative) { | |
| // const size = -10i; | |
| // var<private> a : array<f32, size>; | |
| GlobalConst("size", Expr(-10_i)); | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: array count (-10) must be greater than 0"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_FloatLiteral) { | |
| // var<private> a : array<f32, 10.0>; | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 10_f)), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| "12:34 error: array count must evaluate to a constant integer expression, but is type " | |
| "'f32'"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_IVecLiteral) { | |
| // var<private> a : array<f32, vec2<i32>(10, 10)>; | |
| GlobalVar("a", ty.array(ty.f32(), Call(Source{{12, 34}}, ty.vec2<i32>(), 10_i, 10_i)), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| "12:34 error: array count must evaluate to a constant integer expression, but is type " | |
| "'vec2<i32>'"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_FloatConst) { | |
| // const size = 10.0; | |
| // var<private> a : array<f32, size>; | |
| GlobalConst("size", Expr(10_f)); | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| "12:34 error: array count must evaluate to a constant integer expression, but is type " | |
| "'f32'"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_IVecConst) { | |
| // const size = vec2<i32>(100, 100); | |
| // var<private> a : array<f32, size>; | |
| GlobalConst("size", Call<vec2<i32>>(100_i, 100_i)); | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| "12:34 error: array count must evaluate to a constant integer expression, but is type " | |
| "'vec2<i32>'"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_UnderElementCountLimit) { | |
| // var<private> a : array<f32, 65535>; | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65535_a)), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_OverElementCountLimit) { | |
| // var<private> a : array<f32, 65536>; | |
| GlobalVar(Source{{56, 78}}, "a", ty.array(Source{{12, 34}}, ty.f32(), Expr(65536_a)), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), R"(12:34 error: array count (65536) must be less than 65536 | |
| 56:78 note: while instantiating 'var' a)"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_StorageBufferLargeArray) { | |
| // var<storage> a : array<f32, 65536>; | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, 65536_a)), | |
| builtin::AddressSpace::kStorage, utils::Vector{Binding(0_u), Group(0_u)}); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_NestedStorageBufferLargeArray) { | |
| // Struct S { | |
| // a : array<f32, 65536>, | |
| // } | |
| // var<storage> a : S; | |
| Structure("S", utils::Vector{Member(Source{{12, 34}}, "a", | |
| ty.array(Source{{12, 20}}, ty.f32(), 65536_a))}); | |
| GlobalVar("a", ty(Source{{12, 30}}, "S"), builtin::AddressSpace::kStorage, | |
| utils::Vector{Binding(0_u), Group(0_u)}); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_TooBig_ImplicitStride) { | |
| // struct S { | |
| // @offset(800000) a : f32 | |
| // } | |
| // var<private> a : array<S, 65535>; | |
| Structure("S", utils::Vector{Member(Source{{12, 34}}, "a", ty.f32(), | |
| utils::Vector{MemberOffset(800000_a)})}); | |
| GlobalVar("a", ty.array(ty(Source{{12, 30}}, "S"), Expr(Source{{12, 34}}, 65535_a)), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: array byte size (0xc34f7cafc) must not exceed 0xffffffff bytes"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_TooBig_ExplicitStride) { | |
| // var<private> a : @stride(8000000) array<f32, 65535>; | |
| GlobalVar("a", | |
| ty.array(ty.f32(), Expr(Source{{12, 34}}, 65535_a), utils::Vector{Stride(8000000)}), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: array byte size (0x7a1185ee00) must not exceed 0xffffffff bytes"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_PrivateVar) { | |
| // override size = 10i; | |
| // var<private> a : array<f32, size>; | |
| Override("size", Expr(10_i)); | |
| GlobalVar("a", ty.array(Source{{12, 34}}, ty.f32(), "size"), builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: array with an 'override' element count can only be used as the store " | |
| "type of a 'var<workgroup>'"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_InArray) { | |
| // override size = 10i; | |
| // var<workgroup> a : array<array<f32, size>, 4>; | |
| Override("size", Expr(10_i)); | |
| GlobalVar("a", ty.array(ty.array(Source{{12, 34}}, ty.f32(), "size"), 4_a), | |
| builtin::AddressSpace::kWorkgroup); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: array with an 'override' element count can only be used as the store " | |
| "type of a 'var<workgroup>'"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_InStruct) { | |
| // override size = 10i; | |
| // struct S { | |
| // a : array<f32, size> | |
| // }; | |
| Override("size", Expr(10_i)); | |
| Structure("S", utils::Vector{Member("a", ty.array(Source{{12, 34}}, ty.f32(), "size"))}); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: array with an 'override' element count can only be used as the store " | |
| "type of a 'var<workgroup>'"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_FunctionVar_Explicit) { | |
| // override size = 10i; | |
| // fn f() { | |
| // var a : array<f32, size>; | |
| // } | |
| Override("size", Expr(10_i)); | |
| Func("f", utils::Empty, ty.void_(), | |
| utils::Vector{ | |
| Decl(Var("a", ty.array(Source{{12, 34}}, ty.f32(), "size"))), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: array with an 'override' element count can only be used as the store " | |
| "type of a 'var<workgroup>'"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_FunctionLet_Explicit) { | |
| // override size = 10i; | |
| // fn f() { | |
| // var a : array<f32, size>; | |
| // } | |
| Override("size", Expr(10_i)); | |
| Func("f", utils::Empty, ty.void_(), | |
| utils::Vector{ | |
| Decl(Var("a", ty.array(Source{{12, 34}}, ty.f32(), "size"))), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: array with an 'override' element count can only be used as the store " | |
| "type of a 'var<workgroup>'"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_FunctionVar_Implicit) { | |
| // override size = 10i; | |
| // var<workgroup> w : array<f32, size>; | |
| // fn f() { | |
| // var a = w; | |
| // } | |
| Override("size", Expr(10_i)); | |
| GlobalVar("w", ty.array(ty.f32(), "size"), builtin::AddressSpace::kWorkgroup); | |
| Func("f", utils::Empty, ty.void_(), | |
| utils::Vector{ | |
| Decl(Var("a", Expr(Source{{12, 34}}, "w"))), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: array with an 'override' element count can only be used as the store " | |
| "type of a 'var<workgroup>'"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_FunctionLet_Implicit) { | |
| // override size = 10i; | |
| // var<workgroup> w : array<f32, size>; | |
| // fn f() { | |
| // let a = w; | |
| // } | |
| Override("size", Expr(10_i)); | |
| GlobalVar("w", ty.array(ty.f32(), "size"), builtin::AddressSpace::kWorkgroup); | |
| Func("f", utils::Empty, ty.void_(), | |
| utils::Vector{ | |
| Decl(Let("a", Expr(Source{{12, 34}}, "w"))), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: array with an 'override' element count can only be used as the store " | |
| "type of a 'var<workgroup>'"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_UnnamedOverride_Equivalence) { | |
| // override size = 10i; | |
| // var<workgroup> a : array<f32, size + 1>; | |
| // var<workgroup> b : array<f32, size + 1>; | |
| // fn f() { | |
| // a = b; | |
| // } | |
| Override("size", Expr(10_i)); | |
| GlobalVar("a", ty.array(ty.f32(), Add("size", 1_i)), builtin::AddressSpace::kWorkgroup); | |
| GlobalVar("b", ty.array(ty.f32(), Add("size", 1_i)), builtin::AddressSpace::kWorkgroup); | |
| WrapInFunction(Assign(Source{{12, 34}}, "a", "b")); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: cannot assign 'array<f32, [unnamed override-expression]>' to " | |
| "'array<f32, [unnamed override-expression]>'"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_Param) { | |
| // override size = 10i; | |
| // fn f(a : array<f32, size>) { | |
| // } | |
| Override("size", Expr(10_i)); | |
| Func("f", utils::Vector{Param("a", ty.array(Source{{12, 34}}, ty.f32(), "size"))}, ty.void_(), | |
| utils::Empty); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: type of function parameter must be constructible"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_NamedOverride_ReturnType) { | |
| // override size = 10i; | |
| // fn f() -> array<f32, size> { | |
| // } | |
| Override("size", Expr(10_i)); | |
| Func("f", utils::Empty, ty.array(Source{{12, 34}}, ty.f32(), "size"), utils::Empty); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: function return type must be a constructible type"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_Workgroup_Overridable) { | |
| // override size = 10i; | |
| // var<workgroup> a : array<f32, size>; | |
| Override("size", Expr(10_i)); | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), | |
| builtin::AddressSpace::kWorkgroup); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_ModuleVar) { | |
| // var<private> size : i32 = 10i; | |
| // var<private> a : array<f32, size>; | |
| GlobalVar("size", ty.i32(), Expr(10_i), builtin::AddressSpace::kPrivate); | |
| GlobalVar("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size")), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: var 'size' cannot be referenced at module-scope | |
| note: var 'size' declared here)"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_FunctionConst) { | |
| // { | |
| // const size = 10; | |
| // var a : array<f32, size>; | |
| // } | |
| auto* size = Const("size", Expr(10_i)); | |
| auto* a = Var("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size"))); | |
| WrapInFunction(size, a); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_FunctionLet) { | |
| // { | |
| // let size = 10; | |
| // var a : array<f32, size>; | |
| // } | |
| auto* size = Let("size", Expr(10_i)); | |
| auto* a = Var("a", ty.array(ty.f32(), Expr(Source{{12, 34}}, "size"))); | |
| WrapInFunction(size, a); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: array count must evaluate to a constant integer expression or override " | |
| "variable"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArraySize_ComplexExpr) { | |
| // var a : array<f32, i32(4i)>; | |
| auto* a = Var("a", ty.array(ty.f32(), Call(Source{{12, 34}}, ty.i32(), 4_i))); | |
| WrapInFunction(a); | |
| EXPECT_TRUE(r()->Resolve()); | |
| } | |
| TEST_F(ResolverTypeValidationTest, RuntimeArrayInFunction_Fail) { | |
| /// @vertex | |
| // fn func() { var a : array<i32>; } | |
| auto* var = Var(Source{{56, 78}}, "a", ty.array(Source{{12, 34}}, ty.i32())); | |
| Func("func", utils::Empty, ty.void_(), | |
| utils::Vector{ | |
| Decl(var), | |
| }, | |
| utils::Vector{ | |
| Stage(ast::PipelineStage::kVertex), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: runtime-sized arrays can only be used in the <storage> address space | |
| 56:78 note: while instantiating 'var' a)"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, Struct_Member_VectorNoType) { | |
| // struct S { | |
| // a: vec3; | |
| // }; | |
| Structure("S", utils::Vector{ | |
| Member("a", ty.vec3<Infer>(Source{{12, 34}})), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: expected '<' for 'vec3'"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, Struct_Member_MatrixNoType) { | |
| // struct S { | |
| // a: mat3x3; | |
| // }; | |
| Structure("S", utils::Vector{ | |
| Member("a", ty.mat3x3<Infer>(Source{{12, 34}})), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: expected '<' for 'mat3x3'"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, Struct_TooBig) { | |
| // Struct Bar { | |
| // a: array<f32, 10000>; | |
| // } | |
| // struct Foo { | |
| // a: array<Bar, 65535>; | |
| // b: array<Bar, 65535>; | |
| // } | |
| Structure(Source{{10, 34}}, "Bar", utils::Vector{Member("a", ty.array<f32, 10000>())}); | |
| Structure(Source{{12, 34}}, "Foo", | |
| utils::Vector{Member("a", ty.array(ty(Source{{12, 30}}, "Bar"), Expr(65535_a))), | |
| Member("b", ty.array(ty("Bar"), Expr(65535_a)))}); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: struct size (0x1387ec780) must not exceed 0xffffffff bytes"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, Struct_MemberOffset_TooBig) { | |
| // struct Foo { | |
| // @size(2147483647) a: array<f32, 65535>; | |
| // b: f32; | |
| // c: f32; | |
| // }; | |
| Structure("Foo", utils::Vector{ | |
| Member("z", ty.f32(), utils::Vector{MemberSize(2147483647_a)}), | |
| Member("y", ty.f32(), utils::Vector{MemberSize(2147483647_a)}), | |
| Member(Source{{12, 34}}, "a", ty.array<f32, 65535>()), | |
| Member("c", ty.f32()), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: struct member offset (0x100000000) must not exceed 0xffffffff bytes"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, RuntimeArrayIsLast_Pass) { | |
| // struct Foo { | |
| // vf: f32; | |
| // rt: array<f32>; | |
| // }; | |
| Structure("Foo", utils::Vector{ | |
| Member("vf", ty.f32()), | |
| Member("rt", ty.array<f32>()), | |
| }); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, RuntimeArrayInArray) { | |
| // struct Foo { | |
| // rt : array<array<f32>, 4u>; | |
| // }; | |
| Structure("Foo", utils::Vector{ | |
| Member("rt", ty.array(ty.array(Source{{12, 34}}, ty.f32()), 4_u)), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()) << r()->error(); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: an array element type cannot contain a runtime-sized array"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, RuntimeArrayInStructInArray) { | |
| // struct Foo { | |
| // rt : array<f32>; | |
| // }; | |
| // var<private> a : array<Foo, 4>; | |
| Structure("Foo", utils::Vector{Member("rt", ty.array<f32>())}); | |
| GlobalVar("v", ty.array(ty(Source{{12, 34}}, "Foo"), 4_u), builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()) << r()->error(); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: an array element type cannot contain a runtime-sized array"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, RuntimeArrayInStructInStruct) { | |
| // struct Foo { | |
| // rt : array<f32>; | |
| // }; | |
| // struct Outer { | |
| // inner : Foo; | |
| // }; | |
| auto* foo = Structure("Foo", utils::Vector{ | |
| Member("rt", ty.array<f32>()), | |
| }); | |
| Structure("Outer", utils::Vector{ | |
| Member(Source{{12, 34}}, "inner", ty.Of(foo)), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()) << r()->error(); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: a struct that contains a runtime array cannot be nested inside another " | |
| "struct"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, RuntimeArrayIsNotLast_Fail) { | |
| // struct Foo { | |
| // rt: array<f32>; | |
| // vf: f32; | |
| // }; | |
| Structure("Foo", utils::Vector{ | |
| Member(Source{{12, 34}}, "rt", ty.array<f32>()), | |
| Member("vf", ty.f32()), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()) << r()->error(); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: runtime arrays may only appear as the last member of a struct)"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, RuntimeArrayAsGlobalVariable) { | |
| GlobalVar(Source{{56, 78}}, "g", ty.array(Source{{12, 34}}, ty.i32()), | |
| builtin::AddressSpace::kPrivate); | |
| ASSERT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: runtime-sized arrays can only be used in the <storage> address space | |
| 56:78 note: while instantiating 'var' g)"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, RuntimeArrayAsLocalVariable) { | |
| auto* v = Var(Source{{56, 78}}, "g", ty.array(Source{{12, 34}}, ty.i32())); | |
| WrapInFunction(v); | |
| ASSERT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: runtime-sized arrays can only be used in the <storage> address space | |
| 56:78 note: while instantiating 'var' g)"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, RuntimeArrayAsParameter_Fail) { | |
| // fn func(a : array<u32>) {} | |
| // @vertex fn main() {} | |
| auto* param = Param(Source{{56, 78}}, "a", ty.array(Source{{12, 34}}, ty.i32())); | |
| Func("func", utils::Vector{param}, ty.void_(), | |
| utils::Vector{ | |
| Return(), | |
| }); | |
| Func("main", utils::Empty, ty.void_(), | |
| utils::Vector{ | |
| Return(), | |
| }, | |
| utils::Vector{ | |
| Stage(ast::PipelineStage::kVertex), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()) << r()->error(); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: runtime-sized arrays can only be used in the <storage> address space | |
| 56:78 note: while instantiating parameter a)"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, PtrToRuntimeArrayAsPointerParameter_Fail) { | |
| // fn func(a : ptr<workgroup, array<u32>>) {} | |
| auto* param = Param("a", ty.ptr(Source{{56, 78}}, builtin::AddressSpace::kWorkgroup, | |
| ty.array(Source{{12, 34}}, ty.i32()))); | |
| Func("func", utils::Vector{param}, ty.void_(), | |
| utils::Vector{ | |
| Return(), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()) << r()->error(); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: runtime-sized arrays can only be used in the <storage> address space | |
| 56:78 note: while instantiating ptr<workgroup, array<i32>, read_write>)"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, PtrToRuntimeArrayAsParameter_Fail) { | |
| // fn func(a : ptr<workgroup, array<u32>>) {} | |
| auto* param = Param(Source{{56, 78}}, "a", ty.array(Source{{12, 34}}, ty.i32())); | |
| Func("func", utils::Vector{param}, ty.void_(), | |
| utils::Vector{ | |
| Return(), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()) << r()->error(); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: runtime-sized arrays can only be used in the <storage> address space | |
| 56:78 note: while instantiating parameter a)"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, AliasRuntimeArrayIsNotLast_Fail) { | |
| // type RTArr = array<u32>; | |
| // struct s { | |
| // b: RTArr; | |
| // a: u32; | |
| //} | |
| auto* alias = Alias("RTArr", ty.array<u32>()); | |
| Structure("s", utils::Vector{ | |
| Member(Source{{12, 34}}, "b", ty.Of(alias)), | |
| Member("a", ty.u32()), | |
| }); | |
| EXPECT_FALSE(r()->Resolve()) << r()->error(); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: runtime arrays may only appear as the last member of a struct"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, AliasRuntimeArrayIsLast_Pass) { | |
| // type RTArr = array<u32>; | |
| // struct s { | |
| // a: u32; | |
| // b: RTArr; | |
| //} | |
| auto* alias = Alias("RTArr", ty.array<u32>()); | |
| Structure("s", utils::Vector{ | |
| Member("a", ty.u32()), | |
| Member("b", ty.Of(alias)), | |
| }); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableType) { | |
| auto tex_ty = ty.sampled_texture(Source{{12, 34}}, type::TextureDimension::k2d, ty.f32()); | |
| GlobalVar("arr", ty.array(tex_ty, 4_i), builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: texture_2d<f32> cannot be used as an element type of an array"); | |
| } | |
| TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableTypeWithStride) { | |
| auto ptr_ty = ty.ptr<uniform, u32>(Source{{12, 34}}); | |
| GlobalVar("arr", ty.array(ptr_ty, 4_i, utils::Vector{Stride(16)}), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: ptr<uniform, u32, read> cannot be used as an element type of an array"); | |
| } | |
| namespace GetCanonicalTests { | |
| struct Params { | |
| builder::ast_type_func_ptr create_ast_type; | |
| builder::sem_type_func_ptr create_sem_type; | |
| }; | |
| template <typename T> | |
| constexpr Params ParamsFor() { | |
| return Params{DataType<T>::AST, DataType<T>::Sem}; | |
| } | |
| static constexpr Params cases[] = { | |
| ParamsFor<bool>(), | |
| ParamsFor<alias<bool>>(), | |
| ParamsFor<alias1<alias<bool>>>(), | |
| ParamsFor<vec3<f32>>(), | |
| ParamsFor<alias<vec3<f32>>>(), | |
| ParamsFor<alias1<alias<vec3<f32>>>>(), | |
| ParamsFor<vec3<alias<f32>>>(), | |
| ParamsFor<alias1<vec3<alias<f32>>>>(), | |
| ParamsFor<alias2<alias1<vec3<alias<f32>>>>>(), | |
| ParamsFor<alias3<alias2<vec3<alias1<alias<f32>>>>>>(), | |
| ParamsFor<mat3x3<alias<f32>>>(), | |
| ParamsFor<alias1<mat3x3<alias<f32>>>>(), | |
| ParamsFor<alias2<alias1<mat3x3<alias<f32>>>>>(), | |
| ParamsFor<alias3<alias2<mat3x3<alias1<alias<f32>>>>>>(), | |
| ParamsFor<alias1<alias<bool>>>(), | |
| ParamsFor<alias1<alias<vec3<f32>>>>(), | |
| ParamsFor<alias1<alias<mat3x3<f32>>>>(), | |
| }; | |
| using CanonicalTest = ResolverTestWithParam<Params>; | |
| TEST_P(CanonicalTest, All) { | |
| auto& params = GetParam(); | |
| ast::Type type = params.create_ast_type(*this); | |
| auto* var = Var("v", type); | |
| auto* expr = Expr("v"); | |
| WrapInFunction(var, expr); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| auto* got = TypeOf(expr)->UnwrapRef(); | |
| auto* expected = params.create_sem_type(*this); | |
| EXPECT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n" | |
| << "expected: " << FriendlyName(expected) << "\n"; | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest, CanonicalTest, testing::ValuesIn(cases)); | |
| } // namespace GetCanonicalTests | |
| namespace SampledTextureTests { | |
| using SampledTextureDimensionTest = ResolverTestWithParam<type::TextureDimension>; | |
| TEST_P(SampledTextureDimensionTest, All) { | |
| auto& params = GetParam(); | |
| GlobalVar(Source{{12, 34}}, "a", ty.sampled_texture(params, ty.i32()), Group(0_a), | |
| Binding(0_a)); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest, | |
| SampledTextureDimensionTest, | |
| testing::Values( // | |
| type::TextureDimension::k1d, | |
| type::TextureDimension::k2d, | |
| type::TextureDimension::k2dArray, | |
| type::TextureDimension::k3d, | |
| type::TextureDimension::kCube, | |
| type::TextureDimension::kCubeArray)); | |
| using MultisampledTextureDimensionTest = ResolverTestWithParam<type::TextureDimension>; | |
| TEST_P(MultisampledTextureDimensionTest, All) { | |
| auto& params = GetParam(); | |
| GlobalVar("a", ty.multisampled_texture(Source{{12, 34}}, params, ty.i32()), Group(0_a), | |
| Binding(0_a)); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest, | |
| MultisampledTextureDimensionTest, | |
| testing::Values(type::TextureDimension::k2d)); | |
| struct TypeParams { | |
| builder::ast_type_func_ptr type_func; | |
| bool is_valid; | |
| }; | |
| template <typename T> | |
| constexpr TypeParams TypeParamsFor(bool is_valid) { | |
| return TypeParams{DataType<T>::AST, is_valid}; | |
| } | |
| static constexpr TypeParams type_cases[] = { | |
| TypeParamsFor<bool>(false), | |
| TypeParamsFor<i32>(true), | |
| TypeParamsFor<u32>(true), | |
| TypeParamsFor<f32>(true), | |
| TypeParamsFor<f16>(false), | |
| TypeParamsFor<alias<bool>>(false), | |
| TypeParamsFor<alias<i32>>(true), | |
| TypeParamsFor<alias<u32>>(true), | |
| TypeParamsFor<alias<f32>>(true), | |
| TypeParamsFor<alias<f16>>(false), | |
| TypeParamsFor<vec3<f32>>(false), | |
| TypeParamsFor<mat3x3<f32>>(false), | |
| TypeParamsFor<mat3x3<f16>>(false), | |
| TypeParamsFor<alias<vec3<f32>>>(false), | |
| TypeParamsFor<alias<mat3x3<f32>>>(false), | |
| TypeParamsFor<alias<mat3x3<f16>>>(false), | |
| }; | |
| using SampledTextureTypeTest = ResolverTestWithParam<TypeParams>; | |
| TEST_P(SampledTextureTypeTest, All) { | |
| auto& params = GetParam(); | |
| Enable(builtin::Extension::kF16); | |
| GlobalVar( | |
| "a", | |
| ty.sampled_texture(Source{{12, 34}}, type::TextureDimension::k2d, params.type_func(*this)), | |
| Group(0_a), Binding(0_a)); | |
| if (params.is_valid) { | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } else { | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: texture_2d<type>: type must be f32, i32 or u32"); | |
| } | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest, | |
| SampledTextureTypeTest, | |
| testing::ValuesIn(type_cases)); | |
| using MultisampledTextureTypeTest = ResolverTestWithParam<TypeParams>; | |
| TEST_P(MultisampledTextureTypeTest, All) { | |
| auto& params = GetParam(); | |
| Enable(builtin::Extension::kF16); | |
| GlobalVar("a", | |
| ty.multisampled_texture(Source{{12, 34}}, type::TextureDimension::k2d, | |
| params.type_func(*this)), | |
| Group(0_a), Binding(0_a)); | |
| if (params.is_valid) { | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } else { | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: texture_multisampled_2d<type>: type must be f32, i32 or u32"); | |
| } | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest, | |
| MultisampledTextureTypeTest, | |
| testing::ValuesIn(type_cases)); | |
| } // namespace SampledTextureTests | |
| namespace StorageTextureTests { | |
| struct DimensionParams { | |
| const char* name; | |
| bool is_valid; | |
| }; | |
| static constexpr DimensionParams Dimension_cases[] = { | |
| DimensionParams{"texture_storage_1d", true}, | |
| DimensionParams{"texture_storage_2d", true}, | |
| DimensionParams{"texture_storage_2d_array", true}, | |
| DimensionParams{"texture_storage_3d", true}, | |
| DimensionParams{"texture_storage_cube", false}, | |
| DimensionParams{"texture_storage_cube_array", false}}; | |
| using StorageTextureDimensionTest = ResolverTestWithParam<DimensionParams>; | |
| TEST_P(StorageTextureDimensionTest, All) { | |
| // @group(0) @binding(0) | |
| // var a : texture_storage_*<r32uint, write>; | |
| auto& params = GetParam(); | |
| auto st = ty(Source{{12, 34}}, params.name, utils::ToString(builtin::TexelFormat::kR32Uint), | |
| utils::ToString(builtin::Access::kWrite)); | |
| GlobalVar("a", st, Group(0_a), Binding(0_a)); | |
| if (params.is_valid) { | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } else { | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: unresolved type '" + std::string(params.name) + "'"); | |
| } | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest, | |
| StorageTextureDimensionTest, | |
| testing::ValuesIn(Dimension_cases)); | |
| struct FormatParams { | |
| builtin::TexelFormat format; | |
| bool is_valid; | |
| }; | |
| static constexpr FormatParams format_cases[] = { | |
| FormatParams{builtin::TexelFormat::kBgra8Unorm, true}, | |
| FormatParams{builtin::TexelFormat::kR32Float, true}, | |
| FormatParams{builtin::TexelFormat::kR32Sint, true}, | |
| FormatParams{builtin::TexelFormat::kR32Uint, true}, | |
| FormatParams{builtin::TexelFormat::kRg32Float, true}, | |
| FormatParams{builtin::TexelFormat::kRg32Sint, true}, | |
| FormatParams{builtin::TexelFormat::kRg32Uint, true}, | |
| FormatParams{builtin::TexelFormat::kRgba16Float, true}, | |
| FormatParams{builtin::TexelFormat::kRgba16Sint, true}, | |
| FormatParams{builtin::TexelFormat::kRgba16Uint, true}, | |
| FormatParams{builtin::TexelFormat::kRgba32Float, true}, | |
| FormatParams{builtin::TexelFormat::kRgba32Sint, true}, | |
| FormatParams{builtin::TexelFormat::kRgba32Uint, true}, | |
| FormatParams{builtin::TexelFormat::kRgba8Sint, true}, | |
| FormatParams{builtin::TexelFormat::kRgba8Snorm, true}, | |
| FormatParams{builtin::TexelFormat::kRgba8Uint, true}, | |
| FormatParams{builtin::TexelFormat::kRgba8Unorm, true}}; | |
| using StorageTextureFormatTest = ResolverTestWithParam<FormatParams>; | |
| TEST_P(StorageTextureFormatTest, All) { | |
| auto& params = GetParam(); | |
| // @group(0) @binding(0) | |
| // var a : texture_storage_1d<*, write>; | |
| // @group(0) @binding(1) | |
| // var b : texture_storage_2d<*, write>; | |
| // @group(0) @binding(2) | |
| // var c : texture_storage_2d_array<*, write>; | |
| // @group(0) @binding(3) | |
| // var d : texture_storage_3d<*, write>; | |
| auto st_a = ty.storage_texture(Source{{12, 34}}, type::TextureDimension::k1d, params.format, | |
| builtin::Access::kWrite); | |
| GlobalVar("a", st_a, Group(0_a), Binding(0_a)); | |
| ast::Type st_b = | |
| ty.storage_texture(type::TextureDimension::k2d, params.format, builtin::Access::kWrite); | |
| GlobalVar("b", st_b, Group(0_a), Binding(1_a)); | |
| ast::Type st_c = ty.storage_texture(type::TextureDimension::k2dArray, params.format, | |
| builtin::Access::kWrite); | |
| GlobalVar("c", st_c, Group(0_a), Binding(2_a)); | |
| ast::Type st_d = | |
| ty.storage_texture(type::TextureDimension::k3d, params.format, builtin::Access::kWrite); | |
| GlobalVar("d", st_d, Group(0_a), Binding(3_a)); | |
| if (params.is_valid) { | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } else { | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: image format must be one of the texel formats specified for " | |
| "storage textures in https://gpuweb.github.io/gpuweb/wgsl/#texel-formats"); | |
| } | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest, | |
| StorageTextureFormatTest, | |
| testing::ValuesIn(format_cases)); | |
| using StorageTextureAccessTest = ResolverTest; | |
| TEST_F(StorageTextureAccessTest, MissingTemplates) { | |
| // @group(0) @binding(0) | |
| // var a : texture_storage_1d<r32uint>; | |
| auto st = ty(Source{{12, 34}}, "texture_storage_1d"); | |
| GlobalVar("a", st, Group(0_a), Binding(0_a)); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: expected '<' for 'texture_storage_1d'"); | |
| } | |
| TEST_F(StorageTextureAccessTest, MissingAccess_Fail) { | |
| // @group(0) @binding(0) | |
| // var a : texture_storage_1d<r32uint>; | |
| auto st = ty(Source{{12, 34}}, "texture_storage_1d", "r32uint"); | |
| GlobalVar("a", st, Group(0_a), Binding(0_a)); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), R"(12:34 error: 'texture_storage_1d' requires 2 template arguments)"); | |
| } | |
| TEST_F(StorageTextureAccessTest, RWAccess_Fail) { | |
| // @group(0) @binding(0) | |
| // var a : texture_storage_1d<r32uint, read_write>; | |
| auto st = ty.storage_texture(Source{{12, 34}}, type::TextureDimension::k1d, | |
| builtin::TexelFormat::kR32Uint, builtin::Access::kReadWrite); | |
| GlobalVar("a", st, Group(0_a), Binding(0_a)); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: storage textures currently only support 'write' access control"); | |
| } | |
| TEST_F(StorageTextureAccessTest, ReadOnlyAccess_Fail) { | |
| // @group(0) @binding(0) | |
| // var a : texture_storage_1d<r32uint, read>; | |
| auto st = ty.storage_texture(Source{{12, 34}}, type::TextureDimension::k1d, | |
| builtin::TexelFormat::kR32Uint, builtin::Access::kRead); | |
| GlobalVar("a", st, Group(0_a), Binding(0_a)); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: storage textures currently only support 'write' access control"); | |
| } | |
| TEST_F(StorageTextureAccessTest, WriteOnlyAccess_Pass) { | |
| // @group(0) @binding(0) | |
| // var a : texture_storage_1d<r32uint, write>; | |
| auto st = ty.storage_texture(type::TextureDimension::k1d, builtin::TexelFormat::kR32Uint, | |
| builtin::Access::kWrite); | |
| GlobalVar("a", st, Group(0_a), Binding(0_a)); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| } // namespace StorageTextureTests | |
| namespace MatrixTests { | |
| struct Params { | |
| uint32_t columns; | |
| uint32_t rows; | |
| builder::ast_type_func_ptr elem_ty; | |
| }; | |
| template <typename T> | |
| constexpr Params ParamsFor(uint32_t columns, uint32_t rows) { | |
| return Params{columns, rows, DataType<T>::AST}; | |
| } | |
| using ValidMatrixTypes = ResolverTestWithParam<Params>; | |
| TEST_P(ValidMatrixTypes, Okay) { | |
| // enable f16; | |
| // var a : matNxM<EL_TY>; | |
| auto& params = GetParam(); | |
| Enable(builtin::Extension::kF16); | |
| ast::Type el_ty = params.elem_ty(*this); | |
| GlobalVar("a", ty.mat(el_ty, params.columns, params.rows), builtin::AddressSpace::kPrivate); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest, | |
| ValidMatrixTypes, | |
| testing::Values(ParamsFor<f32>(2, 2), | |
| ParamsFor<f32>(2, 3), | |
| ParamsFor<f32>(2, 4), | |
| ParamsFor<f32>(3, 2), | |
| ParamsFor<f32>(3, 3), | |
| ParamsFor<f32>(3, 4), | |
| ParamsFor<f32>(4, 2), | |
| ParamsFor<f32>(4, 3), | |
| ParamsFor<f32>(4, 4), | |
| ParamsFor<alias<f32>>(4, 2), | |
| ParamsFor<alias<f32>>(4, 3), | |
| ParamsFor<alias<f32>>(4, 4), | |
| ParamsFor<f16>(2, 2), | |
| ParamsFor<f16>(2, 3), | |
| ParamsFor<f16>(2, 4), | |
| ParamsFor<f16>(3, 2), | |
| ParamsFor<f16>(3, 3), | |
| ParamsFor<f16>(3, 4), | |
| ParamsFor<f16>(4, 2), | |
| ParamsFor<f16>(4, 3), | |
| ParamsFor<f16>(4, 4), | |
| ParamsFor<alias<f16>>(4, 2), | |
| ParamsFor<alias<f16>>(4, 3), | |
| ParamsFor<alias<f16>>(4, 4))); | |
| using InvalidMatrixElementTypes = ResolverTestWithParam<Params>; | |
| TEST_P(InvalidMatrixElementTypes, InvalidElementType) { | |
| // enable f16; | |
| // var a : matNxM<EL_TY>; | |
| auto& params = GetParam(); | |
| Enable(builtin::Extension::kF16); | |
| ast::Type el_ty = params.elem_ty(*this); | |
| GlobalVar("a", ty.mat(Source{{12, 34}}, el_ty, params.columns, params.rows), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: matrix element type must be 'f32' or 'f16'"); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest, | |
| InvalidMatrixElementTypes, | |
| testing::Values(ParamsFor<bool>(4, 2), | |
| ParamsFor<i32>(4, 3), | |
| ParamsFor<u32>(4, 4), | |
| ParamsFor<vec2<f32>>(2, 2), | |
| ParamsFor<vec2<f16>>(2, 2), | |
| ParamsFor<vec3<i32>>(2, 3), | |
| ParamsFor<vec4<u32>>(2, 4), | |
| ParamsFor<mat2x2<f32>>(3, 2), | |
| ParamsFor<mat3x3<f32>>(3, 3), | |
| ParamsFor<mat4x4<f32>>(3, 4), | |
| ParamsFor<mat2x2<f16>>(3, 2), | |
| ParamsFor<mat3x3<f16>>(3, 3), | |
| ParamsFor<mat4x4<f16>>(3, 4), | |
| ParamsFor<array<f32, 2>>(4, 2), | |
| ParamsFor<array<f16, 2>>(4, 2))); | |
| } // namespace MatrixTests | |
| namespace VectorTests { | |
| struct Params { | |
| uint32_t width; | |
| builder::ast_type_func_ptr elem_ty; | |
| }; | |
| template <typename T> | |
| constexpr Params ParamsFor(uint32_t width) { | |
| return Params{width, DataType<T>::AST}; | |
| } | |
| using ValidVectorTypes = ResolverTestWithParam<Params>; | |
| TEST_P(ValidVectorTypes, Okay) { | |
| // enable f16; | |
| // var a : vecN<EL_TY>; | |
| auto& params = GetParam(); | |
| Enable(builtin::Extension::kF16); | |
| GlobalVar("a", ty.vec(params.elem_ty(*this), params.width), builtin::AddressSpace::kPrivate); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest, | |
| ValidVectorTypes, | |
| testing::Values(ParamsFor<bool>(2), | |
| ParamsFor<f32>(2), | |
| ParamsFor<f16>(2), | |
| ParamsFor<i32>(2), | |
| ParamsFor<u32>(2), | |
| ParamsFor<bool>(3), | |
| ParamsFor<f32>(3), | |
| ParamsFor<f16>(3), | |
| ParamsFor<i32>(3), | |
| ParamsFor<u32>(3), | |
| ParamsFor<bool>(4), | |
| ParamsFor<f32>(4), | |
| ParamsFor<f16>(4), | |
| ParamsFor<i32>(4), | |
| ParamsFor<u32>(4), | |
| ParamsFor<alias<bool>>(4), | |
| ParamsFor<alias<f32>>(4), | |
| ParamsFor<alias<f16>>(4), | |
| ParamsFor<alias<i32>>(4), | |
| ParamsFor<alias<u32>>(4))); | |
| using InvalidVectorElementTypes = ResolverTestWithParam<Params>; | |
| TEST_P(InvalidVectorElementTypes, InvalidElementType) { | |
| // enable f16; | |
| // var a : vecN<EL_TY>; | |
| auto& params = GetParam(); | |
| Enable(builtin::Extension::kF16); | |
| GlobalVar("a", ty.vec(Source{{12, 34}}, params.elem_ty(*this), params.width), | |
| builtin::AddressSpace::kPrivate); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: vector element type must be 'bool', 'f32', 'f16', 'i32' or 'u32'"); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest, | |
| InvalidVectorElementTypes, | |
| testing::Values(ParamsFor<vec2<f32>>(2), | |
| ParamsFor<vec3<i32>>(2), | |
| ParamsFor<vec4<u32>>(2), | |
| ParamsFor<mat2x2<f32>>(2), | |
| ParamsFor<mat3x3<f16>>(2), | |
| ParamsFor<mat4x4<f32>>(2), | |
| ParamsFor<array<f32, 2>>(2))); | |
| } // namespace VectorTests | |
| namespace BuiltinTypeAliasTests { | |
| struct Params { | |
| const char* alias; | |
| builder::ast_type_func_ptr type; | |
| }; | |
| template <typename T> | |
| constexpr Params Case(const char* alias) { | |
| return Params{alias, DataType<T>::AST}; | |
| } | |
| using BuiltinTypeAliasTest = ResolverTestWithParam<Params>; | |
| TEST_P(BuiltinTypeAliasTest, CheckEquivalent) { | |
| // enable f16; | |
| // var aliased : vecTN; | |
| // var explicit : vecN<T>; | |
| // explicit = aliased; | |
| auto& params = GetParam(); | |
| Enable(builtin::Extension::kF16); | |
| WrapInFunction(Decl(Var("aliased", ty(params.alias))), | |
| Decl(Var("explicit", params.type(*this))), // | |
| Assign("explicit", "aliased")); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_P(BuiltinTypeAliasTest, Construct) { | |
| // enable f16; | |
| // var v : vecN<T> = vecTN(); | |
| auto& params = GetParam(); | |
| Enable(builtin::Extension::kF16); | |
| WrapInFunction(Decl(Var("v", params.type(*this), Call(params.alias)))); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest, | |
| BuiltinTypeAliasTest, | |
| testing::Values(Case<mat2x2<f32>>("mat2x2f"), | |
| Case<mat2x3<f32>>("mat2x3f"), | |
| Case<mat2x4<f32>>("mat2x4f"), | |
| Case<mat3x2<f32>>("mat3x2f"), | |
| Case<mat3x3<f32>>("mat3x3f"), | |
| Case<mat3x4<f32>>("mat3x4f"), | |
| Case<mat4x2<f32>>("mat4x2f"), | |
| Case<mat4x3<f32>>("mat4x3f"), | |
| Case<mat4x4<f32>>("mat4x4f"), | |
| Case<mat2x2<f16>>("mat2x2h"), | |
| Case<mat2x3<f16>>("mat2x3h"), | |
| Case<mat2x4<f16>>("mat2x4h"), | |
| Case<mat3x2<f16>>("mat3x2h"), | |
| Case<mat3x3<f16>>("mat3x3h"), | |
| Case<mat3x4<f16>>("mat3x4h"), | |
| Case<mat4x2<f16>>("mat4x2h"), | |
| Case<mat4x3<f16>>("mat4x3h"), | |
| Case<mat4x4<f16>>("mat4x4h"), | |
| Case<vec2<f32>>("vec2f"), | |
| Case<vec3<f32>>("vec3f"), | |
| Case<vec4<f32>>("vec4f"), | |
| Case<vec2<f16>>("vec2h"), | |
| Case<vec3<f16>>("vec3h"), | |
| Case<vec4<f16>>("vec4h"), | |
| Case<vec2<i32>>("vec2i"), | |
| Case<vec3<i32>>("vec3i"), | |
| Case<vec4<i32>>("vec4i"), | |
| Case<vec2<u32>>("vec2u"), | |
| Case<vec3<u32>>("vec3u"), | |
| Case<vec4<u32>>("vec4u"))); | |
| } // namespace BuiltinTypeAliasTests | |
| namespace TypeDoesNotTakeTemplateArgs { | |
| using ResolverUntemplatedTypeUsedWithTemplateArgs = ResolverTestWithParam<const char*>; | |
| TEST_P(ResolverUntemplatedTypeUsedWithTemplateArgs, Builtin_UseWithTemplateArgs) { | |
| // enable f16; | |
| // var<private> v : f32<true>; | |
| Enable(builtin::Extension::kF16); | |
| GlobalVar("v", builtin::AddressSpace::kPrivate, ty(Source{{12, 34}}, GetParam(), true)); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "12:34 error: type '" + std::string(GetParam()) + | |
| "' does not take template arguments"); | |
| } | |
| TEST_P(ResolverUntemplatedTypeUsedWithTemplateArgs, BuiltinAlias_UseWithTemplateArgs) { | |
| // enable f16; | |
| // alias A = f32; | |
| // var<private> v : A<true>; | |
| Enable(builtin::Extension::kF16); | |
| Alias(Source{{56, 78}}, "A", ty(GetParam())); | |
| GlobalVar("v", builtin::AddressSpace::kPrivate, ty(Source{{12, 34}}, "A", true)); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: type 'A' does not take template arguments | |
| 56:78 note: alias 'A' declared here)"); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(BuiltinTypes, | |
| ResolverUntemplatedTypeUsedWithTemplateArgs, | |
| testing::Values("bool", | |
| "f16", | |
| "f32", | |
| "i32", | |
| "u32", | |
| "mat2x2f", | |
| "mat2x2h", | |
| "mat2x3f", | |
| "mat2x3h", | |
| "mat2x4f", | |
| "mat2x4h", | |
| "mat3x2f", | |
| "mat3x2h", | |
| "mat3x3f", | |
| "mat3x3h", | |
| "mat3x4f", | |
| "mat3x4h", | |
| "mat4x2f", | |
| "mat4x2h", | |
| "mat4x3f", | |
| "mat4x3h", | |
| "mat4x4f", | |
| "mat4x4h", | |
| "vec2f", | |
| "vec2h", | |
| "vec2i", | |
| "vec2u", | |
| "vec3f", | |
| "vec3h", | |
| "vec3i", | |
| "vec3u", | |
| "vec4f", | |
| "vec4h", | |
| "vec4i", | |
| "vec4u")); | |
| TEST_F(ResolverUntemplatedTypeUsedWithTemplateArgs, Struct_UseWithTemplateArgs) { | |
| // struct S { | |
| // i: i32; | |
| // }; | |
| // var<private> v : S<true>; | |
| Structure(Source{{56, 78}}, "S", utils::Vector{Member("i", ty.i32())}); | |
| GlobalVar("v", builtin::AddressSpace::kPrivate, ty(Source{{12, 34}}, "S", true)); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| R"(12:34 error: type 'S' does not take template arguments | |
| 56:78 note: struct 'S' declared here)"); | |
| } | |
| } // namespace TypeDoesNotTakeTemplateArgs | |
| } // namespace | |
| } // namespace tint::resolver |