| // Copyright 2022 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/resolver/resolver.h" | |
| #include "gmock/gmock.h" | |
| #include "src/tint/resolver/resolver_test_helper.h" | |
| namespace tint::resolver { | |
| namespace { | |
| using ResolverIncrementDecrementValidationTest = ResolverTest; | |
| TEST_F(ResolverIncrementDecrementValidationTest, Increment_Signed) { | |
| // var a : i32 = 2; | |
| // a++; | |
| auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2)); | |
| WrapInFunction(var, Increment(Source{{12, 34}}, "a")); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, Decrement_Signed) { | |
| // var a : i32 = 2; | |
| // a--; | |
| auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2)); | |
| WrapInFunction(var, Decrement(Source{{12, 34}}, "a")); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, Increment_Unsigned) { | |
| // var a : u32 = 2u; | |
| // a++; | |
| auto* var = Var("a", ty.u32(), ast::StorageClass::kNone, Expr(2u)); | |
| WrapInFunction(var, Increment(Source{{12, 34}}, "a")); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, Decrement_Unsigned) { | |
| // var a : u32 = 2u; | |
| // a--; | |
| auto* var = Var("a", ty.u32(), ast::StorageClass::kNone, Expr(2u)); | |
| WrapInFunction(var, Decrement(Source{{12, 34}}, "a")); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, ThroughPointer) { | |
| // var a : i32; | |
| // let b : ptr<function,i32> = &a; | |
| // *b++; | |
| auto* var_a = Var("a", ty.i32(), ast::StorageClass::kFunction); | |
| auto* var_b = Let("b", ty.pointer<int>(ast::StorageClass::kFunction), | |
| AddressOf(Expr("a"))); | |
| WrapInFunction(var_a, var_b, Increment(Source{{12, 34}}, Deref("b"))); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, ThroughArray) { | |
| // var a : array<i32, 4>; | |
| // a[1]++; | |
| auto* var_a = Var("a", ty.array(ty.i32(), 4), ast::StorageClass::kNone); | |
| WrapInFunction(var_a, Increment(Source{{12, 34}}, IndexAccessor("a", 1))); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, ThroughVector_Index) { | |
| // var a : vec4<i32>; | |
| // a.y++; | |
| auto* var_a = Var("a", ty.vec4(ty.i32()), ast::StorageClass::kNone); | |
| WrapInFunction(var_a, Increment(Source{{12, 34}}, IndexAccessor("a", 1))); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, ThroughVector_Member) { | |
| // var a : vec4<i32>; | |
| // a.y++; | |
| auto* var_a = Var("a", ty.vec4(ty.i32()), ast::StorageClass::kNone); | |
| WrapInFunction(var_a, Increment(Source{{12, 34}}, MemberAccessor("a", "y"))); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, Float) { | |
| // var a : f32 = 2.0; | |
| // a++; | |
| auto* var = Var("a", ty.f32(), ast::StorageClass::kNone, Expr(2.f)); | |
| auto* inc = Increment(Expr(Source{{12, 34}}, "a")); | |
| WrapInFunction(var, inc); | |
| ASSERT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: increment statement can only be applied to an " | |
| "integer scalar"); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, Vector) { | |
| // var a : vec4<f32>; | |
| // a++; | |
| auto* var = Var("a", ty.vec4<i32>(), ast::StorageClass::kNone); | |
| auto* inc = Increment(Expr(Source{{12, 34}}, "a")); | |
| WrapInFunction(var, inc); | |
| ASSERT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "12:34 error: increment statement can only be applied to an " | |
| "integer scalar"); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, Atomic) { | |
| // var<workgroup> a : atomic<i32>; | |
| // a++; | |
| Global(Source{{12, 34}}, "a", ty.atomic(ty.i32()), | |
| ast::StorageClass::kWorkgroup); | |
| WrapInFunction(Increment(Expr(Source{{56, 78}}, "a"))); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), | |
| "56:78 error: increment statement can only be applied to an " | |
| "integer scalar"); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, Literal) { | |
| // 1++; | |
| WrapInFunction(Increment(Expr(Source{{56, 78}}, 1))); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "56:78 error: cannot modify value of type 'i32'"); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, Constant) { | |
| // let a = 1; | |
| // a++; | |
| auto* a = Let(Source{{12, 34}}, "a", nullptr, Expr(1)); | |
| WrapInFunction(a, Increment(Expr(Source{{56, 78}}, "a"))); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), R"(56:78 error: cannot modify constant value | |
| 12:34 note: 'a' is declared here:)"); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, Parameter) { | |
| // fn func(a : i32) | |
| // { | |
| // a++; | |
| // } | |
| auto* a = Param(Source{{12, 34}}, "a", ty.i32()); | |
| Func("func", {a}, ty.void_(), {Increment(Expr(Source{{56, 78}}, "a"))}); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), R"(56:78 error: cannot modify function parameter | |
| 12:34 note: 'a' is declared here:)"); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, ReturnValue) { | |
| // fn func() -> i32 { | |
| // return 0; | |
| // } | |
| // { | |
| // a++; | |
| // } | |
| Func("func", {}, ty.i32(), {Return(0)}); | |
| WrapInFunction(Increment(Call(Source{{56, 78}}, "func"))); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), R"(56:78 error: cannot modify value of type 'i32')"); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, ReadOnlyBuffer) { | |
| // @group(0) @binding(0) var<storage,read> a : i32; | |
| // { | |
| // a++; | |
| // } | |
| Global(Source{{12, 34}}, "a", ty.i32(), ast::StorageClass::kStorage, | |
| ast::Access::kRead, GroupAndBinding(0, 0)); | |
| WrapInFunction(Increment(Source{{56, 78}}, "a")); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ( | |
| r()->error(), | |
| "56:78 error: cannot modify read-only type 'ref<storage, i32, read>'"); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, Phony) { | |
| // _++; | |
| WrapInFunction(Increment(Phony(Source{{56, 78}}))); | |
| EXPECT_FALSE(r()->Resolve()); | |
| EXPECT_EQ(r()->error(), "56:78 error: cannot modify value of type 'void'"); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, InForLoopInit) { | |
| // var a : i32 = 2; | |
| // for (a++; ; ) { | |
| // break; | |
| // } | |
| auto* a = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2)); | |
| auto* loop = | |
| For(Increment(Source{{56, 78}}, "a"), nullptr, nullptr, Block(Break())); | |
| WrapInFunction(a, loop); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| TEST_F(ResolverIncrementDecrementValidationTest, InForLoopCont) { | |
| // var a : i32 = 2; | |
| // for (; ; a++) { | |
| // break; | |
| // } | |
| auto* a = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2)); | |
| auto* loop = | |
| For(nullptr, nullptr, Increment(Source{{56, 78}}, "a"), Block(Break())); | |
| WrapInFunction(a, loop); | |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); | |
| } | |
| } // namespace | |
| } // namespace tint::resolver |