reader/wgsl: Remove type tracking from the parser
This is the responsibility of the resolver, not the parser.
Required to handle out-of-order declarations.
Fixed: tint:888
Bug: tint:1266
Change-Id: I0cbdbe7f721a88bba89c0394a72a20e20b600000
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/69106
Reviewed-by: James Price <jrprice@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
diff --git a/src/reader/wgsl/parser_impl.cc b/src/reader/wgsl/parser_impl.cc
index 1aa16db..cac4b4e 100644
--- a/src/reader/wgsl/parser_impl.cc
+++ b/src/reader/wgsl/parser_impl.cc
@@ -322,18 +322,6 @@
return last_token_;
}
-void ParserImpl::register_type(const std::string& name,
- const ast::TypeDecl* type_decl) {
- registered_types_[name] = type_decl;
-}
-
-const ast::TypeDecl* ParserImpl::get_type(const std::string& name) {
- if (registered_types_.find(name) == registered_types_.end()) {
- return nullptr;
- }
- return registered_types_[name];
-}
-
bool ParserImpl::Parse() {
translation_unit();
return !has_error();
@@ -419,7 +407,6 @@
if (!expect("struct declaration", Token::Type::kSemicolon))
return Failure::kErrored;
- register_type(builder_.Symbols().NameFor(str.value->name), str.value);
builder_.AST().AddTypeDecl(str.value);
return true;
}
@@ -1006,10 +993,8 @@
if (!type.matched)
return add_error(peek(), "invalid type alias");
- auto* alias = builder_.ty.alias(make_source_range_from(t.source()),
- name.value, type.value);
- register_type(name.value, alias);
- return alias;
+ return builder_.ty.alias(make_source_range_from(t.source()), name.value,
+ type.value);
}
// type_decl
@@ -1059,11 +1044,6 @@
auto t = peek();
Source source;
if (match(Token::Type::kIdentifier, &source)) {
- // TODO(crbug.com/tint/697): Remove
- auto* ty = get_type(t.to_str());
- if (ty == nullptr)
- return add_error(t, "unknown type '" + t.to_str() + "'");
-
return builder_.create<ast::TypeName>(
source, builder_.Symbols().Register(t.to_str()));
}
@@ -2212,7 +2192,7 @@
return create<ast::BitcastExpression>(source, type.value, params.value);
}
- if (t.IsIdentifier() && !get_type(t.to_str())) {
+ if (t.IsIdentifier()) {
next();
auto* ident = create<ast::IdentifierExpression>(
@@ -2890,40 +2870,40 @@
return add_error(peek(), "unable to parse constant literal");
}
return lit.value;
- } else if (!t.IsIdentifier() || get_type(t.to_str())) {
- if (peek_is(Token::Type::kParenLeft, 1) ||
- peek_is(Token::Type::kLessThan, 1)) {
- auto type = expect_type("const_expr");
- if (type.errored) {
- return Failure::kErrored;
- }
+ }
- auto params = expect_paren_block(
- "type constructor", [&]() -> Expect<ast::ExpressionList> {
- ast::ExpressionList list;
- while (continue_parsing()) {
- if (peek_is(Token::Type::kParenRight)) {
- break;
- }
-
- auto arg = expect_const_expr();
- if (arg.errored) {
- return Failure::kErrored;
- }
- list.emplace_back(arg.value);
-
- if (!match(Token::Type::kComma)) {
- break;
- }
- }
- return list;
- });
-
- if (params.errored)
- return Failure::kErrored;
-
- return builder_.Construct(source, type.value, params.value);
+ if (peek_is(Token::Type::kParenLeft, 1) ||
+ peek_is(Token::Type::kLessThan, 1)) {
+ auto type = expect_type("const_expr");
+ if (type.errored) {
+ return Failure::kErrored;
}
+
+ auto params = expect_paren_block(
+ "type constructor", [&]() -> Expect<ast::ExpressionList> {
+ ast::ExpressionList list;
+ while (continue_parsing()) {
+ if (peek_is(Token::Type::kParenRight)) {
+ break;
+ }
+
+ auto arg = expect_const_expr();
+ if (arg.errored) {
+ return Failure::kErrored;
+ }
+ list.emplace_back(arg.value);
+
+ if (!match(Token::Type::kComma)) {
+ break;
+ }
+ }
+ return list;
+ });
+
+ if (params.errored)
+ return Failure::kErrored;
+
+ return builder_.Construct(source, type.value, params.value);
}
return add_error(peek(), "unable to parse const_expr");
}
diff --git a/src/reader/wgsl/parser_impl.h b/src/reader/wgsl/parser_impl.h
index 26601c4..e059f09 100644
--- a/src/reader/wgsl/parser_impl.h
+++ b/src/reader/wgsl/parser_impl.h
@@ -380,17 +380,6 @@
/// @param source the source to associate the error with
/// @param msg the warning message
void deprecated(const Source& source, const std::string& msg);
- /// Registers a declared type into the parser
- /// TODO(crbug.com/tint/724): Remove
- /// @param name the type name
- /// @param type_decl the type declaration
- void register_type(const std::string& name, const ast::TypeDecl* type_decl);
- /// Retrieves a declared type
- /// TODO(crbug.com/tint/724): Remove
- /// @param name The name to lookup
- /// @returns the declared type for `name` or `nullptr` if not found
- const ast::TypeDecl* get_type(const std::string& name);
-
/// Parses the `translation_unit` grammar element
void translation_unit();
/// Parses the `global_decl` grammar element, erroring on parse failure.
@@ -893,7 +882,6 @@
uint32_t parse_depth_ = 0;
std::vector<Token::Type> sync_tokens_;
int silence_errors_ = 0;
- std::unordered_map<std::string, const ast::TypeDecl*> registered_types_;
ProgramBuilder builder_;
size_t max_errors_ = 25;
};
diff --git a/src/reader/wgsl/parser_impl_const_expr_test.cc b/src/reader/wgsl/parser_impl_const_expr_test.cc
index e31763f..9d3dab8 100644
--- a/src/reader/wgsl/parser_impl_const_expr_test.cc
+++ b/src/reader/wgsl/parser_impl_const_expr_test.cc
@@ -124,25 +124,17 @@
EXPECT_EQ(p->error(), "1:1: unable to parse const_expr");
}
-TEST_F(ParserImplTest, ConstExpr_RegisteredType) {
+TEST_F(ParserImplTest, ConstExpr_TypeConstructor) {
auto p = parser("S(0)");
- auto* mem = Member("m", ty.i32(), ast::DecorationList{});
- auto* s = Structure(Sym("S"), {mem});
- p->register_type("S", s);
-
auto e = p->expect_const_expr();
ASSERT_FALSE(e.errored);
ASSERT_TRUE(e->Is<ast::CallExpression>());
-}
-
-TEST_F(ParserImplTest, ConstExpr_NotRegisteredType) {
- auto p = parser("S(0)");
- auto e = p->expect_const_expr();
- ASSERT_TRUE(p->has_error());
- ASSERT_TRUE(e.errored);
- ASSERT_EQ(e.value, nullptr);
- EXPECT_EQ(p->error(), "1:1: unable to parse const_expr");
+ ASSERT_NE(e->As<ast::CallExpression>()->target.type, nullptr);
+ ASSERT_TRUE(e->As<ast::CallExpression>()->target.type->Is<ast::TypeName>());
+ EXPECT_EQ(
+ e->As<ast::CallExpression>()->target.type->As<ast::TypeName>()->name,
+ p->builder().Symbols().Get("S"));
}
TEST_F(ParserImplTest, ConstExpr_Recursion) {
diff --git a/src/reader/wgsl/parser_impl_error_msg_test.cc b/src/reader/wgsl/parser_impl_error_msg_test.cc
index 132e143..a224585 100644
--- a/src/reader/wgsl/parser_impl_error_msg_test.cc
+++ b/src/reader/wgsl/parser_impl_error_msg_test.cc
@@ -494,22 +494,6 @@
" ^\n");
}
-TEST_F(ParserImplErrorTest, GlobalDeclConstNotConstExprWithParn) {
- EXPECT(
- "let a = 1;\n"
- "let b = a();",
- "test.wgsl:2:9 error: unable to parse const_expr\n"
- "let b = a();\n"
- " ^\n");
-}
-
-TEST_F(ParserImplErrorTest, GlobalDeclConstConstExprRegisteredType) {
- EXPECT("let a = S0(0);",
- "test.wgsl:1:9 error: unable to parse const_expr\n"
- "let a = S0(0);\n"
- " ^^\n");
-}
-
TEST_F(ParserImplErrorTest, GlobalDeclConstExprMaxDepth) {
uint32_t kMaxDepth = 128;
@@ -784,13 +768,6 @@
" ^\n");
}
-TEST_F(ParserImplErrorTest, GlobalDeclTypeInvalid) {
- EXPECT("var x : fish;",
- "test.wgsl:1:9 error: unknown type 'fish'\n"
- "var x : fish;\n"
- " ^^^^\n");
-}
-
TEST_F(ParserImplErrorTest, GlobalDeclTypeDecoInvalid) {
EXPECT("var x : [[]] i32;",
"test.wgsl:1:11 error: empty decoration list\n"
diff --git a/src/reader/wgsl/parser_impl_function_header_test.cc b/src/reader/wgsl/parser_impl_function_header_test.cc
index b17581e..369e8d0 100644
--- a/src/reader/wgsl/parser_impl_function_header_test.cc
+++ b/src/reader/wgsl/parser_impl_function_header_test.cc
@@ -141,15 +141,6 @@
EXPECT_EQ(p->error(), "1:10: expected ')' for function declaration");
}
-TEST_F(ParserImplTest, FunctionHeader_InvalidReturnType) {
- auto p = parser("fn main() -> invalid");
- auto f = p->function_header();
- EXPECT_FALSE(f.matched);
- EXPECT_TRUE(f.errored);
- EXPECT_TRUE(p->has_error());
- EXPECT_EQ(p->error(), "1:14: unknown type 'invalid'");
-}
-
TEST_F(ParserImplTest, FunctionHeader_MissingReturnType) {
auto p = parser("fn main() ->");
auto f = p->function_header();
diff --git a/src/reader/wgsl/parser_impl_global_constant_decl_test.cc b/src/reader/wgsl/parser_impl_global_constant_decl_test.cc
index f77aa31..2c4cd54 100644
--- a/src/reader/wgsl/parser_impl_global_constant_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_global_constant_decl_test.cc
@@ -75,19 +75,6 @@
ast::HasDecoration<ast::OverrideDecoration>(e.value->decorations));
}
-TEST_F(ParserImplTest, GlobalConstantDecl_InvalidVariable) {
- auto p = parser("let a : invalid = 1.");
- auto decos = p->decoration_list();
- EXPECT_FALSE(decos.errored);
- EXPECT_FALSE(decos.matched);
- auto e = p->global_constant_decl(decos.value);
- EXPECT_TRUE(p->has_error());
- EXPECT_TRUE(e.errored);
- EXPECT_FALSE(e.matched);
- EXPECT_EQ(e.value, nullptr);
- EXPECT_EQ(p->error(), "1:9: unknown type 'invalid'");
-}
-
TEST_F(ParserImplTest, GlobalConstantDecl_InvalidExpression) {
auto p = parser("let a : f32 = if (a) {}");
auto decos = p->decoration_list();
diff --git a/src/reader/wgsl/parser_impl_global_decl_test.cc b/src/reader/wgsl/parser_impl_global_decl_test.cc
index 8489fe6..97ec487 100644
--- a/src/reader/wgsl/parser_impl_global_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_global_decl_test.cc
@@ -44,13 +44,6 @@
EXPECT_EQ(p->error(), "1:16: expected ':' for variable declaration");
}
-TEST_F(ParserImplTest, GlobalDecl_GlobalVariable_Invalid) {
- auto p = parser("var<private> a : vec2<invalid>;");
- p->expect_global_decl();
- ASSERT_TRUE(p->has_error());
- EXPECT_EQ(p->error(), "1:23: unknown type 'invalid'");
-}
-
TEST_F(ParserImplTest, GlobalDecl_GlobalVariable_MissingSemicolon) {
auto p = parser("var<private> a : vec2<i32>");
p->expect_global_decl();
@@ -120,13 +113,6 @@
EXPECT_EQ(tn->name, str->name);
}
-TEST_F(ParserImplTest, GlobalDecl_TypeAlias_Invalid) {
- auto p = parser("type A = invalid;");
- p->expect_global_decl();
- ASSERT_TRUE(p->has_error());
- EXPECT_EQ(p->error(), "1:10: unknown type 'invalid'");
-}
-
TEST_F(ParserImplTest, GlobalDecl_TypeAlias_MissingSemicolon) {
auto p = parser("type A = i32");
p->expect_global_decl();
diff --git a/src/reader/wgsl/parser_impl_primary_expression_test.cc b/src/reader/wgsl/parser_impl_primary_expression_test.cc
index 0b5eac8..97fc0d1 100644
--- a/src/reader/wgsl/parser_impl_primary_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_primary_expression_test.cc
@@ -131,9 +131,8 @@
ASSERT_TRUE(e->Is<ast::CallExpression>());
auto* call = e->As<ast::CallExpression>();
- ASSERT_TRUE(call->target.type->Is<ast::TypeName>());
- EXPECT_EQ(call->target.type->As<ast::TypeName>()->name,
- p->builder().Symbols().Get("S"));
+ ASSERT_NE(call->target.name, nullptr);
+ EXPECT_EQ(call->target.name->symbol, p->builder().Symbols().Get("S"));
ASSERT_EQ(call->args.size(), 0u);
}
@@ -156,9 +155,8 @@
ASSERT_TRUE(e->Is<ast::CallExpression>());
auto* call = e->As<ast::CallExpression>();
- ASSERT_TRUE(call->target.type->Is<ast::TypeName>());
- EXPECT_EQ(call->target.type->As<ast::TypeName>()->name,
- p->builder().Symbols().Get("S"));
+ ASSERT_NE(call->target.name, nullptr);
+ EXPECT_EQ(call->target.name->symbol, p->builder().Symbols().Get("S"));
ASSERT_EQ(call->args.size(), 2u);
@@ -273,16 +271,6 @@
EXPECT_EQ(p->error(), "1:9: invalid type for bitcast expression");
}
-TEST_F(ParserImplTest, PrimaryExpression_Bitcast_InvalidType) {
- auto p = parser("bitcast<invalid>(1)");
- auto e = p->primary_expression();
- EXPECT_FALSE(e.matched);
- EXPECT_TRUE(e.errored);
- EXPECT_EQ(e.value, nullptr);
- ASSERT_TRUE(p->has_error());
- EXPECT_EQ(p->error(), "1:9: unknown type 'invalid'");
-}
-
TEST_F(ParserImplTest, PrimaryExpression_Bitcast_MissingLeftParen) {
auto p = parser("bitcast<f32>1)");
auto e = p->primary_expression();
diff --git a/src/reader/wgsl/parser_impl_struct_decl_test.cc b/src/reader/wgsl/parser_impl_struct_decl_test.cc
index e7c4e9f..4f041b5 100644
--- a/src/reader/wgsl/parser_impl_struct_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_struct_decl_test.cc
@@ -139,22 +139,6 @@
EXPECT_EQ(p->error(), "1:10: expected '{' for struct declaration");
}
-TEST_F(ParserImplTest, StructDecl_InvalidStructBody) {
- auto p = parser("struct S { a : B; }");
- auto decos = p->decoration_list();
- EXPECT_FALSE(decos.errored);
- EXPECT_FALSE(decos.matched);
- ASSERT_EQ(decos.value.size(), 0u);
-
- auto s = p->struct_decl(decos.value);
- EXPECT_TRUE(s.errored);
- EXPECT_FALSE(s.matched);
- EXPECT_EQ(s.value, nullptr);
-
- EXPECT_TRUE(p->has_error());
- EXPECT_EQ(p->error(), "1:16: unknown type 'B'");
-}
-
TEST_F(ParserImplTest, StructDecl_InvalidDecorationDecl) {
auto p = parser("[[block struct S { a : i32; }");
auto decos = p->decoration_list();
diff --git a/src/reader/wgsl/parser_impl_struct_member_test.cc b/src/reader/wgsl/parser_impl_struct_member_test.cc
index 8a514ac..0f0f980 100644
--- a/src/reader/wgsl/parser_impl_struct_member_test.cc
+++ b/src/reader/wgsl/parser_impl_struct_member_test.cc
@@ -162,19 +162,6 @@
"1:8: expected signed integer literal for size decoration");
}
-TEST_F(ParserImplTest, StructMember_InvalidVariable) {
- auto p = parser("[[size(4)]] a : B;");
- auto decos = p->decoration_list();
- EXPECT_FALSE(decos.errored);
- EXPECT_TRUE(decos.matched);
-
- auto m = p->expect_struct_member(decos.value);
- ASSERT_TRUE(p->has_error());
- ASSERT_TRUE(m.errored);
- ASSERT_EQ(m.value, nullptr);
- EXPECT_EQ(p->error(), "1:17: unknown type 'B'");
-}
-
TEST_F(ParserImplTest, StructMember_MissingSemicolon) {
auto p = parser("a : i32");
auto decos = p->decoration_list();
diff --git a/src/reader/wgsl/parser_impl_test.cc b/src/reader/wgsl/parser_impl_test.cc
index 4573ede..c354fc8 100644
--- a/src/reader/wgsl/parser_impl_test.cc
+++ b/src/reader/wgsl/parser_impl_test.cc
@@ -105,21 +105,6 @@
ASSERT_EQ(1u, p->program().AST().Functions().size());
}
-TEST_F(ParserImplTest, GetRegisteredType) {
- auto p = parser("");
- auto* alias = create<ast::Alias>(Sym("my_alias"), ty.i32());
- p->register_type("my_alias", alias);
-
- auto* got = p->get_type("my_alias");
- EXPECT_EQ(got, alias);
-}
-
-TEST_F(ParserImplTest, GetUnregisteredType) {
- auto p = parser("");
- auto* alias = p->get_type("my_alias");
- ASSERT_EQ(alias, nullptr);
-}
-
} // namespace
} // namespace wgsl
} // namespace reader
diff --git a/src/reader/wgsl/parser_impl_texture_sampler_types_test.cc b/src/reader/wgsl/parser_impl_texture_sampler_types_test.cc
index 970e430..fbd8127 100644
--- a/src/reader/wgsl/parser_impl_texture_sampler_types_test.cc
+++ b/src/reader/wgsl/parser_impl_texture_sampler_types_test.cc
@@ -110,16 +110,6 @@
EXPECT_EQ(t.value->source.range, (Source::Range{{1u, 1u}, {1u, 16u}}));
}
-TEST_F(ParserImplTest, TextureSamplerTypes_SampledTexture_Invalid) {
- auto p = parser("texture_1d<abc>");
- auto t = p->texture_sampler_types();
- ASSERT_TRUE(p->has_error());
- EXPECT_EQ(t.value, nullptr);
- EXPECT_FALSE(t.matched);
- EXPECT_TRUE(t.errored);
- EXPECT_EQ(p->error(), "1:12: unknown type 'abc'");
-}
-
TEST_F(ParserImplTest, TextureSamplerTypes_SampledTexture_MissingType) {
auto p = parser("texture_1d<>");
auto t = p->texture_sampler_types();
@@ -164,16 +154,6 @@
EXPECT_EQ(t.value->source.range, (Source::Range{{1u, 1u}, {1u, 29u}}));
}
-TEST_F(ParserImplTest, TextureSamplerTypes_MultisampledTexture_Invalid) {
- auto p = parser("texture_multisampled_2d<abc>");
- auto t = p->texture_sampler_types();
- ASSERT_TRUE(p->has_error());
- EXPECT_EQ(t.value, nullptr);
- EXPECT_FALSE(t.matched);
- EXPECT_TRUE(t.errored);
- EXPECT_EQ(p->error(), "1:25: unknown type 'abc'");
-}
-
TEST_F(ParserImplTest, TextureSamplerTypes_MultisampledTexture_MissingType) {
auto p = parser("texture_multisampled_2d<>");
auto t = p->texture_sampler_types();
diff --git a/src/reader/wgsl/parser_impl_type_alias_test.cc b/src/reader/wgsl/parser_impl_type_alias_test.cc
index 5f1e03d..45e2e32 100644
--- a/src/reader/wgsl/parser_impl_type_alias_test.cc
+++ b/src/reader/wgsl/parser_impl_type_alias_test.cc
@@ -37,9 +37,6 @@
TEST_F(ParserImplTest, TypeDecl_ParsesStruct_Ident) {
auto p = parser("type a = B");
- auto* str = p->builder().Structure(p->builder().Symbols().Register("B"), {});
- p->register_type("B", str);
-
auto t = p->type_alias();
EXPECT_FALSE(p->has_error());
EXPECT_FALSE(t.errored);
@@ -82,16 +79,6 @@
EXPECT_EQ(p->error(), "1:8: expected '=' for type alias");
}
-TEST_F(ParserImplTest, TypeDecl_InvalidType) {
- auto p = parser("type a = B");
- auto t = p->type_alias();
- EXPECT_TRUE(t.errored);
- EXPECT_FALSE(t.matched);
- EXPECT_TRUE(p->has_error());
- EXPECT_EQ(t.value, nullptr);
- EXPECT_EQ(p->error(), "1:10: unknown type 'B'");
-}
-
} // namespace
} // namespace wgsl
} // namespace reader
diff --git a/src/reader/wgsl/parser_impl_type_decl_test.cc b/src/reader/wgsl/parser_impl_type_decl_test.cc
index 17c3b20..d08a23d 100644
--- a/src/reader/wgsl/parser_impl_type_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_type_decl_test.cc
@@ -36,10 +36,6 @@
TEST_F(ParserImplTest, TypeDecl_Identifier) {
auto p = parser("A");
- auto& builder = p->builder();
- auto* alias_type = builder.ty.alias("A", builder.ty.i32());
- p->register_type("A", alias_type);
-
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
EXPECT_FALSE(t.errored);
@@ -50,17 +46,6 @@
EXPECT_EQ(type_name->source.range, (Source::Range{{1u, 1u}, {1u, 2u}}));
}
-TEST_F(ParserImplTest, TypeDecl_Identifier_NotFound) {
- auto p = parser("B");
-
- auto t = p->type_decl();
- EXPECT_TRUE(t.errored);
- EXPECT_FALSE(t.matched);
- ASSERT_EQ(t.value, nullptr);
- EXPECT_TRUE(p->has_error());
- EXPECT_EQ(p->error(), "1:1: unknown type 'B'");
-}
-
TEST_F(ParserImplTest, TypeDecl_Bool) {
auto p = parser("bool");
@@ -172,24 +157,6 @@
VecData{"vec3", 3, {}},
VecData{"vec4", 4, {}}));
-class VecBadType : public ParserImplTestWithParam<VecData> {};
-
-TEST_P(VecBadType, Handles_Unknown_Type) {
- auto params = GetParam();
- auto p = parser(params.input);
- auto t = p->type_decl();
- EXPECT_TRUE(t.errored);
- EXPECT_FALSE(t.matched);
- ASSERT_EQ(t.value, nullptr);
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(p->error(), "1:6: unknown type 'unknown'");
-}
-INSTANTIATE_TEST_SUITE_P(ParserImplTest,
- VecBadType,
- testing::Values(VecData{"vec2<unknown", 2, {}},
- VecData{"vec3<unknown", 3, {}},
- VecData{"vec4<unknown", 4, {}}));
-
class VecMissingType : public ParserImplTestWithParam<VecData> {};
TEST_P(VecMissingType, Handles_Missing_Type) {
@@ -358,16 +325,6 @@
ASSERT_EQ(p->error(), "1:5: invalid storage class for ptr declaration");
}
-TEST_F(ParserImplTest, TypeDecl_Ptr_BadType) {
- auto p = parser("ptr<function, unknown>");
- auto t = p->type_decl();
- EXPECT_TRUE(t.errored);
- EXPECT_FALSE(t.matched);
- ASSERT_EQ(t.value, nullptr);
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(p->error(), "1:15: unknown type 'unknown'");
-}
-
TEST_F(ParserImplTest, TypeDecl_Ptr_BadAccess) {
auto p = parser("ptr<function, i32, unknown>");
auto t = p->type_decl();
@@ -702,16 +659,6 @@
EXPECT_EQ(t.value->source.range, (Source::Range{{1u, 1u}, {1u, 17u}}));
}
-TEST_F(ParserImplTest, TypeDecl_Array_BadType) {
- auto p = parser("array<unknown, 3>");
- auto t = p->type_decl();
- EXPECT_TRUE(t.errored);
- EXPECT_FALSE(t.matched);
- ASSERT_EQ(t.value, nullptr);
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(p->error(), "1:7: unknown type 'unknown'");
-}
-
TEST_F(ParserImplTest, TypeDecl_Array_BadSize) {
auto p = parser("array<f32, !>");
auto t = p->type_decl();
@@ -851,31 +798,6 @@
MatrixData{"mat4x3 f32>", 4, 3, {}},
MatrixData{"mat4x4 f32>", 4, 4, {}}));
-class MatrixBadType : public ParserImplTestWithParam<MatrixData> {};
-
-TEST_P(MatrixBadType, Handles_Unknown_Type) {
- auto params = GetParam();
- auto p = parser(params.input);
- auto t = p->type_decl();
- EXPECT_TRUE(t.errored);
- EXPECT_FALSE(t.matched);
- ASSERT_EQ(t.value, nullptr);
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(p->error(), "1:8: unknown type 'unknown'");
-}
-INSTANTIATE_TEST_SUITE_P(
- ParserImplTest,
- MatrixBadType,
- testing::Values(MatrixData{"mat2x2<unknown>", 2, 2, {}},
- MatrixData{"mat2x3<unknown>", 2, 3, {}},
- MatrixData{"mat2x4<unknown>", 2, 4, {}},
- MatrixData{"mat3x2<unknown>", 3, 2, {}},
- MatrixData{"mat3x3<unknown>", 3, 3, {}},
- MatrixData{"mat3x4<unknown>", 3, 4, {}},
- MatrixData{"mat4x2<unknown>", 4, 2, {}},
- MatrixData{"mat4x3<unknown>", 4, 3, {}},
- MatrixData{"mat4x4<unknown>", 4, 4, {}}));
-
class MatrixMissingType : public ParserImplTestWithParam<MatrixData> {};
TEST_P(MatrixMissingType, Handles_Missing_Type) {
diff --git a/src/reader/wgsl/parser_impl_variable_ident_decl_test.cc b/src/reader/wgsl/parser_impl_variable_ident_decl_test.cc
index 0cf6a31..489463e 100644
--- a/src/reader/wgsl/parser_impl_variable_ident_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_variable_ident_decl_test.cc
@@ -76,14 +76,6 @@
ASSERT_EQ(p->error(), "1:1: expected identifier for test");
}
-TEST_F(ParserImplTest, VariableIdentDecl_InvalidType) {
- auto p = parser("my_var : invalid");
- auto decl = p->expect_variable_ident_decl("test");
- ASSERT_TRUE(p->has_error());
- ASSERT_TRUE(decl.errored);
- ASSERT_EQ(p->error(), "1:10: unknown type 'invalid'");
-}
-
TEST_F(ParserImplTest, VariableIdentDecl_NonAccessDecoFail) {
auto p = parser("my_var : [[stride(1)]] S");
@@ -95,10 +87,6 @@
ast::DecorationList decos;
decos.push_back(block_deco);
- auto* s = Structure(Sym("S"), members, decos);
-
- p->register_type("S", s);
-
auto decl = p->expect_variable_ident_decl("test");
ASSERT_TRUE(p->has_error());
ASSERT_TRUE(decl.errored);
diff --git a/src/reader/wgsl/parser_impl_variable_stmt_test.cc b/src/reader/wgsl/parser_impl_variable_stmt_test.cc
index 1d5748a..74f51f3 100644
--- a/src/reader/wgsl/parser_impl_variable_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_variable_stmt_test.cc
@@ -58,16 +58,6 @@
EXPECT_TRUE(e->variable->constructor->Is<ast::LiteralExpression>());
}
-TEST_F(ParserImplTest, VariableStmt_VariableDecl_Invalid) {
- auto p = parser("var a : invalid;");
- auto e = p->variable_stmt();
- EXPECT_FALSE(e.matched);
- EXPECT_TRUE(e.errored);
- EXPECT_EQ(e.value, nullptr);
- EXPECT_TRUE(p->has_error());
- EXPECT_EQ(p->error(), "1:9: unknown type 'invalid'");
-}
-
TEST_F(ParserImplTest, VariableStmt_VariableDecl_ConstructorInvalid) {
auto p = parser("var a : i32 = if(a) {}");
auto e = p->variable_stmt();
@@ -165,16 +155,6 @@
ASSERT_EQ(e->source.range.end.column, 6u);
}
-TEST_F(ParserImplTest, VariableStmt_Let_InvalidVarIdent) {
- auto p = parser("let a : invalid = 1");
- auto e = p->variable_stmt();
- EXPECT_FALSE(e.matched);
- EXPECT_TRUE(e.errored);
- EXPECT_EQ(e.value, nullptr);
- EXPECT_TRUE(p->has_error());
- EXPECT_EQ(p->error(), "1:9: unknown type 'invalid'");
-}
-
TEST_F(ParserImplTest, VariableStmt_Let_MissingEqual) {
auto p = parser("let a : i32 1");
auto e = p->variable_stmt();