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,AssignmentStmt_Parses_ToVariable)22 TEST_F(ParserImplTest, AssignmentStmt_Parses_ToVariable) {
23 auto p = parser("a = 123");
24 auto e = p->assignment_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
30 ASSERT_TRUE(e->Is<ast::AssignmentStatement>());
31 ASSERT_NE(e->lhs, nullptr);
32 ASSERT_NE(e->rhs, nullptr);
33
34 ASSERT_TRUE(e->lhs->Is<ast::IdentifierExpression>());
35 auto* ident = e->lhs->As<ast::IdentifierExpression>();
36 EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));
37
38 ASSERT_NE(e->rhs, nullptr);
39 ASSERT_TRUE(e->rhs->Is<ast::SintLiteralExpression>());
40 EXPECT_EQ(e->rhs->As<ast::SintLiteralExpression>()->value, 123);
41 }
42
TEST_F(ParserImplTest,AssignmentStmt_Parses_ToMember)43 TEST_F(ParserImplTest, AssignmentStmt_Parses_ToMember) {
44 auto p = parser("a.b.c[2].d = 123");
45 auto e = p->assignment_stmt();
46 EXPECT_TRUE(e.matched);
47 EXPECT_FALSE(e.errored);
48 EXPECT_FALSE(p->has_error()) << p->error();
49 ASSERT_NE(e.value, nullptr);
50
51 ASSERT_TRUE(e->Is<ast::AssignmentStatement>());
52 ASSERT_NE(e->lhs, nullptr);
53 ASSERT_NE(e->rhs, nullptr);
54
55 ASSERT_NE(e->rhs, nullptr);
56 ASSERT_TRUE(e->rhs->Is<ast::SintLiteralExpression>());
57 EXPECT_EQ(e->rhs->As<ast::SintLiteralExpression>()->value, 123);
58
59 ASSERT_TRUE(e->lhs->Is<ast::MemberAccessorExpression>());
60 auto* mem = e->lhs->As<ast::MemberAccessorExpression>();
61
62 ASSERT_TRUE(mem->member->Is<ast::IdentifierExpression>());
63 auto* ident = mem->member->As<ast::IdentifierExpression>();
64 EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("d"));
65
66 ASSERT_TRUE(mem->structure->Is<ast::IndexAccessorExpression>());
67 auto* idx = mem->structure->As<ast::IndexAccessorExpression>();
68
69 ASSERT_NE(idx->index, nullptr);
70 ASSERT_TRUE(idx->index->Is<ast::SintLiteralExpression>());
71 EXPECT_EQ(idx->index->As<ast::SintLiteralExpression>()->value, 2);
72
73 ASSERT_TRUE(idx->object->Is<ast::MemberAccessorExpression>());
74 mem = idx->object->As<ast::MemberAccessorExpression>();
75 ASSERT_TRUE(mem->member->Is<ast::IdentifierExpression>());
76 ident = mem->member->As<ast::IdentifierExpression>();
77 EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("c"));
78
79 ASSERT_TRUE(mem->structure->Is<ast::MemberAccessorExpression>());
80 mem = mem->structure->As<ast::MemberAccessorExpression>();
81
82 ASSERT_TRUE(mem->structure->Is<ast::IdentifierExpression>());
83 ident = mem->structure->As<ast::IdentifierExpression>();
84 EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));
85
86 ASSERT_TRUE(mem->member->Is<ast::IdentifierExpression>());
87 ident = mem->member->As<ast::IdentifierExpression>();
88 EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("b"));
89 }
90
TEST_F(ParserImplTest,AssignmentStmt_Parses_ToPhony)91 TEST_F(ParserImplTest, AssignmentStmt_Parses_ToPhony) {
92 auto p = parser("_ = 123");
93 auto e = p->assignment_stmt();
94 EXPECT_TRUE(e.matched);
95 EXPECT_FALSE(e.errored);
96 EXPECT_FALSE(p->has_error()) << p->error();
97 ASSERT_NE(e.value, nullptr);
98
99 ASSERT_TRUE(e->Is<ast::AssignmentStatement>());
100 ASSERT_NE(e->lhs, nullptr);
101 ASSERT_NE(e->rhs, nullptr);
102
103 ASSERT_NE(e->rhs, nullptr);
104 ASSERT_TRUE(e->rhs->Is<ast::SintLiteralExpression>());
105 EXPECT_EQ(e->rhs->As<ast::SintLiteralExpression>()->value, 123);
106
107 ASSERT_TRUE(e->lhs->Is<ast::PhonyExpression>());
108 }
109
TEST_F(ParserImplTest,AssignmentStmt_MissingEqual)110 TEST_F(ParserImplTest, AssignmentStmt_MissingEqual) {
111 auto p = parser("a.b.c[2].d 123");
112 auto e = p->assignment_stmt();
113 EXPECT_FALSE(e.matched);
114 EXPECT_TRUE(e.errored);
115 EXPECT_TRUE(p->has_error());
116 EXPECT_EQ(e.value, nullptr);
117 EXPECT_EQ(p->error(), "1:12: expected '=' for assignment");
118 }
119
TEST_F(ParserImplTest,AssignmentStmt_InvalidLHS)120 TEST_F(ParserImplTest, AssignmentStmt_InvalidLHS) {
121 auto p = parser("if (true) {} = 123");
122 auto e = p->assignment_stmt();
123 EXPECT_FALSE(e.matched);
124 EXPECT_FALSE(e.errored);
125 EXPECT_FALSE(p->has_error()) << p->error();
126 EXPECT_EQ(e.value, nullptr);
127 }
128
TEST_F(ParserImplTest,AssignmentStmt_InvalidRHS)129 TEST_F(ParserImplTest, AssignmentStmt_InvalidRHS) {
130 auto p = parser("a.b.c[2].d = if (true) {}");
131 auto e = p->assignment_stmt();
132 EXPECT_FALSE(e.matched);
133 EXPECT_TRUE(e.errored);
134 EXPECT_EQ(e.value, nullptr);
135 EXPECT_TRUE(p->has_error());
136 EXPECT_EQ(p->error(), "1:14: unable to parse right side of assignment");
137 }
138
139 } // namespace
140 } // namespace wgsl
141 } // namespace reader
142 } // namespace tint
143