encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-12-14 23:56:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

Convert binding and group attributes to expressions.

Browse Source 
This CL updates the @group and @binding attributes to use
expressions instead of integers.

Bug: tint:1633
Change-Id: I91068874c104d5b84390f1617cb96265dda6e1e0
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/105801
Auto-Submit: Dan Sinclair <dsinclair@chromium.org>
Commit-Queue: Dan Sinclair <dsinclair@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Ben Clayton <bclayton@google.com>
This commit is contained in:
dan sinclair
2022-10-14 18:39:04 +00:00
committed by Dawn LUCI CQ
parent 308c55d9e0
commit 72ac53e5fa
8 changed files with 217 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -3441,15 +3441,16 @@ Maybe<const ast::Attribute*> ParserImpl::attribute() {
if (t == "binding") {
const char* use = "binding attribute";
return expect_paren_block(use, [&]() -> Result {
auto val = expect_positive_sint(use);
if (val.errored) {
auto expr = expression();
if (expr.errored) {
return Failure::kErrored;
}
if (!expr.matched) {
return add_error(peek(), "expected binding expression");
}
match(Token::Type::kComma);
return create<ast::BindingAttribute>(
t.source(), create<ast::IntLiteralExpression>(
val.value, ast::IntLiteralExpression::Suffix::kNone));
return create<ast::BindingAttribute>(t.source(), expr.value);
});
}
@@ -3478,15 +3479,16 @@ Maybe<const ast::Attribute*> ParserImpl::attribute() {
if (t == "group") {
const char* use = "group attribute";
return expect_paren_block(use, [&]() -> Result {
auto val = expect_positive_sint(use);
if (val.errored) {
auto expr = expression();
if (expr.errored) {
return Failure::kErrored;
}
if (!expr.matched) {
return add_error(peek(), "expected group expression");
}
match(Token::Type::kComma);
return create<ast::GroupAttribute>(
t.source(), create<ast::IntLiteralExpression>(
val.value, ast::IntLiteralExpression::Suffix::kNone));
return create<ast::GroupAttribute>(t.source(), expr.value);
});
}

16
src/tint/reader/wgsl/parser_impl_error_msg_test.cc
View File

@@ -1017,10 +1017,10 @@ TEST_F(ParserImplErrorTest, GlobalDeclVarAttrBindingMissingRParen) {
}
TEST_F(ParserImplErrorTest, GlobalDeclVarAttrBindingInvalidValue) {
EXPECT("@binding(x) var i : i32;",
R"(test.wgsl:1:10 error: expected signed integer literal for binding attribute
@binding(x) var i : i32;
^
EXPECT("@binding(if) var i : i32;",
R"(test.wgsl:1:10 error: expected binding expression
@binding(if) var i : i32;
^^
)");
}
@@ -1041,10 +1041,10 @@ TEST_F(ParserImplErrorTest, GlobalDeclVarAttrGroupMissingRParen) {
}
TEST_F(ParserImplErrorTest, GlobalDeclVarAttrBindingGroupValue) {
EXPECT("@group(x) var i : i32;",
R"(test.wgsl:1:8 error: expected signed integer literal for group attribute
@group(x) var i : i32;
^
EXPECT("@group(if) var i : i32;",
R"(test.wgsl:1:8 error: expected group expression
@group(if) var i : i32;
^^
)");
}

2
src/tint/reader/wgsl/parser_impl_global_variable_decl_test.cc
View File

@@ -139,7 +139,7 @@ TEST_F(ParserImplTest, GlobalVariableDecl_InvalidAttribute) {
EXPECT_NE(e.value, nullptr);
EXPECT_TRUE(p->has_error());
EXPECT_EQ(p->error(), "1:10: expected signed integer literal for binding attribute");
EXPECT_EQ(p->error(), "1:10: expected binding expression");
}
TEST_F(ParserImplTest, GlobalVariableDecl_InvalidConstExpr) {

62
src/tint/reader/wgsl/parser_impl_variable_attribute_test.cc
View File

@@ -392,6 +392,31 @@ TEST_F(ParserImplTest, Attribute_Binding) {
EXPECT_EQ(expr->suffix, ast::IntLiteralExpression::Suffix::kNone);
}
TEST_F(ParserImplTest, Attribute_Binding_Expression) {
auto p = parser("binding(4 + 5)");
auto attr = p->attribute();
EXPECT_TRUE(attr.matched);
EXPECT_FALSE(attr.errored);
ASSERT_NE(attr.value, nullptr);
auto* var_attr = attr.value->As<ast::Attribute>();
ASSERT_NE(var_attr, nullptr);
ASSERT_FALSE(p->has_error());
ASSERT_TRUE(var_attr->Is<ast::BindingAttribute>());
auto* binding = var_attr->As<ast::BindingAttribute>();
ASSERT_TRUE(binding->expr->Is<ast::BinaryExpression>());
auto* expr = binding->expr->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kAdd, expr->op);
auto* v = expr->lhs->As<ast::IntLiteralExpression>();
ASSERT_NE(nullptr, v);
EXPECT_EQ(v->value, 4u);
v = expr->rhs->As<ast::IntLiteralExpression>();
ASSERT_NE(nullptr, v);
EXPECT_EQ(v->value, 5u);
}
TEST_F(ParserImplTest, Attribute_Binding_TrailingComma) {
auto p = parser("binding(4,)");
auto attr = p->attribute();
@@ -437,17 +462,17 @@ TEST_F(ParserImplTest, Attribute_Binding_MissingValue) {
EXPECT_TRUE(attr.errored);
EXPECT_EQ(attr.value, nullptr);
EXPECT_TRUE(p->has_error());
EXPECT_EQ(p->error(), "1:9: expected signed integer literal for binding attribute");
EXPECT_EQ(p->error(), "1:9: expected binding expression");
}
TEST_F(ParserImplTest, Attribute_Binding_MissingInvalid) {
auto p = parser("binding(nan)");
auto p = parser("binding(if)");
auto attr = p->attribute();
EXPECT_FALSE(attr.matched);
EXPECT_TRUE(attr.errored);
EXPECT_EQ(attr.value, nullptr);
EXPECT_TRUE(p->has_error());
EXPECT_EQ(p->error(), "1:9: expected signed integer literal for binding attribute");
EXPECT_EQ(p->error(), "1:9: expected binding expression");
}
TEST_F(ParserImplTest, Attribute_group) {
@@ -468,6 +493,31 @@ TEST_F(ParserImplTest, Attribute_group) {
EXPECT_EQ(expr->suffix, ast::IntLiteralExpression::Suffix::kNone);
}
TEST_F(ParserImplTest, Attribute_group_expression) {
auto p = parser("group(4 + 5)");
auto attr = p->attribute();
EXPECT_TRUE(attr.matched);
EXPECT_FALSE(attr.errored);
ASSERT_NE(attr.value, nullptr);
auto* var_attr = attr.value->As<ast::Attribute>();
ASSERT_FALSE(p->has_error());
ASSERT_NE(var_attr, nullptr);
ASSERT_TRUE(var_attr->Is<ast::GroupAttribute>());
auto* group = var_attr->As<ast::GroupAttribute>();
ASSERT_TRUE(group->expr->Is<ast::BinaryExpression>());
auto* expr = group->expr->As<ast::BinaryExpression>();
EXPECT_EQ(ast::BinaryOp::kAdd, expr->op);
auto* v = expr->lhs->As<ast::IntLiteralExpression>();
ASSERT_NE(nullptr, v);
EXPECT_EQ(v->value, 4u);
v = expr->rhs->As<ast::IntLiteralExpression>();
ASSERT_NE(nullptr, v);
EXPECT_EQ(v->value, 5u);
}
TEST_F(ParserImplTest, Attribute_group_TrailingComma) {
auto p = parser("group(4,)");
auto attr = p->attribute();
@@ -513,17 +563,17 @@ TEST_F(ParserImplTest, Attribute_Group_MissingValue) {
EXPECT_TRUE(attr.errored);
EXPECT_EQ(attr.value, nullptr);
EXPECT_TRUE(p->has_error());
EXPECT_EQ(p->error(), "1:7: expected signed integer literal for group attribute");
EXPECT_EQ(p->error(), "1:7: expected group expression");
}
TEST_F(ParserImplTest, Attribute_Group_MissingInvalid) {
auto p = parser("group(nan)");
auto p = parser("group(if)");
auto attr = p->attribute();
EXPECT_FALSE(attr.matched);
EXPECT_TRUE(attr.errored);
EXPECT_EQ(attr.value, nullptr);
EXPECT_TRUE(p->has_error());
EXPECT_EQ(p->error(), "1:7: expected signed integer literal for group attribute");
EXPECT_EQ(p->error(), "1:7: expected group expression");
}
} // namespace