1 // Copyright 2020 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/override_decoration.h"
16 #include "src/reader/wgsl/parser_impl_test_helper.h"
17
18 namespace tint {
19 namespace reader {
20 namespace wgsl {
21 namespace {
22
TEST_F(ParserImplTest,GlobalConstantDecl)23 TEST_F(ParserImplTest, GlobalConstantDecl) {
24 auto p = parser("let a : f32 = 1.");
25 auto decos = p->decoration_list();
26 EXPECT_FALSE(decos.errored);
27 EXPECT_FALSE(decos.matched);
28 auto e = p->global_constant_decl(decos.value);
29 EXPECT_FALSE(p->has_error()) << p->error();
30 EXPECT_TRUE(e.matched);
31 EXPECT_FALSE(e.errored);
32 ASSERT_NE(e.value, nullptr);
33
34 EXPECT_TRUE(e->is_const);
35 EXPECT_EQ(e->symbol, p->builder().Symbols().Get("a"));
36 ASSERT_NE(e->type, nullptr);
37 EXPECT_TRUE(e->type->Is<ast::F32>());
38
39 EXPECT_EQ(e->source.range.begin.line, 1u);
40 EXPECT_EQ(e->source.range.begin.column, 5u);
41 EXPECT_EQ(e->source.range.end.line, 1u);
42 EXPECT_EQ(e->source.range.end.column, 6u);
43
44 ASSERT_NE(e->constructor, nullptr);
45 EXPECT_TRUE(e->constructor->Is<ast::LiteralExpression>());
46
47 EXPECT_FALSE(
48 ast::HasDecoration<ast::OverrideDecoration>(e.value->decorations));
49 }
50
TEST_F(ParserImplTest,GlobalConstantDecl_Inferred)51 TEST_F(ParserImplTest, GlobalConstantDecl_Inferred) {
52 auto p = parser("let a = 1.");
53 auto decos = p->decoration_list();
54 EXPECT_FALSE(decos.errored);
55 EXPECT_FALSE(decos.matched);
56 auto e = p->global_constant_decl(decos.value);
57 EXPECT_FALSE(p->has_error()) << p->error();
58 EXPECT_TRUE(e.matched);
59 EXPECT_FALSE(e.errored);
60 ASSERT_NE(e.value, nullptr);
61
62 EXPECT_TRUE(e->is_const);
63 EXPECT_EQ(e->symbol, p->builder().Symbols().Get("a"));
64 EXPECT_EQ(e->type, nullptr);
65
66 EXPECT_EQ(e->source.range.begin.line, 1u);
67 EXPECT_EQ(e->source.range.begin.column, 5u);
68 EXPECT_EQ(e->source.range.end.line, 1u);
69 EXPECT_EQ(e->source.range.end.column, 6u);
70
71 ASSERT_NE(e->constructor, nullptr);
72 EXPECT_TRUE(e->constructor->Is<ast::LiteralExpression>());
73
74 EXPECT_FALSE(
75 ast::HasDecoration<ast::OverrideDecoration>(e.value->decorations));
76 }
77
TEST_F(ParserImplTest,GlobalConstantDecl_InvalidExpression)78 TEST_F(ParserImplTest, GlobalConstantDecl_InvalidExpression) {
79 auto p = parser("let a : f32 = if (a) {}");
80 auto decos = p->decoration_list();
81 EXPECT_FALSE(decos.errored);
82 EXPECT_FALSE(decos.matched);
83 auto e = p->global_constant_decl(decos.value);
84 EXPECT_TRUE(p->has_error());
85 EXPECT_TRUE(e.errored);
86 EXPECT_FALSE(e.matched);
87 EXPECT_EQ(e.value, nullptr);
88 EXPECT_EQ(p->error(), "1:15: invalid type for const_expr");
89 }
90
TEST_F(ParserImplTest,GlobalConstantDecl_MissingExpression)91 TEST_F(ParserImplTest, GlobalConstantDecl_MissingExpression) {
92 auto p = parser("let a : f32 =");
93 auto decos = p->decoration_list();
94 EXPECT_FALSE(decos.errored);
95 EXPECT_FALSE(decos.matched);
96 auto e = p->global_constant_decl(decos.value);
97 EXPECT_TRUE(p->has_error());
98 EXPECT_TRUE(e.errored);
99 EXPECT_FALSE(e.matched);
100 EXPECT_EQ(e.value, nullptr);
101 EXPECT_EQ(p->error(), "1:14: unable to parse const_expr");
102 }
103
TEST_F(ParserImplTest,GlobalConstantDec_Override_WithId)104 TEST_F(ParserImplTest, GlobalConstantDec_Override_WithId) {
105 auto p = parser("[[override(7)]] let a : f32 = 1.");
106 auto decos = p->decoration_list();
107 EXPECT_FALSE(decos.errored);
108 EXPECT_TRUE(decos.matched);
109
110 auto e = p->global_constant_decl(decos.value);
111 EXPECT_FALSE(p->has_error()) << p->error();
112 EXPECT_TRUE(e.matched);
113 EXPECT_FALSE(e.errored);
114 ASSERT_NE(e.value, nullptr);
115
116 EXPECT_TRUE(e->is_const);
117 EXPECT_EQ(e->symbol, p->builder().Symbols().Get("a"));
118 ASSERT_NE(e->type, nullptr);
119 EXPECT_TRUE(e->type->Is<ast::F32>());
120
121 EXPECT_EQ(e->source.range.begin.line, 1u);
122 EXPECT_EQ(e->source.range.begin.column, 21u);
123 EXPECT_EQ(e->source.range.end.line, 1u);
124 EXPECT_EQ(e->source.range.end.column, 22u);
125
126 ASSERT_NE(e->constructor, nullptr);
127 EXPECT_TRUE(e->constructor->Is<ast::LiteralExpression>());
128
129 auto* override_deco =
130 ast::GetDecoration<ast::OverrideDecoration>(e.value->decorations);
131 ASSERT_NE(override_deco, nullptr);
132 EXPECT_TRUE(override_deco->has_value);
133 EXPECT_EQ(override_deco->value, 7u);
134 }
135
TEST_F(ParserImplTest,GlobalConstantDec_Override_WithoutId)136 TEST_F(ParserImplTest, GlobalConstantDec_Override_WithoutId) {
137 auto p = parser("[[override]] let a : f32 = 1.");
138 auto decos = p->decoration_list();
139 EXPECT_FALSE(decos.errored);
140 EXPECT_TRUE(decos.matched);
141
142 auto e = p->global_constant_decl(decos.value);
143 EXPECT_FALSE(p->has_error()) << p->error();
144 EXPECT_TRUE(e.matched);
145 EXPECT_FALSE(e.errored);
146 ASSERT_NE(e.value, nullptr);
147
148 EXPECT_TRUE(e->is_const);
149 EXPECT_EQ(e->symbol, p->builder().Symbols().Get("a"));
150 ASSERT_NE(e->type, nullptr);
151 EXPECT_TRUE(e->type->Is<ast::F32>());
152
153 EXPECT_EQ(e->source.range.begin.line, 1u);
154 EXPECT_EQ(e->source.range.begin.column, 18u);
155 EXPECT_EQ(e->source.range.end.line, 1u);
156 EXPECT_EQ(e->source.range.end.column, 19u);
157
158 ASSERT_NE(e->constructor, nullptr);
159 EXPECT_TRUE(e->constructor->Is<ast::LiteralExpression>());
160
161 auto* override_deco =
162 ast::GetDecoration<ast::OverrideDecoration>(e.value->decorations);
163 ASSERT_NE(override_deco, nullptr);
164 EXPECT_FALSE(override_deco->has_value);
165 }
166
TEST_F(ParserImplTest,GlobalConstantDec_Override_MissingId)167 TEST_F(ParserImplTest, GlobalConstantDec_Override_MissingId) {
168 auto p = parser("[[override()]] let a : f32 = 1.");
169 auto decos = p->decoration_list();
170 EXPECT_TRUE(decos.errored);
171 EXPECT_FALSE(decos.matched);
172
173 auto e = p->global_constant_decl(decos.value);
174 EXPECT_TRUE(e.matched);
175 EXPECT_FALSE(e.errored);
176 ASSERT_NE(e.value, nullptr);
177
178 EXPECT_TRUE(p->has_error());
179 EXPECT_EQ(p->error(),
180 "1:12: expected signed integer literal for override decoration");
181 }
182
TEST_F(ParserImplTest,GlobalConstantDec_Override_InvalidId)183 TEST_F(ParserImplTest, GlobalConstantDec_Override_InvalidId) {
184 auto p = parser("[[override(-7)]] let a : f32 = 1.");
185 auto decos = p->decoration_list();
186 EXPECT_TRUE(decos.errored);
187 EXPECT_FALSE(decos.matched);
188
189 auto e = p->global_constant_decl(decos.value);
190 EXPECT_TRUE(e.matched);
191 EXPECT_FALSE(e.errored);
192 ASSERT_NE(e.value, nullptr);
193
194 EXPECT_TRUE(p->has_error());
195 EXPECT_EQ(p->error(), "1:12: override decoration must be positive");
196 }
197
198 } // namespace
199 } // namespace wgsl
200 } // namespace reader
201 } // namespace tint
202