Remove @block attribute

Since this was the only attribute allowed on structures, we can also remove the parsing code for them. However, we still need to have attributes on the struct AST node, since the AddSpirvBlockAttribute transform adds one. Fixed: tint:1324 Change-Id: I7966237765b1d8a58c59908b59e1f1152a8a0439 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/83740 Kokoro: Kokoro <noreply+kokoro@google.com> Reviewed-by: Ben Clayton <bclayton@google.com>
2025-12-21 18:59:21 +00:00 · 2022-03-21 16:09:17 +00:00
parent 3b00139439
commit 8bcecf365d
61 changed files with 403 additions and 1045 deletions
--- a/src/tint/resolver/assignment_validation_test.cc
+++ b/src/tint/resolver/assignment_validation_test.cc
@@ -15,7 +15,6 @@
 #include "src/tint/resolver/resolver.h"

 #include "gmock/gmock.h"
-#include "src/tint/ast/struct_block_attribute.h"
 #include "src/tint/resolver/resolver_test_helper.h"
 #include "src/tint/sem/storage_texture_type.h"

@@ -26,11 +25,10 @@ namespace {
 using ResolverAssignmentValidationTest = ResolverTest;

 TEST_F(ResolverAssignmentValidationTest, ReadOnlyBuffer) {
-  // [[block]] struct S { m : i32 };
+  // struct S { m : i32 };
  // @group(0) @binding(0)
  // var<storage,read> a : S;
-  auto* s = Structure("S", {Member("m", ty.i32())},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member("m", ty.i32())});
  Global(Source{{12, 34}}, "a", ty.Of(s), ast::StorageClass::kStorage,
         ast::Access::kRead,
         ast::AttributeList{
@@ -250,12 +248,11 @@ TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_Handle) {
 }

 TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_Atomic) {
-  // [[block]] struct S { a : atomic<i32>; };
+  // struct S { a : atomic<i32>; };
  // @group(0) @binding(0) var<storage, read_write> v : S;
  // v.a = v.a;

-  auto* s = Structure("S", {Member("a", ty.atomic(ty.i32()))},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member("a", ty.atomic(ty.i32()))});
  Global(Source{{12, 34}}, "v", ty.Of(s), ast::StorageClass::kStorage,
         ast::Access::kReadWrite,
         ast::AttributeList{
@@ -272,12 +269,11 @@ TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_Atomic) {
 }

 TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_RuntimeArray) {
-  // [[block]] struct S { a : array<f32>; };
+  // struct S { a : array<f32>; };
  // @group(0) @binding(0) var<storage, read_write> v : S;
  // v.a = v.a;

-  auto* s = Structure("S", {Member("a", ty.array(ty.f32()))},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member("a", ty.array(ty.f32()))});
  Global(Source{{12, 34}}, "v", ty.Of(s), ast::StorageClass::kStorage,
         ast::Access::kReadWrite,
         ast::AttributeList{
@@ -295,7 +291,6 @@ TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_RuntimeArray) {

 TEST_F(ResolverAssignmentValidationTest,
       AssignToPhony_NonConstructibleStruct_Fail) {
-  // [[block]]
  // struct S {
  //   arr: array<i32>;
  // };
@@ -303,7 +298,7 @@ TEST_F(ResolverAssignmentValidationTest,
  // fn f() {
  //   _ = s;
  // }
-  auto* s = Structure("S", {Member("arr", ty.array<i32>())}, {StructBlock()});
+  auto* s = Structure("S", {Member("arr", ty.array<i32>())});
  Global("s", ty.Of(s), ast::StorageClass::kStorage, GroupAndBinding(0, 0));

  WrapInFunction(Assign(Phony(), Expr(Source{{12, 34}}, "s")));
@@ -316,7 +311,6 @@ TEST_F(ResolverAssignmentValidationTest,
 }

 TEST_F(ResolverAssignmentValidationTest, AssignToPhony_DynamicArray_Fail) {
-  // [[block]]
  // struct S {
  //   arr: array<i32>;
  // };
@@ -324,7 +318,7 @@ TEST_F(ResolverAssignmentValidationTest, AssignToPhony_DynamicArray_Fail) {
  // fn f() {
  //   _ = s.arr;
  // }
-  auto* s = Structure("S", {Member("arr", ty.array<i32>())}, {StructBlock()});
+  auto* s = Structure("S", {Member("arr", ty.array<i32>())});
  Global("s", ty.Of(s), ast::StorageClass::kStorage, GroupAndBinding(0, 0));

  WrapInFunction(Assign(Phony(), MemberAccessor(Source{{12, 34}}, "s", "arr")));
@@ -338,12 +332,10 @@ TEST_F(ResolverAssignmentValidationTest, AssignToPhony_DynamicArray_Fail) {
 }

 TEST_F(ResolverAssignmentValidationTest, AssignToPhony_Pass) {
-  // [[block]]
  // struct S {
  //   i:   i32;
  //   arr: array<i32>;
  // };
-  // [[block]]
  // struct U {
  //   i:   i32;
  // };
@@ -367,13 +359,11 @@ TEST_F(ResolverAssignmentValidationTest, AssignToPhony_Pass) {
  //   _ = wg;
  //   _ = wg[3];
  // }
-  auto* S = Structure("S",
-                      {
-                          Member("i", ty.i32()),
-                          Member("arr", ty.array<i32>()),
-                      },
-                      {StructBlock()});
-  auto* U = Structure("U", {Member("i", ty.i32())}, {StructBlock()});
+  auto* S = Structure("S", {
+                               Member("i", ty.i32()),
+                               Member("arr", ty.array<i32>()),
+                           });
+  auto* U = Structure("U", {Member("i", ty.i32())});
  Global("tex", ty.sampled_texture(ast::TextureDimension::k2d, ty.f32()),
         GroupAndBinding(0, 0));
  Global("smp", ty.sampler(ast::SamplerKind::kSampler), GroupAndBinding(0, 1));
--- a/src/tint/resolver/atomics_test.cc
+++ b/src/tint/resolver/atomics_test.cc
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-#include "src/tint/ast/struct_block_attribute.h"
 #include "src/tint/resolver/resolver.h"
 #include "src/tint/resolver/resolver_test_helper.h"
 #include "src/tint/sem/atomic_type.h"
@@ -50,8 +49,8 @@ TEST_F(ResolverAtomicTest, GlobalWorkgroupU32) {
 }

 TEST_F(ResolverAtomicTest, GlobalStorageStruct) {
-  auto* s = Structure("s", {Member("a", ty.atomic(Source{{12, 34}}, ty.i32()))},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s =
+      Structure("s", {Member("a", ty.atomic(Source{{12, 34}}, ty.i32()))});
  auto* g = Global("g", ty.Of(s), ast::StorageClass::kStorage,
                   ast::Access::kReadWrite,
                   ast::AttributeList{
--- a/src/tint/resolver/atomics_validation_test.cc
+++ b/src/tint/resolver/atomics_validation_test.cc
@@ -34,8 +34,8 @@ TEST_F(ResolverAtomicValidationTest, StorageClass_WorkGroup) {
 }

 TEST_F(ResolverAtomicValidationTest, StorageClass_Storage) {
-  auto* s = Structure("s", {Member("a", ty.atomic(Source{{12, 34}}, ty.i32()))},
-                      {StructBlock()});
+  auto* s =
+      Structure("s", {Member("a", ty.atomic(Source{{12, 34}}, ty.i32()))});
  Global("g", ty.Of(s), ast::StorageClass::kStorage, ast::Access::kReadWrite,
         GroupAndBinding(0, 0));

@@ -211,8 +211,8 @@ TEST_F(ResolverAtomicValidationTest, InvalidStorageClass_Complex) {
 }

 TEST_F(ResolverAtomicValidationTest, Struct_AccessMode_Read) {
-  auto* s = Structure("s", {Member("a", ty.atomic(Source{{12, 34}}, ty.i32()))},
-                      {StructBlock()});
+  auto* s =
+      Structure("s", {Member("a", ty.atomic(Source{{12, 34}}, ty.i32()))});
  Global(Source{{56, 78}}, "g", ty.Of(s), ast::StorageClass::kStorage,
         ast::Access::kRead, GroupAndBinding(0, 0));

@@ -225,8 +225,8 @@ TEST_F(ResolverAtomicValidationTest, Struct_AccessMode_Read) {
 }

 TEST_F(ResolverAtomicValidationTest, InvalidAccessMode_Struct) {
-  auto* s = Structure("s", {Member("a", ty.atomic(Source{{12, 34}}, ty.i32()))},
-                      {StructBlock()});
+  auto* s =
+      Structure("s", {Member("a", ty.atomic(Source{{12, 34}}, ty.i32()))});
  Global(Source{{56, 78}}, "g", ty.Of(s), ast::StorageClass::kStorage,
         ast::Access::kRead, GroupAndBinding(0, 0));

@@ -245,8 +245,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAccessMode_StructOfStruct) {

  auto* Inner =
      Structure("Inner", {Member("m", ty.atomic(Source{{12, 34}}, ty.i32()))});
-  auto* Outer =
-      Structure("Outer", {Member("m", ty.Of(Inner))}, {StructBlock()});
+  auto* Outer = Structure("Outer", {Member("m", ty.Of(Inner))});
  Global(Source{{56, 78}}, "g", ty.Of(Outer), ast::StorageClass::kStorage,
         ast::Access::kRead, GroupAndBinding(0, 0));

@@ -265,8 +264,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAccessMode_StructOfStructOfArray) {

  auto* Inner =
      Structure("Inner", {Member(Source{{12, 34}}, "m", ty.atomic(ty.i32()))});
-  auto* Outer =
-      Structure("Outer", {Member("m", ty.Of(Inner))}, {StructBlock()});
+  auto* Outer = Structure("Outer", {Member("m", ty.Of(Inner))});
  Global(Source{{56, 78}}, "g", ty.Of(Outer), ast::StorageClass::kStorage,
         ast::Access::kRead, GroupAndBinding(0, 0));

@@ -308,7 +306,7 @@ TEST_F(ResolverAtomicValidationTest, InvalidAccessMode_Complex) {
  auto* s3 = Structure("S3", {Member("x", ty.Of(s4))});
  auto* s2 = Structure("S2", {Member("x", ty.Of(s3))});
  auto* s1 = Structure("S1", {Member("x", ty.Of(s2))});
-  auto* s0 = Structure("S0", {Member("x", ty.Of(s1))}, {StructBlock()});
+  auto* s0 = Structure("S0", {Member("x", ty.Of(s1))});
  Global(Source{{56, 78}}, "g", ty.Of(s0), ast::StorageClass::kStorage,
         ast::Access::kRead, GroupAndBinding(0, 0));

--- a/src/tint/resolver/attribute_validation_test.cc
+++ b/src/tint/resolver/attribute_validation_test.cc
@@ -15,6 +15,7 @@
 #include "src/tint/ast/disable_validation_attribute.h"
 #include "src/tint/resolver/resolver.h"
 #include "src/tint/resolver/resolver_test_helper.h"
+#include "src/tint/transform/add_spirv_block_attribute.h"

 #include "gmock/gmock.h"

@@ -63,7 +64,6 @@ enum class AttributeKind {
  kSize,
  kStage,
  kStride,
-  kStructBlock,
  kWorkgroup,

  kBindingAndGroup,
@@ -115,8 +115,6 @@ static ast::AttributeList createAttributes(const Source& source,
      return {builder.Stage(source, ast::PipelineStage::kCompute)};
    case AttributeKind::kStride:
      return {builder.create<ast::StrideAttribute>(source, 4u)};
-    case AttributeKind::kStructBlock:
-      return {builder.create<ast::StructBlockAttribute>(source)};
    case AttributeKind::kWorkgroup:
      return {builder.create<ast::WorkgroupAttribute>(source, builder.Expr(1))};
    case AttributeKind::kBindingAndGroup:
@@ -160,7 +158,6 @@ INSTANTIATE_TEST_SUITE_P(
                    TestParams{AttributeKind::kSize, false},
                    TestParams{AttributeKind::kStage, false},
                    TestParams{AttributeKind::kStride, false},
-                    TestParams{AttributeKind::kStructBlock, false},
                    TestParams{AttributeKind::kWorkgroup, false},
                    TestParams{AttributeKind::kBindingAndGroup, false}));

@@ -195,7 +192,6 @@ INSTANTIATE_TEST_SUITE_P(
                    TestParams{AttributeKind::kSize, false},
                    TestParams{AttributeKind::kStage, false},
                    TestParams{AttributeKind::kStride, false},
-                    TestParams{AttributeKind::kStructBlock, false},
                    TestParams{AttributeKind::kWorkgroup, false},
                    TestParams{AttributeKind::kBindingAndGroup, false}));
 }  // namespace FunctionInputAndOutputTests
@@ -244,7 +240,6 @@ INSTANTIATE_TEST_SUITE_P(
                    TestParams{AttributeKind::kSize, false},
                    TestParams{AttributeKind::kStage, false},
                    TestParams{AttributeKind::kStride, false},
-                    TestParams{AttributeKind::kStructBlock, false},
                    TestParams{AttributeKind::kWorkgroup, false},
                    TestParams{AttributeKind::kBindingAndGroup, false}));

@@ -283,7 +278,6 @@ INSTANTIATE_TEST_SUITE_P(
                    TestParams{AttributeKind::kSize, false},
                    TestParams{AttributeKind::kStage, false},
                    TestParams{AttributeKind::kStride, false},
-                    TestParams{AttributeKind::kStructBlock, false},
                    TestParams{AttributeKind::kWorkgroup, false},
                    TestParams{AttributeKind::kBindingAndGroup, false}));

@@ -333,7 +327,6 @@ INSTANTIATE_TEST_SUITE_P(
                    TestParams{AttributeKind::kSize, false},
                    TestParams{AttributeKind::kStage, false},
                    TestParams{AttributeKind::kStride, false},
-                    TestParams{AttributeKind::kStructBlock, false},
                    TestParams{AttributeKind::kWorkgroup, false},
                    TestParams{AttributeKind::kBindingAndGroup, false}));

@@ -381,7 +374,6 @@ INSTANTIATE_TEST_SUITE_P(
                    TestParams{AttributeKind::kSize, false},
                    TestParams{AttributeKind::kStage, false},
                    TestParams{AttributeKind::kStride, false},
-                    TestParams{AttributeKind::kStructBlock, false},
                    TestParams{AttributeKind::kWorkgroup, false},
                    TestParams{AttributeKind::kBindingAndGroup, false}));

@@ -431,7 +423,6 @@ INSTANTIATE_TEST_SUITE_P(
                    TestParams{AttributeKind::kSize, false},
                    TestParams{AttributeKind::kStage, false},
                    TestParams{AttributeKind::kStride, false},
-                    TestParams{AttributeKind::kStructBlock, false},
                    TestParams{AttributeKind::kWorkgroup, false},
                    TestParams{AttributeKind::kBindingAndGroup, false}));

@@ -477,7 +468,6 @@ INSTANTIATE_TEST_SUITE_P(
                    TestParams{AttributeKind::kSize, false},
                    TestParams{AttributeKind::kStage, false},
                    TestParams{AttributeKind::kStride, false},
-                    TestParams{AttributeKind::kStructBlock, false},
                    TestParams{AttributeKind::kWorkgroup, false},
                    TestParams{AttributeKind::kBindingAndGroup, false}));

@@ -537,13 +527,15 @@ TEST_F(EntryPointReturnTypeAttributeTest, DuplicateInternalAttribute) {

 namespace StructAndStructMemberTests {
 using StructAttributeTest = TestWithParams;
+using SpirvBlockAttribute =
+    transform::AddSpirvBlockAttribute::SpirvBlockAttribute;
 TEST_P(StructAttributeTest, IsValid) {
  auto& params = GetParam();

-  Structure("mystruct", {Member("a", ty.f32())},
-            createAttributes(Source{{12, 34}}, *this, params.kind));
-
-  WrapInFunction();
+  auto* str = create<ast::Struct>(
+      Sym("mystruct"), ast::StructMemberList{Member("a", ty.f32())},
+      createAttributes(Source{{12, 34}}, *this, params.kind));
+  AST().AddGlobalDeclaration(str);

  if (params.should_pass) {
    EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -568,25 +560,9 @@ INSTANTIATE_TEST_SUITE_P(
                    TestParams{AttributeKind::kSize, false},
                    TestParams{AttributeKind::kStage, false},
                    TestParams{AttributeKind::kStride, false},
-                    TestParams{AttributeKind::kStructBlock, true},
                    TestParams{AttributeKind::kWorkgroup, false},
                    TestParams{AttributeKind::kBindingAndGroup, false}));

-TEST_F(StructAttributeTest, DuplicateAttribute) {
-  Structure("mystruct",
-            {
-                Member("a", ty.i32()),
-            },
-            {
-                create<ast::StructBlockAttribute>(Source{{12, 34}}),
-                create<ast::StructBlockAttribute>(Source{{56, 78}}),
-            });
-  WrapInFunction();
-  EXPECT_FALSE(r()->Resolve());
-  EXPECT_EQ(r()->error(),
-            R"(56:78 error: duplicate block attribute
-12:34 note: first attribute declared here)");
-}
 using StructMemberAttributeTest = TestWithParams;
 TEST_P(StructMemberAttributeTest, IsValid) {
  auto& params = GetParam();
@@ -625,7 +601,6 @@ INSTANTIATE_TEST_SUITE_P(
                    TestParams{AttributeKind::kSize, true},
                    TestParams{AttributeKind::kStage, false},
                    TestParams{AttributeKind::kStride, false},
-                    TestParams{AttributeKind::kStructBlock, false},
                    TestParams{AttributeKind::kWorkgroup, false},
                    TestParams{AttributeKind::kBindingAndGroup, false}));
 TEST_F(StructMemberAttributeTest, DuplicateAttribute) {
@@ -678,11 +653,9 @@ TEST_P(ArrayAttributeTest, IsValid) {

  auto* arr = ty.array(ty.f32(), nullptr,
                       createAttributes(Source{{12, 34}}, *this, params.kind));
-  Structure("mystruct",
-            {
-                Member("a", arr),
-            },
-            {create<ast::StructBlockAttribute>()});
+  Structure("mystruct", {
+                            Member("a", arr),
+                        });

  WrapInFunction();

@@ -709,7 +682,6 @@ INSTANTIATE_TEST_SUITE_P(
                    TestParams{AttributeKind::kSize, false},
                    TestParams{AttributeKind::kStage, false},
                    TestParams{AttributeKind::kStride, true},
-                    TestParams{AttributeKind::kStructBlock, false},
                    TestParams{AttributeKind::kWorkgroup, false},
                    TestParams{AttributeKind::kBindingAndGroup, false}));

@@ -753,7 +725,6 @@ INSTANTIATE_TEST_SUITE_P(
                    TestParams{AttributeKind::kSize, false},
                    TestParams{AttributeKind::kStage, false},
                    TestParams{AttributeKind::kStride, false},
-                    TestParams{AttributeKind::kStructBlock, false},
                    TestParams{AttributeKind::kWorkgroup, false},
                    TestParams{AttributeKind::kBindingAndGroup, true}));

@@ -818,7 +789,6 @@ INSTANTIATE_TEST_SUITE_P(
                    TestParams{AttributeKind::kSize, false},
                    TestParams{AttributeKind::kStage, false},
                    TestParams{AttributeKind::kStride, false},
-                    TestParams{AttributeKind::kStructBlock, false},
                    TestParams{AttributeKind::kWorkgroup, false},
                    TestParams{AttributeKind::kBindingAndGroup, false}));

@@ -968,8 +938,7 @@ namespace {

 using ResourceAttributeTest = ResolverTest;
 TEST_F(ResourceAttributeTest, UniformBufferMissingBinding) {
-  auto* s = Structure("S", {Member("x", ty.i32())},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member("x", ty.i32())});
  Global(Source{{12, 34}}, "G", ty.Of(s), ast::StorageClass::kUniform);

  EXPECT_FALSE(r()->Resolve());
@@ -979,8 +948,7 @@ TEST_F(ResourceAttributeTest, UniformBufferMissingBinding) {
 }

 TEST_F(ResourceAttributeTest, StorageBufferMissingBinding) {
-  auto* s = Structure("S", {Member("x", ty.i32())},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member("x", ty.i32())});
  Global(Source{{12, 34}}, "G", ty.Of(s), ast::StorageClass::kStorage,
         ast::Access::kRead);

@@ -1344,8 +1312,7 @@ TEST_F(InterpolateTest, VertexOutput_Integer_MissingFlatInterpolation) {
      {
          Member("pos", ty.vec4<f32>(), {Builtin(ast::Builtin::kPosition)}),
          Member(Source{{12, 34}}, "u", ty.u32(), {Location(0)}),
-      },
-      {});
+      });
  Func("main", {}, ty.Of(s), {Return(Construct(ty.Of(s)))},
       ast::AttributeList{Stage(ast::PipelineStage::kVertex)});

--- a/src/tint/resolver/builtin_test.cc
+++ b/src/tint/resolver/builtin_test.cc
@@ -25,7 +25,6 @@
 #include "src/tint/ast/loop_statement.h"
 #include "src/tint/ast/return_statement.h"
 #include "src/tint/ast/stage_attribute.h"
-#include "src/tint/ast/struct_block_attribute.h"
 #include "src/tint/ast/switch_statement.h"
 #include "src/tint/ast/unary_op_expression.h"
 #include "src/tint/ast/variable_decl_statement.h"
@@ -633,8 +632,7 @@ using ResolverBuiltinDataTest = ResolverTest;

 TEST_F(ResolverBuiltinDataTest, ArrayLength_Vector) {
  auto* ary = ty.array<i32>();
-  auto* str =
-      Structure("S", {Member("x", ary)}, {create<ast::StructBlockAttribute>()});
+  auto* str = Structure("S", {Member("x", ary)});
  Global("a", ty.Of(str), ast::StorageClass::kStorage, ast::Access::kRead,
         ast::AttributeList{
             create<ast::BindingAttribute>(0),
--- a/src/tint/resolver/dependency_graph.cc
+++ b/src/tint/resolver/dependency_graph.cc
@@ -379,8 +379,7 @@ class DependencyScanner {
            ast::IdAttribute, ast::InternalAttribute, ast::InterpolateAttribute,
            ast::InvariantAttribute, ast::LocationAttribute,
            ast::StageAttribute, ast::StrideAttribute,
-            ast::StructBlockAttribute, ast::StructMemberAlignAttribute,
-            ast::StructMemberOffsetAttribute,
+            ast::StructMemberAlignAttribute, ast::StructMemberOffsetAttribute,
            ast::StructMemberSizeAttribute>()) {
      return;
    }
--- a/src/tint/resolver/entry_point_validation_test.cc
+++ b/src/tint/resolver/entry_point_validation_test.cc
@@ -16,7 +16,6 @@
 #include "src/tint/ast/location_attribute.h"
 #include "src/tint/ast/return_statement.h"
 #include "src/tint/ast/stage_attribute.h"
-#include "src/tint/ast/struct_block_attribute.h"
 #include "src/tint/resolver/resolver.h"
 #include "src/tint/resolver/resolver_test_helper.h"

@@ -540,16 +539,13 @@ TEST_F(LocationAttributeTests, BadType_Input_Struct_NestedStruct) {
 }

 TEST_F(LocationAttributeTests, BadType_Input_Struct_RuntimeArray) {
-  // [[block]]
  // struct Input {
  //   @location(0) a : array<f32>;
  // };
  // @stage(fragment)
  // fn main(param : Input) {}
-  auto* input = Structure(
-      "Input",
-      {Member(Source{{13, 43}}, "a", ty.array<float>(), {Location(0)})},
-      {create<ast::StructBlockAttribute>()});
+  auto* input = Structure("Input", {Member(Source{{13, 43}}, "a",
+                                           ty.array<float>(), {Location(0)})});
  auto* param = Param("param", ty.Of(input));
  Func(Source{{12, 34}}, "main", {param}, ty.void_(), {},
       {Stage(ast::PipelineStage::kFragment)});
@@ -563,14 +559,13 @@ TEST_F(LocationAttributeTests, BadType_Input_Struct_RuntimeArray) {
 }

 TEST_F(LocationAttributeTests, BadMemberType_Input) {
-  // [[block]]
  // struct S { @location(0) m: array<i32>; };
  // @stage(fragment)
  // fn frag_main( a: S) {}

  auto* m = Member(Source{{34, 56}}, "m", ty.array<i32>(),
                   ast::AttributeList{Location(Source{{12, 34}}, 0u)});
-  auto* s = Structure("S", {m}, ast::AttributeList{StructBlock()});
+  auto* s = Structure("S", {m});
  auto* p = Param("a", ty.Of(s));

  Func("frag_main", {p}, ty.void_(), {},
@@ -682,7 +677,6 @@ TEST_F(LocationAttributeTests, ReturnType_Struct_NestedStruct) {
 }

 TEST_F(LocationAttributeTests, ReturnType_Struct_RuntimeArray) {
-  // [[block]]
  // struct Output {
  //   @location(0) a : array<f32>;
  // };
@@ -690,10 +684,9 @@ TEST_F(LocationAttributeTests, ReturnType_Struct_RuntimeArray) {
  // fn main() -> Output {
  //   return Output();
  // }
-  auto* output = Structure("Output",
-                           {Member(Source{{13, 43}}, "a", ty.array<float>(),
-                                   {Location(Source{{12, 34}}, 0)})},
-                           {create<ast::StructBlockAttribute>()});
+  auto* output =
+      Structure("Output", {Member(Source{{13, 43}}, "a", ty.array<float>(),
+                                  {Location(Source{{12, 34}}, 0)})});
  Func(Source{{12, 34}}, "main", {}, ty.Of(output),
       {Return(Construct(ty.Of(output)))},
       {Stage(ast::PipelineStage::kFragment)});
--- a/src/tint/resolver/host_shareable_validation_test.cc
+++ b/src/tint/resolver/host_shareable_validation_test.cc
@@ -15,7 +15,6 @@
 #include "src/tint/resolver/resolver.h"

 #include "gmock/gmock.h"
-#include "src/tint/ast/struct_block_attribute.h"
 #include "src/tint/resolver/resolver_test_helper.h"
 #include "src/tint/sem/struct.h"

@@ -26,8 +25,7 @@ namespace {
 using ResolverHostShareableValidationTest = ResolverTest;

 TEST_F(ResolverHostShareableValidationTest, BoolMember) {
-  auto* s = Structure("S", {Member(Source{{12, 34}}, "x", ty.bool_())},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member(Source{{12, 34}}, "x", ty.bool_())});

  Global(Source{{56, 78}}, "g", ty.Of(s), ast::StorageClass::kStorage,
         ast::Access::kRead,
@@ -46,8 +44,7 @@ TEST_F(ResolverHostShareableValidationTest, BoolMember) {
 }

 TEST_F(ResolverHostShareableValidationTest, BoolVectorMember) {
-  auto* s = Structure("S", {Member(Source{{12, 34}}, "x", ty.vec3<bool>())},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member(Source{{12, 34}}, "x", ty.vec3<bool>())});

  Global(Source{{56, 78}}, "g", ty.Of(s), ast::StorageClass::kStorage,
         ast::Access::kRead,
@@ -67,8 +64,7 @@ TEST_F(ResolverHostShareableValidationTest, BoolVectorMember) {

 TEST_F(ResolverHostShareableValidationTest, Aliases) {
  auto* a1 = Alias("a1", ty.bool_());
-  auto* s = Structure("S", {Member(Source{{12, 34}}, "x", ty.Of(a1))},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member(Source{{12, 34}}, "x", ty.Of(a1))});
  auto* a2 = Alias("a2", ty.Of(s));
  Global(Source{{56, 78}}, "g", ty.Of(a2), ast::StorageClass::kStorage,
         ast::Access::kRead,
@@ -91,8 +87,7 @@ TEST_F(ResolverHostShareableValidationTest, NestedStructures) {
  auto* i2 = Structure("I2", {Member(Source{{3, 4}}, "y", ty.Of(i1))});
  auto* i3 = Structure("I3", {Member(Source{{5, 6}}, "z", ty.Of(i2))});

-  auto* s = Structure("S", {Member(Source{{7, 8}}, "m", ty.Of(i3))},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member(Source{{7, 8}}, "m", ty.Of(i3))});

  Global(Source{{9, 10}}, "g", ty.Of(s), ast::StorageClass::kStorage,
         ast::Access::kRead,
@@ -132,8 +127,7 @@ TEST_F(ResolverHostShareableValidationTest, NoError) {
                                 Member(Source{{6, 1}}, "z3", ty.Of(a2)),
                             });

-  auto* s = Structure("S", {Member(Source{{7, 8}}, "m", ty.Of(i3))},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member(Source{{7, 8}}, "m", ty.Of(i3))});

  Global(Source{{9, 10}}, "g", ty.Of(s), ast::StorageClass::kStorage,
         ast::Access::kRead,
--- a/src/tint/resolver/inferred_type_test.cc
+++ b/src/tint/resolver/inferred_type_test.cc
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-#include "src/tint/ast/struct_block_attribute.h"
 #include "src/tint/resolver/resolver.h"
 #include "src/tint/resolver/resolver_test_helper.h"

@@ -154,7 +153,7 @@ TEST_F(ResolverInferredTypeTest, InferArray_Pass) {

 TEST_F(ResolverInferredTypeTest, InferStruct_Pass) {
  auto* member = Member("x", ty.i32());
-  auto* str = Structure("S", {member}, {create<ast::StructBlockAttribute>()});
+  auto* str = Structure("S", {member});

  auto* expected_type = create<sem::Struct>(
      str, str->name,
--- a/src/tint/resolver/ptr_ref_test.cc
+++ b/src/tint/resolver/ptr_ref_test.cc
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-#include "src/tint/ast/struct_block_attribute.h"
 #include "src/tint/resolver/resolver.h"
 #include "src/tint/resolver/resolver_test_helper.h"
 #include "src/tint/sem/reference_type.h"
@@ -61,8 +60,7 @@ TEST_F(ResolverPtrRefTest, AddressOfThenDeref) {
 TEST_F(ResolverPtrRefTest, DefaultPtrStorageClass) {
  // https://gpuweb.github.io/gpuweb/wgsl/#storage-class

-  auto* buf = Structure("S", {Member("m", ty.i32())},
-                        {create<ast::StructBlockAttribute>()});
+  auto* buf = Structure("S", {Member("m", ty.i32())});
  auto* function = Var("f", ty.i32());
  auto* private_ = Global("p", ty.i32(), ast::StorageClass::kPrivate);
  auto* workgroup = Global("w", ty.i32(), ast::StorageClass::kWorkgroup);
--- a/src/tint/resolver/ptr_ref_validation_test.cc
+++ b/src/tint/resolver/ptr_ref_validation_test.cc
@@ -13,7 +13,6 @@
 // limitations under the License.

 #include "src/tint/ast/bitcast_expression.h"
-#include "src/tint/ast/struct_block_attribute.h"
 #include "src/tint/resolver/resolver.h"
 #include "src/tint/resolver/resolver_test_helper.h"
 #include "src/tint/sem/reference_type.h"
@@ -139,7 +138,7 @@ TEST_F(ResolverPtrRefValidationTest, InferredPtrAccessMismatch) {
  // struct Inner {
  //    arr: array<i32, 4>;
  // }
-  // [[block]] struct S {
+  // struct S {
  //    inner: Inner;
  // }
  // @group(0) @binding(0) var<storage, read_write> s : S;
@@ -147,8 +146,7 @@ TEST_F(ResolverPtrRefValidationTest, InferredPtrAccessMismatch) {
  //   let p : pointer<storage, i32> = &s.inner.arr[2];
  // }
  auto* inner = Structure("Inner", {Member("arr", ty.array<i32, 4>())});
-  auto* buf = Structure("S", {Member("inner", ty.Of(inner))},
-                        {create<ast::StructBlockAttribute>()});
+  auto* buf = Structure("S", {Member("inner", ty.Of(inner))});
  auto* storage = Global("s", ty.Of(buf), ast::StorageClass::kStorage,
                         ast::Access::kReadWrite,
                         ast::AttributeList{
--- a/src/tint/resolver/resolver_test.cc
+++ b/src/tint/resolver/resolver_test.cc
@@ -30,7 +30,6 @@
 #include "src/tint/ast/loop_statement.h"
 #include "src/tint/ast/return_statement.h"
 #include "src/tint/ast/stage_attribute.h"
-#include "src/tint/ast/struct_block_attribute.h"
 #include "src/tint/ast/switch_statement.h"
 #include "src/tint/ast/unary_op_expression.h"
 #include "src/tint/ast/variable_decl_statement.h"
@@ -783,8 +782,7 @@ TEST_F(ResolverTest, Function_Parameters) {
 }

 TEST_F(ResolverTest, Function_RegisterInputOutputVariables) {
-  auto* s = Structure("S", {Member("m", ty.u32())},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member("m", ty.u32())});

  auto* sb_var = Global("sb_var", ty.Of(s), ast::StorageClass::kStorage,
                        ast::Access::kReadWrite,
@@ -817,8 +815,7 @@ TEST_F(ResolverTest, Function_RegisterInputOutputVariables) {
 }

 TEST_F(ResolverTest, Function_RegisterInputOutputVariables_SubFunction) {
-  auto* s = Structure("S", {Member("m", ty.u32())},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member("m", ty.u32())});

  auto* sb_var = Global("sb_var", ty.Of(s), ast::StorageClass::kStorage,
                        ast::Access::kReadWrite,
@@ -1800,10 +1797,9 @@ TEST_F(ResolverTest, StorageClass_DoesNotSetOnConst) {
 }

 TEST_F(ResolverTest, Access_SetForStorageBuffer) {
-  // [[block]] struct S { x : i32 };
+  // struct S { x : i32 };
  // var<storage> g : S;
-  auto* s = Structure("S", {Member(Source{{12, 34}}, "x", ty.i32())},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member(Source{{12, 34}}, "x", ty.i32())});
  auto* var =
      Global(Source{{56, 78}}, "g", ty.Of(s), ast::StorageClass::kStorage,
             ast::AttributeList{
--- a/src/tint/resolver/resolver_validation.cc
+++ b/src/tint/resolver/resolver_validation.cc
@@ -2133,7 +2133,7 @@ bool Resolver::ValidateStructure(const sem::Struct* str) {
  }

  for (auto* attr : str->Declaration()->attributes) {
-    if (!(attr->IsAnyOf<ast::StructBlockAttribute, ast::InternalAttribute>())) {
+    if (!(attr->IsAnyOf<ast::InternalAttribute>())) {
      AddError("attribute is not valid for struct declarations", attr->source);
      return false;
    }
--- a/src/tint/resolver/storage_class_layout_validation_test.cc
+++ b/src/tint/resolver/storage_class_layout_validation_test.cc
@@ -26,7 +26,6 @@ using ResolverStorageClassLayoutValidationTest = ResolverTest;
 // Detect unaligned member for storage buffers
 TEST_F(ResolverStorageClassLayoutValidationTest,
       StorageBuffer_UnalignedMember) {
-  // [[block]]
  // struct S {
  //     @size(5) a : f32;
  //     @align(1) b : f32;
@@ -36,8 +35,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest,

  Structure(Source{{12, 34}}, "S",
            {Member("a", ty.f32(), {MemberSize(5)}),
-             Member(Source{{34, 56}}, "b", ty.f32(), {MemberAlign(1)})},
-            {StructBlock()});
+             Member(Source{{34, 56}}, "b", ty.f32(), {MemberAlign(1)})});

  Global(Source{{78, 90}}, "a", ty.type_name("S"), ast::StorageClass::kStorage,
         GroupAndBinding(0, 0));
@@ -57,7 +55,6 @@ TEST_F(ResolverStorageClassLayoutValidationTest,

 TEST_F(ResolverStorageClassLayoutValidationTest,
       StorageBuffer_UnalignedMember_SuggestedFix) {
-  // [[block]]
  // struct S {
  //     @size(5) a : f32;
  //     @align(4) b : f32;
@@ -67,8 +64,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest,

  Structure(Source{{12, 34}}, "S",
            {Member("a", ty.f32(), {MemberSize(5)}),
-             Member(Source{{34, 56}}, "b", ty.f32(), {MemberAlign(4)})},
-            {StructBlock()});
+             Member(Source{{34, 56}}, "b", ty.f32(), {MemberAlign(4)})});

  Global(Source{{78, 90}}, "a", ty.type_name("S"), ast::StorageClass::kStorage,
         GroupAndBinding(0, 0));
@@ -83,7 +79,6 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
  //   scalar : i32;
  // };
  //
-  // [[block]]
  // struct Outer {
  //   scalar : f32;
  //   inner : Inner;
@@ -98,8 +93,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
            {
                Member("scalar", ty.f32()),
                Member(Source{{56, 78}}, "inner", ty.type_name("Inner")),
-            },
-            {StructBlock()});
+            });

  Global(Source{{78, 90}}, "a", ty.type_name("Outer"),
         ast::StorageClass::kUniform, GroupAndBinding(0, 0));
@@ -126,7 +120,6 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
  //   scalar : i32;
  // };
  //
-  // [[block]]
  // struct Outer {
  //   scalar : f32;
  //   @align(16) inner : Inner;
@@ -142,8 +135,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
                Member("scalar", ty.f32()),
                Member(Source{{56, 78}}, "inner", ty.type_name("Inner"),
                       {MemberAlign(16)}),
-            },
-            {StructBlock()});
+            });

  Global(Source{{78, 90}}, "a", ty.type_name("Outer"),
         ast::StorageClass::kUniform, GroupAndBinding(0, 0));
@@ -156,7 +148,6 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
       UniformBuffer_UnalignedMember_Array) {
  // type Inner = @stride(16) array<f32, 10>;
  //
-  // [[block]]
  // struct Outer {
  //   scalar : f32;
  //   inner : Inner;
@@ -170,8 +161,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
            {
                Member("scalar", ty.f32()),
                Member(Source{{56, 78}}, "inner", ty.type_name("Inner")),
-            },
-            {StructBlock()});
+            });

  Global(Source{{78, 90}}, "a", ty.type_name("Outer"),
         ast::StorageClass::kUniform, GroupAndBinding(0, 0));
@@ -192,7 +182,6 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
       UniformBuffer_UnalignedMember_Array_SuggestedFix) {
  // type Inner = @stride(16) array<f32, 10>;
  //
-  // [[block]]
  // struct Outer {
  //   scalar : f32;
  //   @align(16) inner : Inner;
@@ -207,8 +196,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
                Member("scalar", ty.f32()),
                Member(Source{{34, 56}}, "inner", ty.type_name("Inner"),
                       {MemberAlign(16)}),
-            },
-            {StructBlock()});
+            });

  Global(Source{{78, 90}}, "a", ty.type_name("Outer"),
         ast::StorageClass::kUniform, GroupAndBinding(0, 0));
@@ -224,7 +212,6 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
  //   @align(1) @size(5) scalar : i32;
  // };
  //
-  // [[block]]
  // struct Outer {
  //   inner : Inner;
  //   scalar : i32;
@@ -240,8 +227,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
            {
                Member(Source{{56, 78}}, "inner", ty.type_name("Inner")),
                Member(Source{{78, 90}}, "scalar", ty.i32()),
-            },
-            {StructBlock()});
+            });

  Global(Source{{22, 24}}, "a", ty.type_name("Outer"),
         ast::StorageClass::kUniform, GroupAndBinding(0, 0));
@@ -273,7 +259,6 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
  //   @align(1) @size(5) scalar : i32;
  // };
  //
-  // [[block]]
  // struct Outer {
  //   inner : Inner;
  //   scalar : i32;
@@ -294,8 +279,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
            {
                Member(Source{{56, 78}}, "inner", ty.type_name("Inner")),
                Member(Source{{78, 90}}, "scalar", ty.i32()),
-            },
-            {StructBlock()});
+            });

  Global(Source{{22, 24}}, "a", ty.type_name("Outer"),
         ast::StorageClass::kUniform, GroupAndBinding(0, 0));
@@ -326,7 +310,6 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
  //   @align(1) @size(5) scalar : i32;
  // };
  //
-  // [[block]]
  // struct Outer {
  //   @align(16) inner : Inner;
  //   scalar : i32;
@@ -342,8 +325,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
            {
                Member(Source{{56, 78}}, "inner", ty.type_name("Inner")),
                Member(Source{{78, 90}}, "scalar", ty.i32(), {MemberAlign(16)}),
-            },
-            {StructBlock()});
+            });

  Global(Source{{22, 34}}, "a", ty.type_name("Outer"),
         ast::StorageClass::kUniform, GroupAndBinding(0, 0));
@@ -355,7 +337,6 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
 // size is 12. 's' should be at offset 12, which is okay here.
 TEST_F(ResolverStorageClassLayoutValidationTest,
       UniformBuffer_Vec3MemberOffset_NoFail) {
-  // [[block]]
  // struct ScalarPackedAtEndOfVec3 {
  //     v : vec3<f32>;
  //     s : f32;
@@ -363,12 +344,10 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
  // @group(0) @binding(0)
  // var<uniform> a : ScalarPackedAtEndOfVec3;

-  Structure("ScalarPackedAtEndOfVec3",
-            {
-                Member("v", ty.vec3(ty.f32())),
-                Member("s", ty.f32()),
-            },
-            {StructBlock()});
+  Structure("ScalarPackedAtEndOfVec3", {
+                                           Member("v", ty.vec3(ty.f32())),
+                                           Member("s", ty.f32()),
+                                       });

  Global(Source{{78, 90}}, "a", ty.type_name("ScalarPackedAtEndOfVec3"),
         ast::StorageClass::kUniform, GroupAndBinding(0, 0));
@@ -381,7 +360,6 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
       UniformBuffer_InvalidArrayStride_Scalar) {
  // type Inner = array<f32, 10>;
  //
-  // [[block]]
  // struct Outer {
  //   inner : Inner;
  //   scalar : i32;
@@ -396,8 +374,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
            {
                Member("inner", ty.type_name(Source{{34, 56}}, "Inner")),
                Member("scalar", ty.i32()),
-            },
-            {StructBlock()});
+            });

  Global(Source{{78, 90}}, "a", ty.type_name("Outer"),
         ast::StorageClass::kUniform, GroupAndBinding(0, 0));
@@ -418,7 +395,6 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
       UniformBuffer_InvalidArrayStride_Vector) {
  // type Inner = array<vec2<f32>, 10>;
  //
-  // [[block]]
  // struct Outer {
  //   inner : Inner;
  //   scalar : i32;
@@ -433,8 +409,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
            {
                Member("inner", ty.type_name(Source{{34, 56}}, "Inner")),
                Member("scalar", ty.i32()),
-            },
-            {StructBlock()});
+            });

  Global(Source{{78, 90}}, "a", ty.type_name("Outer"),
         ast::StorageClass::kUniform, GroupAndBinding(0, 0));
@@ -460,7 +435,6 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
  // }
  // type Inner = array<ArrayElem, 10>;
  //
-  // [[block]]
  // struct Outer {
  //   inner : Inner;
  //   scalar : i32;
@@ -479,8 +453,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
            {
                Member("inner", ty.type_name(Source{{34, 56}}, "Inner")),
                Member("scalar", ty.i32()),
-            },
-            {StructBlock()});
+            });

  Global(Source{{78, 90}}, "a", ty.type_name("Outer"),
         ast::StorageClass::kUniform, GroupAndBinding(0, 0));
@@ -523,8 +496,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
      Source{{12, 34}}, "Outer",
      {
          Member("inner", ty.array(Source{{34, 56}}, ty.array(ty.f32(), 4), 4)),
-      },
-      {StructBlock()});
+      });

  Global(Source{{78, 90}}, "a", ty.type_name("Outer"),
         ast::StorageClass::kUniform, GroupAndBinding(0, 0));
@@ -544,7 +516,6 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
       UniformBuffer_InvalidArrayStride_SuggestedFix) {
  // type Inner = @stride(16) array<f32, 10>;
  //
-  // [[block]]
  // struct Outer {
  //   inner : Inner;
  //   scalar : i32;
@@ -559,8 +530,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
            {
                Member("inner", ty.type_name(Source{{34, 56}}, "Inner")),
                Member("scalar", ty.i32()),
-            },
-            {StructBlock()});
+            });

  Global(Source{{78, 90}}, "a", ty.type_name("Outer"),
         ast::StorageClass::kUniform, GroupAndBinding(0, 0));
--- a/src/tint/resolver/storage_class_validation_test.cc
+++ b/src/tint/resolver/storage_class_validation_test.cc
@@ -15,7 +15,6 @@
 #include "src/tint/resolver/resolver.h"

 #include "gmock/gmock.h"
-#include "src/tint/ast/struct_block_attribute.h"
 #include "src/tint/resolver/resolver_test_helper.h"
 #include "src/tint/sem/struct.h"

@@ -57,7 +56,7 @@ TEST_F(ResolverStorageClassValidationTest, Private_RuntimeArray) {
 }

 TEST_F(ResolverStorageClassValidationTest, Private_RuntimeArrayInStruct) {
-  auto* s = Structure("S", {Member("m", ty.array(ty.i32()))}, {StructBlock()});
+  auto* s = Structure("S", {Member("m", ty.array(ty.i32()))});
  Global(Source{{12, 34}}, "v", ty.Of(s), ast::StorageClass::kPrivate);

  EXPECT_FALSE(r()->Resolve());
@@ -80,7 +79,7 @@ TEST_F(ResolverStorageClassValidationTest, Workgroup_RuntimeArray) {
 }

 TEST_F(ResolverStorageClassValidationTest, Workgroup_RuntimeArrayInStruct) {
-  auto* s = Structure("S", {Member("m", ty.array(ty.i32()))}, {StructBlock()});
+  auto* s = Structure("S", {Member("m", ty.array(ty.i32()))});
  Global(Source{{12, 34}}, "v", ty.Of(s), ast::StorageClass::kWorkgroup);

  EXPECT_FALSE(r()->Resolve());
@@ -192,10 +191,9 @@ TEST_F(ResolverStorageClassValidationTest, NotStorage_AccessMode) {
 }

 TEST_F(ResolverStorageClassValidationTest, StorageBufferNoError_Basic) {
-  // [[block]] struct S { x : i32 };
+  // struct S { x : i32 };
  // var<storage, read> g : S;
-  auto* s = Structure("S", {Member(Source{{12, 34}}, "x", ty.i32())},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member(Source{{12, 34}}, "x", ty.i32())});
  Global(Source{{56, 78}}, "g", ty.Of(s), ast::StorageClass::kStorage,
         ast::Access::kRead,
         ast::AttributeList{
@@ -207,11 +205,10 @@ TEST_F(ResolverStorageClassValidationTest, StorageBufferNoError_Basic) {
 }

 TEST_F(ResolverStorageClassValidationTest, StorageBufferNoError_Aliases) {
-  // [[block]] struct S { x : i32 };
+  // struct S { x : i32 };
  // type a1 = S;
  // var<storage, read> g : a1;
-  auto* s = Structure("S", {Member(Source{{12, 34}}, "x", ty.i32())},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member(Source{{12, 34}}, "x", ty.i32())});
  auto* a1 = Alias("a1", ty.Of(s));
  auto* a2 = Alias("a2", ty.Of(a1));
  Global(Source{{56, 78}}, "g", ty.Of(a2), ast::StorageClass::kStorage,
@@ -225,11 +222,10 @@ TEST_F(ResolverStorageClassValidationTest, StorageBufferNoError_Aliases) {
 }

 TEST_F(ResolverStorageClassValidationTest, UniformBuffer_Struct_Runtime) {
-  // [[block]] struct S { m:  array<f32>; };
+  // struct S { m:  array<f32>; };
  // @group(0) @binding(0) var<uniform, > svar : S;

-  auto* s = Structure(Source{{12, 34}}, "S", {Member("m", ty.array<i32>())},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure(Source{{12, 34}}, "S", {Member("m", ty.array<i32>())});

  Global(Source{{56, 78}}, "svar", ty.Of(s), ast::StorageClass::kUniform,
         ast::AttributeList{
@@ -336,10 +332,9 @@ TEST_F(ResolverStorageClassValidationTest, UniformBufferBoolAlias) {
 }

 TEST_F(ResolverStorageClassValidationTest, UniformBufferNoError_Basic) {
-  // [[block]] struct S { x : i32 };
+  // struct S { x : i32 };
  // var<uniform> g :  S;
-  auto* s = Structure("S", {Member(Source{{12, 34}}, "x", ty.i32())},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member(Source{{12, 34}}, "x", ty.i32())});
  Global(Source{{56, 78}}, "g", ty.Of(s), ast::StorageClass::kUniform,
         ast::AttributeList{
             create<ast::BindingAttribute>(0),
@@ -350,11 +345,10 @@ TEST_F(ResolverStorageClassValidationTest, UniformBufferNoError_Basic) {
 }

 TEST_F(ResolverStorageClassValidationTest, UniformBufferNoError_Aliases) {
-  // [[block]] struct S { x : i32 };
+  // struct S { x : i32 };
  // type a1 = S;
  // var<uniform> g : a1;
-  auto* s = Structure("S", {Member(Source{{12, 34}}, "x", ty.i32())},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member(Source{{12, 34}}, "x", ty.i32())});
  auto* a1 = Alias("a1", ty.Of(s));
  Global(Source{{56, 78}}, "g", ty.Of(a1), ast::StorageClass::kUniform,
         ast::AttributeList{
--- a/src/tint/resolver/struct_layout_test.cc
+++ b/src/tint/resolver/struct_layout_test.cc
@@ -15,7 +15,6 @@
 #include "src/tint/resolver/resolver.h"

 #include "gmock/gmock.h"
-#include "src/tint/ast/struct_block_attribute.h"
 #include "src/tint/resolver/resolver_test_helper.h"
 #include "src/tint/sem/struct.h"

@@ -129,11 +128,9 @@ TEST_F(ResolverStructLayoutTest, ExplicitStrideArrayStaticSize) {
 }

 TEST_F(ResolverStructLayoutTest, ImplicitStrideArrayRuntimeSized) {
-  auto* s = Structure("S",
-                      {
-                          Member("c", ty.array<f32>()),
-                      },
-                      ast::AttributeList{create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {
+                               Member("c", ty.array<f32>()),
+                           });

  ASSERT_TRUE(r()->Resolve()) << r()->error();

@@ -149,11 +146,9 @@ TEST_F(ResolverStructLayoutTest, ImplicitStrideArrayRuntimeSized) {
 }

 TEST_F(ResolverStructLayoutTest, ExplicitStrideArrayRuntimeSized) {
-  auto* s = Structure("S",
-                      {
-                          Member("c", ty.array<f32>(/*stride*/ 32)),
-                      },
-                      ast::AttributeList{create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {
+                               Member("c", ty.array<f32>(/*stride*/ 32)),
+                           });

  ASSERT_TRUE(r()->Resolve()) << r()->error();

--- a/src/tint/resolver/struct_storage_class_use_test.cc
+++ b/src/tint/resolver/struct_storage_class_use_test.cc
@@ -15,7 +15,6 @@
 #include "src/tint/resolver/resolver.h"

 #include "gmock/gmock.h"
-#include "src/tint/ast/struct_block_attribute.h"
 #include "src/tint/resolver/resolver_test_helper.h"
 #include "src/tint/sem/struct.h"

@@ -168,8 +167,7 @@ TEST_F(ResolverStorageClassUseTest, StructReachableViaLocalArray) {
 }

 TEST_F(ResolverStorageClassUseTest, StructMultipleStorageClassUses) {
-  auto* s = Structure("S", {Member("a", ty.f32())},
-                      {create<ast::StructBlockAttribute>()});
+  auto* s = Structure("S", {Member("a", ty.f32())});
  Global("x", ty.Of(s), ast::StorageClass::kUniform,
         ast::AttributeList{
             create<ast::BindingAttribute>(0),
--- a/src/tint/resolver/type_validation_test.cc
+++ b/src/tint/resolver/type_validation_test.cc
@@ -15,7 +15,6 @@
 #include "src/tint/ast/id_attribute.h"
 #include "src/tint/ast/return_statement.h"
 #include "src/tint/ast/stage_attribute.h"
-#include "src/tint/ast/struct_block_attribute.h"
 #include "src/tint/resolver/resolver.h"
 #include "src/tint/resolver/resolver_test_helper.h"
 #include "src/tint/sem/multisampled_texture_type.h"
@@ -481,18 +480,15 @@ TEST_F(ResolverTypeValidationTest, Struct_MemberOffset_TooBig) {
 }

 TEST_F(ResolverTypeValidationTest, RuntimeArrayIsLast_Pass) {
-  // [[block]]
  // struct Foo {
  //   vf: f32;
  //   rt: array<f32>;
  // };

-  Structure("Foo",
-            {
-                Member("vf", ty.f32()),
-                Member("rt", ty.array<f32>()),
-            },
-            {create<ast::StructBlockAttribute>()});
+  Structure("Foo", {
+                       Member("vf", ty.f32()),
+                       Member("rt", ty.array<f32>()),
+                   });

  WrapInFunction();

@@ -547,18 +543,15 @@ TEST_F(ResolverTypeValidationTest, RuntimeArrayInStructInStruct) {
 }

 TEST_F(ResolverTypeValidationTest, RuntimeArrayIsNotLast_Fail) {
-  // [[block]]
  // struct Foo {
  //   rt: array<f32>;
  //   vf: f32;
  // };

-  Structure("Foo",
-            {
-                Member(Source{{12, 34}}, "rt", ty.array<f32>()),
-                Member("vf", ty.f32()),
-            },
-            {create<ast::StructBlockAttribute>()});
+  Structure("Foo", {
+                       Member(Source{{12, 34}}, "rt", ty.array<f32>()),
+                       Member("vf", ty.f32()),
+                   });

  WrapInFunction();

@@ -639,7 +632,6 @@ TEST_F(ResolverTypeValidationTest, PtrToRuntimeArrayAsParameter_Fail) {
 }

 TEST_F(ResolverTypeValidationTest, AliasRuntimeArrayIsNotLast_Fail) {
-  // [[block]]
  // type RTArr = array<u32>;
  // struct s {
  //  b: RTArr;
@@ -647,12 +639,10 @@ TEST_F(ResolverTypeValidationTest, AliasRuntimeArrayIsNotLast_Fail) {
  //}

  auto* alias = Alias("RTArr", ty.array<u32>());
-  Structure("s",
-            {
-                Member(Source{{12, 34}}, "b", ty.Of(alias)),
-                Member("a", ty.u32()),
-            },
-            {create<ast::StructBlockAttribute>()});
+  Structure("s", {
+                     Member(Source{{12, 34}}, "b", ty.Of(alias)),
+                     Member("a", ty.u32()),
+                 });

  WrapInFunction();

@@ -663,7 +653,6 @@ TEST_F(ResolverTypeValidationTest, AliasRuntimeArrayIsNotLast_Fail) {
 }

 TEST_F(ResolverTypeValidationTest, AliasRuntimeArrayIsLast_Pass) {
-  // [[block]]
  // type RTArr = array<u32>;
  // struct s {
  //  a: u32;
@@ -671,12 +660,10 @@ TEST_F(ResolverTypeValidationTest, AliasRuntimeArrayIsLast_Pass) {
  //}

  auto* alias = Alias("RTArr", ty.array<u32>());
-  Structure("s",
-            {
-                Member("a", ty.u32()),
-                Member("b", ty.Of(alias)),
-            },
-            {create<ast::StructBlockAttribute>()});
+  Structure("s", {
+                     Member("a", ty.u32()),
+                     Member("b", ty.Of(alias)),
+                 });

  WrapInFunction();

--- a/src/tint/resolver/var_let_test.cc
+++ b/src/tint/resolver/var_let_test.cc
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-#include "src/tint/ast/struct_block_attribute.h"
 #include "src/tint/resolver/resolver.h"
 #include "src/tint/resolver/resolver_test_helper.h"
 #include "src/tint/sem/reference_type.h"
@@ -216,8 +215,7 @@ TEST_F(ResolverVarLetTest, LetDecl) {
 TEST_F(ResolverVarLetTest, DefaultVarStorageClass) {
  // https://gpuweb.github.io/gpuweb/wgsl/#storage-class

-  auto* buf = Structure("S", {Member("m", ty.i32())},
-                        {create<ast::StructBlockAttribute>()});
+  auto* buf = Structure("S", {Member("m", ty.i32())});
  auto* function = Var("f", ty.i32());
  auto* private_ = Global("p", ty.i32(), ast::StorageClass::kPrivate);
  auto* workgroup = Global("w", ty.i32(), ast::StorageClass::kWorkgroup);
@@ -264,8 +262,7 @@ TEST_F(ResolverVarLetTest, DefaultVarStorageClass) {
 TEST_F(ResolverVarLetTest, ExplicitVarStorageClass) {
  // https://gpuweb.github.io/gpuweb/wgsl/#storage-class

-  auto* buf = Structure("S", {Member("m", ty.i32())},
-                        {create<ast::StructBlockAttribute>()});
+  auto* buf = Structure("S", {Member("m", ty.i32())});
  auto* storage = Global("sb", ty.Of(buf), ast::StorageClass::kStorage,
                         ast::Access::kReadWrite,
                         ast::AttributeList{
@@ -285,7 +282,7 @@ TEST_F(ResolverVarLetTest, LetInheritsAccessFromOriginatingVariable) {
  // struct Inner {
  //    arr: array<i32, 4>;
  // }
-  // [[block]] struct S {
+  // struct S {
  //    inner: Inner;
  // }
  // @group(0) @binding(0) var<storage, read_write> s : S;
@@ -293,8 +290,7 @@ TEST_F(ResolverVarLetTest, LetInheritsAccessFromOriginatingVariable) {
  //   let p = &s.inner.arr[2];
  // }
  auto* inner = Structure("Inner", {Member("arr", ty.array<i32, 4>())});
-  auto* buf = Structure("S", {Member("inner", ty.Of(inner))},
-                        {create<ast::StructBlockAttribute>()});
+  auto* buf = Structure("S", {Member("inner", ty.Of(inner))});
  auto* storage = Global("s", ty.Of(buf), ast::StorageClass::kStorage,
                         ast::Access::kReadWrite,
                         ast::AttributeList{
--- a/src/tint/resolver/var_let_validation_test.cc
+++ b/src/tint/resolver/var_let_validation_test.cc
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-#include "src/tint/ast/struct_block_attribute.h"
 #include "src/tint/resolver/resolver.h"
 #include "src/tint/resolver/resolver_test_helper.h"

@@ -220,7 +219,7 @@ TEST_F(ResolverVarLetValidationTest, InferredPtrStorageAccessMismatch) {
  // struct Inner {
  //    arr: array<i32, 4>;
  // }
-  // [[block]] struct S {
+  // struct S {
  //    inner: Inner;
  // }
  // @group(0) @binding(0) var<storage> s : S;
@@ -228,8 +227,7 @@ TEST_F(ResolverVarLetValidationTest, InferredPtrStorageAccessMismatch) {
  //   let p : pointer<storage, i32, read_write> = &s.inner.arr[2];
  // }
  auto* inner = Structure("Inner", {Member("arr", ty.array<i32, 4>())});
-  auto* buf = Structure("S", {Member("inner", ty.Of(inner))},
-                        {create<ast::StructBlockAttribute>()});
+  auto* buf = Structure("S", {Member("inner", ty.Of(inner))});
  auto* storage = Global("s", ty.Of(buf), ast::StorageClass::kStorage,
                         ast::AttributeList{
                             create<ast::BindingAttribute>(0),
@@ -262,8 +260,7 @@ TEST_F(ResolverVarLetValidationTest, NonConstructibleType_Atomic) {
 }

 TEST_F(ResolverVarLetValidationTest, NonConstructibleType_RuntimeArray) {
-  auto* s = Structure("S", {Member(Source{{56, 78}}, "m", ty.array(ty.i32()))},
-                      {StructBlock()});
+  auto* s = Structure("S", {Member(Source{{56, 78}}, "m", ty.array(ty.i32()))});
  auto* v = Var(Source{{12, 34}}, "v", ty.Of(s));
  WrapInFunction(v);