| // 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/resolver/resolver_test_helper.h" |
| #include "src/sem/reference_type.h" |
| |
| namespace tint { |
| namespace resolver { |
| namespace { |
| |
| // Helpers and typedefs |
| using builder::alias; |
| using builder::alias1; |
| using builder::alias2; |
| using builder::alias3; |
| using builder::CreatePtrs; |
| using builder::CreatePtrsFor; |
| using builder::DataType; |
| using builder::f32; |
| using builder::i32; |
| using builder::mat2x2; |
| using builder::mat2x3; |
| using builder::mat3x2; |
| using builder::mat3x3; |
| using builder::mat4x4; |
| using builder::u32; |
| using builder::vec2; |
| using builder::vec3; |
| using builder::vec4; |
| |
| class ResolverTypeConstructorValidationTest : public resolver::TestHelper, |
| public testing::Test {}; |
| |
| namespace InferTypeTest { |
| struct Params { |
| builder::ast_type_func_ptr create_rhs_ast_type; |
| builder::ast_expr_func_ptr create_rhs_ast_value; |
| builder::sem_type_func_ptr create_rhs_sem_type; |
| }; |
| |
| template <typename T> |
| constexpr Params ParamsFor() { |
| return Params{DataType<T>::AST, DataType<T>::Expr, DataType<T>::Sem}; |
| } |
| |
| TEST_F(ResolverTypeConstructorValidationTest, InferTypeTest_Simple) { |
| // var a = 1; |
| // var b = a; |
| auto* a = Var("a", nullptr, ast::StorageClass::kNone, Expr(1)); |
| auto* b = Var("b", nullptr, ast::StorageClass::kNone, Expr("a")); |
| auto* a_ident = Expr("a"); |
| auto* b_ident = Expr("b"); |
| |
| WrapInFunction(a, b, Assign(a_ident, "a"), Assign(b_ident, "b")); |
| |
| ASSERT_TRUE(r()->Resolve()) << r()->error(); |
| ASSERT_TRUE(TypeOf(a_ident)->Is<sem::Reference>()); |
| EXPECT_TRUE( |
| TypeOf(a_ident)->As<sem::Reference>()->StoreType()->Is<sem::I32>()); |
| EXPECT_EQ(TypeOf(a_ident)->As<sem::Reference>()->StorageClass(), |
| ast::StorageClass::kFunction); |
| ASSERT_TRUE(TypeOf(b_ident)->Is<sem::Reference>()); |
| EXPECT_TRUE( |
| TypeOf(b_ident)->As<sem::Reference>()->StoreType()->Is<sem::I32>()); |
| EXPECT_EQ(TypeOf(b_ident)->As<sem::Reference>()->StorageClass(), |
| ast::StorageClass::kFunction); |
| } |
| |
| using InferTypeTest_FromConstructorExpression = ResolverTestWithParam<Params>; |
| TEST_P(InferTypeTest_FromConstructorExpression, All) { |
| // e.g. for vec3<f32> |
| // { |
| // var a = vec3<f32>(0.0, 0.0, 0.0) |
| // } |
| auto& params = GetParam(); |
| |
| auto* constructor_expr = params.create_rhs_ast_value(*this, 0); |
| |
| auto* a = Var("a", nullptr, ast::StorageClass::kNone, constructor_expr); |
| // Self-assign 'a' to force the expression to be resolved so we can test its |
| // type below |
| auto* a_ident = Expr("a"); |
| WrapInFunction(Decl(a), Assign(a_ident, "a")); |
| |
| ASSERT_TRUE(r()->Resolve()) << r()->error(); |
| auto* got = TypeOf(a_ident); |
| auto* expected = create<sem::Reference>(params.create_rhs_sem_type(*this), |
| ast::StorageClass::kFunction, |
| ast::Access::kReadWrite); |
| ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n" |
| << "expected: " << FriendlyName(expected) << "\n"; |
| } |
| |
| static constexpr Params from_constructor_expression_cases[] = { |
| ParamsFor<bool>(), |
| ParamsFor<i32>(), |
| ParamsFor<u32>(), |
| ParamsFor<f32>(), |
| ParamsFor<vec3<i32>>(), |
| ParamsFor<vec3<u32>>(), |
| ParamsFor<vec3<f32>>(), |
| ParamsFor<mat3x3<f32>>(), |
| ParamsFor<alias<bool>>(), |
| ParamsFor<alias<i32>>(), |
| ParamsFor<alias<u32>>(), |
| ParamsFor<alias<f32>>(), |
| ParamsFor<alias<vec3<i32>>>(), |
| ParamsFor<alias<vec3<u32>>>(), |
| ParamsFor<alias<vec3<f32>>>(), |
| ParamsFor<alias<mat3x3<f32>>>(), |
| }; |
| INSTANTIATE_TEST_SUITE_P(ResolverTypeConstructorValidationTest, |
| InferTypeTest_FromConstructorExpression, |
| testing::ValuesIn(from_constructor_expression_cases)); |
| |
| using InferTypeTest_FromArithmeticExpression = ResolverTestWithParam<Params>; |
| TEST_P(InferTypeTest_FromArithmeticExpression, All) { |
| // e.g. for vec3<f32> |
| // { |
| // var a = vec3<f32>(2.0, 2.0, 2.0) * 3.0; |
| // } |
| auto& params = GetParam(); |
| |
| auto* arith_lhs_expr = params.create_rhs_ast_value(*this, 2); |
| auto* arith_rhs_expr = params.create_rhs_ast_value(*this, 3); |
| auto* constructor_expr = Mul(arith_lhs_expr, arith_rhs_expr); |
| |
| auto* a = Var("a", nullptr, constructor_expr); |
| // Self-assign 'a' to force the expression to be resolved so we can test its |
| // type below |
| auto* a_ident = Expr("a"); |
| WrapInFunction(Decl(a), Assign(a_ident, "a")); |
| |
| ASSERT_TRUE(r()->Resolve()) << r()->error(); |
| auto* got = TypeOf(a_ident); |
| auto* expected = create<sem::Reference>(params.create_rhs_sem_type(*this), |
| ast::StorageClass::kFunction, |
| ast::Access::kReadWrite); |
| ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n" |
| << "expected: " << FriendlyName(expected) << "\n"; |
| } |
| static constexpr Params from_arithmetic_expression_cases[] = { |
| ParamsFor<i32>(), ParamsFor<u32>(), ParamsFor<f32>(), |
| ParamsFor<vec3<f32>>(), ParamsFor<mat3x3<f32>>(), |
| |
| // TODO(amaiorano): Uncomment once https://crbug.com/tint/680 is fixed |
| // ParamsFor<alias<ty_i32>>(), |
| // ParamsFor<alias<ty_u32>>(), |
| // ParamsFor<alias<ty_f32>>(), |
| // ParamsFor<alias<ty_vec3<f32>>>(), |
| // ParamsFor<alias<ty_mat3x3<f32>>>(), |
| }; |
| INSTANTIATE_TEST_SUITE_P(ResolverTypeConstructorValidationTest, |
| InferTypeTest_FromArithmeticExpression, |
| testing::ValuesIn(from_arithmetic_expression_cases)); |
| |
| using InferTypeTest_FromCallExpression = ResolverTestWithParam<Params>; |
| TEST_P(InferTypeTest_FromCallExpression, All) { |
| // e.g. for vec3<f32> |
| // |
| // fn foo() -> vec3<f32> { |
| // return vec3<f32>(); |
| // } |
| // |
| // fn bar() |
| // { |
| // var a = foo(); |
| // } |
| auto& params = GetParam(); |
| |
| Func("foo", {}, params.create_rhs_ast_type(*this), |
| {Return(Construct(params.create_rhs_ast_type(*this)))}, {}); |
| |
| auto* a = Var("a", nullptr, Call("foo")); |
| // Self-assign 'a' to force the expression to be resolved so we can test its |
| // type below |
| auto* a_ident = Expr("a"); |
| WrapInFunction(Decl(a), Assign(a_ident, "a")); |
| |
| ASSERT_TRUE(r()->Resolve()) << r()->error(); |
| auto* got = TypeOf(a_ident); |
| auto* expected = create<sem::Reference>(params.create_rhs_sem_type(*this), |
| ast::StorageClass::kFunction, |
| ast::Access::kReadWrite); |
| ASSERT_EQ(got, expected) << "got: " << FriendlyName(got) << "\n" |
| << "expected: " << FriendlyName(expected) << "\n"; |
| } |
| static constexpr Params from_call_expression_cases[] = { |
| ParamsFor<bool>(), |
| ParamsFor<i32>(), |
| ParamsFor<u32>(), |
| ParamsFor<f32>(), |
| ParamsFor<vec3<i32>>(), |
| ParamsFor<vec3<u32>>(), |
| ParamsFor<vec3<f32>>(), |
| ParamsFor<mat3x3<f32>>(), |
| ParamsFor<alias<bool>>(), |
| ParamsFor<alias<i32>>(), |
| ParamsFor<alias<u32>>(), |
| ParamsFor<alias<f32>>(), |
| ParamsFor<alias<vec3<i32>>>(), |
| ParamsFor<alias<vec3<u32>>>(), |
| ParamsFor<alias<vec3<f32>>>(), |
| ParamsFor<alias<mat3x3<f32>>>(), |
| }; |
| INSTANTIATE_TEST_SUITE_P(ResolverTypeConstructorValidationTest, |
| InferTypeTest_FromCallExpression, |
| testing::ValuesIn(from_call_expression_cases)); |
| |
| } // namespace InferTypeTest |
| |
| namespace ConversionConstructorTest { |
| struct Params { |
| builder::ast_type_func_ptr lhs_type; |
| builder::ast_type_func_ptr rhs_type; |
| builder::ast_expr_func_ptr rhs_value_expr; |
| }; |
| |
| template <typename LhsType, typename RhsType> |
| constexpr Params ParamsFor() { |
| return Params{DataType<LhsType>::AST, DataType<RhsType>::AST, |
| DataType<RhsType>::Expr}; |
| } |
| |
| static constexpr Params valid_cases[] = { |
| // Direct init (non-conversions) |
| ParamsFor<bool, bool>(), // |
| ParamsFor<i32, i32>(), // |
| ParamsFor<u32, u32>(), // |
| ParamsFor<f32, f32>(), // |
| ParamsFor<vec3<bool>, vec3<bool>>(), // |
| ParamsFor<vec3<i32>, vec3<i32>>(), // |
| ParamsFor<vec3<u32>, vec3<u32>>(), // |
| ParamsFor<vec3<f32>, vec3<f32>>(), // |
| |
| // Splat |
| ParamsFor<vec3<bool>, bool>(), // |
| ParamsFor<vec3<i32>, i32>(), // |
| ParamsFor<vec3<u32>, u32>(), // |
| ParamsFor<vec3<f32>, f32>(), // |
| |
| // Conversion |
| ParamsFor<bool, u32>(), // |
| ParamsFor<bool, i32>(), // |
| ParamsFor<bool, f32>(), // |
| |
| ParamsFor<i32, u32>(), // |
| ParamsFor<i32, f32>(), // |
| |
| ParamsFor<u32, i32>(), // |
| ParamsFor<u32, f32>(), // |
| |
| ParamsFor<f32, u32>(), // |
| ParamsFor<f32, i32>(), // |
| |
| ParamsFor<vec3<bool>, vec3<u32>>(), // |
| ParamsFor<vec3<bool>, vec3<i32>>(), // |
| ParamsFor<vec3<bool>, vec3<f32>>(), // |
| |
| ParamsFor<vec3<i32>, vec3<u32>>(), // |
| ParamsFor<vec3<i32>, vec3<f32>>(), // |
| |
| ParamsFor<vec3<u32>, vec3<i32>>(), // |
| ParamsFor<vec3<u32>, vec3<f32>>(), // |
| |
| ParamsFor<vec3<f32>, vec3<u32>>(), // |
| ParamsFor<vec3<f32>, vec3<i32>>(), // |
| }; |
| |
| using ConversionConstructorValidTest = ResolverTestWithParam<Params>; |
| TEST_P(ConversionConstructorValidTest, All) { |
| auto& params = GetParam(); |
| |
| // var a : <lhs_type1> = <lhs_type2>(<rhs_type>(<rhs_value_expr>)); |
| auto* lhs_type1 = params.lhs_type(*this); |
| auto* lhs_type2 = params.lhs_type(*this); |
| auto* rhs_type = params.rhs_type(*this); |
| auto* rhs_value_expr = params.rhs_value_expr(*this, 0); |
| |
| std::stringstream ss; |
| ss << FriendlyName(lhs_type1) << " = " << FriendlyName(lhs_type2) << "(" |
| << FriendlyName(rhs_type) << "(<rhs value expr>))"; |
| SCOPED_TRACE(ss.str()); |
| |
| auto* a = Var("a", lhs_type1, ast::StorageClass::kNone, |
| Construct(lhs_type2, Construct(rhs_type, rhs_value_expr))); |
| |
| // Self-assign 'a' to force the expression to be resolved so we can test its |
| // type below |
| auto* a_ident = Expr("a"); |
| WrapInFunction(Decl(a), Assign(a_ident, "a")); |
| |
| ASSERT_TRUE(r()->Resolve()) << r()->error(); |
| } |
| INSTANTIATE_TEST_SUITE_P(ResolverTypeConstructorValidationTest, |
| ConversionConstructorValidTest, |
| testing::ValuesIn(valid_cases)); |
| |
| constexpr CreatePtrs all_types[] = { |
| CreatePtrsFor<bool>(), // |
| CreatePtrsFor<u32>(), // |
| CreatePtrsFor<i32>(), // |
| CreatePtrsFor<f32>(), // |
| CreatePtrsFor<vec3<bool>>(), // |
| CreatePtrsFor<vec3<i32>>(), // |
| CreatePtrsFor<vec3<u32>>(), // |
| CreatePtrsFor<vec3<f32>>(), // |
| CreatePtrsFor<mat3x3<i32>>(), // |
| CreatePtrsFor<mat3x3<u32>>(), // |
| CreatePtrsFor<mat3x3<f32>>(), // |
| CreatePtrsFor<mat2x3<i32>>(), // |
| CreatePtrsFor<mat2x3<u32>>(), // |
| CreatePtrsFor<mat2x3<f32>>(), // |
| CreatePtrsFor<mat3x2<i32>>(), // |
| CreatePtrsFor<mat3x2<u32>>(), // |
| CreatePtrsFor<mat3x2<f32>>() // |
| }; |
| |
| using ConversionConstructorInvalidTest = |
| ResolverTestWithParam<std::tuple<CreatePtrs, // lhs |
| CreatePtrs // rhs |
| >>; |
| TEST_P(ConversionConstructorInvalidTest, All) { |
| auto& params = GetParam(); |
| |
| auto& lhs_params = std::get<0>(params); |
| auto& rhs_params = std::get<1>(params); |
| |
| // Skip test for valid cases |
| for (auto& v : valid_cases) { |
| if (v.lhs_type == lhs_params.ast && v.rhs_type == rhs_params.ast && |
| v.rhs_value_expr == rhs_params.expr) { |
| return; |
| } |
| } |
| // Skip non-conversions |
| if (lhs_params.ast == rhs_params.ast) { |
| return; |
| } |
| |
| // var a : <lhs_type1> = <lhs_type2>(<rhs_type>(<rhs_value_expr>)); |
| auto* lhs_type1 = lhs_params.ast(*this); |
| auto* lhs_type2 = lhs_params.ast(*this); |
| auto* rhs_type = rhs_params.ast(*this); |
| auto* rhs_value_expr = rhs_params.expr(*this, 0); |
| |
| std::stringstream ss; |
| ss << FriendlyName(lhs_type1) << " = " << FriendlyName(lhs_type2) << "(" |
| << FriendlyName(rhs_type) << "(<rhs value expr>))"; |
| SCOPED_TRACE(ss.str()); |
| |
| auto* a = Var("a", lhs_type1, ast::StorageClass::kNone, |
| Construct(lhs_type2, Construct(rhs_type, rhs_value_expr))); |
| |
| // Self-assign 'a' to force the expression to be resolved so we can test its |
| // type below |
| auto* a_ident = Expr("a"); |
| WrapInFunction(Decl(a), Assign(a_ident, "a")); |
| |
| ASSERT_FALSE(r()->Resolve()); |
| } |
| INSTANTIATE_TEST_SUITE_P(ResolverTypeConstructorValidationTest, |
| ConversionConstructorInvalidTest, |
| testing::Combine(testing::ValuesIn(all_types), |
| testing::ValuesIn(all_types))); |
| |
| TEST_F(ResolverTypeConstructorValidationTest, |
| ConversionConstructorInvalid_TooManyInitializers) { |
| auto* a = Var("a", ty.f32(), ast::StorageClass::kNone, |
| Construct(Source{{12, 34}}, ty.f32(), Expr(1.0f), Expr(2.0f))); |
| WrapInFunction(a); |
| |
| ASSERT_FALSE(r()->Resolve()); |
| ASSERT_EQ(r()->error(), |
| "12:34 error: expected zero or one value in constructor, got 2"); |
| } |
| |
| TEST_F(ResolverTypeConstructorValidationTest, |
| ConversionConstructorInvalid_InvalidInitializer) { |
| auto* a = Var("a", ty.f32(), ast::StorageClass::kNone, |
| Construct(Source{{12, 34}}, ty.f32(), Expr(true))); |
| WrapInFunction(a); |
| |
| ASSERT_FALSE(r()->Resolve()); |
| ASSERT_EQ(r()->error(), |
| "12:34 error: cannot construct 'f32' with a value of type 'bool'"); |
| } |
| |
| } // namespace ConversionConstructorTest |
| |
| } // namespace |
| } // namespace resolver |
| } // namespace tint |