diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index 492e355..c6affb1 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -85,6 +85,12 @@
     defines += [ "TINT_BUILD_SYNTAX_TREE_WRITER=0" ]
   }
 
+  if (tint_build_ir) {
+    defines += [ "TINT_BUILD_IR=1" ]
+  } else {
+    defines += [ "TINT_BUILD_IR=0" ]
+  }
+
   include_dirs = [
     "${tint_root_dir}/",
     "${tint_root_dir}/include/",
@@ -281,6 +287,8 @@
     "clone_context.cc",
     "program.cc",
     "program_builder.cc",
+    "resolver/builtin_structs.cc",
+    "resolver/builtin_structs.h",
     "resolver/const_eval.cc",
     "resolver/const_eval.h",
     "resolver/ctor_conv_intrinsic.cc",
@@ -739,6 +747,7 @@
     "builtin/extension.h",
     "builtin/function.cc",
     "builtin/function.h",
+    "builtin/interpolation.h",
     "builtin/interpolation_sampling.cc",
     "builtin/interpolation_sampling.h",
     "builtin/interpolation_type.cc",
@@ -1096,6 +1105,87 @@
   ]
 }
 
+libtint_source_set("libtint_ir_builder_src") {
+  sources = [
+    "ir/builder_impl.cc",
+    "ir/builder_impl.h",
+    "ir/converter.cc",
+    "ir/converter.h",
+  ]
+  deps = [
+    ":libtint_ast_src",
+    ":libtint_constant_src",
+    ":libtint_ir_src",
+    ":libtint_program_src",
+    ":libtint_sem_src",
+    ":libtint_type_src",
+    ":libtint_utils_src",
+  ]
+}
+
+libtint_source_set("libtint_ir_src") {
+  sources = [
+    "ir/binary.cc",
+    "ir/binary.h",
+    "ir/bitcast.cc",
+    "ir/bitcast.h",
+    "ir/block.cc",
+    "ir/block.h",
+    "ir/builder.cc",
+    "ir/builder.h",
+    "ir/builtin.cc",
+    "ir/builtin.h",
+    "ir/call.cc",
+    "ir/call.h",
+    "ir/constant.cc",
+    "ir/constant.h",
+    "ir/construct.cc",
+    "ir/construct.h",
+    "ir/convert.cc",
+    "ir/convert.h",
+    "ir/debug.cc",
+    "ir/debug.h",
+    "ir/disassembler.cc",
+    "ir/disassembler.h",
+    "ir/discard.cc",
+    "ir/discard.h",
+    "ir/flow_node.cc",
+    "ir/flow_node.h",
+    "ir/function.cc",
+    "ir/function.h",
+    "ir/if.cc",
+    "ir/if.h",
+    "ir/instruction.cc",
+    "ir/instruction.h",
+    "ir/loop.cc",
+    "ir/loop.h",
+    "ir/module.cc",
+    "ir/module.h",
+    "ir/store.cc",
+    "ir/store.h",
+    "ir/switch.cc",
+    "ir/switch.h",
+    "ir/terminator.cc",
+    "ir/terminator.h",
+    "ir/unary.cc",
+    "ir/unary.h",
+    "ir/user_call.cc",
+    "ir/user_call.h",
+    "ir/value.cc",
+    "ir/value.h",
+    "ir/var.cc",
+    "ir/var.h",
+  ]
+
+  deps = [
+    ":libtint_builtins_src",
+    ":libtint_constant_src",
+    ":libtint_symbols_src",
+    ":libtint_type_src",
+    ":libtint_utils_src",
+  ]
+}
+
 source_set("libtint") {
   public_deps = [
     ":libtint_ast_src",
@@ -1143,6 +1233,15 @@
     public_deps += [ ":libtint_syntax_tree_writer_src" ]
   }
 
+  if (tint_build_ir) {
+    assert(!build_with_chromium,
+           "tint_build_ir cannot be used when building Chromium")
+    public_deps += [
+      ":libtint_ir_builder_src",
+      ":libtint_ir_src",
+    ]
+  }
+
   configs += [ ":tint_common_config" ]
   public_configs = [ ":tint_public_config" ]
 
@@ -1414,6 +1513,7 @@
       "resolver/attribute_validation_test.cc",
       "resolver/bitcast_validation_test.cc",
       "resolver/builtin_enum_test.cc",
+      "resolver/builtin_structs_test.cc",
       "resolver/builtin_test.cc",
       "resolver/builtin_validation_test.cc",
       "resolver/builtins_validation_test.cc",
@@ -2016,6 +2116,24 @@
     ]
   }
 
+  tint_unittests_source_set("tint_unittests_ir_src") {
+    sources = [
+      "ir/binary_test.cc",
+      "ir/bitcast_test.cc",
+      "ir/builder_impl_test.cc",
+      "ir/constant_test.cc",
+      "ir/discard_test.cc",
+      "ir/store_test.cc",
+      "ir/test_helper.h",
+      "ir/unary_test.cc",
+    ]
+
+    deps = [
+      ":libtint_ir_builder_src",
+      ":libtint_ir_src",
+    ]
+  }
+
   if (build_with_chromium) {
     tint_unittests_source_set("tint_unittests_fuzzer_src") {
       sources = [ "fuzzers/random_generator_test.cc" ]
@@ -2077,6 +2195,10 @@
       deps += [ ":tint_unittests_glsl_writer_src" ]
     }
 
+    if (tint_build_ir) {
+      deps += [ ":tint_unittests_ir_src" ]
+    }
+
     if (build_with_chromium) {
       deps += [ ":tint_unittests_fuzzer_src" ]
     }
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index f715428..2e1ded8 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -264,6 +264,8 @@
   reflection.h
   reader/reader.cc
   reader/reader.h
+  resolver/builtin_structs.cc
+  resolver/builtin_structs.h
   resolver/const_eval.cc
   resolver/const_eval.h
   resolver/dependency_graph.cc
@@ -716,6 +718,8 @@
     ir/construct.h
     ir/convert.cc
     ir/convert.h
+    ir/converter.cc
+    ir/converter.h
     ir/debug.cc
     ir/debug.h
     ir/disassembler.cc
@@ -734,8 +738,6 @@
     ir/loop.h
     ir/module.cc
     ir/module.h
-    ir/runtime.cc
-    ir/runtime.h
     ir/store.cc
     ir/store.h
     ir/switch.cc
@@ -748,6 +750,8 @@
     ir/user_call.h
     ir/value.cc
     ir/value.h
+    ir/var.cc
+    ir/var.h
   )
 endif()
 
@@ -911,6 +915,7 @@
     resolver/attribute_validation_test.cc
     resolver/bitcast_validation_test.cc
     resolver/builtin_enum_test.cc
+    resolver/builtin_structs_test.cc
     resolver/builtin_test.cc
     resolver/builtin_validation_test.cc
     resolver/builtins_validation_test.cc
@@ -1420,7 +1425,6 @@
       ir/builder_impl_test.cc
       ir/constant_test.cc
       ir/discard_test.cc
-      ir/runtime_test.cc
       ir/store_test.cc
       ir/test_helper.h
       ir/unary_test.cc
diff --git a/src/tint/builtin/access_bench.cc b/src/tint/builtin/access_bench.cc
index 91f808f..58a5f47 100644
--- a/src/tint/builtin/access_bench.cc
+++ b/src/tint/builtin/access_bench.cc
@@ -43,7 +43,7 @@
             benchmark::DoNotOptimize(result);
         }
     }
-}
+}  // NOLINT(readability/fn_size)
 
 BENCHMARK(AccessParser);
 
diff --git a/src/tint/builtin/address_space_bench.cc b/src/tint/builtin/address_space_bench.cc
index 18cc9d2..81b27eb 100644
--- a/src/tint/builtin/address_space_bench.cc
+++ b/src/tint/builtin/address_space_bench.cc
@@ -94,7 +94,7 @@
             benchmark::DoNotOptimize(result);
         }
     }
-}
+}  // NOLINT(readability/fn_size)
 
 BENCHMARK(AddressSpaceParser);
 
diff --git a/src/tint/builtin/attribute_bench.cc b/src/tint/builtin/attribute_bench.cc
index 5d12ab3..a25fbf1 100644
--- a/src/tint/builtin/attribute_bench.cc
+++ b/src/tint/builtin/attribute_bench.cc
@@ -143,7 +143,7 @@
             benchmark::DoNotOptimize(result);
         }
     }
-}
+}  // NOLINT(readability/fn_size)
 
 BENCHMARK(AttributeParser);
 
diff --git a/src/tint/builtin/builtin.cc b/src/tint/builtin/builtin.cc
index 085a266..8f26436 100644
--- a/src/tint/builtin/builtin.cc
+++ b/src/tint/builtin/builtin.cc
@@ -28,6 +28,84 @@
 /// @param str the string to parse
 /// @returns the parsed enum, or Builtin::kUndefined if the string could not be parsed.
 Builtin ParseBuiltin(std::string_view str) {
+    if (str == "__atomic_compare_exchange_result_i32") {
+        return Builtin::kAtomicCompareExchangeResultI32;
+    }
+    if (str == "__atomic_compare_exchange_result_u32") {
+        return Builtin::kAtomicCompareExchangeResultU32;
+    }
+    if (str == "__frexp_result_abstract") {
+        return Builtin::kFrexpResultAbstract;
+    }
+    if (str == "__frexp_result_f16") {
+        return Builtin::kFrexpResultF16;
+    }
+    if (str == "__frexp_result_f32") {
+        return Builtin::kFrexpResultF32;
+    }
+    if (str == "__frexp_result_vec2_abstract") {
+        return Builtin::kFrexpResultVec2Abstract;
+    }
+    if (str == "__frexp_result_vec2_f16") {
+        return Builtin::kFrexpResultVec2F16;
+    }
+    if (str == "__frexp_result_vec2_f32") {
+        return Builtin::kFrexpResultVec2F32;
+    }
+    if (str == "__frexp_result_vec3_abstract") {
+        return Builtin::kFrexpResultVec3Abstract;
+    }
+    if (str == "__frexp_result_vec3_f16") {
+        return Builtin::kFrexpResultVec3F16;
+    }
+    if (str == "__frexp_result_vec3_f32") {
+        return Builtin::kFrexpResultVec3F32;
+    }
+    if (str == "__frexp_result_vec4_abstract") {
+        return Builtin::kFrexpResultVec4Abstract;
+    }
+    if (str == "__frexp_result_vec4_f16") {
+        return Builtin::kFrexpResultVec4F16;
+    }
+    if (str == "__frexp_result_vec4_f32") {
+        return Builtin::kFrexpResultVec4F32;
+    }
+    if (str == "__modf_result_abstract") {
+        return Builtin::kModfResultAbstract;
+    }
+    if (str == "__modf_result_f16") {
+        return Builtin::kModfResultF16;
+    }
+    if (str == "__modf_result_f32") {
+        return Builtin::kModfResultF32;
+    }
+    if (str == "__modf_result_vec2_abstract") {
+        return Builtin::kModfResultVec2Abstract;
+    }
+    if (str == "__modf_result_vec2_f16") {
+        return Builtin::kModfResultVec2F16;
+    }
+    if (str == "__modf_result_vec2_f32") {
+        return Builtin::kModfResultVec2F32;
+    }
+    if (str == "__modf_result_vec3_abstract") {
+        return Builtin::kModfResultVec3Abstract;
+    }
+    if (str == "__modf_result_vec3_f16") {
+        return Builtin::kModfResultVec3F16;
+    }
+    if (str == "__modf_result_vec3_f32") {
+        return Builtin::kModfResultVec3F32;
+    }
+    if (str == "__modf_result_vec4_abstract") {
+        return Builtin::kModfResultVec4Abstract;
+    }
+    if (str == "__modf_result_vec4_f16") {
+        return Builtin::kModfResultVec4F16;
+    }
+    if (str == "__modf_result_vec4_f32") {
+        return Builtin::kModfResultVec4F32;
+    }
     if (str == "__packed_vec3") {
         return Builtin::kPackedVec3;
     }
@@ -245,6 +323,58 @@
     switch (value) {
         case Builtin::kUndefined:
             return out << "undefined";
+        case Builtin::kAtomicCompareExchangeResultI32:
+            return out << "__atomic_compare_exchange_result_i32";
+        case Builtin::kAtomicCompareExchangeResultU32:
+            return out << "__atomic_compare_exchange_result_u32";
+        case Builtin::kFrexpResultAbstract:
+            return out << "__frexp_result_abstract";
+        case Builtin::kFrexpResultF16:
+            return out << "__frexp_result_f16";
+        case Builtin::kFrexpResultF32:
+            return out << "__frexp_result_f32";
+        case Builtin::kFrexpResultVec2Abstract:
+            return out << "__frexp_result_vec2_abstract";
+        case Builtin::kFrexpResultVec2F16:
+            return out << "__frexp_result_vec2_f16";
+        case Builtin::kFrexpResultVec2F32:
+            return out << "__frexp_result_vec2_f32";
+        case Builtin::kFrexpResultVec3Abstract:
+            return out << "__frexp_result_vec3_abstract";
+        case Builtin::kFrexpResultVec3F16:
+            return out << "__frexp_result_vec3_f16";
+        case Builtin::kFrexpResultVec3F32:
+            return out << "__frexp_result_vec3_f32";
+        case Builtin::kFrexpResultVec4Abstract:
+            return out << "__frexp_result_vec4_abstract";
+        case Builtin::kFrexpResultVec4F16:
+            return out << "__frexp_result_vec4_f16";
+        case Builtin::kFrexpResultVec4F32:
+            return out << "__frexp_result_vec4_f32";
+        case Builtin::kModfResultAbstract:
+            return out << "__modf_result_abstract";
+        case Builtin::kModfResultF16:
+            return out << "__modf_result_f16";
+        case Builtin::kModfResultF32:
+            return out << "__modf_result_f32";
+        case Builtin::kModfResultVec2Abstract:
+            return out << "__modf_result_vec2_abstract";
+        case Builtin::kModfResultVec2F16:
+            return out << "__modf_result_vec2_f16";
+        case Builtin::kModfResultVec2F32:
+            return out << "__modf_result_vec2_f32";
+        case Builtin::kModfResultVec3Abstract:
+            return out << "__modf_result_vec3_abstract";
+        case Builtin::kModfResultVec3F16:
+            return out << "__modf_result_vec3_f16";
+        case Builtin::kModfResultVec3F32:
+            return out << "__modf_result_vec3_f32";
+        case Builtin::kModfResultVec4Abstract:
+            return out << "__modf_result_vec4_abstract";
+        case Builtin::kModfResultVec4F16:
+            return out << "__modf_result_vec4_f16";
+        case Builtin::kModfResultVec4F32:
+            return out << "__modf_result_vec4_f32";
         case Builtin::kPackedVec3:
             return out << "__packed_vec3";
         case Builtin::kArray:
diff --git a/src/tint/builtin/builtin.h b/src/tint/builtin/builtin.h
index da5226d..d891294 100644
--- a/src/tint/builtin/builtin.h
+++ b/src/tint/builtin/builtin.h
@@ -30,6 +30,32 @@
 /// An enumerator of builtin builtin.
 enum class Builtin {
     kUndefined,
+    kAtomicCompareExchangeResultI32,
+    kAtomicCompareExchangeResultU32,
+    kFrexpResultAbstract,
+    kFrexpResultF16,
+    kFrexpResultF32,
+    kFrexpResultVec2Abstract,
+    kFrexpResultVec2F16,
+    kFrexpResultVec2F32,
+    kFrexpResultVec3Abstract,
+    kFrexpResultVec3F16,
+    kFrexpResultVec3F32,
+    kFrexpResultVec4Abstract,
+    kFrexpResultVec4F16,
+    kFrexpResultVec4F32,
+    kModfResultAbstract,
+    kModfResultF16,
+    kModfResultF32,
+    kModfResultVec2Abstract,
+    kModfResultVec2F16,
+    kModfResultVec2F32,
+    kModfResultVec3Abstract,
+    kModfResultVec3F16,
+    kModfResultVec3F32,
+    kModfResultVec4Abstract,
+    kModfResultVec4F16,
+    kModfResultVec4F32,
     kPackedVec3,
     kArray,
     kAtomic,
@@ -113,6 +139,32 @@
 Builtin ParseBuiltin(std::string_view str);
 
 constexpr const char* kBuiltinStrings[] = {
+    "__atomic_compare_exchange_result_i32",
+    "__atomic_compare_exchange_result_u32",
+    "__frexp_result_abstract",
+    "__frexp_result_f16",
+    "__frexp_result_f32",
+    "__frexp_result_vec2_abstract",
+    "__frexp_result_vec2_f16",
+    "__frexp_result_vec2_f32",
+    "__frexp_result_vec3_abstract",
+    "__frexp_result_vec3_f16",
+    "__frexp_result_vec3_f32",
+    "__frexp_result_vec4_abstract",
+    "__frexp_result_vec4_f16",
+    "__frexp_result_vec4_f32",
+    "__modf_result_abstract",
+    "__modf_result_f16",
+    "__modf_result_f32",
+    "__modf_result_vec2_abstract",
+    "__modf_result_vec2_f16",
+    "__modf_result_vec2_f32",
+    "__modf_result_vec3_abstract",
+    "__modf_result_vec3_f16",
+    "__modf_result_vec3_f32",
+    "__modf_result_vec4_abstract",
+    "__modf_result_vec4_f16",
+    "__modf_result_vec4_f32",
     "__packed_vec3",
     "array",
     "atomic",
diff --git a/src/tint/builtin/builtin_bench.cc b/src/tint/builtin/builtin_bench.cc
index 1f309f5..4804ff7 100644
--- a/src/tint/builtin/builtin_bench.cc
+++ b/src/tint/builtin/builtin_bench.cc
@@ -31,496 +31,678 @@
 
 void BuiltinParser(::benchmark::State& state) {
     const char* kStrings[] = {
-        "__acked_veccc",
-        "_pac3ed_v3",
-        "__packeV_vec3",
+        "__atomic_compareexchangeccresult_i32",
+        "__atoml3_compare_exchane_resulti2",
+        "__atomic_compare_Vxchange_result_i32",
+        "__atomic_compare_exchange_result_i32",
+        "__atomic_com1are_exchange_result_i32",
+        "__atomic_qqompare_exchage_resulJ_i32",
+        "__atllmic_compare_exchange_result_i377",
+        "__atomicppcompareqqexchange_reslt_uHH2",
+        "__atomi_compare_exchavge_cesult_3",
+        "__atomic_copare_eGbhange_result_u32",
+        "__atomic_compare_exchange_result_u32",
+        "__atomic_coiipare_exvhange_result_u32",
+        "__atomic_compaWWe_excha8ge_result_u32",
+        "__atomic_comparxxMexchage_result_u32",
+        "__fXexp_resgglt_bstract",
+        "V_frexp_resul_abuXrct",
+        "__frexp_result_abstra3t",
+        "__frexp_result_abstract",
+        "__frexp_resElt_abstract",
+        "__frexTT_Pesult_abstract",
+        "__frexp_resulxxddabstrct",
+        "44_frexp_result_f16",
+        "_VVfrexp_resulSS_f16",
+        "__frexp_reRult_fR6",
+        "__frexp_result_f16",
+        "__frFxp_re9ut_f16",
+        "__frep_result_f16",
+        "__frRRVH_rOOsultf16",
+        "__frepyresult_f32",
+        "_nrr77rexp_result_fGll",
+        "__4rex00_result_f32",
+        "__frexp_result_f32",
+        "__oorep_reult_f2",
+        "__fzzexp_result_3",
+        "__iir11x_respplt_f3",
+        "__frexp_resuXXt_vec2_abstract",
+        "55n99frexp_result_vec2_abstraIIt",
+        "__fHHexpSSaresrrlt_Yec2_abstract",
+        "__frexp_result_vec2_abstract",
+        "__freHp_resutve2_abstkkact",
+        "jfrexpgresult_veRR2_abstrac",
+        "__frexp_resul_vec2_absbrac",
+        "_jfrexp_result_vec2_f16",
+        "__frexp_resultvec2_f16",
+        "__freqpresultvec2_f16",
+        "__frexp_result_vec2_f16",
+        "__frexNN_result_vec_f16",
+        "__frexp_resvvlt_vc2_f1",
+        "__frexp_esult_vec2_f1QQ",
+        "__rerp_result_ffec2_f2",
+        "__frexp_result_vjc2_f32",
+        "__frewwp_reul2_vec2_NN82",
+        "__frexp_result_vec2_f32",
+        "__frexpresult_vec2_f32",
+        "__frexp_result_vec2_frr2",
+        "_Gfrexp_result_vec2_f32",
+        "__frexp_resulFF_vec3_abstract",
+        "_frexp_resultvec3_Estract",
+        "__fexp_result_vec3_abstrract",
+        "__frexp_result_vec3_abstract",
+        "frexp_result_vec3_abstract",
+        "D_rexp_resXlt_veJJ3_abstract",
+        "_frexp_resut_v8c_abstract",
+        "_frexp_rsl1k_vec3_f16",
+        "__frexp_reslt_vec3_f16",
+        "__frexJ_reult_vec3_f16",
+        "__frexp_result_vec3_f16",
+        "c_frexp_result_vec3_f16",
+        "__frexp_result_vec3Of16",
+        "___frexp_reKKultvvvec3_f1tt",
+        "8_frexp_reult_vxxc3_f32",
+        "_frexp_resul___veFqqf32",
+        "_qqfrexp_result_vec_f32",
+        "__frexp_result_vec3_f32",
+        "33_fOexp_result_ve3_6632",
+        "__oorexQQ_rttsult_ve639f32",
+        "__rexp_result_vec3_f662",
+        "__frexp_reszzlt_Oc4xabstrac66",
+        "__frexp_resyylt_vec4_abstract",
+        "__frexp_resut_vecHH_aZsracZ",
+        "__frexp_result_vec4_abstract",
+        "_WWfrex44_resulq_vec4_astract",
+        "__frexp_rsult_veOO4_abstract",
+        "__frexp_resultoovc4_abstYct",
+        "_frexp_esultvec4_f16",
+        "__Frexp_result_ec4_f16",
+        "__frewp_resut_vec4_f16",
+        "__frexp_result_vec4_f16",
+        "__frexp_reslt_veK4fG16",
+        "__fqexp_result_veKK4_f16",
+        "_F3rexp_result_vec4_f1mm",
+        "__frexp_result_ec4_f32",
+        "__frexp_result_qe4_f32",
+        "__frbbxp_result_vec4_b2",
+        "__frexp_result_vec4_f32",
+        "__frexp_reslt_iiec4_f2",
+        "__frexO_resulq_vec4_f32",
+        "__frexp_resulTT_vec4vvf32",
+        "__modf_resulFF_abstract",
+        "fm00df_rePult_abstraQt",
+        "__modf_result_abstPact",
+        "__modf_result_abstract",
+        "_modf_result_abstssac77",
+        "__modf_resulC_bbRbstract",
+        "__modf_result_abstracXX",
+        "__OOofCCresuOOt_f16",
+        "_smodf_resuutfL6",
+        "__modX_result_f16",
+        "__modf_result_f16",
+        "__modf_reult_f16",
+        "__modf_resqqO16",
+        "__modf22result_f16",
+        "__modf_X0eszzlt_fy",
+        "_VVmPf_result_f3i",
+        "__monnfCresultf32",
+        "__modf_result_f32",
+        "_HHAmodf_resqltf32",
+        "__modf_resut_f32",
+        "__modresuft_f3KK",
+        "__modlPrsultggvec2_astract",
+        "__odf_result_vec2_abstract",
+        "__mocTf_result_vNc2_abstra4t",
+        "__modf_result_vec2_abstract",
+        "__modf77result_vec2_plbtract",
+        "__mdf_resultNNvec2zabstgact",
+        "_modf_bbesult_vuuc2_abtraXXt",
+        "__modf_esult_vec2_f16",
+        "__mQdf_esuKt_vec_8816",
+        "q_m9dfresult_vec2_f16",
+        "__modf_result_vec2_f16",
+        "__11odf_result_vec2_f16",
+        "_iimodf_result_vF222f16",
+        "_77modf_result_vec2f16",
+        "__odfNNr2sult_vec2_f32",
+        "__modf_rVVsult_vec2_f32",
+        "__modf_Fesult_vewW2_f311",
+        "__modf_result_vec2_f32",
+        "__modf_rwwsult_vec_f32",
+        "__modf_result_Dec2_f32",
+        "__modf_result_ec2_f3K",
+        "__modf_resul1PP_vech_abstfact",
+        "__modf_result_vec_abstract",
+        "__YYodf_result_vec3_abstract",
+        "__modf_result_vec3_abstract",
+        "__mHHdfresult_kkec3_abstract",
+        "__modf_result_vec3rrabstract",
+        "__modf_ssesulWW_vec_abstract",
+        "__mYdf_reslt_vec3_f16",
+        "q_modLrfsult_vec3_f16",
+        "uu_vvo22f_rfsult_ec3_f16",
+        "__modf_result_vec3_f16",
+        "__mdf_reslt_vec3_f16",
+        "__modfYYresult_ve3f16",
+        "__modfEr77sult_vec3_yY16",
+        "__odf_desuMot_vec3_f32",
+        "__mMMf_result_vec3_f32",
+        "__modf_result_vec3_f355",
+        "__modf_result_vec3_f32",
+        "__modf_rest_vec3Nf32",
+        "_m33df_result_Oec3_f32",
+        "__modf_re3ult_vec3_f32",
+        "__momf_esult_Iec4_abstract",
+        "__modf_resultrvec4_absnnracK",
+        "__modf_eslt_ve4_absXXact",
+        "__modf_result_vec4_abstract",
+        "__modf_rsult_pLLI4_abstract",
+        "_modf_resflt_vec4_bstract",
+        "_Ymodf_resultURDec4_abtract",
+        "__hodf_result_vec4_f16",
+        "__moquu_rslt_vec4_f1II",
+        "__modf_result_vecH_f16",
+        "__modf_result_vec4_f16",
+        "__oQQf_resultvvvc4_f16",
+        "__modf_eeult66ec4_f16",
+        "_Omodf_r7sut_vec4_W16",
+        "__modf_DDes0lt_v55c4_f32",
+        "__modf_rIIsult_Hec4_f32",
+        "_modf_result_vec4_f32",
+        "__modf_result_vec4_f32",
+        "_modf_result_vrc4_f32",
+        "_lmodf_result_vec4_f32",
+        "tt_modfGeslt_vec4_fJJ2",
+        "__paked_vyc3",
+        "_packed_vec3",
+        "__pIIckedBBvec3",
         "__packed_vec3",
-        "__pa1ked_vec3",
-        "_qqJcked_vec3",
-        "__pack77d_vllc3",
-        "arqHapp",
-        "vy",
-        "Grby",
+        "__8aTTked_v33c3",
+        "dnnUUpackeSSY_vec3",
+        "xC_5ackedZvec3",
+        "kkrraq",
+        "a005iy",
+        "anIIray",
         "array",
-        "arviay",
-        "ar8WWy",
-        "Mxxra",
-        "atXggi",
-        "Xoic",
-        "ato3ic",
+        "ccrW",
+        "rKK",
+        "arr66y",
+        "aKKoPi",
+        "atxxmc",
+        "atoqic",
         "atomic",
-        "aEomic",
-        "toTTiPP",
-        "ddtoxxi",
-        "44ool",
-        "VVSSol",
-        "RoRl",
+        "rMoyyiSS",
+        "utom",
+        "oic",
+        "5oFFl",
+        "borz4l",
+        "WW",
         "bool",
-        "oFl",
-        "boo",
-        "ORVHl",
-        "y1",
-        "l77rrn6",
-        "4016",
+        "ZJJCoX",
+        "boPP",
+        "bocl",
+        "fll66",
+        "91yy",
+        "f1KK",
         "f16",
-        "5",
-        "u16",
-        "f",
-        "f3kk",
-        "fi",
-        "f3XX",
+        "x_",
+        "K",
+        "kVz",
+        "K3S",
+        "f2",
+        "fVV",
         "f32",
-        "55399II",
-        "frSSHHa",
-        "U",
-        "jV3",
-        "",
-        "GG",
+        "IAU2",
+        "j",
+        "Y4",
+        "i2",
+        "1xx",
+        "ccm",
         "i32",
-        "2",
-        "",
-        "jj",
-        "a2xrf",
-        "mat2j2",
-        "m82wNN2",
-        "mat2x2",
+        "iJJ",
+        "UfCDD",
+        "i3g",
+        "CCtx",
         "mt2x2",
-        "rrat2x2",
-        "mGt2x2",
-        "mat2x2FF",
-        "at2f",
-        "marrx2f",
+        "mat2x__",
+        "mat2x2",
+        "attxPP",
+        "mdd32x2",
+        "yyK2x2",
+        "m2uu",
+        "ma0nnx2i",
+        "KanuuCC2f",
         "mat2x2f",
-        "t2x2f",
-        "Da2xJJf",
-        "ma82",
-        "m11k2",
-        "matx2h",
-        "maJx2h",
+        "mlX2x2f",
+        "oat2pp2f",
+        "wwat22f",
+        "matguum",
+        "mt2ma2",
+        "Tat2xZRRh",
         "mat2x2h",
-        "mat2c2h",
-        "mat2x2O",
-        "KK_atvvtt2h",
-        "5txxx8",
-        "a__xqq",
-        "maqq2x",
+        "ma8T2xOh",
+        "m0at2x2h",
+        "mBBt2x2h",
+        "Matpp",
+        "Oat2x3",
+        "GGG2x3",
         "mat2x3",
-        "ma32x66",
-        "mttQQo2x3",
-        "mat66x",
-        "mtOxzz66",
-        "mat2yy3f",
-        "ZaHH3Z",
-        "mat2x3f",
-        "4WWt2q3f",
-        "mOO2x3f",
-        "oatY3f",
+        "mHHt2113",
+        "mateF63",
         "matx",
-        "ma2xFh",
-        "at2x3w",
+        "mat2ii3l",
+        "mt2x3f",
+        "IIvvt2x39",
+        "mat2x3f",
+        "mat23f",
+        "mat2h3f",
+        "mllt2xPzz",
+        "t3h",
+        "mtffxqqh",
+        "mtJJx3dd",
         "mat2x3h",
-        "fGtxKh",
-        "matqKx3h",
-        "matmmxFh",
-        "at2x4",
-        "matxq",
-        "mb2bb4",
+        "mzz2X3h",
+        "matx32",
+        "maN2yy3h",
+        "atxO",
+        "rauExP",
+        "meet22dd",
         "mat2x4",
-        "it2x4",
-        "mOO2xq",
-        "mat2Tvv4",
-        "maFF2x4f",
-        "Pa00xQf",
-        "mPt2x4f",
+        "maV92",
+        "maI2x1",
+        "mab2x4",
+        "matzf",
+        "mao2ii4f",
+        "mat45",
         "mat2x4f",
-        "ma772xss",
-        "RRCbb2x4f",
-        "mXXt2x4f",
-        "qaCC2xOOh",
-        "ma2s4L",
-        "mXt2x4h",
+        "at2xSf",
+        "mat22f",
+        "maG1C4f",
+        "maff284h",
+        "t2x4h",
+        "SSatJJx4h",
         "mat2x4h",
-        "mat24h",
-        "qa2O4",
-        "mat2x22h",
-        "mzzyt3x",
-        "atiVP2",
-        "mt3Cnn",
+        "atx9h",
+        "maJJbbTT4h",
+        "66a2xh",
+        "ma663u",
+        "Wa3x2",
+        "ma32",
         "mat3x2",
-        "AtqqHH2",
-        "at3x2",
-        "mafKK",
-        "ltgg2f",
-        "mat3xf",
-        "NTTtcx4f",
+        "ma3x2",
+        "rat3x2",
+        "m2t3xB",
+        "matxBBf",
+        "maRR3xf",
+        "maVV0Lf",
         "mat3x2f",
-        "ma7ppl2f",
-        "mNNt3xg",
-        "uub3XX2f",
-        "matx2h",
-        "Qt882h",
-        "mt9q2h",
+        "a3OOK2f",
+        "magw3xf",
+        "hht3L2f",
+        "aKii3xh",
+        "ma3x2h",
+        "UUa3882",
         "mat3x2h",
-        "m11t3x2h",
-        "22at3iih",
-        "at3x277",
-        "NNa323",
-        "VVat3x3",
-        "ma11F3w3",
+        "rrvvt3x2h",
+        "m3xwmm",
+        "j443x2h",
+        "matXx3",
+        "m8t3x3",
+        "mat3vEE",
         "mat3x3",
-        "matww3",
-        "mat3D3",
-        "maKx3",
-        "mat31PPhf",
-        "mat33f",
-        "mYYt3x3f",
-        "mat3x3f",
-        "mttHH3kk",
-        "mat3rr3f",
-        "WWas3x3f",
-        "Yt3x3h",
-        "mt3qfh",
-        "mav223xuh",
-        "mat3x3h",
-        "t3x3h",
-        "YYat3h",
-        "may3x3EYY",
-        "Moatd4",
-        "mt3xMM",
-        "m55t3x4",
-        "mat3x4",
-        "maN4",
-        "ma33x4",
+        "mzzi3x",
+        "maGGQ3JJ3",
+        "mat3ss3",
+        "matKxPf",
+        "mat3ttf",
         "mt3x3",
-        "mm66Issf",
-        "mat3x1f",
-        "Xt3x4",
+        "mat3x3f",
+        "mMMt3x3f",
+        "maJ03x3f",
+        "V8x3",
+        "maKggx3hh",
+        "maf3x3h",
+        "matQ7x3h",
+        "mat3x3h",
+        "mat3YYh",
+        "mak3x3",
+        "man3x2",
+        "mFFx4",
+        "GGatPPuUU",
+        "mEEFa4",
+        "mat3x4",
+        "mBet3dd4",
+        "55atExcc",
+        "txKK",
+        "mat3x4R",
+        "maDx49",
+        "mt3x4f",
         "mat3x4f",
-        "LatIx4f",
-        "at3ff",
-        "mYtURD4",
-        "mah3x4h",
-        "uuIqt3x",
-        "maH3x4h",
+        "aaat3I",
+        "m77t3x4f",
+        "matIx4f",
+        "md3x4h",
+        "mat34h",
+        "mtt4h",
         "mat3x4h",
-        "at3QQvv",
-        "at66eh",
-        "ma7O4h",
-        "m0t55DD2",
-        "IIaH4x2",
-        "mat4x",
+        "ma3XX3x4h",
+        "Eat34h",
+        "maXX3x4",
+        "mxBt4x2",
+        "Wt4x",
+        "mat66x2",
         "mat4x2",
-        "mt4r2",
-        "mat4xl",
-        "mGttx2",
-        "mat4y2",
-        "mt4x2f",
-        "IIaBB4x2f",
+        "atTv0",
+        "kt",
+        "mpt4x",
+        "at112f",
+        "EaJ4yBBf",
+        "mqIm4x2f",
         "mat4x2f",
-        "TTat4x833",
-        "ddUUnntYYx2f",
-        "m5CCxxdZ",
-        "matkkq2h",
-        "005itpxh",
-        "maIInnx2h",
+        "ma4xFf",
+        "Yt4x2f",
+        "mHHtDh2f",
+        "Ht22h",
+        "matx2",
+        "matx2h",
         "mat4x2h",
-        "Ka4Wcc",
-        "m42KK",
-        "mat66x2h",
-        "mKKtPx",
-        "maxx43",
-        "matqx3",
+        "matx2h",
+        "matddx2h",
+        "Oat4x2h",
+        "bbtB3",
+        "m00tx3",
+        "hat4x3",
         "mat4x3",
-        "rMtyyxSS",
-        "uat4",
-        "tx3",
-        "ma5F4x3f",
-        "rra444z3f",
-        "matWW",
+        "matgYx",
+        "Oat4x3",
+        "mhx3",
+        "fpaEEx3f",
+        "mavx3f",
+        "mzztx3f",
         "mat4x3f",
-        "CatZJXx3f",
-        "maPPx3f",
-        "mat4c3f",
-        "matPPll6h",
-        "mat993yy",
-        "mat4JKKh",
+        "ma4x3f",
+        "OOaJxii",
+        "mft4G3f",
+        "mat4x322T",
+        "datlx3h",
+        "bat4x3h",
         "mat4x3h",
-        "mat4_h",
-        "ayK3h",
-        "mzt4V3k",
-        "qaSKx4",
-        "mat44",
-        "ma4xVV",
+        "BBatx3h",
+        "PPIXt4S3h",
+        "mjjt4x3h",
+        "macc4_4",
+        "SS6zz4xx",
+        "mtx",
         "mat4x4",
-        "mAAt4xI",
-        "jb44",
-        "t4YYx",
-        "mao4x4",
-        "mtx114f",
-        "mtmxccf",
+        "mxxtvN",
+        "AA00t44",
+        "tyexy",
+        "mabWWx0f",
+        "ttatMMxmf",
+        "madf",
         "mat4x4f",
-        "aJJ4x4f",
-        "fCCDD4x4U",
-        "mgt4x4f",
-        "CCx4h",
-        "mat4x66",
-        "maN4M4h",
+        "mat_4f",
+        "Vat4EE4f",
+        "mat44f",
+        "mRIxah",
+        "ma4mmh",
+        "at4x4p",
         "mat4x4h",
-        "mattth",
-        "maKWxh",
-        "mateezx4h",
-        "",
-        "w9",
-        "4tnn",
+        "mat4xh",
+        "aaxh",
+        "mad4x4h",
+        "pCPtd",
+        "p",
+        "5tr",
         "ptr",
-        "tll",
-        "4to",
-        "wEgg",
-        "gamler",
-        "spleS",
-        "aampl",
+        "ff99j",
+        "YYvXR",
+        "r",
+        "XX8m5le",
+        "mpler",
+        "sccmlppr",
         "sampler",
-        "TamplZRRr",
-        "sa8TplOr",
-        "m0ampler",
-        "sampler_Bmomparison",
-        "Mamper_ppomarison",
-        "samper_compOOrison",
+        "sampver",
+        "EESSmplr",
+        "smplr",
+        "samplecomp_risa",
+        "sampler_co_prwwson",
+        "samplerdd99omparison",
         "sampler_comparison",
-        "sampler_compGrGGon",
-        "sHHm11ler_comparison",
-        "sa6ler_FFeemparison",
-        "texure_1",
-        "tKiilure_1d",
-        "exture_1d",
+        "ampler_o99paPPison",
+        "saplerKKcomparison",
+        "saMpler_oomDDarison",
+        "teiie_1B",
+        "txureq1d",
+        "txt00rLL_d",
         "texture_1d",
-        "99etvIIre_1d",
-        "texture_d",
-        "texture_hd",
-        "llxzzure_PPd",
-        "exue2d",
-        "tffqqtre_2d",
+        "tnxture_16vv",
+        "trrxtur_nd",
+        "xxture_eed",
+        "CCNOxture_2d",
+        "txture_2d",
+        "tex4uae_2d",
         "texture_2d",
-        "texturJdd_d",
-        "trXXtu_2zz",
-        "textu2e2d",
-        "tNyyture_2d_array",
-        "txture_2d_rOOa",
-        "textureErduaZPay",
+        "extuNNe_2NN",
+        "texture2d",
+        "tuxtre2d",
+        "teYYtuAe_2d_arESy",
+        "texture_2d_0rray",
+        "texture_2d_aarray",
         "texture_2d_array",
-        "exl22re_2dd_areeay",
-        "mextureVV_ar9ay",
-        "teIItu1_2d_array",
-        "tebture_3d",
-        "ie7ure3d",
-        "teotiire_3d",
+        "texturmm_2d_arra",
+        "texture_2d_aray",
+        "teEuUUe_2darray",
+        "tKKture_Dd",
+        "text__r0_3d",
+        "tAtuel3p",
         "texture_3d",
-        "extre_35",
-        "textre_iS",
-        "t22xtur_3",
-        "teC711recuGe",
-        "texture8cffbe",
-        "textue_cue",
+        "textue_3d",
+        "texturBB_3d",
+        "nnbb99re_3d",
+        "AAEExture_cub",
+        "t66Ttu5e_cube",
+        "textuHe_cube",
         "texture_cube",
-        "texture_SSJJbe",
-        "textrecu9e",
-        "TTeJJbture_cube",
-        "t66ture_cube_aray",
-        "textur66_cubu_arra",
-        "textureWubeyarray",
+        "textrexxHcub",
+        "tzx0uryy_cnbe",
+        "texture_cue",
+        "texurH_kube_array",
+        "exture_cube_array",
+        "ooexrrre_cbe_array",
         "texture_cube_array",
-        "texture_cube_ara",
-        "texture_ube_array",
-        "rexture_cube_array",
-        "tex2ure_depth_2B",
-        "texture_dpBBh_2d",
-        "texture_dpth_RRd",
+        "textre_cubJJarray",
+        "tCCxtu0e_cube_arry",
+        "texturAAcxbe99aFray",
+        "textcre_depth_2d",
+        "texture_Septh_2d",
+        "textureodpthBB2d",
         "texture_depth_2d",
-        "tLL0Vure_deth_2d",
-        "tetKKredOOpth_2d",
-        "textgwre_dpth_2d",
-        "textue_depthLh2d_arpay",
-        "texture_depEh2diiKrray",
-        "texture_dept_2d_array",
+        "texture_dept_2d",
+        "textummedepth_2d",
+        "toxture_ggeQQtPP2d",
+        "tetur_dptB_2d_rray",
+        "texNure_deKKh2d_arrlly",
+        "teture_dpth_2d_arrray",
         "texture_depth_2d_array",
-        "t88xtuUUe_deph_2d_rray",
-        "texrruvve_depth_2d_array",
-        "texture_depmm_2d_wray",
-        "tjture_d44pth_cube",
-        "texture_depth_cXbe",
-        "t8xture_depth_cube",
+        "texture_epth_ppd_array",
+        "teyturPP_depth_2d_array",
+        "texture_ZZptcc_2d_arry",
+        "txtue_depth_cube",
+        "texture00depth_cube",
+        "texPPuBB_deJth_cusse",
         "texture_depth_cube",
-        "textur_devvth_cubEE",
-        "tzxturi99epth_cube",
-        "teQQtuJJGe_nepth_cuAe",
-        "texture_depth_cusse_array",
-        "texture_Pepth_cKbe_array",
-        "texture_dppp_cube_attray",
+        "texJJre_dffpwwh_fube",
+        "textIre_depXXh_cub",
+        "textur_ph_cue",
+        "textue_depth_cube_array",
+        "tKKxtue_depth_cube_array",
+        "teture_d44ptm_cube_adray",
         "texture_depth_cube_array",
-        "exture_deth_cube_array",
-        "texture_depth_MMube_array",
-        "tJJxture_depth_cube_a0ray",
-        "textu8_dpth_mulisampled_2V",
-        "texture_dhhpth_mKltisggmpled_2d",
-        "texture_depth_multisampledf2d",
+        "pexture_deoth_cube_array",
+        "thhHxtureNdepth_cubejarray",
+        "texwwuUUe_depthEc33be_array",
+        "texture_dept_multiuuampled_2",
+        "ddextKre_depth_ultisampcerr_2d",
+        "textuPPe_depr_multttsample2_2d",
         "texture_depth_multisampled_2d",
-        "te77ture_depth_multisamQled_2d",
-        "teture_depthYYmultisampled_2d",
-        "texture_deptk_multiampled_Sd",
-        "txturn_ext2rnal",
-        "txture_FFternal",
-        "texUPPIre_GGxuernal",
+        "1exture_depth_wwsltisampled_2d",
+        "textuce_depth_mnnltisamp11ed_2d",
+        "texture_depth_multisapled_2d",
+        "texture_externl",
+        "teSS66ue_exaaeInal",
+        "textuEEe_extenal",
         "texture_external",
-        "taxtuvEE_externl",
-        "textureexBddernDDl",
-        "tEEMtur_e55tccrnal",
-        "texturemuKKtisample_d",
-        "texture_multisRmpled_2d",
-        "texturemulDisampl9d_2d",
+        "ccexture_exVerIRl",
+        "te9tue_extrnal",
+        "taaxture_exterha",
+        "texture_multisamLLeS_2d",
+        "tefurmm_mutisampled_2d",
+        "texture_mul4isampld_qV",
         "texture_multisampled_2d",
-        "teture_multisampled_2d",
-        "textuIa_multisampld_2d",
-        "texture_multisamp77ed_2d",
-        "texIure_storage_1d",
-        "texture_storagedd",
-        "texture_storae_1d",
+        "texture_multisa_pled_d",
+        "texure_multisampledQd",
+        "texRRuremultisampledEd2d",
+        "textur_st9rage_1d",
+        "tCCx0ure_strag_1",
+        "textuezstorae_1d",
         "texture_storage_1d",
-        "texture_strate_d",
-        "texture33stoXXcge_1d",
-        "texturestorage_1E",
-        "textuXXestorage_2d",
-        "texture_stoBaxxe_2d",
-        "texte_storWge_2G",
+        "texccure_storage_1d",
+        "textureOQQ_orge_1d",
+        "teturettstrage_1d",
+        "textCCrepzzstEr33ge_2d",
+        "textudde_storaghh_2d",
+        "_etur77_66torage_2d",
         "texture_storage_2d",
-        "texture_s66orage_2d",
-        "textvTr_so0age_2d",
-        "textureorgek2d",
-        "textppre_stoae_2d_array",
-        "textre_stora11e_d_array",
-        "textureystorBEgeJ2d_array",
+        "texture_storaPe_2d",
+        "twxture_storage_2d",
+        "textur_straguu_2",
+        "textureXXstorage_6d_array",
+        "extuRRestorage_2d_aray",
+        "txtre_storage_2dVVarr1",
         "texture_storage_2d_array",
-        "texture_mtorage_2dxIqrray",
-        "teture_storageF2d_array",
-        "textur_Ytorage_2d_array",
-        "heDture_sHHorage_3d",
-        "texturstorage23H",
-        "teture_strage_3d",
+        "GGexture_storHHge_2d_array",
+        "MFFxt7re_storage_2d_array",
+        "texture_storage_d_array",
+        "3xTugge_stoage_3d",
+        "texturP_QtKKrag1__d",
+        "textre_storageE3d",
         "texture_storage_3d",
-        "texture_storage_d",
-        "texturestorage_3d",
-        "ddexture_storage_3d",
-        "uPO",
-        "ba",
-        "u02",
+        "tMture_storage_d",
+        "t77xture_sGGorSSe_3d",
+        "txtttre_storage_3FF",
+        "uZZss2",
+        "u2",
+        "u3l",
         "u32",
-        "h32",
-        "gYY",
-        "O32",
-        "eh",
-        "ppfe2",
-        "vev",
+        "u3h",
+        "uTT",
+        "ww2",
+        "vKvjj",
+        "vYY",
+        "EcI2",
         "vec2",
-        "vzz2",
-        "vc2",
-        "OOii",
-        "vGc2f",
-        "22ecTTf",
-        "dlc2f",
+        "vecQQ",
+        "Pc",
+        "veffH",
+        "vec2n",
+        "g6F2f",
+        "vssh8f",
         "vec2f",
-        "vecbf",
-        "ec2BB",
-        "IIScXPP",
-        "jjec2h",
-        "cc_c2h",
-        "zz6xx2h",
+        "veFllf",
+        "00e2j",
+        "gec2f",
+        "vece",
+        "ffc2h",
+        "ve",
         "vec2h",
-        "c2",
-        "4xx2N",
-        "p0AAeh",
-        "vey2",
-        "vbWW0i",
-        "meMMtti",
+        "ve2h",
+        "vqc2h",
+        "AAe",
+        "ec2i",
+        "vec2j",
+        "ZZec2i",
         "vec2i",
-        "di",
-        "vvc_",
-        "VEEc2i",
-        "vec24",
-        "VVeX2u",
-        "veVou",
+        "PPecII2",
+        "ZZec2i",
+        "vnnc2i",
+        "HekkZ222",
+        "ec2",
+        "RcNQQ",
         "vec2u",
-        "ve2u",
-        "ecKKt",
-        "eG",
-        "ea3",
-        "OOc",
-        "G",
+        "eDu",
+        "s3c2cu",
+        "vRR2u",
+        "vlJJ3",
+        "MM",
+        "vT63",
         "vec3",
-        "ve53",
-        "9fjec3",
-        "vvXcRY",
-        "ccf",
-        "v8XX5",
-        "ec3",
+        "QQec3",
+        "vuA",
+        "e3",
+        "yeq3",
+        "vec3xx",
+        "crr",
         "vec3f",
-        "ppc3cc",
-        "vecvf",
-        "eEE3SS",
-        "vec",
-        "eh",
-        "ec3ww",
+        "v99cf",
+        "vecf",
+        "ecHl",
+        "e_h",
+        "uec3",
+        "vc3h",
         "vec3h",
-        "vecd99h",
-        "ve99P",
-        "KKec3",
-        "ooMcDD",
-        "vei",
-        "vqi",
+        "EEtmec3h",
+        "vec",
+        "ec3rr",
+        "xc3i",
+        "vezz",
+        "vec3e",
         "vec3i",
-        "veL30",
-        "vncvv66",
-        "vrrn3",
-        "vxxce",
-        "NCCOc3u",
-        "vc3u",
+        "uc3Zp",
+        "00uc7TT",
+        "vvJJ",
+        "vecQu",
+        "ve3R",
+        "e",
         "vec3u",
-        "aec4u",
-        "NNc3NN",
-        "ve3u",
-        "vc",
-        "vAYS4",
-        "vec0",
+        "veprPP",
+        "xxeDD88u",
+        "lldmYYqqu",
+        "FFec4",
+        "rGecNN",
+        "Mecl",
         "vec4",
-        "vecaa",
-        "mmcq",
-        "vc4",
-        "vE4U",
-        "veKD4",
-        "v0t4__",
+        "c",
+        "qxl4",
+        "ve4",
+        "ae44f",
+        "vec4WW",
+        "vecjj",
         "vec4f",
-        "cpA",
-        "ec4f",
-        "vBBc4f",
-        "vbnn99",
-        "EEcAAh",
-        "v5c66h",
+        "vjjc4f",
+        "vj1f",
+        "vc4f",
+        "vec499",
+        "vyVV4h",
+        "ec4xZ",
         "vec4h",
-        "vHc4h",
-        "vecxh",
-        "vzyn40",
-        "ve4i",
-        "kH4i",
-        "veci",
+        "v33vvh",
+        "vecs9",
+        "veF4",
+        "uec4i",
+        "eIKK",
+        "ve4J",
         "vec4i",
-        "oo4rr",
-        "JJc4",
-        "vcCC0",
-        "xAA99F",
-        "veccu",
-        "vec4S",
+        "vSSCCXXi",
+        "JecWW6ZZ",
+        "ecd5",
+        "vBBcBU",
+        "JJ0c411",
+        "vecttu",
         "vec4u",
-        "vocBB",
-        "ec4u",
-        "veemm",
+        "vttc",
+        "veL4u",
+        "v1c4u",
     };
     for (auto _ : state) {
         for (auto* str : kStrings) {
@@ -528,7 +710,7 @@
             benchmark::DoNotOptimize(result);
         }
     }
-}
+}  // NOLINT(readability/fn_size)
 
 BENCHMARK(BuiltinParser);
 
diff --git a/src/tint/builtin/builtin_test.cc b/src/tint/builtin/builtin_test.cc
index 9ff8d99..ab8c4c6 100644
--- a/src/tint/builtin/builtin_test.cc
+++ b/src/tint/builtin/builtin_test.cc
@@ -43,6 +43,32 @@
 }
 
 static constexpr Case kValidCases[] = {
+    {"__atomic_compare_exchange_result_i32", Builtin::kAtomicCompareExchangeResultI32},
+    {"__atomic_compare_exchange_result_u32", Builtin::kAtomicCompareExchangeResultU32},
+    {"__frexp_result_abstract", Builtin::kFrexpResultAbstract},
+    {"__frexp_result_f16", Builtin::kFrexpResultF16},
+    {"__frexp_result_f32", Builtin::kFrexpResultF32},
+    {"__frexp_result_vec2_abstract", Builtin::kFrexpResultVec2Abstract},
+    {"__frexp_result_vec2_f16", Builtin::kFrexpResultVec2F16},
+    {"__frexp_result_vec2_f32", Builtin::kFrexpResultVec2F32},
+    {"__frexp_result_vec3_abstract", Builtin::kFrexpResultVec3Abstract},
+    {"__frexp_result_vec3_f16", Builtin::kFrexpResultVec3F16},
+    {"__frexp_result_vec3_f32", Builtin::kFrexpResultVec3F32},
+    {"__frexp_result_vec4_abstract", Builtin::kFrexpResultVec4Abstract},
+    {"__frexp_result_vec4_f16", Builtin::kFrexpResultVec4F16},
+    {"__frexp_result_vec4_f32", Builtin::kFrexpResultVec4F32},
+    {"__modf_result_abstract", Builtin::kModfResultAbstract},
+    {"__modf_result_f16", Builtin::kModfResultF16},
+    {"__modf_result_f32", Builtin::kModfResultF32},
+    {"__modf_result_vec2_abstract", Builtin::kModfResultVec2Abstract},
+    {"__modf_result_vec2_f16", Builtin::kModfResultVec2F16},
+    {"__modf_result_vec2_f32", Builtin::kModfResultVec2F32},
+    {"__modf_result_vec3_abstract", Builtin::kModfResultVec3Abstract},
+    {"__modf_result_vec3_f16", Builtin::kModfResultVec3F16},
+    {"__modf_result_vec3_f32", Builtin::kModfResultVec3F32},
+    {"__modf_result_vec4_abstract", Builtin::kModfResultVec4Abstract},
+    {"__modf_result_vec4_f16", Builtin::kModfResultVec4F16},
+    {"__modf_result_vec4_f32", Builtin::kModfResultVec4F32},
     {"__packed_vec3", Builtin::kPackedVec3},
     {"array", Builtin::kArray},
     {"atomic", Builtin::kAtomic},
@@ -116,216 +142,294 @@
 };
 
 static constexpr Case kInvalidCases[] = {
-    {"__acked_veccc", Builtin::kUndefined},
-    {"_pac3ed_v3", Builtin::kUndefined},
-    {"__packeV_vec3", Builtin::kUndefined},
-    {"arra1", Builtin::kUndefined},
-    {"qqrJy", Builtin::kUndefined},
-    {"arrll7y", Builtin::kUndefined},
-    {"atppmHHc", Builtin::kUndefined},
-    {"cto", Builtin::kUndefined},
-    {"abGmi", Builtin::kUndefined},
-    {"bovii", Builtin::kUndefined},
-    {"boWWl", Builtin::kUndefined},
-    {"Mxxl", Builtin::kUndefined},
-    {"fgg", Builtin::kUndefined},
-    {"X", Builtin::kUndefined},
-    {"316", Builtin::kUndefined},
-    {"fE2", Builtin::kUndefined},
-    {"fPTT", Builtin::kUndefined},
-    {"dxx2", Builtin::kUndefined},
-    {"4432", Builtin::kUndefined},
-    {"iSVV2", Builtin::kUndefined},
-    {"RR2", Builtin::kUndefined},
-    {"at292", Builtin::kUndefined},
-    {"mat2x", Builtin::kUndefined},
-    {"Vat2OR2", Builtin::kUndefined},
-    {"ma2xyf", Builtin::kUndefined},
-    {"llnarr2772f", Builtin::kUndefined},
-    {"mat24200", Builtin::kUndefined},
-    {"a2ooh", Builtin::kUndefined},
-    {"zz2x2h", Builtin::kUndefined},
-    {"miitppx1", Builtin::kUndefined},
-    {"maXX2x3", Builtin::kUndefined},
-    {"55IIt2nn99", Builtin::kUndefined},
-    {"aHHrrt2xSS", Builtin::kUndefined},
-    {"makkf", Builtin::kUndefined},
-    {"jatgRx", Builtin::kUndefined},
-    {"mb2x3", Builtin::kUndefined},
-    {"mat2xjh", Builtin::kUndefined},
-    {"at2x3h", Builtin::kUndefined},
-    {"q2x3h", Builtin::kUndefined},
-    {"mNN2x4", Builtin::kUndefined},
-    {"mavv4", Builtin::kUndefined},
-    {"maQQx4", Builtin::kUndefined},
-    {"maffxr", Builtin::kUndefined},
-    {"mat2xjf", Builtin::kUndefined},
-    {"mNNw2x48", Builtin::kUndefined},
-    {"matx4h", Builtin::kUndefined},
-    {"mrrt2x4h", Builtin::kUndefined},
-    {"Gat2x4h", Builtin::kUndefined},
-    {"matFFx2", Builtin::kUndefined},
-    {"mtx", Builtin::kUndefined},
-    {"mrrt3x", Builtin::kUndefined},
+    {"__atomic_compareexchangeccresult_i32", Builtin::kUndefined},
+    {"__atoml3_compare_exchane_resulti2", Builtin::kUndefined},
+    {"__atomic_compare_Vxchange_result_i32", Builtin::kUndefined},
+    {"__atomic_com1are_exchange_result_u32", Builtin::kUndefined},
+    {"__atomic_qqompare_exchage_resulJ_u32", Builtin::kUndefined},
+    {"__atllmic_compare_exchange_result_u377", Builtin::kUndefined},
+    {"qpp_frexp_resultHHbstract", Builtin::kUndefined},
+    {"__fep_esulv_abstract", Builtin::kUndefined},
+    {"__Gbexp_resul_abstract", Builtin::kUndefined},
+    {"_vfrexp_resiilt_f16", Builtin::kUndefined},
+    {"__fr8xp_resultWWf16", Builtin::kUndefined},
+    {"__frxp_result_fMxx", Builtin::kUndefined},
+    {"gg_fXexp_reslt_f32", Builtin::kUndefined},
+    {"__frXxpresul_V32", Builtin::kUndefined},
+    {"__frexp_r3sult_f32", Builtin::kUndefined},
+    {"__frexpEresult_vec2_abstract", Builtin::kUndefined},
+    {"__frex_rPPsult_vTTc2_abstract", Builtin::kUndefined},
+    {"__frexp_resuddt_ec2_xxbstract", Builtin::kUndefined},
+    {"__frexp_result_ve442_f16", Builtin::kUndefined},
+    {"_SSfrexp_resulVV_vec2_f16", Builtin::kUndefined},
+    {"__fRxpRr22sult_vec2_f16", Builtin::kUndefined},
+    {"__frexp_res9lt_vec_fF2", Builtin::kUndefined},
+    {"__frexp_result_ve2_f32", Builtin::kUndefined},
+    {"_OOfrexp_result_VeHRRf32", Builtin::kUndefined},
+    {"__frexp_reyult_vec3_absract", Builtin::kUndefined},
+    {"__frexp_re77ulll_vecG_arrnstract", Builtin::kUndefined},
+    {"__4rexp_result_vec3_00bstract", Builtin::kUndefined},
+    {"__oorxp_result_vec316", Builtin::kUndefined},
+    {"zz_frexp_esult_ec3_f16", Builtin::kUndefined},
+    {"__iirex11_result_vp3_f16", Builtin::kUndefined},
+    {"__frXXxp_result_vec3_f32", Builtin::kUndefined},
+    {"__fnnexp99resIIlt_vec3_f355", Builtin::kUndefined},
+    {"__faSSerrp_result_vHHc3_fY2", Builtin::kUndefined},
+    {"__freHp_resutve4_abstkkact", Builtin::kUndefined},
+    {"jfrexpgresult_veRR4_abstrac", Builtin::kUndefined},
+    {"__frexp_resul_vec4_absbrac", Builtin::kUndefined},
+    {"_jfrexp_result_vec4_f16", Builtin::kUndefined},
+    {"__frexp_resultvec4_f16", Builtin::kUndefined},
+    {"__freqpresultvec4_f16", Builtin::kUndefined},
+    {"__frexNN_result_vec_f32", Builtin::kUndefined},
+    {"__frexp_resvvlt_vc4_f3", Builtin::kUndefined},
+    {"__frexp_esult_vec4_f3QQ", Builtin::kUndefined},
+    {"rmodf_reffultabstract", Builtin::kUndefined},
+    {"__jodf_result_abstract", Builtin::kUndefined},
+    {"_mNNwdf_r2sult8abstract", Builtin::kUndefined},
+    {"__mdf_result_f16", Builtin::kUndefined},
+    {"__modrr_result_f16", Builtin::kUndefined},
+    {"__mGdf_result_f16", Builtin::kUndefined},
+    {"__modf_resulFF_f32", Builtin::kUndefined},
+    {"__modf_eult_E3", Builtin::kUndefined},
+    {"__odf_resurrt_f32", Builtin::kUndefined},
+    {"__modf_reslt_vec_abstract", Builtin::kUndefined},
+    {"__modfJJresuDt_Xc2_abstract", Builtin::kUndefined},
+    {"_modf_reslt_vec28abstrct", Builtin::kUndefined},
+    {"__odf_reult_vkc211f1", Builtin::kUndefined},
+    {"__mdf_result_vec2_f16", Builtin::kUndefined},
+    {"__modf_resuJt_vec2_f6", Builtin::kUndefined},
+    {"__modf_result_vec2cf32", Builtin::kUndefined},
+    {"__modf_result_vec2_fO2", Builtin::kUndefined},
+    {"KK_movvf_result_vec2_ftt__", Builtin::kUndefined},
+    {"xx_modf_r8sult_vec3_abtr5ct", Builtin::kUndefined},
+    {"__modf_resuFt_vec3_aqt__act", Builtin::kUndefined},
+    {"__modf_result_vec3_aqqstrac", Builtin::kUndefined},
+    {"__odf_33esult_vec3_f1O6", Builtin::kUndefined},
+    {"_ttm6df_resQQlt_ooec9_f16", Builtin::kUndefined},
+    {"_modf_resu66t_vec3_f16", Builtin::kUndefined},
+    {"__mdf_resultOvxc3_f36zz", Builtin::kUndefined},
+    {"__modf_resuyyt_vec3_f32", Builtin::kUndefined},
+    {"__mod_resul_vecZHHf32", Builtin::kUndefined},
+    {"__modf_reqult_44ec4WWbstract", Builtin::kUndefined},
+    {"__mof_result_vec4_abstrOOct", Builtin::kUndefined},
+    {"__modYooresult_vh4_bstract", Builtin::kUndefined},
+    {"__modf_relt_ve4_f16", Builtin::kUndefined},
+    {"__modf_result_ve4Ff16", Builtin::kUndefined},
+    {"__modf_result_wec4_f1", Builtin::kUndefined},
+    {"__Kdff_rGsult_vec4_f2", Builtin::kUndefined},
+    {"__modf_reKKulq_vec4_f32", Builtin::kUndefined},
+    {"__modf_resummt3vec4_f3F", Builtin::kUndefined},
+    {"__packed_ec3", Builtin::kUndefined},
+    {"__packed_ecq", Builtin::kUndefined},
+    {"_backed_bbec3", Builtin::kUndefined},
+    {"iira", Builtin::kUndefined},
+    {"aqOOy", Builtin::kUndefined},
+    {"arvvTTy", Builtin::kUndefined},
+    {"atomFFc", Builtin::kUndefined},
+    {"aoQ00P", Builtin::kUndefined},
+    {"atPmic", Builtin::kUndefined},
+    {"bos77", Builtin::kUndefined},
+    {"CoRbbl", Builtin::kUndefined},
+    {"booXX", Builtin::kUndefined},
+    {"qOOO6", Builtin::kUndefined},
+    {"fs", Builtin::kUndefined},
+    {"f1X", Builtin::kUndefined},
+    {"f3", Builtin::kUndefined},
+    {"q", Builtin::kUndefined},
+    {"f322", Builtin::kUndefined},
+    {"0yz2", Builtin::kUndefined},
+    {"iVP", Builtin::kUndefined},
+    {"Cnn", Builtin::kUndefined},
+    {"AtqqHH2", Builtin::kUndefined},
+    {"at2x2", Builtin::kUndefined},
+    {"mafKK", Builtin::kUndefined},
+    {"ltgg2f", Builtin::kUndefined},
+    {"mat2xf", Builtin::kUndefined},
+    {"NTTtcx4f", Builtin::kUndefined},
+    {"ma7ppl2h", Builtin::kUndefined},
+    {"mNNt2xg", Builtin::kUndefined},
+    {"uub2XX2h", Builtin::kUndefined},
+    {"mt2x3", Builtin::kUndefined},
+    {"m88xK", Builtin::kUndefined},
+    {"maqx3", Builtin::kUndefined},
+    {"m11t2x3f", Builtin::kUndefined},
+    {"22at2iif", Builtin::kUndefined},
+    {"at2x377", Builtin::kUndefined},
+    {"m2t2xNh", Builtin::kUndefined},
+    {"mVVt2x3h", Builtin::kUndefined},
+    {"FaWW2w11h", Builtin::kUndefined},
+    {"matww4", Builtin::kUndefined},
+    {"mat2D4", Builtin::kUndefined},
+    {"maKx4", Builtin::kUndefined},
+    {"mat21PPhf", Builtin::kUndefined},
+    {"mat24f", Builtin::kUndefined},
+    {"mYYt2x4f", Builtin::kUndefined},
+    {"mttHH4kk", Builtin::kUndefined},
+    {"mat2rr4h", Builtin::kUndefined},
+    {"WWas2x4h", Builtin::kUndefined},
+    {"maYx2", Builtin::kUndefined},
+    {"mq3f2", Builtin::kUndefined},
+    {"vvafu222", Builtin::kUndefined},
     {"t3x2f", Builtin::kUndefined},
-    {"Da3xJJf", Builtin::kUndefined},
-    {"ma82", Builtin::kUndefined},
-    {"m11k2", Builtin::kUndefined},
-    {"matx2h", Builtin::kUndefined},
-    {"maJx2h", Builtin::kUndefined},
-    {"cat3x3", Builtin::kUndefined},
-    {"mat3O3", Builtin::kUndefined},
-    {"ttKavv3x__", Builtin::kUndefined},
-    {"xx83x3f", Builtin::kUndefined},
-    {"__qatF3", Builtin::kUndefined},
-    {"matqx3f", Builtin::kUndefined},
-    {"33atOx3h", Builtin::kUndefined},
-    {"mtt63x9oQQ", Builtin::kUndefined},
-    {"ma3x66h", Builtin::kUndefined},
-    {"66aOzx4", Builtin::kUndefined},
-    {"myyt3x4", Builtin::kUndefined},
-    {"HHZx4", Builtin::kUndefined},
-    {"4WWt3q4f", Builtin::kUndefined},
-    {"mOO3x4f", Builtin::kUndefined},
-    {"oatY4f", Builtin::kUndefined},
-    {"matx", Builtin::kUndefined},
-    {"ma3xFh", Builtin::kUndefined},
-    {"at3x4w", Builtin::kUndefined},
-    {"ma4Gf", Builtin::kUndefined},
-    {"qatKKx2", Builtin::kUndefined},
-    {"mmmt4x2", Builtin::kUndefined},
-    {"at4x2f", Builtin::kUndefined},
-    {"mt4x2q", Builtin::kUndefined},
-    {"mat4xbb", Builtin::kUndefined},
-    {"mi4x2h", Builtin::kUndefined},
-    {"maOO4xq", Builtin::kUndefined},
-    {"matTvvx2h", Builtin::kUndefined},
-    {"mat4FF3", Builtin::kUndefined},
-    {"mtQ00P", Builtin::kUndefined},
-    {"maP4x3", Builtin::kUndefined},
-    {"ma774xss", Builtin::kUndefined},
-    {"RRCbb4x3f", Builtin::kUndefined},
-    {"mXXt4x3f", Builtin::kUndefined},
-    {"qaCC4xOOh", Builtin::kUndefined},
-    {"ma4s3L", Builtin::kUndefined},
-    {"mXt4x3h", Builtin::kUndefined},
-    {"mat4x", Builtin::kUndefined},
-    {"qqt4", Builtin::kUndefined},
-    {"mat4x22", Builtin::kUndefined},
-    {"myzz40XX", Builtin::kUndefined},
-    {"matVViP", Builtin::kUndefined},
-    {"mannC4f", Builtin::kUndefined},
-    {"atx4AHHq", Builtin::kUndefined},
-    {"may4x4", Builtin::kUndefined},
-    {"aOOOZZh", Builtin::kUndefined},
-    {"V", Builtin::kUndefined},
-    {"ptf__", Builtin::kUndefined},
-    {"4lMT", Builtin::kUndefined},
-    {"sNNmplg", Builtin::kUndefined},
-    {"uubpXXer", Builtin::kUndefined},
-    {"samler", Builtin::kUndefined},
-    {"m88ler_cQmparisoK", Builtin::kUndefined},
-    {"qa9ler_comparison", Builtin::kUndefined},
-    {"sampler_comparis11n", Builtin::kUndefined},
-    {"teiiu22eF1d", Builtin::kUndefined},
-    {"tex77ur_1d", Builtin::kUndefined},
-    {"te2urNN_1d", Builtin::kUndefined},
-    {"texturVV_2d", Builtin::kUndefined},
-    {"WWFxtu11e_wd", Builtin::kUndefined},
-    {"txture_2ww", Builtin::kUndefined},
-    {"texture_2d_arrDy", Builtin::kUndefined},
-    {"teKtre_2d_array", Builtin::kUndefined},
-    {"texhure_2fra11raPP", Builtin::kUndefined},
-    {"texture3d", Builtin::kUndefined},
-    {"texture_3YY", Builtin::kUndefined},
-    {"HHtxtrkk_3d", Builtin::kUndefined},
-    {"texrrure_cube", Builtin::kUndefined},
-    {"tssxturWW_cue", Builtin::kUndefined},
-    {"teYure_cube", Builtin::kUndefined},
-    {"txture_Lufe_arraq", Builtin::kUndefined},
-    {"te22ture_uuubevvfray", Builtin::kUndefined},
-    {"texturecube_aray", Builtin::kUndefined},
-    {"texture_Yepth_2", Builtin::kUndefined},
-    {"teytYYEe_77epth_2d", Builtin::kUndefined},
-    {"teMture_deootd2d", Builtin::kUndefined},
-    {"texMMre_depth_2d_array", Builtin::kUndefined},
-    {"texture_depth_2d_arra55", Builtin::kUndefined},
-    {"texture_deh_2d_aNray", Builtin::kUndefined},
-    {"te3ture_dpth_cO3be", Builtin::kUndefined},
-    {"texture_depth_cub3", Builtin::kUndefined},
-    {"Iexturedepth_cume", Builtin::kUndefined},
-    {"texture_depthnncube_Krrry", Builtin::kUndefined},
-    {"texture_dth_XXube_rra", Builtin::kUndefined},
-    {"textIre_depph_ubeLLarray", Builtin::kUndefined},
-    {"txtfre_depthmultisampled_2d", Builtin::kUndefined},
-    {"texURuYe_Depthmultisampled_2d", Builtin::kUndefined},
-    {"texture_depth_multisamphed_2d", Builtin::kUndefined},
-    {"teqtureuIIextnal", Builtin::kUndefined},
-    {"texture_externaH", Builtin::kUndefined},
-    {"texre_externaQvv", Builtin::kUndefined},
-    {"textureemultismp66ed_d", Builtin::kUndefined},
-    {"tW7trO_multisampled_2d", Builtin::kUndefined},
-    {"texture_mult550ampled_2DD", Builtin::kUndefined},
-    {"teHture_storIIge_1d", Builtin::kUndefined},
-    {"textue_storage_1d", Builtin::kUndefined},
-    {"rexture_storae_1d", Builtin::kUndefined},
-    {"texture_stolage_2d", Builtin::kUndefined},
-    {"txture_JJtGrgtt_2d", Builtin::kUndefined},
-    {"yexture_storage2d", Builtin::kUndefined},
-    {"texture_storage_2d_rray", Builtin::kUndefined},
-    {"texture_IItorage_2d_BBrray", Builtin::kUndefined},
-    {"33exture_TTtorge_Kd_ar88ay", Builtin::kUndefined},
-    {"texSnnYUUure_storage_3d", Builtin::kUndefined},
-    {"textuxe_5torCCdZ_3d", Builtin::kUndefined},
-    {"tkkxture_storaqe_3d", Builtin::kUndefined},
-    {"5i00", Builtin::kUndefined},
-    {"unII2", Builtin::kUndefined},
-    {"cc", Builtin::kUndefined},
-    {"KK", Builtin::kUndefined},
-    {"66ec2", Builtin::kUndefined},
-    {"PPEK", Builtin::kUndefined},
-    {"vexxf", Builtin::kUndefined},
-    {"qec2f", Builtin::kUndefined},
-    {"veSyMMr", Builtin::kUndefined},
-    {"v2u", Builtin::kUndefined},
-    {"ec", Builtin::kUndefined},
-    {"5eFF2h", Builtin::kUndefined},
-    {"rrecz44", Builtin::kUndefined},
-    {"vWW", Builtin::kUndefined},
-    {"XJecCZZ", Builtin::kUndefined},
-    {"vePP2", Builtin::kUndefined},
-    {"vec2c", Builtin::kUndefined},
-    {"ve6ll2u", Builtin::kUndefined},
-    {"vey99", Builtin::kUndefined},
-    {"vKKc3", Builtin::kUndefined},
-    {"x_3", Builtin::kUndefined},
-    {"Ky3", Builtin::kUndefined},
-    {"zek3f", Builtin::kUndefined},
-    {"veKSf", Builtin::kUndefined},
-    {"vc3h", Builtin::kUndefined},
-    {"ec3VV", Builtin::kUndefined},
-    {"IAAc3h", Builtin::kUndefined},
-    {"jbR", Builtin::kUndefined},
-    {"veY4", Builtin::kUndefined},
-    {"ec3i", Builtin::kUndefined},
-    {"vc911", Builtin::kUndefined},
-    {"mmccu", Builtin::kUndefined},
-    {"vJJcu", Builtin::kUndefined},
-    {"lDCfcU", Builtin::kUndefined},
-    {"veg4", Builtin::kUndefined},
-    {"CC", Builtin::kUndefined},
-    {"ec4f", Builtin::kUndefined},
-    {"vIc__f", Builtin::kUndefined},
-    {"ePPtt", Builtin::kUndefined},
-    {"v3dc4h", Builtin::kUndefined},
-    {"vcyyh", Builtin::kUndefined},
-    {"u4", Builtin::kUndefined},
-    {"v03nni", Builtin::kUndefined},
-    {"Cuuecnv", Builtin::kUndefined},
-    {"vX4ll", Builtin::kUndefined},
-    {"vocppu", Builtin::kUndefined},
-    {"vwwc4", Builtin::kUndefined},
-    {"veuug", Builtin::kUndefined},
+    {"YYat3f", Builtin::kUndefined},
+    {"may3x2EYY", Builtin::kUndefined},
+    {"da3xMoh", Builtin::kUndefined},
+    {"matMMx2", Builtin::kUndefined},
+    {"mat3x55h", Builtin::kUndefined},
+    {"maN3", Builtin::kUndefined},
+    {"ma33x3", Builtin::kUndefined},
+    {"mt3x3", Builtin::kUndefined},
+    {"mm66Issf", Builtin::kUndefined},
+    {"mat3x1f", Builtin::kUndefined},
+    {"Xt3x3", Builtin::kUndefined},
+    {"LatIx3h", Builtin::kUndefined},
+    {"at3fh", Builtin::kUndefined},
+    {"mYtURD3", Builtin::kUndefined},
+    {"mah3x4", Builtin::kUndefined},
+    {"muqII4", Builtin::kUndefined},
+    {"mat3xH", Builtin::kUndefined},
+    {"at3QQvv", Builtin::kUndefined},
+    {"at66ef", Builtin::kUndefined},
+    {"ma7O4f", Builtin::kUndefined},
+    {"m55t3x0DD", Builtin::kUndefined},
+    {"maH3x4II", Builtin::kUndefined},
+    {"at3x4", Builtin::kUndefined},
+    {"ma994x2", Builtin::kUndefined},
+    {"mWWt4Gt2", Builtin::kUndefined},
+    {"ay42", Builtin::kUndefined},
+    {"mt4x2f", Builtin::kUndefined},
+    {"IIaBB4x2f", Builtin::kUndefined},
+    {"TTat4x833", Builtin::kUndefined},
+    {"ddUUnntYYx2h", Builtin::kUndefined},
+    {"m5CCxxdZ", Builtin::kUndefined},
+    {"matkkq2h", Builtin::kUndefined},
+    {"5iitp00", Builtin::kUndefined},
+    {"mnntIIx3", Builtin::kUndefined},
+    {"ccaKx", Builtin::kUndefined},
+    {"m43KK", Builtin::kUndefined},
+    {"mat66x3f", Builtin::kUndefined},
+    {"Et4PP3K", Builtin::kUndefined},
+    {"xxatx3h", Builtin::kUndefined},
+    {"qat4x3h", Builtin::kUndefined},
+    {"MMayySrxh", Builtin::kUndefined},
+    {"uat4", Builtin::kUndefined},
+    {"tx4", Builtin::kUndefined},
+    {"ma54FF4", Builtin::kUndefined},
+    {"rra444z4f", Builtin::kUndefined},
+    {"matWW", Builtin::kUndefined},
+    {"CatZJXx4f", Builtin::kUndefined},
+    {"maPPx4h", Builtin::kUndefined},
+    {"mat4c4h", Builtin::kUndefined},
+    {"matPPll6h", Builtin::kUndefined},
+    {"9tyy", Builtin::kUndefined},
+    {"ptKK", Builtin::kUndefined},
+    {"x_", Builtin::kUndefined},
+    {"ayKer", Builtin::kUndefined},
+    {"szmpVek", Builtin::kUndefined},
+    {"sampqeK", Builtin::kUndefined},
+    {"sampler_comparisn", Builtin::kUndefined},
+    {"sapler_comparisVVn", Builtin::kUndefined},
+    {"samplerIcompaAUison", Builtin::kUndefined},
+    {"jexurbRd", Builtin::kUndefined},
+    {"exure_YYd", Builtin::kUndefined},
+    {"exture_1d", Builtin::kUndefined},
+    {"texxxur_1d", Builtin::kUndefined},
+    {"tJxucce_2d", Builtin::kUndefined},
+    {"texure_JJd", Builtin::kUndefined},
+    {"lDexture_fCC_arraU", Builtin::kUndefined},
+    {"tegture_2d_array", Builtin::kUndefined},
+    {"teCCure2d_arra", Builtin::kUndefined},
+    {"textue_3d", Builtin::kUndefined},
+    {"tIx__ure_3d", Builtin::kUndefined},
+    {"texurettPP", Builtin::kUndefined},
+    {"tddx3ure_cube", Builtin::kUndefined},
+    {"teKyyur_cube", Builtin::kUndefined},
+    {"teturecub", Builtin::kUndefined},
+    {"textinne_c03e_array", Builtin::kUndefined},
+    {"nextCCruuvcubK_array", Builtin::kUndefined},
+    {"tXxturellcbe_array", Builtin::kUndefined},
+    {"tppxture_depth_2d", Builtin::kUndefined},
+    {"txture_deptww_2d", Builtin::kUndefined},
+    {"gexturedemmthuu2", Builtin::kUndefined},
+    {"texmmre_depthaa2daray", Builtin::kUndefined},
+    {"texture_RRepth_Td_ccZray", Builtin::kUndefined},
+    {"text88re_depthTOd_array", Builtin::kUndefined},
+    {"texture_depth_cm00e", Builtin::kUndefined},
+    {"texture_Bmepth_cube", Builtin::kUndefined},
+    {"Mextre_ppeph_cube", Builtin::kUndefined},
+    {"texturOO_depth_cub_array", Builtin::kUndefined},
+    {"GeGGture_depthcube_array", Builtin::kUndefined},
+    {"texture11Hdepth_cube_array", Builtin::kUndefined},
+    {"textu6e_FFepth_multiameeled_2d", Builtin::kUndefined},
+    {"texture_epth_mltisampled_2d", Builtin::kUndefined},
+    {"texture_depth_mullKsaiipled_2d", Builtin::kUndefined},
+    {"texture_extenal", Builtin::kUndefined},
+    {"IIext99reexvvernal", Builtin::kUndefined},
+    {"texture_externl", Builtin::kUndefined},
+    {"texture_mhltisampled_2d", Builtin::kUndefined},
+    {"texturemPllltisampzzed_2d", Builtin::kUndefined},
+    {"exture_mltisamed_2d", Builtin::kUndefined},
+    {"texture_qqtoragff_1", Builtin::kUndefined},
+    {"textre_JJddorage_1W", Builtin::kUndefined},
+    {"XXrxture_storae1zz", Builtin::kUndefined},
+    {"texturestorag2_2d", Builtin::kUndefined},
+    {"yyNxture_storage_2d", Builtin::kUndefined},
+    {"etue_storage_2OO", Builtin::kUndefined},
+    {"reutuPe_storZgeE2d_array", Builtin::kUndefined},
+    {"texlure_storddeee_d_22rray", Builtin::kUndefined},
+    {"texture_mtorage_2V_a9ra", Builtin::kUndefined},
+    {"teII1re_storage_3d", Builtin::kUndefined},
+    {"texture_storagb_3d", Builtin::kUndefined},
+    {"texizrestorge73d", Builtin::kUndefined},
+    {"u3oi", Builtin::kUndefined},
+    {"3", Builtin::kUndefined},
+    {"S2", Builtin::kUndefined},
+    {"e22", Builtin::kUndefined},
+    {"1eC2", Builtin::kUndefined},
+    {"vf8c2", Builtin::kUndefined},
+    {"c2f", Builtin::kUndefined},
+    {"JJecSSf", Builtin::kUndefined},
+    {"92f", Builtin::kUndefined},
+    {"vbbJJ2TT", Builtin::kUndefined},
+    {"e66h", Builtin::kUndefined},
+    {"u662h", Builtin::kUndefined},
+    {"vW2i", Builtin::kUndefined},
+    {"v2i", Builtin::kUndefined},
+    {"veci", Builtin::kUndefined},
+    {"rec2u", Builtin::kUndefined},
+    {"2ec2B", Builtin::kUndefined},
+    {"vcBBu", Builtin::kUndefined},
+    {"veRR", Builtin::kUndefined},
+    {"VLL0", Builtin::kUndefined},
+    {"KOe3", Builtin::kUndefined},
+    {"vgwcf", Builtin::kUndefined},
+    {"vLphf", Builtin::kUndefined},
+    {"eiiEf", Builtin::kUndefined},
+    {"ec3h", Builtin::kUndefined},
+    {"UU883", Builtin::kUndefined},
+    {"rrecvvh", Builtin::kUndefined},
+    {"ecmm", Builtin::kUndefined},
+    {"vec4j", Builtin::kUndefined},
+    {"vec3X", Builtin::kUndefined},
+    {"vec38", Builtin::kUndefined},
+    {"vecvEE", Builtin::kUndefined},
+    {"z99ci", Builtin::kUndefined},
+    {"JJGeQQ4", Builtin::kUndefined},
+    {"ssec4", Builtin::kUndefined},
+    {"PecK", Builtin::kUndefined},
+    {"tpc4f", Builtin::kUndefined},
+    {"vec", Builtin::kUndefined},
+    {"MMec4f", Builtin::kUndefined},
+    {"vJJc40", Builtin::kUndefined},
+    {"8c", Builtin::kUndefined},
+    {"vecggKh", Builtin::kUndefined},
+    {"vecfi", Builtin::kUndefined},
+    {"vec47Q", Builtin::kUndefined},
+    {"veY4i", Builtin::kUndefined},
+    {"keSu", Builtin::kUndefined},
+    {"n422", Builtin::kUndefined},
+    {"vFFu", Builtin::kUndefined},
 };
 
 using BuiltinParseTest = testing::TestWithParam<Case>;
diff --git a/src/tint/builtin/builtin_value_bench.cc b/src/tint/builtin/builtin_value_bench.cc
index 4d2e562..28c01ac 100644
--- a/src/tint/builtin/builtin_value_bench.cc
+++ b/src/tint/builtin/builtin_value_bench.cc
@@ -129,7 +129,7 @@
             benchmark::DoNotOptimize(result);
         }
     }
-}
+}  // NOLINT(readability/fn_size)
 
 BENCHMARK(BuiltinValueParser);
 
diff --git a/src/tint/builtin/diagnostic_rule_bench.cc b/src/tint/builtin/diagnostic_rule_bench.cc
index fb60580..efa6977 100644
--- a/src/tint/builtin/diagnostic_rule_bench.cc
+++ b/src/tint/builtin/diagnostic_rule_bench.cc
@@ -41,7 +41,7 @@
             benchmark::DoNotOptimize(result);
         }
     }
-}
+}  // NOLINT(readability/fn_size)
 
 BENCHMARK(CoreDiagnosticRuleParser);
 
@@ -56,7 +56,7 @@
             benchmark::DoNotOptimize(result);
         }
     }
-}
+}  // NOLINT(readability/fn_size)
 
 BENCHMARK(ChromiumDiagnosticRuleParser);
 
diff --git a/src/tint/builtin/diagnostic_severity_bench.cc b/src/tint/builtin/diagnostic_severity_bench.cc
index 13c3ff1..35fe046 100644
--- a/src/tint/builtin/diagnostic_severity_bench.cc
+++ b/src/tint/builtin/diagnostic_severity_bench.cc
@@ -42,7 +42,7 @@
             benchmark::DoNotOptimize(result);
         }
     }
-}
+}  // NOLINT(readability/fn_size)
 
 BENCHMARK(DiagnosticSeverityParser);
 
diff --git a/src/tint/builtin/extension_bench.cc b/src/tint/builtin/extension_bench.cc
index b3e410e..7a50281 100644
--- a/src/tint/builtin/extension_bench.cc
+++ b/src/tint/builtin/extension_bench.cc
@@ -80,7 +80,7 @@
             benchmark::DoNotOptimize(result);
         }
     }
-}
+}  // NOLINT(readability/fn_size)
 
 BENCHMARK(ExtensionParser);
 
diff --git a/src/tint/builtin/interpolation.h b/src/tint/builtin/interpolation.h
new file mode 100644
index 0000000..ad73c30
--- /dev/null
+++ b/src/tint/builtin/interpolation.h
@@ -0,0 +1,33 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_BUILTIN_INTERPOLATION_H_
+#define SRC_TINT_BUILTIN_INTERPOLATION_H_
+
+#include "src/tint/builtin/interpolation_sampling.h"
+#include "src/tint/builtin/interpolation_type.h"
+
+namespace tint::builtin {
+
+/// The values of an `@interpolate` attribute
+struct Interpolation {
+    /// The first argument of a `@interpolate` attribute
+    builtin::InterpolationType type = builtin::InterpolationType::kUndefined;
+    /// The second argument of a `@interpolate` attribute
+    builtin::InterpolationSampling sampling = builtin::InterpolationSampling::kUndefined;
+};
+
+}  // namespace tint::builtin
+
+#endif  // SRC_TINT_BUILTIN_INTERPOLATION_H_
diff --git a/src/tint/builtin/interpolation_sampling_bench.cc b/src/tint/builtin/interpolation_sampling_bench.cc
index 4fb7e09..deb4de0 100644
--- a/src/tint/builtin/interpolation_sampling_bench.cc
+++ b/src/tint/builtin/interpolation_sampling_bench.cc
@@ -40,7 +40,7 @@
             benchmark::DoNotOptimize(result);
         }
     }
-}
+}  // NOLINT(readability/fn_size)
 
 BENCHMARK(InterpolationSamplingParser);
 
diff --git a/src/tint/builtin/interpolation_type_bench.cc b/src/tint/builtin/interpolation_type_bench.cc
index 5098f26..70b5961 100644
--- a/src/tint/builtin/interpolation_type_bench.cc
+++ b/src/tint/builtin/interpolation_type_bench.cc
@@ -43,7 +43,7 @@
             benchmark::DoNotOptimize(result);
         }
     }
-}
+}  // NOLINT(readability/fn_size)
 
 BENCHMARK(InterpolationTypeParser);
 
diff --git a/src/tint/builtin/texel_format_bench.cc b/src/tint/builtin/texel_format_bench.cc
index 5d202ea..0773b9a 100644
--- a/src/tint/builtin/texel_format_bench.cc
+++ b/src/tint/builtin/texel_format_bench.cc
@@ -62,7 +62,7 @@
             benchmark::DoNotOptimize(result);
         }
     }
-}
+}  // NOLINT(readability/fn_size)
 
 BENCHMARK(TexelFormatParser);
 
diff --git a/src/tint/cmd/loopy.cc b/src/tint/cmd/loopy.cc
index 1714e3b..75102eb 100644
--- a/src/tint/cmd/loopy.cc
+++ b/src/tint/cmd/loopy.cc
@@ -19,6 +19,7 @@
 #include "tint/tint.h"
 
 #if TINT_BUILD_IR
+#include "src/tint/ir/converter.h"
 #include "src/tint/ir/module.h"
 #endif  // TINT_BUILD_IR
 
@@ -377,7 +378,7 @@
             loop_count = options.loop_count;
         }
         for (uint32_t i = 0; i < loop_count; ++i) {
-            auto result = tint::ir::Module::FromProgram(program.get());
+            auto result = tint::ir::Converter::FromProgram(program.get());
             if (!result) {
                 std::cerr << "Failed to build IR from program: " << result.Failure() << std::endl;
             }
diff --git a/src/tint/cmd/main.cc b/src/tint/cmd/main.cc
index d61ae24..c8260f1 100644
--- a/src/tint/cmd/main.cc
+++ b/src/tint/cmd/main.cc
@@ -49,10 +49,11 @@
 #include "tint/tint.h"
 
 #if TINT_BUILD_IR
-#include "src/tint/ir/debug.h"
-#include "src/tint/ir/disassembler.h"
-#include "src/tint/ir/module.h"
-#endif  // TINT_BUILD_IR
+#include "src/tint/ir/converter.h"     // nogncheck
+#include "src/tint/ir/debug.h"         // nogncheck
+#include "src/tint/ir/disassembler.h"  // nogncheck
+#include "src/tint/ir/module.h"        // nogncheck
+#endif                                 // TINT_BUILD_IR
 
 namespace {
 
@@ -1078,7 +1079,7 @@
 
 #if TINT_BUILD_IR
     if (options.dump_ir || options.dump_ir_graph) {
-        auto result = tint::ir::Module::FromProgram(program.get());
+        auto result = tint::ir::Converter::FromProgram(program.get());
         if (!result) {
             std::cerr << "Failed to build IR from program: " << result.Failure() << std::endl;
         } else {
diff --git a/src/tint/inspector/inspector.cc b/src/tint/inspector/inspector.cc
index 246943d..adafe3a 100644
--- a/src/tint/inspector/inspector.cc
+++ b/src/tint/inspector/inspector.cc
@@ -621,8 +621,8 @@
         // Recurse into members.
         for (auto* member : struct_ty->Members()) {
             AddEntryPointInOutVariables(name + "." + member->Name().Name(), member->Type(),
-                                        member->Declaration()->attributes, member->Location(),
-                                        variables);
+                                        member->Declaration()->attributes,
+                                        member->Attributes().location, variables);
         }
         return;
     }
diff --git a/src/tint/intrinsics.def b/src/tint/intrinsics.def
index ee4b517..0d667ab 100644
--- a/src/tint/intrinsics.def
+++ b/src/tint/intrinsics.def
@@ -218,6 +218,32 @@
 
   // Internal types.
   __packed_vec3
+  __atomic_compare_exchange_result_i32
+  __atomic_compare_exchange_result_u32
+  __frexp_result_abstract
+  __frexp_result_f16
+  __frexp_result_f32
+  __frexp_result_vec2_abstract
+  __frexp_result_vec2_f16
+  __frexp_result_vec2_f32
+  __frexp_result_vec3_abstract
+  __frexp_result_vec3_f16
+  __frexp_result_vec3_f32
+  __frexp_result_vec4_abstract
+  __frexp_result_vec4_f16
+  __frexp_result_vec4_f32
+  __modf_result_abstract
+  __modf_result_f16
+  __modf_result_f32
+  __modf_result_vec2_abstract
+  __modf_result_vec2_f16
+  __modf_result_vec2_f32
+  __modf_result_vec3_abstract
+  __modf_result_vec3_f16
+  __modf_result_vec3_f32
+  __modf_result_vec4_abstract
+  __modf_result_vec4_f16
+  __modf_result_vec4_f32
 }
 
 // https://gpuweb.github.io/gpuweb/wgsl/#attributes
diff --git a/src/tint/ir/binary.cc b/src/tint/ir/binary.cc
index 6cbf742..d3e3548 100644
--- a/src/tint/ir/binary.cc
+++ b/src/tint/ir/binary.cc
@@ -19,8 +19,8 @@
 
 namespace tint::ir {
 
-Binary::Binary(Kind kind, Value* result, Value* lhs, Value* rhs)
-    : Base(result), kind_(kind), lhs_(lhs), rhs_(rhs) {
+Binary::Binary(uint32_t id, Kind kind, const type::Type* ty, Value* lhs, Value* rhs)
+    : Base(id, ty), kind_(kind), lhs_(lhs), rhs_(rhs) {
     TINT_ASSERT(IR, lhs_);
     TINT_ASSERT(IR, rhs_);
     lhs_->AddUsage(this);
@@ -29,69 +29,68 @@
 
 Binary::~Binary() = default;
 
-utils::StringStream& Binary::ToString(utils::StringStream& out) const {
-    Result()->ToString(out) << " = ";
-    lhs_->ToString(out) << " ";
+utils::StringStream& Binary::ToInstruction(utils::StringStream& out) const {
+    ToValue(out) << " = ";
 
     switch (GetKind()) {
         case Binary::Kind::kAdd:
-            out << "+";
+            out << "add";
             break;
         case Binary::Kind::kSubtract:
-            out << "-";
+            out << "sub";
             break;
         case Binary::Kind::kMultiply:
-            out << "*";
+            out << "mul";
             break;
         case Binary::Kind::kDivide:
-            out << "/";
+            out << "div";
             break;
         case Binary::Kind::kModulo:
-            out << "%";
+            out << "mod";
             break;
         case Binary::Kind::kAnd:
-            out << "&";
+            out << "bit_and";
             break;
         case Binary::Kind::kOr:
-            out << "|";
+            out << "bit_or";
             break;
         case Binary::Kind::kXor:
-            out << "^";
+            out << "bit_xor";
             break;
         case Binary::Kind::kLogicalAnd:
-            out << "&&";
+            out << "log_and";
             break;
         case Binary::Kind::kLogicalOr:
-            out << "||";
+            out << "log_or";
             break;
         case Binary::Kind::kEqual:
-            out << "==";
+            out << "eq";
             break;
         case Binary::Kind::kNotEqual:
-            out << "!=";
+            out << "neq";
             break;
         case Binary::Kind::kLessThan:
-            out << "<";
+            out << "lt";
             break;
         case Binary::Kind::kGreaterThan:
-            out << ">";
+            out << "gt";
             break;
         case Binary::Kind::kLessThanEqual:
-            out << "<=";
+            out << "lte";
             break;
         case Binary::Kind::kGreaterThanEqual:
-            out << ">=";
+            out << "gte";
             break;
         case Binary::Kind::kShiftLeft:
-            out << "<<";
+            out << "shiftl";
             break;
         case Binary::Kind::kShiftRight:
-            out << ">>";
+            out << "shiftr";
             break;
     }
     out << " ";
-    rhs_->ToString(out);
-
+    lhs_->ToValue(out) << ", ";
+    rhs_->ToValue(out);
     return out;
 }
 
diff --git a/src/tint/ir/binary.h b/src/tint/ir/binary.h
index 400e381..92a1998 100644
--- a/src/tint/ir/binary.h
+++ b/src/tint/ir/binary.h
@@ -51,17 +51,18 @@
     };
 
     /// Constructor
+    /// @param id the instruction id
     /// @param kind the kind of binary instruction
-    /// @param result the result value
+    /// @param type the result type
     /// @param lhs the lhs of the instruction
     /// @param rhs the rhs of the instruction
-    Binary(Kind kind, Value* result, Value* lhs, Value* rhs);
-    Binary(const Binary& instr) = delete;
-    Binary(Binary&& instr) = delete;
+    Binary(uint32_t id, Kind kind, const type::Type* type, Value* lhs, Value* rhs);
+    Binary(const Binary& inst) = delete;
+    Binary(Binary&& inst) = delete;
     ~Binary() override;
 
-    Binary& operator=(const Binary& instr) = delete;
-    Binary& operator=(Binary&& instr) = delete;
+    Binary& operator=(const Binary& inst) = delete;
+    Binary& operator=(Binary&& inst) = delete;
 
     /// @returns the kind of instruction
     Kind GetKind() const { return kind_; }
@@ -75,7 +76,7 @@
     /// Write the instruction to the given stream
     /// @param out the stream to write to
     /// @returns the stream
-    utils::StringStream& ToString(utils::StringStream& out) const override;
+    utils::StringStream& ToInstruction(utils::StringStream& out) const override;
 
   private:
     Kind kind_;
diff --git a/src/tint/ir/binary_test.cc b/src/tint/ir/binary_test.cc
index 6be82f9..e03a61d 100644
--- a/src/tint/ir/binary_test.cc
+++ b/src/tint/ir/binary_test.cc
@@ -20,537 +20,469 @@
 namespace {
 
 using namespace tint::number_suffixes;  // NOLINT
-                                        //
+
 using IR_InstructionTest = TestHelper;
 
 TEST_F(IR_InstructionTest, CreateAnd) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.And(b.builder.ir.types.Get<type::I32>(), b.builder.Constant(4_i),
-                                      b.builder.Constant(2_i));
+    const auto* inst = b.builder.And(b.builder.ir.types.Get<type::I32>(), b.builder.Constant(4_i),
+                                     b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kAnd);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kAnd);
+    ASSERT_NE(inst->Type(), nullptr);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    ASSERT_NE(instr->Result()->Type(), nullptr);
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (i32) = 4 & 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(i32) = bit_and 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, CreateOr) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.Or(b.builder.ir.types.Get<type::I32>(), b.builder.Constant(4_i),
-                                     b.builder.Constant(2_i));
+    const auto* inst = b.builder.Or(b.builder.ir.types.Get<type::I32>(), b.builder.Constant(4_i),
+                                    b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kOr);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kOr);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (i32) = 4 | 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(i32) = bit_or 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, CreateXor) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.Xor(b.builder.ir.types.Get<type::I32>(), b.builder.Constant(4_i),
-                                      b.builder.Constant(2_i));
+    const auto* inst = b.builder.Xor(b.builder.ir.types.Get<type::I32>(), b.builder.Constant(4_i),
+                                     b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kXor);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kXor);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (i32) = 4 ^ 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(i32) = bit_xor 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, CreateLogicalAnd) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.LogicalAnd(b.builder.ir.types.Get<type::Bool>(),
-                                             b.builder.Constant(4_i), b.builder.Constant(2_i));
+    const auto* inst = b.builder.LogicalAnd(b.builder.ir.types.Get<type::Bool>(),
+                                            b.builder.Constant(4_i), b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kLogicalAnd);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kLogicalAnd);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (bool) = 4 && 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(bool) = log_and 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, CreateLogicalOr) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.LogicalOr(b.builder.ir.types.Get<type::Bool>(),
-                                            b.builder.Constant(4_i), b.builder.Constant(2_i));
+    const auto* inst = b.builder.LogicalOr(b.builder.ir.types.Get<type::Bool>(),
+                                           b.builder.Constant(4_i), b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kLogicalOr);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kLogicalOr);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (bool) = 4 || 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(bool) = log_or 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, CreateEqual) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.Equal(b.builder.ir.types.Get<type::Bool>(),
-                                        b.builder.Constant(4_i), b.builder.Constant(2_i));
+    const auto* inst = b.builder.Equal(b.builder.ir.types.Get<type::Bool>(),
+                                       b.builder.Constant(4_i), b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kEqual);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kEqual);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (bool) = 4 == 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(bool) = eq 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, CreateNotEqual) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.NotEqual(b.builder.ir.types.Get<type::Bool>(),
-                                           b.builder.Constant(4_i), b.builder.Constant(2_i));
+    const auto* inst = b.builder.NotEqual(b.builder.ir.types.Get<type::Bool>(),
+                                          b.builder.Constant(4_i), b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kNotEqual);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kNotEqual);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (bool) = 4 != 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(bool) = neq 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, CreateLessThan) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.LessThan(b.builder.ir.types.Get<type::Bool>(),
-                                           b.builder.Constant(4_i), b.builder.Constant(2_i));
+    const auto* inst = b.builder.LessThan(b.builder.ir.types.Get<type::Bool>(),
+                                          b.builder.Constant(4_i), b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kLessThan);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kLessThan);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (bool) = 4 < 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(bool) = lt 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, CreateGreaterThan) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.GreaterThan(b.builder.ir.types.Get<type::Bool>(),
-                                              b.builder.Constant(4_i), b.builder.Constant(2_i));
+    const auto* inst = b.builder.GreaterThan(b.builder.ir.types.Get<type::Bool>(),
+                                             b.builder.Constant(4_i), b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kGreaterThan);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kGreaterThan);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (bool) = 4 > 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(bool) = gt 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, CreateLessThanEqual) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.LessThanEqual(b.builder.ir.types.Get<type::Bool>(),
-                                                b.builder.Constant(4_i), b.builder.Constant(2_i));
+    const auto* inst = b.builder.LessThanEqual(b.builder.ir.types.Get<type::Bool>(),
+                                               b.builder.Constant(4_i), b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kLessThanEqual);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kLessThanEqual);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (bool) = 4 <= 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(bool) = lte 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, CreateGreaterThanEqual) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.GreaterThanEqual(
-        b.builder.ir.types.Get<type::Bool>(), b.builder.Constant(4_i), b.builder.Constant(2_i));
+    const auto* inst = b.builder.GreaterThanEqual(b.builder.ir.types.Get<type::Bool>(),
+                                                  b.builder.Constant(4_i), b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kGreaterThanEqual);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kGreaterThanEqual);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (bool) = 4 >= 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(bool) = gte 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, CreateShiftLeft) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.ShiftLeft(b.builder.ir.types.Get<type::I32>(),
-                                            b.builder.Constant(4_i), b.builder.Constant(2_i));
+    const auto* inst = b.builder.ShiftLeft(b.builder.ir.types.Get<type::I32>(),
+                                           b.builder.Constant(4_i), b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kShiftLeft);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kShiftLeft);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (i32) = 4 << 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(i32) = shiftl 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, CreateShiftRight) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.ShiftRight(b.builder.ir.types.Get<type::I32>(),
-                                             b.builder.Constant(4_i), b.builder.Constant(2_i));
+    const auto* inst = b.builder.ShiftRight(b.builder.ir.types.Get<type::I32>(),
+                                            b.builder.Constant(4_i), b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kShiftRight);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kShiftRight);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (i32) = 4 >> 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(i32) = shiftr 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, CreateAdd) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.Add(b.builder.ir.types.Get<type::I32>(), b.builder.Constant(4_i),
-                                      b.builder.Constant(2_i));
+    const auto* inst = b.builder.Add(b.builder.ir.types.Get<type::I32>(), b.builder.Constant(4_i),
+                                     b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kAdd);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kAdd);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (i32) = 4 + 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(i32) = add 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, CreateSubtract) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.Subtract(b.builder.ir.types.Get<type::I32>(),
-                                           b.builder.Constant(4_i), b.builder.Constant(2_i));
+    const auto* inst = b.builder.Subtract(b.builder.ir.types.Get<type::I32>(),
+                                          b.builder.Constant(4_i), b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kSubtract);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kSubtract);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (i32) = 4 - 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(i32) = sub 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, CreateMultiply) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.Multiply(b.builder.ir.types.Get<type::I32>(),
-                                           b.builder.Constant(4_i), b.builder.Constant(2_i));
+    const auto* inst = b.builder.Multiply(b.builder.ir.types.Get<type::I32>(),
+                                          b.builder.Constant(4_i), b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kMultiply);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kMultiply);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (i32) = 4 * 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(i32) = mul 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, CreateDivide) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.Divide(b.builder.ir.types.Get<type::I32>(),
-                                         b.builder.Constant(4_i), b.builder.Constant(2_i));
+    const auto* inst = b.builder.Divide(b.builder.ir.types.Get<type::I32>(),
+                                        b.builder.Constant(4_i), b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kDivide);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kDivide);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (i32) = 4 / 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(i32) = div 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, CreateModulo) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.Modulo(b.builder.ir.types.Get<type::I32>(),
-                                         b.builder.Constant(4_i), b.builder.Constant(2_i));
+    const auto* inst = b.builder.Modulo(b.builder.ir.types.Get<type::I32>(),
+                                        b.builder.Constant(4_i), b.builder.Constant(2_i));
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kModulo);
+    ASSERT_TRUE(inst->Is<Binary>());
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kModulo);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->LHS()->Is<Constant>());
-    auto lhs = instr->LHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->LHS()->Is<Constant>());
+    auto lhs = inst->LHS()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    ASSERT_TRUE(instr->RHS()->Is<Constant>());
-    auto rhs = instr->RHS()->As<Constant>()->value;
+    ASSERT_TRUE(inst->RHS()->Is<Constant>());
+    auto rhs = inst->RHS()->As<Constant>()->value;
     ASSERT_TRUE(rhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (i32) = 4 % 2");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(i32) = mod 4i, 2i");
 }
 
 TEST_F(IR_InstructionTest, Binary_Usage) {
     auto& b = CreateEmptyBuilder();
+    const auto* inst = b.builder.And(b.builder.ir.types.Get<type::I32>(), b.builder.Constant(4_i),
+                                     b.builder.Constant(2_i));
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.And(b.builder.ir.types.Get<type::I32>(), b.builder.Constant(4_i),
-                                      b.builder.Constant(2_i));
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kAnd);
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kAnd);
+    ASSERT_NE(inst->LHS(), nullptr);
+    ASSERT_EQ(inst->LHS()->Usage().Length(), 1u);
+    EXPECT_EQ(inst->LHS()->Usage()[0], inst);
 
-    ASSERT_NE(instr->Result(), nullptr);
-    ASSERT_EQ(instr->Result()->Usage().Length(), 1u);
-    EXPECT_EQ(instr->Result()->Usage()[0], instr);
-
-    ASSERT_NE(instr->LHS(), nullptr);
-    ASSERT_EQ(instr->LHS()->Usage().Length(), 1u);
-    EXPECT_EQ(instr->LHS()->Usage()[0], instr);
-
-    ASSERT_NE(instr->RHS(), nullptr);
-    ASSERT_EQ(instr->RHS()->Usage().Length(), 1u);
-    EXPECT_EQ(instr->RHS()->Usage()[0], instr);
+    ASSERT_NE(inst->RHS(), nullptr);
+    ASSERT_EQ(inst->RHS()->Usage().Length(), 1u);
+    EXPECT_EQ(inst->RHS()->Usage()[0], inst);
 }
 
 TEST_F(IR_InstructionTest, Binary_Usage_DuplicateValue) {
     auto& b = CreateEmptyBuilder();
-
     auto val = b.builder.Constant(4_i);
+    const auto* inst = b.builder.And(b.builder.ir.types.Get<type::I32>(), val, val);
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.And(b.builder.ir.types.Get<type::I32>(), val, val);
+    EXPECT_EQ(inst->GetKind(), Binary::Kind::kAnd);
+    ASSERT_EQ(inst->LHS(), inst->RHS());
 
-    EXPECT_EQ(instr->GetKind(), Binary::Kind::kAnd);
-
-    ASSERT_NE(instr->Result(), nullptr);
-    ASSERT_EQ(instr->Result()->Usage().Length(), 1u);
-    EXPECT_EQ(instr->Result()->Usage()[0], instr);
-
-    ASSERT_EQ(instr->LHS(), instr->RHS());
-
-    ASSERT_NE(instr->LHS(), nullptr);
-    ASSERT_EQ(instr->LHS()->Usage().Length(), 1u);
-    EXPECT_EQ(instr->LHS()->Usage()[0], instr);
+    ASSERT_NE(inst->LHS(), nullptr);
+    ASSERT_EQ(inst->LHS()->Usage().Length(), 1u);
+    EXPECT_EQ(inst->LHS()->Usage()[0], inst);
 }
 
 }  // namespace
diff --git a/src/tint/ir/bitcast.cc b/src/tint/ir/bitcast.cc
index 749702e..70f412c 100644
--- a/src/tint/ir/bitcast.cc
+++ b/src/tint/ir/bitcast.cc
@@ -19,18 +19,14 @@
 
 namespace tint::ir {
 
-Bitcast::Bitcast(Value* result, Value* val) : Base(result), val_(val) {
-    TINT_ASSERT(IR, val_);
-    val_->AddUsage(this);
-}
+Bitcast::Bitcast(uint32_t id, const type::Type* type, Value* val)
+    : Base(id, type, utils::Vector{val}) {}
 
 Bitcast::~Bitcast() = default;
 
-utils::StringStream& Bitcast::ToString(utils::StringStream& out) const {
-    Result()->ToString(out);
-    out << " = bitcast(";
-    val_->ToString(out);
-    out << ")";
+utils::StringStream& Bitcast::ToInstruction(utils::StringStream& out) const {
+    ToValue(out) << " = bitcast ";
+    EmitArgs(out);
     return out;
 }
 
diff --git a/src/tint/ir/bitcast.h b/src/tint/ir/bitcast.h
index c7d9cb8..253ea0b 100644
--- a/src/tint/ir/bitcast.h
+++ b/src/tint/ir/bitcast.h
@@ -15,36 +15,31 @@
 #ifndef SRC_TINT_IR_BITCAST_H_
 #define SRC_TINT_IR_BITCAST_H_
 
-#include "src/tint/ir/instruction.h"
+#include "src/tint/ir/call.h"
 #include "src/tint/utils/castable.h"
 #include "src/tint/utils/string_stream.h"
 
 namespace tint::ir {
 
 /// A bitcast instruction in the IR.
-class Bitcast : public utils::Castable<Bitcast, Instruction> {
+class Bitcast : public utils::Castable<Bitcast, Call> {
   public:
     /// Constructor
-    /// @param result the result value
+    /// @param id the instruction id
+    /// @param type the result type
     /// @param val the value being bitcast
-    Bitcast(Value* result, Value* val);
-    Bitcast(const Bitcast& instr) = delete;
-    Bitcast(Bitcast&& instr) = delete;
+    Bitcast(uint32_t id, const type::Type* type, Value* val);
+    Bitcast(const Bitcast& inst) = delete;
+    Bitcast(Bitcast&& inst) = delete;
     ~Bitcast() override;
 
-    Bitcast& operator=(const Bitcast& instr) = delete;
-    Bitcast& operator=(Bitcast&& instr) = delete;
-
-    /// @returns the left-hand-side value for the instruction
-    const Value* Val() const { return val_; }
+    Bitcast& operator=(const Bitcast& inst) = delete;
+    Bitcast& operator=(Bitcast&& inst) = delete;
 
     /// Write the instruction to the given stream
     /// @param out the stream to write to
     /// @returns the stream
-    utils::StringStream& ToString(utils::StringStream& out) const override;
-
-  private:
-    Value* val_ = nullptr;
+    utils::StringStream& ToInstruction(utils::StringStream& out) const override;
 };
 
 }  // namespace tint::ir
diff --git a/src/tint/ir/bitcast_test.cc b/src/tint/ir/bitcast_test.cc
index 2e6ca9d..a70fb92 100644
--- a/src/tint/ir/bitcast_test.cc
+++ b/src/tint/ir/bitcast_test.cc
@@ -20,44 +20,37 @@
 namespace {
 
 using namespace tint::number_suffixes;  // NOLINT
-                                        //
+
 using IR_InstructionTest = TestHelper;
 
 TEST_F(IR_InstructionTest, Bitcast) {
     auto& b = CreateEmptyBuilder();
-
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr =
+    const auto* inst =
         b.builder.Bitcast(b.builder.ir.types.Get<type::I32>(), b.builder.Constant(4_i));
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-    ASSERT_NE(instr->Result()->Type(), nullptr);
+    ASSERT_TRUE(inst->Is<ir::Bitcast>());
+    ASSERT_NE(inst->Type(), nullptr);
 
-    ASSERT_TRUE(instr->Val()->Is<Constant>());
-    auto val = instr->Val()->As<Constant>()->value;
+    ASSERT_EQ(inst->Args().Length(), 1u);
+    ASSERT_TRUE(inst->Args()[0]->Is<Constant>());
+    auto val = inst->Args()[0]->As<Constant>()->value;
     ASSERT_TRUE(val->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, val->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (i32) = bitcast(4)");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(i32) = bitcast 4i");
 }
 
 TEST_F(IR_InstructionTest, Bitcast_Usage) {
     auto& b = CreateEmptyBuilder();
-
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr =
+    const auto* inst =
         b.builder.Bitcast(b.builder.ir.types.Get<type::I32>(), b.builder.Constant(4_i));
 
-    ASSERT_NE(instr->Result(), nullptr);
-    ASSERT_EQ(instr->Result()->Usage().Length(), 1u);
-    EXPECT_EQ(instr->Result()->Usage()[0], instr);
-
-    ASSERT_NE(instr->Val(), nullptr);
-    ASSERT_EQ(instr->Val()->Usage().Length(), 1u);
-    EXPECT_EQ(instr->Val()->Usage()[0], instr);
+    ASSERT_EQ(inst->Args().Length(), 1u);
+    ASSERT_NE(inst->Args()[0], nullptr);
+    ASSERT_EQ(inst->Args()[0]->Usage().Length(), 1u);
+    EXPECT_EQ(inst->Args()[0]->Usage()[0], inst);
 }
 
 }  // namespace
diff --git a/src/tint/ir/block.h b/src/tint/ir/block.h
index e83d43a..3981355 100644
--- a/src/tint/ir/block.h
+++ b/src/tint/ir/block.h
@@ -33,7 +33,7 @@
 
     /// @returns true if this is a dead block. This can happen in the case like a loop merge block
     /// which is never reached.
-    bool IsDead() const { return branch.target == nullptr; }
+    bool IsDead() const override { return branch.target == nullptr; }
 
     /// The node this block branches too.
     Branch branch = {};
diff --git a/src/tint/ir/builder.cc b/src/tint/ir/builder.cc
index 13ef345..2c97737 100644
--- a/src/tint/ir/builder.cc
+++ b/src/tint/ir/builder.cc
@@ -16,8 +16,6 @@
 
 #include <utility>
 
-#include "src/tint/ir/builder_impl.h"
-
 namespace tint::ir {
 
 Builder::Builder() {}
@@ -26,6 +24,17 @@
 
 Builder::~Builder() = default;
 
+ir::Block* Builder::CreateRootBlockIfNeeded() {
+    if (!ir.root_block) {
+        ir.root_block = CreateBlock();
+
+        // Everything in the module scope must have been const-eval's, so everything will go into a
+        // single block. So, we can create the terminator for the root-block now.
+        ir.root_block->branch.target = CreateTerminator();
+    }
+    return ir.root_block;
+}
+
 Block* Builder::CreateBlock() {
     return ir.flow_nodes.Create<Block>();
 }
@@ -93,12 +102,8 @@
     to->inbound_branches.Push(from);
 }
 
-Runtime::Id Builder::AllocateRuntimeId() {
-    return next_runtime_id++;
-}
-
 Binary* Builder::CreateBinary(Binary::Kind kind, const type::Type* type, Value* lhs, Value* rhs) {
-    return ir.instructions.Create<ir::Binary>(kind, Runtime(type), lhs, rhs);
+    return ir.instructions.Create<ir::Binary>(next_inst_id(), kind, type, lhs, rhs);
 }
 
 Binary* Builder::And(const type::Type* type, Value* lhs, Value* rhs) {
@@ -174,7 +179,7 @@
 }
 
 Unary* Builder::CreateUnary(Unary::Kind kind, const type::Type* type, Value* val) {
-    return ir.instructions.Create<ir::Unary>(kind, Runtime(type), val);
+    return ir.instructions.Create<ir::Unary>(next_inst_id(), kind, type, val);
 }
 
 Unary* Builder::AddressOf(const type::Type* type, Value* val) {
@@ -198,37 +203,43 @@
 }
 
 ir::Bitcast* Builder::Bitcast(const type::Type* type, Value* val) {
-    return ir.instructions.Create<ir::Bitcast>(Runtime(type), val);
+    return ir.instructions.Create<ir::Bitcast>(next_inst_id(), type, val);
 }
 
 ir::Discard* Builder::Discard() {
-    return ir.instructions.Create<ir::Discard>(Runtime(ir.types.Get<type::Void>()));
+    return ir.instructions.Create<ir::Discard>();
 }
 
 ir::UserCall* Builder::UserCall(const type::Type* type,
                                 Symbol name,
                                 utils::VectorRef<Value*> args) {
-    return ir.instructions.Create<ir::UserCall>(Runtime(type), name, std::move(args));
+    return ir.instructions.Create<ir::UserCall>(next_inst_id(), type, name, std::move(args));
 }
 
 ir::Convert* Builder::Convert(const type::Type* to,
                               const type::Type* from,
                               utils::VectorRef<Value*> args) {
-    return ir.instructions.Create<ir::Convert>(Runtime(to), from, std::move(args));
+    return ir.instructions.Create<ir::Convert>(next_inst_id(), to, from, std::move(args));
 }
 
 ir::Construct* Builder::Construct(const type::Type* to, utils::VectorRef<Value*> args) {
-    return ir.instructions.Create<ir::Construct>(Runtime(to), std::move(args));
+    return ir.instructions.Create<ir::Construct>(next_inst_id(), to, std::move(args));
 }
 
 ir::Builtin* Builder::Builtin(const type::Type* type,
                               builtin::Function func,
                               utils::VectorRef<Value*> args) {
-    return ir.instructions.Create<ir::Builtin>(Runtime(type), func, args);
+    return ir.instructions.Create<ir::Builtin>(next_inst_id(), type, func, args);
 }
 
 ir::Store* Builder::Store(Value* to, Value* from) {
     return ir.instructions.Create<ir::Store>(to, from);
 }
 
+ir::Var* Builder::Declare(const type::Type* type,
+                          builtin::AddressSpace address_space,
+                          builtin::Access access) {
+    return ir.instructions.Create<ir::Var>(next_inst_id(), type, address_space, access);
+}
+
 }  // namespace tint::ir
diff --git a/src/tint/ir/builder.h b/src/tint/ir/builder.h
index 3fc78d2..d509c06 100644
--- a/src/tint/ir/builder.h
+++ b/src/tint/ir/builder.h
@@ -29,13 +29,13 @@
 #include "src/tint/ir/if.h"
 #include "src/tint/ir/loop.h"
 #include "src/tint/ir/module.h"
-#include "src/tint/ir/runtime.h"
 #include "src/tint/ir/store.h"
 #include "src/tint/ir/switch.h"
 #include "src/tint/ir/terminator.h"
 #include "src/tint/ir/unary.h"
 #include "src/tint/ir/user_call.h"
 #include "src/tint/ir/value.h"
+#include "src/tint/ir/var.h"
 #include "src/tint/type/bool.h"
 #include "src/tint/type/f16.h"
 #include "src/tint/type/f32.h"
@@ -141,13 +141,6 @@
         return Constant(create<constant::Scalar<bool>>(ir.types.Get<type::Bool>(), v));
     }
 
-    /// Creates a new Runtime value
-    /// @param type the type of the temporary
-    /// @returns the new temporary
-    ir::Runtime* Runtime(const type::Type* type) {
-        return ir.values.Create<ir::Runtime>(type, AllocateRuntimeId());
-    }
-
     /// Creates an op for `lhs kind rhs`
     /// @param kind the kind of operation
     /// @param type the result type of the binary expression
@@ -366,14 +359,26 @@
     /// @returns the instruction
     ir::Store* Store(Value* to, Value* from);
 
-    /// @returns a unique runtime id
-    Runtime::Id AllocateRuntimeId();
+    /// Creates a new `var` declaration
+    /// @param type the var type
+    /// @param address_space the address space
+    /// @param access the access mode
+    /// @returns the instruction
+    ir::Var* Declare(const type::Type* type,
+                     builtin::AddressSpace address_space,
+                     builtin::Access access);
+
+    /// Retrieves the root block for the module, creating if necessary
+    /// @returns the root block
+    ir::Block* CreateRootBlockIfNeeded();
 
     /// The IR module.
     Module ir;
 
-    /// The next temporary number to allocate
-    Runtime::Id next_runtime_id = 1;
+  private:
+    uint32_t next_inst_id() { return next_instruction_id_++; }
+
+    uint32_t next_instruction_id_ = 1;
 };
 
 }  // namespace tint::ir
diff --git a/src/tint/ir/builder_impl.cc b/src/tint/ir/builder_impl.cc
index 1f0f79a..19caf6f 100644
--- a/src/tint/ir/builder_impl.cc
+++ b/src/tint/ir/builder_impl.cc
@@ -39,6 +39,7 @@
 #include "src/tint/ast/identifier_expression.h"
 #include "src/tint/ast/if_statement.h"
 #include "src/tint/ast/int_literal_expression.h"
+#include "src/tint/ast/let.h"
 #include "src/tint/ast/literal_expression.h"
 #include "src/tint/ast/loop_statement.h"
 #include "src/tint/ast/override.h"
@@ -50,6 +51,7 @@
 #include "src/tint/ast/switch_statement.h"
 #include "src/tint/ast/templated_identifier.h"
 #include "src/tint/ast/unary_op_expression.h"
+#include "src/tint/ast/var.h"
 #include "src/tint/ast/variable_decl_statement.h"
 #include "src/tint/ast/while_statement.h"
 #include "src/tint/ir/function.h"
@@ -69,8 +71,10 @@
 #include "src/tint/sem/value_constructor.h"
 #include "src/tint/sem/value_conversion.h"
 #include "src/tint/sem/value_expression.h"
+#include "src/tint/sem/variable.h"
 #include "src/tint/switch.h"
 #include "src/tint/type/void.h"
+#include "src/tint/utils/scoped_assignment.h"
 
 namespace tint::ir {
 namespace {
@@ -169,10 +173,13 @@
             [&](const ast::Alias*) {
                 // Folded away and doesn't appear in the IR.
             },
-            // [&](const ast::Variable* var) {
-            // TODO(dsinclair): Implement
-            // },
-            [&](const ast::Function* func) { return EmitFunction(func); },
+            [&](const ast::Variable* var) {
+                // Setup the current flow node to be the root block for the module. The builder will
+                // handle creating it if it doesn't exist already.
+                TINT_SCOPED_ASSIGNMENT(current_flow_block, builder.CreateRootBlockIfNeeded());
+                EmitVariable(var);
+            },
+            [&](const ast::Function* func) { EmitFunction(func); },
             // [&](const ast::Enable*) {
             // TODO(dsinclair): Implement? I think these need to be passed along so further stages
             // know what is enabled.
@@ -291,69 +298,69 @@
     }
 
     auto* ty = lhs.Get()->Type();
-    Binary* instr = nullptr;
+    Binary* inst = nullptr;
     switch (stmt->op) {
         case ast::BinaryOp::kAnd:
-            instr = builder.And(ty, lhs.Get(), rhs.Get());
+            inst = builder.And(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kOr:
-            instr = builder.Or(ty, lhs.Get(), rhs.Get());
+            inst = builder.Or(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kXor:
-            instr = builder.Xor(ty, lhs.Get(), rhs.Get());
+            inst = builder.Xor(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kLogicalAnd:
-            instr = builder.LogicalAnd(ty, lhs.Get(), rhs.Get());
+            inst = builder.LogicalAnd(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kLogicalOr:
-            instr = builder.LogicalOr(ty, lhs.Get(), rhs.Get());
+            inst = builder.LogicalOr(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kEqual:
-            instr = builder.Equal(ty, lhs.Get(), rhs.Get());
+            inst = builder.Equal(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kNotEqual:
-            instr = builder.NotEqual(ty, lhs.Get(), rhs.Get());
+            inst = builder.NotEqual(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kLessThan:
-            instr = builder.LessThan(ty, lhs.Get(), rhs.Get());
+            inst = builder.LessThan(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kGreaterThan:
-            instr = builder.GreaterThan(ty, lhs.Get(), rhs.Get());
+            inst = builder.GreaterThan(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kLessThanEqual:
-            instr = builder.LessThanEqual(ty, lhs.Get(), rhs.Get());
+            inst = builder.LessThanEqual(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kGreaterThanEqual:
-            instr = builder.GreaterThanEqual(ty, lhs.Get(), rhs.Get());
+            inst = builder.GreaterThanEqual(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kShiftLeft:
-            instr = builder.ShiftLeft(ty, lhs.Get(), rhs.Get());
+            inst = builder.ShiftLeft(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kShiftRight:
-            instr = builder.ShiftRight(ty, lhs.Get(), rhs.Get());
+            inst = builder.ShiftRight(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kAdd:
-            instr = builder.Add(ty, lhs.Get(), rhs.Get());
+            inst = builder.Add(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kSubtract:
-            instr = builder.Subtract(ty, lhs.Get(), rhs.Get());
+            inst = builder.Subtract(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kMultiply:
-            instr = builder.Multiply(ty, lhs.Get(), rhs.Get());
+            inst = builder.Multiply(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kDivide:
-            instr = builder.Divide(ty, lhs.Get(), rhs.Get());
+            inst = builder.Divide(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kModulo:
-            instr = builder.Modulo(ty, lhs.Get(), rhs.Get());
+            inst = builder.Modulo(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kNone:
             TINT_ICE(IR, diagnostics_) << "missing binary operand type";
             return;
     }
-    current_flow_block->instructions.Push(instr);
+    current_flow_block->instructions.Push(inst);
 
-    auto store = builder.Store(lhs.Get(), instr->Result());
+    auto store = builder.Store(lhs.Get(), inst);
     current_flow_block->instructions.Push(store);
 }
 
@@ -430,8 +437,8 @@
         BranchToIfNeeded(loop_node->start.target);
     }
 
-    // The loop merge can get disconnected if the loop returns directly, or the continuing target
-    // branches, eventually, to the merge, but nothing branched to the continuing target.
+    // The loop merge can get disconnected if the loop returns directly, or the continuing
+    // target branches, eventually, to the merge, but nothing branched to the continuing target.
     current_flow_block = loop_node->merge.target->As<Block>();
     if (!IsConnected(loop_node->merge.target)) {
         current_flow_block = nullptr;
@@ -613,12 +620,12 @@
 }
 
 // Discard is being treated as an instruction. The semantics in WGSL is demote_to_helper, so the
-// code has to continue as before it just predicates writes. If WGSL grows some kind of terminating
-// discard that would probably make sense as a FlowNode but would then require figuring out the
-// multi-level exit that is triggered.
+// code has to continue as before it just predicates writes. If WGSL grows some kind of
+// terminating discard that would probably make sense as a FlowNode but would then require
+// figuring out the multi-level exit that is triggered.
 void BuilderImpl::EmitDiscard(const ast::DiscardStatement*) {
-    auto* instr = builder.Discard();
-    current_flow_block->instructions.Push(instr);
+    auto* inst = builder.Discard();
+    current_flow_block->instructions.Push(inst);
 }
 
 void BuilderImpl::EmitBreakIf(const ast::BreakIfStatement* stmt) {
@@ -655,6 +662,15 @@
 }
 
 utils::Result<Value*> BuilderImpl::EmitExpression(const ast::Expression* expr) {
+    // If this is a value that has been const-eval'd return the result.
+    if (auto* sem = program_->Sem().Get(expr)->As<sem::ValueExpression>()) {
+        if (auto* v = sem->ConstantValue()) {
+            if (auto* cv = v->Clone(clone_ctx_)) {
+                return builder.Constant(cv);
+            }
+        }
+    }
+
     return tint::Switch(
         expr,
         // [&](const ast::IndexAccessorExpression* a) {
@@ -682,14 +698,35 @@
 }
 
 void BuilderImpl::EmitVariable(const ast::Variable* var) {
+    auto* sem = program_->Sem().Get(var);
+
     return tint::Switch(  //
         var,
-        // [&](const ast::Var* var) {
-        // TODO(dsinclair): Implement
-        // },
-        // [&](const ast::Let*) {
-        // TODO(dsinclair): Implement
-        // },
+        [&](const ast::Var* v) {
+            auto* ty = sem->Type()->Clone(clone_ctx_.type_ctx);
+            auto* val = builder.Declare(ty, sem->AddressSpace(), sem->Access());
+            current_flow_block->instructions.Push(val);
+
+            if (v->initializer) {
+                auto init = EmitExpression(v->initializer);
+                if (!init) {
+                    return;
+                }
+
+                auto* store = builder.Store(val, init.Get());
+                current_flow_block->instructions.Push(store);
+            }
+            // TODO(dsinclair): Store the mapping from the var name to the `Declare` value
+        },
+        [&](const ast::Let* l) {
+            // A `let` doesn't exist as a standalone item in the IR, it's just the result of the
+            // initializer.
+            auto init = EmitExpression(l->initializer);
+            if (!init) {
+                return;
+            }
+            // TODO(dsinclair): Store the mapping from the let name to the `init` value
+        },
         [&](const ast::Override*) {
             add_error(var->source,
                       "found an `Override` variable. The SubstituteOverrides "
@@ -701,8 +738,8 @@
             // should never be used.
             //
             // TODO(dsinclair): Probably want to store the const variable somewhere and then in
-            // identifier expression log an error if we ever see a const identifier. Add this when
-            // identifiers and variables are supported.
+            // identifier expression log an error if we ever see a const identifier. Add this
+            // when identifiers and variables are supported.
         },
         [&](Default) {
             add_error(var->source, "unknown variable: " + std::string(var->TypeInfo().name));
@@ -718,27 +755,27 @@
     auto* sem = program_->Sem().Get(expr);
     auto* ty = sem->Type()->Clone(clone_ctx_.type_ctx);
 
-    Unary* instr = nullptr;
+    Unary* inst = nullptr;
     switch (expr->op) {
         case ast::UnaryOp::kAddressOf:
-            instr = builder.AddressOf(ty, val.Get());
+            inst = builder.AddressOf(ty, val.Get());
             break;
         case ast::UnaryOp::kComplement:
-            instr = builder.Complement(ty, val.Get());
+            inst = builder.Complement(ty, val.Get());
             break;
         case ast::UnaryOp::kIndirection:
-            instr = builder.Indirection(ty, val.Get());
+            inst = builder.Indirection(ty, val.Get());
             break;
         case ast::UnaryOp::kNegation:
-            instr = builder.Negation(ty, val.Get());
+            inst = builder.Negation(ty, val.Get());
             break;
         case ast::UnaryOp::kNot:
-            instr = builder.Not(ty, val.Get());
+            inst = builder.Not(ty, val.Get());
             break;
     }
 
-    current_flow_block->instructions.Push(instr);
-    return instr->Result();
+    current_flow_block->instructions.Push(inst);
+    return inst;
 }
 
 utils::Result<Value*> BuilderImpl::EmitBinary(const ast::BinaryExpression* expr) {
@@ -755,69 +792,69 @@
     auto* sem = program_->Sem().Get(expr);
     auto* ty = sem->Type()->Clone(clone_ctx_.type_ctx);
 
-    Binary* instr = nullptr;
+    Binary* inst = nullptr;
     switch (expr->op) {
         case ast::BinaryOp::kAnd:
-            instr = builder.And(ty, lhs.Get(), rhs.Get());
+            inst = builder.And(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kOr:
-            instr = builder.Or(ty, lhs.Get(), rhs.Get());
+            inst = builder.Or(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kXor:
-            instr = builder.Xor(ty, lhs.Get(), rhs.Get());
+            inst = builder.Xor(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kLogicalAnd:
-            instr = builder.LogicalAnd(ty, lhs.Get(), rhs.Get());
+            inst = builder.LogicalAnd(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kLogicalOr:
-            instr = builder.LogicalOr(ty, lhs.Get(), rhs.Get());
+            inst = builder.LogicalOr(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kEqual:
-            instr = builder.Equal(ty, lhs.Get(), rhs.Get());
+            inst = builder.Equal(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kNotEqual:
-            instr = builder.NotEqual(ty, lhs.Get(), rhs.Get());
+            inst = builder.NotEqual(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kLessThan:
-            instr = builder.LessThan(ty, lhs.Get(), rhs.Get());
+            inst = builder.LessThan(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kGreaterThan:
-            instr = builder.GreaterThan(ty, lhs.Get(), rhs.Get());
+            inst = builder.GreaterThan(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kLessThanEqual:
-            instr = builder.LessThanEqual(ty, lhs.Get(), rhs.Get());
+            inst = builder.LessThanEqual(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kGreaterThanEqual:
-            instr = builder.GreaterThanEqual(ty, lhs.Get(), rhs.Get());
+            inst = builder.GreaterThanEqual(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kShiftLeft:
-            instr = builder.ShiftLeft(ty, lhs.Get(), rhs.Get());
+            inst = builder.ShiftLeft(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kShiftRight:
-            instr = builder.ShiftRight(ty, lhs.Get(), rhs.Get());
+            inst = builder.ShiftRight(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kAdd:
-            instr = builder.Add(ty, lhs.Get(), rhs.Get());
+            inst = builder.Add(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kSubtract:
-            instr = builder.Subtract(ty, lhs.Get(), rhs.Get());
+            inst = builder.Subtract(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kMultiply:
-            instr = builder.Multiply(ty, lhs.Get(), rhs.Get());
+            inst = builder.Multiply(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kDivide:
-            instr = builder.Divide(ty, lhs.Get(), rhs.Get());
+            inst = builder.Divide(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kModulo:
-            instr = builder.Modulo(ty, lhs.Get(), rhs.Get());
+            inst = builder.Modulo(ty, lhs.Get(), rhs.Get());
             break;
         case ast::BinaryOp::kNone:
             TINT_ICE(IR, diagnostics_) << "missing binary operand type";
             return utils::Failure;
     }
 
-    current_flow_block->instructions.Push(instr);
-    return instr->Result();
+    current_flow_block->instructions.Push(inst);
+    return inst;
 }
 
 utils::Result<Value*> BuilderImpl::EmitBitcast(const ast::BitcastExpression* expr) {
@@ -828,10 +865,10 @@
 
     auto* sem = program_->Sem().Get(expr);
     auto* ty = sem->Type()->Clone(clone_ctx_.type_ctx);
-    auto* instr = builder.Bitcast(ty, val.Get());
+    auto* inst = builder.Bitcast(ty, val.Get());
 
-    current_flow_block->instructions.Push(instr);
-    return instr->Result();
+    current_flow_block->instructions.Push(inst);
+    return inst;
 }
 
 void BuilderImpl::EmitCall(const ast::CallStatement* stmt) {
@@ -874,29 +911,29 @@
 
     auto* ty = sem->Target()->ReturnType()->Clone(clone_ctx_.type_ctx);
 
-    Instruction* instr = nullptr;
+    Instruction* inst = nullptr;
 
     // If this is a builtin function, emit the specific builtin value
     if (auto* b = sem->Target()->As<sem::Builtin>()) {
-        instr = builder.Builtin(ty, b->Type(), args);
+        inst = builder.Builtin(ty, b->Type(), args);
     } else if (sem->Target()->As<sem::ValueConstructor>()) {
-        instr = builder.Construct(ty, std::move(args));
+        inst = builder.Construct(ty, std::move(args));
     } else if (auto* conv = sem->Target()->As<sem::ValueConversion>()) {
         auto* from = conv->Source()->Clone(clone_ctx_.type_ctx);
-        instr = builder.Convert(ty, from, std::move(args));
+        inst = builder.Convert(ty, from, std::move(args));
     } else if (expr->target->identifier->Is<ast::TemplatedIdentifier>()) {
         TINT_UNIMPLEMENTED(IR, diagnostics_) << "missing templated ident support";
         return utils::Failure;
     } else {
         // Not a builtin and not a templated call, so this is a user function.
         auto name = CloneSymbol(expr->target->identifier->symbol);
-        instr = builder.UserCall(ty, name, std::move(args));
+        inst = builder.UserCall(ty, name, std::move(args));
     }
-    if (instr == nullptr) {
+    if (inst == nullptr) {
         return utils::Failure;
     }
-    current_flow_block->instructions.Push(instr);
-    return instr->Result();
+    current_flow_block->instructions.Push(inst);
+    return inst;
 }
 
 utils::Result<Value*> BuilderImpl::EmitLiteral(const ast::LiteralExpression* lit) {
diff --git a/src/tint/ir/builder_impl_test.cc b/src/tint/ir/builder_impl_test.cc
index cd6bf0b..1e6a26d 100644
--- a/src/tint/ir/builder_impl_test.cc
+++ b/src/tint/ir/builder_impl_test.cc
@@ -42,10 +42,10 @@
     EXPECT_EQ(1u, f->start_target->inbound_branches.Length());
     EXPECT_EQ(1u, f->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function f
-  %bb1 = Block
-  Return ()
-FunctionEnd
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func f
+  %fn1 = block
+  ret
+func_end
 
 )");
 }
@@ -88,23 +88,23 @@
     EXPECT_EQ(1u, func->start_target->inbound_branches.Length());
     EXPECT_EQ(1u, func->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = if (true)
+  %fn2 = if true [t: %fn3, f: %fn4, m: %fn5]
     # true branch
-    %bb3 = Block
-    BranchTo %bb4 ()
+    %fn3 = block
+    branch %fn5
 
     # false branch
-    %bb5 = Block
-    BranchTo %bb4 ()
+    %fn4 = block
+    branch %fn5
 
   # if merge
-  %bb4 = Block
-  Return ()
-FunctionEnd
+  %fn5 = block
+  ret
+func_end
 
 )");
 }
@@ -136,22 +136,22 @@
     EXPECT_EQ(1u, func->start_target->inbound_branches.Length());
     EXPECT_EQ(2u, func->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = if (true)
+  %fn2 = if true [t: %fn3, f: %fn4, m: %fn5]
     # true branch
-    %bb3 = Block
-    Return ()
+    %fn3 = block
+    ret
     # false branch
-    %bb4 = Block
-    BranchTo %bb5 ()
+    %fn4 = block
+    branch %fn5
 
   # if merge
-  %bb5 = Block
-  Return ()
-FunctionEnd
+  %fn5 = block
+  ret
+func_end
 
 )");
 }
@@ -183,22 +183,22 @@
     EXPECT_EQ(1u, func->start_target->inbound_branches.Length());
     EXPECT_EQ(2u, func->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = if (true)
+  %fn2 = if true [t: %fn3, f: %fn4, m: %fn5]
     # true branch
-    %bb3 = Block
-    BranchTo %bb4 ()
+    %fn3 = block
+    branch %fn5
 
     # false branch
-    %bb5 = Block
-    Return ()
+    %fn4 = block
+    ret
   # if merge
-  %bb4 = Block
-  Return ()
-FunctionEnd
+  %fn5 = block
+  ret
+func_end
 
 )");
 }
@@ -230,18 +230,18 @@
     EXPECT_EQ(1u, func->start_target->inbound_branches.Length());
     EXPECT_EQ(2u, func->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = if (true)
+  %fn2 = if true [t: %fn3, f: %fn4]
     # true branch
-    %bb3 = Block
-    Return ()
+    %fn3 = block
+    ret
     # false branch
-    %bb4 = Block
-    Return ()
-FunctionEnd
+    %fn4 = block
+    ret
+func_end
 
 )");
 }
@@ -273,36 +273,32 @@
     ASSERT_NE(loop_flow->continuing.target, nullptr);
     ASSERT_NE(loop_flow->merge.target, nullptr);
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = if (true)
+  %fn2 = if true [t: %fn3, f: %fn4, m: %fn5]
     # true branch
-    %bb3 = Block
-    BranchTo %bb4 ()
+    %fn3 = block
+    branch %fn6
 
-    %bb4 = loop
+    %fn6 = loop [s: %fn7, m: %fn8]
       # loop start
-      %bb5 = Block
-      BranchTo %bb6 ()
-
-      # loop continuing
-      %bb7 = Block
-      BranchTo %bb5 ()
+      %fn7 = block
+      branch %fn8
 
     # loop merge
-    %bb6 = Block
-    BranchTo %bb8 ()
+    %fn8 = block
+    branch %fn5
 
     # false branch
-    %bb9 = Block
-    BranchTo %bb8 ()
+    %fn4 = block
+    branch %fn5
 
   # if merge
-  %bb8 = Block
-  Return ()
-FunctionEnd
+  %fn5 = block
+  ret
+func_end
 
 )");
 }
@@ -334,23 +330,19 @@
     EXPECT_EQ(1u, func->start_target->inbound_branches.Length());
     EXPECT_EQ(1u, func->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = loop
+  %fn2 = loop [s: %fn3, m: %fn4]
     # loop start
-    %bb3 = Block
-    BranchTo %bb4 ()
-
-    # loop continuing
-    %bb5 = Block
-    BranchTo %bb3 ()
+    %fn3 = block
+    branch %fn4
 
   # loop merge
-  %bb4 = Block
-  Return ()
-FunctionEnd
+  %fn4 = block
+  ret
+func_end
 
 )");
 }
@@ -396,36 +388,36 @@
     EXPECT_EQ(1u, func->start_target->inbound_branches.Length());
     EXPECT_EQ(1u, func->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = loop
+  %fn2 = loop [s: %fn3, c: %fn4, m: %fn5]
     # loop start
-    %bb3 = Block
-    BranchTo %bb4 ()
+    %fn3 = block
+    branch %fn6
 
-    %bb4 = if (true)
+    %fn6 = if true [t: %fn7, f: %fn8, m: %fn9]
       # true branch
-      %bb5 = Block
-      BranchTo %bb6 ()
+      %fn7 = block
+      branch %fn5
 
       # false branch
-      %bb7 = Block
-      BranchTo %bb8 ()
+      %fn8 = block
+      branch %fn9
 
     # if merge
-    %bb8 = Block
-    BranchTo %bb9 ()
+    %fn9 = block
+    branch %fn4
 
     # loop continuing
-    %bb9 = Block
-    BranchTo %bb3 ()
+    %fn4 = block
+    branch %fn3
 
   # loop merge
-  %bb6 = Block
-  Return ()
-FunctionEnd
+  %fn5 = block
+  ret
+func_end
 
 )");
 }
@@ -471,36 +463,36 @@
     EXPECT_EQ(1u, func->start_target->inbound_branches.Length());
     EXPECT_EQ(1u, func->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = loop
+  %fn2 = loop [s: %fn3, c: %fn4, m: %fn5]
     # loop start
-    %bb3 = Block
-    BranchTo %bb4 ()
+    %fn3 = block
+    branch %fn4
 
     # loop continuing
-    %bb4 = Block
-    BranchTo %bb5 ()
+    %fn4 = block
+    branch %fn6
 
-    %bb5 = if (true)
+    %fn6 = if true [t: %fn7, f: %fn8, m: %fn9]
       # true branch
-      %bb6 = Block
-      BranchTo %bb7 ()
+      %fn7 = block
+      branch %fn5
 
       # false branch
-      %bb8 = Block
-      BranchTo %bb9 ()
+      %fn8 = block
+      branch %fn9
 
     # if merge
-    %bb9 = Block
-    BranchTo %bb3 ()
+    %fn9 = block
+    branch %fn3
 
   # loop merge
-  %bb7 = Block
-  Return ()
-FunctionEnd
+  %fn5 = block
+  ret
+func_end
 
 )");
 }
@@ -546,34 +538,32 @@
     EXPECT_EQ(1u, func->start_target->inbound_branches.Length());
     EXPECT_EQ(1u, func->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = loop
+  %fn2 = loop [s: %fn3, c: %fn4]
     # loop start
-    %bb3 = Block
-    BranchTo %bb4 ()
+    %fn3 = block
+    branch %fn5
 
-    %bb4 = if (true)
+    %fn5 = if true [t: %fn6, f: %fn7, m: %fn8]
       # true branch
-      %bb5 = Block
-      Return ()
+      %fn6 = block
+      ret
       # false branch
-      %bb6 = Block
-      BranchTo %bb7 ()
+      %fn7 = block
+      branch %fn8
 
     # if merge
-    %bb7 = Block
-    BranchTo %bb8 ()
+    %fn8 = block
+    branch %fn4
 
     # loop continuing
-    %bb8 = Block
-    BranchTo %bb3 ()
+    %fn4 = block
+    branch %fn3
 
-  # loop merge
-  # Dead
-FunctionEnd
+func_end
 
 )");
 }
@@ -605,21 +595,15 @@
     EXPECT_EQ(1u, func->start_target->inbound_branches.Length());
     EXPECT_EQ(1u, func->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = loop
+  %fn2 = loop [s: %fn3]
     # loop start
-    %bb3 = Block
-    Return ()
-    # loop continuing
-    %bb4 = Block
-    BranchTo %bb3 ()
-
-  # loop merge
-  # Dead
-FunctionEnd
+    %fn3 = block
+    ret
+func_end
 
 )");
 }
@@ -629,6 +613,9 @@
     // `ast_if` below), it doesn't get emitted as there is no way to reach the
     // loop merge due to the loop itself doing a `return`. This is why the
     // loop merge gets marked as Dead and the `ast_if` doesn't appear.
+    //
+    // Similar, the continuing block goes away as there is no way to get there, so it's treated
+    // as dead code and dropped.
     auto* ast_break_if = BreakIf(true);
     auto* ast_loop = Loop(Block(Return()), Block(ast_break_if));
     auto* ast_if = If(true, Block(Return()));
@@ -670,34 +657,15 @@
     // This is 1 because only the loop branch happens. The subsequent if return is dead code.
     EXPECT_EQ(1u, func->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = loop
+  %fn2 = loop [s: %fn3]
     # loop start
-    %bb3 = Block
-    Return ()
-    # loop continuing
-    %bb4 = Block
-    BranchTo %bb5 ()
-
-    %bb5 = if (true)
-      # true branch
-      %bb6 = Block
-      BranchTo %bb7 ()
-
-      # false branch
-      %bb8 = Block
-      BranchTo %bb9 ()
-
-    # if merge
-    %bb9 = Block
-    BranchTo %bb3 ()
-
-  # loop merge
-  # Dead
-FunctionEnd
+    %fn3 = block
+    ret
+func_end
 
 )");
 }
@@ -743,32 +711,28 @@
     EXPECT_EQ(1u, func->start_target->inbound_branches.Length());
     EXPECT_EQ(1u, func->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = loop
+  %fn2 = loop [s: %fn3, m: %fn4]
     # loop start
-    %bb3 = Block
-    BranchTo %bb4 ()
+    %fn3 = block
+    branch %fn5
 
-    %bb4 = if (true)
+    %fn5 = if true [t: %fn6, f: %fn7]
       # true branch
-      %bb5 = Block
-      BranchTo %bb6 ()
+      %fn6 = block
+      branch %fn4
 
       # false branch
-      %bb7 = Block
-      BranchTo %bb6 ()
-
-    # loop continuing
-    %bb8 = Block
-    BranchTo %bb3 ()
+      %fn7 = block
+      branch %fn4
 
   # loop merge
-  %bb6 = Block
-  Return ()
-FunctionEnd
+  %fn4 = block
+  ret
+func_end
 
 )");
 }
@@ -893,114 +857,110 @@
     EXPECT_EQ(1u, func->start_target->inbound_branches.Length());
     EXPECT_EQ(1u, func->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = loop
+  %fn2 = loop [s: %fn3, c: %fn4, m: %fn5]
     # loop start
-    %bb3 = Block
-    BranchTo %bb4 ()
+    %fn3 = block
+    branch %fn6
 
-    %bb4 = loop
+    %fn6 = loop [s: %fn7, c: %fn8, m: %fn9]
       # loop start
-      %bb5 = Block
-      BranchTo %bb6 ()
+      %fn7 = block
+      branch %fn10
 
-      %bb6 = if (true)
+      %fn10 = if true [t: %fn11, f: %fn12, m: %fn13]
         # true branch
-        %bb7 = Block
-        BranchTo %bb8 ()
+        %fn11 = block
+        branch %fn9
 
         # false branch
-        %bb9 = Block
-        BranchTo %bb10 ()
+        %fn12 = block
+        branch %fn13
 
       # if merge
-      %bb10 = Block
-      BranchTo %bb11 ()
+      %fn13 = block
+      branch %fn14
 
-      %bb11 = if (true)
+      %fn14 = if true [t: %fn15, f: %fn16, m: %fn17]
         # true branch
-        %bb12 = Block
-        BranchTo %bb13 ()
+        %fn15 = block
+        branch %fn8
 
         # false branch
-        %bb14 = Block
-        BranchTo %bb15 ()
+        %fn16 = block
+        branch %fn17
 
       # if merge
-      %bb15 = Block
-      BranchTo %bb13 ()
+      %fn17 = block
+      branch %fn8
 
       # loop continuing
-      %bb13 = Block
-      BranchTo %bb16 ()
+      %fn8 = block
+      branch %fn18
 
-      %bb16 = loop
+      %fn18 = loop [s: %fn19, m: %fn20]
         # loop start
-        %bb17 = Block
-        BranchTo %bb18 ()
-
-        # loop continuing
-        %bb19 = Block
-        BranchTo %bb17 ()
+        %fn19 = block
+        branch %fn20
 
       # loop merge
-      %bb18 = Block
-      BranchTo %bb20 ()
+      %fn20 = block
+      branch %fn21
 
-      %bb20 = loop
+      %fn21 = loop [s: %fn22, c: %fn23, m: %fn24]
         # loop start
-        %bb21 = Block
-        BranchTo %bb22 ()
+        %fn22 = block
+        branch %fn23
 
         # loop continuing
-        %bb22 = Block
-        BranchTo %bb23 ()
+        %fn23 = block
+        branch %fn25
 
-        %bb23 = if (true)
+        %fn25 = if true [t: %fn26, f: %fn27, m: %fn28]
           # true branch
-          %bb24 = Block
-          BranchTo %bb25 ()
+          %fn26 = block
+          branch %fn24
 
           # false branch
-          %bb26 = Block
-          BranchTo %bb27 ()
+          %fn27 = block
+          branch %fn28
 
         # if merge
-        %bb27 = Block
-        BranchTo %bb21 ()
+        %fn28 = block
+        branch %fn22
 
       # loop merge
-      %bb25 = Block
-      BranchTo %bb5 ()
+      %fn24 = block
+      branch %fn7
 
     # loop merge
-    %bb8 = Block
-    BranchTo %bb28 ()
+    %fn9 = block
+    branch %fn29
 
-    %bb28 = if (true)
+    %fn29 = if true [t: %fn30, f: %fn31, m: %fn32]
       # true branch
-      %bb29 = Block
-      BranchTo %bb30 ()
+      %fn30 = block
+      branch %fn5
 
       # false branch
-      %bb31 = Block
-      BranchTo %bb32 ()
+      %fn31 = block
+      branch %fn32
 
     # if merge
-    %bb32 = Block
-    BranchTo %bb33 ()
+    %fn32 = block
+    branch %fn4
 
     # loop continuing
-    %bb33 = Block
-    BranchTo %bb3 ()
+    %fn4 = block
+    branch %fn3
 
   # loop merge
-  %bb30 = Block
-  Return ()
-FunctionEnd
+  %fn5 = block
+  ret
+func_end
 
 )");
 }
@@ -1041,36 +1001,36 @@
     EXPECT_EQ(1u, if_flow->false_.target->inbound_branches.Length());
     EXPECT_EQ(1u, if_flow->merge.target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = loop
+  %fn2 = loop [s: %fn3, c: %fn4, m: %fn5]
     # loop start
-    %bb3 = Block
-    BranchTo %bb4 ()
+    %fn3 = block
+    branch %fn6
 
-    %bb4 = if (false)
+    %fn6 = if false [t: %fn7, f: %fn8, m: %fn9]
       # true branch
-      %bb5 = Block
-      BranchTo %bb6 ()
+      %fn7 = block
+      branch %fn9
 
       # false branch
-      %bb7 = Block
-      BranchTo %bb8 ()
+      %fn8 = block
+      branch %fn5
 
     # if merge
-    %bb6 = Block
-    BranchTo %bb9 ()
+    %fn9 = block
+    branch %fn4
 
     # loop continuing
-    %bb9 = Block
-    BranchTo %bb3 ()
+    %fn4 = block
+    branch %fn3
 
   # loop merge
-  %bb8 = Block
-  Return ()
-FunctionEnd
+  %fn5 = block
+  ret
+func_end
 
 )");
 }
@@ -1111,35 +1071,31 @@
     EXPECT_EQ(1u, if_flow->false_.target->inbound_branches.Length());
     EXPECT_EQ(1u, if_flow->merge.target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = loop
+  %fn2 = loop [s: %fn3, m: %fn4]
     # loop start
-    %bb3 = Block
-    BranchTo %bb4 ()
+    %fn3 = block
+    branch %fn5
 
-    %bb4 = if (true)
+    %fn5 = if true [t: %fn6, f: %fn7, m: %fn8]
       # true branch
-      %bb5 = Block
-      BranchTo %bb6 ()
+      %fn6 = block
+      branch %fn8
 
       # false branch
-      %bb7 = Block
-      BranchTo %bb8 ()
+      %fn7 = block
+      branch %fn4
 
     # if merge
-    %bb6 = Block
-    Return ()
-    # loop continuing
-    %bb9 = Block
-    BranchTo %bb3 ()
-
+    %fn8 = block
+    ret
   # loop merge
-  %bb8 = Block
-  Return ()
-FunctionEnd
+  %fn4 = block
+  ret
+func_end
 
 )");
 }
@@ -1222,23 +1178,19 @@
     EXPECT_EQ(1u, flow->merge.target->inbound_branches.Length());
     EXPECT_EQ(1u, func->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = loop
+  %fn2 = loop [s: %fn3, m: %fn4]
     # loop start
-    %bb3 = Block
-    BranchTo %bb4 ()
-
-    # loop continuing
-    %bb5 = Block
-    BranchTo %bb3 ()
+    %fn3 = block
+    branch %fn4
 
   # loop merge
-  %bb4 = Block
-  Return ()
-FunctionEnd
+  %fn4 = block
+  ret
+func_end
 
 )");
 }
@@ -1285,27 +1237,83 @@
     EXPECT_EQ(3u, flow->merge.target->inbound_branches.Length());
     EXPECT_EQ(1u, func->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = Switch (1)
-    # Case 0
-    %bb3 = Block
-    BranchTo %bb4 ()
+  %fn2 = switch 1i [c: (0i, %fn3), c: (1i, %fn4), c: (default, %fn5), m: %fn6]
+    # case 0i
+    %fn3 = block
+    branch %fn6
 
-    # Case 1
-    %bb5 = Block
-    BranchTo %bb4 ()
+    # case 1i
+    %fn4 = block
+    branch %fn6
 
-    # Case default
-    %bb6 = Block
-    BranchTo %bb4 ()
+    # case default
+    %fn5 = block
+    branch %fn6
 
-  # Switch Merge
-  %bb4 = Block
-  Return ()
-FunctionEnd
+  # switch merge
+  %fn6 = block
+  ret
+func_end
+
+)");
+}
+
+TEST_F(IR_BuilderImplTest, Switch_MultiSelector) {
+    auto* ast_switch = Switch(
+        1_i,
+        utils::Vector{Case(
+            utils::Vector{CaseSelector(0_i), CaseSelector(1_i), DefaultCaseSelector()}, Block())});
+
+    WrapInFunction(ast_switch);
+
+    auto r = Build();
+    ASSERT_TRUE(r) << Error();
+    auto m = r.Move();
+
+    auto* ir_switch = FlowNodeForAstNode(ast_switch);
+    ASSERT_NE(ir_switch, nullptr);
+    ASSERT_TRUE(ir_switch->Is<ir::Switch>());
+
+    auto* flow = ir_switch->As<ir::Switch>();
+    ASSERT_NE(flow->merge.target, nullptr);
+    ASSERT_EQ(1u, flow->cases.Length());
+
+    ASSERT_EQ(1u, m.functions.Length());
+    auto* func = m.functions[0];
+
+    ASSERT_EQ(3u, flow->cases[0].selectors.Length());
+    ASSERT_TRUE(flow->cases[0].selectors[0].val->value->Is<constant::Scalar<tint::i32>>());
+    EXPECT_EQ(0_i,
+              flow->cases[0].selectors[0].val->value->As<constant::Scalar<tint::i32>>()->ValueOf());
+
+    ASSERT_TRUE(flow->cases[0].selectors[1].val->value->Is<constant::Scalar<tint::i32>>());
+    EXPECT_EQ(1_i,
+              flow->cases[0].selectors[1].val->value->As<constant::Scalar<tint::i32>>()->ValueOf());
+
+    EXPECT_TRUE(flow->cases[0].selectors[2].IsDefault());
+
+    EXPECT_EQ(1u, flow->inbound_branches.Length());
+    EXPECT_EQ(1u, flow->cases[0].start.target->inbound_branches.Length());
+    EXPECT_EQ(1u, flow->merge.target->inbound_branches.Length());
+    EXPECT_EQ(1u, func->end_target->inbound_branches.Length());
+
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
+
+  %fn2 = switch 1i [c: (0i 1i default, %fn3), m: %fn4]
+    # case 0i 1i default
+    %fn3 = block
+    branch %fn4
+
+  # switch merge
+  %fn4 = block
+  ret
+func_end
 
 )");
 }
@@ -1337,19 +1345,19 @@
     EXPECT_EQ(1u, flow->merge.target->inbound_branches.Length());
     EXPECT_EQ(1u, func->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = Switch (1)
-    # Case default
-    %bb3 = Block
-    BranchTo %bb4 ()
+  %fn2 = switch 1i [c: (default, %fn3), m: %fn4]
+    # case default
+    %fn3 = block
+    branch %fn4
 
-  # Switch Merge
-  %bb4 = Block
-  Return ()
-FunctionEnd
+  # switch merge
+  %fn4 = block
+  ret
+func_end
 
 )");
 }
@@ -1390,23 +1398,23 @@
     // This is 1 because the if is dead-code eliminated and the return doesn't happen.
     EXPECT_EQ(1u, func->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = Switch (1)
-    # Case 0
-    %bb3 = Block
-    BranchTo %bb4 ()
+  %fn2 = switch 1i [c: (0i, %fn3), c: (default, %fn4), m: %fn5]
+    # case 0i
+    %fn3 = block
+    branch %fn5
 
-    # Case default
-    %bb5 = Block
-    BranchTo %bb4 ()
+    # case default
+    %fn4 = block
+    branch %fn5
 
-  # Switch Merge
-  %bb4 = Block
-  Return ()
-FunctionEnd
+  # switch merge
+  %fn5 = block
+  ret
+func_end
 
 )");
 }
@@ -1449,20 +1457,18 @@
     EXPECT_EQ(0u, flow->merge.target->inbound_branches.Length());
     EXPECT_EQ(2u, func->end_target->inbound_branches.Length());
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  BranchTo %bb2 ()
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  branch %fn2
 
-  %bb2 = Switch (1)
-    # Case 0
-    %bb3 = Block
-    Return ()
-    # Case default
-    %bb4 = Block
-    Return ()
-  # Switch Merge
-  # Dead
-FunctionEnd
+  %fn2 = switch 1i [c: (0i, %fn3), c: (default, %fn4)]
+    # case 0i
+    %fn3 = block
+    ret
+    # case default
+    %fn4 = block
+    ret
+func_end
 
 )");
 }
@@ -1552,8 +1558,75 @@
     EXPECT_EQ(2_u, val->As<constant::Scalar<u32>>()->ValueAs<f32>());
 }
 
+TEST_F(IR_BuilderImplTest, Emit_GlobalVar_NoInit) {
+    GlobalVar("a", ty.u32(), builtin::AddressSpace::kPrivate);
+
+    auto r = Build();
+    ASSERT_TRUE(r) << Error();
+    auto m = r.Move();
+
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = block
+%1(ref<private, u32, read_write>) = var private read_write
+ret
+
+)");
+}
+
+TEST_F(IR_BuilderImplTest, Emit_GlobalVar_Init) {
+    auto* expr = Expr(2_u);
+    GlobalVar("a", ty.u32(), builtin::AddressSpace::kPrivate, expr);
+
+    auto r = Build();
+    ASSERT_TRUE(r) << Error();
+    auto m = r.Move();
+
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = block
+%1(ref<private, u32, read_write>) = var private read_write
+store %1(ref<private, u32, read_write>), 2u
+ret
+
+)");
+}
+
+TEST_F(IR_BuilderImplTest, Emit_Var_NoInit) {
+    auto* a = Var("a", ty.u32(), builtin::AddressSpace::kFunction);
+    WrapInFunction(a);
+
+    auto r = Build();
+    ASSERT_TRUE(r) << Error();
+    auto m = r.Move();
+
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  %1(ref<function, u32, read_write>) = var function read_write
+  ret
+func_end
+
+)");
+}
+
+TEST_F(IR_BuilderImplTest, Emit_Var_Init) {
+    auto* expr = Expr(2_u);
+    auto* a = Var("a", ty.u32(), builtin::AddressSpace::kFunction, expr);
+    WrapInFunction(a);
+
+    auto r = Build();
+    ASSERT_TRUE(r) << Error();
+    auto m = r.Move();
+
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  %1(ref<function, u32, read_write>) = var function read_write
+  store %1(ref<function, u32, read_write>), 2u
+  ret
+func_end
+
+)");
+}
+
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Add) {
-    auto* expr = Add(3_u, 4_u);
+    Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
+    auto* expr = Add(Call("my_func"), 4_u);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1564,12 +1637,14 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (u32) = 3 + 4
+    EXPECT_EQ(d.AsString(), R"(%1(u32) = call my_func
+%2(u32) = add %1(u32), 4u
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Subtract) {
-    auto* expr = Sub(3_u, 4_u);
+    Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
+    auto* expr = Sub(Call("my_func"), 4_u);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1580,12 +1655,14 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (u32) = 3 - 4
+    EXPECT_EQ(d.AsString(), R"(%1(u32) = call my_func
+%2(u32) = sub %1(u32), 4u
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Multiply) {
-    auto* expr = Mul(3_u, 4_u);
+    Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
+    auto* expr = Mul(Call("my_func"), 4_u);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1596,12 +1673,14 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (u32) = 3 * 4
+    EXPECT_EQ(d.AsString(), R"(%1(u32) = call my_func
+%2(u32) = mul %1(u32), 4u
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Div) {
-    auto* expr = Div(3_u, 4_u);
+    Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
+    auto* expr = Div(Call("my_func"), 4_u);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1612,12 +1691,14 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (u32) = 3 / 4
+    EXPECT_EQ(d.AsString(), R"(%1(u32) = call my_func
+%2(u32) = div %1(u32), 4u
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Modulo) {
-    auto* expr = Mod(3_u, 4_u);
+    Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
+    auto* expr = Mod(Call("my_func"), 4_u);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1628,12 +1709,14 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (u32) = 3 % 4
+    EXPECT_EQ(d.AsString(), R"(%1(u32) = call my_func
+%2(u32) = mod %1(u32), 4u
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_And) {
-    auto* expr = And(3_u, 4_u);
+    Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
+    auto* expr = And(Call("my_func"), 4_u);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1644,12 +1727,14 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (u32) = 3 & 4
+    EXPECT_EQ(d.AsString(), R"(%1(u32) = call my_func
+%2(u32) = bit_and %1(u32), 4u
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Or) {
-    auto* expr = Or(3_u, 4_u);
+    Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
+    auto* expr = Or(Call("my_func"), 4_u);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1660,12 +1745,14 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (u32) = 3 | 4
+    EXPECT_EQ(d.AsString(), R"(%1(u32) = call my_func
+%2(u32) = bit_or %1(u32), 4u
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Xor) {
-    auto* expr = Xor(3_u, 4_u);
+    Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
+    auto* expr = Xor(Call("my_func"), 4_u);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1676,12 +1763,14 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (u32) = 3 ^ 4
+    EXPECT_EQ(d.AsString(), R"(%1(u32) = call my_func
+%2(u32) = bit_xor %1(u32), 4u
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_LogicalAnd) {
-    auto* expr = LogicalAnd(true, false);
+    Func("my_func", utils::Empty, ty.bool_(), utils::Vector{Return(true)});
+    auto* expr = LogicalAnd(Call("my_func"), false);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1692,12 +1781,14 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (bool) = true && false
+    EXPECT_EQ(d.AsString(), R"(%1(bool) = call my_func
+%2(bool) = log_and %1(bool), false
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_LogicalOr) {
-    auto* expr = LogicalOr(false, true);
+    Func("my_func", utils::Empty, ty.bool_(), utils::Vector{Return(true)});
+    auto* expr = LogicalOr(Call("my_func"), true);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1708,12 +1799,14 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (bool) = false || true
+    EXPECT_EQ(d.AsString(), R"(%1(bool) = call my_func
+%2(bool) = log_or %1(bool), true
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Equal) {
-    auto* expr = Equal(3_u, 4_u);
+    Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
+    auto* expr = Equal(Call("my_func"), 4_u);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1724,12 +1817,14 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (bool) = 3 == 4
+    EXPECT_EQ(d.AsString(), R"(%1(u32) = call my_func
+%2(bool) = eq %1(u32), 4u
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_NotEqual) {
-    auto* expr = NotEqual(3_u, 4_u);
+    Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
+    auto* expr = NotEqual(Call("my_func"), 4_u);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1740,12 +1835,14 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (bool) = 3 != 4
+    EXPECT_EQ(d.AsString(), R"(%1(u32) = call my_func
+%2(bool) = neq %1(u32), 4u
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_LessThan) {
-    auto* expr = LessThan(3_u, 4_u);
+    Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
+    auto* expr = LessThan(Call("my_func"), 4_u);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1756,12 +1853,14 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (bool) = 3 < 4
+    EXPECT_EQ(d.AsString(), R"(%1(u32) = call my_func
+%2(bool) = lt %1(u32), 4u
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_GreaterThan) {
-    auto* expr = GreaterThan(3_u, 4_u);
+    Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
+    auto* expr = GreaterThan(Call("my_func"), 4_u);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1772,12 +1871,14 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (bool) = 3 > 4
+    EXPECT_EQ(d.AsString(), R"(%1(u32) = call my_func
+%2(bool) = gt %1(u32), 4u
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_LessThanEqual) {
-    auto* expr = LessThanEqual(3_u, 4_u);
+    Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
+    auto* expr = LessThanEqual(Call("my_func"), 4_u);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1788,12 +1889,14 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (bool) = 3 <= 4
+    EXPECT_EQ(d.AsString(), R"(%1(u32) = call my_func
+%2(bool) = lte %1(u32), 4u
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_GreaterThanEqual) {
-    auto* expr = GreaterThanEqual(3_u, 4_u);
+    Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
+    auto* expr = GreaterThanEqual(Call("my_func"), 4_u);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1804,12 +1907,14 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (bool) = 3 >= 4
+    EXPECT_EQ(d.AsString(), R"(%1(u32) = call my_func
+%2(bool) = gte %1(u32), 4u
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_ShiftLeft) {
-    auto* expr = Shl(3_u, 4_u);
+    Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
+    auto* expr = Shl(Call("my_func"), 4_u);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1820,12 +1925,14 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (u32) = 3 << 4
+    EXPECT_EQ(d.AsString(), R"(%1(u32) = call my_func
+%2(u32) = shiftl %1(u32), 4u
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_ShiftRight) {
-    auto* expr = Shr(3_u, 4_u);
+    Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
+    auto* expr = Shr(Call("my_func"), 4_u);
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1836,13 +1943,16 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (u32) = 3 >> 4
+    EXPECT_EQ(d.AsString(), R"(%1(u32) = call my_func
+%2(u32) = shiftr %1(u32), 4u
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Compound) {
-    auto* expr = LogicalAnd(LessThan(1_u, Add(Shr(3_u, 4_u), 9_u)),
-                            GreaterThan(2.5_f, Div(6.7_f, Mul(2.3_f, 5.5_f))));
+    Func("my_func", utils::Empty, ty.f32(), utils::Vector{Return(0_f)});
+
+    auto* expr = LogicalAnd(LessThan(Call("my_func"), 2_f),
+                            GreaterThan(2.5_f, Div(Call("my_func"), Mul(2.3_f, Call("my_func")))));
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1853,18 +1963,39 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (u32) = 3 >> 4
-%2 (u32) = %1 (u32) + 9
-%3 (bool) = 1 < %2 (u32)
-%4 (f32) = 2.29999995231628417969 * 5.5
-%5 (f32) = 6.69999980926513671875 / %4 (f32)
-%6 (bool) = 2.5 > %5 (f32)
-%7 (bool) = %3 (bool) && %6 (bool)
+    EXPECT_EQ(d.AsString(), R"(%1(f32) = call my_func
+%2(bool) = lt %1(f32), 2.0f
+%3(f32) = call my_func
+%4(f32) = call my_func
+%5(f32) = mul 2.29999995231628417969f, %4(f32)
+%6(f32) = div %3(f32), %5(f32)
+%7(bool) = gt 2.5f, %6(f32)
+%8(bool) = log_and %2(bool), %7(bool)
+)");
+}
+
+TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Compound_WithConstEval) {
+    Func("my_func", utils::Vector{Param("p", ty.bool_())}, ty.bool_(), utils::Vector{Return(true)});
+    auto* expr = Call("my_func", LogicalAnd(LessThan(2.4_f, 2_f),
+                                            GreaterThan(2.5_f, Div(10_f, Mul(2.3_f, 9.4_f)))));
+    WrapInFunction(expr);
+
+    auto& b = CreateBuilder();
+    InjectFlowBlock();
+    auto r = b.EmitExpression(expr);
+    ASSERT_THAT(b.Diagnostics(), testing::IsEmpty());
+    ASSERT_TRUE(r);
+
+    Disassembler d(b.builder.ir);
+    d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
+    EXPECT_EQ(d.AsString(), R"(%1(bool) = call my_func, false
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitExpression_Bitcast) {
-    auto* expr = Bitcast<f32>(3_u);
+    Func("my_func", utils::Empty, ty.f32(), utils::Vector{Return(0_f)});
+
+    auto* expr = Bitcast<f32>(Call("my_func"));
     WrapInFunction(expr);
 
     auto& b = CreateBuilder();
@@ -1875,7 +2006,8 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (f32) = bitcast(3)
+    EXPECT_EQ(d.AsString(), R"(%1(f32) = call my_func
+%2(f32) = bitcast %1(f32)
 )");
 }
 
@@ -1893,25 +2025,25 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (void) = discard
+    EXPECT_EQ(d.AsString(), R"(discard
 )");
 }
 
 TEST_F(IR_BuilderImplTest, EmitStatement_UserFunction) {
     Func("my_func", utils::Vector{Param("p", ty.f32())}, ty.void_(), utils::Empty);
 
-    auto* stmt = CallStmt(Call("my_func", Mul(2_f, 3_f)));
+    auto* stmt = CallStmt(Call("my_func", Mul(2_a, 3_a)));
     WrapInFunction(stmt);
 
     auto& b = CreateBuilder();
+
     InjectFlowBlock();
     b.EmitStatement(stmt);
     ASSERT_THAT(b.Diagnostics(), testing::IsEmpty());
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (f32) = 2.0 * 3.0
-%2 (void) = call(my_func, %1 (f32))
+    EXPECT_EQ(d.AsString(), R"(%1(void) = call my_func, 6.0f
 )");
 }
 
@@ -1930,7 +2062,7 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%1 (vec3<f32>) = construct(vec3<f32>)
+    EXPECT_EQ(d.AsString(), R"(%1(vec3<f32>) = construct
 )");
 }
 
@@ -1948,7 +2080,7 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%2 (vec3<f32>) = construct(vec3<f32>, 2.0, 3.0, %1 (void))
+    EXPECT_EQ(d.AsString(), R"(%2(vec3<f32>) = construct 2.0f, 3.0f, %1(void)
 )");
 }
 
@@ -1966,7 +2098,7 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%2 (f32) = convert(f32, i32, %1 (void))
+    EXPECT_EQ(d.AsString(), R"(%2(f32) = convert i32, %1(void)
 )");
 }
 
@@ -1979,10 +2111,10 @@
     ASSERT_TRUE(r) << Error();
     auto m = r.Move();
 
-    EXPECT_EQ(Disassemble(m), R"(%bb0 = Function test_function
-  %bb1 = Block
-  Return (2.0)
-FunctionEnd
+    EXPECT_EQ(Disassemble(m), R"(%fn0 = func test_function
+  %fn1 = block
+  ret 2.0f
+func_end
 
 )");
 }
@@ -2001,7 +2133,7 @@
 
     Disassembler d(b.builder.ir);
     d.EmitBlockInstructions(b.current_flow_block->As<ir::Block>());
-    EXPECT_EQ(d.AsString(), R"(%2 (f32) = asin(%1 (void))
+    EXPECT_EQ(d.AsString(), R"(%2(f32) = asin %1(void)
 )");
 }
 
diff --git a/src/tint/ir/builtin.cc b/src/tint/ir/builtin.cc
index 4237797..54cf882 100644
--- a/src/tint/ir/builtin.cc
+++ b/src/tint/ir/builtin.cc
@@ -20,16 +20,17 @@
 // \cond DO_NOT_DOCUMENT
 namespace tint::ir {
 
-Builtin::Builtin(Value* result, builtin::Function func, utils::VectorRef<Value*> args)
-    : Base(result, args), func_(func) {}
+Builtin::Builtin(uint32_t id,
+                 const type::Type* type,
+                 builtin::Function func,
+                 utils::VectorRef<Value*> args)
+    : Base(id, type, args), func_(func) {}
 
 Builtin::~Builtin() = default;
 
-utils::StringStream& Builtin::ToString(utils::StringStream& out) const {
-    Result()->ToString(out);
-    out << " = " << builtin::str(func_) << "(";
+utils::StringStream& Builtin::ToInstruction(utils::StringStream& out) const {
+    ToValue(out) << " = " << builtin::str(func_) << " ";
     EmitArgs(out);
-    out << ")";
     return out;
 }
 
diff --git a/src/tint/ir/builtin.h b/src/tint/ir/builtin.h
index b1fd61d..9f6f666 100644
--- a/src/tint/ir/builtin.h
+++ b/src/tint/ir/builtin.h
@@ -26,16 +26,20 @@
 class Builtin : public utils::Castable<Builtin, Call> {
   public:
     /// Constructor
-    /// @param result the result value
+    /// @param id the instruction id
+    /// @param type the result type
     /// @param func the builtin function
     /// @param args the conversion arguments
-    Builtin(Value* result, builtin::Function func, utils::VectorRef<Value*> args);
-    Builtin(const Builtin& instr) = delete;
-    Builtin(Builtin&& instr) = delete;
+    Builtin(uint32_t id,
+            const type::Type* type,
+            builtin::Function func,
+            utils::VectorRef<Value*> args);
+    Builtin(const Builtin& inst) = delete;
+    Builtin(Builtin&& inst) = delete;
     ~Builtin() override;
 
-    Builtin& operator=(const Builtin& instr) = delete;
-    Builtin& operator=(Builtin&& instr) = delete;
+    Builtin& operator=(const Builtin& inst) = delete;
+    Builtin& operator=(Builtin&& inst) = delete;
 
     /// @returns the builtin function
     builtin::Function Func() const { return func_; }
@@ -43,7 +47,7 @@
     /// Write the instruction to the given stream
     /// @param out the stream to write to
     /// @returns the stream
-    utils::StringStream& ToString(utils::StringStream& out) const override;
+    utils::StringStream& ToInstruction(utils::StringStream& out) const override;
 
   private:
     const builtin::Function func_;
diff --git a/src/tint/ir/call.cc b/src/tint/ir/call.cc
index b801260..322f83d 100644
--- a/src/tint/ir/call.cc
+++ b/src/tint/ir/call.cc
@@ -18,7 +18,10 @@
 
 namespace tint::ir {
 
-Call::Call(Value* result, utils::VectorRef<Value*> args) : Base(result), args_(args) {
+Call::Call() : Base() {}
+
+Call::Call(uint32_t id, const type::Type* type, utils::VectorRef<Value*> args)
+    : Base(id, type), args_(args) {
     for (auto* arg : args) {
         arg->AddUsage(this);
     }
@@ -33,7 +36,7 @@
             out << ", ";
         }
         first = false;
-        arg->ToString(out);
+        arg->ToValue(out);
     }
 }
 
diff --git a/src/tint/ir/call.h b/src/tint/ir/call.h
index e7bf684..a49e9fa 100644
--- a/src/tint/ir/call.h
+++ b/src/tint/ir/call.h
@@ -24,16 +24,12 @@
 /// A Call instruction in the IR.
 class Call : public utils::Castable<Call, Instruction> {
   public:
-    /// Constructor
-    /// @param result the result value
-    /// @param args the constructor arguments
-    Call(Value* result, utils::VectorRef<Value*> args);
-    Call(const Call& instr) = delete;
-    Call(Call&& instr) = delete;
+    Call(const Call& inst) = delete;
+    Call(Call&& inst) = delete;
     ~Call() override;
 
-    Call& operator=(const Call& instr) = delete;
-    Call& operator=(Call&& instr) = delete;
+    Call& operator=(const Call& inst) = delete;
+    Call& operator=(Call&& inst) = delete;
 
     /// @returns the constructor arguments
     utils::VectorRef<Value*> Args() const { return args_; }
@@ -42,6 +38,15 @@
     /// @param out the output stream
     void EmitArgs(utils::StringStream& out) const;
 
+  protected:
+    /// Constructor
+    Call();
+    /// Constructor
+    /// @param id the instruction id
+    /// @param type the result type
+    /// @param args the constructor arguments
+    Call(uint32_t id, const type::Type* type, utils::VectorRef<Value*> args);
+
   private:
     utils::Vector<Value*, 1> args_;
 };
diff --git a/src/tint/ir/constant.cc b/src/tint/ir/constant.cc
index 4036616..0666e91 100644
--- a/src/tint/ir/constant.cc
+++ b/src/tint/ir/constant.cc
@@ -29,33 +29,39 @@
 
 Constant::~Constant() = default;
 
-utils::StringStream& Constant::ToString(utils::StringStream& out) const {
+utils::StringStream& Constant::ToValue(utils::StringStream& out) const {
     std::function<void(const constant::Value*)> emit = [&](const constant::Value* c) {
         Switch(
             c,
             [&](const constant::Scalar<AFloat>* scalar) { out << scalar->ValueAs<AFloat>().value; },
             [&](const constant::Scalar<AInt>* scalar) { out << scalar->ValueAs<AInt>().value; },
-            [&](const constant::Scalar<i32>* scalar) { out << scalar->ValueAs<i32>().value; },
-            [&](const constant::Scalar<u32>* scalar) { out << scalar->ValueAs<u32>().value; },
-            [&](const constant::Scalar<f32>* scalar) { out << scalar->ValueAs<f32>().value; },
-            [&](const constant::Scalar<f16>* scalar) { out << scalar->ValueAs<f16>().value; },
+            [&](const constant::Scalar<i32>* scalar) {
+                out << scalar->ValueAs<i32>().value << "i";
+            },
+            [&](const constant::Scalar<u32>* scalar) {
+                out << scalar->ValueAs<u32>().value << "u";
+            },
+            [&](const constant::Scalar<f32>* scalar) {
+                out << scalar->ValueAs<f32>().value << "f";
+            },
+            [&](const constant::Scalar<f16>* scalar) {
+                out << scalar->ValueAs<f16>().value << "h";
+            },
             [&](const constant::Scalar<bool>* scalar) {
                 out << (scalar->ValueAs<bool>() ? "true" : "false");
             },
             [&](const constant::Splat* splat) {
-                out << splat->Type()->FriendlyName() << "(";
+                out << splat->Type()->FriendlyName() << " ";
                 emit(splat->Index(0));
-                out << ")";
             },
             [&](const constant::Composite* composite) {
-                out << composite->Type()->FriendlyName() << "(";
+                out << composite->Type()->FriendlyName() << " ";
                 for (const auto* elem : composite->elements) {
                     if (elem != composite->elements[0]) {
                         out << ", ";
                     }
                     emit(elem);
                 }
-                out << ")";
             });
     };
     emit(value);
diff --git a/src/tint/ir/constant.h b/src/tint/ir/constant.h
index 207af5d..2413721 100644
--- a/src/tint/ir/constant.h
+++ b/src/tint/ir/constant.h
@@ -35,7 +35,7 @@
     /// Write the constant to the given stream
     /// @param out the stream to write to
     /// @returns the stream
-    utils::StringStream& ToString(utils::StringStream& out) const override;
+    utils::StringStream& ToValue(utils::StringStream& out) const override;
 
     /// The constants value
     const constant::Value* const value;
diff --git a/src/tint/ir/constant_test.cc b/src/tint/ir/constant_test.cc
index f407cdb..43d92b4 100644
--- a/src/tint/ir/constant_test.cc
+++ b/src/tint/ir/constant_test.cc
@@ -31,8 +31,8 @@
     auto* c = b.builder.Constant(1.2_f);
     EXPECT_EQ(1.2_f, c->value->As<constant::Scalar<f32>>()->ValueAs<f32>());
 
-    c->ToString(str);
-    EXPECT_EQ("1.20000004768371582031", str.str());
+    c->ToValue(str);
+    EXPECT_EQ("1.20000004768371582031f", str.str());
 
     EXPECT_TRUE(c->value->Is<constant::Scalar<f32>>());
     EXPECT_FALSE(c->value->Is<constant::Scalar<f16>>());
@@ -49,8 +49,8 @@
     auto* c = b.builder.Constant(1.1_h);
     EXPECT_EQ(1.1_h, c->value->As<constant::Scalar<f16>>()->ValueAs<f16>());
 
-    c->ToString(str);
-    EXPECT_EQ("1.099609375", str.str());
+    c->ToValue(str);
+    EXPECT_EQ("1.099609375h", str.str());
 
     EXPECT_FALSE(c->value->Is<constant::Scalar<f32>>());
     EXPECT_TRUE(c->value->Is<constant::Scalar<f16>>());
@@ -67,8 +67,8 @@
     auto* c = b.builder.Constant(1_i);
     EXPECT_EQ(1_i, c->value->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
-    c->ToString(str);
-    EXPECT_EQ("1", str.str());
+    c->ToValue(str);
+    EXPECT_EQ("1i", str.str());
 
     EXPECT_FALSE(c->value->Is<constant::Scalar<f32>>());
     EXPECT_FALSE(c->value->Is<constant::Scalar<f16>>());
@@ -85,8 +85,8 @@
     auto* c = b.builder.Constant(2_u);
     EXPECT_EQ(2_u, c->value->As<constant::Scalar<u32>>()->ValueAs<u32>());
 
-    c->ToString(str);
-    EXPECT_EQ("2", str.str());
+    c->ToValue(str);
+    EXPECT_EQ("2u", str.str());
 
     EXPECT_FALSE(c->value->Is<constant::Scalar<f32>>());
     EXPECT_FALSE(c->value->Is<constant::Scalar<f16>>());
@@ -104,7 +104,7 @@
         auto* c = b.builder.Constant(false);
         EXPECT_FALSE(c->value->As<constant::Scalar<bool>>()->ValueAs<bool>());
 
-        c->ToString(str);
+        c->ToValue(str);
         EXPECT_EQ("false", str.str());
     }
 
@@ -113,7 +113,7 @@
         auto c = b.builder.Constant(true);
         EXPECT_TRUE(c->value->As<constant::Scalar<bool>>()->ValueAs<bool>());
 
-        c->ToString(str);
+        c->ToValue(str);
         EXPECT_EQ("true", str.str());
 
         EXPECT_FALSE(c->value->Is<constant::Scalar<f32>>());
diff --git a/src/tint/ir/construct.cc b/src/tint/ir/construct.cc
index 595075b..1507e8f 100644
--- a/src/tint/ir/construct.cc
+++ b/src/tint/ir/construct.cc
@@ -19,18 +19,14 @@
 
 namespace tint::ir {
 
-Construct::Construct(Value* result, utils::VectorRef<Value*> args) : Base(result, args) {}
+Construct::Construct(uint32_t id, const type::Type* type, utils::VectorRef<Value*> args)
+    : Base(id, type, args) {}
 
 Construct::~Construct() = default;
 
-utils::StringStream& Construct::ToString(utils::StringStream& out) const {
-    Result()->ToString(out);
-    out << " = construct(" << Result()->Type()->FriendlyName();
-    if (!Args().IsEmpty()) {
-        out << ", ";
-        EmitArgs(out);
-    }
-    out << ")";
+utils::StringStream& Construct::ToInstruction(utils::StringStream& out) const {
+    ToValue(out) << " = construct ";
+    EmitArgs(out);
     return out;
 }
 
diff --git a/src/tint/ir/construct.h b/src/tint/ir/construct.h
index c9d1819..1cc0102 100644
--- a/src/tint/ir/construct.h
+++ b/src/tint/ir/construct.h
@@ -25,20 +25,21 @@
 class Construct : public utils::Castable<Construct, Call> {
   public:
     /// Constructor
-    /// @param result the result value
+    /// @param id the instruction id
+    /// @param type the result type
     /// @param args the constructor arguments
-    Construct(Value* result, utils::VectorRef<Value*> args);
-    Construct(const Construct& instr) = delete;
-    Construct(Construct&& instr) = delete;
+    Construct(uint32_t id, const type::Type* type, utils::VectorRef<Value*> args);
+    Construct(const Construct& inst) = delete;
+    Construct(Construct&& inst) = delete;
     ~Construct() override;
 
-    Construct& operator=(const Construct& instr) = delete;
-    Construct& operator=(Construct&& instr) = delete;
+    Construct& operator=(const Construct& inst) = delete;
+    Construct& operator=(Construct&& inst) = delete;
 
     /// Write the instruction to the given stream
     /// @param out the stream to write to
     /// @returns the stream
-    utils::StringStream& ToString(utils::StringStream& out) const override;
+    utils::StringStream& ToInstruction(utils::StringStream& out) const override;
 };
 
 }  // namespace tint::ir
diff --git a/src/tint/ir/convert.cc b/src/tint/ir/convert.cc
index ed31250..7ffd6f5 100644
--- a/src/tint/ir/convert.cc
+++ b/src/tint/ir/convert.cc
@@ -19,17 +19,17 @@
 
 namespace tint::ir {
 
-Convert::Convert(Value* result, const type::Type* from, utils::VectorRef<Value*> args)
-    : Base(result, args), from_(from) {}
+Convert::Convert(uint32_t id,
+                 const type::Type* to_type,
+                 const type::Type* from_type,
+                 utils::VectorRef<Value*> args)
+    : Base(id, to_type, args), from_type_(from_type) {}
 
 Convert::~Convert() = default;
 
-utils::StringStream& Convert::ToString(utils::StringStream& out) const {
-    Result()->ToString(out);
-    out << " = convert(" << Result()->Type()->FriendlyName() << ", " << from_->FriendlyName()
-        << ", ";
+utils::StringStream& Convert::ToInstruction(utils::StringStream& out) const {
+    ToValue(out) << " = convert " << from_type_->FriendlyName() << ", ";
     EmitArgs(out);
-    out << ")";
     return out;
 }
 
diff --git a/src/tint/ir/convert.h b/src/tint/ir/convert.h
index d157e03..c164a45 100644
--- a/src/tint/ir/convert.h
+++ b/src/tint/ir/convert.h
@@ -26,29 +26,33 @@
 class Convert : public utils::Castable<Convert, Call> {
   public:
     /// Constructor
-    /// @param result the result value
-    /// @param from the type being converted from
+    /// @param id the instruction id
+    /// @param result_type the result type
+    /// @param from_type the type being converted from
     /// @param args the conversion arguments
-    Convert(Value* result, const type::Type* from, utils::VectorRef<Value*> args);
-    Convert(const Convert& instr) = delete;
-    Convert(Convert&& instr) = delete;
+    Convert(uint32_t id,
+            const type::Type* result_type,
+            const type::Type* from_type,
+            utils::VectorRef<Value*> args);
+    Convert(const Convert& inst) = delete;
+    Convert(Convert&& inst) = delete;
     ~Convert() override;
 
-    Convert& operator=(const Convert& instr) = delete;
-    Convert& operator=(Convert&& instr) = delete;
+    Convert& operator=(const Convert& inst) = delete;
+    Convert& operator=(Convert&& inst) = delete;
 
     /// @returns the from type
-    const type::Type* From() const { return from_; }
+    const type::Type* FromType() const { return from_type_; }
     /// @returns the to type
-    const type::Type* To() const { return Result()->Type(); }
+    const type::Type* ToType() const { return Type(); }
 
     /// Write the instruction to the given stream
     /// @param out the stream to write to
     /// @returns the stream
-    utils::StringStream& ToString(utils::StringStream& out) const override;
+    utils::StringStream& ToInstruction(utils::StringStream& out) const override;
 
   private:
-    const type::Type* from_ = nullptr;
+    const type::Type* from_type_ = nullptr;
 };
 
 }  // namespace tint::ir
diff --git a/src/tint/ir/converter.cc b/src/tint/ir/converter.cc
new file mode 100644
index 0000000..e89be3a
--- /dev/null
+++ b/src/tint/ir/converter.cc
@@ -0,0 +1,42 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/ir/converter.h"
+
+#include "src/tint/ir/builder_impl.h"
+#include "src/tint/program.h"
+
+namespace tint::ir {
+
+// static
+Converter::Result Converter::FromProgram(const Program* program) {
+    if (!program->IsValid()) {
+        return Result{std::string("input program is not valid")};
+    }
+
+    BuilderImpl b(program);
+    auto r = b.Build();
+    if (!r) {
+        return b.Diagnostics().str();
+    }
+
+    return Result{r.Move()};
+}
+
+// static
+const Program* Converter::ToProgram() {
+    return nullptr;
+}
+
+}  // namespace tint::ir
diff --git a/src/tint/ir/converter.h b/src/tint/ir/converter.h
new file mode 100644
index 0000000..8defd83
--- /dev/null
+++ b/src/tint/ir/converter.h
@@ -0,0 +1,54 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_IR_CONVERTER_H_
+#define SRC_TINT_IR_CONVERTER_H_
+
+#include <string>
+
+#include "src/tint/ir/module.h"
+#include "src/tint/utils/result.h"
+
+// Forward Declarations
+namespace tint {
+class Program;
+}  // namespace tint
+
+namespace tint::ir {
+
+/// Class for converting into and out of IR.
+class Converter {
+  public:
+    /// The result type for the FromProgram method.
+    using Result = utils::Result<Module, std::string>;
+
+    /// Builds an ir::Module from the given Program
+    /// @param program the Program to use.
+    /// @returns the `utiils::Result` of generating the IR. The result will contain the `ir::Module`
+    /// on success, otherwise the `std::string` error.
+    ///
+    /// @note this assumes the program |IsValid|, and has had const-eval done so
+    /// any abstract values have been calculated and converted into the relevant
+    /// concrete types.
+    static Result FromProgram(const Program* program);
+
+    /// Converts the module back to a Program
+    /// @returns the resulting program, or nullptr on error
+    ///  (Note, this will probably turn into a utils::Result, just stubbing for now)
+    static const Program* ToProgram();
+};
+
+}  // namespace tint::ir
+
+#endif  // SRC_TINT_IR_CONVERTER_H_
diff --git a/src/tint/ir/disassembler.cc b/src/tint/ir/disassembler.cc
index c3bb006..2b8de0b 100644
--- a/src/tint/ir/disassembler.cc
+++ b/src/tint/ir/disassembler.cc
@@ -20,6 +20,7 @@
 #include "src/tint/ir/switch.h"
 #include "src/tint/ir/terminator.h"
 #include "src/tint/switch.h"
+#include "src/tint/utils/scoped_assignment.h"
 
 namespace tint::ir {
 namespace {
@@ -62,9 +63,9 @@
 }
 
 void Disassembler::EmitBlockInstructions(const Block* b) {
-    for (const auto* instr : b->instructions) {
+    for (const auto* inst : b->instructions) {
         Indent();
-        instr->ToString(out_) << std::endl;
+        inst->ToInstruction(out_) << std::endl;
     }
 }
 
@@ -89,7 +90,9 @@
     tint::Switch(
         node,
         [&](const ir::Function* f) {
-            Indent() << "%bb" << GetIdForNode(f) << " = Function " << f->name.Name() << std::endl;
+            TINT_SCOPED_ASSIGNMENT(in_function_, true);
+
+            Indent() << "%fn" << GetIdForNode(f) << " = func " << f->name.Name() << std::endl;
 
             {
                 ScopedIndent func_indent(&indent_size_);
@@ -101,27 +104,28 @@
         [&](const ir::Block* b) {
             // If this block is dead, nothing to do
             if (b->IsDead()) {
-                Indent() << "# Dead" << std::endl;
                 return;
             }
 
-            Indent() << "%bb" << GetIdForNode(b) << " = Block" << std::endl;
+            Indent() << "%fn" << GetIdForNode(b) << " = block" << std::endl;
             EmitBlockInstructions(b);
 
             if (b->branch.target->Is<Terminator>()) {
-                Indent() << "Return";
+                Indent() << "ret";
             } else {
-                Indent() << "BranchTo "
-                         << "%bb" << GetIdForNode(b->branch.target);
+                Indent() << "branch "
+                         << "%fn" << GetIdForNode(b->branch.target);
             }
-            out_ << " (";
-            for (const auto* v : b->branch.args) {
-                if (v != b->branch.args.Front()) {
-                    out_ << ", ";
+            if (!b->branch.args.IsEmpty()) {
+                out_ << " ";
+                for (const auto* v : b->branch.args) {
+                    if (v != b->branch.args.Front()) {
+                        out_ << ", ";
+                    }
+                    v->ToValue(out_);
                 }
-                v->ToString(out_);
             }
-            out_ << ")" << std::endl;
+            out_ << std::endl;
 
             if (!b->branch.target->Is<Terminator>()) {
                 out_ << std::endl;
@@ -130,15 +134,37 @@
             Walk(b->branch.target);
         },
         [&](const ir::Switch* s) {
-            Indent() << "%bb" << GetIdForNode(s) << " = Switch (";
-            s->condition->ToString(out_);
-            out_ << ")" << std::endl;
+            Indent() << "%fn" << GetIdForNode(s) << " = switch ";
+            s->condition->ToValue(out_);
+            out_ << " [";
+            for (const auto& c : s->cases) {
+                if (&c != &s->cases.Front()) {
+                    out_ << ", ";
+                }
+                out_ << "c: (";
+                for (const auto& selector : c.selectors) {
+                    if (&selector != &c.selectors.Front()) {
+                        out_ << " ";
+                    }
+
+                    if (selector.IsDefault()) {
+                        out_ << "default";
+                    } else {
+                        selector.val->ToValue(out_);
+                    }
+                }
+                out_ << ", %fn" << GetIdForNode(c.start.target) << ")";
+            }
+            if (s->merge.target->IsConnected()) {
+                out_ << ", m: %fn" << GetIdForNode(s->merge.target);
+            }
+            out_ << "]" << std::endl;
 
             {
                 ScopedIndent switch_indent(&indent_size_);
                 ScopedStopNode scope(&stop_nodes_, s->merge.target);
                 for (const auto& c : s->cases) {
-                    Indent() << "# Case ";
+                    Indent() << "# case ";
                     for (const auto& selector : c.selectors) {
                         if (&selector != &c.selectors.Front()) {
                             out_ << " ";
@@ -147,7 +173,7 @@
                         if (selector.IsDefault()) {
                             out_ << "default";
                         } else {
-                            selector.val->ToString(out_);
+                            selector.val->ToValue(out_);
                         }
                     }
                     out_ << std::endl;
@@ -155,13 +181,20 @@
                 }
             }
 
-            Indent() << "# Switch Merge" << std::endl;
-            Walk(s->merge.target);
+            if (s->merge.target->IsConnected()) {
+                Indent() << "# switch merge" << std::endl;
+                Walk(s->merge.target);
+            }
         },
         [&](const ir::If* i) {
-            Indent() << "%bb" << GetIdForNode(i) << " = if (";
-            i->condition->ToString(out_);
-            out_ << ")" << std::endl;
+            Indent() << "%fn" << GetIdForNode(i) << " = if ";
+            i->condition->ToValue(out_);
+            out_ << " [t: %fn" << GetIdForNode(i->true_.target) << ", f: %fn"
+                 << GetIdForNode(i->false_.target);
+            if (i->merge.target->IsConnected()) {
+                out_ << ", m: %fn" << GetIdForNode(i->merge.target);
+            }
+            out_ << "]" << std::endl;
 
             {
                 ScopedIndent if_indent(&indent_size_);
@@ -174,13 +207,23 @@
                 Walk(i->false_.target);
             }
 
-            if (!i->merge.target->IsDisconnected()) {
+            if (i->merge.target->IsConnected()) {
                 Indent() << "# if merge" << std::endl;
                 Walk(i->merge.target);
             }
         },
         [&](const ir::Loop* l) {
-            Indent() << "%bb" << GetIdForNode(l) << " = loop" << std::endl;
+            Indent() << "%fn" << GetIdForNode(l) << " = loop [s: %fn"
+                     << GetIdForNode(l->start.target);
+
+            if (l->continuing.target->IsConnected()) {
+                out_ << ", c: %fn" << GetIdForNode(l->continuing.target);
+            }
+            if (l->merge.target->IsConnected()) {
+                out_ << ", m: %fn" << GetIdForNode(l->merge.target);
+            }
+            out_ << "]" << std::endl;
+
             {
                 ScopedStopNode loop_scope(&stop_nodes_, l->merge.target);
                 ScopedIndent loop_indent(&indent_size_);
@@ -190,18 +233,30 @@
                     Walk(l->start.target);
                 }
 
-                Indent() << "# loop continuing" << std::endl;
-                Walk(l->continuing.target);
+                if (l->continuing.target->IsConnected()) {
+                    Indent() << "# loop continuing" << std::endl;
+                    Walk(l->continuing.target);
+                }
             }
 
-            Indent() << "# loop merge" << std::endl;
-            Walk(l->merge.target);
+            if (l->merge.target->IsConnected()) {
+                Indent() << "# loop merge" << std::endl;
+                Walk(l->merge.target);
+            }
         },
-        [&](const ir::Terminator*) { Indent() << "FunctionEnd" << std::endl
-                                              << std::endl; });
+        [&](const ir::Terminator*) {
+            if (in_function_) {
+                Indent() << "func_end" << std::endl;
+            }
+            out_ << std::endl;
+        });
 }
 
 std::string Disassembler::Disassemble() {
+    if (mod_.root_block) {
+        Walk(mod_.root_block);
+    }
+
     for (const auto* func : mod_.functions) {
         Walk(func);
     }
diff --git a/src/tint/ir/disassembler.h b/src/tint/ir/disassembler.h
index eee6b76..04b3997 100644
--- a/src/tint/ir/disassembler.h
+++ b/src/tint/ir/disassembler.h
@@ -56,6 +56,7 @@
     std::unordered_map<const FlowNode*, size_t> flow_node_to_id_;
     size_t next_node_id_ = 0;
     uint32_t indent_size_ = 0;
+    bool in_function_ = false;
 };
 
 }  // namespace tint::ir
diff --git a/src/tint/ir/discard.cc b/src/tint/ir/discard.cc
index 1d179b5..bc7bdc3 100644
--- a/src/tint/ir/discard.cc
+++ b/src/tint/ir/discard.cc
@@ -19,13 +19,12 @@
 
 namespace tint::ir {
 
-Discard::Discard(Value* result) : Base(result) {}
+Discard::Discard() : Base() {}
 
 Discard::~Discard() = default;
 
-utils::StringStream& Discard::ToString(utils::StringStream& out) const {
-    Result()->ToString(out);
-    out << " = discard";
+utils::StringStream& Discard::ToInstruction(utils::StringStream& out) const {
+    out << "discard";
     return out;
 }
 
diff --git a/src/tint/ir/discard.h b/src/tint/ir/discard.h
index b27dc9d..456c8d5 100644
--- a/src/tint/ir/discard.h
+++ b/src/tint/ir/discard.h
@@ -15,29 +15,29 @@
 #ifndef SRC_TINT_IR_DISCARD_H_
 #define SRC_TINT_IR_DISCARD_H_
 
-#include "src/tint/ir/instruction.h"
+#include "src/tint/debug.h"
+#include "src/tint/ir/call.h"
 #include "src/tint/utils/castable.h"
 #include "src/tint/utils/string_stream.h"
 
 namespace tint::ir {
 
 /// A discard instruction in the IR.
-class Discard : public utils::Castable<Discard, Instruction> {
+class Discard : public utils::Castable<Discard, Call> {
   public:
     /// Constructor
-    /// @param result the result id
-    explicit Discard(Value* result);
-    Discard(const Discard& instr) = delete;
-    Discard(Discard&& instr) = delete;
+    Discard();
+    Discard(const Discard& inst) = delete;
+    Discard(Discard&& inst) = delete;
     ~Discard() override;
 
-    Discard& operator=(const Discard& instr) = delete;
-    Discard& operator=(Discard&& instr) = delete;
+    Discard& operator=(const Discard& inst) = delete;
+    Discard& operator=(Discard&& inst) = delete;
 
     /// Write the instruction to the given stream
     /// @param out the stream to write to
     /// @returns the stream
-    utils::StringStream& ToString(utils::StringStream& out) const override;
+    utils::StringStream& ToInstruction(utils::StringStream& out) const override;
 };
 
 }  // namespace tint::ir
diff --git a/src/tint/ir/discard_test.cc b/src/tint/ir/discard_test.cc
index 0f2fb5d..32b5c1e 100644
--- a/src/tint/ir/discard_test.cc
+++ b/src/tint/ir/discard_test.cc
@@ -24,17 +24,12 @@
 TEST_F(IR_InstructionTest, Discard) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr = b.builder.Discard();
-
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-    ASSERT_NE(instr->Result()->Type(), nullptr);
-    ASSERT_NE(instr->Result()->Type()->As<type::Void>(), nullptr);
+    const auto* inst = b.builder.Discard();
+    ASSERT_TRUE(inst->Is<ir::Discard>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (void) = discard");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "discard");
 }
 
 }  // namespace
diff --git a/src/tint/ir/flow_node.h b/src/tint/ir/flow_node.h
index 2a91674..905f077 100644
--- a/src/tint/ir/flow_node.h
+++ b/src/tint/ir/flow_node.h
@@ -32,8 +32,11 @@
     ///   - Node is a continue target outside control flow (loop that returns)
     utils::Vector<FlowNode*, 2> inbound_branches;
 
-    /// @returns true if this node has no inbound branches
-    bool IsDisconnected() const { return inbound_branches.IsEmpty(); }
+    /// @returns true if this node has inbound branches and branches out
+    bool IsConnected() const { return !IsDead() && !inbound_branches.IsEmpty(); }
+
+    /// @returns true if the node does not branch out
+    virtual bool IsDead() const { return false; }
 
   protected:
     /// Constructor
diff --git a/src/tint/ir/instruction.cc b/src/tint/ir/instruction.cc
index 46644dd..3e3192f 100644
--- a/src/tint/ir/instruction.cc
+++ b/src/tint/ir/instruction.cc
@@ -18,10 +18,9 @@
 
 namespace tint::ir {
 
-Instruction::Instruction(Value* result) : result_(result) {
-    TINT_ASSERT(IR, result_);
-    result_->AddUsage(this);
-}
+Instruction::Instruction() = default;
+
+Instruction::Instruction(uint32_t id, const type::Type* ty) : id_(id), type_(ty) {}
 
 Instruction::~Instruction() = default;
 
diff --git a/src/tint/ir/instruction.h b/src/tint/ir/instruction.h
index df965e4..f2dac09 100644
--- a/src/tint/ir/instruction.h
+++ b/src/tint/ir/instruction.h
@@ -22,31 +22,46 @@
 namespace tint::ir {
 
 /// An instruction in the IR.
-class Instruction : public utils::Castable<Instruction> {
+class Instruction : public utils::Castable<Instruction, Value> {
   public:
-    Instruction(const Instruction& instr) = delete;
-    Instruction(Instruction&& instr) = delete;
+    Instruction(const Instruction& inst) = delete;
+    Instruction(Instruction&& inst) = delete;
     /// Destructor
     ~Instruction() override;
 
-    Instruction& operator=(const Instruction& instr) = delete;
-    Instruction& operator=(Instruction&& instr) = delete;
+    Instruction& operator=(const Instruction& inst) = delete;
+    Instruction& operator=(Instruction&& inst) = delete;
 
-    /// @returns the result value for the instruction
-    Value* Result() const { return result_; }
+    /// @returns the type of the value
+    const type::Type* Type() const override { return type_; }
+
+    /// Write the value to the given stream
+    /// @param out the stream to write to
+    /// @returns the stream
+    utils::StringStream& ToValue(utils::StringStream& out) const override {
+        out << "%" << std::to_string(id_);
+        if (type_ != nullptr) {
+            out << "(" << Type()->FriendlyName() << ")";
+        }
+        return out;
+    }
 
     /// Write the instruction to the given stream
     /// @param out the stream to write to
     /// @returns the stream
-    virtual utils::StringStream& ToString(utils::StringStream& out) const = 0;
+    virtual utils::StringStream& ToInstruction(utils::StringStream& out) const = 0;
 
   protected:
     /// Constructor
-    /// @param result the result value
-    explicit Instruction(Value* result);
+    Instruction();
+    /// Constructor
+    /// @param id the instruction id
+    /// @param type the result type
+    Instruction(uint32_t id, const type::Type* type);
 
   private:
-    Value* result_ = nullptr;
+    uint32_t id_ = 0;
+    const type::Type* type_ = nullptr;
 };
 
 }  // namespace tint::ir
diff --git a/src/tint/ir/module.cc b/src/tint/ir/module.cc
index e434888..133d364 100644
--- a/src/tint/ir/module.cc
+++ b/src/tint/ir/module.cc
@@ -14,26 +14,8 @@
 
 #include "src/tint/ir/module.h"
 
-#include "src/tint/ir/builder_impl.h"
-#include "src/tint/program.h"
-
 namespace tint::ir {
 
-// static
-Module::Result Module::FromProgram(const Program* program) {
-    if (!program->IsValid()) {
-        return Result{std::string("input program is not valid")};
-    }
-
-    BuilderImpl b(program);
-    auto r = b.Build();
-    if (!r) {
-        return b.Diagnostics().str();
-    }
-
-    return Result{r.Move()};
-}
-
 Module::Module() = default;
 
 Module::Module(Module&&) = default;
@@ -42,8 +24,4 @@
 
 Module& Module::operator=(Module&&) = default;
 
-const Program* Module::ToProgram() const {
-    return nullptr;
-}
-
 }  // namespace tint::ir
diff --git a/src/tint/ir/module.h b/src/tint/ir/module.h
index 5cfc883..ebf9209 100644
--- a/src/tint/ir/module.h
+++ b/src/tint/ir/module.h
@@ -28,29 +28,11 @@
 #include "src/tint/utils/result.h"
 #include "src/tint/utils/vector.h"
 
-// Forward Declarations
-namespace tint {
-class Program;
-}  // namespace tint
-
 namespace tint::ir {
 
 /// Main module class for the IR.
 class Module {
   public:
-    /// The result type for the FromProgram method.
-    using Result = utils::Result<Module, std::string>;
-
-    /// Builds an ir::Module from the given Program
-    /// @param program the Program to use.
-    /// @returns the `utiils::Result` of generating the IR. The result will contain the `ir::Module`
-    /// on success, otherwise the `std::string` error.
-    ///
-    /// @note this assumes the program |IsValid|, and has had const-eval done so
-    /// any abstract values have been calculated and converted into the relevant
-    /// concrete types.
-    static Result FromProgram(const Program* program);
-
     /// Constructor
     Module();
     /// Move constructor
@@ -64,11 +46,6 @@
     /// @returns a reference to this module
     Module& operator=(Module&& o);
 
-    /// Converts the module back to a Program
-    /// @returns the resulting program, or nullptr on error
-    ///  (Note, this will probably turn into a utils::Result, just stubbing for now)
-    const Program* ToProgram() const;
-
   private:
     /// Program Id required to create other components
     ProgramID prog_id_;
@@ -88,6 +65,9 @@
     /// List of indexes into the functions list for the entry points
     utils::Vector<Function*, 8> entry_points;
 
+    /// The block containing module level declarations, if any exist.
+    Block* root_block = nullptr;
+
     /// The type manager for the module
     type::Manager types;
 
diff --git a/src/tint/ir/runtime.cc b/src/tint/ir/runtime.cc
deleted file mode 100644
index a1f485d..0000000
--- a/src/tint/ir/runtime.cc
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright 2022 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/tint/ir/runtime.h"
-
-#include <string>
-
-TINT_INSTANTIATE_TYPEINFO(tint::ir::Runtime);
-
-namespace tint::ir {
-
-Runtime::Runtime(const type::Type* type, Id id) : type_(type), id_(id) {}
-
-Runtime::~Runtime() = default;
-
-utils::StringStream& Runtime::ToString(utils::StringStream& out) const {
-    out << "%" << std::to_string(AsId()) << " (" << type_->FriendlyName() << ")";
-    return out;
-}
-
-}  // namespace tint::ir
diff --git a/src/tint/ir/runtime.h b/src/tint/ir/runtime.h
deleted file mode 100644
index 6e2558c..0000000
--- a/src/tint/ir/runtime.h
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2022 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_TINT_IR_RUNTIME_H_
-#define SRC_TINT_IR_RUNTIME_H_
-
-#include "src/tint/ir/value.h"
-#include "src/tint/utils/string_stream.h"
-
-namespace tint::ir {
-
-/// Runtime value in the IR.
-class Runtime : public utils::Castable<Runtime, Value> {
-  public:
-    /// A value id.
-    using Id = uint32_t;
-
-    /// Constructor
-    /// @param type the type of the value
-    /// @param id the id for the value
-    Runtime(const type::Type* type, Id id);
-
-    /// Destructor
-    ~Runtime() override;
-
-    Runtime(const Runtime&) = delete;
-    Runtime(Runtime&&) = delete;
-
-    Runtime& operator=(const Runtime&) = delete;
-    Runtime& operator=(Runtime&&) = delete;
-
-    /// @returns the value data as an `Id`.
-    Id AsId() const { return id_; }
-
-    /// @returns the type of the value
-    const type::Type* Type() const override { return type_; }
-
-    /// Write the id to the given stream
-    /// @param out the stream to write to
-    /// @returns the stream
-    utils::StringStream& ToString(utils::StringStream& out) const override;
-
-  private:
-    const type::Type* type_ = nullptr;
-    Id id_ = 0;
-};
-
-}  // namespace tint::ir
-
-#endif  // SRC_TINT_IR_RUNTIME_H_
diff --git a/src/tint/ir/runtime_test.cc b/src/tint/ir/runtime_test.cc
deleted file mode 100644
index 7959909..0000000
--- a/src/tint/ir/runtime_test.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2022 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/tint/ir/runtime.h"
-#include "src/tint/ir/test_helper.h"
-#include "src/tint/utils/string_stream.h"
-
-namespace tint::ir {
-namespace {
-
-using namespace tint::number_suffixes;  // NOLINT
-
-using IR_RuntimeTest = TestHelper;
-
-TEST_F(IR_RuntimeTest, id) {
-    auto& b = CreateEmptyBuilder();
-
-    utils::StringStream str;
-
-    b.builder.next_runtime_id = Runtime::Id(4);
-    auto* val = b.builder.Runtime(b.builder.ir.types.Get<type::I32>());
-    EXPECT_EQ(4u, val->AsId());
-
-    val->ToString(str);
-    EXPECT_EQ("%4 (i32)", str.str());
-}
-
-}  // namespace
-}  // namespace tint::ir
diff --git a/src/tint/ir/store.cc b/src/tint/ir/store.cc
index 32162c3..8d35214 100644
--- a/src/tint/ir/store.cc
+++ b/src/tint/ir/store.cc
@@ -19,17 +19,19 @@
 
 namespace tint::ir {
 
-Store::Store(Value* to, Value* from) : Base(to), from_(from) {
+Store::Store(Value* to, Value* from) : Base(), to_(to), from_(from) {
+    TINT_ASSERT(IR, to_);
     TINT_ASSERT(IR, from_);
+    to_->AddUsage(this);
     from_->AddUsage(this);
 }
 
 Store::~Store() = default;
 
-utils::StringStream& Store::ToString(utils::StringStream& out) const {
-    Result()->ToString(out);
-    out << " = ";
-    from_->ToString(out);
+utils::StringStream& Store::ToInstruction(utils::StringStream& out) const {
+    out << "store ";
+    to_->ToValue(out) << ", ";
+    from_->ToValue(out);
     return out;
 }
 
diff --git a/src/tint/ir/store.h b/src/tint/ir/store.h
index 57544fc..ea5550d 100644
--- a/src/tint/ir/store.h
+++ b/src/tint/ir/store.h
@@ -28,22 +28,25 @@
     /// @param to the value to store too
     /// @param from the value being stored from
     Store(Value* to, Value* from);
-    Store(const Store& instr) = delete;
-    Store(Store&& instr) = delete;
+    Store(const Store& inst) = delete;
+    Store(Store&& inst) = delete;
     ~Store() override;
 
-    Store& operator=(const Store& instr) = delete;
-    Store& operator=(Store&& instr) = delete;
+    Store& operator=(const Store& inst) = delete;
+    Store& operator=(Store&& inst) = delete;
 
+    /// @returns the value being stored too
+    const Value* to() const { return to_; }
     /// @returns the value being stored
     const Value* from() const { return from_; }
 
     /// Write the instruction to the given stream
     /// @param out the stream to write to
     /// @returns the stream
-    utils::StringStream& ToString(utils::StringStream& out) const override;
+    utils::StringStream& ToInstruction(utils::StringStream& out) const override;
 
   private:
+    Value* to_ = nullptr;
     Value* from_ = nullptr;
 };
 
diff --git a/src/tint/ir/store_test.cc b/src/tint/ir/store_test.cc
index e0632dd..82347dc 100644
--- a/src/tint/ir/store_test.cc
+++ b/src/tint/ir/store_test.cc
@@ -26,39 +26,37 @@
 TEST_F(IR_InstructionTest, CreateStore) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
+    // TODO(dsinclair): This is wrong, but we don't have anything correct to store too at the
+    // moment.
+    auto* to = b.builder.Discard();
+    const auto* inst = b.builder.Store(to, b.builder.Constant(4_i));
 
-    auto* rt = b.builder.Runtime(b.builder.ir.types.Get<type::I32>());
-    const auto* instr = b.builder.Store(rt, b.builder.Constant(4_i));
+    ASSERT_TRUE(inst->Is<Store>());
+    ASSERT_EQ(inst->to(), to);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    ASSERT_NE(instr->Result()->Type(), nullptr);
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->from()->Is<Constant>());
-    auto lhs = instr->from()->As<Constant>()->value;
+    ASSERT_TRUE(inst->from()->Is<Constant>());
+    auto lhs = inst->from()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (i32) = 4");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "store %0, 4i");
 }
 
 TEST_F(IR_InstructionTest, Store_Usage) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
-    auto* rt = b.builder.Runtime(b.builder.ir.types.Get<type::I32>());
-    const auto* instr = b.builder.Store(rt, b.builder.Constant(4_i));
+    auto* to = b.builder.Discard();
+    const auto* inst = b.builder.Store(to, b.builder.Constant(4_i));
 
-    ASSERT_NE(instr->Result(), nullptr);
-    ASSERT_EQ(instr->Result()->Usage().Length(), 1u);
-    EXPECT_EQ(instr->Result()->Usage()[0], instr);
+    ASSERT_NE(inst->to(), nullptr);
+    ASSERT_EQ(inst->to()->Usage().Length(), 1u);
+    EXPECT_EQ(inst->to()->Usage()[0], inst);
 
-    ASSERT_NE(instr->from(), nullptr);
-    ASSERT_EQ(instr->from()->Usage().Length(), 1u);
-    EXPECT_EQ(instr->from()->Usage()[0], instr);
+    ASSERT_NE(inst->from(), nullptr);
+    ASSERT_EQ(inst->from()->Usage().Length(), 1u);
+    EXPECT_EQ(inst->from()->Usage()[0], inst);
 }
 
 }  // namespace
diff --git a/src/tint/ir/unary.cc b/src/tint/ir/unary.cc
index 532efcc..f3c4f24 100644
--- a/src/tint/ir/unary.cc
+++ b/src/tint/ir/unary.cc
@@ -19,34 +19,35 @@
 
 namespace tint::ir {
 
-Unary::Unary(Kind kind, Value* result, Value* val) : Base(result), kind_(kind), val_(val) {
+Unary::Unary(uint32_t id, Kind kind, const type::Type* type, Value* val)
+    : Base(id, type), kind_(kind), val_(val) {
     TINT_ASSERT(IR, val_);
     val_->AddUsage(this);
 }
 
 Unary::~Unary() = default;
 
-utils::StringStream& Unary::ToString(utils::StringStream& out) const {
-    Result()->ToString(out) << " = ";
+utils::StringStream& Unary::ToInstruction(utils::StringStream& out) const {
+    ToValue(out) << " = ";
     switch (GetKind()) {
         case Unary::Kind::kAddressOf:
-            out << "&";
+            out << "addr_of";
             break;
         case Unary::Kind::kComplement:
-            out << "~";
+            out << "bit_complement";
             break;
         case Unary::Kind::kIndirection:
-            out << "*";
+            out << "indirection";
             break;
         case Unary::Kind::kNegation:
-            out << "-";
+            out << "negation";
             break;
         case Unary::Kind::kNot:
-            out << "!";
+            out << "log_not";
             break;
     }
-    val_->ToString(out);
-
+    out << " ";
+    val_->ToValue(out);
     return out;
 }
 
diff --git a/src/tint/ir/unary.h b/src/tint/ir/unary.h
index 0337b4f..ce3e5d7 100644
--- a/src/tint/ir/unary.h
+++ b/src/tint/ir/unary.h
@@ -34,16 +34,17 @@
     };
 
     /// Constructor
+    /// @param id the instruction id
     /// @param kind the kind of unary instruction
-    /// @param result the result value
+    /// @param type the result type
     /// @param val the lhs of the instruction
-    Unary(Kind kind, Value* result, Value* val);
-    Unary(const Unary& instr) = delete;
-    Unary(Unary&& instr) = delete;
+    Unary(uint32_t id, Kind kind, const type::Type* type, Value* val);
+    Unary(const Unary& inst) = delete;
+    Unary(Unary&& inst) = delete;
     ~Unary() override;
 
-    Unary& operator=(const Unary& instr) = delete;
-    Unary& operator=(Unary&& instr) = delete;
+    Unary& operator=(const Unary& inst) = delete;
+    Unary& operator=(Unary&& inst) = delete;
 
     /// @returns the kind of instruction
     Kind GetKind() const { return kind_; }
@@ -54,7 +55,7 @@
     /// Write the instruction to the given stream
     /// @param out the stream to write to
     /// @returns the stream
-    utils::StringStream& ToString(utils::StringStream& out) const override;
+    utils::StringStream& ToInstruction(utils::StringStream& out) const override;
 
   private:
     Kind kind_;
diff --git a/src/tint/ir/unary_test.cc b/src/tint/ir/unary_test.cc
index cfc5579..ff247a2 100644
--- a/src/tint/ir/unary_test.cc
+++ b/src/tint/ir/unary_test.cc
@@ -26,135 +26,112 @@
 TEST_F(IR_InstructionTest, CreateAddressOf) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
     // TODO(dsinclair): This would be better as an identifier, but works for now.
-    const auto* instr =
+    const auto* inst =
         b.builder.AddressOf(b.builder.ir.types.Get<type::Pointer>(
                                 b.builder.ir.types.Get<type::I32>(),
                                 builtin::AddressSpace::kPrivate, builtin::Access::kReadWrite),
                             b.builder.Constant(4_i));
 
-    EXPECT_EQ(instr->GetKind(), Unary::Kind::kAddressOf);
+    ASSERT_TRUE(inst->Is<Unary>());
+    EXPECT_EQ(inst->GetKind(), Unary::Kind::kAddressOf);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    ASSERT_NE(instr->Result()->Type(), nullptr);
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
+    ASSERT_NE(inst->Type(), nullptr);
 
-    ASSERT_TRUE(instr->Val()->Is<Constant>());
-    auto lhs = instr->Val()->As<Constant>()->value;
+    ASSERT_TRUE(inst->Val()->Is<Constant>());
+    auto lhs = inst->Val()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (ptr<private, i32, read_write>) = &4");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(ptr<private, i32, read_write>) = addr_of 4i");
 }
 
 TEST_F(IR_InstructionTest, CreateComplement) {
     auto& b = CreateEmptyBuilder();
-
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr =
+    const auto* inst =
         b.builder.Complement(b.builder.ir.types.Get<type::I32>(), b.builder.Constant(4_i));
 
-    EXPECT_EQ(instr->GetKind(), Unary::Kind::kComplement);
+    ASSERT_TRUE(inst->Is<Unary>());
+    EXPECT_EQ(inst->GetKind(), Unary::Kind::kComplement);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->Val()->Is<Constant>());
-    auto lhs = instr->Val()->As<Constant>()->value;
+    ASSERT_TRUE(inst->Val()->Is<Constant>());
+    auto lhs = inst->Val()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (i32) = ~4");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(i32) = bit_complement 4i");
 }
 
 TEST_F(IR_InstructionTest, CreateIndirection) {
     auto& b = CreateEmptyBuilder();
 
-    b.builder.next_runtime_id = Runtime::Id(42);
     // TODO(dsinclair): This would be better as an identifier, but works for now.
-    const auto* instr =
+    const auto* inst =
         b.builder.Indirection(b.builder.ir.types.Get<type::I32>(), b.builder.Constant(4_i));
 
-    EXPECT_EQ(instr->GetKind(), Unary::Kind::kIndirection);
+    ASSERT_TRUE(inst->Is<Unary>());
+    EXPECT_EQ(inst->GetKind(), Unary::Kind::kIndirection);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->Val()->Is<Constant>());
-    auto lhs = instr->Val()->As<Constant>()->value;
+    ASSERT_TRUE(inst->Val()->Is<Constant>());
+    auto lhs = inst->Val()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (i32) = *4");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(i32) = indirection 4i");
 }
 
 TEST_F(IR_InstructionTest, CreateNegation) {
     auto& b = CreateEmptyBuilder();
-
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr =
+    const auto* inst =
         b.builder.Negation(b.builder.ir.types.Get<type::I32>(), b.builder.Constant(4_i));
 
-    EXPECT_EQ(instr->GetKind(), Unary::Kind::kNegation);
+    ASSERT_TRUE(inst->Is<Unary>());
+    EXPECT_EQ(inst->GetKind(), Unary::Kind::kNegation);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->Val()->Is<Constant>());
-    auto lhs = instr->Val()->As<Constant>()->value;
+    ASSERT_TRUE(inst->Val()->Is<Constant>());
+    auto lhs = inst->Val()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<i32>>());
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (i32) = -4");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(i32) = negation 4i");
 }
 
 TEST_F(IR_InstructionTest, CreateNot) {
     auto& b = CreateEmptyBuilder();
-
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr =
+    const auto* inst =
         b.builder.Not(b.builder.ir.types.Get<type::Bool>(), b.builder.Constant(true));
 
-    EXPECT_EQ(instr->GetKind(), Unary::Kind::kNot);
+    ASSERT_TRUE(inst->Is<Unary>());
+    EXPECT_EQ(inst->GetKind(), Unary::Kind::kNot);
 
-    ASSERT_TRUE(instr->Result()->Is<Runtime>());
-    EXPECT_EQ(Runtime::Id(42), instr->Result()->As<Runtime>()->AsId());
-
-    ASSERT_TRUE(instr->Val()->Is<Constant>());
-    auto lhs = instr->Val()->As<Constant>()->value;
+    ASSERT_TRUE(inst->Val()->Is<Constant>());
+    auto lhs = inst->Val()->As<Constant>()->value;
     ASSERT_TRUE(lhs->Is<constant::Scalar<bool>>());
     EXPECT_TRUE(lhs->As<constant::Scalar<bool>>()->ValueAs<bool>());
 
     utils::StringStream str;
-    instr->ToString(str);
-    EXPECT_EQ(str.str(), "%42 (bool) = !true");
+    inst->ToInstruction(str);
+    EXPECT_EQ(str.str(), "%1(bool) = log_not true");
 }
 
 TEST_F(IR_InstructionTest, Unary_Usage) {
     auto& b = CreateEmptyBuilder();
-
-    b.builder.next_runtime_id = Runtime::Id(42);
-    const auto* instr =
+    const auto* inst =
         b.builder.Negation(b.builder.ir.types.Get<type::I32>(), b.builder.Constant(4_i));
 
-    EXPECT_EQ(instr->GetKind(), Unary::Kind::kNegation);
+    EXPECT_EQ(inst->GetKind(), Unary::Kind::kNegation);
 
-    ASSERT_NE(instr->Result(), nullptr);
-    ASSERT_EQ(instr->Result()->Usage().Length(), 1u);
-    EXPECT_EQ(instr->Result()->Usage()[0], instr);
-
-    ASSERT_NE(instr->Val(), nullptr);
-    ASSERT_EQ(instr->Val()->Usage().Length(), 1u);
-    EXPECT_EQ(instr->Val()->Usage()[0], instr);
+    ASSERT_NE(inst->Val(), nullptr);
+    ASSERT_EQ(inst->Val()->Usage().Length(), 1u);
+    EXPECT_EQ(inst->Val()->Usage()[0], inst);
 }
 
 }  // namespace
diff --git a/src/tint/ir/user_call.cc b/src/tint/ir/user_call.cc
index 9a1f7eb..f23a2ca 100644
--- a/src/tint/ir/user_call.cc
+++ b/src/tint/ir/user_call.cc
@@ -19,17 +19,17 @@
 
 namespace tint::ir {
 
-UserCall::UserCall(Value* result, Symbol name, utils::VectorRef<Value*> args)
-    : Base(result, args), name_(name) {}
+UserCall::UserCall(uint32_t id, const type::Type* type, Symbol name, utils::VectorRef<Value*> args)
+    : Base(id, type, args), name_(name) {}
 
 UserCall::~UserCall() = default;
 
-utils::StringStream& UserCall::ToString(utils::StringStream& out) const {
-    Result()->ToString(out);
-    out << " = call(";
-    out << name_.Name() << ", ";
+utils::StringStream& UserCall::ToInstruction(utils::StringStream& out) const {
+    ToValue(out) << " = call " << name_.Name();
+    if (Args().Length() > 0) {
+        out << ", ";
+    }
     EmitArgs(out);
-    out << ")";
     return out;
 }
 
diff --git a/src/tint/ir/user_call.h b/src/tint/ir/user_call.h
index 0662455..1e2b070 100644
--- a/src/tint/ir/user_call.h
+++ b/src/tint/ir/user_call.h
@@ -26,16 +26,17 @@
 class UserCall : public utils::Castable<UserCall, Call> {
   public:
     /// Constructor
-    /// @param result the result value
+    /// @param id the instruction id
+    /// @param type the result type
     /// @param name the function name
     /// @param args the function arguments
-    UserCall(Value* result, Symbol name, utils::VectorRef<Value*> args);
-    UserCall(const UserCall& instr) = delete;
-    UserCall(UserCall&& instr) = delete;
+    UserCall(uint32_t id, const type::Type* type, Symbol name, utils::VectorRef<Value*> args);
+    UserCall(const UserCall& inst) = delete;
+    UserCall(UserCall&& inst) = delete;
     ~UserCall() override;
 
-    UserCall& operator=(const UserCall& instr) = delete;
-    UserCall& operator=(UserCall&& instr) = delete;
+    UserCall& operator=(const UserCall& inst) = delete;
+    UserCall& operator=(UserCall&& inst) = delete;
 
     /// @returns the function name
     Symbol Name() const { return name_; }
@@ -43,7 +44,7 @@
     /// Write the instruction to the given stream
     /// @param out the stream to write to
     /// @returns the stream
-    utils::StringStream& ToString(utils::StringStream& out) const override;
+    utils::StringStream& ToInstruction(utils::StringStream& out) const override;
 
   private:
     Symbol name_{};
diff --git a/src/tint/ir/value.cc b/src/tint/ir/value.cc
index 750fe19..c735cd9 100644
--- a/src/tint/ir/value.cc
+++ b/src/tint/ir/value.cc
@@ -15,7 +15,6 @@
 #include "src/tint/ir/value.h"
 
 #include "src/tint/ir/constant.h"
-#include "src/tint/ir/runtime.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Value);
 
diff --git a/src/tint/ir/value.h b/src/tint/ir/value.h
index e2a642b..7f3f4b7 100644
--- a/src/tint/ir/value.h
+++ b/src/tint/ir/value.h
@@ -40,8 +40,8 @@
     Value& operator=(Value&&) = delete;
 
     /// Adds an instruction which uses this value.
-    /// @param instr the instruction
-    void AddUsage(const Instruction* instr) { uses_.Add(instr); }
+    /// @param inst the instruction
+    void AddUsage(const Instruction* inst) { uses_.Add(inst); }
 
     /// @returns the vector of instructions which use this value. An instruction will only be
     /// returned once even if that instruction uses the given value multiple times.
@@ -53,7 +53,7 @@
     /// Write the value to the given stream
     /// @param out the stream to write to
     /// @returns the stream
-    virtual utils::StringStream& ToString(utils::StringStream& out) const = 0;
+    virtual utils::StringStream& ToValue(utils::StringStream& out) const = 0;
 
   protected:
     /// Constructor
diff --git a/src/tint/ir/var.cc b/src/tint/ir/var.cc
new file mode 100644
index 0000000..740a35e
--- /dev/null
+++ b/src/tint/ir/var.cc
@@ -0,0 +1,35 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/ir/var.h"
+#include "src/tint/debug.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::ir::Var);
+
+namespace tint::ir {
+
+Var::Var(uint32_t id,
+         const type::Type* ty,
+         builtin::AddressSpace address_space,
+         builtin::Access access)
+    : Base(id, ty), address_space_(address_space), access_(access) {}
+
+Var::~Var() = default;
+
+utils::StringStream& Var::ToInstruction(utils::StringStream& out) const {
+    ToValue(out) << " = var " << address_space_ << " " << access_;
+    return out;
+}
+
+}  // namespace tint::ir
diff --git a/src/tint/ir/var.h b/src/tint/ir/var.h
new file mode 100644
index 0000000..456e7d3
--- /dev/null
+++ b/src/tint/ir/var.h
@@ -0,0 +1,63 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_IR_VAR_H_
+#define SRC_TINT_IR_VAR_H_
+
+#include "src/tint/builtin/access.h"
+#include "src/tint/builtin/address_space.h"
+#include "src/tint/ir/instruction.h"
+#include "src/tint/utils/castable.h"
+#include "src/tint/utils/string_stream.h"
+
+namespace tint::ir {
+
+/// An instruction in the IR.
+class Var : public utils::Castable<Var, Instruction> {
+  public:
+    /// Constructor
+    /// @param id the instruction id
+    /// @param type the type
+    /// @param address_space the address space of the var
+    /// @param access the access mode of the var
+    Var(uint32_t id,
+        const type::Type* type,
+        builtin::AddressSpace address_space,
+        builtin::Access access);
+    Var(const Var& inst) = delete;
+    Var(Var&& inst) = delete;
+    ~Var() override;
+
+    Var& operator=(const Var& inst) = delete;
+    Var& operator=(Var&& inst) = delete;
+
+    /// @returns the address space
+    builtin::AddressSpace AddressSpace() const { return address_space_; }
+
+    /// @returns the access mode
+    builtin::Access Access() const { return access_; }
+
+    /// Write the instruction to the given stream
+    /// @param out the stream to write to
+    /// @returns the stream
+    utils::StringStream& ToInstruction(utils::StringStream& out) const override;
+
+  private:
+    builtin::AddressSpace address_space_;
+    builtin::Access access_;
+};
+
+}  // namespace tint::ir
+
+#endif  // SRC_TINT_IR_VAR_H_
diff --git a/src/tint/program_builder.h b/src/tint/program_builder.h
index b4f5eea..49b14fc 100644
--- a/src/tint/program_builder.h
+++ b/src/tint/program_builder.h
@@ -1470,7 +1470,7 @@
 
     /// @param name the symbol string
     /// @return a Symbol with the given name
-    Symbol Sym(const std::string& name) { return Symbols().Register(name); }
+    Symbol Sym(std::string_view name) { return Symbols().Register(name); }
 
     /// @param enumerator the enumerator
     /// @return a Symbol with the given enum value
diff --git a/src/tint/resolver/attribute_validation_test.cc b/src/tint/resolver/attribute_validation_test.cc
index 098ab17..b9160ce 100644
--- a/src/tint/resolver/attribute_validation_test.cc
+++ b/src/tint/resolver/attribute_validation_test.cc
@@ -131,6 +131,43 @@
     return {};
 }
 
+static std::string name(AttributeKind kind) {
+    switch (kind) {
+        case AttributeKind::kAlign:
+            return "@align";
+        case AttributeKind::kBinding:
+            return "@binding";
+        case AttributeKind::kBuiltin:
+            return "@builtin";
+        case AttributeKind::kDiagnostic:
+            return "@diagnostic";
+        case AttributeKind::kGroup:
+            return "@group";
+        case AttributeKind::kId:
+            return "@id";
+        case AttributeKind::kInterpolate:
+            return "@interpolate";
+        case AttributeKind::kInvariant:
+            return "@invariant";
+        case AttributeKind::kLocation:
+            return "@location";
+        case AttributeKind::kOffset:
+            return "@offset";
+        case AttributeKind::kMustUse:
+            return "@must_use";
+        case AttributeKind::kSize:
+            return "@size";
+        case AttributeKind::kStage:
+            return "@stage";
+        case AttributeKind::kStride:
+            return "@stride";
+        case AttributeKind::kWorkgroup:
+            return "@workgroup_size";
+        case AttributeKind::kBindingAndGroup:
+            return "@binding";
+    }
+    return "<unknown>";
+}
 namespace FunctionInputAndOutputTests {
 using FunctionParameterAttributeTest = TestWithParams;
 TEST_P(FunctionParameterAttributeTest, IsValid) {
@@ -144,11 +181,16 @@
 
     if (params.should_pass) {
         EXPECT_TRUE(r()->Resolve()) << r()->error();
+    } else if (params.kind == AttributeKind::kLocation || params.kind == AttributeKind::kBuiltin ||
+               params.kind == AttributeKind::kInvariant ||
+               params.kind == AttributeKind::kInterpolate) {
+        EXPECT_FALSE(r()->Resolve());
+        EXPECT_EQ(r()->error(), "error: " + name(params.kind) +
+                                    " is not valid for non-entry point function parameters");
     } else {
         EXPECT_FALSE(r()->Resolve());
         EXPECT_EQ(r()->error(),
-                  "error: attribute is not valid for non-entry point function "
-                  "parameters");
+                  "error: " + name(params.kind) + " is not valid for function parameters");
     }
 }
 INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
@@ -184,9 +226,9 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
     } else {
         EXPECT_FALSE(r()->Resolve());
-        EXPECT_EQ(r()->error(),
-                  "error: attribute is not valid for non-entry point function "
-                  "return types");
+        EXPECT_EQ(r()->error(), "error: " + name(params.kind) +
+                                    " is not valid for non-entry point function "
+                                    "return types");
     }
 }
 INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
@@ -234,10 +276,11 @@
         } else if (params.kind == AttributeKind::kInterpolate ||
                    params.kind == AttributeKind::kLocation ||
                    params.kind == AttributeKind::kInvariant) {
-            EXPECT_EQ(r()->error(),
-                      "12:34 error: attribute is not valid for compute shader inputs");
+            EXPECT_EQ(r()->error(), "12:34 error: " + name(params.kind) +
+                                        " is not valid for compute shader inputs");
         } else {
-            EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for function parameters");
+            EXPECT_EQ(r()->error(), "12:34 error: " + name(params.kind) +
+                                        " is not valid for function parameters");
         }
     }
 }
@@ -277,7 +320,8 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
     } else {
         EXPECT_FALSE(r()->Resolve());
-        EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for function parameters");
+        EXPECT_EQ(r()->error(),
+                  "12:34 error: " + name(params.kind) + " is not valid for function parameters");
     }
 }
 INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
@@ -331,7 +375,8 @@
                       "12:34 error: invariant attribute must only be applied to a "
                       "position builtin");
         } else {
-            EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for function parameters");
+            EXPECT_EQ(r()->error(), "12:34 error: " + name(params.kind) +
+                                        " is not valid for function parameters");
         }
     }
 }
@@ -378,12 +423,12 @@
         } else if (params.kind == AttributeKind::kInterpolate ||
                    params.kind == AttributeKind::kLocation ||
                    params.kind == AttributeKind::kInvariant) {
-            EXPECT_EQ(r()->error(),
-                      "12:34 error: attribute is not valid for compute shader output");
+            EXPECT_EQ(r()->error(), "12:34 error: " + name(params.kind) +
+                                        " is not valid for compute shader output");
         } else {
-            EXPECT_EQ(r()->error(),
-                      "12:34 error: attribute is not valid for entry point return "
-                      "types");
+            EXPECT_EQ(r()->error(), "12:34 error: " + name(params.kind) +
+                                        " is not valid for entry point return "
+                                        "types");
         }
     }
 }
@@ -434,8 +479,8 @@
                       R"(34:56 error: duplicate location attribute
 12:34 note: first attribute declared here)");
         } else {
-            EXPECT_EQ(r()->error(),
-                      R"(12:34 error: attribute is not valid for entry point return types)");
+            EXPECT_EQ(r()->error(), "12:34 error: " + name(params.kind) +
+                                        " is not valid for entry point return types");
         }
     }
 }
@@ -484,8 +529,8 @@
                       R"(34:56 error: multiple entry point IO attributes
 12:34 note: previously consumed @location)");
         } else {
-            EXPECT_EQ(r()->error(),
-                      R"(12:34 error: attribute is not valid for entry point return types)");
+            EXPECT_EQ(r()->error(), "12:34 error: " + name(params.kind) +
+                                        " is not valid for entry point return types");
         }
     }
 }
@@ -591,7 +636,8 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
     } else {
         EXPECT_FALSE(r()->Resolve());
-        EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for struct declarations");
+        EXPECT_EQ(r()->error(),
+                  "12:34 error: " + name(params.kind) + " is not valid for struct declarations");
     }
 }
 INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
@@ -628,7 +674,8 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
     } else {
         EXPECT_FALSE(r()->Resolve());
-        EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for structure members");
+        EXPECT_EQ(r()->error(),
+                  "12:34 error: " + name(params.kind) + " is not valid for struct members");
     }
 }
 INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
@@ -871,7 +918,8 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
     } else {
         EXPECT_FALSE(r()->Resolve());
-        EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for array types");
+        EXPECT_EQ(r()->error(),
+                  "12:34 error: " + name(params.kind) + " is not valid for array types");
     }
 }
 INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
@@ -898,7 +946,6 @@
     auto& params = GetParam();
 
     auto attrs = createAttributes(Source{{12, 34}}, *this, params.kind);
-    auto* attr = attrs[0];
     if (IsBindingAttribute(params.kind)) {
         GlobalVar("a", ty.sampler(type::SamplerKind::kSampler), attrs);
     } else {
@@ -910,8 +957,8 @@
     } else {
         EXPECT_FALSE(r()->Resolve());
         if (!IsBindingAttribute(params.kind)) {
-            EXPECT_EQ(r()->error(), "12:34 error: attribute '" + attr->Name() +
-                                        "' is not valid for module-scope 'var'");
+            EXPECT_EQ(r()->error(),
+                      "12:34 error: " + name(params.kind) + " is not valid for module-scope 'var'");
         }
     }
 }
@@ -944,13 +991,22 @@
 12:34 note: first attribute declared here)");
 }
 
-TEST_F(VariableAttributeTest, LocalVariable) {
+TEST_F(VariableAttributeTest, LocalVar) {
     auto* v = Var("a", ty.f32(), utils::Vector{Binding(Source{{12, 34}}, 2_a)});
 
     WrapInFunction(v);
 
     EXPECT_FALSE(r()->Resolve());
-    EXPECT_EQ(r()->error(), "12:34 error: attributes are not valid on local variables");
+    EXPECT_EQ(r()->error(), "12:34 error: @binding is not valid for function-scope 'var'");
+}
+
+TEST_F(VariableAttributeTest, LocalLet) {
+    auto* v = Let("a", utils::Vector{Binding(Source{{12, 34}}, 2_a)}, Expr(1_a));
+
+    WrapInFunction(v);
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(r()->error(), "12:34 error: @binding is not valid for 'let' declaration");
 }
 
 using ConstantAttributeTest = TestWithParams;
@@ -965,7 +1021,7 @@
     } else {
         EXPECT_FALSE(r()->Resolve());
         EXPECT_EQ(r()->error(),
-                  "12:34 error: attribute is not valid for module-scope 'const' declaration");
+                  "12:34 error: " + name(params.kind) + " is not valid for 'const' declaration");
     }
 }
 INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
@@ -987,17 +1043,14 @@
                                          TestParams{AttributeKind::kWorkgroup, false},
                                          TestParams{AttributeKind::kBindingAndGroup, false}));
 
-TEST_F(ConstantAttributeTest, DuplicateAttribute) {
+TEST_F(ConstantAttributeTest, InvalidAttribute) {
     GlobalConst("a", ty.f32(), Expr(1.23_f),
                 utils::Vector{
                     Id(Source{{12, 34}}, 0_a),
-                    Id(Source{{56, 78}}, 1_a),
                 });
 
     EXPECT_FALSE(r()->Resolve());
-    EXPECT_EQ(r()->error(),
-              R"(56:78 error: duplicate id attribute
-12:34 note: first attribute declared here)");
+    EXPECT_EQ(r()->error(), "12:34 error: @id is not valid for 'const' declaration");
 }
 
 using OverrideAttributeTest = TestWithParams;
@@ -1010,7 +1063,8 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
     } else {
         EXPECT_FALSE(r()->Resolve());
-        EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for 'override' declaration");
+        EXPECT_EQ(r()->error(),
+                  "12:34 error: " + name(params.kind) + " is not valid for 'override' declaration");
     }
 }
 INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
@@ -1056,7 +1110,8 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
     } else {
         EXPECT_FALSE(r()->Resolve());
-        EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for switch statements");
+        EXPECT_EQ(r()->error(),
+                  "12:34 error: " + name(params.kind) + " is not valid for switch statements");
     }
 }
 INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
@@ -1089,7 +1144,8 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
     } else {
         EXPECT_FALSE(r()->Resolve());
-        EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for switch body");
+        EXPECT_EQ(r()->error(),
+                  "12:34 error: " + name(params.kind) + " is not valid for switch body");
     }
 }
 INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
@@ -1122,7 +1178,8 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
     } else {
         EXPECT_FALSE(r()->Resolve());
-        EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for if statements");
+        EXPECT_EQ(r()->error(),
+                  "12:34 error: " + name(params.kind) + " is not valid for if statements");
     }
 }
 INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
@@ -1155,7 +1212,8 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
     } else {
         EXPECT_FALSE(r()->Resolve());
-        EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for for statements");
+        EXPECT_EQ(r()->error(),
+                  "12:34 error: " + name(params.kind) + " is not valid for for statements");
     }
 }
 INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
@@ -1188,7 +1246,8 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
     } else {
         EXPECT_FALSE(r()->Resolve());
-        EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for loop statements");
+        EXPECT_EQ(r()->error(),
+                  "12:34 error: " + name(params.kind) + " is not valid for loop statements");
     }
 }
 INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
@@ -1221,7 +1280,8 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
     } else {
         EXPECT_FALSE(r()->Resolve());
-        EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for while statements");
+        EXPECT_EQ(r()->error(),
+                  "12:34 error: " + name(params.kind) + " is not valid for while statements");
     }
 }
 INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
@@ -1251,7 +1311,8 @@
             EXPECT_TRUE(r()->Resolve()) << r()->error();
         } else {
             EXPECT_FALSE(r()->Resolve());
-            EXPECT_EQ(r()->error(), "error: attribute is not valid for block statements");
+            EXPECT_EQ(r()->error(),
+                      "error: " + name(GetParam().kind) + " is not valid for block statements");
         }
     }
 };
diff --git a/src/tint/resolver/builtin_structs.cc b/src/tint/resolver/builtin_structs.cc
new file mode 100644
index 0000000..4e45c16
--- /dev/null
+++ b/src/tint/resolver/builtin_structs.cc
@@ -0,0 +1,239 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/resolver/builtin_structs.h"
+
+#include <algorithm>
+#include <string>
+#include <utility>
+
+#include "src/tint/program_builder.h"
+#include "src/tint/switch.h"
+#include "src/tint/type/abstract_float.h"
+#include "src/tint/type/abstract_int.h"
+#include "src/tint/type/vector.h"
+
+namespace tint::resolver {
+
+namespace {
+
+struct NameAndType {
+    std::string_view name;
+    const type::Type* type;
+};
+
+type::Struct* BuildStruct(ProgramBuilder& b,
+                          builtin::Builtin name,
+                          std::initializer_list<NameAndType> member_names_and_types) {
+    uint32_t offset = 0;
+    uint32_t max_align = 0;
+    utils::Vector<const type::StructMember*, 4> members;
+    for (auto& m : member_names_and_types) {
+        uint32_t align = std::max<uint32_t>(m.type->Align(), 1);
+        uint32_t size = m.type->Size();
+        offset = utils::RoundUp(align, offset);
+        max_align = std::max(max_align, align);
+        members.Push(b.create<type::StructMember>(
+            /* name */ b.Sym(m.name),
+            /* type */ m.type,
+            /* index */ static_cast<uint32_t>(members.Length()),
+            /* offset */ offset,
+            /* align */ align,
+            /* size */ size,
+            /* attributes */ type::StructMemberAttributes{}));
+        offset += size;
+    }
+    uint32_t size_without_padding = offset;
+    uint32_t size_with_padding = utils::RoundUp(max_align, offset);
+    return b.create<type::Struct>(
+        /* name */ b.Sym(name),
+        /* members */ std::move(members),
+        /* align */ max_align,
+        /* size */ size_with_padding,
+        /* size_no_padding */ size_without_padding);
+}
+}  // namespace
+
+constexpr std::array kModfVecF32Names{
+    builtin::Builtin::kModfResultVec2F32,
+    builtin::Builtin::kModfResultVec3F32,
+    builtin::Builtin::kModfResultVec4F32,
+};
+constexpr std::array kModfVecF16Names{
+    builtin::Builtin::kModfResultVec2F16,
+    builtin::Builtin::kModfResultVec3F16,
+    builtin::Builtin::kModfResultVec4F16,
+};
+constexpr std::array kModfVecAbstractNames{
+    builtin::Builtin::kModfResultVec2Abstract,
+    builtin::Builtin::kModfResultVec3Abstract,
+    builtin::Builtin::kModfResultVec4Abstract,
+};
+
+type::Struct* CreateModfResult(ProgramBuilder& b, const type::Type* ty) {
+    return Switch(
+        ty,
+        [&](const type::F32*) {
+            return BuildStruct(b, builtin::Builtin::kModfResultF32, {{"fract", ty}, {"whole", ty}});
+        },  //
+        [&](const type::F16*) {
+            return BuildStruct(b, builtin::Builtin::kModfResultF16, {{"fract", ty}, {"whole", ty}});
+        },
+        [&](const type::AbstractFloat*) {
+            auto* abstract = BuildStruct(b, builtin::Builtin::kModfResultAbstract,
+                                         {{"fract", ty}, {"whole", ty}});
+            auto* f32 = b.create<type::F32>();
+            auto* f16 = b.create<type::F16>();
+            abstract->SetConcreteTypes(utils::Vector{
+                BuildStruct(b, builtin::Builtin::kModfResultF32, {{"fract", f32}, {"whole", f32}}),
+                BuildStruct(b, builtin::Builtin::kModfResultF16, {{"fract", f16}, {"whole", f16}}),
+            });
+            return abstract;
+        },
+        [&](const type::Vector* vec) {
+            auto width = vec->Width();
+            return Switch(
+                vec->type(),  //
+                [&](const type::F32*) {
+                    return BuildStruct(b, kModfVecF32Names[width - 2],
+                                       {{"fract", vec}, {"whole", vec}});
+                },
+                [&](const type::F16*) {
+                    return BuildStruct(b, kModfVecF16Names[width - 2],
+                                       {{"fract", vec}, {"whole", vec}});
+                },
+                [&](const type::AbstractFloat*) {
+                    auto* vec_f32 = b.create<type::Vector>(b.create<type::F32>(), width);
+                    auto* vec_f16 = b.create<type::Vector>(b.create<type::F16>(), width);
+                    auto* abstract = BuildStruct(b, kModfVecAbstractNames[width - 2],
+                                                 {{"fract", vec}, {"whole", vec}});
+                    abstract->SetConcreteTypes(utils::Vector{
+                        BuildStruct(b, kModfVecF32Names[width - 2],
+                                    {{"fract", vec_f32}, {"whole", vec_f32}}),
+                        BuildStruct(b, kModfVecF16Names[width - 2],
+                                    {{"fract", vec_f16}, {"whole", vec_f16}}),
+                    });
+                    return abstract;
+                },
+                [&](Default) {
+                    TINT_ICE(Resolver, b.Diagnostics())
+                        << "unhandled modf type: " << b.FriendlyName(ty);
+                    return nullptr;
+                });
+        },
+        [&](Default) {
+            TINT_ICE(Resolver, b.Diagnostics()) << "unhandled modf type: " << b.FriendlyName(ty);
+            return nullptr;
+        });
+}
+
+constexpr std::array kFrexpVecF32Names{
+    builtin::Builtin::kFrexpResultVec2F32,
+    builtin::Builtin::kFrexpResultVec3F32,
+    builtin::Builtin::kFrexpResultVec4F32,
+};
+constexpr std::array kFrexpVecF16Names{
+    builtin::Builtin::kFrexpResultVec2F16,
+    builtin::Builtin::kFrexpResultVec3F16,
+    builtin::Builtin::kFrexpResultVec4F16,
+};
+constexpr std::array kFrexpVecAbstractNames{
+    builtin::Builtin::kFrexpResultVec2Abstract,
+    builtin::Builtin::kFrexpResultVec3Abstract,
+    builtin::Builtin::kFrexpResultVec4Abstract,
+};
+type::Struct* CreateFrexpResult(ProgramBuilder& b, const type::Type* ty) {
+    return Switch(
+        ty,  //
+        [&](const type::F32*) {
+            auto* i32 = b.create<type::I32>();
+            return BuildStruct(b, builtin::Builtin::kFrexpResultF32, {{"fract", ty}, {"exp", i32}});
+        },
+        [&](const type::F16*) {
+            auto* i32 = b.create<type::I32>();
+            return BuildStruct(b, builtin::Builtin::kFrexpResultF16, {{"fract", ty}, {"exp", i32}});
+        },
+        [&](const type::AbstractFloat*) {
+            auto* f32 = b.create<type::F32>();
+            auto* f16 = b.create<type::F16>();
+            auto* i32 = b.create<type::I32>();
+            auto* ai = b.create<type::AbstractInt>();
+            auto* abstract = BuildStruct(b, builtin::Builtin::kFrexpResultAbstract,
+                                         {{"fract", ty}, {"exp", ai}});
+            abstract->SetConcreteTypes(utils::Vector{
+                BuildStruct(b, builtin::Builtin::kFrexpResultF32, {{"fract", f32}, {"exp", i32}}),
+                BuildStruct(b, builtin::Builtin::kFrexpResultF16, {{"fract", f16}, {"exp", i32}}),
+            });
+            return abstract;
+        },
+        [&](const type::Vector* vec) {
+            auto width = vec->Width();
+            return Switch(
+                vec->type(),  //
+                [&](const type::F32*) {
+                    auto* vec_i32 = b.create<type::Vector>(b.create<type::I32>(), width);
+                    return BuildStruct(b, kFrexpVecF32Names[width - 2],
+                                       {{"fract", ty}, {"exp", vec_i32}});
+                },
+                [&](const type::F16*) {
+                    auto* vec_i32 = b.create<type::Vector>(b.create<type::I32>(), width);
+                    return BuildStruct(b, kFrexpVecF16Names[width - 2],
+                                       {{"fract", ty}, {"exp", vec_i32}});
+                },
+                [&](const type::AbstractFloat*) {
+                    auto* vec_f32 = b.create<type::Vector>(b.create<type::F32>(), width);
+                    auto* vec_f16 = b.create<type::Vector>(b.create<type::F16>(), width);
+                    auto* vec_i32 = b.create<type::Vector>(b.create<type::I32>(), width);
+                    auto* vec_ai = b.create<type::Vector>(b.create<type::AbstractInt>(), width);
+                    auto* abstract = BuildStruct(b, kFrexpVecAbstractNames[width - 2],
+                                                 {{"fract", ty}, {"exp", vec_ai}});
+                    abstract->SetConcreteTypes(utils::Vector{
+                        BuildStruct(b, kFrexpVecF32Names[width - 2],
+                                    {{"fract", vec_f32}, {"exp", vec_i32}}),
+                        BuildStruct(b, kFrexpVecF16Names[width - 2],
+                                    {{"fract", vec_f16}, {"exp", vec_i32}}),
+                    });
+                    return abstract;
+                },
+                [&](Default) {
+                    TINT_ICE(Resolver, b.Diagnostics())
+                        << "unhandled frexp type: " << b.FriendlyName(ty);
+                    return nullptr;
+                });
+        },
+        [&](Default) {
+            TINT_ICE(Resolver, b.Diagnostics()) << "unhandled frexp type: " << b.FriendlyName(ty);
+            return nullptr;
+        });
+}
+
+type::Struct* CreateAtomicCompareExchangeResult(ProgramBuilder& b, const type::Type* ty) {
+    return Switch(
+        ty,  //
+        [&](const type::I32*) {
+            return BuildStruct(b, builtin::Builtin::kAtomicCompareExchangeResultI32,
+                               {{"old_value", ty}, {"exchanged", b.create<type::Bool>()}});
+        },
+        [&](const type::U32*) {
+            return BuildStruct(b, builtin::Builtin::kAtomicCompareExchangeResultU32,
+                               {{"old_value", ty}, {"exchanged", b.create<type::Bool>()}});
+        },
+        [&](Default) {
+            TINT_ICE(Resolver, b.Diagnostics())
+                << "unhandled atomic_compare_exchange type: " << b.FriendlyName(ty);
+            return nullptr;
+        });
+}
+
+}  // namespace tint::resolver
diff --git a/src/tint/resolver/builtin_structs.h b/src/tint/resolver/builtin_structs.h
new file mode 100644
index 0000000..b8f56c7
--- /dev/null
+++ b/src/tint/resolver/builtin_structs.h
@@ -0,0 +1,49 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_RESOLVER_BUILTIN_STRUCTS_H_
+#define SRC_TINT_RESOLVER_BUILTIN_STRUCTS_H_
+
+// Forward declarations
+namespace tint {
+class ProgramBuilder;
+}  // namespace tint
+namespace tint::type {
+class Struct;
+class Type;
+}  // namespace tint::type
+
+namespace tint::resolver {
+
+/**
+ * @param ty the type of the `fract` and `whole` struct members.
+ * @return the builtin struct type for a modf() builtin call.
+ */
+type::Struct* CreateModfResult(ProgramBuilder& b, const type::Type* ty);
+
+/**
+ * @param fract the type of the `fract` struct member.
+ * @return the builtin struct type for a frexp() builtin call.
+ */
+type::Struct* CreateFrexpResult(ProgramBuilder& b, const type::Type* fract);
+
+/**
+ * @param ty the type of the `old_value` struct member.
+ * @return the builtin struct type for a atomic_compare_exchange() builtin call.
+ */
+type::Struct* CreateAtomicCompareExchangeResult(ProgramBuilder& b, const type::Type* ty);
+
+}  // namespace tint::resolver
+
+#endif  // SRC_TINT_RESOLVER_BUILTIN_STRUCTS_H_
diff --git a/src/tint/resolver/builtin_structs_test.cc b/src/tint/resolver/builtin_structs_test.cc
new file mode 100644
index 0000000..9adf209
--- /dev/null
+++ b/src/tint/resolver/builtin_structs_test.cc
@@ -0,0 +1,73 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/resolver/resolver.h"
+#include "src/tint/resolver/resolver_test_helper.h"
+
+#include "gmock/gmock.h"
+
+using namespace tint::number_suffixes;  // NOLINT
+
+namespace tint::resolver {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+// access
+////////////////////////////////////////////////////////////////////////////////
+using ResolverBuiltinStructs = ResolverTestWithParam<builtin::Builtin>;
+
+TEST_P(ResolverBuiltinStructs, Resolve) {
+    Enable(builtin::Extension::kF16);
+
+    // var<private> p : NAME;
+    auto* var = GlobalVar("p", ty(GetParam()), builtin::AddressSpace::kPrivate);
+
+    ASSERT_TRUE(r()->Resolve()) << r()->error();
+    auto* str = As<type::Struct>(TypeOf(var)->UnwrapRef());
+    ASSERT_NE(str, nullptr);
+    EXPECT_EQ(str->Name().Name(), utils::ToString(GetParam()));
+    EXPECT_FALSE(Is<sem::Struct>(str));
+}
+
+INSTANTIATE_TEST_SUITE_P(,
+                         ResolverBuiltinStructs,
+                         testing::Values(builtin::Builtin::kAtomicCompareExchangeResultI32,
+                                         builtin::Builtin::kAtomicCompareExchangeResultU32,
+                                         builtin::Builtin::kFrexpResultAbstract,
+                                         builtin::Builtin::kFrexpResultF16,
+                                         builtin::Builtin::kFrexpResultF32,
+                                         builtin::Builtin::kFrexpResultVec2Abstract,
+                                         builtin::Builtin::kFrexpResultVec2F16,
+                                         builtin::Builtin::kFrexpResultVec2F32,
+                                         builtin::Builtin::kFrexpResultVec3Abstract,
+                                         builtin::Builtin::kFrexpResultVec3F16,
+                                         builtin::Builtin::kFrexpResultVec3F32,
+                                         builtin::Builtin::kFrexpResultVec4Abstract,
+                                         builtin::Builtin::kFrexpResultVec4F16,
+                                         builtin::Builtin::kFrexpResultVec4F32,
+                                         builtin::Builtin::kModfResultAbstract,
+                                         builtin::Builtin::kModfResultF16,
+                                         builtin::Builtin::kModfResultF32,
+                                         builtin::Builtin::kModfResultVec2Abstract,
+                                         builtin::Builtin::kModfResultVec2F16,
+                                         builtin::Builtin::kModfResultVec2F32,
+                                         builtin::Builtin::kModfResultVec3Abstract,
+                                         builtin::Builtin::kModfResultVec3F16,
+                                         builtin::Builtin::kModfResultVec3F32,
+                                         builtin::Builtin::kModfResultVec4Abstract,
+                                         builtin::Builtin::kModfResultVec4F16,
+                                         builtin::Builtin::kModfResultVec4F32));
+
+}  // namespace
+}  // namespace tint::resolver
diff --git a/src/tint/resolver/builtin_test.cc b/src/tint/resolver/builtin_test.cc
index 8cfbc67..60c01f7 100644
--- a/src/tint/resolver/builtin_test.cc
+++ b/src/tint/resolver/builtin_test.cc
@@ -925,7 +925,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    auto* ty = TypeOf(call)->As<sem::Struct>();
+    auto* ty = TypeOf(call)->As<type::Struct>();
     ASSERT_NE(ty, nullptr);
     ASSERT_EQ(ty->Members().Length(), 2u);
 
@@ -956,7 +956,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    auto* ty = TypeOf(call)->As<sem::Struct>();
+    auto* ty = TypeOf(call)->As<type::Struct>();
     ASSERT_NE(ty, nullptr);
     ASSERT_EQ(ty->Members().Length(), 2u);
 
@@ -985,7 +985,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    auto* ty = TypeOf(call)->As<sem::Struct>();
+    auto* ty = TypeOf(call)->As<type::Struct>();
     ASSERT_NE(ty, nullptr);
     ASSERT_EQ(ty->Members().Length(), 2u);
 
@@ -1020,7 +1020,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    auto* ty = TypeOf(call)->As<sem::Struct>();
+    auto* ty = TypeOf(call)->As<type::Struct>();
     ASSERT_NE(ty, nullptr);
     ASSERT_EQ(ty->Members().Length(), 2u);
 
@@ -1174,7 +1174,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    auto* ty = TypeOf(call)->As<sem::Struct>();
+    auto* ty = TypeOf(call)->As<type::Struct>();
     ASSERT_NE(ty, nullptr);
     ASSERT_EQ(ty->Members().Length(), 2u);
 
@@ -1205,7 +1205,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    auto* ty = TypeOf(call)->As<sem::Struct>();
+    auto* ty = TypeOf(call)->As<type::Struct>();
     ASSERT_NE(ty, nullptr);
     ASSERT_EQ(ty->Members().Length(), 2u);
 
@@ -1234,7 +1234,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    auto* ty = TypeOf(call)->As<sem::Struct>();
+    auto* ty = TypeOf(call)->As<type::Struct>();
     ASSERT_NE(ty, nullptr);
     ASSERT_EQ(ty->Members().Length(), 2u);
 
@@ -1269,7 +1269,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    auto* ty = TypeOf(call)->As<sem::Struct>();
+    auto* ty = TypeOf(call)->As<type::Struct>();
     ASSERT_NE(ty, nullptr);
     ASSERT_EQ(ty->Members().Length(), 2u);
 
diff --git a/src/tint/resolver/builtins_validation_test.cc b/src/tint/resolver/builtins_validation_test.cc
index a985a1d..d5f8c4f 100644
--- a/src/tint/resolver/builtins_validation_test.cc
+++ b/src/tint/resolver/builtins_validation_test.cc
@@ -948,7 +948,7 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    auto* res_ty = TypeOf(builtin)->As<sem::Struct>();
+    auto* res_ty = TypeOf(builtin)->As<type::Struct>();
     ASSERT_TRUE(res_ty != nullptr);
     auto members = res_ty->Members();
     ASSERT_EQ(members.Length(), 2u);
@@ -961,7 +961,7 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    auto* res_ty = TypeOf(builtin)->As<sem::Struct>();
+    auto* res_ty = TypeOf(builtin)->As<type::Struct>();
     ASSERT_TRUE(res_ty != nullptr);
     auto members = res_ty->Members();
     ASSERT_EQ(members.Length(), 2u);
@@ -978,7 +978,7 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    auto* res_ty = TypeOf(builtin)->As<sem::Struct>();
+    auto* res_ty = TypeOf(builtin)->As<type::Struct>();
     ASSERT_TRUE(res_ty != nullptr);
     auto members = res_ty->Members();
     ASSERT_EQ(members.Length(), 2u);
@@ -995,7 +995,7 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    auto* res_ty = TypeOf(builtin)->As<sem::Struct>();
+    auto* res_ty = TypeOf(builtin)->As<type::Struct>();
     ASSERT_TRUE(res_ty != nullptr);
     auto members = res_ty->Members();
     ASSERT_EQ(members.Length(), 2u);
@@ -1012,7 +1012,7 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    auto* res_ty = TypeOf(builtin)->As<sem::Struct>();
+    auto* res_ty = TypeOf(builtin)->As<type::Struct>();
     ASSERT_TRUE(res_ty != nullptr);
     auto members = res_ty->Members();
     ASSERT_EQ(members.Length(), 2u);
@@ -1025,7 +1025,7 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    auto* res_ty = TypeOf(builtin)->As<sem::Struct>();
+    auto* res_ty = TypeOf(builtin)->As<type::Struct>();
     ASSERT_TRUE(res_ty != nullptr);
     auto members = res_ty->Members();
     ASSERT_EQ(members.Length(), 2u);
@@ -1042,7 +1042,7 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    auto* res_ty = TypeOf(builtin)->As<sem::Struct>();
+    auto* res_ty = TypeOf(builtin)->As<type::Struct>();
     ASSERT_TRUE(res_ty != nullptr);
     auto members = res_ty->Members();
     ASSERT_EQ(members.Length(), 2u);
@@ -1059,7 +1059,7 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    auto* res_ty = TypeOf(builtin)->As<sem::Struct>();
+    auto* res_ty = TypeOf(builtin)->As<type::Struct>();
     ASSERT_TRUE(res_ty != nullptr);
     auto members = res_ty->Members();
     ASSERT_EQ(members.Length(), 2u);
diff --git a/src/tint/resolver/const_eval_builtin_test.cc b/src/tint/resolver/const_eval_builtin_test.cc
index 2cef1d1..7aecfac 100644
--- a/src/tint/resolver/const_eval_builtin_test.cc
+++ b/src/tint/resolver/const_eval_builtin_test.cc
@@ -166,7 +166,7 @@
         ASSERT_NE(value, nullptr);
         EXPECT_TYPE(value->Type(), sem->Type());
 
-        if (value->Type()->Is<sem::Struct>()) {
+        if (value->Type()->Is<type::Struct>()) {
             // The result type of the constant-evaluated expression is a structure.
             // Compare each of the fields individually.
             for (size_t i = 0; i < expected_case.values.Length(); i++) {
diff --git a/src/tint/resolver/const_eval_construction_test.cc b/src/tint/resolver/const_eval_construction_test.cc
index 361edbf..d8efe8e 100644
--- a/src/tint/resolver/const_eval_construction_test.cc
+++ b/src/tint/resolver/const_eval_construction_test.cc
@@ -1445,7 +1445,7 @@
     ASSERT_NE(sem, nullptr);
     auto* arr = sem->Type()->As<type::Array>();
     ASSERT_NE(arr, nullptr);
-    EXPECT_TRUE(arr->ElemType()->Is<sem::Struct>());
+    EXPECT_TRUE(arr->ElemType()->Is<type::Struct>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
@@ -1662,7 +1662,7 @@
     ASSERT_NE(sem, nullptr);
     auto* arr = sem->Type()->As<type::Array>();
     ASSERT_NE(arr, nullptr);
-    EXPECT_TRUE(arr->ElemType()->Is<sem::Struct>());
+    EXPECT_TRUE(arr->ElemType()->Is<type::Struct>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
@@ -1787,7 +1787,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<sem::Struct>();
+    auto* str = sem->Type()->As<type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 3u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
@@ -1828,7 +1828,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<sem::Struct>();
+    auto* str = sem->Type()->As<type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 5u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
@@ -1875,7 +1875,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<sem::Struct>();
+    auto* str = sem->Type()->As<type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 3u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
@@ -1928,7 +1928,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<sem::Struct>();
+    auto* str = sem->Type()->As<type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 5u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
@@ -1999,7 +1999,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<sem::Struct>();
+    auto* str = sem->Type()->As<type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 2u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
@@ -2009,14 +2009,14 @@
 
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<sem::Struct>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::Struct>());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<i32>(), 0_i);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<u32>(), 0_u);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(2)->ValueAs<f32>(), 0_f);
 
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<sem::Struct>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::Struct>());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->ValueAs<i32>(), 0_i);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<u32>(), 0_u);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->ValueAs<f32>(), 0_f);
@@ -2039,7 +2039,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<sem::Struct>();
+    auto* str = sem->Type()->As<type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 5u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
@@ -2091,7 +2091,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<sem::Struct>();
+    auto* str = sem->Type()->As<type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 5u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
@@ -2163,7 +2163,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<sem::Struct>();
+    auto* str = sem->Type()->As<type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 2u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
@@ -2173,14 +2173,14 @@
 
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<sem::Struct>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::Struct>());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<i32>(), 1_i);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<u32>(), 2_u);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(2)->ValueAs<f32>(), 3_f);
 
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<sem::Struct>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::Struct>());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->ValueAs<i32>(), 4_i);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<u32>(), 0_u);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->ValueAs<f32>(), 6_f);
@@ -2199,7 +2199,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<sem::Struct>();
+    auto* str = sem->Type()->As<type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 2u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
diff --git a/src/tint/resolver/const_eval_member_access_test.cc b/src/tint/resolver/const_eval_member_access_test.cc
index 9a74e6c..ee92714 100644
--- a/src/tint/resolver/const_eval_member_access_test.cc
+++ b/src/tint/resolver/const_eval_member_access_test.cc
@@ -41,7 +41,7 @@
 
     auto* outer = Sem().Get(outer_expr);
     ASSERT_NE(outer, nullptr);
-    auto* str = outer->Type()->As<sem::Struct>();
+    auto* str = outer->Type()->As<type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 2u);
     ASSERT_NE(outer->ConstantValue(), nullptr);
@@ -53,7 +53,7 @@
     ASSERT_NE(o1->ConstantValue(), nullptr);
     EXPECT_FALSE(o1->ConstantValue()->AnyZero());
     EXPECT_FALSE(o1->ConstantValue()->AllZero());
-    EXPECT_TRUE(o1->ConstantValue()->Type()->Is<sem::Struct>());
+    EXPECT_TRUE(o1->ConstantValue()->Type()->Is<type::Struct>());
     EXPECT_EQ(o1->ConstantValue()->Index(0)->ValueAs<i32>(), 1_i);
     EXPECT_EQ(o1->ConstantValue()->Index(1)->ValueAs<u32>(), 2_u);
     EXPECT_EQ(o1->ConstantValue()->Index(2)->ValueAs<f32>(), 3_f);
diff --git a/src/tint/resolver/entry_point_validation_test.cc b/src/tint/resolver/entry_point_validation_test.cc
index dac6cd2..eb2d779 100644
--- a/src/tint/resolver/entry_point_validation_test.cc
+++ b/src/tint/resolver/entry_point_validation_test.cc
@@ -1084,7 +1084,7 @@
          });
 
     EXPECT_FALSE(r()->Resolve());
-    EXPECT_EQ(r()->error(), R"(12:34 error: attribute is not valid for compute shader output)");
+    EXPECT_EQ(r()->error(), R"(12:34 error: @location is not valid for compute shader output)");
 }
 
 TEST_F(LocationAttributeTests, ComputeShaderLocation_Output) {
@@ -1099,7 +1099,7 @@
          });
 
     EXPECT_FALSE(r()->Resolve());
-    EXPECT_EQ(r()->error(), R"(12:34 error: attribute is not valid for compute shader inputs)");
+    EXPECT_EQ(r()->error(), R"(12:34 error: @location is not valid for compute shader inputs)");
 }
 
 TEST_F(LocationAttributeTests, ComputeShaderLocationStructMember_Output) {
@@ -1119,7 +1119,7 @@
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
-              "12:34 error: attribute is not valid for compute shader output\n"
+              "12:34 error: @location is not valid for compute shader output\n"
               "56:78 note: while analyzing entry point 'main'");
 }
 
@@ -1138,7 +1138,7 @@
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
-              "12:34 error: attribute is not valid for compute shader inputs\n"
+              "12:34 error: @location is not valid for compute shader inputs\n"
               "56:78 note: while analyzing entry point 'main'");
 }
 
diff --git a/src/tint/resolver/inferred_type_test.cc b/src/tint/resolver/inferred_type_test.cc
index ab2478b..4545419 100644
--- a/src/tint/resolver/inferred_type_test.cc
+++ b/src/tint/resolver/inferred_type_test.cc
@@ -151,9 +151,9 @@
     auto* str = Structure("S", utils::Vector{member});
 
     auto* expected_type = create<sem::Struct>(
-        str, str->source, str->name->symbol,
-        utils::Vector{create<sem::StructMember>(member, member->source, member->name->symbol,
-                                                create<type::I32>(), 0u, 0u, 0u, 4u, std::nullopt)},
+        str, str->name->symbol,
+        utils::Vector{create<sem::StructMember>(member, member->name->symbol, create<type::I32>(),
+                                                0u, 0u, 0u, 4u, type::StructMemberAttributes{})},
         0u, 4u, 4u);
 
     auto* ctor_expr = Call(ty.Of(str));
diff --git a/src/tint/resolver/intrinsic_table.cc b/src/tint/resolver/intrinsic_table.cc
index fc226eb..4295bb3 100644
--- a/src/tint/resolver/intrinsic_table.cc
+++ b/src/tint/resolver/intrinsic_table.cc
@@ -20,6 +20,7 @@
 
 #include "src/tint/ast/binary_expression.h"
 #include "src/tint/program_builder.h"
+#include "src/tint/resolver/builtin_structs.h"
 #include "src/tint/sem/evaluation_stage.h"
 #include "src/tint/sem/pipeline_stage_set.h"
 #include "src/tint/sem/value_constructor.h"
@@ -819,170 +820,26 @@
     return false;
 }
 
-struct NameAndType {
-    std::string name;
-    const type::Type* type;
-};
-sem::Struct* build_struct(ProgramBuilder& b,
-                          std::string name,
-                          std::initializer_list<NameAndType> member_names_and_types) {
-    uint32_t offset = 0;
-    uint32_t max_align = 0;
-    utils::Vector<const sem::StructMember*, 4> members;
-    for (auto& m : member_names_and_types) {
-        uint32_t align = std::max<uint32_t>(m.type->Align(), 1);
-        uint32_t size = m.type->Size();
-        offset = utils::RoundUp(align, offset);
-        max_align = std::max(max_align, align);
-        members.Push(b.create<sem::StructMember>(
-            /* declaration */ nullptr,
-            /* source */ Source{},
-            /* name */ b.Sym(m.name),
-            /* type */ m.type,
-            /* index */ static_cast<uint32_t>(members.Length()),
-            /* offset */ offset,
-            /* align */ align,
-            /* size */ size,
-            /* location */ std::nullopt));
-        offset += size;
-    }
-    uint32_t size_without_padding = offset;
-    uint32_t size_with_padding = utils::RoundUp(max_align, offset);
-    return b.create<sem::Struct>(
-        /* declaration */ nullptr,
-        /* source */ Source{},
-        /* name */ b.Sym(name),
-        /* members */ std::move(members),
-        /* align */ max_align,
-        /* size */ size_with_padding,
-        /* size_no_padding */ size_without_padding);
+const type::Struct* build_modf_result(MatchState& state, const type::Type* el) {
+    return CreateModfResult(state.builder, el);
 }
 
-const sem::Struct* build_modf_result(MatchState& state, const type::Type* el) {
-    auto build_f32 = [&] {
-        auto* ty = state.builder.create<type::F32>();
-        return build_struct(state.builder, "__modf_result_f32", {{"fract", ty}, {"whole", ty}});
-    };
-    auto build_f16 = [&] {
-        auto* ty = state.builder.create<type::F16>();
-        return build_struct(state.builder, "__modf_result_f16", {{"fract", ty}, {"whole", ty}});
-    };
-
-    return Switch(
-        el,                                             //
-        [&](const type::F32*) { return build_f32(); },  //
-        [&](const type::F16*) { return build_f16(); },  //
-        [&](const type::AbstractFloat*) {
-            auto* abstract = build_struct(state.builder, "__modf_result_abstract",
-                                          {{"fract", el}, {"whole", el}});
-            abstract->SetConcreteTypes(utils::Vector{build_f32(), build_f16()});
-            return abstract;
-        },
-        [&](Default) {
-            TINT_ICE(Resolver, state.builder.Diagnostics())
-                << "unhandled modf type: " << state.builder.FriendlyName(el);
-            return nullptr;
-        });
+const type::Struct* build_modf_result_vec(MatchState& state, Number& n, const type::Type* el) {
+    auto* vec = state.builder.create<type::Vector>(el, n.Value());
+    return CreateModfResult(state.builder, vec);
 }
 
-const sem::Struct* build_modf_result_vec(MatchState& state, Number& n, const type::Type* el) {
-    auto prefix = "__modf_result_vec" + std::to_string(n.Value());
-    auto build_f32 = [&] {
-        auto* vec =
-            state.builder.create<type::Vector>(state.builder.create<type::F32>(), n.Value());
-        return build_struct(state.builder, prefix + "_f32", {{"fract", vec}, {"whole", vec}});
-    };
-    auto build_f16 = [&] {
-        auto* vec =
-            state.builder.create<type::Vector>(state.builder.create<type::F16>(), n.Value());
-        return build_struct(state.builder, prefix + "_f16", {{"fract", vec}, {"whole", vec}});
-    };
-
-    return Switch(
-        el,                                             //
-        [&](const type::F32*) { return build_f32(); },  //
-        [&](const type::F16*) { return build_f16(); },  //
-        [&](const type::AbstractFloat*) {
-            auto* vec = state.builder.create<type::Vector>(el, n.Value());
-            auto* abstract =
-                build_struct(state.builder, prefix + "_abstract", {{"fract", vec}, {"whole", vec}});
-            abstract->SetConcreteTypes(utils::Vector{build_f32(), build_f16()});
-            return abstract;
-        },
-        [&](Default) {
-            TINT_ICE(Resolver, state.builder.Diagnostics())
-                << "unhandled modf type: " << state.builder.FriendlyName(el);
-            return nullptr;
-        });
+const type::Struct* build_frexp_result(MatchState& state, const type::Type* el) {
+    return CreateFrexpResult(state.builder, el);
 }
 
-const sem::Struct* build_frexp_result(MatchState& state, const type::Type* el) {
-    auto build_f32 = [&] {
-        auto* f = state.builder.create<type::F32>();
-        auto* i = state.builder.create<type::I32>();
-        return build_struct(state.builder, "__frexp_result_f32", {{"fract", f}, {"exp", i}});
-    };
-    auto build_f16 = [&] {
-        auto* f = state.builder.create<type::F16>();
-        auto* i = state.builder.create<type::I32>();
-        return build_struct(state.builder, "__frexp_result_f16", {{"fract", f}, {"exp", i}});
-    };
-
-    return Switch(
-        el,                                             //
-        [&](const type::F32*) { return build_f32(); },  //
-        [&](const type::F16*) { return build_f16(); },  //
-        [&](const type::AbstractFloat*) {
-            auto* i = state.builder.create<type::AbstractInt>();
-            auto* abstract =
-                build_struct(state.builder, "__frexp_result_abstract", {{"fract", el}, {"exp", i}});
-            abstract->SetConcreteTypes(utils::Vector{build_f32(), build_f16()});
-            return abstract;
-        },
-        [&](Default) {
-            TINT_ICE(Resolver, state.builder.Diagnostics())
-                << "unhandled frexp type: " << state.builder.FriendlyName(el);
-            return nullptr;
-        });
+const type::Struct* build_frexp_result_vec(MatchState& state, Number& n, const type::Type* el) {
+    auto* vec = state.builder.create<type::Vector>(el, n.Value());
+    return CreateFrexpResult(state.builder, vec);
 }
 
-const sem::Struct* build_frexp_result_vec(MatchState& state, Number& n, const type::Type* el) {
-    auto prefix = "__frexp_result_vec" + std::to_string(n.Value());
-    auto build_f32 = [&] {
-        auto* f = state.builder.create<type::Vector>(state.builder.create<type::F32>(), n.Value());
-        auto* e = state.builder.create<type::Vector>(state.builder.create<type::I32>(), n.Value());
-        return build_struct(state.builder, prefix + "_f32", {{"fract", f}, {"exp", e}});
-    };
-    auto build_f16 = [&] {
-        auto* f = state.builder.create<type::Vector>(state.builder.create<type::F16>(), n.Value());
-        auto* e = state.builder.create<type::Vector>(state.builder.create<type::I32>(), n.Value());
-        return build_struct(state.builder, prefix + "_f16", {{"fract", f}, {"exp", e}});
-    };
-
-    return Switch(
-        el,                                             //
-        [&](const type::F32*) { return build_f32(); },  //
-        [&](const type::F16*) { return build_f16(); },  //
-        [&](const type::AbstractFloat*) {
-            auto* f = state.builder.create<type::Vector>(el, n.Value());
-            auto* e = state.builder.create<type::Vector>(state.builder.create<type::AbstractInt>(),
-                                                         n.Value());
-            auto* abstract =
-                build_struct(state.builder, prefix + "_abstract", {{"fract", f}, {"exp", e}});
-            abstract->SetConcreteTypes(utils::Vector{build_f32(), build_f16()});
-            return abstract;
-        },
-        [&](Default) {
-            TINT_ICE(Resolver, state.builder.Diagnostics())
-                << "unhandled frexp type: " << state.builder.FriendlyName(el);
-            return nullptr;
-        });
-}
-
-const sem::Struct* build_atomic_compare_exchange_result(MatchState& state, const type::Type* ty) {
-    return build_struct(state.builder, "__atomic_compare_exchange_result" + ty->FriendlyName(),
-                        {{"old_value", const_cast<type::Type*>(ty)},
-                         {"exchanged", state.builder.create<type::Bool>()}});
+const type::Struct* build_atomic_compare_exchange_result(MatchState& state, const type::Type* ty) {
+    return CreateAtomicCompareExchangeResult(state.builder, ty);
 }
 
 /// ParameterInfo describes a parameter
diff --git a/src/tint/resolver/materialize_test.cc b/src/tint/resolver/materialize_test.cc
index 6fa2010..94d916c 100644
--- a/src/tint/resolver/materialize_test.cc
+++ b/src/tint/resolver/materialize_test.cc
@@ -1253,11 +1253,11 @@
     auto* sem = Sem().Get(call);
     ASSERT_TRUE(sem->Is<sem::Materialize>());
     auto* materialize = sem->As<sem::Materialize>();
-    ASSERT_TRUE(materialize->Type()->Is<sem::Struct>());
-    auto* concrete_str = materialize->Type()->As<sem::Struct>();
+    ASSERT_TRUE(materialize->Type()->Is<type::Struct>());
+    auto* concrete_str = materialize->Type()->As<type::Struct>();
     ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::F32>());
-    ASSERT_TRUE(materialize->Expr()->Type()->Is<sem::Struct>());
-    auto* abstract_str = materialize->Expr()->Type()->As<sem::Struct>();
+    ASSERT_TRUE(materialize->Expr()->Type()->Is<type::Struct>());
+    auto* abstract_str = materialize->Expr()->Type()->As<type::Struct>();
     ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::AbstractFloat>());
 }
 
@@ -1269,12 +1269,12 @@
     auto* sem = Sem().Get(call);
     ASSERT_TRUE(sem->Is<sem::Materialize>());
     auto* materialize = sem->As<sem::Materialize>();
-    ASSERT_TRUE(materialize->Type()->Is<sem::Struct>());
-    auto* concrete_str = materialize->Type()->As<sem::Struct>();
+    ASSERT_TRUE(materialize->Type()->Is<type::Struct>());
+    auto* concrete_str = materialize->Type()->As<type::Struct>();
     ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::Vector>());
     ASSERT_TRUE(concrete_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
-    ASSERT_TRUE(materialize->Expr()->Type()->Is<sem::Struct>());
-    auto* abstract_str = materialize->Expr()->Type()->As<sem::Struct>();
+    ASSERT_TRUE(materialize->Expr()->Type()->Is<type::Struct>());
+    auto* abstract_str = materialize->Expr()->Type()->As<type::Struct>();
     ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::Vector>());
     ASSERT_TRUE(
         abstract_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::AbstractFloat>());
@@ -1291,11 +1291,11 @@
     auto* sem = Sem().Get(call);
     ASSERT_TRUE(sem->Is<sem::Materialize>());
     auto* materialize = sem->As<sem::Materialize>();
-    ASSERT_TRUE(materialize->Type()->Is<sem::Struct>());
-    auto* concrete_str = materialize->Type()->As<sem::Struct>();
+    ASSERT_TRUE(materialize->Type()->Is<type::Struct>());
+    auto* concrete_str = materialize->Type()->As<type::Struct>();
     ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::F16>());
-    ASSERT_TRUE(materialize->Expr()->Type()->Is<sem::Struct>());
-    auto* abstract_str = materialize->Expr()->Type()->As<sem::Struct>();
+    ASSERT_TRUE(materialize->Expr()->Type()->Is<type::Struct>());
+    auto* abstract_str = materialize->Expr()->Type()->As<type::Struct>();
     ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::AbstractFloat>());
 }
 
@@ -1309,12 +1309,12 @@
     auto* sem = Sem().Get(call);
     ASSERT_TRUE(sem->Is<sem::Materialize>());
     auto* materialize = sem->As<sem::Materialize>();
-    ASSERT_TRUE(materialize->Type()->Is<sem::Struct>());
-    auto* concrete_str = materialize->Type()->As<sem::Struct>();
+    ASSERT_TRUE(materialize->Type()->Is<type::Struct>());
+    auto* concrete_str = materialize->Type()->As<type::Struct>();
     ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::Vector>());
     ASSERT_TRUE(concrete_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::F16>());
-    ASSERT_TRUE(materialize->Expr()->Type()->Is<sem::Struct>());
-    auto* abstract_str = materialize->Expr()->Type()->As<sem::Struct>();
+    ASSERT_TRUE(materialize->Expr()->Type()->Is<type::Struct>());
+    auto* abstract_str = materialize->Expr()->Type()->As<type::Struct>();
     ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::Vector>());
     ASSERT_TRUE(
         abstract_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::AbstractFloat>());
@@ -1328,12 +1328,12 @@
     auto* sem = Sem().Get(call);
     ASSERT_TRUE(sem->Is<sem::Materialize>());
     auto* materialize = sem->As<sem::Materialize>();
-    ASSERT_TRUE(materialize->Type()->Is<sem::Struct>());
-    auto* concrete_str = materialize->Type()->As<sem::Struct>();
+    ASSERT_TRUE(materialize->Type()->Is<type::Struct>());
+    auto* concrete_str = materialize->Type()->As<type::Struct>();
     ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::F32>());
     ASSERT_TRUE(concrete_str->Members()[1]->Type()->Is<type::I32>());
-    ASSERT_TRUE(materialize->Expr()->Type()->Is<sem::Struct>());
-    auto* abstract_str = materialize->Expr()->Type()->As<sem::Struct>();
+    ASSERT_TRUE(materialize->Expr()->Type()->Is<type::Struct>());
+    auto* abstract_str = materialize->Expr()->Type()->As<type::Struct>();
     ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::AbstractFloat>());
     ASSERT_TRUE(abstract_str->Members()[1]->Type()->Is<type::AbstractInt>());
 }
@@ -1346,14 +1346,14 @@
     auto* sem = Sem().Get(call);
     ASSERT_TRUE(sem->Is<sem::Materialize>());
     auto* materialize = sem->As<sem::Materialize>();
-    ASSERT_TRUE(materialize->Type()->Is<sem::Struct>());
-    auto* concrete_str = materialize->Type()->As<sem::Struct>();
+    ASSERT_TRUE(materialize->Type()->Is<type::Struct>());
+    auto* concrete_str = materialize->Type()->As<type::Struct>();
     ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::Vector>());
     ASSERT_TRUE(concrete_str->Members()[1]->Type()->Is<type::Vector>());
     ASSERT_TRUE(concrete_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
     ASSERT_TRUE(concrete_str->Members()[1]->Type()->As<type::Vector>()->type()->Is<type::I32>());
-    ASSERT_TRUE(materialize->Expr()->Type()->Is<sem::Struct>());
-    auto* abstract_str = materialize->Expr()->Type()->As<sem::Struct>();
+    ASSERT_TRUE(materialize->Expr()->Type()->Is<type::Struct>());
+    auto* abstract_str = materialize->Expr()->Type()->As<type::Struct>();
     ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::Vector>());
     ASSERT_TRUE(
         abstract_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::AbstractFloat>());
@@ -1372,12 +1372,12 @@
     auto* sem = Sem().Get(call);
     ASSERT_TRUE(sem->Is<sem::Materialize>());
     auto* materialize = sem->As<sem::Materialize>();
-    ASSERT_TRUE(materialize->Type()->Is<sem::Struct>());
-    auto* concrete_str = materialize->Type()->As<sem::Struct>();
+    ASSERT_TRUE(materialize->Type()->Is<type::Struct>());
+    auto* concrete_str = materialize->Type()->As<type::Struct>();
     ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::F16>());
     ASSERT_TRUE(concrete_str->Members()[1]->Type()->Is<type::I32>());
-    ASSERT_TRUE(materialize->Expr()->Type()->Is<sem::Struct>());
-    auto* abstract_str = materialize->Expr()->Type()->As<sem::Struct>();
+    ASSERT_TRUE(materialize->Expr()->Type()->Is<type::Struct>());
+    auto* abstract_str = materialize->Expr()->Type()->As<type::Struct>();
     ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::AbstractFloat>());
     ASSERT_TRUE(abstract_str->Members()[1]->Type()->Is<type::AbstractInt>());
 }
@@ -1392,14 +1392,14 @@
     auto* sem = Sem().Get(call);
     ASSERT_TRUE(sem->Is<sem::Materialize>());
     auto* materialize = sem->As<sem::Materialize>();
-    ASSERT_TRUE(materialize->Type()->Is<sem::Struct>());
-    auto* concrete_str = materialize->Type()->As<sem::Struct>();
+    ASSERT_TRUE(materialize->Type()->Is<type::Struct>());
+    auto* concrete_str = materialize->Type()->As<type::Struct>();
     ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::Vector>());
     ASSERT_TRUE(concrete_str->Members()[1]->Type()->Is<type::Vector>());
     ASSERT_TRUE(concrete_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::F16>());
     ASSERT_TRUE(concrete_str->Members()[1]->Type()->As<type::Vector>()->type()->Is<type::I32>());
-    ASSERT_TRUE(materialize->Expr()->Type()->Is<sem::Struct>());
-    auto* abstract_str = materialize->Expr()->Type()->As<sem::Struct>();
+    ASSERT_TRUE(materialize->Expr()->Type()->Is<type::Struct>());
+    auto* abstract_str = materialize->Expr()->Type()->As<type::Struct>();
     ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::Vector>());
     ASSERT_TRUE(
         abstract_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::AbstractFloat>());
diff --git a/src/tint/resolver/resolver.cc b/src/tint/resolver/resolver.cc
index 58050b9..de29692 100644
--- a/src/tint/resolver/resolver.cc
+++ b/src/tint/resolver/resolver.cc
@@ -43,6 +43,7 @@
 #include "src/tint/ast/while_statement.h"
 #include "src/tint/ast/workgroup_attribute.h"
 #include "src/tint/builtin/builtin.h"
+#include "src/tint/resolver/builtin_structs.h"
 #include "src/tint/resolver/uniformity.h"
 #include "src/tint/sem/break_if_statement.h"
 #include "src/tint/sem/builtin_enum_expression.h"
@@ -246,6 +247,20 @@
         }
     }
 
+    for (auto* attribute : v->attributes) {
+        Mark(attribute);
+        bool ok = Switch(
+            attribute,  //
+            [&](const ast::InternalAttribute* attr) -> bool { return InternalAttribute(attr); },
+            [&](Default) {
+                ErrorInvalidAttribute(attribute, "'let' declaration");
+                return false;
+            });
+        if (!ok) {
+            return nullptr;
+        }
+    }
+
     if (!v->initializer) {
         AddError("'let' declaration must have an initializer", v->source);
         return nullptr;
@@ -339,37 +354,51 @@
         /* constant_value */ nullptr, std::nullopt, std::nullopt);
     sem->SetInitializer(rhs);
 
-    if (auto* id_attr = ast::GetAttribute<ast::IdAttribute>(v->attributes)) {
-        ExprEvalStageConstraint constraint{sem::EvaluationStage::kConstant, "@id"};
-        TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
+    for (auto* attribute : v->attributes) {
+        Mark(attribute);
+        bool ok = Switch(
+            attribute,  //
+            [&](const ast::IdAttribute* attr) {
+                ExprEvalStageConstraint constraint{sem::EvaluationStage::kConstant, "@id"};
+                TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
 
-        auto* materialized = Materialize(ValueExpression(id_attr->expr));
-        if (!materialized) {
+                auto* materialized = Materialize(ValueExpression(attr->expr));
+                if (!materialized) {
+                    return false;
+                }
+                if (!materialized->Type()->IsAnyOf<type::I32, type::U32>()) {
+                    AddError("@id must be an i32 or u32 value", attr->source);
+                    return false;
+                }
+
+                auto const_value = materialized->ConstantValue();
+                auto value = const_value->ValueAs<AInt>();
+                if (value < 0) {
+                    AddError("@id value must be non-negative", attr->source);
+                    return false;
+                }
+                if (value > std::numeric_limits<decltype(OverrideId::value)>::max()) {
+                    AddError(
+                        "@id value must be between 0 and " +
+                            std::to_string(std::numeric_limits<decltype(OverrideId::value)>::max()),
+                        attr->source);
+                    return false;
+                }
+
+                auto o = OverrideId{static_cast<decltype(OverrideId::value)>(value)};
+                sem->SetOverrideId(o);
+
+                // Track the constant IDs that are specified in the shader.
+                override_ids_.Add(o, sem);
+                return true;
+            },
+            [&](Default) {
+                ErrorInvalidAttribute(attribute, "'override' declaration");
+                return false;
+            });
+        if (!ok) {
             return nullptr;
         }
-        if (!materialized->Type()->IsAnyOf<type::I32, type::U32>()) {
-            AddError("@id must be an i32 or u32 value", id_attr->source);
-            return nullptr;
-        }
-
-        auto const_value = materialized->ConstantValue();
-        auto value = const_value->ValueAs<AInt>();
-        if (value < 0) {
-            AddError("@id value must be non-negative", id_attr->source);
-            return nullptr;
-        }
-        if (value > std::numeric_limits<decltype(OverrideId::value)>::max()) {
-            AddError("@id value must be between 0 and " +
-                         std::to_string(std::numeric_limits<decltype(OverrideId::value)>::max()),
-                     id_attr->source);
-            return nullptr;
-        }
-
-        auto o = OverrideId{static_cast<decltype(OverrideId::value)>(value)};
-        sem->SetOverrideId(o);
-
-        // Track the constant IDs that are specified in the shader.
-        override_ids_.Add(o, sem);
     }
 
     builder_->Sem().Add(v, sem);
@@ -392,6 +421,18 @@
         return nullptr;
     }
 
+    for (auto* attribute : c->attributes) {
+        Mark(attribute);
+        bool ok = Switch(attribute,  //
+                         [&](Default) {
+                             ErrorInvalidAttribute(attribute, "'const' declaration");
+                             return false;
+                         });
+        if (!ok) {
+            return nullptr;
+        }
+    }
+
     const sem::ValueExpression* rhs = nullptr;
     {
         ExprEvalStageConstraint constraint{sem::EvaluationStage::kConstant, "const initializer"};
@@ -528,72 +569,98 @@
 
     sem::Variable* sem = nullptr;
     if (is_global) {
+        bool has_io_address_space = address_space == builtin::AddressSpace::kIn ||
+                                    address_space == builtin::AddressSpace::kOut;
+
+        std::optional<uint32_t> group, binding, location;
+        for (auto* attribute : var->attributes) {
+            Mark(attribute);
+            enum Status { kSuccess, kErrored, kInvalid };
+            auto res = Switch(
+                attribute,  //
+                [&](const ast::BindingAttribute* attr) {
+                    auto value = BindingAttribute(attr);
+                    if (!value) {
+                        return kErrored;
+                    }
+                    binding = value.Get();
+                    return kSuccess;
+                },
+                [&](const ast::GroupAttribute* attr) {
+                    auto value = GroupAttribute(attr);
+                    if (!value) {
+                        return kErrored;
+                    }
+                    group = value.Get();
+                    return kSuccess;
+                },
+                [&](const ast::LocationAttribute* attr) {
+                    if (!has_io_address_space) {
+                        return kInvalid;
+                    }
+                    auto value = LocationAttribute(attr);
+                    if (!value) {
+                        return kErrored;
+                    }
+                    location = value.Get();
+                    return kSuccess;
+                },
+                [&](const ast::BuiltinAttribute* attr) {
+                    if (!has_io_address_space) {
+                        return kInvalid;
+                    }
+                    return BuiltinAttribute(attr) ? kSuccess : kErrored;
+                },
+                [&](const ast::InterpolateAttribute* attr) {
+                    if (!has_io_address_space) {
+                        return kInvalid;
+                    }
+                    return InterpolateAttribute(attr) ? kSuccess : kErrored;
+                },
+                [&](const ast::InvariantAttribute* attr) {
+                    if (!has_io_address_space) {
+                        return kInvalid;
+                    }
+                    return InvariantAttribute(attr) ? kSuccess : kErrored;
+                },
+                [&](const ast::InternalAttribute* attr) {
+                    return InternalAttribute(attr) ? kSuccess : kErrored;
+                },
+                [&](Default) { return kInvalid; });
+
+            switch (res) {
+                case kSuccess:
+                    break;
+                case kErrored:
+                    return nullptr;
+                case kInvalid:
+                    ErrorInvalidAttribute(attribute, "module-scope 'var'");
+                    return nullptr;
+            }
+        }
+
         std::optional<sem::BindingPoint> binding_point;
-        if (var->HasBindingPoint()) {
-            uint32_t binding = 0;
-            {
-                ExprEvalStageConstraint constraint{sem::EvaluationStage::kConstant, "@binding"};
-                TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
-
-                auto* attr = ast::GetAttribute<ast::BindingAttribute>(var->attributes);
-                auto* materialized = Materialize(ValueExpression(attr->expr));
-                if (!materialized) {
-                    return nullptr;
-                }
-                if (!materialized->Type()->IsAnyOf<type::I32, type::U32>()) {
-                    AddError("@binding must be an i32 or u32 value", attr->source);
-                    return nullptr;
-                }
-
-                auto const_value = materialized->ConstantValue();
-                auto value = const_value->ValueAs<AInt>();
-                if (value < 0) {
-                    AddError("@binding value must be non-negative", attr->source);
-                    return nullptr;
-                }
-                binding = u32(value);
-            }
-
-            uint32_t group = 0;
-            {
-                ExprEvalStageConstraint constraint{sem::EvaluationStage::kConstant, "@group"};
-                TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
-
-                auto* attr = ast::GetAttribute<ast::GroupAttribute>(var->attributes);
-                auto* materialized = Materialize(ValueExpression(attr->expr));
-                if (!materialized) {
-                    return nullptr;
-                }
-                if (!materialized->Type()->IsAnyOf<type::I32, type::U32>()) {
-                    AddError("@group must be an i32 or u32 value", attr->source);
-                    return nullptr;
-                }
-
-                auto const_value = materialized->ConstantValue();
-                auto value = const_value->ValueAs<AInt>();
-                if (value < 0) {
-                    AddError("@group value must be non-negative", attr->source);
-                    return nullptr;
-                }
-                group = u32(value);
-            }
-            binding_point = {group, binding};
+        if (group && binding) {
+            binding_point = sem::BindingPoint{group.value(), binding.value()};
         }
-
-        std::optional<uint32_t> location;
-        if (auto* attr = ast::GetAttribute<ast::LocationAttribute>(var->attributes)) {
-            auto value = LocationAttribute(attr);
-            if (!value) {
-                return nullptr;
-            }
-            location = value.Get();
-        }
-
         sem = builder_->create<sem::GlobalVariable>(
             var, var_ty, sem::EvaluationStage::kRuntime, address_space, access,
             /* constant_value */ nullptr, binding_point, location);
 
     } else {
+        for (auto* attribute : var->attributes) {
+            Mark(attribute);
+            bool ok = Switch(
+                attribute,
+                [&](const ast::InternalAttribute* attr) { return InternalAttribute(attr); },
+                [&](Default) {
+                    ErrorInvalidAttribute(attribute, "function-scope 'var'");
+                    return false;
+                });
+            if (!ok) {
+                return nullptr;
+            }
+        }
         sem = builder_->create<sem::LocalVariable>(var, var_ty, sem::EvaluationStage::kRuntime,
                                                    address_space, access, current_statement_,
                                                    /* constant_value */ nullptr);
@@ -604,18 +671,93 @@
     return sem;
 }
 
-sem::Parameter* Resolver::Parameter(const ast::Parameter* param, uint32_t index) {
+sem::Parameter* Resolver::Parameter(const ast::Parameter* param,
+                                    const ast::Function* func,
+                                    uint32_t index) {
     Mark(param->name);
 
     auto add_note = [&] {
         AddNote("while instantiating parameter " + param->name->symbol.Name(), param->source);
     };
 
-    for (auto* attr : param->attributes) {
-        if (!Attribute(attr)) {
-            return nullptr;
+    std::optional<uint32_t> location, group, binding;
+
+    if (func->IsEntryPoint()) {
+        for (auto* attribute : param->attributes) {
+            Mark(attribute);
+            bool ok = Switch(
+                attribute,  //
+                [&](const ast::LocationAttribute* attr) {
+                    auto value = LocationAttribute(attr);
+                    if (!value) {
+                        return false;
+                    }
+                    location = value.Get();
+                    return true;
+                },
+                [&](const ast::BuiltinAttribute* attr) -> bool { return BuiltinAttribute(attr); },
+                [&](const ast::InvariantAttribute* attr) -> bool {
+                    return InvariantAttribute(attr);
+                },
+                [&](const ast::InterpolateAttribute* attr) -> bool {
+                    return InterpolateAttribute(attr);
+                },
+                [&](const ast::InternalAttribute* attr) -> bool { return InternalAttribute(attr); },
+                [&](const ast::GroupAttribute* attr) -> bool {
+                    if (validator_.IsValidationEnabled(
+                            param->attributes, ast::DisabledValidation::kEntryPointParameter)) {
+                        ErrorInvalidAttribute(attribute, "function parameters");
+                        return false;
+                    }
+                    auto value = GroupAttribute(attr);
+                    if (!value) {
+                        return false;
+                    }
+                    group = value.Get();
+                    return true;
+                },
+                [&](const ast::BindingAttribute* attr) -> bool {
+                    if (validator_.IsValidationEnabled(
+                            param->attributes, ast::DisabledValidation::kEntryPointParameter)) {
+                        ErrorInvalidAttribute(attribute, "function parameters");
+                        return false;
+                    }
+                    auto value = BindingAttribute(attr);
+                    if (!value) {
+                        return false;
+                    }
+                    binding = value.Get();
+                    return true;
+                },
+                [&](Default) {
+                    ErrorInvalidAttribute(attribute, "function parameters");
+                    return false;
+                });
+            if (!ok) {
+                return nullptr;
+            }
+        }
+    } else {
+        for (auto* attribute : param->attributes) {
+            Mark(attribute);
+            bool ok = Switch(
+                attribute,  //
+                [&](const ast::InternalAttribute* attr) -> bool { return InternalAttribute(attr); },
+                [&](Default) {
+                    if (attribute->IsAnyOf<ast::LocationAttribute, ast::BuiltinAttribute,
+                                           ast::InvariantAttribute, ast::InterpolateAttribute>()) {
+                        ErrorInvalidAttribute(attribute, "non-entry point function parameters");
+                    } else {
+                        ErrorInvalidAttribute(attribute, "function parameters");
+                    }
+                    return false;
+                });
+            if (!ok) {
+                return nullptr;
+            }
         }
     }
+
     if (!validator_.NoDuplicateAttributes(param->attributes)) {
         return nullptr;
     }
@@ -641,72 +783,22 @@
     }
 
     std::optional<sem::BindingPoint> binding_point;
-    if (param->HasBindingPoint()) {
-        binding_point = sem::BindingPoint{};
-        {
-            ExprEvalStageConstraint constraint{sem::EvaluationStage::kConstant, "@binding value"};
-            TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
-
-            auto* attr = ast::GetAttribute<ast::BindingAttribute>(param->attributes);
-            auto* materialized = Materialize(ValueExpression(attr->expr));
-            if (!materialized) {
-                return nullptr;
-            }
-            binding_point->binding = materialized->ConstantValue()->ValueAs<u32>();
-        }
-        {
-            ExprEvalStageConstraint constraint{sem::EvaluationStage::kConstant, "@group value"};
-            TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
-
-            auto* attr = ast::GetAttribute<ast::GroupAttribute>(param->attributes);
-            auto* materialized = Materialize(ValueExpression(attr->expr));
-            if (!materialized) {
-                return nullptr;
-            }
-            binding_point->group = materialized->ConstantValue()->ValueAs<u32>();
-        }
-    }
-
-    std::optional<uint32_t> location;
-    if (auto* attr = ast::GetAttribute<ast::LocationAttribute>(param->attributes)) {
-        auto value = LocationAttribute(attr);
-        if (!value) {
-            return nullptr;
-        }
-        location = value.Get();
+    if (group && binding) {
+        binding_point = sem::BindingPoint{group.value(), binding.value()};
     }
 
     auto* sem = builder_->create<sem::Parameter>(
         param, index, ty, builtin::AddressSpace::kUndefined, builtin::Access::kUndefined,
         sem::ParameterUsage::kNone, binding_point, location);
     builder_->Sem().Add(param, sem);
+
+    if (!validator_.Parameter(sem)) {
+        return nullptr;
+    }
+
     return sem;
 }
 
-utils::Result<uint32_t> Resolver::LocationAttribute(const ast::LocationAttribute* attr) {
-    ExprEvalStageConstraint constraint{sem::EvaluationStage::kConstant, "@location value"};
-    TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
-
-    auto* materialized = Materialize(ValueExpression(attr->expr));
-    if (!materialized) {
-        return utils::Failure;
-    }
-
-    if (!materialized->Type()->IsAnyOf<type::I32, type::U32>()) {
-        AddError("@location must be an i32 or u32 value", attr->source);
-        return utils::Failure;
-    }
-
-    auto const_value = materialized->ConstantValue();
-    auto value = const_value->ValueAs<AInt>();
-    if (value < 0) {
-        AddError("@location value must be non-negative", attr->source);
-        return utils::Failure;
-    }
-
-    return static_cast<uint32_t>(value);
-}
-
 builtin::Access Resolver::DefaultAccessForAddressSpace(builtin::AddressSpace address_space) {
     // https://gpuweb.github.io/gpuweb/wgsl/#storage-class
     switch (address_space) {
@@ -795,12 +887,6 @@
         return nullptr;
     }
 
-    for (auto* attr : v->attributes) {
-        if (!Attribute(attr)) {
-            return nullptr;
-        }
-    }
-
     if (!validator_.NoDuplicateAttributes(v->attributes)) {
         return nullptr;
     }
@@ -859,8 +945,28 @@
 
     validator_.DiagnosticFilters().Push();
     TINT_DEFER(validator_.DiagnosticFilters().Pop());
-    for (auto* attr : decl->attributes) {
-        if (!Attribute(attr)) {
+
+    for (auto* attribute : decl->attributes) {
+        Mark(attribute);
+        bool ok = Switch(
+            attribute,
+            [&](const ast::DiagnosticAttribute* attr) { return DiagnosticAttribute(attr); },
+            [&](const ast::StageAttribute* attr) { return StageAttribute(attr); },
+            [&](const ast::MustUseAttribute* attr) { return MustUseAttribute(attr); },
+            [&](const ast::WorkgroupAttribute* attr) {
+                auto value = WorkgroupAttribute(attr);
+                if (!value) {
+                    return false;
+                }
+                func->SetWorkgroupSize(value.Get());
+                return true;
+            },
+            [&](const ast::InternalAttribute* attr) { return InternalAttribute(attr); },
+            [&](Default) {
+                ErrorInvalidAttribute(attribute, "functions");
+                return false;
+            });
+        if (!ok) {
             return nullptr;
         }
     }
@@ -883,19 +989,15 @@
             }
         }
 
-        auto* p = Parameter(param, parameter_index++);
+        auto* p = Parameter(param, decl, parameter_index++);
         if (!p) {
             return nullptr;
         }
 
-        if (!validator_.Parameter(decl, p)) {
-            return nullptr;
-        }
-
         func->AddParameter(p);
 
         auto* p_ty = const_cast<type::Type*>(p->Type());
-        if (auto* str = p_ty->As<sem::Struct>()) {
+        if (auto* str = p_ty->As<type::Struct>()) {
             switch (decl->PipelineStage()) {
                 case ast::PipelineStage::kVertex:
                     str->AddUsage(type::PipelineStageUsage::kVertexInput);
@@ -924,22 +1026,77 @@
     }
     func->SetReturnType(return_type);
 
-    // Determine if the return type has a location
-    for (auto* attr : decl->return_type_attributes) {
-        if (!Attribute(attr)) {
-            return nullptr;
-        }
+    if (decl->IsEntryPoint()) {
+        // Determine if the return type has a location
+        bool permissive = validator_.IsValidationDisabled(
+                              decl->attributes, ast::DisabledValidation::kEntryPointParameter) ||
+                          validator_.IsValidationDisabled(
+                              decl->attributes, ast::DisabledValidation::kFunctionParameter);
+        for (auto* attribute : decl->return_type_attributes) {
+            Mark(attribute);
+            enum Status { kSuccess, kErrored, kInvalid };
+            auto res = Switch(
+                attribute,  //
+                [&](const ast::LocationAttribute* attr) {
+                    auto value = LocationAttribute(attr);
+                    if (!value) {
+                        return kErrored;
+                    }
+                    func->SetReturnLocation(value.Get());
+                    return kSuccess;
+                },
+                [&](const ast::BuiltinAttribute* attr) {
+                    return BuiltinAttribute(attr) ? kSuccess : kErrored;
+                },
+                [&](const ast::InternalAttribute* attr) {
+                    return InternalAttribute(attr) ? kSuccess : kErrored;
+                },
+                [&](const ast::InterpolateAttribute* attr) {
+                    return InterpolateAttribute(attr) ? kSuccess : kErrored;
+                },
+                [&](const ast::InvariantAttribute* attr) {
+                    return InvariantAttribute(attr) ? kSuccess : kErrored;
+                },
+                [&](const ast::BindingAttribute* attr) {
+                    if (!permissive) {
+                        return kInvalid;
+                    }
+                    return BindingAttribute(attr) ? kSuccess : kErrored;
+                },
+                [&](const ast::GroupAttribute* attr) {
+                    if (!permissive) {
+                        return kInvalid;
+                    }
+                    return GroupAttribute(attr) ? kSuccess : kErrored;
+                },
+                [&](Default) { return kInvalid; });
 
-        if (auto* loc_attr = attr->As<ast::LocationAttribute>()) {
-            auto value = LocationAttribute(loc_attr);
-            if (!value) {
+            switch (res) {
+                case kSuccess:
+                    break;
+                case kErrored:
+                    return nullptr;
+                case kInvalid:
+                    ErrorInvalidAttribute(attribute, "entry point return types");
+                    return nullptr;
+            }
+        }
+    } else {
+        for (auto* attribute : decl->return_type_attributes) {
+            Mark(attribute);
+            bool ok = Switch(attribute,  //
+                             [&](Default) {
+                                 ErrorInvalidAttribute(attribute,
+                                                       "non-entry point function return types");
+                                 return false;
+                             });
+            if (!ok) {
                 return nullptr;
             }
-            func->SetReturnLocation(value.Get());
         }
     }
 
-    if (auto* str = return_type->As<sem::Struct>()) {
+    if (auto* str = return_type->As<type::Struct>()) {
         if (!ApplyAddressSpaceUsageToType(builtin::AddressSpace::kUndefined, str, decl->source)) {
             AddNote("while instantiating return type for " + decl->name->symbol.Name(),
                     decl->source);
@@ -963,10 +1120,6 @@
 
     ApplyDiagnosticSeverities(func);
 
-    if (!WorkgroupSize(decl)) {
-        return nullptr;
-    }
-
     if (decl->IsEntryPoint()) {
         entry_points_.Push(func);
     }
@@ -1015,94 +1168,6 @@
     return func;
 }
 
-bool Resolver::WorkgroupSize(const ast::Function* func) {
-    // Set work-group size defaults.
-    sem::WorkgroupSize ws;
-    for (size_t i = 0; i < 3; i++) {
-        ws[i] = 1;
-    }
-
-    auto* attr = ast::GetAttribute<ast::WorkgroupAttribute>(func->attributes);
-    if (!attr) {
-        return true;
-    }
-
-    auto values = attr->Values();
-    utils::Vector<const sem::ValueExpression*, 3> args;
-    utils::Vector<const type::Type*, 3> arg_tys;
-
-    constexpr const char* kErrBadExpr =
-        "workgroup_size argument must be a constant or override-expression of type "
-        "abstract-integer, i32 or u32";
-
-    for (size_t i = 0; i < 3; i++) {
-        // Each argument to this attribute can either be a literal, an identifier for a
-        // module-scope constants, a const-expression, or nullptr if not specified.
-        auto* value = values[i];
-        if (!value) {
-            break;
-        }
-        const auto* expr = ValueExpression(value);
-        if (!expr) {
-            return false;
-        }
-        auto* ty = expr->Type();
-        if (!ty->IsAnyOf<type::I32, type::U32, type::AbstractInt>()) {
-            AddError(kErrBadExpr, value->source);
-            return false;
-        }
-
-        if (expr->Stage() != sem::EvaluationStage::kConstant &&
-            expr->Stage() != sem::EvaluationStage::kOverride) {
-            AddError(kErrBadExpr, value->source);
-            return false;
-        }
-
-        args.Push(expr);
-        arg_tys.Push(ty);
-    }
-
-    auto* common_ty = type::Type::Common(arg_tys);
-    if (!common_ty) {
-        AddError("workgroup_size arguments must be of the same type, either i32 or u32",
-                 attr->source);
-        return false;
-    }
-
-    // If all arguments are abstract-integers, then materialize to i32.
-    if (common_ty->Is<type::AbstractInt>()) {
-        common_ty = builder_->create<type::I32>();
-    }
-
-    for (size_t i = 0; i < args.Length(); i++) {
-        auto* materialized = Materialize(args[i], common_ty);
-        if (!materialized) {
-            return false;
-        }
-        if (auto* value = materialized->ConstantValue()) {
-            if (value->ValueAs<AInt>() < 1) {
-                AddError("workgroup_size argument must be at least 1", values[i]->source);
-                return false;
-            }
-            ws[i] = value->ValueAs<u32>();
-        } else {
-            ws[i] = std::nullopt;
-        }
-    }
-
-    uint64_t total_size = static_cast<uint64_t>(ws[0].value_or(1));
-    for (size_t i = 1; i < 3; i++) {
-        total_size *= static_cast<uint64_t>(ws[i].value_or(1));
-        if (total_size > 0xffffffff) {
-            AddError("total workgroup grid size cannot exceed 0xffffffff", values[i]->source);
-            return false;
-        }
-    }
-
-    current_function_->SetWorkgroupSize(std::move(ws));
-    return true;
-}
-
 bool Resolver::Statements(utils::VectorRef<const ast::Statement*> stmts) {
     sem::Behaviors behaviors{sem::Behavior::kNext};
 
@@ -1696,7 +1761,7 @@
             }
             return nullptr;
         },
-        [&](const sem::Struct* s) -> const type::Type* {
+        [&](const type::Struct* s) -> const type::Type* {
             if (auto tys = s->ConcreteTypes(); !tys.IsEmpty()) {
                 return target_ty ? target_ty : tys[0];
             }
@@ -2078,7 +2143,7 @@
                 }
                 return call;
             },
-            [&](const sem::Struct* str) -> sem::Call* {
+            [&](const type::Struct* str) -> sem::Call* {
                 auto* call_target = struct_ctors_.GetOrCreate(
                     StructConstructorSig{{str, args.Length(), args_stage}},
                     [&]() -> sem::ValueConstructor* {
@@ -2336,6 +2401,7 @@
     auto check_no_tmpl_args = [&](type::Type* ty) -> type::Type* {
         return TINT_LIKELY(CheckNotTemplated("type", ident)) ? ty : nullptr;
     };
+    auto af = [&] { return b.create<type::AbstractFloat>(); };
     auto f32 = [&] { return b.create<type::F32>(); };
     auto i32 = [&] { return b.create<type::I32>(); };
     auto u32 = [&] { return b.create<type::U32>(); };
@@ -2586,9 +2652,6 @@
             return nullptr;
         }
 
-        if (TINT_UNLIKELY(!el_ty)) {
-            return nullptr;
-        }
         if (TINT_UNLIKELY(!validator_.Vector(el_ty, ident->source))) {
             return nullptr;
         }
@@ -2740,9 +2803,60 @@
             return storage_texture(type::TextureDimension::k2dArray);
         case builtin::Builtin::kTextureStorage3D:
             return storage_texture(type::TextureDimension::k3d);
-        case builtin::Builtin::kPackedVec3: {
+        case builtin::Builtin::kPackedVec3:
             return packed_vec3_t();
-        }
+        case builtin::Builtin::kAtomicCompareExchangeResultI32:
+            return CreateAtomicCompareExchangeResult(*builder_, i32());
+        case builtin::Builtin::kAtomicCompareExchangeResultU32:
+            return CreateAtomicCompareExchangeResult(*builder_, u32());
+        case builtin::Builtin::kFrexpResultAbstract:
+            return CreateFrexpResult(*builder_, af());
+        case builtin::Builtin::kFrexpResultF16:
+            return CreateFrexpResult(*builder_, f16());
+        case builtin::Builtin::kFrexpResultF32:
+            return CreateFrexpResult(*builder_, f32());
+        case builtin::Builtin::kFrexpResultVec2Abstract:
+            return CreateFrexpResult(*builder_, vec(af(), 2));
+        case builtin::Builtin::kFrexpResultVec2F16:
+            return CreateFrexpResult(*builder_, vec(f16(), 2));
+        case builtin::Builtin::kFrexpResultVec2F32:
+            return CreateFrexpResult(*builder_, vec(f32(), 2));
+        case builtin::Builtin::kFrexpResultVec3Abstract:
+            return CreateFrexpResult(*builder_, vec(af(), 3));
+        case builtin::Builtin::kFrexpResultVec3F16:
+            return CreateFrexpResult(*builder_, vec(f16(), 3));
+        case builtin::Builtin::kFrexpResultVec3F32:
+            return CreateFrexpResult(*builder_, vec(f32(), 3));
+        case builtin::Builtin::kFrexpResultVec4Abstract:
+            return CreateFrexpResult(*builder_, vec(af(), 4));
+        case builtin::Builtin::kFrexpResultVec4F16:
+            return CreateFrexpResult(*builder_, vec(f16(), 4));
+        case builtin::Builtin::kFrexpResultVec4F32:
+            return CreateFrexpResult(*builder_, vec(f32(), 4));
+        case builtin::Builtin::kModfResultAbstract:
+            return CreateModfResult(*builder_, af());
+        case builtin::Builtin::kModfResultF16:
+            return CreateModfResult(*builder_, f16());
+        case builtin::Builtin::kModfResultF32:
+            return CreateModfResult(*builder_, f32());
+        case builtin::Builtin::kModfResultVec2Abstract:
+            return CreateModfResult(*builder_, vec(af(), 2));
+        case builtin::Builtin::kModfResultVec2F16:
+            return CreateModfResult(*builder_, vec(f16(), 2));
+        case builtin::Builtin::kModfResultVec2F32:
+            return CreateModfResult(*builder_, vec(f32(), 2));
+        case builtin::Builtin::kModfResultVec3Abstract:
+            return CreateModfResult(*builder_, vec(af(), 3));
+        case builtin::Builtin::kModfResultVec3F16:
+            return CreateModfResult(*builder_, vec(f16(), 3));
+        case builtin::Builtin::kModfResultVec3F32:
+            return CreateModfResult(*builder_, vec(f32(), 3));
+        case builtin::Builtin::kModfResultVec4Abstract:
+            return CreateModfResult(*builder_, vec(af(), 4));
+        case builtin::Builtin::kModfResultVec4F16:
+            return CreateModfResult(*builder_, vec(f16(), 4));
+        case builtin::Builtin::kModfResultVec4F32:
+            return CreateModfResult(*builder_, vec(f32(), 4));
         case builtin::Builtin::kUndefined:
             break;
     }
@@ -3134,10 +3248,10 @@
 
     return Switch(
         storage_ty,  //
-        [&](const sem::Struct* str) -> sem::ValueExpression* {
+        [&](const type::Struct* str) -> sem::ValueExpression* {
             auto symbol = expr->member->symbol;
 
-            const sem::StructMember* member = nullptr;
+            const type::StructMember* member = nullptr;
             for (auto* m : str->Members()) {
                 if (m->Name() == symbol) {
                     member = m;
@@ -3424,38 +3538,207 @@
     return sem;
 }
 
-bool Resolver::Attribute(const ast::Attribute* attr) {
-    Mark(attr);
-    return Switch(
-        attr,  //
-        [&](const ast::BuiltinAttribute* b) { return BuiltinAttribute(b); },
-        [&](const ast::DiagnosticAttribute* d) { return DiagnosticControl(d->control); },
-        [&](const ast::InterpolateAttribute* i) { return InterpolateAttribute(i); },
-        [&](const ast::InternalAttribute* i) { return InternalAttribute(i); },
-        [&](Default) { return true; });
+utils::Result<uint32_t> Resolver::LocationAttribute(const ast::LocationAttribute* attr) {
+    ExprEvalStageConstraint constraint{sem::EvaluationStage::kConstant, "@location value"};
+    TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
+
+    auto* materialized = Materialize(ValueExpression(attr->expr));
+    if (!materialized) {
+        return utils::Failure;
+    }
+
+    if (!materialized->Type()->IsAnyOf<type::I32, type::U32>()) {
+        AddError("@location must be an i32 or u32 value", attr->source);
+        return utils::Failure;
+    }
+
+    auto const_value = materialized->ConstantValue();
+    auto value = const_value->ValueAs<AInt>();
+    if (value < 0) {
+        AddError("@location value must be non-negative", attr->source);
+        return utils::Failure;
+    }
+
+    return static_cast<uint32_t>(value);
 }
 
-bool Resolver::BuiltinAttribute(const ast::BuiltinAttribute* attr) {
+utils::Result<uint32_t> Resolver::BindingAttribute(const ast::BindingAttribute* attr) {
+    ExprEvalStageConstraint constraint{sem::EvaluationStage::kConstant, "@binding"};
+    TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
+
+    auto* materialized = Materialize(ValueExpression(attr->expr));
+    if (!materialized) {
+        return utils::Failure;
+    }
+    if (!materialized->Type()->IsAnyOf<type::I32, type::U32>()) {
+        AddError("@binding must be an i32 or u32 value", attr->source);
+        return utils::Failure;
+    }
+
+    auto const_value = materialized->ConstantValue();
+    auto value = const_value->ValueAs<AInt>();
+    if (value < 0) {
+        AddError("@binding value must be non-negative", attr->source);
+        return utils::Failure;
+    }
+    return static_cast<uint32_t>(value);
+}
+
+utils::Result<uint32_t> Resolver::GroupAttribute(const ast::GroupAttribute* attr) {
+    ExprEvalStageConstraint constraint{sem::EvaluationStage::kConstant, "@group"};
+    TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
+
+    auto* materialized = Materialize(ValueExpression(attr->expr));
+    if (!materialized) {
+        return utils::Failure;
+    }
+    if (!materialized->Type()->IsAnyOf<type::I32, type::U32>()) {
+        AddError("@group must be an i32 or u32 value", attr->source);
+        return utils::Failure;
+    }
+
+    auto const_value = materialized->ConstantValue();
+    auto value = const_value->ValueAs<AInt>();
+    if (value < 0) {
+        AddError("@group value must be non-negative", attr->source);
+        return utils::Failure;
+    }
+    return static_cast<uint32_t>(value);
+}
+
+utils::Result<sem::WorkgroupSize> Resolver::WorkgroupAttribute(
+    const ast::WorkgroupAttribute* attr) {
+    // Set work-group size defaults.
+    sem::WorkgroupSize ws;
+    for (size_t i = 0; i < 3; i++) {
+        ws[i] = 1;
+    }
+
+    auto values = attr->Values();
+    utils::Vector<const sem::ValueExpression*, 3> args;
+    utils::Vector<const type::Type*, 3> arg_tys;
+
+    constexpr const char* kErrBadExpr =
+        "workgroup_size argument must be a constant or override-expression of type "
+        "abstract-integer, i32 or u32";
+
+    for (size_t i = 0; i < 3; i++) {
+        // Each argument to this attribute can either be a literal, an identifier for a
+        // module-scope constants, a const-expression, or nullptr if not specified.
+        auto* value = values[i];
+        if (!value) {
+            break;
+        }
+        const auto* expr = ValueExpression(value);
+        if (!expr) {
+            return utils::Failure;
+        }
+        auto* ty = expr->Type();
+        if (!ty->IsAnyOf<type::I32, type::U32, type::AbstractInt>()) {
+            AddError(kErrBadExpr, value->source);
+            return utils::Failure;
+        }
+
+        if (expr->Stage() != sem::EvaluationStage::kConstant &&
+            expr->Stage() != sem::EvaluationStage::kOverride) {
+            AddError(kErrBadExpr, value->source);
+            return utils::Failure;
+        }
+
+        args.Push(expr);
+        arg_tys.Push(ty);
+    }
+
+    auto* common_ty = type::Type::Common(arg_tys);
+    if (!common_ty) {
+        AddError("workgroup_size arguments must be of the same type, either i32 or u32",
+                 attr->source);
+        return utils::Failure;
+    }
+
+    // If all arguments are abstract-integers, then materialize to i32.
+    if (common_ty->Is<type::AbstractInt>()) {
+        common_ty = builder_->create<type::I32>();
+    }
+
+    for (size_t i = 0; i < args.Length(); i++) {
+        auto* materialized = Materialize(args[i], common_ty);
+        if (!materialized) {
+            return utils::Failure;
+        }
+        if (auto* value = materialized->ConstantValue()) {
+            if (value->ValueAs<AInt>() < 1) {
+                AddError("workgroup_size argument must be at least 1", values[i]->source);
+                return utils::Failure;
+            }
+            ws[i] = value->ValueAs<u32>();
+        } else {
+            ws[i] = std::nullopt;
+        }
+    }
+
+    uint64_t total_size = static_cast<uint64_t>(ws[0].value_or(1));
+    for (size_t i = 1; i < 3; i++) {
+        total_size *= static_cast<uint64_t>(ws[i].value_or(1));
+        if (total_size > 0xffffffff) {
+            AddError("total workgroup grid size cannot exceed 0xffffffff", values[i]->source);
+            return utils::Failure;
+        }
+    }
+
+    return ws;
+}
+
+utils::Result<tint::builtin::BuiltinValue> Resolver::BuiltinAttribute(
+    const ast::BuiltinAttribute* attr) {
     auto* builtin_expr = BuiltinValueExpression(attr->builtin);
     if (!builtin_expr) {
-        return false;
+        return utils::Failure;
     }
     // Apply the resolved tint::sem::BuiltinEnumExpression<tint::builtin::BuiltinValue> to the
     // attribute.
     builder_->Sem().Add(attr, builtin_expr);
+    return builtin_expr->Value();
+}
+
+bool Resolver::DiagnosticAttribute(const ast::DiagnosticAttribute* attr) {
+    return DiagnosticControl(attr->control);
+}
+
+bool Resolver::StageAttribute(const ast::StageAttribute*) {
     return true;
 }
 
-bool Resolver::InterpolateAttribute(const ast::InterpolateAttribute* attr) {
-    if (!InterpolationType(attr->type)) {
-        return false;
-    }
-    if (attr->sampling && !InterpolationSampling(attr->sampling)) {
-        return false;
-    }
+bool Resolver::MustUseAttribute(const ast::MustUseAttribute*) {
     return true;
 }
 
+bool Resolver::InvariantAttribute(const ast::InvariantAttribute*) {
+    return true;
+}
+
+bool Resolver::StrideAttribute(const ast::StrideAttribute*) {
+    return true;
+}
+
+utils::Result<builtin::Interpolation> Resolver::InterpolateAttribute(
+    const ast::InterpolateAttribute* attr) {
+    builtin::Interpolation out;
+    auto* type = InterpolationType(attr->type);
+    if (!type) {
+        return utils::Failure;
+    }
+    out.type = type->Value();
+    if (attr->sampling) {
+        auto* sampling = InterpolationSampling(attr->sampling);
+        if (!sampling) {
+            return utils::Failure;
+        }
+        out.sampling = sampling->Value();
+    }
+    return out;
+}
+
 bool Resolver::InternalAttribute(const ast::InternalAttribute* attr) {
     for (auto* dep : attr->dependencies) {
         if (!Expression(dep)) {
@@ -3576,24 +3859,30 @@
         return false;
     }
 
-    for (auto* attr : attributes) {
-        Mark(attr);
-        if (auto* sd = attr->As<ast::StrideAttribute>()) {
-            // If the element type is not plain, then el_ty->Align() may be 0, in which case we
-            // could get a DBZ in ArrayStrideAttribute(). In this case, validation will error
-            // about the invalid array element type (which is tested later), so this is just a
-            // seatbelt.
-            if (IsPlain(el_ty)) {
-                explicit_stride = sd->stride;
-                if (!validator_.ArrayStrideAttribute(sd, el_ty->Size(), el_ty->Align())) {
-                    return false;
+    for (auto* attribute : attributes) {
+        Mark(attribute);
+        bool ok = Switch(
+            attribute,  //
+            [&](const ast::StrideAttribute* attr) {
+                // If the element type is not plain, then el_ty->Align() may be 0, in which case we
+                // could get a DBZ in ArrayStrideAttribute(). In this case, validation will error
+                // about the invalid array element type (which is tested later), so this is just a
+                // seatbelt.
+                if (IsPlain(el_ty)) {
+                    explicit_stride = attr->stride;
+                    if (!validator_.ArrayStrideAttribute(attr, el_ty->Size(), el_ty->Align())) {
+                        return false;
+                    }
                 }
-            }
-            continue;
+                return true;
+            },
+            [&](Default) {
+                ErrorInvalidAttribute(attribute, "array types");
+                return false;
+            });
+        if (!ok) {
+            return false;
         }
-
-        AddError("attribute is not valid for array types", attr->source);
-        return false;
     }
 
     return true;
@@ -3677,8 +3966,18 @@
     if (!validator_.NoDuplicateAttributes(str->attributes)) {
         return nullptr;
     }
-    for (auto* attr : str->attributes) {
-        Mark(attr);
+
+    for (auto* attribute : str->attributes) {
+        Mark(attribute);
+        bool ok = Switch(
+            attribute, [&](const ast::InternalAttribute* attr) { return InternalAttribute(attr); },
+            [&](Default) {
+                ErrorInvalidAttribute(attribute, "struct declarations");
+                return false;
+            });
+        if (!ok) {
+            return nullptr;
+        }
     }
 
     utils::Vector<const sem::StructMember*, 8> sem_members;
@@ -3730,89 +4029,88 @@
         bool has_offset_attr = false;
         bool has_align_attr = false;
         bool has_size_attr = false;
-        std::optional<uint32_t> location;
-        for (auto* attr : member->attributes) {
-            if (!Attribute(attr)) {
-                return nullptr;
-            }
+        type::StructMemberAttributes attributes;
+        for (auto* attribute : member->attributes) {
+            Mark(attribute);
             bool ok = Switch(
-                attr,  //
-                [&](const ast::StructMemberOffsetAttribute* o) {
-                    // Offset attributes are not part of the WGSL spec, but are emitted
-                    // by the SPIR-V reader.
+                attribute,  //
+                [&](const ast::StructMemberOffsetAttribute* attr) {
+                    // Offset attributes are not part of the WGSL spec, but are emitted by the
+                    // SPIR-V reader.
+
                     ExprEvalStageConstraint constraint{sem::EvaluationStage::kConstant,
                                                        "@offset value"};
                     TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
 
-                    auto* materialized = Materialize(ValueExpression(o->expr));
+                    auto* materialized = Materialize(ValueExpression(attr->expr));
                     if (!materialized) {
                         return false;
                     }
                     auto const_value = materialized->ConstantValue();
                     if (!const_value) {
-                        AddError("@offset must be constant expression", o->expr->source);
+                        AddError("@offset must be constant expression", attr->expr->source);
                         return false;
                     }
                     offset = const_value->ValueAs<uint64_t>();
 
                     if (offset < struct_size) {
-                        AddError("offsets must be in ascending order", o->source);
+                        AddError("offsets must be in ascending order", attr->source);
                         return false;
                     }
                     has_offset_attr = true;
                     return true;
                 },
-                [&](const ast::StructMemberAlignAttribute* a) {
+                [&](const ast::StructMemberAlignAttribute* attr) {
                     ExprEvalStageConstraint constraint{sem::EvaluationStage::kConstant, "@align"};
                     TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
 
-                    auto* materialized = Materialize(ValueExpression(a->expr));
+                    auto* materialized = Materialize(ValueExpression(attr->expr));
                     if (!materialized) {
                         return false;
                     }
                     if (!materialized->Type()->IsAnyOf<type::I32, type::U32>()) {
-                        AddError("@align must be an i32 or u32 value", a->source);
+                        AddError("@align must be an i32 or u32 value", attr->source);
                         return false;
                     }
 
                     auto const_value = materialized->ConstantValue();
                     if (!const_value) {
-                        AddError("@align must be constant expression", a->source);
+                        AddError("@align must be constant expression", attr->source);
                         return false;
                     }
                     auto value = const_value->ValueAs<AInt>();
 
                     if (value <= 0 || !utils::IsPowerOfTwo(value)) {
                         AddError("@align value must be a positive, power-of-two integer",
-                                 a->source);
+                                 attr->source);
                         return false;
                     }
                     align = u32(value);
                     has_align_attr = true;
                     return true;
                 },
-                [&](const ast::StructMemberSizeAttribute* s) {
+                [&](const ast::StructMemberSizeAttribute* attr) {
                     ExprEvalStageConstraint constraint{sem::EvaluationStage::kConstant, "@size"};
                     TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
 
-                    auto* materialized = Materialize(ValueExpression(s->expr));
+                    auto* materialized = Materialize(ValueExpression(attr->expr));
                     if (!materialized) {
                         return false;
                     }
                     if (!materialized->Type()->IsAnyOf<type::U32, type::I32>()) {
-                        AddError("@size must be an i32 or u32 value", s->source);
+                        AddError("@size must be an i32 or u32 value", attr->source);
                         return false;
                     }
 
                     auto const_value = materialized->ConstantValue();
                     if (!const_value) {
-                        AddError("@size must be constant expression", s->expr->source);
+                        AddError("@size must be constant expression", attr->expr->source);
                         return false;
                     }
                     {
                         auto value = const_value->ValueAs<AInt>();
                         if (value <= 0) {
-                            AddError("@size must be a positive integer", s->source);
+                            AddError("@size must be a positive integer", attr->source);
                             return false;
                         }
                     }
@@ -3820,24 +4118,56 @@
                     if (value < size) {
                         AddError("@size must be at least as big as the type's size (" +
                                      std::to_string(size) + ")",
-                                 s->source);
+                                 attr->source);
                         return false;
                     }
                     size = u32(value);
                     has_size_attr = true;
                     return true;
                 },
-                [&](const ast::LocationAttribute* loc_attr) {
-                    auto value = LocationAttribute(loc_attr);
+                [&](const ast::LocationAttribute* attr) {
+                    auto value = LocationAttribute(attr);
                     if (!value) {
                         return false;
                     }
-                    location = value.Get();
+                    attributes.location = value.Get();
                     return true;
                 },
-                [&](Default) {
-                    // The validator will check attributes can be applied to the struct member.
+                [&](const ast::BuiltinAttribute* attr) {
+                    auto value = BuiltinAttribute(attr);
+                    if (!value) {
+                        return false;
+                    }
+                    attributes.builtin = value.Get();
                     return true;
+                },
+                [&](const ast::InterpolateAttribute* attr) {
+                    auto value = InterpolateAttribute(attr);
+                    if (!value) {
+                        return false;
+                    }
+                    attributes.interpolation = value.Get();
+                    return true;
+                },
+                [&](const ast::InvariantAttribute* attr) {
+                    if (!InvariantAttribute(attr)) {
+                        return false;
+                    }
+                    attributes.invariant = true;
+                    return true;
+                },
+                [&](const ast::StrideAttribute* attr) {
+                    if (validator_.IsValidationEnabled(
+                            member->attributes, ast::DisabledValidation::kIgnoreStrideAttribute)) {
+                        ErrorInvalidAttribute(attribute, "struct members");
+                        return false;
+                    }
+                    return StrideAttribute(attr);
+                },
+                [&](const ast::InternalAttribute* attr) { return InternalAttribute(attr); },
+                [&](Default) {
+                    ErrorInvalidAttribute(attribute, "struct members");
+                    return false;
                 });
             if (!ok) {
                 return nullptr;
@@ -3859,9 +4189,9 @@
         }
 
         auto* sem_member = builder_->create<sem::StructMember>(
-            member, member->source, member->name->symbol, type,
-            static_cast<uint32_t>(sem_members.Length()), static_cast<uint32_t>(offset),
-            static_cast<uint32_t>(align), static_cast<uint32_t>(size), location);
+            member, member->name->symbol, type, static_cast<uint32_t>(sem_members.Length()),
+            static_cast<uint32_t>(offset), static_cast<uint32_t>(align),
+            static_cast<uint32_t>(size), attributes);
         builder_->Sem().Add(member, sem_member);
         sem_members.Push(sem_member);
 
@@ -3884,14 +4214,13 @@
     }
 
     auto* out = builder_->create<sem::Struct>(
-        str, str->source, str->name->symbol, std::move(sem_members),
-        static_cast<uint32_t>(struct_align), static_cast<uint32_t>(struct_size),
-        static_cast<uint32_t>(size_no_padding));
+        str, str->name->symbol, std::move(sem_members), static_cast<uint32_t>(struct_align),
+        static_cast<uint32_t>(struct_size), static_cast<uint32_t>(size_no_padding));
 
     for (size_t i = 0; i < sem_members.Length(); i++) {
         auto* mem_type = sem_members[i]->Type();
         if (mem_type->Is<type::Atomic>()) {
-            atomic_composite_info_.Add(out, &sem_members[i]->Source());
+            atomic_composite_info_.Add(out, &sem_members[i]->Declaration()->source);
             break;
         } else {
             if (auto found = atomic_composite_info_.Get(mem_type)) {
@@ -3999,14 +4328,16 @@
         }
 
         // Handle switch body attributes.
-        for (auto* attr : stmt->body_attributes) {
-            Mark(attr);
-            if (auto* dc = attr->As<ast::DiagnosticAttribute>()) {
-                if (!DiagnosticControl(dc->control)) {
+        for (auto* attribute : stmt->body_attributes) {
+            Mark(attribute);
+            bool ok = Switch(
+                attribute,
+                [&](const ast::DiagnosticAttribute* attr) { return DiagnosticAttribute(attr); },
+                [&](Default) {
+                    ErrorInvalidAttribute(attribute, "switch body");
                     return false;
-                }
-            } else {
-                AddError("attribute is not valid for switch body", attr->source);
+                });
+            if (!ok) {
                 return false;
             }
         }
@@ -4049,14 +4380,6 @@
             return false;
         }
 
-        for (auto* attr : stmt->variable->attributes) {
-            Mark(attr);
-            if (!attr->Is<ast::InternalAttribute>()) {
-                AddError("attributes are not valid on local variables", attr->source);
-                return false;
-            }
-        }
-
         current_compound_statement_->AddDecl(variable->As<sem::LocalVariable>());
 
         if (auto* ctor = variable->Initializer()) {
@@ -4242,7 +4565,7 @@
                 utils::StringStream err;
                 err << "while analyzing structure member " << sem_.TypeNameOf(str) << "."
                     << member->Name().Name();
-                AddNote(err.str(), member->Source());
+                AddNote(err.str(), member->Declaration()->source);
                 return false;
             }
         }
@@ -4289,16 +4612,16 @@
 
     // Helper to handle attributes that are supported on certain types of statement.
     auto handle_attributes = [&](auto* stmt, sem::Statement* sem_stmt, const char* use) {
-        for (auto* attr : stmt->attributes) {
-            Mark(attr);
-            if (auto* dc = attr->template As<ast::DiagnosticAttribute>()) {
-                if (!DiagnosticControl(dc->control)) {
+        for (auto* attribute : stmt->attributes) {
+            Mark(attribute);
+            bool ok = Switch(
+                attribute,  //
+                [&](const ast::DiagnosticAttribute* attr) { return DiagnosticAttribute(attr); },
+                [&](Default) {
+                    ErrorInvalidAttribute(attribute, use);
                     return false;
-                }
-            } else {
-                utils::StringStream ss;
-                ss << "attribute is not valid for " << use;
-                AddError(ss.str(), attr->source);
+                });
+            if (!ok) {
                 return false;
             }
         }
@@ -4401,6 +4724,10 @@
     sem_.NoteDeclarationSource(resolved.Node());
 }
 
+void Resolver::ErrorInvalidAttribute(const ast::Attribute* attr, std::string_view use) {
+    AddError("@" + attr->Name() + " is not valid for " + std::string(use), attr->source);
+}
+
 void Resolver::AddError(const std::string& msg, const Source& source) const {
     diagnostics_.add_error(diag::System::Resolver, msg, source);
 }
diff --git a/src/tint/resolver/resolver.h b/src/tint/resolver/resolver.h
index edc088a..5d13d25 100644
--- a/src/tint/resolver/resolver.h
+++ b/src/tint/resolver/resolver.h
@@ -312,17 +312,50 @@
     /// current_function_
     bool WorkgroupSize(const ast::Function*);
 
-    /// Resolves the attribute @p attr
-    /// @returns true on success, false on failure
-    bool Attribute(const ast::Attribute* attr);
-
     /// Resolves the `@builtin` attribute @p attr
+    /// @returns the builtin value on success
+    utils::Result<tint::builtin::BuiltinValue> BuiltinAttribute(const ast::BuiltinAttribute* attr);
+
+    /// Resolves the `@location` attribute @p attr
+    /// @returns the location value on success.
+    utils::Result<uint32_t> LocationAttribute(const ast::LocationAttribute* attr);
+
+    /// Resolves the `@binding` attribute @p attr
+    /// @returns the binding value on success.
+    utils::Result<uint32_t> BindingAttribute(const ast::BindingAttribute* attr);
+
+    /// Resolves the `@group` attribute @p attr
+    /// @returns the group value on success.
+    utils::Result<uint32_t> GroupAttribute(const ast::GroupAttribute* attr);
+
+    /// Resolves the `@workgroup_size` attribute @p attr
+    /// @returns the workgroup size on success.
+    utils::Result<sem::WorkgroupSize> WorkgroupAttribute(const ast::WorkgroupAttribute* attr);
+
+    /// Resolves the `@diagnostic` attribute @p attr
     /// @returns true on success, false on failure
-    bool BuiltinAttribute(const ast::BuiltinAttribute* attr);
+    bool DiagnosticAttribute(const ast::DiagnosticAttribute* attr);
+
+    /// Resolves the stage attribute @p attr
+    /// @returns true on success, false on failure
+    bool StageAttribute(const ast::StageAttribute* attr);
+
+    /// Resolves the `@must_use` attribute @p attr
+    /// @returns true on success, false on failure
+    bool MustUseAttribute(const ast::MustUseAttribute* attr);
+
+    /// Resolves the `@invariant` attribute @p attr
+    /// @returns true on success, false on failure
+    bool InvariantAttribute(const ast::InvariantAttribute*);
+
+    /// Resolves the `@stride` attribute @p attr
+    /// @returns true on success, false on failure
+    bool StrideAttribute(const ast::StrideAttribute*);
 
     /// Resolves the `@interpolate` attribute @p attr
     /// @returns true on success, false on failure
-    bool InterpolateAttribute(const ast::InterpolateAttribute* attr);
+    utils::Result<builtin::Interpolation> InterpolateAttribute(
+        const ast::InterpolateAttribute* attr);
 
     /// Resolves the internal attribute @p attr
     /// @returns true on success, false on failure
@@ -427,12 +460,11 @@
     /// nullptr is returned.
     /// @note the caller is expected to validate the parameter
     /// @param param the AST parameter
+    /// @param func the AST function that owns the parameter
     /// @param index the index of the parameter
-    sem::Parameter* Parameter(const ast::Parameter* param, uint32_t index);
-
-    /// @returns the location value for a `@location` attribute, validating the value's range and
-    /// type.
-    utils::Result<uint32_t> LocationAttribute(const ast::LocationAttribute* attr);
+    sem::Parameter* Parameter(const ast::Parameter* param,
+                              const ast::Function* func,
+                              uint32_t index);
 
     /// Records the address space usage for the given type, and any transient
     /// dependencies of the type. Validates that the type can be used for the
@@ -497,6 +529,11 @@
                                            const ResolvedIdentifier& resolved,
                                            std::string_view wanted);
 
+    /// Raises an error that the attribute is not valid for the given use.
+    /// @param attr the invalue attribute
+    /// @param use the thing that the attribute was applied to
+    void ErrorInvalidAttribute(const ast::Attribute* attr, std::string_view use);
+
     /// Adds the given error message to the diagnostics
     void AddError(const std::string& msg, const Source& source) const;
 
@@ -523,7 +560,7 @@
     // It is a tuple of the structure type, number of arguments provided and earliest evaluation
     // stage.
     using StructConstructorSig =
-        utils::UnorderedKeyWrapper<std::tuple<const sem::Struct*, size_t, sem::EvaluationStage>>;
+        utils::UnorderedKeyWrapper<std::tuple<const type::Struct*, size_t, sem::EvaluationStage>>;
 
     /// ExprEvalStageConstraint describes a constraint on when expressions can be evaluated.
     struct ExprEvalStageConstraint {
diff --git a/src/tint/resolver/resolver_test.cc b/src/tint/resolver/resolver_test.cc
index 5df2fae..dfe42ae 100644
--- a/src/tint/resolver/resolver_test.cc
+++ b/src/tint/resolver/resolver_test.cc
@@ -1265,7 +1265,7 @@
     EXPECT_TRUE(sma->Member()->Type()->Is<type::F32>());
     EXPECT_EQ(sma->Object()->Declaration(), mem->object);
     EXPECT_EQ(sma->Member()->Index(), 1u);
-    EXPECT_EQ(sma->Member()->Declaration()->name->symbol, Symbols().Get("second_member"));
+    EXPECT_EQ(sma->Member()->Name().Name(), "second_member");
 }
 
 TEST_F(ResolverTest, Expr_MemberAccessor_Struct_Alias) {
diff --git a/src/tint/resolver/struct_address_space_use_test.cc b/src/tint/resolver/struct_address_space_use_test.cc
index aeb5c31..e97a6ac 100644
--- a/src/tint/resolver/struct_address_space_use_test.cc
+++ b/src/tint/resolver/struct_address_space_use_test.cc
@@ -32,7 +32,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_TRUE(sem->AddressSpaceUsage().empty());
 }
@@ -44,7 +44,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kUndefined));
 }
@@ -56,7 +56,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kUndefined));
 }
@@ -68,7 +68,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kPrivate));
 }
@@ -80,7 +80,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kPrivate));
 }
@@ -92,7 +92,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kPrivate));
 }
@@ -104,7 +104,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kPrivate));
 }
@@ -116,7 +116,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kFunction));
 }
@@ -128,7 +128,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kFunction));
 }
@@ -140,7 +140,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kFunction));
 }
@@ -152,7 +152,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kFunction));
 }
@@ -166,7 +166,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(builtin::AddressSpace::kUniform,
                                                                builtin::AddressSpace::kStorage,
diff --git a/src/tint/resolver/struct_pipeline_stage_use_test.cc b/src/tint/resolver/struct_pipeline_stage_use_test.cc
index 4707650..b4857f0 100644
--- a/src/tint/resolver/struct_pipeline_stage_use_test.cc
+++ b/src/tint/resolver/struct_pipeline_stage_use_test.cc
@@ -34,7 +34,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_TRUE(sem->PipelineStageUses().empty());
 }
@@ -46,7 +46,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_TRUE(sem->PipelineStageUses().empty());
 }
@@ -59,7 +59,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_TRUE(sem->PipelineStageUses().empty());
 }
@@ -74,7 +74,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->PipelineStageUses(),
                 UnorderedElementsAre(type::PipelineStageUsage::kVertexInput));
@@ -90,7 +90,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->PipelineStageUses(),
                 UnorderedElementsAre(type::PipelineStageUsage::kVertexOutput));
@@ -104,7 +104,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->PipelineStageUses(),
                 UnorderedElementsAre(type::PipelineStageUsage::kFragmentInput));
@@ -118,7 +118,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->PipelineStageUses(),
                 UnorderedElementsAre(type::PipelineStageUsage::kFragmentOutput));
@@ -135,7 +135,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->PipelineStageUses(),
                 UnorderedElementsAre(type::PipelineStageUsage::kComputeInput));
@@ -154,7 +154,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->PipelineStageUses(),
                 UnorderedElementsAre(type::PipelineStageUsage::kVertexOutput,
@@ -170,7 +170,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->PipelineStageUses(),
                 UnorderedElementsAre(type::PipelineStageUsage::kFragmentInput));
@@ -184,10 +184,10 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     ASSERT_EQ(1u, sem->Members().Length());
-    EXPECT_EQ(3u, sem->Members()[0]->Location());
+    EXPECT_EQ(3u, sem->Members()[0]->Attributes().location);
 }
 
 TEST_F(ResolverPipelineStageUseTest, StructUsedAsShaderReturnTypeViaAlias) {
@@ -200,7 +200,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->PipelineStageUses(),
                 UnorderedElementsAre(type::PipelineStageUsage::kFragmentOutput));
@@ -214,10 +214,10 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<sem::Struct>();
+    auto* sem = TypeOf(s)->As<type::Struct>();
     ASSERT_NE(sem, nullptr);
     ASSERT_EQ(1u, sem->Members().Length());
-    EXPECT_EQ(3u, sem->Members()[0]->Location());
+    EXPECT_EQ(3u, sem->Members()[0]->Attributes().location);
 }
 
 }  // namespace
diff --git a/src/tint/resolver/unresolved_identifier_test.cc b/src/tint/resolver/unresolved_identifier_test.cc
index e52b858..5802005 100644
--- a/src/tint/resolver/unresolved_identifier_test.cc
+++ b/src/tint/resolver/unresolved_identifier_test.cc
@@ -43,7 +43,7 @@
     Func("f",
          utils::Vector{
              Param("p", ty.i32(), utils::Vector{Builtin(Expr(Source{{12, 34}}, "positon"))})},
-         ty.void_(), utils::Empty);
+         ty.void_(), utils::Empty, utils::Vector{Stage(ast::PipelineStage::kVertex)});
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), R"(12:34 error: unresolved builtin value 'positon'
diff --git a/src/tint/resolver/validator.cc b/src/tint/resolver/validator.cc
index 97eae88..63f2b4d 100644
--- a/src/tint/resolver/validator.cc
+++ b/src/tint/resolver/validator.cc
@@ -200,7 +200,7 @@
 // https://gpuweb.github.io/gpuweb/wgsl/#plain-types-section
 bool Validator::IsPlain(const type::Type* type) const {
     return type->is_scalar() ||
-           type->IsAnyOf<type::Atomic, type::Vector, type::Matrix, type::Array, sem::Struct>();
+           type->IsAnyOf<type::Atomic, type::Vector, type::Matrix, type::Array, type::Struct>();
 }
 
 // https://gpuweb.github.io/gpuweb/wgsl/#fixed-footprint-types
@@ -214,7 +214,7 @@
             return !arr->Count()->Is<type::RuntimeArrayCount>() &&
                    IsFixedFootprint(arr->ElemType());
         },
-        [&](const sem::Struct* str) {
+        [&](const type::Struct* str) {
             for (auto* member : str->Members()) {
                 if (!IsFixedFootprint(member->Type())) {
                     return false;
@@ -235,7 +235,7 @@
         [&](const type::Vector* vec) { return IsHostShareable(vec->type()); },
         [&](const type::Matrix* mat) { return IsHostShareable(mat->type()); },
         [&](const type::Array* arr) { return IsHostShareable(arr->ElemType()); },
-        [&](const sem::Struct* str) {
+        [&](const type::Struct* str) {
             for (auto* member : str->Members()) {
                 if (!IsHostShareable(member->Type())) {
                     return false;
@@ -397,11 +397,11 @@
 
     auto is_uniform_struct_or_array = [address_space](const type::Type* ty) {
         return address_space == builtin::AddressSpace::kUniform &&
-               ty->IsAnyOf<type::Array, sem::Struct>();
+               ty->IsAnyOf<type::Array, type::Struct>();
     };
 
     auto is_uniform_struct = [address_space](const type::Type* ty) {
-        return address_space == builtin::AddressSpace::kUniform && ty->Is<sem::Struct>();
+        return address_space == builtin::AddressSpace::kUniform && ty->Is<type::Struct>();
     };
 
     auto required_alignment_of = [&](const type::Type* ty) {
@@ -413,7 +413,7 @@
         return required_align;
     };
 
-    auto member_name_of = [](const sem::StructMember* sm) { return sm->Name().Name(); };
+    auto member_name_of = [](const type::StructMember* sm) { return sm->Name().Name(); };
 
     // Only validate the [type + address space] once
     if (!valid_type_storage_layouts_.Add(TypeAndAddressSpace{store_ty, address_space})) {
@@ -445,7 +445,7 @@
 
             // Recurse into the member type.
             if (!AddressSpaceLayout(m->Type(), address_space, m->Declaration()->type->source)) {
-                AddNote("see layout of struct:\n" + str->Layout(), str->Source());
+                AddNote("see layout of struct:\n" + str->Layout(), str->Declaration()->source);
                 note_usage();
                 return false;
             }
@@ -461,13 +461,13 @@
                              "' is currently at offset " + std::to_string(m->Offset()) +
                              ". Consider setting @align(" + std::to_string(required_align) +
                              ") on this member",
-                         m->Source());
+                         m->Declaration()->source);
 
-                AddNote("see layout of struct:\n" + str->Layout(), str->Source());
+                AddNote("see layout of struct:\n" + str->Layout(), str->Declaration()->source);
 
                 if (auto* member_str = m->Type()->As<sem::Struct>()) {
                     AddNote("and layout of struct member:\n" + member_str->Layout(),
-                            member_str->Source());
+                            member_str->Declaration()->source);
                 }
 
                 note_usage();
@@ -483,19 +483,19 @@
                     !enabled_extensions_.Contains(
                         builtin::Extension::kChromiumInternalRelaxedUniformLayout)) {
                     AddError(
-                        "uniform storage requires that the number of bytes between the "
-                        "start of the previous member of type struct and the current "
-                        "member be a multiple of 16 bytes, but there are currently " +
+                        "uniform storage requires that the number of bytes between the start of "
+                        "the previous member of type struct and the current member be a multiple "
+                        "of 16 bytes, but there are currently " +
                             std::to_string(prev_to_curr_offset) + " bytes between '" +
                             member_name_of(prev_member) + "' and '" + member_name_of(m) +
                             "'. Consider setting @align(16) on this member",
-                        m->Source());
+                        m->Declaration()->source);
 
-                    AddNote("see layout of struct:\n" + str->Layout(), str->Source());
+                    AddNote("see layout of struct:\n" + str->Layout(), str->Declaration()->source);
 
                     auto* prev_member_str = prev_member->Type()->As<sem::Struct>();
                     AddNote("and layout of previous member struct:\n" + prev_member_str->Layout(),
-                            prev_member_str->Source());
+                            prev_member_str->Declaration()->source);
                     note_usage();
                     return false;
                 }
@@ -606,32 +606,10 @@
                 return false;
             }
 
-            for (auto* attr : decl->attributes) {
-                bool is_shader_io_attribute =
-                    attr->IsAnyOf<ast::BuiltinAttribute, ast::InterpolateAttribute,
-                                  ast::InvariantAttribute, ast::LocationAttribute>();
-                bool has_io_address_space = global->AddressSpace() == builtin::AddressSpace::kIn ||
-                                            global->AddressSpace() == builtin::AddressSpace::kOut;
-                if (!attr->IsAnyOf<ast::BindingAttribute, ast::GroupAttribute,
-                                   ast::InternalAttribute>() &&
-                    (!is_shader_io_attribute || !has_io_address_space)) {
-                    AddError("attribute '" + attr->Name() + "' is not valid for module-scope 'var'",
-                             attr->source);
-                    return false;
-                }
-            }
-
             return Var(global);
         },
         [&](const ast::Override*) { return Override(global, override_ids); },
-        [&](const ast::Const*) {
-            if (!decl->attributes.IsEmpty()) {
-                AddError("attribute is not valid for module-scope 'const' declaration",
-                         decl->attributes[0]->source);
-                return false;
-            }
-            return Const(global);
-        },
+        [&](const ast::Const*) { return Const(global); },
         [&](Default) {
             TINT_ICE(Resolver, diagnostics_)
                 << "Validator::GlobalVariable() called with a unknown variable type: "
@@ -773,9 +751,6 @@
                     ast::GetAttribute<ast::IdAttribute>((*var)->Declaration()->attributes)->source);
                 return false;
             }
-        } else {
-            AddError("attribute is not valid for 'override' declaration", attr->source);
-            return false;
         }
     }
 
@@ -792,28 +767,13 @@
     return true;
 }
 
-bool Validator::Parameter(const ast::Function* func, const sem::Variable* var) const {
+bool Validator::Parameter(const sem::Variable* var) const {
     auto* decl = var->Declaration();
 
     if (IsValidationDisabled(decl->attributes, ast::DisabledValidation::kFunctionParameter)) {
         return true;
     }
 
-    for (auto* attr : decl->attributes) {
-        if (!func->IsEntryPoint() && !attr->Is<ast::InternalAttribute>()) {
-            AddError("attribute is not valid for non-entry point function parameters",
-                     attr->source);
-            return false;
-        }
-        if (!attr->IsAnyOf<ast::BuiltinAttribute, ast::InvariantAttribute, ast::LocationAttribute,
-                           ast::InterpolateAttribute, ast::InternalAttribute>() &&
-            (IsValidationEnabled(decl->attributes,
-                                 ast::DisabledValidation::kEntryPointParameter))) {
-            AddError("attribute is not valid for function parameters", attr->source);
-            return false;
-        }
-    }
-
     if (auto* ref = var->Type()->As<type::Pointer>()) {
         if (IsValidationEnabled(decl->attributes, ast::DisabledValidation::kIgnoreAddressSpace)) {
             bool ok = false;
@@ -1028,14 +988,7 @@
                 }
                 return true;
             },
-            [&](Default) {
-                if (!attr->IsAnyOf<ast::DiagnosticAttribute, ast::StageAttribute,
-                                   ast::InternalAttribute>()) {
-                    AddError("attribute is not valid for functions", attr->source);
-                    return false;
-                }
-                return true;
-            });
+            [&](Default) { return true; });
         if (!ok) {
             return false;
         }
@@ -1069,24 +1022,6 @@
             TINT_ICE(Resolver, diagnostics_)
                 << "Function " << decl->name->symbol.Name() << " has no body";
         }
-
-        for (auto* attr : decl->return_type_attributes) {
-            if (!decl->IsEntryPoint()) {
-                AddError("attribute is not valid for non-entry point function return types",
-                         attr->source);
-                return false;
-            }
-            if (!attr->IsAnyOf<ast::BuiltinAttribute, ast::InternalAttribute,
-                               ast::LocationAttribute, ast::InterpolateAttribute,
-                               ast::InvariantAttribute>() &&
-                (IsValidationEnabled(decl->attributes,
-                                     ast::DisabledValidation::kEntryPointParameter) &&
-                 IsValidationEnabled(decl->attributes,
-                                     ast::DisabledValidation::kFunctionParameter))) {
-                AddError("attribute is not valid for entry point return types", attr->source);
-                return false;
-            }
-        }
     }
 
     if (decl->IsEntryPoint()) {
@@ -1196,19 +1131,19 @@
             if (is_invalid_compute_shader_attribute) {
                 std::string input_or_output =
                     param_or_ret == ParamOrRetType::kParameter ? "inputs" : "output";
-                AddError("attribute is not valid for compute shader " + input_or_output,
+                AddError("@" + attr->Name() + " is not valid for compute shader " + input_or_output,
                          attr->source);
                 return false;
             }
         }
 
         if (IsValidationEnabled(attrs, ast::DisabledValidation::kEntryPointParameter)) {
-            if (is_struct_member && ty->Is<sem::Struct>()) {
+            if (is_struct_member && ty->Is<type::Struct>()) {
                 AddError("nested structures cannot be used for entry point IO", source);
                 return false;
             }
 
-            if (!ty->Is<sem::Struct>() && !pipeline_io_attribute) {
+            if (!ty->Is<type::Struct>() && !pipeline_io_attribute) {
                 std::string err = "missing entry point IO attribute";
                 if (!is_struct_member) {
                     err += (param_or_ret == ParamOrRetType::kParameter ? " on parameter"
@@ -1278,9 +1213,9 @@
             if (auto* str = ty->As<sem::Struct>()) {
                 for (auto* member : str->Members()) {
                     if (!validate_entry_point_attributes_inner(
-                            member->Declaration()->attributes, member->Type(), member->Source(),
-                            param_or_ret,
-                            /*is_struct_member*/ true, member->Location())) {
+                            member->Declaration()->attributes, member->Type(),
+                            member->Declaration()->source, param_or_ret,
+                            /*is_struct_member*/ true, member->Attributes().location)) {
                         AddNote("while analyzing entry point '" + decl->name->symbol.Name() + "'",
                                 decl->source);
                         return false;
@@ -1828,7 +1763,7 @@
 }
 
 bool Validator::StructureInitializer(const ast::CallExpression* ctor,
-                                     const sem::Struct* struct_type) const {
+                                     const type::Struct* struct_type) const {
     if (!struct_type->IsConstructible()) {
         AddError("structure constructor has non-constructible type", ctor->source);
         return false;
@@ -2131,7 +2066,7 @@
 
 bool Validator::Structure(const sem::Struct* str, ast::PipelineStage stage) const {
     if (str->Members().IsEmpty()) {
-        AddError("structures must have at least one member", str->Source());
+        AddError("structures must have at least one member", str->Declaration()->source);
         return false;
     }
 
@@ -2141,7 +2076,7 @@
             if (r->Count()->Is<type::RuntimeArrayCount>()) {
                 if (member != str->Members().Back()) {
                     AddError("runtime arrays may only appear as the last member of a struct",
-                             member->Source());
+                             member->Declaration()->source);
                     return false;
                 }
             }
@@ -2153,7 +2088,7 @@
         } else if (!IsFixedFootprint(member->Type())) {
             AddError(
                 "a struct that contains a runtime array cannot be nested inside another struct",
-                member->Source());
+                member->Declaration()->source);
             return false;
         }
 
@@ -2170,9 +2105,10 @@
                 },
                 [&](const ast::LocationAttribute* location) {
                     has_location = true;
-                    TINT_ASSERT(Resolver, member->Location().has_value());
-                    if (!LocationAttribute(location, member->Location().value(), member->Type(),
-                                           locations, stage, member->Source())) {
+                    TINT_ASSERT(Resolver, member->Attributes().location.has_value());
+                    if (!LocationAttribute(location, member->Attributes().location.value(),
+                                           member->Type(), locations, stage,
+                                           member->Declaration()->source)) {
                         return false;
                     }
                     return true;
@@ -2205,24 +2141,7 @@
                     }
                     return true;
                 },
-                [&](Default) {
-                    if (!attr->IsAnyOf<ast::BuiltinAttribute,             //
-                                       ast::InternalAttribute,            //
-                                       ast::InterpolateAttribute,         //
-                                       ast::InvariantAttribute,           //
-                                       ast::LocationAttribute,            //
-                                       ast::StructMemberOffsetAttribute,  //
-                                       ast::StructMemberAlignAttribute>()) {
-                        if (attr->Is<ast::StrideAttribute>() &&
-                            IsValidationDisabled(member->Declaration()->attributes,
-                                                 ast::DisabledValidation::kIgnoreStrideAttribute)) {
-                            return true;
-                        }
-                        AddError("attribute is not valid for structure members", attr->source);
-                        return false;
-                    }
-                    return true;
-                });
+                [&](Default) { return true; });
             if (!ok) {
                 return false;
             }
@@ -2241,13 +2160,6 @@
         }
     }
 
-    for (auto* attr : str->Declaration()->attributes) {
-        if (!(attr->IsAnyOf<ast::InternalAttribute>())) {
-            AddError("attribute is not valid for struct declarations", attr->source);
-            return false;
-        }
-    }
-
     return true;
 }
 
@@ -2260,7 +2172,8 @@
                                   const bool is_input) const {
     std::string inputs_or_output = is_input ? "inputs" : "output";
     if (stage == ast::PipelineStage::kCompute) {
-        AddError("attribute is not valid for compute shader " + inputs_or_output, loc_attr->source);
+        AddError("@" + loc_attr->Name() + " is not valid for compute shader " + inputs_or_output,
+                 loc_attr->source);
         return false;
     }
 
@@ -2652,8 +2565,8 @@
             }
             return true;
         },
-        [&](const sem::Struct*) { return check_sub_atomics(); },  //
-        [&](const type::Array*) { return check_sub_atomics(); },  //
+        [&](const type::Struct*) { return check_sub_atomics(); },  //
+        [&](const type::Array*) { return check_sub_atomics(); },   //
         [&](Default) { return true; });
 }
 
diff --git a/src/tint/resolver/validator.h b/src/tint/resolver/validator.h
index e0e3051..999bc49 100644
--- a/src/tint/resolver/validator.h
+++ b/src/tint/resolver/validator.h
@@ -348,10 +348,9 @@
     bool Matrix(const type::Type* el_ty, const Source& source) const;
 
     /// Validates a function parameter
-    /// @param func the function the variable is for
     /// @param var the variable to validate
     /// @returns true on success, false otherwise
-    bool Parameter(const ast::Function* func, const sem::Variable* var) const;
+    bool Parameter(const sem::Variable* var) const;
 
     /// Validates a return
     /// @param ret the return statement to validate
@@ -398,7 +397,7 @@
     /// @param struct_type the type of the structure
     /// @returns true on success, false otherwise
     bool StructureInitializer(const ast::CallExpression* ctor,
-                              const sem::Struct* struct_type) const;
+                              const type::Struct* struct_type) const;
 
     /// Validates a switch statement
     /// @param s the switch to validate
diff --git a/src/tint/resolver/variable_test.cc b/src/tint/resolver/variable_test.cc
index 7af6027..5daee08 100644
--- a/src/tint/resolver/variable_test.cc
+++ b/src/tint/resolver/variable_test.cc
@@ -81,8 +81,8 @@
     EXPECT_TRUE(TypeOf(f)->As<type::Reference>()->StoreType()->Is<type::F32>());
     EXPECT_TRUE(TypeOf(h)->As<type::Reference>()->StoreType()->Is<type::F16>());
     EXPECT_TRUE(TypeOf(b)->As<type::Reference>()->StoreType()->Is<type::Bool>());
-    EXPECT_TRUE(TypeOf(s)->As<type::Reference>()->StoreType()->Is<sem::Struct>());
-    EXPECT_TRUE(TypeOf(a)->As<type::Reference>()->StoreType()->Is<sem::Struct>());
+    EXPECT_TRUE(TypeOf(s)->As<type::Reference>()->StoreType()->Is<type::Struct>());
+    EXPECT_TRUE(TypeOf(a)->As<type::Reference>()->StoreType()->Is<type::Struct>());
 
     EXPECT_EQ(Sem().Get(i)->Initializer(), nullptr);
     EXPECT_EQ(Sem().Get(u)->Initializer(), nullptr);
@@ -161,8 +161,8 @@
     EXPECT_TRUE(TypeOf(f)->As<type::Reference>()->StoreType()->Is<type::F32>());
     EXPECT_TRUE(TypeOf(h)->As<type::Reference>()->StoreType()->Is<type::F16>());
     EXPECT_TRUE(TypeOf(b)->As<type::Reference>()->StoreType()->Is<type::Bool>());
-    EXPECT_TRUE(TypeOf(s)->As<type::Reference>()->StoreType()->Is<sem::Struct>());
-    EXPECT_TRUE(TypeOf(a)->As<type::Reference>()->StoreType()->Is<sem::Struct>());
+    EXPECT_TRUE(TypeOf(s)->As<type::Reference>()->StoreType()->Is<type::Struct>());
+    EXPECT_TRUE(TypeOf(a)->As<type::Reference>()->StoreType()->Is<type::Struct>());
 
     EXPECT_EQ(Sem().Get(i)->Initializer()->Declaration(), i_c);
     EXPECT_EQ(Sem().Get(u)->Initializer()->Declaration(), u_c);
@@ -383,7 +383,7 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-// Function-scope 'let'
+// 'let' declaration
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 TEST_F(ResolverVariableTest, LocalLet) {
     // struct S { i : i32; }
@@ -444,8 +444,8 @@
     ASSERT_TRUE(TypeOf(f)->Is<type::F32>());
     ASSERT_TRUE(TypeOf(h)->Is<type::F16>());
     ASSERT_TRUE(TypeOf(b)->Is<type::Bool>());
-    ASSERT_TRUE(TypeOf(s)->Is<sem::Struct>());
-    ASSERT_TRUE(TypeOf(a)->Is<sem::Struct>());
+    ASSERT_TRUE(TypeOf(s)->Is<type::Struct>());
+    ASSERT_TRUE(TypeOf(a)->Is<type::Struct>());
     ASSERT_TRUE(TypeOf(p)->Is<type::Pointer>());
     ASSERT_TRUE(TypeOf(p)->As<type::Pointer>()->StoreType()->Is<type::I32>());
 
@@ -924,7 +924,7 @@
     ASSERT_TRUE(TypeOf(c_vu32)->Is<type::Vector>());
     ASSERT_TRUE(TypeOf(c_vf32)->Is<type::Vector>());
     ASSERT_TRUE(TypeOf(c_mf32)->Is<type::Matrix>());
-    ASSERT_TRUE(TypeOf(c_s)->Is<sem::Struct>());
+    ASSERT_TRUE(TypeOf(c_s)->Is<type::Struct>());
 
     EXPECT_TRUE(Sem().Get(c_i32)->ConstantValue()->AllZero());
     EXPECT_TRUE(Sem().Get(c_u32)->ConstantValue()->AllZero());
@@ -987,7 +987,7 @@
     ASSERT_TRUE(TypeOf(c_vaf)->Is<type::Vector>());
     ASSERT_TRUE(TypeOf(c_mf32)->Is<type::Matrix>());
     ASSERT_TRUE(TypeOf(c_maf32)->Is<type::Matrix>());
-    ASSERT_TRUE(TypeOf(c_s)->Is<sem::Struct>());
+    ASSERT_TRUE(TypeOf(c_s)->Is<type::Struct>());
 
     EXPECT_TRUE(Sem().Get(c_i32)->ConstantValue()->AllZero());
     EXPECT_TRUE(Sem().Get(c_u32)->ConstantValue()->AllZero());
diff --git a/src/tint/sem/member_accessor_expression.cc b/src/tint/sem/member_accessor_expression.cc
index 9ad15f0..573f670 100644
--- a/src/tint/sem/member_accessor_expression.cc
+++ b/src/tint/sem/member_accessor_expression.cc
@@ -41,7 +41,7 @@
                                        const Statement* statement,
                                        const constant::Value* constant,
                                        const ValueExpression* object,
-                                       const StructMember* member,
+                                       const type::StructMember* member,
                                        bool has_side_effects,
                                        const Variable* root_ident /* = nullptr */)
     : Base(declaration,
diff --git a/src/tint/sem/member_accessor_expression.h b/src/tint/sem/member_accessor_expression.h
index cea9f2d..b2abdec 100644
--- a/src/tint/sem/member_accessor_expression.h
+++ b/src/tint/sem/member_accessor_expression.h
@@ -22,9 +22,9 @@
 namespace tint::ast {
 class MemberAccessorExpression;
 }  // namespace tint::ast
-namespace tint::sem {
+namespace tint::type {
 class StructMember;
-}  // namespace tint::sem
+}  // namespace tint::type
 
 namespace tint::sem {
 
@@ -81,7 +81,7 @@
                        const Statement* statement,
                        const constant::Value* constant,
                        const ValueExpression* object,
-                       const StructMember* member,
+                       const type::StructMember* member,
                        bool has_side_effects,
                        const Variable* root_ident = nullptr);
 
@@ -89,10 +89,10 @@
     ~StructMemberAccess() override;
 
     /// @returns the structure member
-    StructMember const* Member() const { return member_; }
+    type::StructMember const* Member() const { return member_; }
 
   private:
-    StructMember const* const member_;
+    type::StructMember const* const member_;
 };
 
 /// Swizzle holds the semantic information for a ast::MemberAccessorExpression
diff --git a/src/tint/sem/struct.cc b/src/tint/sem/struct.cc
index 413231a..e6c0e73 100644
--- a/src/tint/sem/struct.cc
+++ b/src/tint/sem/struct.cc
@@ -22,26 +22,28 @@
 namespace tint::sem {
 
 Struct::Struct(const ast::Struct* declaration,
-               tint::Source source,
                Symbol name,
                utils::VectorRef<const StructMember*> members,
                uint32_t align,
                uint32_t size,
                uint32_t size_no_padding)
-    : Base(source, name, members, align, size, size_no_padding), declaration_(declaration) {}
+    : Base(name, members, align, size, size_no_padding), declaration_(declaration) {
+    TINT_ASSERT(Semantic, declaration != nullptr);
+}
 
 Struct::~Struct() = default;
 
 StructMember::StructMember(const ast::StructMember* declaration,
-                           tint::Source source,
                            Symbol name,
                            const type::Type* type,
                            uint32_t index,
                            uint32_t offset,
                            uint32_t align,
                            uint32_t size,
-                           std::optional<uint32_t> location)
-    : Base(source, name, type, index, offset, align, size, location), declaration_(declaration) {}
+                           const type::StructMemberAttributes& attributes)
+    : Base(name, type, index, offset, align, size, attributes), declaration_(declaration) {
+    TINT_ASSERT(Semantic, declaration != nullptr);
+}
 
 StructMember::~StructMember() = default;
 
diff --git a/src/tint/sem/struct.h b/src/tint/sem/struct.h
index 2b437af..fd59dcd 100644
--- a/src/tint/sem/struct.h
+++ b/src/tint/sem/struct.h
@@ -38,19 +38,17 @@
 namespace tint::sem {
 
 /// Struct holds the semantic information for structures.
+/// Unlike type::Struct, sem::Struct has an AST declaration node.
 class Struct final : public utils::Castable<Struct, type::Struct> {
   public:
     /// Constructor
     /// @param declaration the AST structure declaration
-    /// @param source the source of the structure
     /// @param name the name of the structure
     /// @param members the structure members
     /// @param align the byte alignment of the structure
     /// @param size the byte size of the structure
-    /// @param size_no_padding size of the members without the end of structure
-    /// alignment padding
+    /// @param size_no_padding size of the members without the end of structure alignment padding
     Struct(const ast::Struct* declaration,
-           tint::Source source,
            Symbol name,
            utils::VectorRef<const StructMember*> members,
            uint32_t align,
@@ -73,27 +71,26 @@
 };
 
 /// StructMember holds the semantic information for structure members.
+/// Unlike type::StructMember, sem::StructMember has an AST declaration node.
 class StructMember final : public utils::Castable<StructMember, type::StructMember> {
   public:
     /// Constructor
     /// @param declaration the AST declaration node
-    /// @param source the source of the struct member
     /// @param name the name of the structure member
     /// @param type the type of the member
     /// @param index the index of the member in the structure
     /// @param offset the byte offset from the base of the structure
     /// @param align the byte alignment of the member
     /// @param size the byte size of the member
-    /// @param location the location attribute, if present
+    /// @param attributes the optional attributes
     StructMember(const ast::StructMember* declaration,
-                 tint::Source source,
                  Symbol name,
                  const type::Type* type,
                  uint32_t index,
                  uint32_t offset,
                  uint32_t align,
                  uint32_t size,
-                 std::optional<uint32_t> location);
+                 const type::StructMemberAttributes& attributes);
 
     /// Destructor
     ~StructMember() override;
diff --git a/src/tint/sem/struct_test.cc b/src/tint/sem/struct_test.cc
index 424930d..c267234 100644
--- a/src/tint/sem/struct_test.cc
+++ b/src/tint/sem/struct_test.cc
@@ -26,8 +26,8 @@
     auto name = Sym("S");
     auto* impl = create<ast::Struct>(Ident(name), utils::Empty, utils::Empty);
     auto* ptr = impl;
-    auto* s = create<sem::Struct>(impl, impl->source, impl->name->symbol, utils::Empty,
-                                  4u /* align */, 8u /* size */, 16u /* size_no_padding */);
+    auto* s = create<sem::Struct>(impl, impl->name->symbol, utils::Empty, 4u /* align */,
+                                  8u /* size */, 16u /* size_no_padding */);
     EXPECT_EQ(s->Declaration(), ptr);
     EXPECT_EQ(s->Align(), 4u);
     EXPECT_EQ(s->Size(), 8u);
@@ -36,11 +36,11 @@
 
 TEST_F(SemStructTest, Equals) {
     auto* a_impl = create<ast::Struct>(Ident("a"), utils::Empty, utils::Empty);
-    auto* a = create<sem::Struct>(a_impl, a_impl->source, a_impl->name->symbol, utils::Empty,
-                                  4u /* align */, 4u /* size */, 4u /* size_no_padding */);
+    auto* a = create<sem::Struct>(a_impl, a_impl->name->symbol, utils::Empty, 4u /* align */,
+                                  4u /* size */, 4u /* size_no_padding */);
     auto* b_impl = create<ast::Struct>(Ident("b"), utils::Empty, utils::Empty);
-    auto* b = create<sem::Struct>(b_impl, b_impl->source, b_impl->name->symbol, utils::Empty,
-                                  4u /* align */, 4u /* size */, 4u /* size_no_padding */);
+    auto* b = create<sem::Struct>(b_impl, b_impl->name->symbol, utils::Empty, 4u /* align */,
+                                  4u /* size */, 4u /* size_no_padding */);
 
     EXPECT_TRUE(a->Equals(*a));
     EXPECT_FALSE(a->Equals(*b));
@@ -50,8 +50,8 @@
 TEST_F(SemStructTest, FriendlyName) {
     auto name = Sym("my_struct");
     auto* impl = create<ast::Struct>(Ident(name), utils::Empty, utils::Empty);
-    auto* s = create<sem::Struct>(impl, impl->source, impl->name->symbol, utils::Empty,
-                                  4u /* align */, 4u /* size */, 4u /* size_no_padding */);
+    auto* s = create<sem::Struct>(impl, impl->name->symbol, utils::Empty, 4u /* align */,
+                                  4u /* size */, 4u /* size_no_padding */);
     EXPECT_EQ(s->FriendlyName(), "my_struct");
 }
 
diff --git a/src/tint/templates/enums.tmpl.inc b/src/tint/templates/enums.tmpl.inc
index ad46942..adc06e0 100644
--- a/src/tint/templates/enums.tmpl.inc
+++ b/src/tint/templates/enums.tmpl.inc
@@ -191,7 +191,7 @@
             benchmark::DoNotOptimize(result);
         }
     }
-}
+} // NOLINT(readability/fn_size)
 
 BENCHMARK({{$enum}}Parser);
 {{- end -}}
diff --git a/src/tint/transform/array_length_from_uniform.cc b/src/tint/transform/array_length_from_uniform.cc
index 98d4a6b..1c88483 100644
--- a/src/tint/transform/array_length_from_uniform.cc
+++ b/src/tint/transform/array_length_from_uniform.cc
@@ -147,7 +147,7 @@
             const ast::Expression* total_size = total_storage_buffer_size;
             auto* storage_buffer_type = storage_buffer_sem->Type()->UnwrapRef();
             const type::Array* array_type = nullptr;
-            if (auto* str = storage_buffer_type->As<sem::Struct>()) {
+            if (auto* str = storage_buffer_type->As<type::Struct>()) {
                 // The variable is a struct, so subtract the byte offset of the array
                 // member.
                 auto* array_member_sem = str->Members().Back();
diff --git a/src/tint/transform/calculate_array_length.cc b/src/tint/transform/calculate_array_length.cc
index 743a992..4a3598d 100644
--- a/src/tint/transform/calculate_array_length.cc
+++ b/src/tint/transform/calculate_array_length.cc
@@ -204,7 +204,7 @@
 
                             const type::Array* array_type = Switch(
                                 storage_buffer_type->StoreType(),
-                                [&](const sem::Struct* str) {
+                                [&](const type::Struct* str) {
                                     // The variable is a struct, so subtract the byte offset of
                                     // the array member.
                                     auto* array_member_sem = str->Members().Back();
diff --git a/src/tint/transform/canonicalize_entry_point_io.cc b/src/tint/transform/canonicalize_entry_point_io.cc
index 840f8ff..9e9368a 100644
--- a/src/tint/transform/canonicalize_entry_point_io.cc
+++ b/src/tint/transform/canonicalize_entry_point_io.cc
@@ -371,7 +371,7 @@
         // list to pass them through to the inner function.
         utils::Vector<const ast::Expression*, 8> inner_struct_values;
         for (auto* member : str->Members()) {
-            if (TINT_UNLIKELY(member->Type()->Is<sem::Struct>())) {
+            if (TINT_UNLIKELY(member->Type()->Is<type::Struct>())) {
                 TINT_ICE(Transform, ctx.dst->Diagnostics()) << "nested IO struct";
                 continue;
             }
@@ -380,8 +380,8 @@
 
             auto attributes =
                 CloneShaderIOAttributes(member->Declaration()->attributes, do_interpolate);
-            auto* input_expr =
-                AddInput(name, member->Type(), member->Location(), std::move(attributes));
+            auto* input_expr = AddInput(name, member->Type(), member->Attributes().location,
+                                        std::move(attributes));
             inner_struct_values.Push(input_expr);
         }
 
@@ -400,7 +400,7 @@
         bool do_interpolate = func_ast->PipelineStage() != ast::PipelineStage::kFragment;
         if (auto* str = inner_ret_type->As<sem::Struct>()) {
             for (auto* member : str->Members()) {
-                if (TINT_UNLIKELY(member->Type()->Is<sem::Struct>())) {
+                if (TINT_UNLIKELY(member->Type()->Is<type::Struct>())) {
                     TINT_ICE(Transform, ctx.dst->Diagnostics()) << "nested IO struct";
                     continue;
                 }
@@ -410,8 +410,8 @@
                     CloneShaderIOAttributes(member->Declaration()->attributes, do_interpolate);
 
                 // Extract the original structure member.
-                AddOutput(name, member->Type(), member->Location(), std::move(attributes),
-                          ctx.dst->MemberAccessor(original_result, name));
+                AddOutput(name, member->Type(), member->Attributes().location,
+                          std::move(attributes), ctx.dst->MemberAccessor(original_result, name));
             }
         } else if (!inner_ret_type->Is<type::Void>()) {
             auto attributes =
@@ -639,7 +639,7 @@
         // aggregated into a single structure.
         if (!func_sem->Parameters().IsEmpty()) {
             for (auto* param : func_sem->Parameters()) {
-                if (param->Type()->Is<sem::Struct>()) {
+                if (param->Type()->Is<type::Struct>()) {
                     ProcessStructParameter(param);
                 } else {
                     ProcessNonStructParameter(param);
diff --git a/src/tint/transform/decompose_memory_access.cc b/src/tint/transform/decompose_memory_access.cc
index 564451c..181518d 100644
--- a/src/tint/transform/decompose_memory_access.cc
+++ b/src/tint/transform/decompose_memory_access.cc
@@ -522,7 +522,7 @@
                         auto* offset = b.Add("offset", u32(i * mat_ty->ColumnStride()));
                         values.Push(b.Call(load, offset));
                     }
-                } else if (auto* str = el_ty->As<sem::Struct>()) {
+                } else if (auto* str = el_ty->As<type::Struct>()) {
                     for (auto* member : str->Members()) {
                         auto* offset = b.Add("offset", u32(member->Offset()));
                         Symbol load = LoadFunc(member->Type()->UnwrapRef(), address_space, buffer);
@@ -607,7 +607,7 @@
                         }
                         return stmts;
                     },
-                    [&](const sem::Struct* str) {
+                    [&](const type::Struct* str) {
                         utils::Vector<const ast::Statement*, 8> stmts;
                         for (auto* member : str->Members()) {
                             auto* offset = b.Add("offset", u32(member->Offset()));
@@ -660,8 +660,8 @@
 
             // For intrinsics that return a struct, there is no AST node for it, so create one now.
             if (intrinsic->Type() == builtin::Function::kAtomicCompareExchangeWeak) {
-                auto* str = intrinsic->ReturnType()->As<sem::Struct>();
-                TINT_ASSERT(Transform, str && str->Declaration() == nullptr);
+                auto* str = intrinsic->ReturnType()->As<type::Struct>();
+                TINT_ASSERT(Transform, str);
 
                 utils::Vector<const ast::StructMember*, 8> ast_members;
                 ast_members.Reserve(str->Members().Length());
@@ -869,7 +869,7 @@
                 }
             } else {
                 if (auto access = state.TakeAccess(accessor->object)) {
-                    auto* str_ty = access.type->As<sem::Struct>();
+                    auto* str_ty = access.type->As<type::Struct>();
                     auto* member = str_ty->FindMember(accessor->member->symbol);
                     auto offset = member->Offset();
                     state.AddAccess(accessor, {
diff --git a/src/tint/transform/decompose_strided_matrix.cc b/src/tint/transform/decompose_strided_matrix.cc
index dd03dc2..6443095 100644
--- a/src/tint/transform/decompose_strided_matrix.cc
+++ b/src/tint/transform/decompose_strided_matrix.cc
@@ -70,7 +70,7 @@
     // Scan the program for all storage and uniform structure matrix members with
     // a custom stride attribute. Replace these matrices with an equivalent array,
     // and populate the `decomposed` map with the members that have been replaced.
-    utils::Hashmap<const ast::StructMember*, MatrixInfo, 8> decomposed;
+    utils::Hashmap<const type::StructMember*, MatrixInfo, 8> decomposed;
     for (auto* node : src->ASTNodes().Objects()) {
         if (auto* str = node->As<ast::Struct>()) {
             auto* str_ty = src->Sem().Get(str);
@@ -98,7 +98,7 @@
                 auto* replacement =
                     b.Member(member->Offset(), ctx.Clone(member->Name()), info.array(ctx.dst));
                 ctx.Replace(member->Declaration(), replacement);
-                decomposed.Add(member->Declaration(), info);
+                decomposed.Add(member, info);
             }
         }
     }
@@ -114,7 +114,7 @@
     ctx.ReplaceAll(
         [&](const ast::IndexAccessorExpression* expr) -> const ast::IndexAccessorExpression* {
             if (auto* access = src->Sem().Get<sem::StructMemberAccess>(expr->object)) {
-                if (decomposed.Contains(access->Member()->Declaration())) {
+                if (decomposed.Contains(access->Member())) {
                     auto* obj = ctx.CloneWithoutTransform(expr->object);
                     auto* idx = ctx.Clone(expr->index);
                     return b.IndexAccessor(obj, idx);
@@ -131,7 +131,7 @@
     std::unordered_map<MatrixInfo, Symbol, MatrixInfo::Hasher> mat_to_arr;
     ctx.ReplaceAll([&](const ast::AssignmentStatement* stmt) -> const ast::Statement* {
         if (auto* access = src->Sem().Get<sem::StructMemberAccess>(stmt->lhs)) {
-            if (auto info = decomposed.Find(access->Member()->Declaration())) {
+            if (auto info = decomposed.Find(access->Member())) {
                 auto fn = utils::GetOrCreate(mat_to_arr, *info, [&] {
                     auto name =
                         b.Symbols().New("mat" + std::to_string(info->matrix->columns()) + "x" +
@@ -170,7 +170,7 @@
     std::unordered_map<MatrixInfo, Symbol, MatrixInfo::Hasher> arr_to_mat;
     ctx.ReplaceAll([&](const ast::MemberAccessorExpression* expr) -> const ast::Expression* {
         if (auto* access = src->Sem().Get(expr)->UnwrapLoad()->As<sem::StructMemberAccess>()) {
-            if (auto info = decomposed.Find(access->Member()->Declaration())) {
+            if (auto info = decomposed.Find(access->Member())) {
                 auto fn = utils::GetOrCreate(arr_to_mat, *info, [&] {
                     auto name =
                         b.Symbols().New("arr_to_mat" + std::to_string(info->matrix->columns()) +
diff --git a/src/tint/transform/demote_to_helper.cc b/src/tint/transform/demote_to_helper.cc
index c853ef0..46e9203 100644
--- a/src/tint/transform/demote_to_helper.cc
+++ b/src/tint/transform/demote_to_helper.cc
@@ -186,7 +186,7 @@
                             // original member values over to it.
 
                             // Declare a struct to hold the result values.
-                            auto* result_struct = sem_call->Type()->As<sem::Struct>();
+                            auto* result_struct = sem_call->Type()->As<type::Struct>();
                             auto* atomic_ty = result_struct->Members()[0]->Type();
                             result_ty = b.ty(
                                 utils::GetOrCreate(atomic_cmpxchg_result_types, atomic_ty, [&]() {
diff --git a/src/tint/transform/first_index_offset.cc b/src/tint/transform/first_index_offset.cc
index 59588e2..c8d4a26 100644
--- a/src/tint/transform/first_index_offset.cc
+++ b/src/tint/transform/first_index_offset.cc
@@ -79,7 +79,7 @@
 
     // Map of builtin usages
     std::unordered_map<const sem::Variable*, const char*> builtin_vars;
-    std::unordered_map<const sem::StructMember*, const char*> builtin_members;
+    std::unordered_map<const type::StructMember*, const char*> builtin_members;
 
     bool has_vertex_or_instance_index = false;
 
diff --git a/src/tint/transform/localize_struct_array_assignment.cc b/src/tint/transform/localize_struct_array_assignment.cc
index f5f8744..775da6a 100644
--- a/src/tint/transform/localize_struct_array_assignment.cc
+++ b/src/tint/transform/localize_struct_array_assignment.cc
@@ -60,7 +60,7 @@
                     continue;
                 }
                 auto og = GetOriginatingTypeAndAddressSpace(assign_stmt);
-                if (!(og.first->Is<sem::Struct>() &&
+                if (!(og.first->Is<type::Struct>() &&
                       (og.second == builtin::AddressSpace::kFunction ||
                        og.second == builtin::AddressSpace::kPrivate))) {
                     continue;
diff --git a/src/tint/transform/module_scope_var_to_entry_point_param.cc b/src/tint/transform/module_scope_var_to_entry_point_param.cc
index a394ef6..14e16bb 100644
--- a/src/tint/transform/module_scope_var_to_entry_point_param.cc
+++ b/src/tint/transform/module_scope_var_to_entry_point_param.cc
@@ -54,7 +54,7 @@
         return true;
     } else if (auto* ary = type->As<type::Array>()) {
         return ContainsMatrix(ary->ElemType());
-    } else if (auto* str = type->As<sem::Struct>()) {
+    } else if (auto* str = type->As<type::Struct>()) {
         for (auto* member : str->Members()) {
             if (ContainsMatrix(member->Type())) {
                 return true;
@@ -85,11 +85,6 @@
                 return;
             }
 
-            if (!str->Declaration()) {
-                // The struct is a built-in structure that we do not need to declare.
-                return;
-            }
-
             // Recurse into members.
             for (auto* member : str->Members()) {
                 CloneStructTypes(member->Type());
diff --git a/src/tint/transform/num_workgroups_from_uniform.cc b/src/tint/transform/num_workgroups_from_uniform.cc
index 18889f4..60e9a72 100644
--- a/src/tint/transform/num_workgroups_from_uniform.cc
+++ b/src/tint/transform/num_workgroups_from_uniform.cc
@@ -99,10 +99,7 @@
             }
 
             for (auto* member : str->Members()) {
-                auto* builtin =
-                    ast::GetAttribute<ast::BuiltinAttribute>(member->Declaration()->attributes);
-                if (!builtin ||
-                    src->Sem().Get(builtin)->Value() != builtin::BuiltinValue::kNumWorkgroups) {
+                if (member->Attributes().builtin != builtin::BuiltinValue::kNumWorkgroups) {
                     continue;
                 }
 
diff --git a/src/tint/transform/packed_vec3.cc b/src/tint/transform/packed_vec3.cc
index 9ef78a6..16d8af4 100644
--- a/src/tint/transform/packed_vec3.cc
+++ b/src/tint/transform/packed_vec3.cc
@@ -159,7 +159,7 @@
                 }
                 return {};
             },
-            [&](const sem::Struct* str) -> ast::Type {
+            [&](const type::Struct* str) -> ast::Type {
                 if (ContainsVec3(str)) {
                     auto name = rewritten_structs.GetOrCreate(str, [&]() {
                         utils::Vector<const ast::StructMember*, 4> members;
@@ -170,12 +170,14 @@
                                 // Copy the member attributes.
                                 bool needs_align = true;
                                 utils::Vector<const ast::Attribute*, 4> attributes;
-                                for (auto* attr : member->Declaration()->attributes) {
-                                    if (attr->IsAnyOf<ast::StructMemberAlignAttribute,
-                                                      ast::StructMemberOffsetAttribute>()) {
-                                        needs_align = false;
+                                if (auto* sem_mem = member->As<sem::StructMember>()) {
+                                    for (auto* attr : sem_mem->Declaration()->attributes) {
+                                        if (attr->IsAnyOf<ast::StructMemberAlignAttribute,
+                                                          ast::StructMemberOffsetAttribute>()) {
+                                            needs_align = false;
+                                        }
+                                        attributes.Push(ctx.Clone(attr));
                                     }
-                                    attributes.Push(ctx.Clone(attr));
                                 }
                                 // If the alignment wasn't already specified, add an attribute to
                                 // make sure that we don't alter the alignment when using the packed
@@ -187,12 +189,17 @@
                                                       std::move(attributes)));
                             } else {
                                 // No vec3s, just clone the member as is.
-                                members.Push(ctx.Clone(member->Declaration()));
+                                if (auto* sem_mem = member->As<sem::StructMember>()) {
+                                    members.Push(ctx.Clone(sem_mem->Declaration()));
+                                } else {
+                                    members.Push(b.Member(ctx.Clone(member->Name()), new_type,
+                                                          utils::Empty));
+                                }
                             }
                         }
                         // Create the new structure.
-                        auto struct_name = b.Symbols().New(str->Declaration()->name->symbol.Name() +
-                                                           "_tint_packed_vec3");
+                        auto struct_name =
+                            b.Symbols().New(str->Name().Name() + "_tint_packed_vec3");
                         b.Structure(struct_name, std::move(members));
                         return struct_name;
                     });
@@ -246,7 +253,7 @@
             [&](const type::Matrix* mat) {
                 copy_array_elements(mat->columns(), mat->ColumnType());
             },
-            [&](const sem::Struct* str) {
+            [&](const type::Struct* str) {
                 // Copy the struct members over one at a time, packing/unpacking as necessary.
                 for (auto* member : str->Members()) {
                     const ast::Expression* element =
diff --git a/src/tint/transform/packed_vec3_test.cc b/src/tint/transform/packed_vec3_test.cc
index dbc28f7..a7f829f 100644
--- a/src/tint/transform/packed_vec3_test.cc
+++ b/src/tint/transform/packed_vec3_test.cc
@@ -4328,7 +4328,7 @@
         // The first member should have an alignment of 16 bytes, a size of 12 bytes, and the second
         // member should have an offset of 12 bytes.
         auto* sem_str = got.program.Sem().Get(vars[0]);
-        auto* str_ty = sem_str->Type()->UnwrapRef()->As<sem::Struct>();
+        auto* str_ty = sem_str->Type()->UnwrapRef()->As<type::Struct>();
         ASSERT_NE(str_ty, nullptr);
         ASSERT_EQ(str_ty->Members().Length(), 2u);
         EXPECT_EQ(str_ty->Members()[0]->Align(), 16u);
diff --git a/src/tint/transform/pad_structs.cc b/src/tint/transform/pad_structs.cc
index 90f2e59..cfa8c90 100644
--- a/src/tint/transform/pad_structs.cc
+++ b/src/tint/transform/pad_structs.cc
@@ -84,7 +84,7 @@
             new_members.Push(b.Member(name, type));
 
             uint32_t size = ty->Size();
-            if (ty->Is<sem::Struct>() && str->UsedAs(builtin::AddressSpace::kUniform)) {
+            if (ty->Is<type::Struct>() && str->UsedAs(builtin::AddressSpace::kUniform)) {
                 // std140 structs should be padded out to 16 bytes.
                 size = utils::RoundUp(16u, size);
             } else if (auto* array_ty = ty->As<type::Array>()) {
diff --git a/src/tint/transform/preserve_padding.cc b/src/tint/transform/preserve_padding.cc
index 6df1a1c..0e4daee 100644
--- a/src/tint/transform/preserve_padding.cc
+++ b/src/tint/transform/preserve_padding.cc
@@ -160,12 +160,12 @@
                     return body;
                 });
             },
-            [&](const sem::Struct* str) {
+            [&](const type::Struct* str) {
                 // Call a helper function that assigns each member separately.
                 return call_helper([&]() {
                     utils::Vector<const ast::Statement*, 8> body;
                     for (auto member : str->Members()) {
-                        auto name = member->Declaration()->name->symbol.Name();
+                        auto name = member->Name().Name();
                         body.Push(MakeAssignment(member->Type(),
                                                  b.MemberAccessor(b.Deref(kDestParamName), name),
                                                  b.MemberAccessor(kValueParamName, name)));
@@ -199,7 +199,7 @@
                 }
                 return HasPadding(col_ty);
             },
-            [&](const sem::Struct* str) {
+            [&](const type::Struct* str) {
                 uint32_t current_offset = 0;
                 for (auto* member : str->Members()) {
                     if (member->Offset() > current_offset) {
diff --git a/src/tint/transform/renamer.cc b/src/tint/transform/renamer.cc
index 14b8c12..92589b1 100644
--- a/src/tint/transform/renamer.cc
+++ b/src/tint/transform/renamer.cc
@@ -1281,8 +1281,8 @@
                 if (sem->Is<sem::Swizzle>()) {
                     preserved_identifiers.Add(accessor->member);
                 } else if (auto* str_expr = src->Sem().GetVal(accessor->object)) {
-                    if (auto* ty = str_expr->Type()->UnwrapRef()->As<sem::Struct>()) {
-                        if (ty->Declaration() == nullptr) {  // Builtin structure
+                    if (auto* ty = str_expr->Type()->UnwrapRef()->As<type::Struct>()) {
+                        if (!ty->Is<sem::Struct>()) {  // Builtin structure
                             preserved_identifiers.Add(accessor->member);
                         }
                     }
diff --git a/src/tint/transform/spirv_atomic.cc b/src/tint/transform/spirv_atomic.cc
index 82b955c..d58d58b 100644
--- a/src/tint/transform/spirv_atomic.cc
+++ b/src/tint/transform/spirv_atomic.cc
@@ -53,7 +53,7 @@
     ProgramBuilder b;
     /// The clone context
     CloneContext ctx = {&b, src, /* auto_clone_symbols */ true};
-    std::unordered_map<const ast::Struct*, ForkedStruct> forked_structs;
+    std::unordered_map<const type::Struct*, ForkedStruct> forked_structs;
     std::unordered_set<const sem::Variable*> atomic_variables;
     utils::UniqueVector<const sem::ValueExpression*, 8> atomic_expressions;
 
@@ -123,7 +123,8 @@
         if (!forked_structs.empty()) {
             ctx.ReplaceAll([&](const ast::Struct* str) {
                 // Is `str` a structure we need to fork?
-                if (auto it = forked_structs.find(str); it != forked_structs.end()) {
+                auto* str_ty = ctx.src->Sem().Get(str);
+                if (auto it = forked_structs.find(str_ty); it != forked_structs.end()) {
                     const auto& forked = it->second;
 
                     // Re-create the structure swapping in the atomic-flavoured members
@@ -154,10 +155,10 @@
     }
 
   private:
-    ForkedStruct& Fork(const ast::Struct* str) {
+    ForkedStruct& Fork(const type::Struct* str) {
         auto& forked = forked_structs[str];
         if (!forked.name.IsValid()) {
-            forked.name = b.Symbols().New(str->name->symbol.Name() + "_atomic");
+            forked.name = b.Symbols().New(str->Name().Name() + "_atomic");
         }
         return forked;
     }
@@ -179,7 +180,7 @@
                     // Fork the struct (the first time) and mark member(s) that need to be made
                     // atomic.
                     auto* member = access->Member();
-                    Fork(member->Struct()->Declaration()).atomic_members.emplace(member->Index());
+                    Fork(member->Struct()).atomic_members.emplace(member->Index());
                     atomic_expressions.Add(access->Object());
                 },
                 [&](const sem::IndexAccessorExpression* index) {
@@ -198,7 +199,7 @@
             ty,  //
             [&](const type::I32*) { return b.ty.atomic(CreateASTTypeFor(ctx, ty)); },
             [&](const type::U32*) { return b.ty.atomic(CreateASTTypeFor(ctx, ty)); },
-            [&](const sem::Struct* str) { return b.ty(Fork(str->Declaration()).name); },
+            [&](const type::Struct* str) { return b.ty(Fork(str).name); },
             [&](const type::Array* arr) {
                 if (arr->Count()->Is<type::RuntimeArrayCount>()) {
                     return b.ty.array(AtomicTypeFor(arr->ElemType()));
@@ -231,7 +232,7 @@
                 (atomic_variables.count(e->RootIdentifier()) != 0)) {
                 // If it's a struct member, make sure it's one we marked as atomic
                 if (auto* ma = e->As<sem::StructMemberAccess>()) {
-                    auto it = forked_structs.find(ma->Member()->Struct()->Declaration());
+                    auto it = forked_structs.find(ma->Member()->Struct());
                     if (it != forked_structs.end()) {
                         auto& forked = it->second;
                         return forked.atomic_members.count(ma->Member()->Index()) != 0;
diff --git a/src/tint/transform/std140.cc b/src/tint/transform/std140.cc
index b22a6e0..fa4fade 100644
--- a/src/tint/transform/std140.cc
+++ b/src/tint/transform/std140.cc
@@ -144,7 +144,7 @@
 
         // Scan structures for members that need forking
         for (auto* ty : src->Types()) {
-            if (auto* str = ty->As<sem::Struct>()) {
+            if (auto* str = ty->As<type::Struct>()) {
                 if (str->UsedAs(builtin::AddressSpace::kUniform)) {
                     for (auto* member : str->Members()) {
                         if (needs_fork(member->Type())) {
@@ -226,11 +226,11 @@
     utils::Hashset<const sem::Variable*, 8> std140_uniforms;
 
     // Map of original structure to 'std140' forked structure
-    utils::Hashmap<const sem::Struct*, Symbol, 8> std140_structs;
+    utils::Hashmap<const type::Struct*, Symbol, 8> std140_structs;
 
     // Map of structure member in src of a matrix type, to list of decomposed column
     // members in ctx.dst.
-    utils::Hashmap<const sem::StructMember*, utils::Vector<const ast::StructMember*, 4>, 8>
+    utils::Hashmap<const type::StructMember*, utils::Vector<const ast::StructMember*, 4>, 8>
         std140_mat_members;
 
     /// Describes a matrix that has been forked to a std140-structure holding the decomposed column
@@ -403,7 +403,7 @@
     ast::Type Std140Type(const type::Type* ty) {
         return Switch(
             ty,  //
-            [&](const sem::Struct* str) {
+            [&](const type::Struct* str) {
                 if (auto std140 = std140_structs.Find(str)) {
                     return b.ty(*std140);
                 }
@@ -631,7 +631,7 @@
     const std::string ConvertSuffix(const type::Type* ty) {
         return Switch(
             ty,  //
-            [&](const sem::Struct* str) { return str->Name().Name(); },
+            [&](const type::Struct* str) { return str->Name().Name(); },
             [&](const type::Array* arr) {
                 auto count = arr->ConstantCount();
                 if (TINT_UNLIKELY(!count)) {
@@ -694,7 +694,7 @@
 
             Switch(
                 ty,  //
-                [&](const sem::Struct* str) {
+                [&](const type::Struct* str) {
                     // Convert each of the structure members using either a converter function
                     // call, or by reassembling a std140 matrix from column vector members.
                     utils::Vector<const ast::Expression*, 8> args;
@@ -832,7 +832,7 @@
         // As this is accessing only part of the matrix, we just need to pick the right column
         // vector member.
         auto column_idx = std::get<u32>(chain.indices[std140_mat_idx + 1]);
-        if (auto* str = tint::As<sem::Struct>(ty)) {
+        if (auto* str = tint::As<type::Struct>(ty)) {
             // Structure member matrix. The columns are decomposed into the structure.
             auto mat_member_idx = std::get<u32>(chain.indices[std140_mat_idx]);
             auto* mat_member = str->Members()[mat_member_idx];
@@ -913,7 +913,7 @@
                 }
             }
 
-            if (auto* str = tint::As<sem::Struct>(ty)) {
+            if (auto* str = tint::As<type::Struct>(ty)) {
                 // Structure member matrix. The columns are decomposed into the structure.
                 auto mat_member_idx = std::get<u32>(chain.indices[std140_mat_idx]);
                 auto* mat_member = str->Members()[mat_member_idx];
@@ -1012,7 +1012,7 @@
         stmts.Push(b.Decl(let));
 
         utils::Vector<const ast::MemberAccessorExpression*, 4> columns;
-        if (auto* str = tint::As<sem::Struct>(ty)) {
+        if (auto* str = tint::As<type::Struct>(ty)) {
             // Structure member matrix. The columns are decomposed into the structure.
             auto mat_member_idx = std::get<u32>(chain.indices[std140_mat_idx]);
             auto* mat_member = str->Members()[mat_member_idx];
@@ -1133,7 +1133,7 @@
         auto idx = std::get<u32>(access);
         return Switch(
             ty,  //
-            [&](const sem::Struct* str) -> ExprTypeName {
+            [&](const type::Struct* str) -> ExprTypeName {
                 auto* member = str->Members()[idx];
                 auto member_name = member->Name().Name();
                 auto* expr = b.MemberAccessor(lhs, member_name);
diff --git a/src/tint/transform/transform.cc b/src/tint/transform/transform.cc
index 2002d02..453768f 100644
--- a/src/tint/transform/transform.cc
+++ b/src/tint/transform/transform.cc
@@ -143,7 +143,7 @@
         }
         return ctx.dst->ty.array(el, u32(count.value()), std::move(attrs));
     }
-    if (auto* s = ty->As<sem::Struct>()) {
+    if (auto* s = ty->As<type::Struct>()) {
         return ctx.dst->ty(ctx.Clone(s->Name()));
     }
     if (auto* s = ty->As<type::Reference>()) {
diff --git a/src/tint/transform/transform_test.cc b/src/tint/transform/transform_test.cc
index 1201e98..2da1ec5 100644
--- a/src/tint/transform/transform_test.cc
+++ b/src/tint/transform/transform_test.cc
@@ -120,8 +120,8 @@
 TEST_F(CreateASTTypeForTest, Struct) {
     auto str = create([](ProgramBuilder& b) {
         auto* decl = b.Structure("S", {});
-        return b.create<sem::Struct>(decl, decl->source, decl->name->symbol, utils::Empty,
-                                     4u /* align */, 4u /* size */, 4u /* size_no_padding */);
+        return b.create<sem::Struct>(decl, decl->name->symbol, utils::Empty, 4u /* align */,
+                                     4u /* size */, 4u /* size_no_padding */);
     });
 
     ast::CheckIdentifier(str, "S");
diff --git a/src/tint/transform/truncate_interstage_variables.cc b/src/tint/transform/truncate_interstage_variables.cc
index 33c5cf7..1fc0050 100644
--- a/src/tint/transform/truncate_interstage_variables.cc
+++ b/src/tint/transform/truncate_interstage_variables.cc
@@ -83,6 +83,8 @@
         auto* func_sem = sem.Get(func_ast);
         auto* str = func_sem->ReturnType()->As<sem::Struct>();
 
+        // This transform is run after CanonicalizeEntryPointIO transform,
+        // So it is guaranteed that entry point inputs are already grouped in a struct.
         if (TINT_UNLIKELY(!str)) {
             TINT_ICE(Transform, ctx.dst->Diagnostics())
                 << "Entrypoint function return type is non-struct.\n"
@@ -91,20 +93,14 @@
             continue;
         }
 
-        // This transform is run after CanonicalizeEntryPointIO transform,
-        // So it is guaranteed that entry point inputs are already grouped in a struct.
-        const ast::Struct* struct_ty = str->Declaration();
-
         // A prepass to check if any interstage variable locations in the entry point needs
         // truncating. If not we don't really need to handle this entry point.
         utils::Hashset<const sem::StructMember*, 16u> omit_members;
 
-        for (auto* member : struct_ty->members) {
-            if (ast::GetAttribute<ast::LocationAttribute>(member->attributes)) {
-                auto* m = sem.Get(member);
-                uint32_t location = m->Location().value();
-                if (!data->interstage_locations.test(location)) {
-                    omit_members.Add(m);
+        for (auto* member : str->Members()) {
+            if (auto location = member->Attributes().location) {
+                if (!data->interstage_locations.test(location.value())) {
+                    omit_members.Add(member);
                 }
             }
         }
diff --git a/src/tint/transform/vertex_pulling.cc b/src/tint/transform/vertex_pulling.cc
index 064be00..5f704de 100644
--- a/src/tint/transform/vertex_pulling.cc
+++ b/src/tint/transform/vertex_pulling.cc
@@ -826,8 +826,8 @@
                 auto* sem = src->Sem().Get(member);
                 info.type = sem->Type();
 
-                TINT_ASSERT(Transform, sem->Location().has_value());
-                location_info[sem->Location().value()] = info;
+                TINT_ASSERT(Transform, sem->Attributes().location.has_value());
+                location_info[sem->Attributes().location.value()] = info;
                 has_locations = true;
             } else {
                 auto* builtin_attr = ast::GetAttribute<ast::BuiltinAttribute>(member->attributes);
diff --git a/src/tint/transform/zero_init_workgroup_memory.cc b/src/tint/transform/zero_init_workgroup_memory.cc
index 8572ef2..ec4a869 100644
--- a/src/tint/transform/zero_init_workgroup_memory.cc
+++ b/src/tint/transform/zero_init_workgroup_memory.cc
@@ -168,19 +168,16 @@
                 }
             }
 
-            if (auto* str = sem.Get(param)->Type()->As<sem::Struct>()) {
+            if (auto* str = sem.Get(param)->Type()->As<type::Struct>()) {
                 for (auto* member : str->Members()) {
-                    if (auto* builtin_attr = ast::GetAttribute<ast::BuiltinAttribute>(
-                            member->Declaration()->attributes)) {
-                        auto builtin = sem.Get(builtin_attr)->Value();
-                        if (builtin == builtin::BuiltinValue::kLocalInvocationIndex) {
-                            local_index = [=] {
-                                auto* param_expr = b.Expr(ctx.Clone(param->name->symbol));
-                                auto* member_name = ctx.Clone(member->Declaration()->name);
-                                return b.MemberAccessor(param_expr, member_name);
-                            };
-                            break;
-                        }
+                    if (member->Attributes().builtin ==
+                        builtin::BuiltinValue::kLocalInvocationIndex) {
+                        local_index = [=] {
+                            auto* param_expr = b.Expr(ctx.Clone(param->name->symbol));
+                            auto member_name = ctx.Clone(member->Name());
+                            return b.MemberAccessor(param_expr, member_name);
+                        };
+                        break;
                     }
                 }
             }
@@ -318,9 +315,9 @@
             return true;
         }
 
-        if (auto* str = ty->As<sem::Struct>()) {
+        if (auto* str = ty->As<type::Struct>()) {
             for (auto* member : str->Members()) {
-                auto name = ctx.Clone(member->Declaration()->name->symbol);
+                auto name = ctx.Clone(member->Name());
                 auto get_member = [&](uint32_t num_values) {
                     auto s = get_expr(num_values);
                     if (!s) {
@@ -444,7 +441,7 @@
         if (ty->Is<type::Atomic>()) {
             return false;
         }
-        if (auto* str = ty->As<sem::Struct>()) {
+        if (auto* str = ty->As<type::Struct>()) {
             for (auto* member : str->Members()) {
                 if (!CanTriviallyZero(member->Type())) {
                     return false;
diff --git a/src/tint/type/struct.cc b/src/tint/type/struct.cc
index e5c8d4c..c9864cb 100644
--- a/src/tint/type/struct.cc
+++ b/src/tint/type/struct.cc
@@ -52,14 +52,12 @@
 
 }  // namespace
 
-Struct::Struct(tint::Source source,
-               Symbol name,
+Struct::Struct(Symbol name,
                utils::VectorRef<const StructMember*> members,
                uint32_t align,
                uint32_t size,
                uint32_t size_no_padding)
     : Base(utils::Hash(utils::TypeInfo::Of<Struct>().full_hashcode, name), FlagsFrom(members)),
-      source_(source),
       name_(name),
       members_(std::move(members)),
       align_(align),
@@ -169,33 +167,30 @@
     for (const auto& mem : members_) {
         members.Push(mem->Clone(ctx));
     }
-    return ctx.dst.mgr->Get<Struct>(source_, sym, members, align_, size_, size_no_padding_);
+    return ctx.dst.mgr->Get<Struct>(sym, members, align_, size_, size_no_padding_);
 }
 
-StructMember::StructMember(tint::Source source,
-                           Symbol name,
+StructMember::StructMember(Symbol name,
                            const type::Type* type,
                            uint32_t index,
                            uint32_t offset,
                            uint32_t align,
                            uint32_t size,
-                           std::optional<uint32_t> location)
-    : source_(source),
-      name_(name),
+                           const StructMemberAttributes& attributes)
+    : name_(name),
       type_(type),
       index_(index),
       offset_(offset),
       align_(align),
       size_(size),
-      location_(location) {}
+      attributes_(attributes) {}
 
 StructMember::~StructMember() = default;
 
 StructMember* StructMember::Clone(CloneContext& ctx) const {
     auto sym = ctx.dst.st->Register(name_.Name());
     auto* ty = type_->Clone(ctx);
-    return ctx.dst.mgr->Get<StructMember>(source_, sym, ty, index_, offset_, align_, size_,
-                                          location_);
+    return ctx.dst.mgr->Get<StructMember>(sym, ty, index_, offset_, align_, size_, attributes_);
 }
 
 }  // namespace tint::type
diff --git a/src/tint/type/struct.h b/src/tint/type/struct.h
index ea459f5..08119d0 100644
--- a/src/tint/type/struct.h
+++ b/src/tint/type/struct.h
@@ -22,6 +22,7 @@
 #include <unordered_set>
 
 #include "src/tint/builtin/address_space.h"
+#include "src/tint/builtin/interpolation.h"
 #include "src/tint/symbol.h"
 #include "src/tint/type/node.h"
 #include "src/tint/type/type.h"
@@ -48,15 +49,13 @@
 class Struct : public utils::Castable<Struct, Type> {
   public:
     /// Constructor
-    /// @param source the source of the structure
     /// @param name the name of the structure
     /// @param members the structure members
     /// @param align the byte alignment of the structure
     /// @param size the byte size of the structure
     /// @param size_no_padding size of the members without the end of structure
     /// alignment padding
-    Struct(tint::Source source,
-           Symbol name,
+    Struct(Symbol name,
            utils::VectorRef<const StructMember*> members,
            uint32_t align,
            uint32_t size,
@@ -69,9 +68,6 @@
     /// @returns true if the this type is equal to @p other
     bool Equals(const UniqueNode& other) const override;
 
-    /// @returns the source of the structure
-    tint::Source Source() const { return source_; }
-
     /// @returns the name of the structure
     Symbol Name() const { return name_; }
 
@@ -152,7 +148,6 @@
     Struct* Clone(CloneContext& ctx) const override;
 
   private:
-    const tint::Source source_;
     const Symbol name_;
     const utils::Vector<const StructMember*, 4> members_;
     const uint32_t align_;
@@ -163,33 +158,40 @@
     utils::Vector<const Struct*, 2> concrete_types_;
 };
 
+/// Attributes that can be applied to the StructMember
+struct StructMemberAttributes {
+    /// The value of a `@location` attribute
+    std::optional<uint32_t> location;
+    /// The value of a `@builtin` attribute
+    std::optional<builtin::BuiltinValue> builtin;
+    /// The values of a `@interpolate` attribute
+    std::optional<builtin::Interpolation> interpolation;
+    /// True if the member was annotated with `@invariant`
+    bool invariant = false;
+};
+
 /// StructMember holds the type information for structure members.
 class StructMember : public utils::Castable<StructMember, Node> {
   public:
     /// Constructor
-    /// @param source the source of the struct member
     /// @param name the name of the structure member
     /// @param type the type of the member
     /// @param index the index of the member in the structure
     /// @param offset the byte offset from the base of the structure
     /// @param align the byte alignment of the member
     /// @param size the byte size of the member
-    /// @param location the location attribute, if present
-    StructMember(tint::Source source,
-                 Symbol name,
+    /// @param attributes the optional attributes
+    StructMember(Symbol name,
                  const type::Type* type,
                  uint32_t index,
                  uint32_t offset,
                  uint32_t align,
                  uint32_t size,
-                 std::optional<uint32_t> location);
+                 const StructMemberAttributes& attributes);
 
     /// Destructor
     ~StructMember() override;
 
-    /// @returns the source the struct member
-    const tint::Source& Source() const { return source_; }
-
     /// @returns the name of the structure member
     Symbol Name() const { return name_; }
 
@@ -215,15 +217,14 @@
     /// @returns byte size
     uint32_t Size() const { return size_; }
 
-    /// @returns the location, if set
-    std::optional<uint32_t> Location() const { return location_; }
+    /// @returns the optional attributes
+    const StructMemberAttributes& Attributes() const { return attributes_; }
 
     /// @param ctx the clone context
     /// @returns a clone of this struct member
     StructMember* Clone(CloneContext& ctx) const;
 
   private:
-    const tint::Source source_;
     const Symbol name_;
     const type::Struct* struct_;
     const type::Type* type_;
@@ -231,7 +232,7 @@
     const uint32_t offset_;
     const uint32_t align_;
     const uint32_t size_;
-    const std::optional<uint32_t> location_;
+    const StructMemberAttributes attributes_;
 };
 
 }  // namespace tint::type
diff --git a/src/tint/type/struct_test.cc b/src/tint/type/struct_test.cc
index 7bfb437..bb88740 100644
--- a/src/tint/type/struct_test.cc
+++ b/src/tint/type/struct_test.cc
@@ -24,7 +24,7 @@
 
 TEST_F(TypeStructTest, Creation) {
     auto name = Sym("S");
-    auto* s = create<Struct>(Source{}, name, utils::Empty, 4u /* align */, 8u /* size */,
+    auto* s = create<Struct>(name, utils::Empty, 4u /* align */, 8u /* size */,
                              16u /* size_no_padding */);
     EXPECT_EQ(s->Align(), 4u);
     EXPECT_EQ(s->Size(), 8u);
@@ -32,9 +32,9 @@
 }
 
 TEST_F(TypeStructTest, Equals) {
-    auto* a = create<Struct>(Source{}, Sym("a"), utils::Empty, 4u /* align */, 4u /* size */,
+    auto* a = create<Struct>(Sym("a"), utils::Empty, 4u /* align */, 4u /* size */,
                              4u /* size_no_padding */);
-    auto* b = create<Struct>(Source{}, Sym("b"), utils::Empty, 4u /* align */, 4u /* size */,
+    auto* b = create<Struct>(Sym("b"), utils::Empty, 4u /* align */, 4u /* size */,
                              4u /* size_no_padding */);
 
     EXPECT_TRUE(a->Equals(*a));
@@ -44,8 +44,8 @@
 
 TEST_F(TypeStructTest, FriendlyName) {
     auto name = Sym("my_struct");
-    auto* s = create<Struct>(Source{}, name, utils::Empty, 4u /* align */, 4u /* size */,
-                             4u /* size_no_padding */);
+    auto* s =
+        create<Struct>(name, utils::Empty, 4u /* align */, 4u /* size */, 4u /* size_no_padding */);
     EXPECT_EQ(s->FriendlyName(), "my_struct");
 }
 
@@ -101,10 +101,8 @@
     auto* sem = p.Sem().Get(st);
     ASSERT_EQ(2u, sem->Members().Length());
 
-    EXPECT_TRUE(sem->Members()[0]->Location().has_value());
-    EXPECT_EQ(sem->Members()[0]->Location().value(), 1u);
-
-    EXPECT_FALSE(sem->Members()[1]->Location().has_value());
+    EXPECT_EQ(sem->Members()[0]->Attributes().location, 1u);
+    EXPECT_FALSE(sem->Members()[1]->Attributes().location.has_value());
 }
 
 TEST_F(TypeStructTest, IsConstructable) {
@@ -207,12 +205,15 @@
 }
 
 TEST_F(TypeStructTest, Clone) {
+    type::StructMemberAttributes attrs_location_2;
+    attrs_location_2.location = 2;
+
     auto* s = create<Struct>(
-        Source{}, Sym("my_struct"),
-        utils::Vector{create<StructMember>(Source{}, Sym("b"), create<Vector>(create<F32>(), 3u),
-                                           0u, 0u, 16u, 12u, std::optional<uint32_t>{2}),
-                      create<StructMember>(Source{}, Sym("a"), create<I32>(), 1u, 16u, 4u, 4u,
-                                           std::optional<uint32_t>())},
+        Sym("my_struct"),
+        utils::Vector{create<StructMember>(Sym("b"), create<Vector>(create<F32>(), 3u), 0u, 0u, 16u,
+                                           12u, attrs_location_2),
+                      create<StructMember>(Sym("a"), create<I32>(), 1u, 16u, 4u, 4u,
+                                           type::StructMemberAttributes{})},
         4u /* align */, 8u /* size */, 16u /* size_no_padding */);
 
     ProgramID id;
diff --git a/src/tint/type/type_test.cc b/src/tint/type/type_test.cc
index 1565e10..b76a43a 100644
--- a/src/tint/type/type_test.cc
+++ b/src/tint/type/type_test.cc
@@ -45,50 +45,44 @@
     const Matrix* mat4x3_af = create<Matrix>(vec3_af, 4u);
     const Reference* ref_u32 =
         create<Reference>(u32, builtin::AddressSpace::kPrivate, builtin::Access::kReadWrite);
-    const Struct* str_f32 = create<Struct>(Source{},
-                                           Sym("str_f32"),
+    const Struct* str_f32 = create<Struct>(Sym("str_f32"),
                                            utils::Vector{
                                                create<StructMember>(
-                                                   /* source */ Source{},
                                                    /* name */ Sym("x"),
                                                    /* type */ f32,
                                                    /* index */ 0u,
                                                    /* offset */ 0u,
                                                    /* align */ 4u,
                                                    /* size */ 4u,
-                                                   /* location */ std::nullopt),
+                                                   /* attributes */ type::StructMemberAttributes{}),
                                            },
                                            /* align*/ 4u,
                                            /* size*/ 4u,
                                            /* size_no_padding*/ 4u);
-    const Struct* str_f16 = create<Struct>(Source{},
-                                           Sym("str_f16"),
+    const Struct* str_f16 = create<Struct>(Sym("str_f16"),
                                            utils::Vector{
                                                create<StructMember>(
-                                                   /* source */ Source{},
                                                    /* name */ Sym("x"),
                                                    /* type */ f16,
                                                    /* index */ 0u,
                                                    /* offset */ 0u,
                                                    /* align */ 4u,
                                                    /* size */ 4u,
-                                                   /* location */ std::nullopt),
+                                                   /* attributes */ type::StructMemberAttributes{}),
                                            },
                                            /* align*/ 4u,
                                            /* size*/ 4u,
                                            /* size_no_padding*/ 4u);
-    Struct* str_af = create<Struct>(Source{},
-                                    Sym("str_af"),
+    Struct* str_af = create<Struct>(Sym("str_af"),
                                     utils::Vector{
                                         create<StructMember>(
-                                            /* source */ Source{},
                                             /* name */ Sym("x"),
                                             /* type */ af,
                                             /* index */ 0u,
                                             /* offset */ 0u,
                                             /* align */ 4u,
                                             /* size */ 4u,
-                                            /* location */ std::nullopt),
+                                            /* attributes */ type::StructMemberAttributes{}),
                                     },
                                     /* align*/ 4u,
                                     /* size*/ 4u,
diff --git a/src/tint/writer/glsl/generator_impl.cc b/src/tint/writer/glsl/generator_impl.cc
index cd3834f..8fcdd3d 100644
--- a/src/tint/writer/glsl/generator_impl.cc
+++ b/src/tint/writer/glsl/generator_impl.cc
@@ -814,7 +814,7 @@
             return;
         }
         case builtin::Function::kAtomicCompareExchangeWeak: {
-            EmitStructType(&helpers_, builtin->ReturnType()->As<sem::Struct>());
+            EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>());
 
             auto* dest = expr->args[0];
             auto* compare_value = expr->args[1];
@@ -1043,7 +1043,7 @@
                       [&](TextBuffer* b, const std::vector<std::string>& params) {
                           // Emit the builtin return type unique to this overload. This does not
                           // exist in the AST, so it will not be generated in Generate().
-                          EmitStructType(&helpers_, builtin->ReturnType()->As<sem::Struct>());
+                          EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>());
 
                           {
                               auto l = line(b);
@@ -1064,7 +1064,7 @@
                       [&](TextBuffer* b, const std::vector<std::string>& params) {
                           // Emit the builtin return type unique to this overload. This does not
                           // exist in the AST, so it will not be generated in Generate().
-                          EmitStructType(&helpers_, builtin->ReturnType()->As<sem::Struct>());
+                          EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>());
 
                           {
                               auto l = line(b);
@@ -1769,7 +1769,7 @@
 
 void GeneratorImpl::EmitUniformVariable(const ast::Var* var, const sem::Variable* sem) {
     auto* type = sem->Type()->UnwrapRef();
-    auto* str = type->As<sem::Struct>();
+    auto* str = type->As<type::Struct>();
     if (TINT_UNLIKELY(!str)) {
         TINT_ICE(Writer, builder_.Diagnostics()) << "storage variable must be of struct type";
         return;
@@ -1788,7 +1788,7 @@
 
 void GeneratorImpl::EmitStorageVariable(const ast::Var* var, const sem::Variable* sem) {
     auto* type = sem->Type()->UnwrapRef();
-    auto* str = type->As<sem::Struct>();
+    auto* str = type->As<type::Struct>();
     if (TINT_UNLIKELY(!str)) {
         TINT_ICE(Writer, builder_.Diagnostics()) << "storage variable must be of struct type";
         return;
@@ -2040,7 +2040,7 @@
         for (auto* var : func->params) {
             auto* sem = builder_.Sem().Get(var);
             auto* type = sem->Type();
-            if (TINT_UNLIKELY(!type->Is<sem::Struct>())) {
+            if (TINT_UNLIKELY(!type->Is<type::Struct>())) {
                 // ICE likely indicates that the CanonicalizeEntryPointIO transform was
                 // not run, or a builtin parameter was added after it was run.
                 TINT_ICE(Writer, diagnostics_) << "Unsupported non-struct entry point parameter";
@@ -2132,7 +2132,7 @@
                 EmitConstant(out, constant->Index(i));
             }
         },
-        [&](const sem::Struct* s) {
+        [&](const type::Struct* s) {
             EmitStructType(&helpers_, s);
 
             out << StructName(s);
@@ -2210,7 +2210,7 @@
             }
             EmitZeroValue(out, mat->type());
         }
-    } else if (auto* str = type->As<sem::Struct>()) {
+    } else if (auto* str = type->As<type::Struct>()) {
         EmitType(out, type, builtin::AddressSpace::kUndefined, builtin::Access::kUndefined, "");
         bool first = true;
         ScopedParen sp(out);
@@ -2568,7 +2568,7 @@
         TINT_ICE(Writer, diagnostics_) << "Attempting to emit pointer type. These should have been "
                                           "removed with the SimplifyPointers transform";
     } else if (type->Is<type::Sampler>()) {
-    } else if (auto* str = type->As<sem::Struct>()) {
+    } else if (auto* str = type->As<type::Struct>()) {
         out << StructName(str);
     } else if (auto* tex = type->As<type::Texture>()) {
         if (TINT_UNLIKELY(tex->Is<type::ExternalTexture>())) {
@@ -2669,7 +2669,7 @@
     }
 }
 
-void GeneratorImpl::EmitStructType(TextBuffer* b, const sem::Struct* str) {
+void GeneratorImpl::EmitStructType(TextBuffer* b, const type::Struct* str) {
     auto it = emitted_structs_.emplace(str);
     if (!it.second) {
         return;
@@ -2682,7 +2682,7 @@
     line(b);
 }
 
-void GeneratorImpl::EmitStructMembers(TextBuffer* b, const sem::Struct* str) {
+void GeneratorImpl::EmitStructMembers(TextBuffer* b, const type::Struct* str) {
     ScopedIndent si(b);
     for (auto* mem : str->Members()) {
         auto name = mem->Name().Name();
diff --git a/src/tint/writer/glsl/generator_impl.h b/src/tint/writer/glsl/generator_impl.h
index 0698d4f..5d74e37 100644
--- a/src/tint/writer/glsl/generator_impl.h
+++ b/src/tint/writer/glsl/generator_impl.h
@@ -383,11 +383,11 @@
     /// this function will simply return `true` without emitting anything.
     /// @param buffer the text buffer that the type declaration will be written to
     /// @param ty the struct to generate
-    void EmitStructType(TextBuffer* buffer, const sem::Struct* ty);
+    void EmitStructType(TextBuffer* buffer, const type::Struct* ty);
     /// Handles generating the members of a structure
     /// @param buffer the text buffer that the struct members will be written to
     /// @param ty the struct to generate
-    void EmitStructMembers(TextBuffer* buffer, const sem::Struct* ty);
+    void EmitStructMembers(TextBuffer* buffer, const type::Struct* ty);
     /// Handles a unary op expression
     /// @param out the output of the expression stream
     /// @param expr the expression to emit
@@ -399,7 +399,7 @@
     /// Handles generating a 'var' declaration
     /// @param var the variable to generate
     void EmitVar(const ast::Var* var);
-    /// Handles generating a function-scope 'let' declaration
+    /// Handles generating a 'let' declaration
     /// @param let the variable to generate
     void EmitLet(const ast::Let* let);
     /// Handles generating a module-scope 'let' declaration
@@ -460,7 +460,7 @@
     std::unordered_map<const type::Vector*, std::string> dynamic_vector_write_;
     std::unordered_map<const type::Vector*, std::string> int_dot_funcs_;
     std::unordered_map<BinaryOperandType, std::string> float_modulo_funcs_;
-    std::unordered_set<const sem::Struct*> emitted_structs_;
+    std::unordered_set<const type::Struct*> emitted_structs_;
     bool requires_oes_sample_variables_ = false;
     bool requires_default_precision_qualifier_ = false;
     bool requires_f16_extension_ = false;
diff --git a/src/tint/writer/glsl/generator_impl_type_test.cc b/src/tint/writer/glsl/generator_impl_type_test.cc
index 0e85155..5cec150 100644
--- a/src/tint/writer/glsl/generator_impl_type_test.cc
+++ b/src/tint/writer/glsl/generator_impl_type_test.cc
@@ -170,8 +170,8 @@
     GeneratorImpl& gen = Build();
 
     TextGenerator::TextBuffer buf;
-    auto* sem_s = program->TypeOf(s)->As<sem::Struct>();
-    gen.EmitStructType(&buf, sem_s);
+    auto* str = program->TypeOf(s)->As<type::Struct>();
+    gen.EmitStructType(&buf, str);
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
     EXPECT_EQ(buf.String(), R"(struct S {
   int a;
@@ -190,9 +190,9 @@
 
     GeneratorImpl& gen = Build();
 
-    auto* sem_s = program->TypeOf(s)->As<sem::Struct>();
+    auto* str = program->TypeOf(s)->As<type::Struct>();
     utils::StringStream out;
-    gen.EmitType(out, sem_s, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite, "");
+    gen.EmitType(out, str, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite, "");
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
     EXPECT_EQ(out.str(), "S");
 }
@@ -224,8 +224,8 @@
     GeneratorImpl& gen = Build();
 
     TextGenerator::TextBuffer buf;
-    auto* sem_s = program->TypeOf(s)->As<sem::Struct>();
-    gen.EmitStructType(&buf, sem_s);
+    auto* str = program->TypeOf(s)->As<type::Struct>();
+    gen.EmitStructType(&buf, str);
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
     EXPECT_EQ(buf.String(), R"(struct S {
   int a;
diff --git a/src/tint/writer/hlsl/generator_impl.cc b/src/tint/writer/hlsl/generator_impl.cc
index 5cce6a1..ed86e9e 100644
--- a/src/tint/writer/hlsl/generator_impl.cc
+++ b/src/tint/writer/hlsl/generator_impl.cc
@@ -1094,7 +1094,7 @@
         }
     }
 
-    bool brackets = type->IsAnyOf<type::Array, sem::Struct>();
+    bool brackets = type->IsAnyOf<type::Array, type::Struct>();
 
     // For single-value vector initializers, swizzle the scalar to the right
     // vector dimension using .x
@@ -1887,7 +1887,7 @@
             return true;
         }
         case builtin::Function::kAtomicCompareExchangeWeak: {
-            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<sem::Struct>())) {
+            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>())) {
                 return false;
             }
 
@@ -2004,7 +2004,7 @@
 
             // Emit the builtin return type unique to this overload. This does not
             // exist in the AST, so it will not be generated in Generate().
-            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<sem::Struct>())) {
+            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>())) {
                 return false;
             }
 
@@ -2037,7 +2037,7 @@
 
             // Emit the builtin return type unique to this overload. This does not
             // exist in the AST, so it will not be generated in Generate().
-            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<sem::Struct>())) {
+            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>())) {
                 return false;
             }
 
@@ -3287,7 +3287,7 @@
         for (auto* var : func->params) {
             auto* sem = builder_.Sem().Get(var);
             auto* type = sem->Type();
-            if (TINT_UNLIKELY(!type->Is<sem::Struct>())) {
+            if (TINT_UNLIKELY(!type->Is<type::Struct>())) {
                 // ICE likely indicates that the CanonicalizeEntryPointIO transform was
                 // not run, or a builtin parameter was added after it was run.
                 TINT_ICE(Writer, diagnostics_) << "Unsupported non-struct entry point parameter";
@@ -3437,7 +3437,7 @@
 
             return true;
         },
-        [&](const sem::Struct* s) {
+        [&](const type::Struct* s) {
             if (!EmitStructType(&helpers_, s)) {
                 return false;
             }
@@ -3580,7 +3580,7 @@
             }
             return true;
         },
-        [&](const sem::Struct*) {
+        [&](const type::Struct*) {
             out << "(";
             TINT_DEFER(out << ")" << value);
             return EmitType(out, type, builtin::AddressSpace::kUndefined,
@@ -4077,7 +4077,7 @@
             out << "State";
             return true;
         },
-        [&](const sem::Struct* str) {
+        [&](const type::Struct* str) {
             out << StructName(str);
             return true;
         },
@@ -4202,7 +4202,7 @@
     return true;
 }
 
-bool GeneratorImpl::EmitStructType(TextBuffer* b, const sem::Struct* str) {
+bool GeneratorImpl::EmitStructType(TextBuffer* b, const type::Struct* str) {
     auto it = emitted_structs_.emplace(str);
     if (!it.second) {
         return true;
@@ -4216,73 +4216,48 @@
             auto* ty = mem->Type();
             auto out = line(b);
             std::string pre, post;
-            if (auto* decl = mem->Declaration()) {
-                for (auto* attr : decl->attributes) {
-                    if (attr->Is<ast::LocationAttribute>()) {
-                        auto& pipeline_stage_uses = str->PipelineStageUses();
-                        if (TINT_UNLIKELY(pipeline_stage_uses.size() != 1)) {
-                            TINT_ICE(Writer, diagnostics_) << "invalid entry point IO struct uses";
-                        }
 
-                        auto loc = mem->Location().value();
-                        if (pipeline_stage_uses.count(type::PipelineStageUsage::kVertexInput)) {
-                            post += " : TEXCOORD" + std::to_string(loc);
-                        } else if (pipeline_stage_uses.count(
-                                       type::PipelineStageUsage::kVertexOutput)) {
-                            post += " : TEXCOORD" + std::to_string(loc);
-                        } else if (pipeline_stage_uses.count(
-                                       type::PipelineStageUsage::kFragmentInput)) {
-                            post += " : TEXCOORD" + std::to_string(loc);
-                        } else if (TINT_LIKELY(pipeline_stage_uses.count(
-                                       type::PipelineStageUsage::kFragmentOutput))) {
-                            post += " : SV_Target" + std::to_string(loc);
-                        } else {
-                            TINT_ICE(Writer, diagnostics_) << "invalid use of location attribute";
-                        }
-                    } else if (auto* builtin_attr = attr->As<ast::BuiltinAttribute>()) {
-                        auto builtin = program_->Sem().Get(builtin_attr)->Value();
-                        auto name = builtin_to_attribute(builtin);
-                        if (name.empty()) {
-                            diagnostics_.add_error(diag::System::Writer, "unsupported builtin");
-                            return false;
-                        }
-                        post += " : " + name;
-                    } else if (auto* interpolate = attr->As<ast::InterpolateAttribute>()) {
-                        auto& sem = program_->Sem();
-                        auto i_type =
-                            sem.Get<sem::BuiltinEnumExpression<builtin::InterpolationType>>(
-                                   interpolate->type)
-                                ->Value();
+            auto& attributes = mem->Attributes();
 
-                        auto i_smpl = builtin::InterpolationSampling::kUndefined;
-                        if (interpolate->sampling) {
-                            i_smpl =
-                                sem.Get<sem::BuiltinEnumExpression<builtin::InterpolationSampling>>(
-                                       interpolate->sampling)
-                                    ->Value();
-                        }
-
-                        auto mod = interpolation_to_modifiers(i_type, i_smpl);
-                        if (mod.empty()) {
-                            diagnostics_.add_error(diag::System::Writer,
-                                                   "unsupported interpolation");
-                            return false;
-                        }
-                        pre += mod;
-
-                    } else if (attr->Is<ast::InvariantAttribute>()) {
-                        // Note: `precise` is not exactly the same as `invariant`, but is
-                        // stricter and therefore provides the necessary guarantees.
-                        // See discussion here: https://github.com/gpuweb/gpuweb/issues/893
-                        pre += "precise ";
-                    } else if (TINT_UNLIKELY((!attr->IsAnyOf<ast::StructMemberAlignAttribute,
-                                                             ast::StructMemberOffsetAttribute,
-                                                             ast::StructMemberSizeAttribute>()))) {
-                        TINT_ICE(Writer, diagnostics_)
-                            << "unhandled struct member attribute: " << attr->Name();
-                        return false;
-                    }
+            if (auto location = attributes.location) {
+                auto& pipeline_stage_uses = str->PipelineStageUses();
+                if (TINT_UNLIKELY(pipeline_stage_uses.size() != 1)) {
+                    TINT_ICE(Writer, diagnostics_) << "invalid entry point IO struct uses";
                 }
+                if (pipeline_stage_uses.count(type::PipelineStageUsage::kVertexInput)) {
+                    post += " : TEXCOORD" + std::to_string(location.value());
+                } else if (pipeline_stage_uses.count(type::PipelineStageUsage::kVertexOutput)) {
+                    post += " : TEXCOORD" + std::to_string(location.value());
+                } else if (pipeline_stage_uses.count(type::PipelineStageUsage::kFragmentInput)) {
+                    post += " : TEXCOORD" + std::to_string(location.value());
+                } else if (TINT_LIKELY(pipeline_stage_uses.count(
+                               type::PipelineStageUsage::kFragmentOutput))) {
+                    post += " : SV_Target" + std::to_string(location.value());
+                } else {
+                    TINT_ICE(Writer, diagnostics_) << "invalid use of location attribute";
+                }
+            }
+            if (auto builtin = attributes.builtin) {
+                auto name = builtin_to_attribute(builtin.value());
+                if (name.empty()) {
+                    diagnostics_.add_error(diag::System::Writer, "unsupported builtin");
+                    return false;
+                }
+                post += " : " + name;
+            }
+            if (auto interpolation = attributes.interpolation) {
+                auto mod = interpolation_to_modifiers(interpolation->type, interpolation->sampling);
+                if (mod.empty()) {
+                    diagnostics_.add_error(diag::System::Writer, "unsupported interpolation");
+                    return false;
+                }
+                pre += mod;
+            }
+            if (attributes.invariant) {
+                // Note: `precise` is not exactly the same as `invariant`, but is
+                // stricter and therefore provides the necessary guarantees.
+                // See discussion here: https://github.com/gpuweb/gpuweb/issues/893
+                pre += "precise ";
             }
 
             out << pre;
diff --git a/src/tint/writer/hlsl/generator_impl.h b/src/tint/writer/hlsl/generator_impl.h
index 103e355..f52d58f 100644
--- a/src/tint/writer/hlsl/generator_impl.h
+++ b/src/tint/writer/hlsl/generator_impl.h
@@ -449,7 +449,7 @@
     /// @param buffer the text buffer that the type declaration will be written to
     /// @param ty the struct to generate
     /// @returns true if the struct is emitted
-    bool EmitStructType(TextBuffer* buffer, const sem::Struct* ty);
+    bool EmitStructType(TextBuffer* buffer, const type::Struct* ty);
     /// Handles a unary op expression
     /// @param out the output of the expression stream
     /// @param expr the expression to emit
@@ -470,7 +470,7 @@
     /// @param var the variable to generate
     /// @returns true if the variable was emitted
     bool EmitVar(const ast::Var* var);
-    /// Handles generating a function-scope 'let' declaration
+    /// Handles generating a 'let' declaration
     /// @param let the variable to generate
     /// @returns true if the variable was emitted
     bool EmitLet(const ast::Let* let);
@@ -568,7 +568,7 @@
     std::unordered_map<const type::Matrix*, std::string> dynamic_matrix_vector_write_;
     std::unordered_map<const type::Matrix*, std::string> dynamic_matrix_scalar_write_;
     std::unordered_map<const type::Type*, std::string> value_or_one_if_zero_;
-    std::unordered_set<const sem::Struct*> emitted_structs_;
+    std::unordered_set<const type::Struct*> emitted_structs_;
 };
 
 }  // namespace tint::writer::hlsl
diff --git a/src/tint/writer/hlsl/generator_impl_type_test.cc b/src/tint/writer/hlsl/generator_impl_type_test.cc
index d93d8e3..337b26b 100644
--- a/src/tint/writer/hlsl/generator_impl_type_test.cc
+++ b/src/tint/writer/hlsl/generator_impl_type_test.cc
@@ -171,8 +171,8 @@
     GeneratorImpl& gen = Build();
 
     TextGenerator::TextBuffer buf;
-    auto* sem_s = program->TypeOf(s)->As<sem::Struct>();
-    ASSERT_TRUE(gen.EmitStructType(&buf, sem_s)) << gen.Diagnostics();
+    auto* str = program->TypeOf(s)->As<type::Struct>();
+    ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
     EXPECT_EQ(buf.String(), R"(struct S {
   int a;
   float b;
@@ -203,10 +203,10 @@
 
     GeneratorImpl& gen = Build();
 
-    auto* sem_s = program->TypeOf(s)->As<sem::Struct>();
+    auto* str = program->TypeOf(s)->As<type::Struct>();
     utils::StringStream out;
-    ASSERT_TRUE(gen.EmitType(out, sem_s, builtin::AddressSpace::kUndefined,
-                             builtin::Access::kReadWrite, ""))
+    ASSERT_TRUE(
+        gen.EmitType(out, str, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite, ""))
         << gen.Diagnostics();
     EXPECT_EQ(out.str(), "S");
 }
@@ -238,8 +238,8 @@
     GeneratorImpl& gen = Build();
 
     TextGenerator::TextBuffer buf;
-    auto* sem_s = program->TypeOf(s)->As<sem::Struct>();
-    ASSERT_TRUE(gen.EmitStructType(&buf, sem_s)) << gen.Diagnostics();
+    auto* str = program->TypeOf(s)->As<type::Struct>();
+    ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
     EXPECT_EQ(buf.String(), R"(struct S {
   int a;
   float b;
diff --git a/src/tint/writer/msl/generator_impl.cc b/src/tint/writer/msl/generator_impl.cc
index 0435918..14288ee 100644
--- a/src/tint/writer/msl/generator_impl.cc
+++ b/src/tint/writer/msl/generator_impl.cc
@@ -363,7 +363,7 @@
 }
 
 bool GeneratorImpl::EmitTypeDecl(const type::Type* ty) {
-    if (auto* str = ty->As<sem::Struct>()) {
+    if (auto* str = ty->As<type::Struct>()) {
         if (!EmitStructType(current_buffer_, str)) {
             return false;
         }
@@ -826,7 +826,7 @@
             terminator = "}";
             return true;
         },
-        [&](const sem::Struct*) {
+        [&](const type::Struct*) {
             out << "{";
             terminator = "}";
             return true;
@@ -848,10 +848,9 @@
             out << ", ";
         }
 
-        if (auto* struct_ty = type->As<sem::Struct>()) {
+        if (auto* struct_ty = type->As<type::Struct>()) {
             // Emit field designators for structures to account for padding members.
-            auto* member = struct_ty->Members()[i]->Declaration();
-            auto name = member->name->symbol.Name();
+            auto name = struct_ty->Members()[i]->Name().Name();
             out << "." << name << "=";
         }
 
@@ -922,11 +921,11 @@
         case builtin::Function::kAtomicCompareExchangeWeak: {
             auto* ptr_ty = TypeOf(expr->args[0])->UnwrapRef()->As<type::Pointer>();
             auto sc = ptr_ty->AddressSpace();
-            auto* str = builtin->ReturnType()->As<sem::Struct>();
+            auto* str = builtin->ReturnType()->As<type::Struct>();
 
             auto func = utils::GetOrCreate(
                 atomicCompareExchangeWeak_, ACEWKeyType{{sc, str}}, [&]() -> std::string {
-                    if (!EmitStructType(&helpers_, builtin->ReturnType()->As<sem::Struct>())) {
+                    if (!EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>())) {
                         return "";
                     }
 
@@ -937,7 +936,7 @@
 
                     {
                         auto f = line(&buf);
-                        auto str_name = StructName(builtin->ReturnType()->As<sem::Struct>());
+                        auto str_name = StructName(builtin->ReturnType()->As<type::Struct>());
                         f << str_name << " " << name << "(";
                         if (!EmitTypeAndName(f, atomic_ty, "atomic")) {
                             return "";
@@ -1361,11 +1360,11 @@
 
             // Emit the builtin return type unique to this overload. This does not
             // exist in the AST, so it will not be generated in Generate().
-            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<sem::Struct>())) {
+            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>())) {
                 return false;
             }
 
-            line(b) << StructName(builtin->ReturnType()->As<sem::Struct>()) << " result;";
+            line(b) << StructName(builtin->ReturnType()->As<type::Struct>()) << " result;";
             line(b) << "result.fract = modf(" << in << ", result.whole);";
             line(b) << "return result;";
             return true;
@@ -1387,11 +1386,11 @@
 
             // Emit the builtin return type unique to this overload. This does not
             // exist in the AST, so it will not be generated in Generate().
-            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<sem::Struct>())) {
+            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>())) {
                 return false;
             }
 
-            line(b) << StructName(builtin->ReturnType()->As<sem::Struct>()) << " result;";
+            line(b) << StructName(builtin->ReturnType()->As<type::Struct>()) << " result;";
             line(b) << "result.fract = frexp(" << in << ", result.exp);";
             line(b) << "return result;";
             return true;
@@ -1658,7 +1657,7 @@
             out << "{}";
             return true;
         },
-        [&](const sem::Struct*) {
+        [&](const type::Struct*) {
             out << "{}";
             return true;
         },
@@ -1763,7 +1762,7 @@
 
             return true;
         },
-        [&](const sem::Struct* s) {
+        [&](const type::Struct* s) {
             if (!EmitStructType(&helpers_, s)) {
                 return false;
             }
@@ -2636,7 +2635,7 @@
             out << "sampler";
             return true;
         },
-        [&](const sem::Struct* str) {
+        [&](const type::Struct* str) {
             // The struct type emits as just the name. The declaration would be
             // emitted as part of emitting the declared types.
             out << StructName(str);
@@ -2791,7 +2790,7 @@
     return false;
 }
 
-bool GeneratorImpl::EmitStructType(TextBuffer* b, const sem::Struct* str) {
+bool GeneratorImpl::EmitStructType(TextBuffer* b, const type::Struct* str) {
     auto it = emitted_structs_.emplace(str);
     if (!it.second) {
         return true;
@@ -2852,88 +2851,51 @@
 
         out << " " << mem_name;
         // Emit attributes
-        if (auto* decl = mem->Declaration()) {
-            for (auto* attr : decl->attributes) {
-                bool ok = Switch(
-                    attr,
-                    [&](const ast::BuiltinAttribute* builtin_attr) {
-                        auto builtin = program_->Sem().Get(builtin_attr)->Value();
-                        auto name = builtin_to_attribute(builtin);
-                        if (name.empty()) {
-                            diagnostics_.add_error(diag::System::Writer, "unknown builtin");
-                            return false;
-                        }
-                        out << " [[" << name << "]]";
-                        return true;
-                    },
-                    [&](const ast::LocationAttribute*) {
-                        auto& pipeline_stage_uses = str->PipelineStageUses();
-                        if (TINT_UNLIKELY(pipeline_stage_uses.size() != 1)) {
-                            TINT_ICE(Writer, diagnostics_) << "invalid entry point IO struct uses";
-                            return false;
-                        }
+        auto& attributes = mem->Attributes();
 
-                        uint32_t loc = mem->Location().value();
-                        if (pipeline_stage_uses.count(type::PipelineStageUsage::kVertexInput)) {
-                            out << " [[attribute(" + std::to_string(loc) + ")]]";
-                        } else if (pipeline_stage_uses.count(
-                                       type::PipelineStageUsage::kVertexOutput)) {
-                            out << " [[user(locn" + std::to_string(loc) + ")]]";
-                        } else if (pipeline_stage_uses.count(
-                                       type::PipelineStageUsage::kFragmentInput)) {
-                            out << " [[user(locn" + std::to_string(loc) + ")]]";
-                        } else if (TINT_LIKELY(pipeline_stage_uses.count(
-                                       type::PipelineStageUsage::kFragmentOutput))) {
-                            out << " [[color(" + std::to_string(loc) + ")]]";
-                        } else {
-                            TINT_ICE(Writer, diagnostics_) << "invalid use of location decoration";
-                            return false;
-                        }
-                        return true;
-                    },
-                    [&](const ast::InterpolateAttribute* interpolate) {
-                        auto& sem = program_->Sem();
-                        auto i_type =
-                            sem.Get<sem::BuiltinEnumExpression<builtin::InterpolationType>>(
-                                   interpolate->type)
-                                ->Value();
-
-                        auto i_smpl = builtin::InterpolationSampling::kUndefined;
-                        if (interpolate->sampling) {
-                            i_smpl =
-                                sem.Get<sem::BuiltinEnumExpression<builtin::InterpolationSampling>>(
-                                       interpolate->sampling)
-                                    ->Value();
-                        }
-
-                        auto name = interpolation_to_attribute(i_type, i_smpl);
-                        if (name.empty()) {
-                            diagnostics_.add_error(diag::System::Writer,
-                                                   "unknown interpolation attribute");
-                            return false;
-                        }
-                        out << " [[" << name << "]]";
-                        return true;
-                    },
-                    [&](const ast::InvariantAttribute*) {
-                        if (invariant_define_name_.empty()) {
-                            invariant_define_name_ = UniqueIdentifier("TINT_INVARIANT");
-                        }
-                        out << " " << invariant_define_name_;
-                        return true;
-                    },
-                    [&](const ast::StructMemberOffsetAttribute*) { return true; },
-                    [&](const ast::StructMemberAlignAttribute*) { return true; },
-                    [&](const ast::StructMemberSizeAttribute*) { return true; },
-                    [&](Default) {
-                        TINT_ICE(Writer, diagnostics_)
-                            << "unhandled struct member attribute: " << attr->Name();
-                        return false;
-                    });
-                if (!ok) {
-                    return false;
-                }
+        if (auto builtin = attributes.builtin) {
+            auto name = builtin_to_attribute(builtin.value());
+            if (name.empty()) {
+                diagnostics_.add_error(diag::System::Writer, "unknown builtin");
+                return false;
             }
+            out << " [[" << name << "]]";
+        }
+
+        if (auto location = attributes.location) {
+            auto& pipeline_stage_uses = str->PipelineStageUses();
+            if (TINT_UNLIKELY(pipeline_stage_uses.size() != 1)) {
+                TINT_ICE(Writer, diagnostics_) << "invalid entry point IO struct uses";
+                return false;
+            }
+
+            if (pipeline_stage_uses.count(type::PipelineStageUsage::kVertexInput)) {
+                out << " [[attribute(" + std::to_string(location.value()) + ")]]";
+            } else if (pipeline_stage_uses.count(type::PipelineStageUsage::kVertexOutput)) {
+                out << " [[user(locn" + std::to_string(location.value()) + ")]]";
+            } else if (pipeline_stage_uses.count(type::PipelineStageUsage::kFragmentInput)) {
+                out << " [[user(locn" + std::to_string(location.value()) + ")]]";
+            } else if (TINT_LIKELY(
+                           pipeline_stage_uses.count(type::PipelineStageUsage::kFragmentOutput))) {
+                out << " [[color(" + std::to_string(location.value()) + ")]]";
+            } else {
+                TINT_ICE(Writer, diagnostics_) << "invalid use of location decoration";
+                return false;
+            }
+        }
+
+        if (auto interpolation = attributes.interpolation) {
+            auto name = interpolation_to_attribute(interpolation->type, interpolation->sampling);
+            if (name.empty()) {
+                diagnostics_.add_error(diag::System::Writer, "unknown interpolation attribute");
+                return false;
+            }
+            out << " [[" << name << "]]";
+        }
+
+        if (attributes.invariant) {
+            invariant_define_name_ = UniqueIdentifier("TINT_INVARIANT");
+            out << " " << invariant_define_name_;
         }
 
         out << ";";
@@ -3223,7 +3185,7 @@
             return SizeAndAlign{};
         },
 
-        [&](const sem::Struct* str) {
+        [&](const type::Struct* str) {
             // TODO(crbug.com/tint/650): There's an assumption here that MSL's
             // default structure size and alignment matches WGSL's. We need to
             // confirm this.
diff --git a/src/tint/writer/msl/generator_impl.h b/src/tint/writer/msl/generator_impl.h
index 5699242..0be80be 100644
--- a/src/tint/writer/msl/generator_impl.h
+++ b/src/tint/writer/msl/generator_impl.h
@@ -340,7 +340,7 @@
     /// @param buffer the text buffer that the type declaration will be written to
     /// @param str the struct to generate
     /// @returns true if the struct is emitted
-    bool EmitStructType(TextBuffer* buffer, const sem::Struct* str);
+    bool EmitStructType(TextBuffer* buffer, const type::Struct* str);
     /// Handles a unary op expression
     /// @param out the output of the expression stream
     /// @param expr the expression to emit
@@ -350,7 +350,7 @@
     /// @param var the variable to generate
     /// @returns true if the variable was emitted
     bool EmitVar(const ast::Var* var);
-    /// Handles generating a function-scope 'let' declaration
+    /// Handles generating a 'let' declaration
     /// @param let the variable to generate
     /// @returns true if the variable was emitted
     bool EmitLet(const ast::Let* let);
@@ -418,7 +418,7 @@
     /// Name of atomicCompareExchangeWeak() helper for the given pointer storage
     /// class and struct return type
     using ACEWKeyType =
-        utils::UnorderedKeyWrapper<std::tuple<builtin::AddressSpace, const sem::Struct*>>;
+        utils::UnorderedKeyWrapper<std::tuple<builtin::AddressSpace, const type::Struct*>>;
     std::unordered_map<ACEWKeyType, std::string> atomicCompareExchangeWeak_;
 
     /// Unique name of the 'TINT_INVARIANT' preprocessor define.
@@ -440,7 +440,7 @@
     std::unordered_map<const sem::Builtin*, std::string> builtins_;
     std::unordered_map<const type::Type*, std::string> unary_minus_funcs_;
     std::unordered_map<uint32_t, std::string> int_dot_funcs_;
-    std::unordered_set<const sem::Struct*> emitted_structs_;
+    std::unordered_set<const type::Struct*> emitted_structs_;
 };
 
 }  // namespace tint::writer::msl
diff --git a/src/tint/writer/msl/generator_impl_type_test.cc b/src/tint/writer/msl/generator_impl_type_test.cc
index 3208708..3b9b652 100644
--- a/src/tint/writer/msl/generator_impl_type_test.cc
+++ b/src/tint/writer/msl/generator_impl_type_test.cc
@@ -245,8 +245,8 @@
     GeneratorImpl& gen = Build();
 
     TextGenerator::TextBuffer buf;
-    auto* sem_s = program->TypeOf(s)->As<sem::Struct>();
-    ASSERT_TRUE(gen.EmitStructType(&buf, sem_s)) << gen.Diagnostics();
+    auto* str = program->TypeOf(s)->As<type::Struct>();
+    ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
     EXPECT_EQ(buf.String(), R"(struct S {
   int a;
   float b;
@@ -292,8 +292,8 @@
     GeneratorImpl& gen = Build();
 
     TextGenerator::TextBuffer buf;
-    auto* sem_s = program->TypeOf(type)->As<sem::Struct>();
-    ASSERT_TRUE(gen.EmitStructType(&buf, sem_s)) << gen.Diagnostics();
+    auto* str = program->TypeOf(type)->As<type::Struct>();
+    ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
 
     // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, ARRAY_COUNT, NAME)
     // for each field of the structure s.
@@ -401,8 +401,8 @@
     GeneratorImpl& gen = Build();
 
     TextGenerator::TextBuffer buf;
-    auto* sem_s = program->TypeOf(type)->As<sem::Struct>();
-    ASSERT_TRUE(gen.EmitStructType(&buf, sem_s)) << gen.Diagnostics();
+    auto* str = program->TypeOf(type)->As<type::Struct>();
+    ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
 
     // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, ARRAY_COUNT, NAME)
     // for each field of the structure s.
@@ -493,8 +493,8 @@
     GeneratorImpl& gen = Build();
 
     TextGenerator::TextBuffer buf;
-    auto* sem_s = program->TypeOf(type)->As<sem::Struct>();
-    ASSERT_TRUE(gen.EmitStructType(&buf, sem_s)) << gen.Diagnostics();
+    auto* str = program->TypeOf(type)->As<type::Struct>();
+    ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
 
     // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, ARRAY_COUNT, NAME)
     // for each field of the structure s.
@@ -577,8 +577,8 @@
     GeneratorImpl& gen = Build();
 
     TextGenerator::TextBuffer buf;
-    auto* sem_s = program->TypeOf(type)->As<sem::Struct>();
-    ASSERT_TRUE(gen.EmitStructType(&buf, sem_s)) << gen.Diagnostics();
+    auto* str = program->TypeOf(type)->As<type::Struct>();
+    ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
 
     // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, ARRAY_COUNT, NAME)
     // for each field of the structure s.
@@ -639,8 +639,8 @@
     GeneratorImpl& gen = Build();
 
     TextGenerator::TextBuffer buf;
-    auto* sem_s = program->TypeOf(type)->As<sem::Struct>();
-    ASSERT_TRUE(gen.EmitStructType(&buf, sem_s)) << gen.Diagnostics();
+    auto* str = program->TypeOf(type)->As<type::Struct>();
+    ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
     EXPECT_EQ(buf.String(), R"(struct S {
   /* 0x0000 */ int tint_pad_2;
   /* 0x0004 */ tint_array<int8_t, 124> tint_pad_10;
@@ -698,8 +698,8 @@
     GeneratorImpl& gen = Build();
 
     TextGenerator::TextBuffer buf;
-    auto* sem_s = program->TypeOf(type)->As<sem::Struct>();
-    ASSERT_TRUE(gen.EmitStructType(&buf, sem_s)) << gen.Diagnostics();
+    auto* str = program->TypeOf(type)->As<type::Struct>();
+    ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
     EXPECT_EQ(buf.String(), R"(struct S {
   /* 0x0000 */ int a;
   /* 0x0004 */ float b;
diff --git a/src/tint/writer/spirv/builder.cc b/src/tint/writer/spirv/builder.cc
index 4a5c90b..972ba7c 100644
--- a/src/tint/writer/spirv/builder.cc
+++ b/src/tint/writer/spirv/builder.cc
@@ -790,8 +790,8 @@
         ops.push_back(Operand(init_id));
     } else {
         auto* st = type->As<type::StorageTexture>();
-        if (st || type->Is<sem::Struct>()) {
-            // type is a sem::Struct or a type::StorageTexture
+        if (st || type->Is<type::Struct>()) {
+            // type is a type::Struct or a type::StorageTexture
             auto access = st ? st->access() : sem->Access();
             switch (access) {
                 case builtin::Access::kWrite:
@@ -1353,7 +1353,7 @@
         // If the result is not a vector then we should have validated that the
         // value type is a correctly sized vector so we can just use it directly.
         if (result_type == value_type || result_type->Is<type::Matrix>() ||
-            result_type->Is<type::Array>() || result_type->Is<sem::Struct>()) {
+            result_type->Is<type::Array>() || result_type->Is<type::Struct>()) {
             ops.push_back(Operand(id));
             continue;
         }
@@ -1715,7 +1715,7 @@
             }
             return composite(count.value());
         },
-        [&](const sem::Struct* s) { return composite(s->Members().Length()); },
+        [&](const type::Struct* s) { return composite(s->Members().Length()); },
         [&](Default) {
             error_ = "unhandled constant type: " + builder_.FriendlyName(ty);
             return 0;
@@ -2391,13 +2391,12 @@
             params.push_back(Operand(struct_id));
 
             auto* type = TypeOf(accessor->object)->UnwrapRef();
-            if (!type->Is<sem::Struct>()) {
+            if (!type->Is<type::Struct>()) {
                 error_ = "invalid type (" + type->FriendlyName() + ") for runtime array length";
                 return 0;
             }
             // Runtime array must be the last member in the structure
-            params.push_back(
-                Operand(uint32_t(type->As<sem::Struct>()->Declaration()->members.Length() - 1)));
+            params.push_back(Operand(uint32_t(type->As<type::Struct>()->Members().Length() - 1)));
 
             if (!push_function_inst(spv::Op::OpArrayLength, params)) {
                 return 0;
@@ -3702,7 +3701,7 @@
             [&](const type::Reference* ref) {  //
                 return GenerateReferenceType(ref, result);
             },
-            [&](const sem::Struct* str) {  //
+            [&](const type::Struct* str) {  //
                 return GenerateStructType(str, result);
             },
             [&](const type::U32*) {
@@ -3914,7 +3913,7 @@
     return true;
 }
 
-bool Builder::GenerateStructType(const sem::Struct* struct_type, const Operand& result) {
+bool Builder::GenerateStructType(const type::Struct* struct_type, const Operand& result) {
     auto struct_id = std::get<uint32_t>(result);
 
     if (struct_type->Name().IsValid()) {
@@ -3924,9 +3923,11 @@
     OperandList ops;
     ops.push_back(result);
 
-    auto* decl = struct_type->Declaration();
-    if (decl && ast::HasAttribute<transform::AddBlockAttribute::BlockAttribute>(decl->attributes)) {
-        push_annot(spv::Op::OpDecorate, {Operand(struct_id), U32Operand(SpvDecorationBlock)});
+    if (auto* sem_str = struct_type->As<sem::Struct>()) {
+        auto* decl = sem_str->Declaration();
+        if (ast::HasAttribute<transform::AddBlockAttribute::BlockAttribute>(decl->attributes)) {
+            push_annot(spv::Op::OpDecorate, {Operand(struct_id), U32Operand(SpvDecorationBlock)});
+        }
     }
 
     for (uint32_t i = 0; i < struct_type->Members().Length(); ++i) {
@@ -3944,7 +3945,7 @@
 
 uint32_t Builder::GenerateStructMember(uint32_t struct_id,
                                        uint32_t idx,
-                                       const sem::StructMember* member) {
+                                       const type::StructMember* member) {
     push_debug(spv::Op::OpMemberName,
                {Operand(struct_id), Operand(idx), Operand(member->Name().Name())});
 
diff --git a/src/tint/writer/spirv/builder.h b/src/tint/writer/spirv/builder.h
index 53fb108..1bbffc8 100644
--- a/src/tint/writer/spirv/builder.h
+++ b/src/tint/writer/spirv/builder.h
@@ -496,7 +496,7 @@
     /// @param struct_type the vector to generate
     /// @param result the result operand
     /// @returns true if the vector was successfully generated
-    bool GenerateStructType(const sem::Struct* struct_type, const Operand& result);
+    bool GenerateStructType(const type::Struct* struct_type, const Operand& result);
     /// Generates a struct member
     /// @param struct_id the id of the parent structure
     /// @param idx the index of the member
@@ -504,7 +504,7 @@
     /// @returns the id of the struct member or 0 on error.
     uint32_t GenerateStructMember(uint32_t struct_id,
                                   uint32_t idx,
-                                  const sem::StructMember* member);
+                                  const type::StructMember* member);
     /// Generates a variable declaration statement
     /// @param stmt the statement to generate
     /// @returns true on successfull generation
diff --git a/src/tint/writer/text_generator.cc b/src/tint/writer/text_generator.cc
index 8d18b9a..13a75d5 100644
--- a/src/tint/writer/text_generator.cc
+++ b/src/tint/writer/text_generator.cc
@@ -30,7 +30,7 @@
     return builder_.Symbols().New(prefix).Name();
 }
 
-std::string TextGenerator::StructName(const sem::Struct* s) {
+std::string TextGenerator::StructName(const type::Struct* s) {
     auto name = s->Name().Name();
     if (name.size() > 1 && name[0] == '_' && name[1] == '_') {
         name = utils::GetOrCreate(builtin_struct_names_, s,
diff --git a/src/tint/writer/text_generator.h b/src/tint/writer/text_generator.h
index 34b93d4..04fe785 100644
--- a/src/tint/writer/text_generator.h
+++ b/src/tint/writer/text_generator.h
@@ -112,7 +112,7 @@
     /// structures that start with double underscores. If the structure is a
     /// builtin, then the returned name will be a unique name without the leading
     /// underscores.
-    std::string StructName(const sem::Struct* s);
+    std::string StructName(const type::Struct* s);
 
     /// @param str the string
     /// @param suffix the suffix to remove
@@ -221,7 +221,7 @@
     /// The primary text buffer that the generator will emit
     TextBuffer main_buffer_;
     /// Map of builtin structure to unique generated name
-    std::unordered_map<const sem::Struct*, std::string> builtin_struct_names_;
+    std::unordered_map<const type::Struct*, std::string> builtin_struct_names_;
 };
 
 }  // namespace tint::writer
diff --git a/tint_overrides_with_defaults.gni b/tint_overrides_with_defaults.gni
index c54915d..977e433 100644
--- a/tint_overrides_with_defaults.gni
+++ b/tint_overrides_with_defaults.gni
@@ -77,6 +77,11 @@
     tint_build_syntax_tree_writer = false
   }
 
+  # Build the Tint IR
+  if (!defined(tint_build_ir)) {
+    tint_build_ir = false
+  }
+
   # Build unittests
   if (!defined(tint_build_unittests)) {
     tint_build_unittests = true