Converting to Atomic-Free Plain to Constructible

The language in the spec and details of the restriction have changed,
https://github.com/gpuweb/gpuweb/pull/1876.

BUG=tint:928

Change-Id: Ib9f4d5e785bb5e04d63e880fe8984a8683d759f0
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/57260
Commit-Queue: Ryan Harrison <rharrison@chromium.org>
Auto-Submit: Ryan Harrison <rharrison@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: James Price <jrprice@google.com>

src/ast/disable_validation_decoration.cc

@@ -38,8 +38,8 @@ std::string DisableValidationDecoration::InternalName() const {
       return "disable_validation__ignore_storage_class";
     case DisabledValidation::kEntryPointParameter:
       return "disable_validation__entry_point_parameter";
-    case DisabledValidation::kIgnoreAtomicFunctionParameter:
+    case DisabledValidation::kIgnoreConstructibleFunctionParameter:
-      return "disable_validation__ignore_atomic_function_parameter";
+      return "disable_validation__ignore_constructible_function_parameter";
   }
   return "<invalid>";
 }

src/ast/disable_validation_decoration.h

@@ -38,8 +38,8 @@ enum class DisabledValidation {
   /// check for entry IO decorations.
   kEntryPointParameter,
   /// When applied to a function parameter, the validator will not
-  /// check if parameter type is atomic-free
+  /// check if parameter type is constructible
-  kIgnoreAtomicFunctionParameter,
+  kIgnoreConstructibleFunctionParameter,
 };
 
 /// An internal decoration used to tell the validator to ignore specific

src/resolver/entry_point_validation_test.cc

@@ -230,10 +230,8 @@ TEST_F(ResolverEntryPointValidationTest, ReturnType_Struct_RuntimeArray) {
        {Stage(ast::PipelineStage::kFragment)});
 
   EXPECT_FALSE(r()->Resolve());
-  EXPECT_EQ(
+  EXPECT_EQ(r()->error(),
-      r()->error(),
+            R"(error: function return type must be a constructible type)");
-      R"(13:43 error: entry point IO types cannot contain runtime sized arrays
-12:34 note: while analysing entry point main)");
 }
 
 TEST_F(ResolverEntryPointValidationTest, ReturnType_Struct_DuplicateBuiltins) {
@@ -446,8 +444,7 @@ TEST_F(ResolverEntryPointValidationTest, Parameter_Struct_RuntimeArray) {
   EXPECT_FALSE(r()->Resolve());
   EXPECT_EQ(
       r()->error(),
-      R"(13:43 error: entry point IO types cannot contain runtime sized arrays
+      R"(error: store type of function parameter must be a constructible type)");
-12:34 note: while analysing entry point main)");
 }
 
 TEST_F(ResolverEntryPointValidationTest, Parameter_DuplicateBuiltins) {

src/resolver/function_validation_test.cc

@@ -479,49 +479,54 @@ TEST_F(ResolverFunctionValidationTest, WorkgroupSize_NonConst) {
             "i32 module-scope constant");
 }
 
