1 // Copyright 2021 The Tint Authors.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "src/ast/struct_block_decoration.h"
16 #include "src/resolver/resolver.h"
17 #include "src/resolver/resolver_test_helper.h"
18
19 #include "gmock/gmock.h"
20
21 namespace tint {
22 namespace resolver {
23 namespace {
24
25 struct ResolverVarLetValidationTest : public resolver::TestHelper,
26 public testing::Test {};
27
TEST_F(ResolverVarLetValidationTest,LetNoInitializer)28 TEST_F(ResolverVarLetValidationTest, LetNoInitializer) {
29 // let a : i32;
30 WrapInFunction(Const(Source{{12, 34}}, "a", ty.i32(), nullptr));
31
32 EXPECT_FALSE(r()->Resolve());
33 EXPECT_EQ(r()->error(),
34 "12:34 error: let declaration must have an initializer");
35 }
36
TEST_F(ResolverVarLetValidationTest,GlobalLetNoInitializer)37 TEST_F(ResolverVarLetValidationTest, GlobalLetNoInitializer) {
38 // let a : i32;
39 GlobalConst(Source{{12, 34}}, "a", ty.i32(), nullptr);
40
41 EXPECT_FALSE(r()->Resolve());
42 EXPECT_EQ(r()->error(),
43 "12:34 error: let declaration must have an initializer");
44 }
45
TEST_F(ResolverVarLetValidationTest,VarNoInitializerNoType)46 TEST_F(ResolverVarLetValidationTest, VarNoInitializerNoType) {
47 // var a;
48 WrapInFunction(Var(Source{{12, 34}}, "a", nullptr));
49
50 EXPECT_FALSE(r()->Resolve());
51 EXPECT_EQ(r()->error(),
52 "12:34 error: function scope var declaration requires a type or "
53 "initializer");
54 }
55
TEST_F(ResolverVarLetValidationTest,GlobalVarNoInitializerNoType)56 TEST_F(ResolverVarLetValidationTest, GlobalVarNoInitializerNoType) {
57 // var a;
58 Global(Source{{12, 34}}, "a", nullptr);
59
60 EXPECT_FALSE(r()->Resolve());
61 EXPECT_EQ(r()->error(),
62 "12:34 error: module scope var declaration requires a type and "
63 "initializer");
64 }
65
TEST_F(ResolverVarLetValidationTest,VarTypeNotStorable)66 TEST_F(ResolverVarLetValidationTest, VarTypeNotStorable) {
67 // var i : i32;
68 // var p : pointer<function, i32> = &v;
69 auto* i = Var("i", ty.i32(), ast::StorageClass::kNone);
70 auto* p =
71 Var(Source{{56, 78}}, "a", ty.pointer<i32>(ast::StorageClass::kFunction),
72 ast::StorageClass::kNone, AddressOf(Source{{12, 34}}, "i"));
73 WrapInFunction(i, p);
74
75 EXPECT_FALSE(r()->Resolve());
76 EXPECT_EQ(r()->error(),
77 "56:78 error: ptr<function, i32, read_write> cannot be used as the "
78 "type of a var");
79 }
80
TEST_F(ResolverVarLetValidationTest,LetTypeNotConstructible)81 TEST_F(ResolverVarLetValidationTest, LetTypeNotConstructible) {
82 // [[group(0), binding(0)]] var t1 : texture_2d<f32>;
83 // let t2 : t1;
84 auto* t1 =
85 Global("t1", ty.sampled_texture(ast::TextureDimension::k2d, ty.f32()),
86 GroupAndBinding(0, 0));
87 auto* t2 = Const(Source{{56, 78}}, "t2", nullptr, Expr(t1));
88 WrapInFunction(t2);
89
90 EXPECT_FALSE(r()->Resolve());
91 EXPECT_EQ(r()->error(),
92 "56:78 error: texture_2d<f32> cannot be used as the type of a let");
93 }
94
TEST_F(ResolverVarLetValidationTest,LetConstructorWrongType)95 TEST_F(ResolverVarLetValidationTest, LetConstructorWrongType) {
96 // var v : i32 = 2u
97 WrapInFunction(Const(Source{{3, 3}}, "v", ty.i32(), Expr(2u)));
98
99 EXPECT_FALSE(r()->Resolve());
100 EXPECT_EQ(
101 r()->error(),
102 R"(3:3 error: cannot initialize let of type 'i32' with value of type 'u32')");
103 }
104
TEST_F(ResolverVarLetValidationTest,VarConstructorWrongType)105 TEST_F(ResolverVarLetValidationTest, VarConstructorWrongType) {
106 // var v : i32 = 2u
107 WrapInFunction(
108 Var(Source{{3, 3}}, "v", ty.i32(), ast::StorageClass::kNone, Expr(2u)));
109
110 EXPECT_FALSE(r()->Resolve());
111 EXPECT_EQ(
112 r()->error(),
113 R"(3:3 error: cannot initialize var of type 'i32' with value of type 'u32')");
114 }
115
TEST_F(ResolverVarLetValidationTest,LetConstructorWrongTypeViaAlias)116 TEST_F(ResolverVarLetValidationTest, LetConstructorWrongTypeViaAlias) {
117 auto* a = Alias("I32", ty.i32());
118 WrapInFunction(Const(Source{{3, 3}}, "v", ty.Of(a), Expr(2u)));
119
120 EXPECT_FALSE(r()->Resolve());
121 EXPECT_EQ(
122 r()->error(),
123 R"(3:3 error: cannot initialize let of type 'i32' with value of type 'u32')");
124 }
125
TEST_F(ResolverVarLetValidationTest,VarConstructorWrongTypeViaAlias)126 TEST_F(ResolverVarLetValidationTest, VarConstructorWrongTypeViaAlias) {
127 auto* a = Alias("I32", ty.i32());
128 WrapInFunction(
129 Var(Source{{3, 3}}, "v", ty.Of(a), ast::StorageClass::kNone, Expr(2u)));
130
131 EXPECT_FALSE(r()->Resolve());
132 EXPECT_EQ(
133 r()->error(),
134 R"(3:3 error: cannot initialize var of type 'i32' with value of type 'u32')");
135 }
136
TEST_F(ResolverVarLetValidationTest,LetOfPtrConstructedWithRef)137 TEST_F(ResolverVarLetValidationTest, LetOfPtrConstructedWithRef) {
138 // var a : f32;
139 // let b : ptr<function,f32> = a;
140 const auto priv = ast::StorageClass::kFunction;
141 auto* var_a = Var("a", ty.f32(), priv);
142 auto* var_b =
143 Const(Source{{12, 34}}, "b", ty.pointer<float>(priv), Expr("a"), {});
144 WrapInFunction(var_a, var_b);
145
146 ASSERT_FALSE(r()->Resolve());
147
148 EXPECT_EQ(
149 r()->error(),
150 R"(12:34 error: cannot initialize let of type 'ptr<function, f32, read_write>' with value of type 'f32')");
151 }
152
TEST_F(ResolverVarLetValidationTest,LocalLetRedeclared)153 TEST_F(ResolverVarLetValidationTest, LocalLetRedeclared) {
154 // let l : f32 = 1.;
155 // let l : i32 = 0;
156 auto* l1 = Const("l", ty.f32(), Expr(1.f));
157 auto* l2 = Const(Source{{12, 34}}, "l", ty.i32(), Expr(0));
158 WrapInFunction(l1, l2);
159
160 EXPECT_FALSE(r()->Resolve());
161 EXPECT_EQ(
162 r()->error(),
163 "12:34 error: redeclaration of 'l'\nnote: 'l' previously declared here");
164 }
165
TEST_F(ResolverVarLetValidationTest,GlobalVarRedeclaredAsLocal)166 TEST_F(ResolverVarLetValidationTest, GlobalVarRedeclaredAsLocal) {
167 // var v : f32 = 2.1;
168 // fn my_func() {
169 // var v : f32 = 2.0;
170 // return 0;
171 // }
172
173 Global("v", ty.f32(), ast::StorageClass::kPrivate, Expr(2.1f));
174
175 WrapInFunction(Var(Source{{12, 34}}, "v", ty.f32(), ast::StorageClass::kNone,
176 Expr(2.0f)));
177
178 EXPECT_TRUE(r()->Resolve()) << r()->error();
179 }
180
TEST_F(ResolverVarLetValidationTest,VarRedeclaredInInnerBlock)181 TEST_F(ResolverVarLetValidationTest, VarRedeclaredInInnerBlock) {
182 // {
183 // var v : f32;
184 // { var v : f32; }
185 // }
186 auto* var_outer = Var("v", ty.f32(), ast::StorageClass::kNone);
187 auto* var_inner =
188 Var(Source{{12, 34}}, "v", ty.f32(), ast::StorageClass::kNone);
189 auto* inner = Block(Decl(var_inner));
190 auto* outer_body = Block(Decl(var_outer), inner);
191
192 WrapInFunction(outer_body);
193
194 EXPECT_TRUE(r()->Resolve()) << r()->error();
195 }
196
TEST_F(ResolverVarLetValidationTest,VarRedeclaredInIfBlock)197 TEST_F(ResolverVarLetValidationTest, VarRedeclaredInIfBlock) {
198 // {
199 // var v : f32 = 3.14;
200 // if (true) { var v : f32 = 2.0; }
201 // }
202 auto* var_a_float = Var("v", ty.f32(), ast::StorageClass::kNone, Expr(3.1f));
203
204 auto* var = Var(Source{{12, 34}}, "v", ty.f32(), ast::StorageClass::kNone,
205 Expr(2.0f));
206
207 auto* cond = Expr(true);
208 auto* body = Block(Decl(var));
209
210 auto* outer_body =
211 Block(Decl(var_a_float),
212 create<ast::IfStatement>(cond, body, ast::ElseStatementList{}));
213
214 WrapInFunction(outer_body);
215
216 EXPECT_TRUE(r()->Resolve()) << r()->error();
217 }
218
TEST_F(ResolverVarLetValidationTest,InferredPtrStorageAccessMismatch)219 TEST_F(ResolverVarLetValidationTest, InferredPtrStorageAccessMismatch) {
220 // struct Inner {
221 // arr: array<i32, 4>;
222 // }
223 // [[block]] struct S {
224 // inner: Inner;
225 // }
226 // [[group(0), binding(0)]] var<storage> s : S;
227 // fn f() {
228 // let p : pointer<storage, i32, read_write> = &s.inner.arr[2];
229 // }
230 auto* inner = Structure("Inner", {Member("arr", ty.array<i32, 4>())});
231 auto* buf = Structure("S", {Member("inner", ty.Of(inner))},
232 {create<ast::StructBlockDecoration>()});
233 auto* storage = Global("s", ty.Of(buf), ast::StorageClass::kStorage,
234 ast::DecorationList{
235 create<ast::BindingDecoration>(0),
236 create<ast::GroupDecoration>(0),
237 });
238
239 auto* expr =
240 IndexAccessor(MemberAccessor(MemberAccessor(storage, "inner"), "arr"), 4);
241 auto* ptr = Const(
242 Source{{12, 34}}, "p",
243 ty.pointer<i32>(ast::StorageClass::kStorage, ast::Access::kReadWrite),
244 AddressOf(expr));
245
246 WrapInFunction(ptr);
247
248 EXPECT_FALSE(r()->Resolve());
249 EXPECT_EQ(r()->error(),
250 "12:34 error: cannot initialize let of type "
251 "'ptr<storage, i32, read_write>' with value of type "
252 "'ptr<storage, i32, read>'");
253 }
254
TEST_F(ResolverVarLetValidationTest,NonConstructibleType_Atomic)255 TEST_F(ResolverVarLetValidationTest, NonConstructibleType_Atomic) {
256 auto* v = Var("v", ty.atomic(Source{{12, 34}}, ty.i32()));
257 WrapInFunction(v);
258
259 EXPECT_FALSE(r()->Resolve());
260 EXPECT_EQ(r()->error(),
261 "12:34 error: function variable must have a constructible type");
262 }
263
TEST_F(ResolverVarLetValidationTest,NonConstructibleType_RuntimeArray)264 TEST_F(ResolverVarLetValidationTest, NonConstructibleType_RuntimeArray) {
265 auto* s = Structure("S", {Member("m", ty.array(ty.i32()))}, {StructBlock()});
266 auto* v = Var("v", ty.Of(s));
267 WrapInFunction(v);
268
269 EXPECT_FALSE(r()->Resolve());
270 EXPECT_EQ(r()->error(),
271 "error: function variable must have a constructible type");
272 }
273
TEST_F(ResolverVarLetValidationTest,NonConstructibleType_Struct_WithAtomic)274 TEST_F(ResolverVarLetValidationTest, NonConstructibleType_Struct_WithAtomic) {
275 auto* s = Structure("S", {Member("m", ty.atomic(ty.i32()))});
276 auto* v = Var("v", ty.Of(s));
277 WrapInFunction(v);
278
279 EXPECT_FALSE(r()->Resolve());
280 EXPECT_EQ(r()->error(),
281 "error: function variable must have a constructible type");
282 }
283
TEST_F(ResolverVarLetValidationTest,NonConstructibleType_InferredType)284 TEST_F(ResolverVarLetValidationTest, NonConstructibleType_InferredType) {
285 // [[group(0), binding(0)]] var s : sampler;
286 // fn foo() {
287 // var v = s;
288 // }
289 Global("s", ty.sampler(ast::SamplerKind::kSampler), GroupAndBinding(0, 0));
290 auto* v = Var(Source{{12, 34}}, "v", nullptr, Expr("s"));
291 WrapInFunction(v);
292
293 EXPECT_FALSE(r()->Resolve());
294 EXPECT_EQ(r()->error(),
295 "12:34 error: function variable must have a constructible type");
296 }
297
TEST_F(ResolverVarLetValidationTest,InvalidStorageClassForInitializer)298 TEST_F(ResolverVarLetValidationTest, InvalidStorageClassForInitializer) {
299 // var<workgroup> v : f32 = 1.23;
300 Global(Source{{12, 34}}, "v", ty.f32(), ast::StorageClass::kWorkgroup,
301 Expr(1.23f));
302
303 EXPECT_FALSE(r()->Resolve());
304 EXPECT_EQ(r()->error(),
305 "12:34 error: var of storage class 'workgroup' cannot have "
306 "an initializer. var initializers are only supported for the "
307 "storage classes 'private' and 'function'");
308 }
309
310 } // namespace
311 } // namespace resolver
312 } // namespace tint
313