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

Big cleanup now that AST nodes are raw pointers

Browse Source 
Remove all redundant std::move()s. I've also removed calls to
std::move() in tests, even if they act as an optimization. This is for
two reasons:
(a) Performance is not important for testing, and this helps with
    readability.
(b) A whole bunch tests were relying on std::move() clearing vectors so
    they can be repopulated and used again. This is undefined behavior:

> Objects of types defined in the C++ standard library may be moved from
> (12.8). Move operations may be explicitly specified or implicitly
> generated. Unless otherwise specified, such moved-from objects shall
> be placed in a valid but unspecified state.

All of these UB cases have been fixed.

Removed all duplicate variables left over from:
  `auto* foo_ptr = foo.get()`
which became:
  `auto* foo_ptr = foo`

Bug: tint:322
Change-Id: Ibd08a2379671382320fd4d8da296ccc6a378b8af
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/32900
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: dan sinclair <dsinclair@chromium.org>
This commit is contained in:
Ben Clayton
2020-11-16 16:41:47 +00:00
committed by Commit Bot service account
parent b053acf796
commit 4bfe461646
130 changed files with 3078 additions and 3708 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/transform/bound_array_accessors_transform.cc
View File

@@ -244,8 +244,7 @@ bool BoundArrayAccessorsTransform::ProcessAccessExpression(
cast_expr.push_back(expr->idx_expr());
ast::ExpressionList params;
params.push_back(
create<ast::TypeConstructorExpression>(u32, std::move(cast_expr)));
params.push_back(create<ast::TypeConstructorExpression>(u32, cast_expr));
params.push_back(create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(u32, size - 1)));
@@ -253,7 +252,7 @@ bool BoundArrayAccessorsTransform::ProcessAccessExpression(
create<ast::IdentifierExpression>("min"), std::move(params));
call_expr->set_result_type(u32);
expr->set_idx_expr(std::move(call_expr));
expr->set_idx_expr(call_expr);
}
return true;
}

110
src/transform/bound_array_accessors_transform_test.cc
View File