-TEST_F(ResolverFunctionValidationTest, ReturnIsAtomicFreePlain_NonPlain) {
+TEST_F(ResolverFunctionValidationTest, ReturnIsConstructible_NonPlain) {
   auto* ret_type =
       ty.pointer(Source{{12, 34}}, ty.i32(), ast::StorageClass::kFunction);
   Func("f", {}, ret_type, {});
 
   EXPECT_FALSE(r()->Resolve());
-  EXPECT_EQ(
+  EXPECT_EQ(r()->error(),
-      r()->error(),
+            "12:34 error: function return type must be a constructible type");
-      "12:34 error: function return type must be an atomic-free plain type");
 }
 
-TEST_F(ResolverFunctionValidationTest, ReturnIsAtomicFreePlain_AtomicInt) {
+TEST_F(ResolverFunctionValidationTest, ReturnIsConstructible_AtomicInt) {
   auto* ret_type = ty.atomic(Source{{12, 34}}, ty.i32());
   Func("f", {}, ret_type, {});
 
   EXPECT_FALSE(r()->Resolve());
-  EXPECT_EQ(
+  EXPECT_EQ(r()->error(),
-      r()->error(),
+            "12:34 error: function return type must be a constructible type");
-      "12:34 error: function return type must be an atomic-free plain type");
 }
 
-TEST_F(ResolverFunctionValidationTest, ReturnIsAtomicFreePlain_ArrayOfAtomic) {
+TEST_F(ResolverFunctionValidationTest, ReturnIsConstructible_ArrayOfAtomic) {
-  auto* ret_type = ty.array(Source{{12, 34}}, ty.atomic(ty.i32()));
+  auto* ret_type = ty.array(Source{{12, 34}}, ty.atomic(ty.i32()), 10);
   Func("f", {}, ret_type, {});
 
   EXPECT_FALSE(r()->Resolve());
-  EXPECT_EQ(
+  EXPECT_EQ(r()->error(),
-      r()->error(),
+            "12:34 error: function return type must be a constructible type");
-      "12:34 error: function return type must be an atomic-free plain type");
 }
 
-TEST_F(ResolverFunctionValidationTest, ReturnIsAtomicFreePlain_StructOfAtomic) {
+TEST_F(ResolverFunctionValidationTest, ReturnIsConstructible_StructOfAtomic) {
   Structure("S", {Member("m", ty.atomic(ty.i32()))});
   auto* ret_type = ty.type_name(Source{{12, 34}}, "S");
   Func("f", {}, ret_type, {});
 
   EXPECT_FALSE(r()->Resolve());
-  EXPECT_EQ(
+  EXPECT_EQ(r()->error(),
-      r()->error(),
+            "12:34 error: function return type must be a constructible type");
-      "12:34 error: function return type must be an atomic-free plain type");
 }
 
-TEST_F(ResolverFunctionValidationTest, ParameterSotreType_NonAtomicFree) {
+TEST_F(ResolverFunctionValidationTest, ReturnIsConstructible_RuntimeArray) {
+  auto* ret_type = ty.array(Source{{12, 34}}, ty.i32(), 0);
+  Func("f", {}, ret_type, {});
+
+  EXPECT_FALSE(r()->Resolve());
+  EXPECT_EQ(r()->error(),
+            "12:34 error: function return type must be a constructible type");
+}
+
+TEST_F(ResolverFunctionValidationTest, ParameterStoreType_NonAtomicFree) {
   Structure("S", {Member("m", ty.atomic(ty.i32()))});
   auto* ret_type = ty.type_name(Source{{12, 34}}, "S");
   auto* bar = Param(Source{{12, 34}}, "bar", ret_type);
@@ -529,8 +534,8 @@ TEST_F(ResolverFunctionValidationTest, ParameterSotreType_NonAtomicFree) {
 
   EXPECT_FALSE(r()->Resolve());
   EXPECT_EQ(r()->error(),
-            "12:34 error: store type of function parameter must be an "
+            "12:34 error: store type of function parameter must be a "
-            "atomic-free type");
+            "constructible type");
 }
 
 TEST_F(ResolverFunctionValidationTest, ParameterSotreType_AtomicFree) {

src/resolver/resolver.cc

@@ -193,8 +193,8 @@ bool Resolver::IsPlain(const sem::Type* type) const {
          type->Is<sem::Array>() || type->Is<sem::Struct>();
 }
 
-// https://gpuweb.github.io/gpuweb/wgsl/#atomic-free
+// https://gpuweb.github.io/gpuweb/wgsl/#constructible-types
-bool Resolver::IsAtomicFreePlain(const sem::Type* type) const {
+bool Resolver::IsConstructible(const sem::Type* type) const {
   if (type->Is<sem::Atomic>()) {
     return false;
   }
@@ -204,12 +204,16 @@ bool Resolver::IsAtomicFreePlain(const sem::Type* type) const {
   }
 
   if (auto* arr = type->As<sem::Array>()) {
-    return IsAtomicFreePlain(arr->ElemType());
+    if (arr->IsRuntimeSized()) {
+      return false;
+    }
+
+    return IsConstructible(arr->ElemType());
   }
 
   if (auto* str = type->As<sem::Struct>()) {
     for (auto* m : str->Members()) {
-      if (!IsAtomicFreePlain(m->Type())) {
+      if (!IsConstructible(m->Type())) {
         return false;
       }
     }
@@ -944,7 +948,8 @@ bool Resolver::ValidateFunctionParameter(const ast::Function* func,
                     ast::DisabledValidation::kEntryPointParameter) &&
                 IsValidationEnabled(
                     info->declaration->decorations(),
-                    ast::DisabledValidation::kIgnoreAtomicFunctionParameter))) {
+                    ast::DisabledValidation::
+                        kIgnoreConstructibleFunctionParameter))) {
       AddError("decoration is not valid for function parameters",
                deco->source());
       return false;
@@ -965,11 +970,11 @@ bool Resolver::ValidateFunctionParameter(const ast::Function* func,
   }
 
   if (IsPlain(info->type)) {
-    if (!IsAtomicFreePlain(info->type) &&
+    if (!IsConstructible(info->type) &&
         IsValidationEnabled(
             info->declaration->decorations(),
-            ast::DisabledValidation::kIgnoreAtomicFunctionParameter)) {
+            ast::DisabledValidation::kIgnoreConstructibleFunctionParameter)) {
-      AddError("store type of function parameter must be an atomic-free type",
+      AddError("store type of function parameter must be a constructible type",
                info->declaration->source());
       return false;
     }
@@ -1091,8 +1096,8 @@ bool Resolver::ValidateFunction(const ast::Function* func,
   }
 
   if (!info->return_type->Is<sem::Void>()) {
-    if (!IsAtomicFreePlain(info->return_type)) {
+    if (!IsConstructible(info->return_type)) {
-      AddError("function return type must be an atomic-free plain type",
+      AddError("function return type must be a constructible type",
                func->return_type()->source());
       return false;
     }

src/resolver/resolver.h

@@ -81,8 +81,8 @@ class Resolver {
   bool IsPlain(const sem::Type* type) const;
 
   /// @param type the given type
-  /// @returns true if the given type is a atomic-free plain type
+  /// @returns true if the given type is a constructible type
-  bool IsAtomicFreePlain(const sem::Type* type) const;
+  bool IsConstructible(const sem::Type* type) const;
 
   /// @param type the given type
   /// @returns true if the given type is storable

src/transform/calculate_array_length.cc

@@ -18,6 +18,7 @@
 #include <utility>
 
 #include "src/ast/call_statement.h"
+#include "src/ast/disable_validation_decoration.h"
 #include "src/program_builder.h"
 #include "src/sem/block_statement.h"
 #include "src/sem/call.h"
@@ -82,6 +83,10 @@ void CalculateArrayLength::Run(CloneContext& ctx, const DataMap&, DataMap&) {
       auto name = ctx.dst->Sym();
       auto* buffer_typename =
           ctx.dst->ty.type_name(ctx.Clone(buffer_type->Declaration()->name()));
+      auto* disable_validation =
+          ctx.dst->ASTNodes().Create<ast::DisableValidationDecoration>(
+              ctx.dst->ID(),
+              ast::DisabledValidation::kIgnoreConstructibleFunctionParameter);
       auto* func = ctx.dst->create<ast::Function>(
           name,
           ast::VariableList{
@@ -90,7 +95,7 @@ void CalculateArrayLength::Run(CloneContext& ctx, const DataMap&, DataMap&) {
               ctx.dst->create<ast::Variable>(
                   ctx.dst->Sym("buffer"), ast::StorageClass::kStorage,
                   ast::Access::kUndefined, buffer_typename, true, nullptr,
-                  ast::DecorationList{}),
+                  ast::DecorationList{disable_validation}),
               ctx.dst->Param("result",
                              ctx.dst->ty.pointer(ctx.dst->ty.u32(),
                                                  ast::StorageClass::kFunction)),

src/transform/calculate_array_length_test.cc

@@ -46,7 +46,7 @@ struct SB {
 };
 
 [[internal(intrinsic_buffer_size)]]
-fn tint_symbol(buffer : SB, result : ptr<function, u32>)
+fn tint_symbol([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, result : ptr<function, u32>)
 
 [[group(0), binding(0)]] var<storage, read> sb : SB;
 
@@ -90,7 +90,7 @@ struct SB {
 };
 
 [[internal(intrinsic_buffer_size)]]
-fn tint_symbol(buffer : SB, result : ptr<function, u32>)
+fn tint_symbol([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, result : ptr<function, u32>)
 
 [[group(0), binding(0)]] var<storage, read> sb : SB;
 
@@ -136,7 +136,7 @@ struct SB {
 };
 
 [[internal(intrinsic_buffer_size)]]
-fn tint_symbol(buffer : SB, result : ptr<function, u32>)
+fn tint_symbol([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, result : ptr<function, u32>)
 
 [[group(0), binding(0)]] var<storage, read> sb : SB;
 
@@ -184,7 +184,7 @@ struct SB {
 };
 
 [[internal(intrinsic_buffer_size)]]
-fn tint_symbol(buffer : SB, result : ptr<function, u32>)
+fn tint_symbol([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, result : ptr<function, u32>)
 
 [[group(0), binding(0)]] var<storage, read> sb : SB;
 
@@ -245,7 +245,7 @@ struct SB1 {
 };
 
 [[internal(intrinsic_buffer_size)]]
-fn tint_symbol(buffer : SB1, result : ptr<function, u32>)
+fn tint_symbol([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB1, result : ptr<function, u32>)
 
 [[block]]
 struct SB2 {
@@ -254,7 +254,7 @@ struct SB2 {
 };
 
 [[internal(intrinsic_buffer_size)]]
-fn tint_symbol_3(buffer : SB2, result : ptr<function, u32>)
+fn tint_symbol_3([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB2, result : ptr<function, u32>)
 
 [[group(0), binding(0)]] var<storage, read> sb1 : SB1;
 

src/transform/decompose_memory_access.cc

@@ -477,8 +477,8 @@ struct DecomposeMemoryAccess::State {
           auto* buf_ast_ty = CreateASTTypeFor(&ctx, buf_ty);
           auto* disable_validation =
               ctx.dst->ASTNodes().Create<ast::DisableValidationDecoration>(
-                  ctx.dst->ID(),
+                  ctx.dst->ID(), ast::DisabledValidation::
-                  ast::DisabledValidation::kIgnoreAtomicFunctionParameter);
+                                     kIgnoreConstructibleFunctionParameter);
 
           ast::VariableList params = {
               // Note: The buffer parameter requires the StorageClass in
@@ -566,8 +566,8 @@ struct DecomposeMemoryAccess::State {
           auto* el_ast_ty = CreateASTTypeFor(&ctx, el_ty);
           auto* disable_validation =
               ctx.dst->ASTNodes().Create<ast::DisableValidationDecoration>(
-                  ctx.dst->ID(),
+                  ctx.dst->ID(), ast::DisabledValidation::
-                  ast::DisabledValidation::kIgnoreAtomicFunctionParameter);
+                                     kIgnoreConstructibleFunctionParameter);
           ast::VariableList params{
               // Note: The buffer parameter requires the StorageClass in
               // order for HLSL to emit this as a ByteAddressBuffer.
@@ -662,7 +662,7 @@ struct DecomposeMemoryAccess::State {
       auto* disable_validation =
           ctx.dst->ASTNodes().Create<ast::DisableValidationDecoration>(
               ctx.dst->ID(),
-              ast::DisabledValidation::kIgnoreAtomicFunctionParameter);
+              ast::DisabledValidation::kIgnoreConstructibleFunctionParameter);
       // The first parameter to all WGSL atomics is the expression to the
       // atomic. This is replaced with two parameters: the buffer and offset.
 

src/transform/decompose_memory_access_test.cc

@@ -107,78 +107,78 @@ struct SB {
 };
 
 [[internal(intrinsic_load_storage_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> i32
+fn tint_symbol([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> i32
 
 [[internal(intrinsic_load_storage_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_1([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> u32
+fn tint_symbol_1([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> u32
 
 [[internal(intrinsic_load_storage_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_2([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> f32
+fn tint_symbol_2([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> f32
 
 [[internal(intrinsic_load_storage_vec2_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_3([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec2<i32>
+fn tint_symbol_3([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec2<i32>
 
 [[internal(intrinsic_load_storage_vec2_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_4([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec2<u32>
+fn tint_symbol_4([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec2<u32>
 
 [[internal(intrinsic_load_storage_vec2_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_5([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec2<f32>
+fn tint_symbol_5([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec2<f32>
 
 [[internal(intrinsic_load_storage_vec3_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_6([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec3<i32>
+fn tint_symbol_6([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec3<i32>
 
 [[internal(intrinsic_load_storage_vec3_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_7([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec3<u32>
+fn tint_symbol_7([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec3<u32>
 
 [[internal(intrinsic_load_storage_vec3_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_8([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec3<f32>
+fn tint_symbol_8([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec3<f32>
 
 [[internal(intrinsic_load_storage_vec4_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_9([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec4<i32>
+fn tint_symbol_9([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec4<i32>
 
 [[internal(intrinsic_load_storage_vec4_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_10([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec4<u32>
+fn tint_symbol_10([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec4<u32>
 
 [[internal(intrinsic_load_storage_vec4_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_11([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec4<f32>
+fn tint_symbol_11([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec4<f32>
 
-fn tint_symbol_12([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat2x2<f32> {
+fn tint_symbol_12([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat2x2<f32> {
   return mat2x2<f32>(tint_symbol_5(buffer, (offset + 0u)), tint_symbol_5(buffer, (offset + 8u)));
 }
 
-fn tint_symbol_13([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat2x3<f32> {
+fn tint_symbol_13([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat2x3<f32> {
   return mat2x3<f32>(tint_symbol_8(buffer, (offset + 0u)), tint_symbol_8(buffer, (offset + 16u)));
 }
 
-fn tint_symbol_14([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat2x4<f32> {
+fn tint_symbol_14([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat2x4<f32> {
   return mat2x4<f32>(tint_symbol_11(buffer, (offset + 0u)), tint_symbol_11(buffer, (offset + 16u)));
 }
 
-fn tint_symbol_15([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat3x2<f32> {
+fn tint_symbol_15([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat3x2<f32> {
   return mat3x2<f32>(tint_symbol_5(buffer, (offset + 0u)), tint_symbol_5(buffer, (offset + 8u)), tint_symbol_5(buffer, (offset + 16u)));
 }
 
-fn tint_symbol_16([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat3x3<f32> {
+fn tint_symbol_16([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat3x3<f32> {
   return mat3x3<f32>(tint_symbol_8(buffer, (offset + 0u)), tint_symbol_8(buffer, (offset + 16u)), tint_symbol_8(buffer, (offset + 32u)));
 }
 
-fn tint_symbol_17([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat3x4<f32> {
+fn tint_symbol_17([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat3x4<f32> {
   return mat3x4<f32>(tint_symbol_11(buffer, (offset + 0u)), tint_symbol_11(buffer, (offset + 16u)), tint_symbol_11(buffer, (offset + 32u)));
 }
 
-fn tint_symbol_18([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat4x2<f32> {
+fn tint_symbol_18([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat4x2<f32> {
   return mat4x2<f32>(tint_symbol_5(buffer, (offset + 0u)), tint_symbol_5(buffer, (offset + 8u)), tint_symbol_5(buffer, (offset + 16u)), tint_symbol_5(buffer, (offset + 24u)));
 }
 
-fn tint_symbol_19([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat4x3<f32> {
+fn tint_symbol_19([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat4x3<f32> {
   return mat4x3<f32>(tint_symbol_8(buffer, (offset + 0u)), tint_symbol_8(buffer, (offset + 16u)), tint_symbol_8(buffer, (offset + 32u)), tint_symbol_8(buffer, (offset + 48u)));
 }
 
-fn tint_symbol_20([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat4x4<f32> {
+fn tint_symbol_20([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat4x4<f32> {
   return mat4x4<f32>(tint_symbol_11(buffer, (offset + 0u)), tint_symbol_11(buffer, (offset + 16u)), tint_symbol_11(buffer, (offset + 32u)), tint_symbol_11(buffer, (offset + 48u)));
 }
 
-fn tint_symbol_21([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> array<vec3<f32>, 2> {
+fn tint_symbol_21([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> array<vec3<f32>, 2> {
   return array<vec3<f32>, 2>(tint_symbol_8(buffer, (offset + 0u)), tint_symbol_8(buffer, (offset + 16u)));
 }
 
@@ -301,78 +301,78 @@ struct UB {
 };
 
 [[internal(intrinsic_load_uniform_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> i32
+fn tint_symbol([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> i32
 
 [[internal(intrinsic_load_uniform_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_1([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> u32
+fn tint_symbol_1([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> u32
 
 [[internal(intrinsic_load_uniform_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_2([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> f32
+fn tint_symbol_2([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> f32
 
 [[internal(intrinsic_load_uniform_vec2_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_3([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> vec2<i32>
+fn tint_symbol_3([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> vec2<i32>
 
 [[internal(intrinsic_load_uniform_vec2_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_4([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> vec2<u32>
+fn tint_symbol_4([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> vec2<u32>
 
 [[internal(intrinsic_load_uniform_vec2_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_5([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> vec2<f32>
+fn tint_symbol_5([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> vec2<f32>
 
 [[internal(intrinsic_load_uniform_vec3_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_6([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> vec3<i32>
+fn tint_symbol_6([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> vec3<i32>
 
 [[internal(intrinsic_load_uniform_vec3_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_7([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> vec3<u32>
+fn tint_symbol_7([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> vec3<u32>
 
 [[internal(intrinsic_load_uniform_vec3_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_8([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> vec3<f32>
+fn tint_symbol_8([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> vec3<f32>
 
 [[internal(intrinsic_load_uniform_vec4_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_9([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> vec4<i32>
+fn tint_symbol_9([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> vec4<i32>
 
 [[internal(intrinsic_load_uniform_vec4_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_10([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> vec4<u32>
+fn tint_symbol_10([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> vec4<u32>
 
 [[internal(intrinsic_load_uniform_vec4_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_11([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> vec4<f32>
+fn tint_symbol_11([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> vec4<f32>
 
-fn tint_symbol_12([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> mat2x2<f32> {
+fn tint_symbol_12([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> mat2x2<f32> {
   return mat2x2<f32>(tint_symbol_5(buffer, (offset + 0u)), tint_symbol_5(buffer, (offset + 8u)));
 }
 
-fn tint_symbol_13([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> mat2x3<f32> {
+fn tint_symbol_13([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> mat2x3<f32> {
   return mat2x3<f32>(tint_symbol_8(buffer, (offset + 0u)), tint_symbol_8(buffer, (offset + 16u)));
 }
 
-fn tint_symbol_14([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> mat2x4<f32> {
+fn tint_symbol_14([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> mat2x4<f32> {
   return mat2x4<f32>(tint_symbol_11(buffer, (offset + 0u)), tint_symbol_11(buffer, (offset + 16u)));
 }
 
-fn tint_symbol_15([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> mat3x2<f32> {
+fn tint_symbol_15([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> mat3x2<f32> {
   return mat3x2<f32>(tint_symbol_5(buffer, (offset + 0u)), tint_symbol_5(buffer, (offset + 8u)), tint_symbol_5(buffer, (offset + 16u)));
 }
 
-fn tint_symbol_16([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> mat3x3<f32> {
+fn tint_symbol_16([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> mat3x3<f32> {
   return mat3x3<f32>(tint_symbol_8(buffer, (offset + 0u)), tint_symbol_8(buffer, (offset + 16u)), tint_symbol_8(buffer, (offset + 32u)));
 }
 
-fn tint_symbol_17([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> mat3x4<f32> {
+fn tint_symbol_17([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> mat3x4<f32> {
   return mat3x4<f32>(tint_symbol_11(buffer, (offset + 0u)), tint_symbol_11(buffer, (offset + 16u)), tint_symbol_11(buffer, (offset + 32u)));
 }
 
-fn tint_symbol_18([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> mat4x2<f32> {
+fn tint_symbol_18([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> mat4x2<f32> {
   return mat4x2<f32>(tint_symbol_5(buffer, (offset + 0u)), tint_symbol_5(buffer, (offset + 8u)), tint_symbol_5(buffer, (offset + 16u)), tint_symbol_5(buffer, (offset + 24u)));
 }
 
-fn tint_symbol_19([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> mat4x3<f32> {
+fn tint_symbol_19([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> mat4x3<f32> {
   return mat4x3<f32>(tint_symbol_8(buffer, (offset + 0u)), tint_symbol_8(buffer, (offset + 16u)), tint_symbol_8(buffer, (offset + 32u)), tint_symbol_8(buffer, (offset + 48u)));
 }
 
-fn tint_symbol_20([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> mat4x4<f32> {
+fn tint_symbol_20([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> mat4x4<f32> {
   return mat4x4<f32>(tint_symbol_11(buffer, (offset + 0u)), tint_symbol_11(buffer, (offset + 16u)), tint_symbol_11(buffer, (offset + 32u)), tint_symbol_11(buffer, (offset + 48u)));
 }
 
-fn tint_symbol_21([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : UB, offset : u32) -> array<vec3<f32>, 2> {
+fn tint_symbol_21([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : UB, offset : u32) -> array<vec3<f32>, 2> {
   return array<vec3<f32>, 2>(tint_symbol_8(buffer, (offset + 0u)), tint_symbol_8(buffer, (offset + 16u)));
 }
 
@@ -495,96 +495,96 @@ struct SB {
 };
 
 [[internal(intrinsic_store_storage_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : i32)
+fn tint_symbol([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : i32)
 
 [[internal(intrinsic_store_storage_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_1([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : u32)
+fn tint_symbol_1([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : u32)
 
 [[internal(intrinsic_store_storage_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_2([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : f32)
+fn tint_symbol_2([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : f32)
 
 [[internal(intrinsic_store_storage_vec2_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_3([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec2<i32>)
+fn tint_symbol_3([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec2<i32>)
 
 [[internal(intrinsic_store_storage_vec2_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_4([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec2<u32>)
+fn tint_symbol_4([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec2<u32>)
 
 [[internal(intrinsic_store_storage_vec2_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_5([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec2<f32>)
+fn tint_symbol_5([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec2<f32>)
 
 [[internal(intrinsic_store_storage_vec3_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_6([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec3<i32>)
+fn tint_symbol_6([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec3<i32>)
 
 [[internal(intrinsic_store_storage_vec3_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_7([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec3<u32>)
+fn tint_symbol_7([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec3<u32>)
 
 [[internal(intrinsic_store_storage_vec3_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_8([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec3<f32>)
+fn tint_symbol_8([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec3<f32>)
 
 [[internal(intrinsic_store_storage_vec4_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_9([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec4<i32>)
+fn tint_symbol_9([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec4<i32>)
 
 [[internal(intrinsic_store_storage_vec4_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_10([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec4<u32>)
+fn tint_symbol_10([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec4<u32>)
 
 [[internal(intrinsic_store_storage_vec4_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_11([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec4<f32>)
+fn tint_symbol_11([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec4<f32>)
 
-fn tint_symbol_12([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat2x2<f32>) {
+fn tint_symbol_12([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat2x2<f32>) {
   tint_symbol_5(buffer, (offset + 0u), value[0u]);
   tint_symbol_5(buffer, (offset + 8u), value[1u]);
 }
 
-fn tint_symbol_13([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat2x3<f32>) {
+fn tint_symbol_13([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat2x3<f32>) {
   tint_symbol_8(buffer, (offset + 0u), value[0u]);
   tint_symbol_8(buffer, (offset + 16u), value[1u]);
 }
 
-fn tint_symbol_14([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat2x4<f32>) {
+fn tint_symbol_14([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat2x4<f32>) {
   tint_symbol_11(buffer, (offset + 0u), value[0u]);
   tint_symbol_11(buffer, (offset + 16u), value[1u]);
 }
 
-fn tint_symbol_15([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat3x2<f32>) {
+fn tint_symbol_15([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat3x2<f32>) {
   tint_symbol_5(buffer, (offset + 0u), value[0u]);
   tint_symbol_5(buffer, (offset + 8u), value[1u]);
   tint_symbol_5(buffer, (offset + 16u), value[2u]);
 }
 
-fn tint_symbol_16([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat3x3<f32>) {
+fn tint_symbol_16([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat3x3<f32>) {
   tint_symbol_8(buffer, (offset + 0u), value[0u]);
   tint_symbol_8(buffer, (offset + 16u), value[1u]);
   tint_symbol_8(buffer, (offset + 32u), value[2u]);
 }
 
-fn tint_symbol_17([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat3x4<f32>) {
+fn tint_symbol_17([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat3x4<f32>) {
   tint_symbol_11(buffer, (offset + 0u), value[0u]);
   tint_symbol_11(buffer, (offset + 16u), value[1u]);
   tint_symbol_11(buffer, (offset + 32u), value[2u]);
 }
 
-fn tint_symbol_18([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat4x2<f32>) {
+fn tint_symbol_18([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat4x2<f32>) {
   tint_symbol_5(buffer, (offset + 0u), value[0u]);
   tint_symbol_5(buffer, (offset + 8u), value[1u]);
   tint_symbol_5(buffer, (offset + 16u), value[2u]);
   tint_symbol_5(buffer, (offset + 24u), value[3u]);
 }
 
-fn tint_symbol_19([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat4x3<f32>) {
+fn tint_symbol_19([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat4x3<f32>) {
   tint_symbol_8(buffer, (offset + 0u), value[0u]);
   tint_symbol_8(buffer, (offset + 16u), value[1u]);
   tint_symbol_8(buffer, (offset + 32u), value[2u]);
   tint_symbol_8(buffer, (offset + 48u), value[3u]);
 }
 
-fn tint_symbol_20([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat4x4<f32>) {
+fn tint_symbol_20([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat4x4<f32>) {
   tint_symbol_11(buffer, (offset + 0u), value[0u]);
   tint_symbol_11(buffer, (offset + 16u), value[1u]);
   tint_symbol_11(buffer, (offset + 32u), value[2u]);
   tint_symbol_11(buffer, (offset + 48u), value[3u]);
 }
 
-fn tint_symbol_21([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : array<vec3<f32>, 2>) {
+fn tint_symbol_21([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : array<vec3<f32>, 2>) {
   tint_symbol_8(buffer, (offset + 0u), value[0u]);
   tint_symbol_8(buffer, (offset + 16u), value[1u]);
 }
@@ -687,82 +687,82 @@ struct SB {
 };
 
 [[internal(intrinsic_load_storage_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> i32
+fn tint_symbol([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> i32
 
 [[internal(intrinsic_load_storage_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_1([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> u32
+fn tint_symbol_1([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> u32
 
 [[internal(intrinsic_load_storage_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_2([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> f32
+fn tint_symbol_2([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> f32
 
 [[internal(intrinsic_load_storage_vec2_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_3([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec2<i32>
+fn tint_symbol_3([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec2<i32>
 
 [[internal(intrinsic_load_storage_vec2_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_4([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec2<u32>
+fn tint_symbol_4([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec2<u32>
 
 [[internal(intrinsic_load_storage_vec2_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_5([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec2<f32>
+fn tint_symbol_5([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec2<f32>
 
 [[internal(intrinsic_load_storage_vec3_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_6([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec3<i32>
+fn tint_symbol_6([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec3<i32>
 
 [[internal(intrinsic_load_storage_vec3_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_7([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec3<u32>
+fn tint_symbol_7([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec3<u32>
 
 [[internal(intrinsic_load_storage_vec3_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_8([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec3<f32>
+fn tint_symbol_8([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec3<f32>
 
 [[internal(intrinsic_load_storage_vec4_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_9([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec4<i32>
+fn tint_symbol_9([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec4<i32>
 
 [[internal(intrinsic_load_storage_vec4_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_10([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec4<u32>
+fn tint_symbol_10([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec4<u32>
 
 [[internal(intrinsic_load_storage_vec4_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_11([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> vec4<f32>
+fn tint_symbol_11([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> vec4<f32>
 
-fn tint_symbol_12([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat2x2<f32> {
+fn tint_symbol_12([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat2x2<f32> {
   return mat2x2<f32>(tint_symbol_5(buffer, (offset + 0u)), tint_symbol_5(buffer, (offset + 8u)));
 }
 
-fn tint_symbol_13([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat2x3<f32> {
+fn tint_symbol_13([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat2x3<f32> {
   return mat2x3<f32>(tint_symbol_8(buffer, (offset + 0u)), tint_symbol_8(buffer, (offset + 16u)));
 }
 
-fn tint_symbol_14([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat2x4<f32> {
+fn tint_symbol_14([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat2x4<f32> {
   return mat2x4<f32>(tint_symbol_11(buffer, (offset + 0u)), tint_symbol_11(buffer, (offset + 16u)));
 }
 
-fn tint_symbol_15([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat3x2<f32> {
+fn tint_symbol_15([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat3x2<f32> {
   return mat3x2<f32>(tint_symbol_5(buffer, (offset + 0u)), tint_symbol_5(buffer, (offset + 8u)), tint_symbol_5(buffer, (offset + 16u)));
 }
 
-fn tint_symbol_16([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat3x3<f32> {
+fn tint_symbol_16([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat3x3<f32> {
   return mat3x3<f32>(tint_symbol_8(buffer, (offset + 0u)), tint_symbol_8(buffer, (offset + 16u)), tint_symbol_8(buffer, (offset + 32u)));
 }
 
-fn tint_symbol_17([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat3x4<f32> {
+fn tint_symbol_17([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat3x4<f32> {
   return mat3x4<f32>(tint_symbol_11(buffer, (offset + 0u)), tint_symbol_11(buffer, (offset + 16u)), tint_symbol_11(buffer, (offset + 32u)));
 }
 
-fn tint_symbol_18([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat4x2<f32> {
+fn tint_symbol_18([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat4x2<f32> {
   return mat4x2<f32>(tint_symbol_5(buffer, (offset + 0u)), tint_symbol_5(buffer, (offset + 8u)), tint_symbol_5(buffer, (offset + 16u)), tint_symbol_5(buffer, (offset + 24u)));
 }
 
-fn tint_symbol_19([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat4x3<f32> {
+fn tint_symbol_19([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat4x3<f32> {
   return mat4x3<f32>(tint_symbol_8(buffer, (offset + 0u)), tint_symbol_8(buffer, (offset + 16u)), tint_symbol_8(buffer, (offset + 32u)), tint_symbol_8(buffer, (offset + 48u)));
 }
 
-fn tint_symbol_20([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> mat4x4<f32> {
+fn tint_symbol_20([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> mat4x4<f32> {
   return mat4x4<f32>(tint_symbol_11(buffer, (offset + 0u)), tint_symbol_11(buffer, (offset + 16u)), tint_symbol_11(buffer, (offset + 32u)), tint_symbol_11(buffer, (offset + 48u)));
 }
 
-fn tint_symbol_21([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> array<vec3<f32>, 2> {
+fn tint_symbol_21([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> array<vec3<f32>, 2> {
   return array<vec3<f32>, 2>(tint_symbol_8(buffer, (offset + 0u)), tint_symbol_8(buffer, (offset + 16u)));
 }
 
-fn tint_symbol_22([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> SB {
+fn tint_symbol_22([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> SB {
   return SB(tint_symbol(buffer, (offset + 0u)), tint_symbol_1(buffer, (offset + 4u)), tint_symbol_2(buffer, (offset + 8u)), tint_symbol_3(buffer, (offset + 16u)), tint_symbol_4(buffer, (offset + 24u)), tint_symbol_5(buffer, (offset + 32u)), tint_symbol_6(buffer, (offset + 48u)), tint_symbol_7(buffer, (offset + 64u)), tint_symbol_8(buffer, (offset + 80u)), tint_symbol_9(buffer, (offset + 96u)), tint_symbol_10(buffer, (offset + 112u)), tint_symbol_11(buffer, (offset + 128u)), tint_symbol_12(buffer, (offset + 144u)), tint_symbol_13(buffer, (offset + 160u)), tint_symbol_14(buffer, (offset + 192u)), tint_symbol_15(buffer, (offset + 224u)), tint_symbol_16(buffer, (offset + 256u)), tint_symbol_17(buffer, (offset + 304u)), tint_symbol_18(buffer, (offset + 352u)), tint_symbol_19(buffer, (offset + 384u)), tint_symbol_20(buffer, (offset + 448u)), tint_symbol_21(buffer, (offset + 512u)));
 }
 
@@ -843,101 +843,101 @@ struct SB {
 };
 
 [[internal(intrinsic_store_storage_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : i32)
+fn tint_symbol([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : i32)
 
 [[internal(intrinsic_store_storage_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_1([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : u32)
+fn tint_symbol_1([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : u32)
 
 [[internal(intrinsic_store_storage_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_2([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : f32)
+fn tint_symbol_2([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : f32)
 
 [[internal(intrinsic_store_storage_vec2_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_3([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec2<i32>)
+fn tint_symbol_3([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec2<i32>)
 
 [[internal(intrinsic_store_storage_vec2_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_4([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec2<u32>)
+fn tint_symbol_4([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec2<u32>)
 
 [[internal(intrinsic_store_storage_vec2_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_5([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec2<f32>)
+fn tint_symbol_5([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec2<f32>)
 
 [[internal(intrinsic_store_storage_vec3_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_6([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec3<i32>)
+fn tint_symbol_6([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec3<i32>)
 
 [[internal(intrinsic_store_storage_vec3_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_7([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec3<u32>)
+fn tint_symbol_7([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec3<u32>)
 
 [[internal(intrinsic_store_storage_vec3_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_8([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec3<f32>)
+fn tint_symbol_8([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec3<f32>)
 
 [[internal(intrinsic_store_storage_vec4_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_9([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec4<i32>)
+fn tint_symbol_9([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec4<i32>)
 
 [[internal(intrinsic_store_storage_vec4_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_10([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec4<u32>)
+fn tint_symbol_10([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec4<u32>)
 
 [[internal(intrinsic_store_storage_vec4_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_11([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : vec4<f32>)
+fn tint_symbol_11([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : vec4<f32>)
 
-fn tint_symbol_12([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat2x2<f32>) {
+fn tint_symbol_12([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat2x2<f32>) {
   tint_symbol_5(buffer, (offset + 0u), value[0u]);
   tint_symbol_5(buffer, (offset + 8u), value[1u]);
 }
 
-fn tint_symbol_13([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat2x3<f32>) {
+fn tint_symbol_13([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat2x3<f32>) {
   tint_symbol_8(buffer, (offset + 0u), value[0u]);
   tint_symbol_8(buffer, (offset + 16u), value[1u]);
 }
 
-fn tint_symbol_14([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat2x4<f32>) {
+fn tint_symbol_14([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat2x4<f32>) {
   tint_symbol_11(buffer, (offset + 0u), value[0u]);
   tint_symbol_11(buffer, (offset + 16u), value[1u]);
 }
 
-fn tint_symbol_15([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat3x2<f32>) {
+fn tint_symbol_15([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat3x2<f32>) {
   tint_symbol_5(buffer, (offset + 0u), value[0u]);
   tint_symbol_5(buffer, (offset + 8u), value[1u]);
   tint_symbol_5(buffer, (offset + 16u), value[2u]);
 }
 
-fn tint_symbol_16([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat3x3<f32>) {
+fn tint_symbol_16([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat3x3<f32>) {
   tint_symbol_8(buffer, (offset + 0u), value[0u]);
   tint_symbol_8(buffer, (offset + 16u), value[1u]);
   tint_symbol_8(buffer, (offset + 32u), value[2u]);
 }
 
-fn tint_symbol_17([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat3x4<f32>) {
+fn tint_symbol_17([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat3x4<f32>) {
   tint_symbol_11(buffer, (offset + 0u), value[0u]);
   tint_symbol_11(buffer, (offset + 16u), value[1u]);
   tint_symbol_11(buffer, (offset + 32u), value[2u]);
 }
 
-fn tint_symbol_18([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat4x2<f32>) {
+fn tint_symbol_18([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat4x2<f32>) {
   tint_symbol_5(buffer, (offset + 0u), value[0u]);
   tint_symbol_5(buffer, (offset + 8u), value[1u]);
   tint_symbol_5(buffer, (offset + 16u), value[2u]);
   tint_symbol_5(buffer, (offset + 24u), value[3u]);
 }
 
-fn tint_symbol_19([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat4x3<f32>) {
+fn tint_symbol_19([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat4x3<f32>) {
   tint_symbol_8(buffer, (offset + 0u), value[0u]);
   tint_symbol_8(buffer, (offset + 16u), value[1u]);
   tint_symbol_8(buffer, (offset + 32u), value[2u]);
   tint_symbol_8(buffer, (offset + 48u), value[3u]);
 }
 
-fn tint_symbol_20([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : mat4x4<f32>) {
+fn tint_symbol_20([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : mat4x4<f32>) {
   tint_symbol_11(buffer, (offset + 0u), value[0u]);
   tint_symbol_11(buffer, (offset + 16u), value[1u]);
   tint_symbol_11(buffer, (offset + 32u), value[2u]);
   tint_symbol_11(buffer, (offset + 48u), value[3u]);
 }
 
-fn tint_symbol_21([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : array<vec3<f32>, 2>) {
+fn tint_symbol_21([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : array<vec3<f32>, 2>) {
   tint_symbol_8(buffer, (offset + 0u), value[0u]);
   tint_symbol_8(buffer, (offset + 16u), value[1u]);
 }
 
-fn tint_symbol_22([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, value : SB) {
+fn tint_symbol_22([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, value : SB) {
   tint_symbol(buffer, (offset + 0u), value.a);
   tint_symbol_1(buffer, (offset + 4u), value.b);
   tint_symbol_2(buffer, (offset + 8u), value.c);
@@ -1032,7 +1032,7 @@ struct SB {
 };
 
 [[internal(intrinsic_load_storage_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> f32
+fn tint_symbol([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> f32
 
 [[group(0), binding(0)]] var<storage, read_write> sb : SB;
 
@@ -1100,7 +1100,7 @@ struct SB {
 };
 
 [[internal(intrinsic_load_storage_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> f32
+fn tint_symbol([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> f32
 
 [[group(0), binding(0)]] var<storage, read_write> sb : SB;
 
@@ -1187,7 +1187,7 @@ struct SB {
 };
 
 [[internal(intrinsic_load_storage_f32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> f32
+fn tint_symbol([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> f32
 
 [[group(0), binding(0)]] var<storage, read_write> sb : SB;
 
@@ -1251,64 +1251,64 @@ struct SB {
 };
 
 [[internal(intrinsic_atomic_store_storage_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : i32)
+fn tint_symbol([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : i32)
 
 [[internal(intrinsic_atomic_load_storage_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_1([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> i32
+fn tint_symbol_1([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> i32
 
 [[internal(intrinsic_atomic_add_storage_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_2([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : i32) -> i32
+fn tint_symbol_2([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : i32) -> i32
 
 [[internal(intrinsic_atomic_max_storage_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_3([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : i32) -> i32
+fn tint_symbol_3([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : i32) -> i32
 
 [[internal(intrinsic_atomic_min_storage_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_4([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : i32) -> i32
+fn tint_symbol_4([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : i32) -> i32
 
 [[internal(intrinsic_atomic_and_storage_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_5([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : i32) -> i32
+fn tint_symbol_5([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : i32) -> i32
 
 [[internal(intrinsic_atomic_or_storage_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_6([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : i32) -> i32
+fn tint_symbol_6([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : i32) -> i32
 
 [[internal(intrinsic_atomic_xor_storage_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_7([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : i32) -> i32
+fn tint_symbol_7([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : i32) -> i32
 
 [[internal(intrinsic_atomic_exchange_storage_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_8([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : i32) -> i32
+fn tint_symbol_8([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : i32) -> i32
 
 [[internal(intrinsic_atomic_compare_exchange_weak_storage_i32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_9([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : i32, param_2 : i32) -> vec2<i32>
+fn tint_symbol_9([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : i32, param_2 : i32) -> vec2<i32>
 
 [[internal(intrinsic_atomic_store_storage_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_10([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : u32)
+fn tint_symbol_10([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : u32)
 
 [[internal(intrinsic_atomic_load_storage_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_11([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32) -> u32
+fn tint_symbol_11([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32) -> u32
 
 [[internal(intrinsic_atomic_add_storage_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_12([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : u32) -> u32
+fn tint_symbol_12([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : u32) -> u32
 
 [[internal(intrinsic_atomic_max_storage_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_13([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : u32) -> u32
+fn tint_symbol_13([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : u32) -> u32
 
 [[internal(intrinsic_atomic_min_storage_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_14([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : u32) -> u32
+fn tint_symbol_14([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : u32) -> u32
 
 [[internal(intrinsic_atomic_and_storage_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_15([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : u32) -> u32
+fn tint_symbol_15([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : u32) -> u32
 
 [[internal(intrinsic_atomic_or_storage_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_16([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : u32) -> u32
+fn tint_symbol_16([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : u32) -> u32
 
 [[internal(intrinsic_atomic_xor_storage_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_17([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : u32) -> u32
+fn tint_symbol_17([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : u32) -> u32
 
 [[internal(intrinsic_atomic_exchange_storage_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_18([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : u32) -> u32
+fn tint_symbol_18([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : u32) -> u32
 
 [[internal(intrinsic_atomic_compare_exchange_weak_storage_u32), internal(disable_validation__function_has_no_body)]]
-fn tint_symbol_19([[internal(disable_validation__ignore_atomic_function_parameter)]] buffer : SB, offset : u32, param_1 : u32, param_2 : u32) -> vec2<u32>
+fn tint_symbol_19([[internal(disable_validation__ignore_constructible_function_parameter)]] buffer : SB, offset : u32, param_1 : u32, param_2 : u32) -> vec2<u32>
 
 [[group(0), binding(0)]] var<storage, read_write> sb : SB;
 

src/transform/inline_pointer_lets.h

@@ -30,7 +30,7 @@ namespace transform {
 ///
 /// Note: InlinePointerLets does not operate on module-scope `let`s, as these
 /// cannot be pointers: https://gpuweb.github.io/gpuweb/wgsl/#module-constants
-/// `A module-scope let-declared constant must be of atomic-free plain type.`
+/// `A module-scope let-declared constant must be of constructible type.`
 class InlinePointerLets : public Castable<InlinePointerLets, Transform> {
  public:
   /// Constructor