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/resolver/resolver.h"
16
17 #include "gtest/gtest.h"
18 #include "src/resolver/resolver_test_helper.h"
19 #include "src/sem/expression.h"
20
21 namespace tint {
22 namespace resolver {
23 namespace {
24
25 using Scalar = sem::Constant::Scalar;
26
27 using ResolverConstantsTest = ResolverTest;
28
TEST_F(ResolverConstantsTest,Scalar_i32)29 TEST_F(ResolverConstantsTest, Scalar_i32) {
30 auto* expr = Expr(99);
31 WrapInFunction(expr);
32
33 EXPECT_TRUE(r()->Resolve()) << r()->error();
34
35 auto* sem = Sem().Get(expr);
36 EXPECT_NE(sem, nullptr);
37 EXPECT_TRUE(sem->Type()->Is<sem::I32>());
38 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
39 EXPECT_EQ(sem->ConstantValue().ElementType(), sem->Type());
40 ASSERT_EQ(sem->ConstantValue().Elements().size(), 1u);
41 EXPECT_EQ(sem->ConstantValue().Elements()[0].i32, 99);
42 }
43
TEST_F(ResolverConstantsTest,Scalar_u32)44 TEST_F(ResolverConstantsTest, Scalar_u32) {
45 auto* expr = Expr(99u);
46 WrapInFunction(expr);
47
48 EXPECT_TRUE(r()->Resolve()) << r()->error();
49
50 auto* sem = Sem().Get(expr);
51 EXPECT_NE(sem, nullptr);
52 EXPECT_TRUE(sem->Type()->Is<sem::U32>());
53 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
54 EXPECT_EQ(sem->ConstantValue().ElementType(), sem->Type());
55 ASSERT_EQ(sem->ConstantValue().Elements().size(), 1u);
56 EXPECT_EQ(sem->ConstantValue().Elements()[0].u32, 99u);
57 }
58
TEST_F(ResolverConstantsTest,Scalar_f32)59 TEST_F(ResolverConstantsTest, Scalar_f32) {
60 auto* expr = Expr(9.9f);
61 WrapInFunction(expr);
62
63 EXPECT_TRUE(r()->Resolve()) << r()->error();
64
65 auto* sem = Sem().Get(expr);
66 EXPECT_NE(sem, nullptr);
67 EXPECT_TRUE(sem->Type()->Is<sem::F32>());
68 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
69 EXPECT_EQ(sem->ConstantValue().ElementType(), sem->Type());
70 ASSERT_EQ(sem->ConstantValue().Elements().size(), 1u);
71 EXPECT_EQ(sem->ConstantValue().Elements()[0].f32, 9.9f);
72 }
73
TEST_F(ResolverConstantsTest,Scalar_bool)74 TEST_F(ResolverConstantsTest, Scalar_bool) {
75 auto* expr = Expr(true);
76 WrapInFunction(expr);
77
78 EXPECT_TRUE(r()->Resolve()) << r()->error();
79
80 auto* sem = Sem().Get(expr);
81 EXPECT_NE(sem, nullptr);
82 EXPECT_TRUE(sem->Type()->Is<sem::Bool>());
83 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
84 EXPECT_EQ(sem->ConstantValue().ElementType(), sem->Type());
85 ASSERT_EQ(sem->ConstantValue().Elements().size(), 1u);
86 EXPECT_EQ(sem->ConstantValue().Elements()[0].bool_, true);
87 }
88
TEST_F(ResolverConstantsTest,Vec3_ZeroInit_i32)89 TEST_F(ResolverConstantsTest, Vec3_ZeroInit_i32) {
90 auto* expr = vec3<i32>();
91 WrapInFunction(expr);
92
93 EXPECT_TRUE(r()->Resolve()) << r()->error();
94
95 auto* sem = Sem().Get(expr);
96 EXPECT_NE(sem, nullptr);
97 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
98 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::I32>());
99 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
100 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
101 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::I32>());
102 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
103 EXPECT_EQ(sem->ConstantValue().Elements()[0].i32, 0);
104 EXPECT_EQ(sem->ConstantValue().Elements()[1].i32, 0);
105 EXPECT_EQ(sem->ConstantValue().Elements()[2].i32, 0);
106 }
107
TEST_F(ResolverConstantsTest,Vec3_ZeroInit_u32)108 TEST_F(ResolverConstantsTest, Vec3_ZeroInit_u32) {
109 auto* expr = vec3<u32>();
110 WrapInFunction(expr);
111
112 EXPECT_TRUE(r()->Resolve()) << r()->error();
113
114 auto* sem = Sem().Get(expr);
115 EXPECT_NE(sem, nullptr);
116 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
117 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::U32>());
118 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
119 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
120 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::U32>());
121 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
122 EXPECT_EQ(sem->ConstantValue().Elements()[0].u32, 0u);
123 EXPECT_EQ(sem->ConstantValue().Elements()[1].u32, 0u);
124 EXPECT_EQ(sem->ConstantValue().Elements()[2].u32, 0u);
125 }
126
TEST_F(ResolverConstantsTest,Vec3_ZeroInit_f32)127 TEST_F(ResolverConstantsTest, Vec3_ZeroInit_f32) {
128 auto* expr = vec3<f32>();
129 WrapInFunction(expr);
130
131 EXPECT_TRUE(r()->Resolve()) << r()->error();
132
133 auto* sem = Sem().Get(expr);
134 EXPECT_NE(sem, nullptr);
135 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
136 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::F32>());
137 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
138 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
139 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::F32>());
140 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
141 EXPECT_EQ(sem->ConstantValue().Elements()[0].f32, 0u);
142 EXPECT_EQ(sem->ConstantValue().Elements()[1].f32, 0u);
143 EXPECT_EQ(sem->ConstantValue().Elements()[2].f32, 0u);
144 }
145
TEST_F(ResolverConstantsTest,Vec3_ZeroInit_bool)146 TEST_F(ResolverConstantsTest, Vec3_ZeroInit_bool) {
147 auto* expr = vec3<bool>();
148 WrapInFunction(expr);
149
150 EXPECT_TRUE(r()->Resolve()) << r()->error();
151
152 auto* sem = Sem().Get(expr);
153 EXPECT_NE(sem, nullptr);
154 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
155 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::Bool>());
156 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
157 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
158 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::Bool>());
159 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
160 EXPECT_EQ(sem->ConstantValue().Elements()[0].bool_, false);
161 EXPECT_EQ(sem->ConstantValue().Elements()[1].bool_, false);
162 EXPECT_EQ(sem->ConstantValue().Elements()[2].bool_, false);
163 }
164
TEST_F(ResolverConstantsTest,Vec3_Splat_i32)165 TEST_F(ResolverConstantsTest, Vec3_Splat_i32) {
166 auto* expr = vec3<i32>(99);
167 WrapInFunction(expr);
168
169 EXPECT_TRUE(r()->Resolve()) << r()->error();
170
171 auto* sem = Sem().Get(expr);
172 EXPECT_NE(sem, nullptr);
173 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
174 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::I32>());
175 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
176 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
177 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::I32>());
178 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
179 EXPECT_EQ(sem->ConstantValue().Elements()[0].i32, 99);
180 EXPECT_EQ(sem->ConstantValue().Elements()[1].i32, 99);
181 EXPECT_EQ(sem->ConstantValue().Elements()[2].i32, 99);
182 }
183
TEST_F(ResolverConstantsTest,Vec3_Splat_u32)184 TEST_F(ResolverConstantsTest, Vec3_Splat_u32) {
185 auto* expr = vec3<u32>(99u);
186 WrapInFunction(expr);
187
188 EXPECT_TRUE(r()->Resolve()) << r()->error();
189
190 auto* sem = Sem().Get(expr);
191 EXPECT_NE(sem, nullptr);
192 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
193 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::U32>());
194 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
195 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
196 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::U32>());
197 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
198 EXPECT_EQ(sem->ConstantValue().Elements()[0].u32, 99u);
199 EXPECT_EQ(sem->ConstantValue().Elements()[1].u32, 99u);
200 EXPECT_EQ(sem->ConstantValue().Elements()[2].u32, 99u);
201 }
202
TEST_F(ResolverConstantsTest,Vec3_Splat_f32)203 TEST_F(ResolverConstantsTest, Vec3_Splat_f32) {
204 auto* expr = vec3<f32>(9.9f);
205 WrapInFunction(expr);
206
207 EXPECT_TRUE(r()->Resolve()) << r()->error();
208
209 auto* sem = Sem().Get(expr);
210 EXPECT_NE(sem, nullptr);
211 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
212 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::F32>());
213 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
214 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
215 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::F32>());
216 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
217 EXPECT_EQ(sem->ConstantValue().Elements()[0].f32, 9.9f);
218 EXPECT_EQ(sem->ConstantValue().Elements()[1].f32, 9.9f);
219 EXPECT_EQ(sem->ConstantValue().Elements()[2].f32, 9.9f);
220 }
221
TEST_F(ResolverConstantsTest,Vec3_Splat_bool)222 TEST_F(ResolverConstantsTest, Vec3_Splat_bool) {
223 auto* expr = vec3<bool>(true);
224 WrapInFunction(expr);
225
226 EXPECT_TRUE(r()->Resolve()) << r()->error();
227
228 auto* sem = Sem().Get(expr);
229 EXPECT_NE(sem, nullptr);
230 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
231 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::Bool>());
232 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
233 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
234 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::Bool>());
235 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
236 EXPECT_EQ(sem->ConstantValue().Elements()[0].bool_, true);
237 EXPECT_EQ(sem->ConstantValue().Elements()[1].bool_, true);
238 EXPECT_EQ(sem->ConstantValue().Elements()[2].bool_, true);
239 }
240
TEST_F(ResolverConstantsTest,Vec3_FullConstruct_i32)241 TEST_F(ResolverConstantsTest, Vec3_FullConstruct_i32) {
242 auto* expr = vec3<i32>(1, 2, 3);
243 WrapInFunction(expr);
244
245 EXPECT_TRUE(r()->Resolve()) << r()->error();
246
247 auto* sem = Sem().Get(expr);
248 EXPECT_NE(sem, nullptr);
249 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
250 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::I32>());
251 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
252 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
253 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::I32>());
254 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
255 EXPECT_EQ(sem->ConstantValue().Elements()[0].i32, 1);
256 EXPECT_EQ(sem->ConstantValue().Elements()[1].i32, 2);
257 EXPECT_EQ(sem->ConstantValue().Elements()[2].i32, 3);
258 }
259
TEST_F(ResolverConstantsTest,Vec3_FullConstruct_u32)260 TEST_F(ResolverConstantsTest, Vec3_FullConstruct_u32) {
261 auto* expr = vec3<u32>(1u, 2u, 3u);
262 WrapInFunction(expr);
263
264 EXPECT_TRUE(r()->Resolve()) << r()->error();
265
266 auto* sem = Sem().Get(expr);
267 EXPECT_NE(sem, nullptr);
268 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
269 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::U32>());
270 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
271 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
272 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::U32>());
273 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
274 EXPECT_EQ(sem->ConstantValue().Elements()[0].u32, 1u);
275 EXPECT_EQ(sem->ConstantValue().Elements()[1].u32, 2u);
276 EXPECT_EQ(sem->ConstantValue().Elements()[2].u32, 3u);
277 }
278
TEST_F(ResolverConstantsTest,Vec3_FullConstruct_f32)279 TEST_F(ResolverConstantsTest, Vec3_FullConstruct_f32) {
280 auto* expr = vec3<f32>(1.f, 2.f, 3.f);
281 WrapInFunction(expr);
282
283 EXPECT_TRUE(r()->Resolve()) << r()->error();
284
285 auto* sem = Sem().Get(expr);
286 EXPECT_NE(sem, nullptr);
287 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
288 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::F32>());
289 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
290 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
291 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::F32>());
292 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
293 EXPECT_EQ(sem->ConstantValue().Elements()[0].f32, 1.f);
294 EXPECT_EQ(sem->ConstantValue().Elements()[1].f32, 2.f);
295 EXPECT_EQ(sem->ConstantValue().Elements()[2].f32, 3.f);
296 }
297
TEST_F(ResolverConstantsTest,Vec3_FullConstruct_bool)298 TEST_F(ResolverConstantsTest, Vec3_FullConstruct_bool) {
299 auto* expr = vec3<bool>(true, false, true);
300 WrapInFunction(expr);
301
302 EXPECT_TRUE(r()->Resolve()) << r()->error();
303
304 auto* sem = Sem().Get(expr);
305 EXPECT_NE(sem, nullptr);
306 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
307 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::Bool>());
308 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
309 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
310 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::Bool>());
311 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
312 EXPECT_EQ(sem->ConstantValue().Elements()[0].bool_, true);
313 EXPECT_EQ(sem->ConstantValue().Elements()[1].bool_, false);
314 EXPECT_EQ(sem->ConstantValue().Elements()[2].bool_, true);
315 }
316
TEST_F(ResolverConstantsTest,Vec3_MixConstruct_i32)317 TEST_F(ResolverConstantsTest, Vec3_MixConstruct_i32) {
318 auto* expr = vec3<i32>(1, vec2<i32>(2, 3));
319 WrapInFunction(expr);
320
321 EXPECT_TRUE(r()->Resolve()) << r()->error();
322
323 auto* sem = Sem().Get(expr);
324 EXPECT_NE(sem, nullptr);
325 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
326 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::I32>());
327 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
328 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
329 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::I32>());
330 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
331 EXPECT_EQ(sem->ConstantValue().Elements()[0].i32, 1);
332 EXPECT_EQ(sem->ConstantValue().Elements()[1].i32, 2);
333 EXPECT_EQ(sem->ConstantValue().Elements()[2].i32, 3);
334 }
335
TEST_F(ResolverConstantsTest,Vec3_MixConstruct_u32)336 TEST_F(ResolverConstantsTest, Vec3_MixConstruct_u32) {
337 auto* expr = vec3<u32>(vec2<u32>(1u, 2u), 3u);
338 WrapInFunction(expr);
339
340 EXPECT_TRUE(r()->Resolve()) << r()->error();
341
342 auto* sem = Sem().Get(expr);
343 EXPECT_NE(sem, nullptr);
344 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
345 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::U32>());
346 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
347 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
348 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::U32>());
349 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
350 EXPECT_EQ(sem->ConstantValue().Elements()[0].u32, 1u);
351 EXPECT_EQ(sem->ConstantValue().Elements()[1].u32, 2u);
352 EXPECT_EQ(sem->ConstantValue().Elements()[2].u32, 3u);
353 }
354
TEST_F(ResolverConstantsTest,Vec3_MixConstruct_f32)355 TEST_F(ResolverConstantsTest, Vec3_MixConstruct_f32) {
356 auto* expr = vec3<f32>(1.f, vec2<f32>(2.f, 3.f));
357 WrapInFunction(expr);
358
359 EXPECT_TRUE(r()->Resolve()) << r()->error();
360
361 auto* sem = Sem().Get(expr);
362 EXPECT_NE(sem, nullptr);
363 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
364 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::F32>());
365 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
366 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
367 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::F32>());
368 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
369 EXPECT_EQ(sem->ConstantValue().Elements()[0].f32, 1.f);
370 EXPECT_EQ(sem->ConstantValue().Elements()[1].f32, 2.f);
371 EXPECT_EQ(sem->ConstantValue().Elements()[2].f32, 3.f);
372 }
373
TEST_F(ResolverConstantsTest,Vec3_MixConstruct_bool)374 TEST_F(ResolverConstantsTest, Vec3_MixConstruct_bool) {
375 auto* expr = vec3<bool>(vec2<bool>(true, false), true);
376 WrapInFunction(expr);
377
378 EXPECT_TRUE(r()->Resolve()) << r()->error();
379
380 auto* sem = Sem().Get(expr);
381 EXPECT_NE(sem, nullptr);
382 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
383 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::Bool>());
384 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
385 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
386 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::Bool>());
387 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
388 EXPECT_EQ(sem->ConstantValue().Elements()[0].bool_, true);
389 EXPECT_EQ(sem->ConstantValue().Elements()[1].bool_, false);
390 EXPECT_EQ(sem->ConstantValue().Elements()[2].bool_, true);
391 }
392
TEST_F(ResolverConstantsTest,Vec3_Cast_f32_to_32)393 TEST_F(ResolverConstantsTest, Vec3_Cast_f32_to_32) {
394 auto* expr = vec3<i32>(vec3<f32>(1.1f, 2.2f, 3.3f));
395 WrapInFunction(expr);
396
397 EXPECT_TRUE(r()->Resolve()) << r()->error();
398
399 auto* sem = Sem().Get(expr);
400 EXPECT_NE(sem, nullptr);
401 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
402 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::I32>());
403 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
404 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
405 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::I32>());
406 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
407 EXPECT_EQ(sem->ConstantValue().Elements()[0].i32, 1);
408 EXPECT_EQ(sem->ConstantValue().Elements()[1].i32, 2);
409 EXPECT_EQ(sem->ConstantValue().Elements()[2].i32, 3);
410 }
411
TEST_F(ResolverConstantsTest,Vec3_Cast_u32_to_f32)412 TEST_F(ResolverConstantsTest, Vec3_Cast_u32_to_f32) {
413 auto* expr = vec3<f32>(vec3<u32>(10u, 20u, 30u));
414 WrapInFunction(expr);
415
416 EXPECT_TRUE(r()->Resolve()) << r()->error();
417
418 auto* sem = Sem().Get(expr);
419 EXPECT_NE(sem, nullptr);
420 ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
421 EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::F32>());
422 EXPECT_EQ(sem->Type()->As<sem::Vector>()->Width(), 3u);
423 EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
424 EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::F32>());
425 ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
426 EXPECT_EQ(sem->ConstantValue().Elements()[0].f32, 10.f);
427 EXPECT_EQ(sem->ConstantValue().Elements()[1].f32, 20.f);
428 EXPECT_EQ(sem->ConstantValue().Elements()[2].f32, 30.f);
429 }
430
431 } // namespace
432 } // namespace resolver
433 } // namespace tint
434