@@ -54,15 +54,15 @@ class BoundArrayAccessorsTest : public testing::Test {
ast::BlockStatement* SetupFunctionAndBody() {
auto* block = create<ast::BlockStatement>();
body_ = block;
auto* func = create<ast::Function>("func", ast::VariableList{}, &void_type_,
std::move(block));
mod_.AddFunction(std::move(func));
auto* func =
create<ast::Function>("func", ast::VariableList{}, &void_type_, block);
mod_.AddFunction(func);
return body_;
}
void DeclareVariable(ast::Variable* var) {
ASSERT_NE(body_, nullptr);
body_->append(create<ast::VariableDeclStatement>(std::move(var)));
body_->append(create<ast::VariableDeclStatement>(var));
}
TypeDeterminer* td() { return &td_; }
@@ -105,19 +105,18 @@ TEST_F(BoundArrayAccessorsTest, Ptrs_Clamp) {
auto* c_var = create<ast::Variable>("c", ast::StorageClass::kFunction, &u32);
c_var->set_is_const(true);
DeclareVariable(std::move(c_var));
DeclareVariable(c_var);
auto* access_idx = create<ast::IdentifierExpression>("c");
auto* access_ptr = access_idx;
auto* accessor = create<ast::ArrayAccessorExpression>(
create<ast::IdentifierExpression>("a"), std::move(access_idx));
create<ast::IdentifierExpression>("a"), access_idx);
auto* ptr = accessor;
auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &ptr_type);
b->set_constructor(std::move(accessor));
b->set_constructor(accessor);
b->set_is_const(true);
DeclareVariable(std::move(b));
DeclareVariable(b);
ASSERT_TRUE(td()->Determine()) << td()->error();
@@ -136,7 +135,7 @@ TEST_F(BoundArrayAccessorsTest, Ptrs_Clamp) {
auto* tc = idx->params()[0]->AsConstructor()->AsTypeConstructor();
EXPECT_TRUE(tc->type()->IsU32());
ASSERT_EQ(tc->values().size(), 1u);
ASSERT_EQ(tc->values()[0], access_ptr);
ASSERT_EQ(tc->values()[0], access_idx);
ASSERT_TRUE(idx->params()[1]->IsConstructor());
ASSERT_TRUE(idx->params()[1]->AsConstructor()->IsScalarConstructor());
@@ -170,18 +169,17 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_Nested_Scalar) {
create<ast::Variable>("i", ast::StorageClass::kFunction, &u32));
auto* b_access_idx = create<ast::IdentifierExpression>("i");
auto* b_access_ptr = b_access_idx;
auto* a_access_idx = create<ast::ArrayAccessorExpression>(
create<ast::IdentifierExpression>("b"), std::move(b_access_idx));
create<ast::IdentifierExpression>("b"), b_access_idx);
auto* accessor = create<ast::ArrayAccessorExpression>(
create<ast::IdentifierExpression>("a"), std::move(a_access_idx));
create<ast::IdentifierExpression>("a"), a_access_idx);
auto* ptr = accessor;
auto* b = create<ast::Variable>("c", ast::StorageClass::kFunction, &f32);
b->set_constructor(std::move(accessor));
DeclareVariable(std::move(b));
b->set_constructor(accessor);
DeclareVariable(b);
ASSERT_TRUE(td()->Determine()) << td()->error();
@@ -214,7 +212,7 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_Nested_Scalar) {
tc = sub_idx->params()[0]->AsConstructor()->AsTypeConstructor();
EXPECT_TRUE(tc->type()->IsU32());
ASSERT_EQ(tc->values().size(), 1u);
ASSERT_EQ(tc->values()[0], b_access_ptr);
ASSERT_EQ(tc->values()[0], b_access_idx);
ASSERT_TRUE(sub_idx->params()[1]->IsConstructor());
ASSERT_TRUE(sub_idx->params()[1]->AsConstructor()->IsScalarConstructor());
@@ -253,8 +251,8 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_Scalar) {
auto* ptr = accessor;
auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
b->set_constructor(std::move(accessor));
DeclareVariable(std::move(b));
b->set_constructor(accessor);
DeclareVariable(b);
ASSERT_TRUE(td()->Determine()) << td()->error();
@@ -295,15 +293,14 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_Expr) {
create<ast::UintLiteral>(&u32, 2)),
create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 3))));
auto* access_ptr = access_idx;
auto* accessor = create<ast::ArrayAccessorExpression>(
create<ast::IdentifierExpression>("a"), std::move(access_idx));
create<ast::IdentifierExpression>("a"), access_idx);
auto* ptr = accessor;
auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
b->set_constructor(std::move(accessor));
DeclareVariable(std::move(b));
b->set_constructor(accessor);
DeclareVariable(b);
ASSERT_TRUE(td()->Determine()) << td()->error();
@@ -322,7 +319,7 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_Expr) {
auto* tc = idx->params()[0]->AsConstructor()->AsTypeConstructor();
EXPECT_TRUE(tc->type()->IsU32());
ASSERT_EQ(tc->values().size(), 1u);
ASSERT_EQ(tc->values()[0], access_ptr);
ASSERT_EQ(tc->values()[0], access_idx);
ASSERT_TRUE(idx->params()[1]->IsConstructor());
ASSERT_TRUE(idx->params()[1]->AsConstructor()->IsScalarConstructor());
@@ -355,8 +352,8 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_Negative) {
auto* ptr = accessor;
auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
b->set_constructor(std::move(accessor));
DeclareVariable(std::move(b));
b->set_constructor(accessor);
DeclareVariable(b);
ASSERT_TRUE(td()->Determine()) << td()->error();
@@ -394,8 +391,8 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_OutOfBounds) {
auto* ptr = accessor;
auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
b->set_constructor(std::move(accessor));
DeclareVariable(std::move(b));
b->set_constructor(accessor);
DeclareVariable(b);
ASSERT_TRUE(td()->Determine()) << td()->error();
@@ -433,8 +430,8 @@ TEST_F(BoundArrayAccessorsTest, Vector_Idx_Scalar) {
auto* ptr = accessor;
auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
b->set_constructor(std::move(accessor));
DeclareVariable(std::move(b));
b->set_constructor(accessor);
DeclareVariable(b);
ASSERT_TRUE(td()->Determine()) << td()->error();
@@ -475,15 +472,14 @@ TEST_F(BoundArrayAccessorsTest, Vector_Idx_Expr) {
create<ast::UintLiteral>(&u32, 2)),
create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 3))));
auto* access_ptr = access_idx;
auto* accessor = create<ast::ArrayAccessorExpression>(
create<ast::IdentifierExpression>("a"), std::move(access_idx));
create<ast::IdentifierExpression>("a"), access_idx);
auto* ptr = accessor;
auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
b->set_constructor(std::move(accessor));
DeclareVariable(std::move(b));
b->set_constructor(accessor);
DeclareVariable(b);
ASSERT_TRUE(td()->Determine()) << td()->error();
@@ -501,7 +497,7 @@ TEST_F(BoundArrayAccessorsTest, Vector_Idx_Expr) {
auto* tc = idx->params()[0]->AsConstructor()->AsTypeConstructor();
EXPECT_TRUE(tc->type()->IsU32());
ASSERT_EQ(tc->values().size(), 1u);
ASSERT_EQ(tc->values()[0], access_ptr);
ASSERT_EQ(tc->values()[0], access_idx);
ASSERT_TRUE(idx->params()[1]->IsConstructor());
ASSERT_TRUE(idx->params()[1]->AsConstructor()->IsScalarConstructor());
@@ -534,8 +530,8 @@ TEST_F(BoundArrayAccessorsTest, Vector_Idx_Negative) {
auto* ptr = accessor;
auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
b->set_constructor(std::move(accessor));
DeclareVariable(std::move(b));
b->set_constructor(accessor);
DeclareVariable(b);
ASSERT_TRUE(td()->Determine()) << td()->error();
@@ -573,8 +569,8 @@ TEST_F(BoundArrayAccessorsTest, Vector_Idx_OutOfBounds) {
auto* ptr = accessor;
auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
b->set_constructor(std::move(accessor));
DeclareVariable(std::move(b));
b->set_constructor(accessor);
DeclareVariable(b);
ASSERT_TRUE(td()->Determine()) << td()->error();
@@ -615,8 +611,8 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Scalar) {
auto* ptr = accessor;
auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
b->set_constructor(std::move(accessor));
DeclareVariable(std::move(b));
b->set_constructor(accessor);
DeclareVariable(b);
ASSERT_TRUE(td()->Determine()) << td()->error();
@@ -670,18 +666,17 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Expr_Column) {
create<ast::UintLiteral>(&u32, 2)),
create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 3))));
auto* access_ptr = access_idx;
auto* accessor = create<ast::ArrayAccessorExpression>(
create<ast::ArrayAccessorExpression>(
create<ast::IdentifierExpression>("a"), std::move(access_idx)),
create<ast::IdentifierExpression>("a"), access_idx),
create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1u)));
auto* ptr = accessor;
auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
b->set_constructor(std::move(accessor));
DeclareVariable(std::move(b));
b->set_constructor(accessor);
DeclareVariable(b);
ASSERT_TRUE(td()->Determine()) << td()->error();
@@ -703,7 +698,7 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Expr_Column) {
auto* tc = idx->params()[0]->AsConstructor()->AsTypeConstructor();
EXPECT_TRUE(tc->type()->IsU32());
ASSERT_EQ(tc->values().size(), 1u);
ASSERT_EQ(tc->values()[0], access_ptr);
ASSERT_EQ(tc->values()[0], access_idx);
ASSERT_TRUE(idx->params()[1]->IsConstructor());
ASSERT_TRUE(idx->params()[1]->AsConstructor()->IsScalarConstructor());
@@ -749,19 +744,18 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Expr_Row) {
create<ast::UintLiteral>(&u32, 2)),
create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 3))));
auto* access_ptr = access_idx;
auto* accessor = create<ast::ArrayAccessorExpression>(
create<ast::ArrayAccessorExpression>(
create<ast::IdentifierExpression>("a"),
create<ast::ScalarConstructorExpression>(
create<ast::UintLiteral>(&u32, 1u))),
std::move(access_idx));
access_idx);
auto* ptr = accessor;
auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
b->set_constructor(std::move(accessor));
DeclareVariable(std::move(b));
b->set_constructor(accessor);
DeclareVariable(b);
ASSERT_TRUE(td()->Determine()) << td()->error();
@@ -790,7 +784,7 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Expr_Row) {
auto* tc = idx->params()[0]->AsConstructor()->AsTypeConstructor();
EXPECT_TRUE(tc->type()->IsU32());
ASSERT_EQ(tc->values().size(), 1u);
ASSERT_EQ(tc->values()[0], access_ptr);
ASSERT_EQ(tc->values()[0], access_idx);
ASSERT_TRUE(idx->params()[1]->IsConstructor());
ASSERT_TRUE(idx->params()[1]->AsConstructor()->IsScalarConstructor());
@@ -828,8 +822,8 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Negative_Column) {
auto* ptr = accessor;
auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
b->set_constructor(std::move(accessor));
DeclareVariable(std::move(b));
b->set_constructor(accessor);
DeclareVariable(b);
ASSERT_TRUE(td()->Determine()) << td()->error();
@@ -882,8 +876,8 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Negative_Row) {
auto* ptr = accessor;
auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
b->set_constructor(std::move(accessor));
DeclareVariable(std::move(b));
b->set_constructor(accessor);
DeclareVariable(b);
ASSERT_TRUE(td()->Determine()) << td()->error();
@@ -937,8 +931,8 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_OutOfBounds_Column) {
auto* ptr = accessor;
auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
b->set_constructor(std::move(accessor));
DeclareVariable(std::move(b));
b->set_constructor(accessor);
DeclareVariable(b);
ASSERT_TRUE(td()->Determine()) << td()->error();
@@ -992,8 +986,8 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_OutOfBounds_Row) {
auto* ptr = accessor;
auto* b = create<ast::Variable>("b", ast::StorageClass::kFunction, &f32);
b->set_constructor(std::move(accessor));
DeclareVariable(std::move(b));
b->set_constructor(accessor);
DeclareVariable(b);
ASSERT_TRUE(td()->Determine()) << td()->error();

38
src/transform/vertex_pulling_transform.cc
View File

@@ -151,7 +151,7 @@ void VertexPullingTransform::FindOrInsertVertexIndexIfUsed() {
create<ast::BuiltinDecoration>(ast::Builtin::kVertexIdx, Source{}));
var->set_decorations(std::move(decorations));
mod_->AddGlobalVariable(std::move(var));
mod_->AddGlobalVariable(var);
}
void VertexPullingTransform::FindOrInsertInstanceIndexIfUsed() {
@@ -193,7 +193,7 @@ void VertexPullingTransform::FindOrInsertInstanceIndexIfUsed() {
create<ast::BuiltinDecoration>(ast::Builtin::kInstanceIdx, Source{}));
var->set_decorations(std::move(decorations));
mod_->AddGlobalVariable(std::move(var));
mod_->AddGlobalVariable(var);
}
void VertexPullingTransform::ConvertVertexInputVariablesToPrivate() {
@@ -257,7 +257,7 @@ void VertexPullingTransform::AddVertexStorageBuffers() {
decorations.push_back(create<ast::SetDecoration>(pulling_set_, Source{}));
var->set_decorations(std::move(decorations));
mod_->AddGlobalVariable(std::move(var));
mod_->AddGlobalVariable(var);
}
mod_->AddConstructedType(struct_type);
}
@@ -278,7 +278,7 @@ void VertexPullingTransform::AddVertexPullingPreamble(
// |kPullingPosVarName| refers to the byte location of the current read. We
// declare a variable in the shader to avoid having to reuse Expression
// objects.
block->append(std::move(pos_declaration));
block->append(pos_declaration);
for (uint32_t i = 0; i < vertex_state_->vertex_buffers.size(); ++i) {
const VertexBufferLayoutDescriptor& buffer_layout =
@@ -302,14 +302,14 @@ void VertexPullingTransform::AddVertexPullingPreamble(
auto* pos_value = create<ast::BinaryExpression>(
ast::BinaryOp::kAdd,
create<ast::BinaryExpression>(
ast::BinaryOp::kMultiply, std::move(index_identifier),
ast::BinaryOp::kMultiply, index_identifier,
GenUint(static_cast<uint32_t>(buffer_layout.array_stride))),
GenUint(static_cast<uint32_t>(attribute_desc.offset)));
// Update position of the read
auto* set_pos_expr = create<ast::AssignmentStatement>(
CreatePullingPositionIdent(), std::move(pos_value));
block->append(std::move(set_pos_expr));
CreatePullingPositionIdent(), pos_value);
block->append(set_pos_expr);
block->append(create<ast::AssignmentStatement>(
create<ast::IdentifierExpression>(v->name()),
@@ -317,7 +317,7 @@ void VertexPullingTransform::AddVertexPullingPreamble(
}
}
vertex_func->body()->insert(0, std::move(block));
vertex_func->body()->insert(0, block);
}
ast::Expression* VertexPullingTransform::GenUint(uint32_t value) {
@@ -367,22 +367,19 @@ ast::Expression* VertexPullingTransform::AccessU32(uint32_t buffer,
create<ast::MemberAccessorExpression>(
create<ast::IdentifierExpression>(GetVertexBufferName(buffer)),
create<ast::IdentifierExpression>(kStructBufferName)),
create<ast::BinaryExpression>(ast::BinaryOp::kDivide, std::move(pos),
GenUint(4)));
create<ast::BinaryExpression>(ast::BinaryOp::kDivide, pos, GenUint(4)));
}
ast::Expression* VertexPullingTransform::AccessI32(uint32_t buffer,
ast::Expression* pos) {
// as<T> reinterprets bits
return create<ast::BitcastExpression>(GetI32Type(),
AccessU32(buffer, std::move(pos)));
return create<ast::BitcastExpression>(GetI32Type(), AccessU32(buffer, pos));
}
ast::Expression* VertexPullingTransform::AccessF32(uint32_t buffer,
ast::Expression* pos) {
// as<T> reinterprets bits
return create<ast::BitcastExpression>(GetF32Type(),
AccessU32(buffer, std::move(pos)));
return create<ast::BitcastExpression>(GetF32Type(), AccessU32(buffer, pos));
}
ast::Expression* VertexPullingTransform::AccessPrimitive(uint32_t buffer,
@@ -394,11 +391,11 @@ ast::Expression* VertexPullingTransform::AccessPrimitive(uint32_t buffer,
// from the position variable.
switch (format) {
case VertexFormat::kU32:
return AccessU32(buffer, std::move(pos));
return AccessU32(buffer, pos);
case VertexFormat::kI32:
return AccessI32(buffer, std::move(pos));
return AccessI32(buffer, pos);
case VertexFormat::kF32:
return AccessF32(buffer, std::move(pos));
return AccessF32(buffer, pos);
default:
return nullptr;
}
@@ -415,8 +412,7 @@ ast::Expression* VertexPullingTransform::AccessVec(uint32_t buffer,
auto* cur_pos = create<ast::BinaryExpression>(ast::BinaryOp::kAdd,
CreatePullingPositionIdent(),
GenUint(element_stride * i));
expr_list.push_back(
AccessPrimitive(buffer, std::move(cur_pos), base_format));
expr_list.push_back(AccessPrimitive(buffer, cur_pos, base_format));
}
return create<ast::TypeConstructorExpression>(
@@ -443,8 +439,8 @@ VertexBufferLayoutDescriptor::VertexBufferLayoutDescriptor(
uint64_t in_array_stride,
InputStepMode in_step_mode,
std::vector<VertexAttributeDescriptor> in_attributes)
: array_stride(std::move(in_array_stride)),
step_mode(std::move(in_step_mode)),
: array_stride(in_array_stride),
step_mode(in_step_mode),
attributes(std::move(in_attributes)) {}
VertexBufferLayoutDescriptor::VertexBufferLayoutDescriptor(

18
src/transform/vertex_pulling_transform_test.cc
View File

@@ -47,7 +47,7 @@ class VertexPullingTransformHelper {
create<ast::BlockStatement>());
func->add_decoration(
create<ast::StageDecoration>(ast::PipelineStage::kVertex, Source{}));
mod()->AddFunction(std::move(func));
mod()->AddFunction(func);
}
// Set up the transformation, after building the module
@@ -58,7 +58,7 @@ class VertexPullingTransformHelper {
EXPECT_TRUE(td.Determine());
transform_->SetVertexState(
std::make_unique<VertexStateDescriptor>(std::move(vertex_state)));
std::make_unique<VertexStateDescriptor>(vertex_state));
transform_->SetEntryPoint("main");
}
@@ -72,8 +72,8 @@ class VertexPullingTransformHelper {
ast::VariableDecorationList decorations;
decorations.push_back(create<ast::LocationDecoration>(location, Source{}));
var->set_decorations(std::move(decorations));
mod_->AddGlobalVariable(std::move(var));
var->set_decorations(decorations);
mod_->AddGlobalVariable(var);
}
Context* ctx() { return &ctx_; }
@@ -125,7 +125,7 @@ TEST_F(VertexPullingTransformTest, Error_EntryPointWrongStage) {
create<ast::BlockStatement>());
func->add_decoration(
create<ast::StageDecoration>(ast::PipelineStage::kFragment, Source{}));
mod()->AddFunction(std::move(func));
mod()->AddFunction(func);
InitTransform({});
EXPECT_FALSE(transform()->Run());
@@ -410,8 +410,8 @@ TEST_F(VertexPullingTransformTest, ExistingVertexIndexAndInstanceIndex) {
decorations.push_back(
create<ast::BuiltinDecoration>(ast::Builtin::kVertexIdx, Source{}));
vertex_index_var->set_decorations(std::move(decorations));
mod()->AddGlobalVariable(std::move(vertex_index_var));
vertex_index_var->set_decorations(decorations);
mod()->AddGlobalVariable(vertex_index_var);
}
{
@@ -423,8 +423,8 @@ TEST_F(VertexPullingTransformTest, ExistingVertexIndexAndInstanceIndex) {
decorations.push_back(
create<ast::BuiltinDecoration>(ast::Builtin::kInstanceIdx, Source{}));
instance_index_var->set_decorations(std::move(decorations));
mod()->AddGlobalVariable(std::move(instance_index_var));
instance_index_var->set_decorations(decorations);
mod()->AddGlobalVariable(instance_index_var);
}
InitTransform(