encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-12-18 01:15:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename 'constructed types' to 'type declarartions'

Browse Source 
Change-Id: I0c79be17a10a542df602447e555c1344621d2dce
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/53803
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Antonio Maiorano <amaiorano@google.com>
This commit is contained in:
Ben Clayton
2021-06-09 14:32:14 +00:00
parent 8758f10a20
commit 950809f534
36 changed files with 141 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/reader/spirv/function.cc
View File

@@ -1044,7 +1044,7 @@ bool FunctionEmitter::EmitEntryPointAsWrapper() {
// Create and register the result type.
auto* str = create<ast::Struct>(Source{}, return_struct_sym, return_members,
ast::DecorationList{});
parser_impl_.AddConstructedType(return_struct_sym, str);
parser_impl_.AddTypeDecl(return_struct_sym, str);
return_type = builder_.ty.Of(str);
// Add the return-value statement.

10
src/reader/spirv/parser_impl.cc
View File

@@ -1033,14 +1033,14 @@ const Type* ParserImpl::ConvertType(
if (num_non_writable_members == members.size()) {
read_only_struct_types_.insert(ast_struct->name());
}
AddConstructedType(sym, ast_struct);
AddTypeDecl(sym, ast_struct);
return ty_.Struct(sym, std::move(ast_member_types));
}
void ParserImpl::AddConstructedType(Symbol name, ast::TypeDecl* decl) {
auto iter = constructed_types_.insert(name);
void ParserImpl::AddTypeDecl(Symbol name, ast::TypeDecl* decl) {
auto iter = declared_types_.insert(name);
if (iter.second) {
builder_.AST().AddConstructedType(decl);
builder_.AST().AddTypeDecl(decl);
}
}
@@ -1220,7 +1220,7 @@ const Type* ParserImpl::MaybeGenerateAlias(
builder_.ty.alias(sym, ast_underlying_type->Build(builder_));
// Record this new alias as the AST type for this SPIR-V ID.
AddConstructedType(sym, ast_alias_type);
AddTypeDecl(sym, ast_alias_type);
return ty_.Alias(sym, ast_underlying_type);
}

8
src/reader/spirv/parser_impl.h
View File

@@ -190,10 +190,10 @@ class ParserImpl : Reader {
const spvtools::opt::analysis::Type* type,
const Type* ast_type);
/// Adds `type` as a constructed type if it hasn't been added yet.
/// Adds `decl` as a declared type if it hasn't been added yet.
/// @param name the type's unique name
/// @param decl the type declaration to add
void AddConstructedType(Symbol name, ast::TypeDecl* decl);
void AddTypeDecl(Symbol name, ast::TypeDecl* decl);
/// @returns the fail stream object
FailStream& fail_stream() { return fail_stream_; }
@@ -760,9 +760,9 @@ class ParserImpl : Reader {
std::unordered_map<const spvtools::opt::Instruction*, const Pointer*>
handle_type_;
// Set of symbols of constructed types that have been added, used to avoid
// Set of symbols of declared type that have been added, used to avoid
// adding duplicates.
std::unordered_set<Symbol> constructed_types_;
std::unordered_set<Symbol> declared_types_;
/// Maps the SPIR-V ID of a module-scope builtin variable that should be
/// ignored or type-converted, to its builtin kind.

27
src/reader/wgsl/parser_impl.cc
View File

@@ -312,16 +312,16 @@ Token ParserImpl::last_token() const {
return last_token_;
}
void ParserImpl::register_constructed(const std::string& name,
const ast::TypeDecl* type_decl) {
registered_constructs_[name] = type_decl;
void ParserImpl::register_type(const std::string& name,
const ast::TypeDecl* type_decl) {
registered_types_[name] = type_decl;
}
const ast::TypeDecl* ParserImpl::get_constructed(const std::string& name) {
if (registered_constructs_.find(name) == registered_constructs_.end()) {
const ast::TypeDecl* ParserImpl::get_type(const std::string& name) {
if (registered_types_.find(name) == registered_types_.end()) {
return nullptr;
}
return registered_constructs_[name];
return registered_types_[name];
}
bool ParserImpl::Parse() {
@@ -397,7 +397,7 @@ Expect<bool> ParserImpl::expect_global_decl() {
if (!expect("type alias", Token::Type::kSemicolon))
return Failure::kErrored;
builder_.AST().AddConstructedType(const_cast<ast::Alias*>(ta.value));
builder_.AST().AddTypeDecl(const_cast<ast::Alias*>(ta.value));
return true;
}
@@ -409,9 +409,8 @@ Expect<bool> ParserImpl::expect_global_decl() {
if (!expect("struct declaration", Token::Type::kSemicolon))
return Failure::kErrored;
register_constructed(builder_.Symbols().NameFor(str.value->name()),
str.value);
builder_.AST().AddConstructedType(str.value);
register_type(builder_.Symbols().NameFor(str.value->name()), str.value);
builder_.AST().AddTypeDecl(str.value);
return true;
}
@@ -1032,7 +1031,7 @@ Maybe<ast::Alias*> ParserImpl::type_alias() {
auto* alias = builder_.ty.alias(make_source_range_from(t.source()),
name.value, type.value);
register_constructed(name.value, alias);
register_type(name.value, alias);
return alias;
}
@@ -1082,9 +1081,9 @@ Maybe<ast::Type*> ParserImpl::type_decl(ast::DecorationList& decos) {
Source source;
if (match(Token::Type::kIdentifier, &source)) {
// TODO(crbug.com/tint/697): Remove
auto* ty = get_constructed(t.to_str());
auto* ty = get_type(t.to_str());
if (ty == nullptr)
return add_error(t, "unknown constructed type '" + t.to_str() + "'");
return add_error(t, "unknown type '" + t.to_str() + "'");
return builder_.create<ast::TypeName>(
source, builder_.Symbols().Register(t.to_str()));
@@ -2242,7 +2241,7 @@ Maybe<ast::Expression*> ParserImpl::primary_expression() {
return create<ast::BitcastExpression>(source, type.value, params.value);
}
if (t.IsIdentifier() && !get_constructed(t.to_str())) {
if (t.IsIdentifier() && !get_type(t.to_str())) {
next();
auto* ident = create<ast::IdentifierExpression>(

17
src/reader/wgsl/parser_impl.h
View File

@@ -378,17 +378,16 @@ class ParserImpl {
/// @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 constructed type into the parser
/// Registers a declared type into the parser
/// TODO(crbug.com/tint/724): Remove
/// @param name the constructed name
/// @param type_decl the constructed type declaration
void register_constructed(const std::string& name,
const ast::TypeDecl* type_decl);
/// Retrieves a constructed type
/// @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 constructed type for `name` or `nullptr` if not found
const ast::TypeDecl* get_constructed(const std::string& name);
/// @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();
@@ -882,7 +881,7 @@ class ParserImpl {
uint32_t sync_depth_ = 0;
std::vector<Token::Type> sync_tokens_;
int silence_errors_ = 0;
std::unordered_map<std::string, const ast::TypeDecl*> registered_constructs_;
std::unordered_map<std::string, const ast::TypeDecl*> registered_types_;
ProgramBuilder builder_;
size_t max_errors_ = 25;
};

2
src/reader/wgsl/parser_impl_const_expr_test.cc
View File

@@ -134,7 +134,7 @@ TEST_F(ParserImplTest, ConstExpr_ConstLiteral_Invalid) {
ASSERT_TRUE(p->has_error());
ASSERT_TRUE(e.errored);
ASSERT_EQ(e.value, nullptr);
EXPECT_EQ(p->error(), "1:1: unknown constructed type 'invalid'");
EXPECT_EQ(p->error(), "1:1: unknown type 'invalid'");
}
TEST_F(ParserImplTest, ConstExpr_Recursion) {

4
src/reader/wgsl/parser_impl_error_msg_test.cc
View File

@@ -420,7 +420,7 @@ TEST_F(ParserImplErrorTest, FunctionMissingOpenLine) {
var a : f32 = bar[0];
return;
})",
"test.wgsl:2:17 error: unknown constructed type 'bar'\n"
"test.wgsl:2:17 error: unknown type 'bar'\n"
" var a : f32 = bar[0];\n"
" ^^^\n"
"\n"
@@ -733,7 +733,7 @@ TEST_F(ParserImplErrorTest, GlobalDeclTypeAliasMissingSemicolon) {
TEST_F(ParserImplErrorTest, GlobalDeclTypeInvalid) {
EXPECT("var x : fish;",
"test.wgsl:1:9 error: unknown constructed type 'fish'\n"
"test.wgsl:1:9 error: unknown type 'fish'\n"
"var x : fish;\n"
" ^^^^\n");
}

2
src/reader/wgsl/parser_impl_function_header_test.cc
View File

@@ -112,7 +112,7 @@ TEST_F(ParserImplTest, FunctionHeader_InvalidReturnType) {
EXPECT_FALSE(f.matched);
EXPECT_TRUE(f.errored);
EXPECT_TRUE(p->has_error());
EXPECT_EQ(p->error(), "1:14: unknown constructed type 'invalid'");
EXPECT_EQ(p->error(), "1:14: unknown type 'invalid'");
}
TEST_F(ParserImplTest, FunctionHeader_MissingReturnType) {

2
src/reader/wgsl/parser_impl_global_constant_decl_test.cc
View File

@@ -85,7 +85,7 @@ TEST_F(ParserImplTest, GlobalConstantDecl_InvalidVariable) {
EXPECT_TRUE(e.errored);
EXPECT_FALSE(e.matched);
EXPECT_EQ(e.value, nullptr);
EXPECT_EQ(p->error(), "1:9: unknown constructed type 'invalid'");
EXPECT_EQ(p->error(), "1:9: unknown type 'invalid'");
}
TEST_F(ParserImplTest, GlobalConstantDecl_InvalidExpression) {

37
src/reader/wgsl/parser_impl_global_decl_test.cc
View File

@@ -48,7 +48,7 @@ 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 constructed type 'invalid'");
EXPECT_EQ(p->error(), "1:23: unknown type 'invalid'");
}
TEST_F(ParserImplTest, GlobalDecl_GlobalVariable_MissingSemicolon) {
@@ -90,12 +90,11 @@ TEST_F(ParserImplTest, GlobalDecl_TypeAlias) {
ASSERT_FALSE(p->has_error()) << p->error();
auto program = p->program();
ASSERT_EQ(program.AST().ConstructedTypes().size(), 1u);
ASSERT_TRUE(program.AST().ConstructedTypes()[0]->Is<ast::Alias>());
EXPECT_EQ(
program.Symbols().NameFor(
program.AST().ConstructedTypes()[0]->As<ast::Alias>()->symbol()),
"A");
ASSERT_EQ(program.AST().TypeDecls().size(), 1u);
ASSERT_TRUE(program.AST().TypeDecls()[0]->Is<ast::Alias>());
EXPECT_EQ(program.Symbols().NameFor(
program.AST().TypeDecls()[0]->As<ast::Alias>()->symbol()),
"A");
}
TEST_F(ParserImplTest, GlobalDecl_TypeAlias_StructIdent) {
@@ -108,13 +107,13 @@ type B = A;)");
ASSERT_FALSE(p->has_error()) << p->error();
auto program = p->program();
ASSERT_EQ(program.AST().ConstructedTypes().size(), 2u);
ASSERT_TRUE(program.AST().ConstructedTypes()[0]->Is<ast::Struct>());
auto* str = program.AST().ConstructedTypes()[0]->As<ast::Struct>();
ASSERT_EQ(program.AST().TypeDecls().size(), 2u);
ASSERT_TRUE(program.AST().TypeDecls()[0]->Is<ast::Struct>());
auto* str = program.AST().TypeDecls()[0]->As<ast::Struct>();
EXPECT_EQ(str->name(), program.Symbols().Get("A"));
ASSERT_TRUE(program.AST().ConstructedTypes()[1]->Is<ast::Alias>());
auto* alias = program.AST().ConstructedTypes()[1]->As<ast::Alias>();
ASSERT_TRUE(program.AST().TypeDecls()[1]->Is<ast::Alias>());
auto* alias = program.AST().TypeDecls()[1]->As<ast::Alias>();
EXPECT_EQ(alias->symbol(), program.Symbols().Get("B"));
auto* tn = alias->type()->As<ast::TypeName>();
EXPECT_NE(tn, nullptr);
@@ -125,7 +124,7 @@ 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 constructed type 'invalid'");
EXPECT_EQ(p->error(), "1:10: unknown type 'invalid'");
}
TEST_F(ParserImplTest, GlobalDecl_TypeAlias_MissingSemicolon) {
@@ -170,9 +169,9 @@ TEST_F(ParserImplTest, GlobalDecl_ParsesStruct) {
ASSERT_FALSE(p->has_error()) << p->error();
auto program = p->program();
ASSERT_EQ(program.AST().ConstructedTypes().size(), 1u);
ASSERT_EQ(program.AST().TypeDecls().size(), 1u);
auto* t = program.AST().ConstructedTypes()[0];
auto* t = program.AST().TypeDecls()[0];
ASSERT_NE(t, nullptr);
ASSERT_TRUE(t->Is<ast::Struct>());
@@ -188,9 +187,9 @@ TEST_F(ParserImplTest, GlobalDecl_Struct_WithStride) {
ASSERT_FALSE(p->has_error()) << p->error();
auto program = p->program();
ASSERT_EQ(program.AST().ConstructedTypes().size(), 1u);
ASSERT_EQ(program.AST().TypeDecls().size(), 1u);
auto* t = program.AST().ConstructedTypes()[0];
auto* t = program.AST().TypeDecls()[0];
ASSERT_NE(t, nullptr);
ASSERT_TRUE(t->Is<ast::Struct>());
@@ -215,9 +214,9 @@ TEST_F(ParserImplTest, GlobalDecl_Struct_WithDecoration) {
ASSERT_FALSE(p->has_error()) << p->error();
auto program = p->program();
ASSERT_EQ(program.AST().ConstructedTypes().size(), 1u);
ASSERT_EQ(program.AST().TypeDecls().size(), 1u);
auto* t = program.AST().ConstructedTypes()[0];
auto* t = program.AST().TypeDecls()[0];
ASSERT_NE(t, nullptr);
ASSERT_TRUE(t->Is<ast::Struct>());

2
src/reader/wgsl/parser_impl_primary_expression_test.cc
View File

@@ -300,7 +300,7 @@ TEST_F(ParserImplTest, PrimaryExpression_Bitcast_InvalidType) {
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
ASSERT_TRUE(p->has_error());
EXPECT_EQ(p->error(), "1:9: unknown constructed type 'invalid'");
EXPECT_EQ(p->error(), "1:9: unknown type 'invalid'");
}
TEST_F(ParserImplTest, PrimaryExpression_Bitcast_MissingLeftParen) {

2
src/reader/wgsl/parser_impl_struct_decl_test.cc
View File

@@ -152,7 +152,7 @@ TEST_F(ParserImplTest, StructDecl_InvalidStructBody) {
EXPECT_EQ(s.value, nullptr);
EXPECT_TRUE(p->has_error());
EXPECT_EQ(p->error(), "1:16: unknown constructed type 'B'");
EXPECT_EQ(p->error(), "1:16: unknown type 'B'");
}
TEST_F(ParserImplTest, StructDecl_InvalidDecorationDecl) {

2
src/reader/wgsl/parser_impl_struct_member_test.cc
View File

@@ -202,7 +202,7 @@ TEST_F(ParserImplTest, StructMember_InvalidVariable) {
ASSERT_TRUE(p->has_error());
ASSERT_TRUE(m.errored);
ASSERT_EQ(m.value, nullptr);
EXPECT_EQ(p->error(), "1:17: unknown constructed type 'B'");
EXPECT_EQ(p->error(), "1:17: unknown type 'B'");
}
TEST_F(ParserImplTest, StructMember_MissingSemicolon) {

6
src/reader/wgsl/parser_impl_test.cc
View File

@@ -54,15 +54,15 @@ fn main() -> { // missing return type
TEST_F(ParserImplTest, GetRegisteredType) {
auto p = parser("");
auto* alias = create<ast::Alias>(Sym("my_alias"), ty.i32());
p->register_constructed("my_alias", alias);
p->register_type("my_alias", alias);
auto* got = p->get_constructed("my_alias");
auto* got = p->get_type("my_alias");
EXPECT_EQ(got, alias);
}
TEST_F(ParserImplTest, GetUnregisteredType) {
auto p = parser("");
auto* alias = p->get_constructed("my_alias");
auto* alias = p->get_type("my_alias");
ASSERT_EQ(alias, nullptr);
}

4
src/reader/wgsl/parser_impl_texture_sampler_types_test.cc
View File

@@ -126,7 +126,7 @@ TEST_F(ParserImplTest, TextureSamplerTypes_SampledTexture_Invalid) {
EXPECT_EQ(t.value, nullptr);
EXPECT_FALSE(t.matched);
EXPECT_TRUE(t.errored);
EXPECT_EQ(p->error(), "1:12: unknown constructed type 'abc'");
EXPECT_EQ(p->error(), "1:12: unknown type 'abc'");
}
TEST_F(ParserImplTest, TextureSamplerTypes_SampledTexture_MissingType) {
@@ -185,7 +185,7 @@ TEST_F(ParserImplTest, TextureSamplerTypes_MultisampledTexture_Invalid) {
EXPECT_EQ(t.value, nullptr);
EXPECT_FALSE(t.matched);
EXPECT_TRUE(t.errored);
EXPECT_EQ(p->error(), "1:25: unknown constructed type 'abc'");
EXPECT_EQ(p->error(), "1:25: unknown type 'abc'");
}
TEST_F(ParserImplTest, TextureSamplerTypes_MultisampledTexture_MissingType) {

4
src/reader/wgsl/parser_impl_type_alias_test.cc
View File

@@ -38,7 +38,7 @@ TEST_F(ParserImplTest, TypeDecl_ParsesStruct_Ident) {
auto p = parser("type a = B");
auto* str = p->builder().Structure(p->builder().Symbols().Register("B"), {});
p->register_constructed("B", str);
p->register_type("B", str);
auto t = p->type_alias();
EXPECT_FALSE(p->has_error());
@@ -89,7 +89,7 @@ TEST_F(ParserImplTest, TypeDecl_InvalidType) {
EXPECT_FALSE(t.matched);
EXPECT_TRUE(p->has_error());
EXPECT_EQ(t.value, nullptr);
EXPECT_EQ(p->error(), "1:10: unknown constructed type 'B'");
EXPECT_EQ(p->error(), "1:10: unknown type 'B'");
}
} // namespace

12
src/reader/wgsl/parser_impl_type_decl_test.cc
View File

@@ -38,7 +38,7 @@ TEST_F(ParserImplTest, TypeDecl_Identifier) {
auto& builder = p->builder();
auto* alias_type = builder.ty.alias("A", builder.ty.i32());
p->register_constructed("A", alias_type);
p->register_type("A", alias_type);
auto t = p->type_decl();
EXPECT_TRUE(t.matched);
@@ -58,7 +58,7 @@ TEST_F(ParserImplTest, TypeDecl_Identifier_NotFound) {
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
EXPECT_TRUE(p->has_error());
EXPECT_EQ(p->error(), "1:1: unknown constructed type 'B'");
EXPECT_EQ(p->error(), "1:1: unknown type 'B'");
}
TEST_F(ParserImplTest, TypeDecl_Bool) {
@@ -182,7 +182,7 @@ TEST_P(VecBadType, Handles_Unknown_Type) {
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
ASSERT_TRUE(p->has_error());
ASSERT_EQ(p->error(), "1:6: unknown constructed type 'unknown'");
ASSERT_EQ(p->error(), "1:6: unknown type 'unknown'");
}
INSTANTIATE_TEST_SUITE_P(ParserImplTest,
VecBadType,
@@ -365,7 +365,7 @@ TEST_F(ParserImplTest, TypeDecl_Ptr_BadType) {
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
ASSERT_TRUE(p->has_error());
ASSERT_EQ(p->error(), "1:15: unknown constructed type 'unknown'");
ASSERT_EQ(p->error(), "1:15: unknown type 'unknown'");
}
TEST_F(ParserImplTest, TypeDecl_Ptr_BadAccess) {
@@ -599,7 +599,7 @@ TEST_F(ParserImplTest, TypeDecl_Array_BadType) {
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
ASSERT_TRUE(p->has_error());
ASSERT_EQ(p->error(), "1:7: unknown constructed type 'unknown'");
ASSERT_EQ(p->error(), "1:7: unknown type 'unknown'");
}
TEST_F(ParserImplTest, TypeDecl_Array_ZeroSize) {
@@ -761,7 +761,7 @@ TEST_P(MatrixBadType, Handles_Unknown_Type) {
EXPECT_FALSE(t.matched);
ASSERT_EQ(t.value, nullptr);
ASSERT_TRUE(p->has_error());
ASSERT_EQ(p->error(), "1:8: unknown constructed type 'unknown'");
ASSERT_EQ(p->error(), "1:8: unknown type 'unknown'");
}
INSTANTIATE_TEST_SUITE_P(
ParserImplTest,

12
src/reader/wgsl/parser_impl_variable_ident_decl_test.cc
View File

@@ -81,7 +81,7 @@ TEST_F(ParserImplTest, VariableIdentDecl_InvalidType) {
auto decl = p->expect_variable_ident_decl("test");
ASSERT_TRUE(p->has_error());
ASSERT_TRUE(decl.errored);
ASSERT_EQ(p->error(), "1:10: unknown constructed type 'invalid'");
ASSERT_EQ(p->error(), "1:10: unknown type 'invalid'");
}
// TODO(crbug.com/tint/846): Remove
@@ -134,7 +134,7 @@ TEST_F(ParserImplTest, VariableIdentDecl_ParsesWithAccessDeco_Read_DEPRECATED) {
auto* s = Structure(Sym("S"), members, decos);
p->register_constructed("S", s);
p->register_type("S", s);
auto res = p->expect_global_decl();
ASSERT_FALSE(res.errored) << p->error();
@@ -166,7 +166,7 @@ TEST_F(ParserImplTest,
auto* s = Structure(Sym("S"), members, decos);
p->register_constructed("S", s);
p->register_type("S", s);
auto res = p->expect_global_decl();
ASSERT_FALSE(res.errored) << p->error();
@@ -197,7 +197,7 @@ TEST_F(ParserImplTest, VariableIdentDecl_MultipleAccessDecoFail_DEPRECATED) {
auto* s = Structure(Sym("S"), members, decos);
p->register_constructed("S", s);
p->register_type("S", s);
auto decl = p->expect_variable_ident_decl("test");
ASSERT_TRUE(p->has_error());
@@ -220,7 +220,7 @@ TEST_F(ParserImplTest,
auto* s = Structure(Sym("S"), members, decos);
p->register_constructed("S", s);
p->register_type("S", s);
auto decl = p->expect_variable_ident_decl("test");
ASSERT_TRUE(p->has_error());
@@ -259,7 +259,7 @@ TEST_F(ParserImplTest, VariableIdentDecl_NonAccessDecoFail) {
auto* s = Structure(Sym("S"), members, decos);
p->register_constructed("S", s);
p->register_type("S", s);
auto decl = p->expect_variable_ident_decl("test");
ASSERT_TRUE(p->has_error());

4
src/reader/wgsl/parser_impl_variable_stmt_test.cc
View File

@@ -65,7 +65,7 @@ TEST_F(ParserImplTest, VariableStmt_VariableDecl_Invalid) {
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
EXPECT_TRUE(p->has_error());
EXPECT_EQ(p->error(), "1:9: unknown constructed type 'invalid'");
EXPECT_EQ(p->error(), "1:9: unknown type 'invalid'");
}
TEST_F(ParserImplTest, VariableStmt_VariableDecl_ConstructorInvalid) {
@@ -160,7 +160,7 @@ TEST_F(ParserImplTest, VariableStmt_Let_InvalidVarIdent) {
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
EXPECT_TRUE(p->has_error());
EXPECT_EQ(p->error(), "1:9: unknown constructed type 'invalid'");
EXPECT_EQ(p->error(), "1:9: unknown type 'invalid'");
}
TEST_F(ParserImplTest, VariableStmt_Let_MissingEqual) {