encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add optionally_typed_ident to WGSL parser. 

This CL adds the `optionally_typed_ident` construct into the WGSL
parser and uses it where the conditional was used previously.

Bug: tint:1633
Change-Id: I15eaf838792208f56b4ddebd950086f14c8962b3
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/99382
Reviewed-by: Ben Clayton <bclayton@google.com>
Commit-Queue: Dan Sinclair <dsinclair@chromium.org>
This commit is contained in:
dan sinclair 2022-08-17 17:38:17 +00:00 committed by Dawn LUCI CQ
parent 0f0ba20208
commit eb0af9def7
3 changed files with 36 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
src/tint/reader/wgsl/parser_impl.cc
View File

@ -594,8 +594,8 @@ Maybe<const ast::Variable*> ParserImpl::global_variable_decl(AttributeList& attr
} }
// global_constant_decl : // global_constant_decl :
// | LET (ident | variable_ident_decl) global_const_initializer // | LET optionally_typed_ident global_const_initializer
// | attribute* override (ident | variable_ident_decl) (equal expression)? // | attribute* override optionally_typed_ident (equal expression)?
// global_const_initializer // global_const_initializer
// : EQUAL const_expr // : EQUAL const_expr
Maybe<const ast::Variable*> ParserImpl::global_constant_decl(AttributeList& attrs) { Maybe<const ast::Variable*> ParserImpl::global_constant_decl(AttributeList& attrs) {
@ -615,7 +615,7 @@ Maybe<const ast::Variable*> ParserImpl::global_constant_decl(AttributeList& attr
return Failure::kNoMatch; return Failure::kNoMatch;
} }
auto decl = expect_ident_or_variable_ident_decl(use); auto decl = expect_optionally_typed_ident(use);
if (decl.errored) { if (decl.errored) {
return Failure::kErrored; return Failure::kErrored;
} }
@ -666,7 +666,7 @@ Maybe<const ast::Variable*> ParserImpl::global_constant_decl(AttributeList& attr
} }
// variable_decl // variable_decl
// : VAR variable_qualifier? (ident | variable_ident_decl) // : VAR variable_qualifier? optionally_typed_ident
Maybe<ParserImpl::VarDeclInfo> ParserImpl::variable_decl() { Maybe<ParserImpl::VarDeclInfo> ParserImpl::variable_decl() {
Source source; Source source;
if (!match(Token::Type::kVar, &source)) { if (!match(Token::Type::kVar, &source)) {
@ -682,7 +682,7 @@ Maybe<ParserImpl::VarDeclInfo> ParserImpl::variable_decl() {
vq = explicit_vq.value; vq = explicit_vq.value;
} }
auto decl = expect_ident_or_variable_ident_decl("variable declaration"); auto decl = expect_optionally_typed_ident("variable declaration");
if (decl.errored) { if (decl.errored) {
return Failure::kErrored; return Failure::kErrored;
} }
@ -918,7 +918,7 @@ Expect<ast::TexelFormat> ParserImpl::expect_texel_format(std::string_view use) {
return fmt; return fmt;
} }
Expect<ParserImpl::TypedIdentifier> ParserImpl::expect_ident_or_variable_ident_decl_impl( Expect<ParserImpl::TypedIdentifier> ParserImpl::expect_ident_with_optional_type_decl(
std::string_view use, std::string_view use,
bool allow_inferred) { bool allow_inferred) {
auto ident = expect_ident(use); auto ident = expect_ident(use);
@ -946,16 +946,17 @@ Expect<ParserImpl::TypedIdentifier> ParserImpl::expect_ident_or_variable_ident_d
return TypedIdentifier{type.value, ident.value, ident.source}; return TypedIdentifier{type.value, ident.value, ident.source};
} }
// (ident | variable_ident_decl) // optionally_typed_ident
Expect<ParserImpl::TypedIdentifier> ParserImpl::expect_ident_or_variable_ident_decl( // : ident ( COLON typed_decl ) ?
Expect<ParserImpl::TypedIdentifier> ParserImpl::expect_optionally_typed_ident(
std::string_view use) { std::string_view use) {
return expect_ident_or_variable_ident_decl_impl(use, true); return expect_ident_with_optional_type_decl(use, true);
} }
// variable_ident_decl // ident_with_type_decl
// : IDENT COLON type_decl // : IDENT COLON type_decl
Expect<ParserImpl::TypedIdentifier> ParserImpl::expect_variable_ident_decl(std::string_view use) { Expect<ParserImpl::TypedIdentifier> ParserImpl::expect_ident_with_type_decl(std::string_view use) {
return expect_ident_or_variable_ident_decl_impl(use, false); return expect_ident_with_optional_type_decl(use, false);
} }
// access_mode // access_mode
@ -1356,14 +1357,14 @@ Expect<ParserImpl::StructMemberList> ParserImpl::expect_struct_body_decl() {
} }
// struct_member // struct_member
// : attribute* variable_ident_decl // : attribute* ident_with_type_decl
Expect<ast::StructMember*> ParserImpl::expect_struct_member() { Expect<ast::StructMember*> ParserImpl::expect_struct_member() {
auto attrs = attribute_list(); auto attrs = attribute_list();
if (attrs.errored) { if (attrs.errored) {
return Failure::kErrored; return Failure::kErrored;
} }
auto decl = expect_variable_ident_decl("struct member"); auto decl = expect_ident_with_type_decl("struct member");
if (decl.errored) { if (decl.errored) {
return Failure::kErrored; return Failure::kErrored;
} }
@ -1519,11 +1520,11 @@ Expect<ParserImpl::ParameterList> ParserImpl::expect_param_list() {
} }
// param // param
// : attribute_list* variable_ident_decl // : attribute_list* ident_with_type_decl
Expect<ast::Parameter*> ParserImpl::expect_param() { Expect<ast::Parameter*> ParserImpl::expect_param() {
auto attrs = attribute_list(); auto attrs = attribute_list();
auto decl = expect_variable_ident_decl("parameter"); auto decl = expect_ident_with_type_decl("parameter");
if (decl.errored) { if (decl.errored) {
return Failure::kErrored; return Failure::kErrored;
} }
@ -1861,11 +1862,11 @@ Maybe<const ast::ReturnStatement*> ParserImpl::return_statement() {
// variable_statement // variable_statement
// : variable_decl // : variable_decl
// | variable_decl EQUAL expression // | variable_decl EQUAL expression
// | LET (ident | variable_ident_decl) EQUAL expression // | LET optionally_typed_ident EQUAL expression
// | CONST (ident | variable_ident_decl) EQUAL expression // | CONST optionally_typed_ident EQUAL expression
Maybe<const ast::VariableDeclStatement*> ParserImpl::variable_statement() { Maybe<const ast::VariableDeclStatement*> ParserImpl::variable_statement() {
if (match(Token::Type::kConst)) { if (match(Token::Type::kConst)) {
auto decl = expect_ident_or_variable_ident_decl("'const' declaration"); auto decl = expect_optionally_typed_ident("'const' declaration");
if (decl.errored) { if (decl.errored) {
return Failure::kErrored; return Failure::kErrored;
} }
@ -1892,7 +1893,7 @@ Maybe<const ast::VariableDeclStatement*> ParserImpl::variable_statement() {
} }
if (match(Token::Type::kLet)) { if (match(Token::Type::kLet)) {
auto decl = expect_ident_or_variable_ident_decl("'let' declaration"); auto decl = expect_optionally_typed_ident("'let' declaration");
if (decl.errored) { if (decl.errored) {
return Failure::kErrored; return Failure::kErrored;
} }

10
src/tint/reader/wgsl/parser_impl.h
View File

@ -410,21 +410,21 @@ class ParserImpl {
/// Parses a `variable_decl` grammar element /// Parses a `variable_decl` grammar element
/// @returns the parsed variable declaration info /// @returns the parsed variable declaration info
Maybe<VarDeclInfo> variable_decl(); Maybe<VarDeclInfo> variable_decl();
/// Helper for parsing ident or variable_ident_decl. Should not be called directly, /// Helper for parsing ident with an optional type declaration. Should not be called directly,
/// use the specific version below. /// use the specific version below.
/// @param use a description of what was being parsed if an error was raised. /// @param use a description of what was being parsed if an error was raised.
/// @param allow_inferred allow the identifier to be parsed without a type /// @param allow_inferred allow the identifier to be parsed without a type
/// @returns the parsed identifier, and possibly type, or empty otherwise /// @returns the parsed identifier, and possibly type, or empty otherwise
Expect<TypedIdentifier> expect_ident_or_variable_ident_decl_impl(std::string_view use, Expect<TypedIdentifier> expect_ident_with_optional_type_decl(std::string_view use,
bool allow_inferred); bool allow_inferred);
/// Parses a `ident` or a `variable_ident_decl` grammar element, erroring on parse failure. /// Parses a `ident` or a `variable_ident_decl` grammar element, erroring on parse failure.
/// @param use a description of what was being parsed if an error was raised. /// @param use a description of what was being parsed if an error was raised.
/// @returns the identifier or empty otherwise. /// @returns the identifier or empty otherwise.
Expect<TypedIdentifier> expect_ident_or_variable_ident_decl(std::string_view use); Expect<TypedIdentifier> expect_optionally_typed_ident(std::string_view use);
/// Parses a `variable_ident_decl` grammar element, erroring on parse failure. /// Parses a `variable_ident_decl` grammar element, erroring on parse failure.
/// @param use a description of what was being parsed if an error was raised. /// @param use a description of what was being parsed if an error was raised.
/// @returns the identifier and type parsed or empty otherwise /// @returns the identifier and type parsed or empty otherwise
Expect<TypedIdentifier> expect_variable_ident_decl(std::string_view use); Expect<TypedIdentifier> expect_ident_with_type_decl(std::string_view use);
/// Parses a `variable_qualifier` grammar element /// Parses a `variable_qualifier` grammar element
/// @returns the variable qualifier information /// @returns the variable qualifier information
Maybe<VariableQualifier> variable_qualifier(); Maybe<VariableQualifier> variable_qualifier();

20
src/tint/reader/wgsl/parser_impl_variable_ident_decl_test.cc
View File

@ -19,7 +19,7 @@ namespace {
TEST_F(ParserImplTest, VariableIdentDecl_Parses) { TEST_F(ParserImplTest, VariableIdentDecl_Parses) {
auto p = parser("my_var : f32"); auto p = parser("my_var : f32");
auto decl = p->expect_variable_ident_decl("test"); auto decl = p->expect_ident_with_type_decl("test");
ASSERT_FALSE(p->has_error()) << p->error(); ASSERT_FALSE(p->has_error()) << p->error();
ASSERT_FALSE(decl.errored); ASSERT_FALSE(decl.errored);
ASSERT_EQ(decl->name, "my_var"); ASSERT_EQ(decl->name, "my_var");
@ -32,7 +32,7 @@ TEST_F(ParserImplTest, VariableIdentDecl_Parses) {
TEST_F(ParserImplTest, VariableIdentDecl_Parses_AllowInferredType) { TEST_F(ParserImplTest, VariableIdentDecl_Parses_AllowInferredType) {
auto p = parser("my_var : f32"); auto p = parser("my_var : f32");
auto decl = p->expect_ident_or_variable_ident_decl("test"); auto decl = p->expect_optionally_typed_ident("test");
ASSERT_FALSE(p->has_error()) << p->error(); ASSERT_FALSE(p->has_error()) << p->error();
ASSERT_FALSE(decl.errored); ASSERT_FALSE(decl.errored);
ASSERT_EQ(decl->name, "my_var"); ASSERT_EQ(decl->name, "my_var");
@ -45,14 +45,14 @@ TEST_F(ParserImplTest, VariableIdentDecl_Parses_AllowInferredType) {
TEST_F(ParserImplTest, VariableIdentDecl_Inferred_Parse_Failure) { TEST_F(ParserImplTest, VariableIdentDecl_Inferred_Parse_Failure) {
auto p = parser("my_var = 1.0"); auto p = parser("my_var = 1.0");
auto decl = p->expect_variable_ident_decl("test"); auto decl = p->expect_ident_with_type_decl("test");
ASSERT_TRUE(p->has_error()); ASSERT_TRUE(p->has_error());
ASSERT_EQ(p->error(), "1:8: expected ':' for test"); ASSERT_EQ(p->error(), "1:8: expected ':' for test");
} }
TEST_F(ParserImplTest, VariableIdentDecl_Inferred_Parses_AllowInferredType) { TEST_F(ParserImplTest, VariableIdentDecl_Inferred_Parses_AllowInferredType) {
auto p = parser("my_var = 1.0"); auto p = parser("my_var = 1.0");
auto decl = p->expect_ident_or_variable_ident_decl("test"); auto decl = p->expect_optionally_typed_ident("test");
ASSERT_FALSE(p->has_error()) << p->error(); ASSERT_FALSE(p->has_error()) << p->error();
ASSERT_FALSE(decl.errored); ASSERT_FALSE(decl.errored);
ASSERT_EQ(decl->name, "my_var"); ASSERT_EQ(decl->name, "my_var");
@ -63,7 +63,7 @@ TEST_F(ParserImplTest, VariableIdentDecl_Inferred_Parses_AllowInferredType) {
TEST_F(ParserImplTest, VariableIdentDecl_MissingIdent) { TEST_F(ParserImplTest, VariableIdentDecl_MissingIdent) {
auto p = parser(": f32"); auto p = parser(": f32");
auto decl = p->expect_variable_ident_decl("test"); auto decl = p->expect_ident_with_type_decl("test");
ASSERT_TRUE(p->has_error()); ASSERT_TRUE(p->has_error());
ASSERT_TRUE(decl.errored); ASSERT_TRUE(decl.errored);
ASSERT_EQ(p->error(), "1:1: expected identifier for test"); ASSERT_EQ(p->error(), "1:1: expected identifier for test");
@ -71,7 +71,7 @@ TEST_F(ParserImplTest, VariableIdentDecl_MissingIdent) {
TEST_F(ParserImplTest, VariableIdentDecl_MissingIdent_AllowInferredType) { TEST_F(ParserImplTest, VariableIdentDecl_MissingIdent_AllowInferredType) {
auto p = parser(": f32"); auto p = parser(": f32");
auto decl = p->expect_ident_or_variable_ident_decl("test"); auto decl = p->expect_optionally_typed_ident("test");
ASSERT_TRUE(p->has_error()); ASSERT_TRUE(p->has_error());
ASSERT_TRUE(decl.errored); ASSERT_TRUE(decl.errored);
ASSERT_EQ(p->error(), "1:1: expected identifier for test"); ASSERT_EQ(p->error(), "1:1: expected identifier for test");
@ -79,7 +79,7 @@ TEST_F(ParserImplTest, VariableIdentDecl_MissingIdent_AllowInferredType) {
TEST_F(ParserImplTest, VariableIdentDecl_MissingType) { TEST_F(ParserImplTest, VariableIdentDecl_MissingType) {
auto p = parser("my_var :"); auto p = parser("my_var :");
auto decl = p->expect_variable_ident_decl("test"); auto decl = p->expect_ident_with_type_decl("test");
ASSERT_TRUE(p->has_error()); ASSERT_TRUE(p->has_error());
ASSERT_TRUE(decl.errored); ASSERT_TRUE(decl.errored);
ASSERT_EQ(p->error(), "1:9: invalid type for test"); ASSERT_EQ(p->error(), "1:9: invalid type for test");
@ -87,7 +87,7 @@ TEST_F(ParserImplTest, VariableIdentDecl_MissingType) {
TEST_F(ParserImplTest, VariableIdentDecl_MissingType_AllowInferredType) { TEST_F(ParserImplTest, VariableIdentDecl_MissingType_AllowInferredType) {
auto p = parser("my_var :"); auto p = parser("my_var :");
auto decl = p->expect_ident_or_variable_ident_decl("test"); auto decl = p->expect_optionally_typed_ident("test");
ASSERT_TRUE(p->has_error()); ASSERT_TRUE(p->has_error());
ASSERT_TRUE(decl.errored); ASSERT_TRUE(decl.errored);
ASSERT_EQ(p->error(), "1:9: invalid type for test"); ASSERT_EQ(p->error(), "1:9: invalid type for test");
@ -95,7 +95,7 @@ TEST_F(ParserImplTest, VariableIdentDecl_MissingType_AllowInferredType) {
TEST_F(ParserImplTest, VariableIdentDecl_InvalidIdent) { TEST_F(ParserImplTest, VariableIdentDecl_InvalidIdent) {
auto p = parser("123 : f32"); auto p = parser("123 : f32");
auto decl = p->expect_variable_ident_decl("test"); auto decl = p->expect_ident_with_type_decl("test");
ASSERT_TRUE(p->has_error()); ASSERT_TRUE(p->has_error());
ASSERT_TRUE(decl.errored); ASSERT_TRUE(decl.errored);
ASSERT_EQ(p->error(), "1:1: expected identifier for test"); ASSERT_EQ(p->error(), "1:1: expected identifier for test");
@ -103,7 +103,7 @@ TEST_F(ParserImplTest, VariableIdentDecl_InvalidIdent) {
TEST_F(ParserImplTest, VariableIdentDecl_InvalidIdent_AllowInferredType) { TEST_F(ParserImplTest, VariableIdentDecl_InvalidIdent_AllowInferredType) {
auto p = parser("123 : f32"); auto p = parser("123 : f32");
auto decl = p->expect_ident_or_variable_ident_decl("test"); auto decl = p->expect_optionally_typed_ident("test");
ASSERT_TRUE(p->has_error()); ASSERT_TRUE(p->has_error());
ASSERT_TRUE(decl.errored); ASSERT_TRUE(decl.errored);
ASSERT_EQ(p->error(), "1:1: expected identifier for test"); ASSERT_EQ(p->error(), "1:1: expected identifier for test");