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/reader/wgsl/parser_impl_test_helper.h"
16
17 namespace tint {
18 namespace reader {
19 namespace wgsl {
20 namespace {
21
TEST_F(ParserImplTest,VariableStmt_VariableDecl)22 TEST_F(ParserImplTest, VariableStmt_VariableDecl) {
23 auto p = parser("var a : i32;");
24 auto e = p->variable_stmt();
25 EXPECT_TRUE(e.matched);
26 EXPECT_FALSE(e.errored);
27 EXPECT_FALSE(p->has_error()) << p->error();
28 ASSERT_NE(e.value, nullptr);
29 ASSERT_TRUE(e->Is<ast::VariableDeclStatement>());
30 ASSERT_NE(e->variable, nullptr);
31 EXPECT_EQ(e->variable->symbol, p->builder().Symbols().Get("a"));
32
33 ASSERT_EQ(e->source.range.begin.line, 1u);
34 ASSERT_EQ(e->source.range.begin.column, 5u);
35 ASSERT_EQ(e->source.range.end.line, 1u);
36 ASSERT_EQ(e->source.range.end.column, 6u);
37
38 EXPECT_EQ(e->variable->constructor, nullptr);
39 }
40
TEST_F(ParserImplTest,VariableStmt_VariableDecl_WithInit)41 TEST_F(ParserImplTest, VariableStmt_VariableDecl_WithInit) {
42 auto p = parser("var a : i32 = 1;");
43 auto e = p->variable_stmt();
44 EXPECT_TRUE(e.matched);
45 EXPECT_FALSE(e.errored);
46 EXPECT_FALSE(p->has_error()) << p->error();
47 ASSERT_NE(e.value, nullptr);
48 ASSERT_TRUE(e->Is<ast::VariableDeclStatement>());
49 ASSERT_NE(e->variable, nullptr);
50 EXPECT_EQ(e->variable->symbol, p->builder().Symbols().Get("a"));
51
52 ASSERT_EQ(e->source.range.begin.line, 1u);
53 ASSERT_EQ(e->source.range.begin.column, 5u);
54 ASSERT_EQ(e->source.range.end.line, 1u);
55 ASSERT_EQ(e->source.range.end.column, 6u);
56
57 ASSERT_NE(e->variable->constructor, nullptr);
58 EXPECT_TRUE(e->variable->constructor->Is<ast::LiteralExpression>());
59 }
60
TEST_F(ParserImplTest,VariableStmt_VariableDecl_ConstructorInvalid)61 TEST_F(ParserImplTest, VariableStmt_VariableDecl_ConstructorInvalid) {
62 auto p = parser("var a : i32 = if(a) {}");
63 auto e = p->variable_stmt();
64 EXPECT_FALSE(e.matched);
65 EXPECT_TRUE(e.errored);
66 EXPECT_EQ(e.value, nullptr);
67 EXPECT_TRUE(p->has_error());
68 EXPECT_EQ(p->error(), "1:15: missing constructor for variable declaration");
69 }
70
TEST_F(ParserImplTest,VariableStmt_VariableDecl_ArrayInit)71 TEST_F(ParserImplTest, VariableStmt_VariableDecl_ArrayInit) {
72 auto p = parser("var a : array<i32> = array<i32>();");
73 auto e = p->variable_stmt();
74 EXPECT_TRUE(e.matched);
75 EXPECT_FALSE(e.errored);
76 EXPECT_FALSE(p->has_error()) << p->error();
77 ASSERT_NE(e.value, nullptr);
78 ASSERT_TRUE(e->Is<ast::VariableDeclStatement>());
79 ASSERT_NE(e->variable, nullptr);
80 EXPECT_EQ(e->variable->symbol, p->builder().Symbols().Get("a"));
81
82 ASSERT_NE(e->variable->constructor, nullptr);
83 auto* call = e->variable->constructor->As<ast::CallExpression>();
84 ASSERT_NE(call, nullptr);
85 EXPECT_EQ(call->target.name, nullptr);
86 EXPECT_NE(call->target.type, nullptr);
87 }
88
TEST_F(ParserImplTest,VariableStmt_VariableDecl_ArrayInit_NoSpace)89 TEST_F(ParserImplTest, VariableStmt_VariableDecl_ArrayInit_NoSpace) {
90 auto p = parser("var a : array<i32>=array<i32>();");
91 auto e = p->variable_stmt();
92 EXPECT_TRUE(e.matched);
93 EXPECT_FALSE(e.errored);
94 EXPECT_FALSE(p->has_error()) << p->error();
95 ASSERT_NE(e.value, nullptr);
96 ASSERT_TRUE(e->Is<ast::VariableDeclStatement>());
97 ASSERT_NE(e->variable, nullptr);
98 EXPECT_EQ(e->variable->symbol, p->builder().Symbols().Get("a"));
99
100 ASSERT_NE(e->variable->constructor, nullptr);
101 auto* call = e->variable->constructor->As<ast::CallExpression>();
102 ASSERT_NE(call, nullptr);
103 EXPECT_EQ(call->target.name, nullptr);
104 EXPECT_NE(call->target.type, nullptr);
105 }
106
TEST_F(ParserImplTest,VariableStmt_VariableDecl_VecInit)107 TEST_F(ParserImplTest, VariableStmt_VariableDecl_VecInit) {
108 auto p = parser("var a : vec2<i32> = vec2<i32>();");
109 auto e = p->variable_stmt();
110 EXPECT_TRUE(e.matched);
111 EXPECT_FALSE(e.errored);
112 EXPECT_FALSE(p->has_error()) << p->error();
113 ASSERT_NE(e.value, nullptr);
114 ASSERT_TRUE(e->Is<ast::VariableDeclStatement>());
115 ASSERT_NE(e->variable, nullptr);
116 EXPECT_EQ(e->variable->symbol, p->builder().Symbols().Get("a"));
117
118 ASSERT_NE(e->variable->constructor, nullptr);
119 auto* call = e->variable->constructor->As<ast::CallExpression>();
120 ASSERT_NE(call, nullptr);
121 EXPECT_EQ(call->target.name, nullptr);
122 EXPECT_NE(call->target.type, nullptr);
123 }
124
TEST_F(ParserImplTest,VariableStmt_VariableDecl_VecInit_NoSpace)125 TEST_F(ParserImplTest, VariableStmt_VariableDecl_VecInit_NoSpace) {
126 auto p = parser("var a : vec2<i32>=vec2<i32>();");
127 auto e = p->variable_stmt();
128 EXPECT_TRUE(e.matched);
129 EXPECT_FALSE(e.errored);
130 EXPECT_FALSE(p->has_error()) << p->error();
131 ASSERT_NE(e.value, nullptr);
132 ASSERT_TRUE(e->Is<ast::VariableDeclStatement>());
133 ASSERT_NE(e->variable, nullptr);
134 EXPECT_EQ(e->variable->symbol, p->builder().Symbols().Get("a"));
135
136 ASSERT_NE(e->variable->constructor, nullptr);
137 auto* call = e->variable->constructor->As<ast::CallExpression>();
138 ASSERT_NE(call, nullptr);
139 EXPECT_EQ(call->target.name, nullptr);
140 EXPECT_NE(call->target.type, nullptr);
141 }
142
TEST_F(ParserImplTest,VariableStmt_Let)143 TEST_F(ParserImplTest, VariableStmt_Let) {
144 auto p = parser("let a : i32 = 1");
145 auto e = p->variable_stmt();
146 EXPECT_TRUE(e.matched);
147 EXPECT_FALSE(e.errored);
148 EXPECT_FALSE(p->has_error()) << p->error();
149 ASSERT_NE(e.value, nullptr);
150 ASSERT_TRUE(e->Is<ast::VariableDeclStatement>());
151
152 ASSERT_EQ(e->source.range.begin.line, 1u);
153 ASSERT_EQ(e->source.range.begin.column, 5u);
154 ASSERT_EQ(e->source.range.end.line, 1u);
155 ASSERT_EQ(e->source.range.end.column, 6u);
156 }
157
TEST_F(ParserImplTest,VariableStmt_Let_MissingEqual)158 TEST_F(ParserImplTest, VariableStmt_Let_MissingEqual) {
159 auto p = parser("let a : i32 1");
160 auto e = p->variable_stmt();
161 EXPECT_FALSE(e.matched);
162 EXPECT_TRUE(e.errored);
163 EXPECT_EQ(e.value, nullptr);
164 EXPECT_TRUE(p->has_error());
165 EXPECT_EQ(p->error(), "1:13: expected '=' for let declaration");
166 }
167
TEST_F(ParserImplTest,VariableStmt_Let_MissingConstructor)168 TEST_F(ParserImplTest, VariableStmt_Let_MissingConstructor) {
169 auto p = parser("let a : i32 =");
170 auto e = p->variable_stmt();
171 EXPECT_FALSE(e.matched);
172 EXPECT_TRUE(e.errored);
173 EXPECT_EQ(e.value, nullptr);
174 EXPECT_TRUE(p->has_error());
175 EXPECT_EQ(p->error(), "1:14: missing constructor for let declaration");
176 }
177
TEST_F(ParserImplTest,VariableStmt_Let_InvalidConstructor)178 TEST_F(ParserImplTest, VariableStmt_Let_InvalidConstructor) {
179 auto p = parser("let a : i32 = if (a) {}");
180 auto e = p->variable_stmt();
181 EXPECT_FALSE(e.matched);
182 EXPECT_TRUE(e.errored);
183 EXPECT_EQ(e.value, nullptr);
184 EXPECT_TRUE(p->has_error());
185 EXPECT_EQ(p->error(), "1:15: missing constructor for let declaration");
186 }
187
188 } // namespace
189 } // namespace wgsl
190 } // namespace reader
191 } // namespace tint
192