diff --git a/include/tint/tint.h b/include/tint/tint.h
index fe3a787..d6e54e8 100644
--- a/include/tint/tint.h
+++ b/include/tint/tint.h
@@ -30,6 +30,8 @@
 #include "src/tint/lang/wgsl/ast/transform/vertex_pulling.h"
 #include "src/tint/lang/wgsl/helpers/flatten_bindings.h"
 #include "src/tint/lang/wgsl/inspector/inspector.h"
+#include "src/tint/utils/diagnostic/formatter.h"
+#include "src/tint/utils/diagnostic/printer.h"
 #include "tint/array_length_from_uniform_options.h"
 #include "tint/binding_point.h"
 #include "tint/binding_remapper_options.h"
diff --git a/src/dawn/native/TintUtils.cpp b/src/dawn/native/TintUtils.cpp
index 4cb758c..1d2dfd4 100644
--- a/src/dawn/native/TintUtils.cpp
+++ b/src/dawn/native/TintUtils.cpp
@@ -28,17 +28,11 @@
 
 thread_local DeviceBase* tlDevice = nullptr;
 
-void TintICEReporter(const tint::diag::List& diagnostics) {
+void TintICEReporter(const tint::InternalCompilerError& err) {
     if (tlDevice) {
-        tlDevice->HandleError(DAWN_INTERNAL_ERROR(diagnostics.str()));
+        tlDevice->HandleError(DAWN_INTERNAL_ERROR(err.Error()));
 #if DAWN_ENABLE_ASSERTS
-        for (const tint::diag::Diagnostic& diag : diagnostics) {
-            if (diag.severity >= tint::diag::Severity::InternalCompilerError) {
-                HandleAssertionFailure(
-                    diag.source.file ? diag.source.file->path.c_str() : "<unknown>", "",
-                    diag.source.range.begin.line, diag.message.c_str());
-            }
-        }
+        HandleAssertionFailure(err.File(), "", err.Line(), err.Message().c_str());
 #endif
     }
 }
diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index d16559c..1a20807 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -229,8 +229,6 @@
     "utils/containers/unique_allocator.h",
     "utils/containers/unique_vector.h",
     "utils/containers/vector.h",
-    "utils/debug/debug.cc",
-    "utils/debug/debug.h",
     "utils/debug/debugger.cc",
     "utils/debug/debugger.h",
     "utils/diagnostic/diagnostic.cc",
@@ -241,6 +239,8 @@
     "utils/diagnostic/printer.h",
     "utils/diagnostic/source.cc",
     "utils/diagnostic/source.h",
+    "utils/ice/ice.cc",
+    "utils/ice/ice.h",
     "utils/macros/compiler.h",
     "utils/macros/concat.h",
     "utils/macros/defer.h",
@@ -1918,9 +1918,9 @@
       "utils/containers/unique_allocator_test.cc",
       "utils/containers/unique_vector_test.cc",
       "utils/containers/vector_test.cc",
-      "utils/debug/debug_test.cc",
       "utils/diagnostic/source_test.cc",
       "utils/file/tmpfile_test.cc",
+      "utils/ice/ice_test.cc",
       "utils/macros/defer_test.cc",
       "utils/macros/scoped_assignment_test.cc",
       "utils/math/crc32_test.cc",
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index 24472ad..2c85a44 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -56,8 +56,6 @@
 
 ## Tint diagnostic utilities. Used by libtint and tint_utils_io.
 add_library(tint_diagnostic_utils
-  utils/debug/debug.cc
-  utils/debug/debug.h
   utils/diagnostic/diagnostic.cc
   utils/diagnostic/diagnostic.h
   utils/diagnostic/formatter.cc
@@ -68,6 +66,8 @@
   utils/diagnostic/source.h
   utils/debug/debugger.cc
   utils/debug/debugger.h
+  utils/ice/ice.cc
+  utils/ice/ice.h
   utils/text/unicode.cc
   utils/text/unicode.h
 )
@@ -1139,12 +1139,12 @@
     utils/containers/unique_allocator_test.cc
     utils/containers/unique_vector_test.cc
     utils/containers/vector_test.cc
-    utils/debug/debug_test.cc
     utils/diagnostic/diagnostic_test.cc
     utils/diagnostic/formatter_test.cc
     utils/diagnostic/printer_test.cc
     utils/diagnostic/source_test.cc
     utils/file/tmpfile_test.cc
+    utils/ice/ice_test.cc
     utils/macros/defer_test.cc
     utils/macros/scoped_assignment_test.cc
     utils/math/crc32_test.cc
diff --git a/src/tint/cmd/helper.cc b/src/tint/cmd/helper.cc
index 29c8ab3..5fc4de5 100644
--- a/src/tint/cmd/helper.cc
+++ b/src/tint/cmd/helper.cc
@@ -22,6 +22,8 @@
 #include "spirv-tools/libspirv.hpp"
 #endif
 
+#include "src/tint/utils/diagnostic/formatter.h"
+#include "src/tint/utils/diagnostic/printer.h"
 #include "src/tint/utils/text/string.h"
 
 namespace tint::cmd {
@@ -68,10 +70,10 @@
 
 }  // namespace
 
-[[noreturn]] void TintInternalCompilerErrorReporter(const tint::diag::List& diagnostics) {
-    auto printer = tint::diag::Printer::create(stderr, true);
-    tint::diag::Formatter{}.format(diagnostics, printer.get());
-    tint::diag::Style bold_red{tint::diag::Color::kRed, true};
+[[noreturn]] void TintInternalCompilerErrorReporter(const InternalCompilerError& err) {
+    auto printer = diag::Printer::create(stderr, true);
+    diag::Style bold_red{diag::Color::kRed, true};
+    printer->write(err.Error(), bold_red);
     constexpr const char* please_file_bug = R"(
 ********************************************************************
 *  The tint shader compiler has encountered an unexpected error.   *
diff --git a/src/tint/cmd/helper.h b/src/tint/cmd/helper.h
index 6215059..8b00708 100644
--- a/src/tint/cmd/helper.h
+++ b/src/tint/cmd/helper.h
@@ -33,8 +33,7 @@
 };
 
 /// Reporter callback for internal tint errors
-/// @param diagnostics the diagnostics to emit
-[[noreturn]] void TintInternalCompilerErrorReporter(const tint::diag::List& diagnostics);
+[[noreturn]] void TintInternalCompilerErrorReporter(const InternalCompilerError& err);
 
 /// PrintWGSL writes the WGSL of the program to the provided ostream, if the
 /// WGSL writer is enabled, otherwise it does nothing.
diff --git a/src/tint/cmd/info.cc b/src/tint/cmd/info.cc
index 83421bc..34593f2 100644
--- a/src/tint/cmd/info.cc
+++ b/src/tint/cmd/info.cc
@@ -328,9 +328,6 @@
         return 0;
     }
 
-    auto diag_printer = tint::diag::Printer::create(stderr, true);
-    tint::diag::Formatter diag_formatter;
-
     std::unique_ptr<tint::Program> program;
     std::unique_ptr<tint::Source::File> source_file;
 
diff --git a/src/tint/cmd/loopy.cc b/src/tint/cmd/loopy.cc
index 26b9d20..e48fee7 100644
--- a/src/tint/cmd/loopy.cc
+++ b/src/tint/cmd/loopy.cc
@@ -318,9 +318,6 @@
         options.format = Format::kSpirv;
     }
 
-    auto diag_printer = tint::diag::Printer::create(stderr, true);
-    tint::diag::Formatter diag_formatter;
-
     std::unique_ptr<tint::Program> program;
     std::unique_ptr<tint::Source::File> source_file;
 
diff --git a/src/tint/cmd/main.cc b/src/tint/cmd/main.cc
index 72803b9..18cd971 100644
--- a/src/tint/cmd/main.cc
+++ b/src/tint/cmd/main.cc
@@ -41,6 +41,8 @@
 #include "src/tint/utils/cli/cli.h"
 #include "src/tint/utils/command/command.h"
 #include "src/tint/utils/containers/transform.h"
+#include "src/tint/utils/diagnostic/formatter.h"
+#include "src/tint/utils/diagnostic/printer.h"
 #include "src/tint/utils/macros/defer.h"
 #include "src/tint/utils/text/string.h"
 #include "src/tint/utils/text/string_stream.h"
@@ -809,7 +811,7 @@
         case tint::ast::PipelineStage::kCompute:
             return EShLangCompute;
         default:
-            TINT_ASSERT(AST, false);
+            TINT_UNREACHABLE();
             return EShLangVertex;
     }
 }
@@ -1004,9 +1006,6 @@
         options.format = Format::kSpvAsm;
     }
 
-    auto diag_printer = tint::diag::Printer::create(stderr, true);
-    tint::diag::Formatter diag_formatter;
-
     std::unique_ptr<tint::Program> program;
     std::unique_ptr<tint::Source::File> source_file;
 
@@ -1139,7 +1138,7 @@
     auto out = transform_manager.Run(program.get(), std::move(transform_inputs), outputs);
     if (!out.IsValid()) {
         tint::cmd::PrintWGSL(std::cerr, out);
-        diag_formatter.format(out.Diagnostics(), diag_printer.get());
+        std::cerr << out.Diagnostics().str() << std::endl;
         return 1;
     }
 
diff --git a/src/tint/fuzzers/tint_ast_clone_fuzzer.cc b/src/tint/fuzzers/tint_ast_clone_fuzzer.cc
index e498915..d017032 100644
--- a/src/tint/fuzzers/tint_ast_clone_fuzzer.cc
+++ b/src/tint/fuzzers/tint_ast_clone_fuzzer.cc
@@ -40,9 +40,8 @@
         }                                                                                       \
     } while (false)
 
-[[noreturn]] void TintInternalCompilerErrorReporter(const tint::diag::List& diagnostics) {
-    auto printer = tint::diag::Printer::create(stderr, true);
-    tint::diag::Formatter{}.format(diagnostics, printer.get());
+[[noreturn]] void TintInternalCompilerErrorReporter(const tint::InternalCompilerError& err) {
+    std::cerr << err.Error() << std::endl;
     __builtin_trap();
 }
 
diff --git a/src/tint/fuzzers/tint_ast_fuzzer/expression_size.cc b/src/tint/fuzzers/tint_ast_fuzzer/expression_size.cc
index addbbf5..a01fd67 100644
--- a/src/tint/fuzzers/tint_ast_fuzzer/expression_size.cc
+++ b/src/tint/fuzzers/tint_ast_fuzzer/expression_size.cc
@@ -29,8 +29,7 @@
             continue;
         }
         size_t expr_size = 0;
-        diag::List empty;
-        ast::TraverseExpressions(expr_ast_node, empty, [&](const ast::Expression* expression) {
+        ast::TraverseExpressions(expr_ast_node, [&](const ast::Expression* expression) {
             if (expression == expr_ast_node) {
                 expr_size++;
                 return ast::TraverseAction::Descend;
diff --git a/src/tint/fuzzers/tint_ast_fuzzer/fuzzer.cc b/src/tint/fuzzers/tint_ast_fuzzer/fuzzer.cc
index 8f2946d..01445b3 100644
--- a/src/tint/fuzzers/tint_ast_fuzzer/fuzzer.cc
+++ b/src/tint/fuzzers/tint_ast_fuzzer/fuzzer.cc
@@ -114,9 +114,8 @@
 
         fuzzer.Run(data, size);
         if (fuzzer.HasErrors()) {
-            std::cout << "Fuzzing " << target.name << " produced an error" << std::endl;
-            auto printer = tint::diag::Printer::create(stderr, true);
-            tint::diag::Formatter{}.format(fuzzer.Diagnostics(), printer.get());
+            std::cout << "Fuzzing " << target.name << " produced an error" << std::endl
+                      << fuzzer.Diagnostics().str() << std::endl;
         }
     }
 
diff --git a/src/tint/fuzzers/tint_common_fuzzer.cc b/src/tint/fuzzers/tint_common_fuzzer.cc
index 4bb3261..e4b56e0 100644
--- a/src/tint/fuzzers/tint_common_fuzzer.cc
+++ b/src/tint/fuzzers/tint_common_fuzzer.cc
@@ -37,6 +37,7 @@
 #include "src/tint/lang/wgsl/program/program.h"
 #include "src/tint/lang/wgsl/sem/variable.h"
 #include "src/tint/utils/diagnostic/formatter.h"
+#include "src/tint/utils/diagnostic/printer.h"
 #include "src/tint/utils/math/hash.h"
 #include "tint/binding_point.h"
 
@@ -59,21 +60,22 @@
         __builtin_trap();                                          \
     } while (false)
 
-[[noreturn]] void TintInternalCompilerErrorReporter(const tint::diag::List& diagnostics) {
-    FATAL_ERROR(diagnostics, "");
+[[noreturn]] void TintInternalCompilerErrorReporter(const InternalCompilerError& err) {
+    std::cerr << err.Error() << std::endl;
+    __builtin_trap();
 }
 
 // Wrapping in a macro, so it can be a one-liner in the code, but not
 // introduce another level in the stack trace. This will help with de-duping
 // ClusterFuzz issues.
-#define CHECK_INSPECTOR(program, inspector)                                                    \
-    do {                                                                                       \
-        if ((inspector).has_error()) {                                                         \
-            if (!enforce_validity) {                                                           \
-                return;                                                                        \
-            }                                                                                  \
-            FATAL_ERROR((program)->Diagnostics(), "Inspector failed: " + (inspector).error()); \
-        }                                                                                      \
+#define CHECK_INSPECTOR(program, inspector)                                                  \
+    do {                                                                                     \
+        if ((inspector).has_error()) {                                                       \
+            if (!enforce_validity) {                                                         \
+                return;                                                                      \
+            }                                                                                \
+            FATAL_ERROR(program->Diagnostics(), "Inspector failed: " + (inspector).error()); \
+        }                                                                                    \
     } while (false)
 
 // Wrapping in a macro to make code more readable and help with issue de-duping.
diff --git a/src/tint/fuzzers/tint_concurrency_fuzzer.cc b/src/tint/fuzzers/tint_concurrency_fuzzer.cc
index 24d8e02..0d2d8b0 100644
--- a/src/tint/fuzzers/tint_concurrency_fuzzer.cc
+++ b/src/tint/fuzzers/tint_concurrency_fuzzer.cc
@@ -32,9 +32,8 @@
 
 static constexpr size_t kNumThreads = 8;
 
-[[noreturn]] void TintInternalCompilerErrorReporter(const tint::diag::List& diagnostics) {
-    auto printer = tint::diag::Printer::create(stderr, true);
-    tint::diag::Formatter{}.format(diagnostics, printer.get());
+[[noreturn]] void TintInternalCompilerErrorReporter(const tint::InternalCompilerError& err) {
+    std::cerr << err.Error() << std::endl;
     __builtin_trap();
 }
 
diff --git a/src/tint/fuzzers/tint_ir_roundtrip_fuzzer.cc b/src/tint/fuzzers/tint_ir_roundtrip_fuzzer.cc
index 757b8f4..fa2c0b7 100644
--- a/src/tint/fuzzers/tint_ir_roundtrip_fuzzer.cc
+++ b/src/tint/fuzzers/tint_ir_roundtrip_fuzzer.cc
@@ -22,9 +22,8 @@
 #include "src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.h"
 #include "src/tint/lang/wgsl/writer/writer.h"
 
-[[noreturn]] void TintInternalCompilerErrorReporter(const tint::diag::List& diagnostics) {
-    auto printer = tint::diag::Printer::create(stderr, true);
-    tint::diag::Formatter{}.format(diagnostics, printer.get());
+[[noreturn]] void TintInternalCompilerErrorReporter(const tint::InternalCompilerError& err) {
+    std::cerr << err.Error() << std::endl;
     __builtin_trap();
 }
 
diff --git a/src/tint/lang/core/builtin/number.cc b/src/tint/lang/core/builtin/number.cc
index 980d934..5c48960 100644
--- a/src/tint/lang/core/builtin/number.cc
+++ b/src/tint/lang/core/builtin/number.cc
@@ -18,7 +18,7 @@
 #include <cmath>
 #include <cstring>
 
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/memory/bitcast.h"
 #include "src/tint/utils/text/string_stream.h"
 
@@ -244,14 +244,13 @@
         // Since we ensure that kSmallestValue = 0x1f-14 > abs(value) >= kSmallestSubnormalValue =
         // 0x1f-24, value will have a unbiased exponent in range -24 to -15 (inclusive), and the
         // corresponding biased exponent in f32 is in range 103 to 112 (inclusive).
-        TINT_ASSERT(Semantic,
-                    (kMinF32BiasedExpForF16SubnormalNumber <= biased_exponent_original) &&
-                        (biased_exponent_original <= kMaxF32BiasedExpForF16SubnormalNumber));
+        TINT_ASSERT((kMinF32BiasedExpForF16SubnormalNumber <= biased_exponent_original) &&
+                    (biased_exponent_original <= kMaxF32BiasedExpForF16SubnormalNumber));
 
         // As we have proved, masking out the lowest 126-e mantissa bits of input value will result
         // in a valid subnormal f16 value, which is exactly the required quantization result.
         uint32_t discard_bits = 126 - biased_exponent_original;  // In range 14 to 23 (inclusive)
-        TINT_ASSERT(Semantic, (14 <= discard_bits) && (discard_bits <= kF32MantissaBits));
+        TINT_ASSERT((14 <= discard_bits) && (discard_bits <= kF32MantissaBits));
         uint32_t discard_mask = (1u << discard_bits) - 1;
         u32 = u32 & ~discard_mask;
     } else {
@@ -293,7 +292,7 @@
     uint32_t f32_mantissa = f32_bit_pattern & kF32MantissaMask;
 
     uint16_t f16_sign_part = static_cast<uint16_t>((f32_bit_pattern & kF32SignMask) >> 16);
-    TINT_ASSERT(Semantic, (f16_sign_part & ~kF16SignMask) == 0);
+    TINT_ASSERT((f16_sign_part & ~kF16SignMask) == 0);
 
     if ((f32_bit_pattern & ~kF32SignMask) == 0) {
         // +/- zero
@@ -308,8 +307,8 @@
         uint16_t f16_mantissa_part =
             static_cast<uint16_t>(f32_mantissa >> (kF32MantissaBits - kF16MantissaBits));
 
-        TINT_ASSERT(Semantic, (f16_exp_part & ~kF16ExponentMask) == 0);
-        TINT_ASSERT(Semantic, (f16_mantissa_part & ~kF16MantissaMask) == 0);
+        TINT_ASSERT((f16_exp_part & ~kF16ExponentMask) == 0);
+        TINT_ASSERT((f16_mantissa_part & ~kF16MantissaMask) == 0);
 
         return f16_sign_part | f16_exp_part | f16_mantissa_part;
     }
@@ -330,17 +329,16 @@
             static_cast<uint16_t>((f32_mantissa | (kF32MantissaMask + 1)) >>
                                   (kF32MantissaBits + 1 - f16_valid_mantissa_bits));
 
-        TINT_ASSERT(Semantic, (1 <= f16_valid_mantissa_bits) &&
-                                  (f16_valid_mantissa_bits <= kF16MantissaBits));
-        TINT_ASSERT(Semantic, (f16_mantissa_part & ~((1u << f16_valid_mantissa_bits) - 1)) == 0);
-        TINT_ASSERT(Semantic, (f16_mantissa_part != 0));
+        TINT_ASSERT((1 <= f16_valid_mantissa_bits) &&
+                    (f16_valid_mantissa_bits <= kF16MantissaBits));
+        TINT_ASSERT((f16_mantissa_part & ~((1u << f16_valid_mantissa_bits) - 1)) == 0);
+        TINT_ASSERT((f16_mantissa_part != 0));
 
         return f16_sign_part | f16_exp_part | f16_mantissa_part;
     }
 
     // Neither zero, subnormal f16 or normal f16, shall never hit.
-    tint::diag::List diag;
-    TINT_UNREACHABLE(Semantic, diag);
+    TINT_UNREACHABLE();
     return kF16Nan;
 }
 
diff --git a/src/tint/lang/core/constant/composite.cc b/src/tint/lang/core/constant/composite.cc
index c1a4dce..735f6b3 100644
--- a/src/tint/lang/core/constant/composite.cc
+++ b/src/tint/lang/core/constant/composite.cc
@@ -27,7 +27,7 @@
                      bool all_0,
                      bool any_0)
     : type(t), elements(std::move(els)), all_zero(all_0), any_zero(any_0), hash(CalcHash()) {
-    TINT_ASSERT(Constant, !elements.IsEmpty());
+    TINT_ASSERT(!elements.IsEmpty());
 }
 
 Composite::~Composite() = default;
diff --git a/src/tint/lang/core/constant/scalar.h b/src/tint/lang/core/constant/scalar.h
index 59ca5d0..4ae023d 100644
--- a/src/tint/lang/core/constant/scalar.h
+++ b/src/tint/lang/core/constant/scalar.h
@@ -43,7 +43,7 @@
     /// @param v the scalar value
     Scalar(const type::Type* t, T v) : type(t), value(v) {
         if constexpr (IsFloatingPoint<T>) {
-            TINT_ASSERT(Constant, std::isfinite(v.value));
+            TINT_ASSERT(std::isfinite(v.value));
         }
     }
     ~Scalar() override = default;
diff --git a/src/tint/lang/core/constant/value.cc b/src/tint/lang/core/constant/value.cc
index ac1954f..6578da3 100644
--- a/src/tint/lang/core/constant/value.cc
+++ b/src/tint/lang/core/constant/value.cc
@@ -96,8 +96,8 @@
         [&](Default) {
             auto va = InternalValue();
             auto vb = b->InternalValue();
-            TINT_ASSERT(Resolver, !std::holds_alternative<std::monostate>(va));
-            TINT_ASSERT(Resolver, !std::holds_alternative<std::monostate>(vb));
+            TINT_ASSERT(!std::holds_alternative<std::monostate>(va));
+            TINT_ASSERT(!std::holds_alternative<std::monostate>(vb));
             return va == vb;
         });
 }
diff --git a/src/tint/lang/core/ir/access.cc b/src/tint/lang/core/ir/access.cc
index 9d73b98..15e567e 100644
--- a/src/tint/lang/core/ir/access.cc
+++ b/src/tint/lang/core/ir/access.cc
@@ -16,8 +16,6 @@
 
 #include <utility>
 
-#include "src/tint/utils/debug/debug.h"
-
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Access);
 
 namespace tint::ir {
diff --git a/src/tint/lang/core/ir/binary.cc b/src/tint/lang/core/ir/binary.cc
index 2669a6f..f64b626 100644
--- a/src/tint/lang/core/ir/binary.cc
+++ b/src/tint/lang/core/ir/binary.cc
@@ -13,7 +13,6 @@
 // limitations under the License.
 
 #include "src/tint/lang/core/ir/binary.h"
-#include "src/tint/utils/debug/debug.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Binary);
 
diff --git a/src/tint/lang/core/ir/bitcast.cc b/src/tint/lang/core/ir/bitcast.cc
index 2fbb073..6efa962 100644
--- a/src/tint/lang/core/ir/bitcast.cc
+++ b/src/tint/lang/core/ir/bitcast.cc
@@ -13,7 +13,6 @@
 // limitations under the License.
 
 #include "src/tint/lang/core/ir/bitcast.h"
-#include "src/tint/utils/debug/debug.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Bitcast);
 
diff --git a/src/tint/lang/core/ir/block.cc b/src/tint/lang/core/ir/block.cc
index 1d4fb31..a7bc38f 100644
--- a/src/tint/lang/core/ir/block.cc
+++ b/src/tint/lang/core/ir/block.cc
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "src/tint/lang/core/ir/block.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Block);
 
@@ -23,8 +24,8 @@
 Block::~Block() = default;
 
 Instruction* Block::Prepend(Instruction* inst) {
-    TINT_ASSERT_OR_RETURN_VALUE(IR, inst, inst);
-    TINT_ASSERT_OR_RETURN_VALUE(IR, inst->Block() == nullptr, inst);
+    TINT_ASSERT_OR_RETURN_VALUE(inst, inst);
+    TINT_ASSERT_OR_RETURN_VALUE(inst->Block() == nullptr, inst);
 
     inst->SetBlock(this);
     instructions_.count += 1;
@@ -42,8 +43,8 @@
 }
 
 Instruction* Block::Append(Instruction* inst) {
-    TINT_ASSERT_OR_RETURN_VALUE(IR, inst, inst);
-    TINT_ASSERT_OR_RETURN_VALUE(IR, inst->Block() == nullptr, inst);
+    TINT_ASSERT_OR_RETURN_VALUE(inst, inst);
+    TINT_ASSERT_OR_RETURN_VALUE(inst->Block() == nullptr, inst);
 
     inst->SetBlock(this);
     instructions_.count += 1;
@@ -61,10 +62,10 @@
 }
 
 void Block::InsertBefore(Instruction* before, Instruction* inst) {
-    TINT_ASSERT_OR_RETURN(IR, before);
-    TINT_ASSERT_OR_RETURN(IR, inst);
-    TINT_ASSERT_OR_RETURN(IR, before->Block() == this);
-    TINT_ASSERT_OR_RETURN(IR, inst->Block() == nullptr);
+    TINT_ASSERT_OR_RETURN(before);
+    TINT_ASSERT_OR_RETURN(inst);
+    TINT_ASSERT_OR_RETURN(before->Block() == this);
+    TINT_ASSERT_OR_RETURN(inst->Block() == nullptr);
 
     inst->SetBlock(this);
     instructions_.count += 1;
@@ -83,10 +84,10 @@
 }
 
 void Block::InsertAfter(Instruction* after, Instruction* inst) {
-    TINT_ASSERT_OR_RETURN(IR, after);
-    TINT_ASSERT_OR_RETURN(IR, inst);
-    TINT_ASSERT_OR_RETURN(IR, after->Block() == this);
-    TINT_ASSERT_OR_RETURN(IR, inst->Block() == nullptr);
+    TINT_ASSERT_OR_RETURN(after);
+    TINT_ASSERT_OR_RETURN(inst);
+    TINT_ASSERT_OR_RETURN(after->Block() == this);
+    TINT_ASSERT_OR_RETURN(inst->Block() == nullptr);
 
     inst->SetBlock(this);
     instructions_.count += 1;
@@ -104,10 +105,10 @@
 }
 
 void Block::Replace(Instruction* target, Instruction* inst) {
-    TINT_ASSERT_OR_RETURN(IR, target);
-    TINT_ASSERT_OR_RETURN(IR, inst);
-    TINT_ASSERT_OR_RETURN(IR, target->Block() == this);
-    TINT_ASSERT_OR_RETURN(IR, inst->Block() == nullptr);
+    TINT_ASSERT_OR_RETURN(target);
+    TINT_ASSERT_OR_RETURN(inst);
+    TINT_ASSERT_OR_RETURN(target->Block() == this);
+    TINT_ASSERT_OR_RETURN(inst->Block() == nullptr);
 
     inst->SetBlock(this);
     target->SetBlock(nullptr);
@@ -134,8 +135,8 @@
 }
 
 void Block::Remove(Instruction* inst) {
-    TINT_ASSERT_OR_RETURN(IR, inst);
-    TINT_ASSERT_OR_RETURN(IR, inst->Block() == this);
+    TINT_ASSERT_OR_RETURN(inst);
+    TINT_ASSERT_OR_RETURN(inst->Block() == this);
 
     inst->SetBlock(nullptr);
     instructions_.count -= 1;
diff --git a/src/tint/lang/core/ir/block_param.cc b/src/tint/lang/core/ir/block_param.cc
index d6c4cd6..46a4070 100644
--- a/src/tint/lang/core/ir/block_param.cc
+++ b/src/tint/lang/core/ir/block_param.cc
@@ -13,13 +13,14 @@
 // limitations under the License.
 
 #include "src/tint/lang/core/ir/block_param.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::BlockParam);
 
 namespace tint::ir {
 
 BlockParam::BlockParam(const type::Type* ty) : type_(ty) {
-    TINT_ASSERT(IR, type_ != nullptr);
+    TINT_ASSERT(type_ != nullptr);
 }
 
 BlockParam::~BlockParam() = default;
diff --git a/src/tint/lang/core/ir/break_if.cc b/src/tint/lang/core/ir/break_if.cc
index 15cd0f2..5ca3b93 100644
--- a/src/tint/lang/core/ir/break_if.cc
+++ b/src/tint/lang/core/ir/break_if.cc
@@ -19,13 +19,14 @@
 #include "src/tint/lang/core/ir/block.h"
 #include "src/tint/lang/core/ir/loop.h"
 #include "src/tint/lang/core/ir/multi_in_block.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::BreakIf);
 
 namespace tint::ir {
 
 BreakIf::BreakIf(Value* condition, ir::Loop* loop, VectorRef<Value*> args) : loop_(loop) {
-    TINT_ASSERT(IR, loop_);
+    TINT_ASSERT(loop_);
 
     AddOperand(BreakIf::kConditionOperandOffset, condition);
     AddOperands(BreakIf::kArgsOperandOffset, std::move(args));
diff --git a/src/tint/lang/core/ir/builder.cc b/src/tint/lang/core/ir/builder.cc
index 060a732..d611b12 100644
--- a/src/tint/lang/core/ir/builder.cc
+++ b/src/tint/lang/core/ir/builder.cc
@@ -19,6 +19,7 @@
 #include "src/tint/lang/core/constant/scalar.h"
 #include "src/tint/lang/core/type/pointer.h"
 #include "src/tint/lang/core/type/reference.h"
+#include "src/tint/utils/ice/ice.h"
 
 namespace tint::ir {
 
@@ -107,10 +108,10 @@
 
 const type::Type* Builder::VectorPtrElementType(const type::Type* type) {
     auto* vec_ptr_ty = type->As<type::Pointer>();
-    TINT_ASSERT(IR, vec_ptr_ty);
+    TINT_ASSERT(vec_ptr_ty);
     if (TINT_LIKELY(vec_ptr_ty)) {
         auto* vec_ty = vec_ptr_ty->StoreType()->As<type::Vector>();
-        TINT_ASSERT(IR, vec_ty);
+        TINT_ASSERT(vec_ty);
         if (TINT_LIKELY(vec_ty)) {
             return vec_ty->type();
         }
diff --git a/src/tint/lang/core/ir/builder.h b/src/tint/lang/core/ir/builder.h
index 8f5bfd6..479398e 100644
--- a/src/tint/lang/core/ir/builder.h
+++ b/src/tint/lang/core/ir/builder.h
@@ -65,6 +65,7 @@
 #include "src/tint/lang/core/type/u32.h"
 #include "src/tint/lang/core/type/vector.h"
 #include "src/tint/lang/core/type/void.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/macros/scoped_assignment.h"
 #include "src/tint/utils/rtti/switch.h"
 
@@ -265,7 +266,7 @@
                 return in;  /// Pass-through
             } else if constexpr (is_instruction) {
                 /// Extract the first result from the instruction
-                TINT_ASSERT(IR, in->HasResults() && !in->HasMultiResults());
+                TINT_ASSERT(in->HasResults() && !in->HasMultiResults());
                 return in->Result();
             }
         } else if constexpr (is_numeric) {
@@ -664,7 +665,7 @@
     ir::Let* Let(std::string_view name, VALUE&& value) {
         auto* val = Value(std::forward<VALUE>(value));
         if (TINT_UNLIKELY(!val)) {
-            TINT_ASSERT(IR, val);
+            TINT_ASSERT(val);
             return nullptr;
         }
         auto* let = Append(ir.instructions.Create<ir::Let>(InstructionResult(val->Type()), val));
diff --git a/src/tint/lang/core/ir/builtin_call.cc b/src/tint/lang/core/ir/builtin_call.cc
index d754f5a..da086cb 100644
--- a/src/tint/lang/core/ir/builtin_call.cc
+++ b/src/tint/lang/core/ir/builtin_call.cc
@@ -16,8 +16,6 @@
 
 #include <utility>
 
-#include "src/tint/utils/debug/debug.h"
-
 TINT_INSTANTIATE_TYPEINFO(tint::ir::BuiltinCall);
 
 namespace tint::ir {
diff --git a/src/tint/lang/core/ir/constant.cc b/src/tint/lang/core/ir/constant.cc
index cf09c50..a161e4d 100644
--- a/src/tint/lang/core/ir/constant.cc
+++ b/src/tint/lang/core/ir/constant.cc
@@ -13,13 +13,14 @@
 // limitations under the License.
 
 #include "src/tint/lang/core/ir/constant.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Constant);
 
 namespace tint::ir {
 
 Constant::Constant(const constant::Value* val) : value_(val) {
-    TINT_ASSERT(IR, value_);
+    TINT_ASSERT(value_);
 }
 
 Constant::~Constant() = default;
diff --git a/src/tint/lang/core/ir/construct.cc b/src/tint/lang/core/ir/construct.cc
index 8912359..bbbff97 100644
--- a/src/tint/lang/core/ir/construct.cc
+++ b/src/tint/lang/core/ir/construct.cc
@@ -16,8 +16,6 @@
 
 #include <utility>
 
-#include "src/tint/utils/debug/debug.h"
-
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Construct);
 
 namespace tint::ir {
diff --git a/src/tint/lang/core/ir/continue.cc b/src/tint/lang/core/ir/continue.cc
index ce2c9d0..206b045 100644
--- a/src/tint/lang/core/ir/continue.cc
+++ b/src/tint/lang/core/ir/continue.cc
@@ -19,13 +19,14 @@
 #include "src/tint/lang/core/ir/block.h"
 #include "src/tint/lang/core/ir/loop.h"
 #include "src/tint/lang/core/ir/multi_in_block.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Continue);
 
 namespace tint::ir {
 
 Continue::Continue(ir::Loop* loop, VectorRef<Value*> args) : loop_(loop) {
-    TINT_ASSERT(IR, loop_);
+    TINT_ASSERT(loop_);
 
     AddOperands(Continue::kArgsOperandOffset, std::move(args));
 
diff --git a/src/tint/lang/core/ir/convert.cc b/src/tint/lang/core/ir/convert.cc
index 00ba18f..ac55ec5 100644
--- a/src/tint/lang/core/ir/convert.cc
+++ b/src/tint/lang/core/ir/convert.cc
@@ -16,8 +16,6 @@
 
 #include <utility>
 
-#include "src/tint/utils/debug/debug.h"
-
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Convert);
 
 namespace tint::ir {
diff --git a/src/tint/lang/core/ir/core_builtin_call.cc b/src/tint/lang/core/ir/core_builtin_call.cc
index a75c5bc..0f4e45a 100644
--- a/src/tint/lang/core/ir/core_builtin_call.cc
+++ b/src/tint/lang/core/ir/core_builtin_call.cc
@@ -16,7 +16,7 @@
 
 #include <utility>
 
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::CoreBuiltinCall);
 
@@ -26,8 +26,8 @@
                                  builtin::Function func,
                                  VectorRef<Value*> arguments)
     : Base(result, arguments), func_(func) {
-    TINT_ASSERT(IR, func != builtin::Function::kNone);
-    TINT_ASSERT(IR, func != builtin::Function::kTintMaterialize);
+    TINT_ASSERT(func != builtin::Function::kNone);
+    TINT_ASSERT(func != builtin::Function::kTintMaterialize);
 }
 
 CoreBuiltinCall::~CoreBuiltinCall() = default;
diff --git a/src/tint/lang/core/ir/disassembler.cc b/src/tint/lang/core/ir/disassembler.cc
index 2c06f15..fedf684 100644
--- a/src/tint/lang/core/ir/disassembler.cc
+++ b/src/tint/lang/core/ir/disassembler.cc
@@ -52,6 +52,7 @@
 #include "src/tint/lang/core/ir/var.h"
 #include "src/tint/lang/core/type/struct.h"
 #include "src/tint/lang/core/type/type.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/macros/scoped_assignment.h"
 #include "src/tint/utils/rtti/switch.h"
 #include "src/tint/utils/text/string.h"
@@ -89,12 +90,12 @@
 }
 
 size_t Disassembler::IdOf(Block* node) {
-    TINT_ASSERT(IR, node);
+    TINT_ASSERT(node);
     return block_ids_.GetOrCreate(node, [&] { return block_ids_.Count(); });
 }
 
 std::string Disassembler::IdOf(Value* value) {
-    TINT_ASSERT(IR, value);
+    TINT_ASSERT(value);
     return value_ids_.GetOrCreate(value, [&] {
         if (auto sym = mod_.NameOf(value)) {
             if (ids_.Add(sym.Name())) {
diff --git a/src/tint/lang/core/ir/discard.cc b/src/tint/lang/core/ir/discard.cc
index c0220e1..27b1a1e 100644
--- a/src/tint/lang/core/ir/discard.cc
+++ b/src/tint/lang/core/ir/discard.cc
@@ -14,7 +14,6 @@
 
 #include "src/tint/lang/core/ir/discard.h"
 #include "src/tint/lang/core/type/void.h"
-#include "src/tint/utils/debug/debug.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Discard);
 
diff --git a/src/tint/lang/core/ir/discard.h b/src/tint/lang/core/ir/discard.h
index 5d9b4e8..9ae20d8 100644
--- a/src/tint/lang/core/ir/discard.h
+++ b/src/tint/lang/core/ir/discard.h
@@ -16,7 +16,7 @@
 #define SRC_TINT_LANG_CORE_IR_DISCARD_H_
 
 #include "src/tint/lang/core/ir/call.h"
-#include "src/tint/utils/debug/debug.h"
+
 #include "src/tint/utils/rtti/castable.h"
 
 namespace tint::ir {
diff --git a/src/tint/lang/core/ir/function.cc b/src/tint/lang/core/ir/function.cc
index 98754b8..408daf8 100644
--- a/src/tint/lang/core/ir/function.cc
+++ b/src/tint/lang/core/ir/function.cc
@@ -15,6 +15,7 @@
 #include "src/tint/lang/core/ir/function.h"
 
 #include "src/tint/utils/containers/predicates.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Function);
 
@@ -24,7 +25,7 @@
                    PipelineStage stage,
                    std::optional<std::array<uint32_t, 3>> wg_size)
     : pipeline_stage_(stage), workgroup_size_(wg_size) {
-    TINT_ASSERT(IR, rt != nullptr);
+    TINT_ASSERT(rt != nullptr);
 
     return_.type = rt;
 }
@@ -33,12 +34,12 @@
 
 void Function::SetParams(VectorRef<FunctionParam*> params) {
     params_ = std::move(params);
-    TINT_ASSERT(IR, !params_.Any(tint::IsNull));
+    TINT_ASSERT(!params_.Any(IsNull));
 }
 
 void Function::SetParams(std::initializer_list<FunctionParam*> params) {
     params_ = params;
-    TINT_ASSERT(IR, !params_.Any(tint::IsNull));
+    TINT_ASSERT(!params_.Any(IsNull));
 }
 
 StringStream& operator<<(StringStream& out, Function::PipelineStage value) {
diff --git a/src/tint/lang/core/ir/function.h b/src/tint/lang/core/ir/function.h
index 143efe0..660440f 100644
--- a/src/tint/lang/core/ir/function.h
+++ b/src/tint/lang/core/ir/function.h
@@ -23,6 +23,7 @@
 #include "src/tint/lang/core/ir/location.h"
 #include "src/tint/lang/core/ir/value.h"
 #include "src/tint/lang/core/type/type.h"
+#include "src/tint/utils/ice/ice.h"
 
 // Forward declarations
 namespace tint::ir {
@@ -91,7 +92,7 @@
     /// Sets the return attributes
     /// @param builtin the builtin to set
     void SetReturnBuiltin(ReturnBuiltin builtin) {
-        TINT_ASSERT(IR, !return_.builtin.has_value());
+        TINT_ASSERT(!return_.builtin.has_value());
         return_.builtin = builtin;
     }
     /// @returns the return builtin attribute
@@ -130,7 +131,7 @@
     /// Sets the root block for the function
     /// @param target the root block
     void SetBlock(Block* target) {
-        TINT_ASSERT(IR, target != nullptr);
+        TINT_ASSERT(target != nullptr);
         block_ = target;
     }
     /// @returns the function root block
diff --git a/src/tint/lang/core/ir/function_param.cc b/src/tint/lang/core/ir/function_param.cc
index 492522e..1dc8930 100644
--- a/src/tint/lang/core/ir/function_param.cc
+++ b/src/tint/lang/core/ir/function_param.cc
@@ -14,12 +14,14 @@
 
 #include "src/tint/lang/core/ir/function_param.h"
 
+#include "src/tint/utils/ice/ice.h"
+
 TINT_INSTANTIATE_TYPEINFO(tint::ir::FunctionParam);
 
 namespace tint::ir {
 
 FunctionParam::FunctionParam(const type::Type* ty) : type_(ty) {
-    TINT_ASSERT(IR, ty != nullptr);
+    TINT_ASSERT(ty != nullptr);
 }
 
 FunctionParam::~FunctionParam() = default;
diff --git a/src/tint/lang/core/ir/function_param.h b/src/tint/lang/core/ir/function_param.h
index e4edabc..44ad9a5 100644
--- a/src/tint/lang/core/ir/function_param.h
+++ b/src/tint/lang/core/ir/function_param.h
@@ -21,6 +21,7 @@
 #include "src/tint/lang/core/ir/location.h"
 #include "src/tint/lang/core/ir/value.h"
 #include "src/tint/utils/containers/vector.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/rtti/castable.h"
 
 namespace tint::ir {
@@ -65,7 +66,7 @@
     /// Sets the builtin information. Note, it is currently an error if the builtin is already set.
     /// @param val the builtin to set
     void SetBuiltin(FunctionParam::Builtin val) {
-        TINT_ASSERT(IR, !builtin_.has_value());
+        TINT_ASSERT(!builtin_.has_value());
         builtin_ = val;
     }
     /// @returns the builtin set for the parameter
diff --git a/src/tint/lang/core/ir/if.cc b/src/tint/lang/core/ir/if.cc
index e080712..372039f 100644
--- a/src/tint/lang/core/ir/if.cc
+++ b/src/tint/lang/core/ir/if.cc
@@ -17,12 +17,13 @@
 TINT_INSTANTIATE_TYPEINFO(tint::ir::If);
 
 #include "src/tint/lang/core/ir/multi_in_block.h"
+#include "src/tint/utils/ice/ice.h"
 
 namespace tint::ir {
 
 If::If(Value* cond, ir::Block* t, ir::Block* f) : true_(t), false_(f) {
-    TINT_ASSERT(IR, true_);
-    TINT_ASSERT(IR, false_);
+    TINT_ASSERT(true_);
+    TINT_ASSERT(false_);
 
     AddOperand(If::kConditionOperandOffset, cond);
 
diff --git a/src/tint/lang/core/ir/instruction.cc b/src/tint/lang/core/ir/instruction.cc
index 85e8aa7..feb7a58 100644
--- a/src/tint/lang/core/ir/instruction.cc
+++ b/src/tint/lang/core/ir/instruction.cc
@@ -15,7 +15,7 @@
 #include "src/tint/lang/core/ir/instruction.h"
 
 #include "src/tint/lang/core/ir/block.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Instruction);
 
@@ -26,7 +26,7 @@
 Instruction::~Instruction() = default;
 
 void Instruction::Destroy() {
-    TINT_ASSERT(IR, Alive());
+    TINT_ASSERT(Alive());
     if (Block()) {
         Remove();
     }
@@ -38,25 +38,25 @@
 }
 
 void Instruction::InsertBefore(Instruction* before) {
-    TINT_ASSERT_OR_RETURN(IR, before);
-    TINT_ASSERT_OR_RETURN(IR, before->Block() != nullptr);
+    TINT_ASSERT_OR_RETURN(before);
+    TINT_ASSERT_OR_RETURN(before->Block() != nullptr);
     before->Block()->InsertBefore(before, this);
 }
 
 void Instruction::InsertAfter(Instruction* after) {
-    TINT_ASSERT_OR_RETURN(IR, after);
-    TINT_ASSERT_OR_RETURN(IR, after->Block() != nullptr);
+    TINT_ASSERT_OR_RETURN(after);
+    TINT_ASSERT_OR_RETURN(after->Block() != nullptr);
     after->Block()->InsertAfter(after, this);
 }
 
 void Instruction::ReplaceWith(Instruction* replacement) {
-    TINT_ASSERT_OR_RETURN(IR, replacement);
-    TINT_ASSERT_OR_RETURN(IR, Block() != nullptr);
+    TINT_ASSERT_OR_RETURN(replacement);
+    TINT_ASSERT_OR_RETURN(Block() != nullptr);
     Block()->Replace(this, replacement);
 }
 
 void Instruction::Remove() {
-    TINT_ASSERT_OR_RETURN(IR, Block() != nullptr);
+    TINT_ASSERT_OR_RETURN(Block() != nullptr);
     Block()->Remove(this);
 }
 
diff --git a/src/tint/lang/core/ir/instruction_result.cc b/src/tint/lang/core/ir/instruction_result.cc
index 20a4674..300eca3 100644
--- a/src/tint/lang/core/ir/instruction_result.cc
+++ b/src/tint/lang/core/ir/instruction_result.cc
@@ -16,19 +16,20 @@
 
 #include "src/tint/lang/core/ir/constant.h"
 #include "src/tint/lang/core/ir/instruction.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::InstructionResult);
 
 namespace tint::ir {
 
 InstructionResult::InstructionResult(const type::Type* type) : type_(type) {
-    TINT_ASSERT(IR, type_ != nullptr);
+    TINT_ASSERT(type_ != nullptr);
 }
 
 InstructionResult::~InstructionResult() = default;
 
 void InstructionResult::Destroy() {
-    TINT_ASSERT(IR, source_ == nullptr);
+    TINT_ASSERT(source_ == nullptr);
     Base::Destroy();
 }
 
diff --git a/src/tint/lang/core/ir/intrinsic_call.cc b/src/tint/lang/core/ir/intrinsic_call.cc
index ee52c23..5ab9663 100644
--- a/src/tint/lang/core/ir/intrinsic_call.cc
+++ b/src/tint/lang/core/ir/intrinsic_call.cc
@@ -16,8 +16,6 @@
 
 #include <utility>
 
-#include "src/tint/utils/debug/debug.h"
-
 TINT_INSTANTIATE_TYPEINFO(tint::ir::IntrinsicCall);
 
 namespace tint::ir {
diff --git a/src/tint/lang/core/ir/let.cc b/src/tint/lang/core/ir/let.cc
index b489fc1..7309786 100644
--- a/src/tint/lang/core/ir/let.cc
+++ b/src/tint/lang/core/ir/let.cc
@@ -14,7 +14,6 @@
 
 #include "src/tint/lang/core/ir/let.h"
 #include "src/tint/lang/core/ir/store.h"
-#include "src/tint/utils/debug/debug.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Let);
 
diff --git a/src/tint/lang/core/ir/load.cc b/src/tint/lang/core/ir/load.cc
index 00a03f5..3ed33f1 100644
--- a/src/tint/lang/core/ir/load.cc
+++ b/src/tint/lang/core/ir/load.cc
@@ -15,7 +15,7 @@
 #include "src/tint/lang/core/ir/load.h"
 
 #include "src/tint/lang/core/type/pointer.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Load);
 
@@ -24,8 +24,8 @@
 Load::Load(InstructionResult* result, Value* from) {
     flags_.Add(Flag::kSequenced);
 
-    TINT_ASSERT(IR, from->Type()->Is<type::Pointer>());
-    TINT_ASSERT(IR, from && from->Type()->UnwrapPtr() == result->Type());
+    TINT_ASSERT(from->Type()->Is<type::Pointer>());
+    TINT_ASSERT(from && from->Type()->UnwrapPtr() == result->Type());
 
     AddOperand(Load::kFromOperandOffset, from);
     AddResult(result);
diff --git a/src/tint/lang/core/ir/load_vector_element.cc b/src/tint/lang/core/ir/load_vector_element.cc
index aad4f47..eb1669e 100644
--- a/src/tint/lang/core/ir/load_vector_element.cc
+++ b/src/tint/lang/core/ir/load_vector_element.cc
@@ -13,7 +13,6 @@
 // limitations under the License.
 
 #include "src/tint/lang/core/ir/load_vector_element.h"
-#include "src/tint/utils/debug/debug.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::LoadVectorElement);
 
diff --git a/src/tint/lang/core/ir/loop.cc b/src/tint/lang/core/ir/loop.cc
index 81d9def..001a270 100644
--- a/src/tint/lang/core/ir/loop.cc
+++ b/src/tint/lang/core/ir/loop.cc
@@ -17,6 +17,7 @@
 #include <utility>
 
 #include "src/tint/lang/core/ir/multi_in_block.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Loop);
 
@@ -24,9 +25,9 @@
 
 Loop::Loop(ir::Block* i, ir::MultiInBlock* b, ir::MultiInBlock* c)
     : initializer_(i), body_(b), continuing_(c) {
-    TINT_ASSERT(IR, initializer_);
-    TINT_ASSERT(IR, body_);
-    TINT_ASSERT(IR, continuing_);
+    TINT_ASSERT(initializer_);
+    TINT_ASSERT(body_);
+    TINT_ASSERT(continuing_);
 
     if (initializer_) {
         initializer_->SetParent(this);
diff --git a/src/tint/lang/core/ir/module.cc b/src/tint/lang/core/ir/module.cc
index 0c5da05..c7bc576 100644
--- a/src/tint/lang/core/ir/module.cc
+++ b/src/tint/lang/core/ir/module.cc
@@ -16,6 +16,8 @@
 
 #include <limits>
 
+#include "src/tint/utils/ice/ice.h"
+
 namespace tint::ir {
 
 Module::Module() = default;
@@ -27,7 +29,7 @@
 Module& Module::operator=(Module&&) = default;
 
 Symbol Module::NameOf(Instruction* inst) {
-    TINT_ASSERT(IR, inst->HasResults() && !inst->HasMultiResults());
+    TINT_ASSERT(inst->HasResults() && !inst->HasMultiResults());
     return NameOf(inst->Result());
 }
 
@@ -36,17 +38,17 @@
 }
 
 void Module::SetName(Instruction* inst, std::string_view name) {
-    TINT_ASSERT(IR, inst->HasResults() && !inst->HasMultiResults());
+    TINT_ASSERT(inst->HasResults() && !inst->HasMultiResults());
     return SetName(inst->Result(), name);
 }
 
 void Module::SetName(Value* value, std::string_view name) {
-    TINT_ASSERT(IR, !name.empty());
+    TINT_ASSERT(!name.empty());
     value_to_name_.Replace(value, symbols.Register(name));
 }
 
 void Module::SetName(Value* value, Symbol name) {
-    TINT_ASSERT(IR, name.IsValid());
+    TINT_ASSERT(name.IsValid());
     value_to_name_.Replace(value, name);
 }
 
diff --git a/src/tint/lang/core/ir/module.h b/src/tint/lang/core/ir/module.h
index df39ff9..1ae271e 100644
--- a/src/tint/lang/core/ir/module.h
+++ b/src/tint/lang/core/ir/module.h
@@ -26,6 +26,7 @@
 #include "src/tint/lang/core/ir/value.h"
 #include "src/tint/lang/core/type/manager.h"
 #include "src/tint/utils/containers/vector.h"
+#include "src/tint/utils/diagnostic/source.h"
 #include "src/tint/utils/generation_id.h"
 #include "src/tint/utils/memory/block_allocator.h"
 #include "src/tint/utils/result/result.h"
diff --git a/src/tint/lang/core/ir/multi_in_block.cc b/src/tint/lang/core/ir/multi_in_block.cc
index 615876c..3753feb 100644
--- a/src/tint/lang/core/ir/multi_in_block.cc
+++ b/src/tint/lang/core/ir/multi_in_block.cc
@@ -15,6 +15,7 @@
 #include "src/tint/lang/core/ir/multi_in_block.h"
 
 #include "src/tint/utils/containers/predicates.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::MultiInBlock);
 
@@ -33,7 +34,7 @@
 }
 
 void MultiInBlock::AddInboundSiblingBranch(ir::Terminator* node) {
-    TINT_ASSERT(IR, node != nullptr);
+    TINT_ASSERT(node != nullptr);
 
     if (node) {
         inbound_sibling_branches_.Push(node);
diff --git a/src/tint/lang/core/ir/next_iteration.cc b/src/tint/lang/core/ir/next_iteration.cc
index 797cd0c..a7d9faf 100644
--- a/src/tint/lang/core/ir/next_iteration.cc
+++ b/src/tint/lang/core/ir/next_iteration.cc
@@ -18,6 +18,7 @@
 
 #include "src/tint/lang/core/ir/loop.h"
 #include "src/tint/lang/core/ir/multi_in_block.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::NextIteration);
 
@@ -25,7 +26,7 @@
 
 NextIteration::NextIteration(ir::Loop* loop, VectorRef<Value*> args /* = tint::Empty */)
     : loop_(loop) {
-    TINT_ASSERT(IR, loop_);
+    TINT_ASSERT(loop_);
 
     AddOperands(NextIteration::kArgsOperandOffset, std::move(args));
 
diff --git a/src/tint/lang/core/ir/operand_instruction.h b/src/tint/lang/core/ir/operand_instruction.h
index d6fd4bb..abc81e3 100644
--- a/src/tint/lang/core/ir/operand_instruction.h
+++ b/src/tint/lang/core/ir/operand_instruction.h
@@ -19,6 +19,7 @@
 
 #include "src/tint/lang/core/ir/instruction.h"
 #include "src/tint/lang/core/ir/instruction_result.h"
+#include "src/tint/utils/ice/ice.h"
 
 namespace tint::ir {
 
@@ -41,7 +42,7 @@
     /// @param index the operand index
     /// @param value the value to use
     void SetOperand(size_t index, ir::Value* value) override {
-        TINT_ASSERT(IR, index < operands_.Length());
+        TINT_ASSERT(index < operands_.Length());
         if (operands_[index]) {
             operands_[index]->RemoveUsage({this, index});
         }
@@ -101,7 +102,7 @@
     /// @param idx the index the operand should be at
     /// @param value the operand value to append
     void AddOperand(size_t idx, ir::Value* value) {
-        TINT_ASSERT(IR, idx == operands_.Length());
+        TINT_ASSERT(idx == operands_.Length());
 
         if (value) {
             value->AddUsage({this, static_cast<uint32_t>(operands_.Length())});
diff --git a/src/tint/lang/core/ir/store.cc b/src/tint/lang/core/ir/store.cc
index e4f7ce2..648e9f2 100644
--- a/src/tint/lang/core/ir/store.cc
+++ b/src/tint/lang/core/ir/store.cc
@@ -13,7 +13,6 @@
 // limitations under the License.
 
 #include "src/tint/lang/core/ir/store.h"
-#include "src/tint/utils/debug/debug.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Store);
 
diff --git a/src/tint/lang/core/ir/store_vector_element.cc b/src/tint/lang/core/ir/store_vector_element.cc
index 5cbb108..219ded3 100644
--- a/src/tint/lang/core/ir/store_vector_element.cc
+++ b/src/tint/lang/core/ir/store_vector_element.cc
@@ -13,7 +13,6 @@
 // limitations under the License.
 
 #include "src/tint/lang/core/ir/store_vector_element.h"
-#include "src/tint/utils/debug/debug.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::StoreVectorElement);
 
diff --git a/src/tint/lang/core/ir/switch.cc b/src/tint/lang/core/ir/switch.cc
index 4f1c5b2..bda068f 100644
--- a/src/tint/lang/core/ir/switch.cc
+++ b/src/tint/lang/core/ir/switch.cc
@@ -14,12 +14,14 @@
 
 #include "src/tint/lang/core/ir/switch.h"
 
+#include "src/tint/utils/ice/ice.h"
+
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Switch);
 
 namespace tint::ir {
 
 Switch::Switch(Value* cond) {
-    TINT_ASSERT(IR, cond);
+    TINT_ASSERT(cond);
 
     AddOperand(Switch::kConditionOperandOffset, cond);
 }
diff --git a/src/tint/lang/core/ir/swizzle.cc b/src/tint/lang/core/ir/swizzle.cc
index b81fab8..83361a5 100644
--- a/src/tint/lang/core/ir/swizzle.cc
+++ b/src/tint/lang/core/ir/swizzle.cc
@@ -16,7 +16,7 @@
 
 #include <utility>
 
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Swizzle);
 
@@ -24,14 +24,14 @@
 
 Swizzle::Swizzle(InstructionResult* result, Value* object, VectorRef<uint32_t> indices)
     : indices_(std::move(indices)) {
-    TINT_ASSERT(IR, !indices.IsEmpty());
-    TINT_ASSERT(IR, indices.Length() <= 4);
+    TINT_ASSERT(!indices.IsEmpty());
+    TINT_ASSERT(indices.Length() <= 4);
 
     AddOperand(Swizzle::kObjectOperandOffset, object);
     AddResult(result);
 
     for (auto idx : indices_) {
-        TINT_ASSERT(IR, idx < 4);
+        TINT_ASSERT(idx < 4);
     }
 }
 
diff --git a/src/tint/lang/core/ir/transform/builtin_polyfill_spirv.cc b/src/tint/lang/core/ir/transform/builtin_polyfill_spirv.cc
index 99079b9..926045e 100644
--- a/src/tint/lang/core/ir/transform/builtin_polyfill_spirv.cc
+++ b/src/tint/lang/core/ir/transform/builtin_polyfill_spirv.cc
@@ -26,6 +26,7 @@
 #include "src/tint/lang/core/type/sampled_texture.h"
 #include "src/tint/lang/core/type/storage_texture.h"
 #include "src/tint/lang/core/type/texture.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::transform::BuiltinPolyfillSpirv);
 TINT_INSTANTIATE_TYPEINFO(tint::ir::transform::BuiltinPolyfillSpirv::LiteralOperand);
@@ -147,7 +148,7 @@
                 default:
                     break;
             }
-            TINT_ASSERT_OR_RETURN(Transform, replacement);
+            TINT_ASSERT_OR_RETURN(replacement);
 
             // Replace the old builtin result with the new value.
             if (auto name = ir->NameOf(builtin->Result())) {
@@ -174,13 +175,13 @@
         while (auto* let = tint::As<Let>(ptr->Source())) {
             ptr = let->Value()->As<InstructionResult>();
         }
-        TINT_ASSERT_OR_RETURN_VALUE(Transform, ptr, nullptr);
+        TINT_ASSERT_OR_RETURN_VALUE(ptr, nullptr);
 
         auto* access = ptr->Source()->As<Access>();
-        TINT_ASSERT_OR_RETURN_VALUE(Transform, access, nullptr);
-        TINT_ASSERT_OR_RETURN_VALUE(Transform, access->Indices().Length() == 1u, nullptr);
-        TINT_ASSERT_OR_RETURN_VALUE(
-            Transform, access->Object()->Type()->UnwrapPtr()->Is<type::Struct>(), nullptr);
+        TINT_ASSERT_OR_RETURN_VALUE(access, nullptr);
+        TINT_ASSERT_OR_RETURN_VALUE(access->Indices().Length() == 1u, nullptr);
+        TINT_ASSERT_OR_RETURN_VALUE(access->Object()->Type()->UnwrapPtr()->Is<type::Struct>(),
+                                    nullptr);
         auto* const_idx = access->Indices()[0]->As<Constant>();
 
         // Replace the builtin call with a call to the spirv.array_length intrinsic.
@@ -205,7 +206,7 @@
                 case builtin::AddressSpace::kStorage:
                     return b.Constant(u32(SpvScopeDevice));
                 default:
-                    TINT_ASSERT(Transform, false && "unhandled atomic address space");
+                    TINT_UNREACHABLE() << "unhandled atomic address space";
                     return nullptr;
             }
         }();
diff --git a/src/tint/lang/core/ir/transform/demote_to_helper.cc b/src/tint/lang/core/ir/transform/demote_to_helper.cc
index ce8aec4b..335ce09 100644
--- a/src/tint/lang/core/ir/transform/demote_to_helper.cc
+++ b/src/tint/lang/core/ir/transform/demote_to_helper.cc
@@ -18,6 +18,7 @@
 
 #include "src/tint/lang/core/ir/builder.h"
 #include "src/tint/lang/core/ir/module.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::transform::DemoteToHelper);
 
@@ -140,7 +141,7 @@
             // Move the original instruction into the if-true block.
             auto* result = ifelse->True()->Append(inst);
 
-            TINT_ASSERT(Transform, !inst->HasMultiResults());
+            TINT_ASSERT(!inst->HasMultiResults());
             if (inst->HasResults() && !inst->Result()->Type()->Is<type::Void>()) {
                 // The original instruction had a result, so return it from the if instruction.
                 ifelse->SetResults(Vector{b.InstructionResult(inst->Result()->Type())});
diff --git a/src/tint/lang/core/ir/transform/expand_implicit_splats.cc b/src/tint/lang/core/ir/transform/expand_implicit_splats.cc
index b8faedf..81eb5a6 100644
--- a/src/tint/lang/core/ir/transform/expand_implicit_splats.cc
+++ b/src/tint/lang/core/ir/transform/expand_implicit_splats.cc
@@ -123,7 +123,7 @@
                 expand_operand(builtin, CoreBuiltinCall::kArgsOperandOffset + 2);
                 break;
             default:
-                TINT_ASSERT(Transform, false && "unhandled builtin call");
+                TINT_UNREACHABLE() << "unhandled builtin call";
                 break;
         }
     }
diff --git a/src/tint/lang/core/ir/transform/handle_matrix_arithmetic.cc b/src/tint/lang/core/ir/transform/handle_matrix_arithmetic.cc
index 423d660..40d2190 100644
--- a/src/tint/lang/core/ir/transform/handle_matrix_arithmetic.cc
+++ b/src/tint/lang/core/ir/transform/handle_matrix_arithmetic.cc
@@ -19,6 +19,7 @@
 #include "src/tint/lang/core/ir/builder.h"
 #include "src/tint/lang/core/ir/module.h"
 #include "src/tint/lang/core/type/matrix.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::transform::HandleMatrixArithmetic);
 
@@ -41,7 +42,7 @@
             continue;
         }
         if (auto* binary = inst->As<Binary>()) {
-            TINT_ASSERT(Transform, binary->Operands().Length() == 2);
+            TINT_ASSERT(binary->Operands().Length() == 2);
             if (binary->LHS()->Type()->Is<type::Matrix>() ||
                 binary->RHS()->Type()->Is<type::Matrix>()) {
                 binary_worklist.Push(binary);
@@ -113,7 +114,7 @@
                 break;
 
             default:
-                TINT_ASSERT(Transform, false && "unhandled matrix arithmetic instruction");
+                TINT_UNREACHABLE() << "unhandled matrix arithmetic instruction";
                 break;
         }
     }
diff --git a/src/tint/lang/core/ir/unary.cc b/src/tint/lang/core/ir/unary.cc
index 41a9aaa..5f83962 100644
--- a/src/tint/lang/core/ir/unary.cc
+++ b/src/tint/lang/core/ir/unary.cc
@@ -13,7 +13,6 @@
 // limitations under the License.
 
 #include "src/tint/lang/core/ir/unary.h"
-#include "src/tint/utils/debug/debug.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Unary);
 
diff --git a/src/tint/lang/core/ir/user_call.cc b/src/tint/lang/core/ir/user_call.cc
index 01e7f91..11f791a 100644
--- a/src/tint/lang/core/ir/user_call.cc
+++ b/src/tint/lang/core/ir/user_call.cc
@@ -16,8 +16,6 @@
 
 #include <utility>
 
-#include "src/tint/utils/debug/debug.h"
-
 TINT_INSTANTIATE_TYPEINFO(tint::ir::UserCall);
 
 namespace tint::ir {
diff --git a/src/tint/lang/core/ir/value.cc b/src/tint/lang/core/ir/value.cc
index 4353ab6..3677d9e 100644
--- a/src/tint/lang/core/ir/value.cc
+++ b/src/tint/lang/core/ir/value.cc
@@ -16,6 +16,7 @@
 
 #include "src/tint/lang/core/ir/constant.h"
 #include "src/tint/lang/core/ir/instruction.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Value);
 
@@ -26,8 +27,8 @@
 Value::~Value() = default;
 
 void Value::Destroy() {
-    TINT_ASSERT(IR, Alive());
-    TINT_ASSERT(IR, Usages().Count() == 0);
+    TINT_ASSERT(Alive());
+    TINT_ASSERT(Usages().Count() == 0);
     flags_.Add(Flag::kDead);
 }
 
diff --git a/src/tint/lang/core/ir/var.cc b/src/tint/lang/core/ir/var.cc
index 0609fd0..3bf295c 100644
--- a/src/tint/lang/core/ir/var.cc
+++ b/src/tint/lang/core/ir/var.cc
@@ -13,8 +13,9 @@
 // limitations under the License.
 
 #include "src/tint/lang/core/ir/var.h"
+
 #include "src/tint/lang/core/ir/store.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Var);
 
@@ -22,7 +23,7 @@
 
 Var::Var(InstructionResult* result) {
     if (result && result->Type()) {
-        TINT_ASSERT(IR, result->Type()->Is<type::Pointer>());
+        TINT_ASSERT(result->Type()->Is<type::Pointer>());
     }
 
     // Default to no initializer.
diff --git a/src/tint/lang/core/type/array.cc b/src/tint/lang/core/type/array.cc
index 4d2d81c..a3831a4 100644
--- a/src/tint/lang/core/type/array.cc
+++ b/src/tint/lang/core/type/array.cc
@@ -18,7 +18,7 @@
 
 #include "src/tint/lang/core/type/manager.h"
 #include "src/tint/lang/core/type/texture_dimension.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 #include "src/tint/utils/text/symbol_table.h"
@@ -68,7 +68,7 @@
       size_(size),
       stride_(stride),
       implicit_stride_(implicit_stride) {
-    TINT_ASSERT(Type, element_);
+    TINT_ASSERT(element_);
 }
 
 bool Array::Equals(const UniqueNode& other) const {
diff --git a/src/tint/lang/core/type/atomic.cc b/src/tint/lang/core/type/atomic.cc
index 1ab17f4..4ff5607 100644
--- a/src/tint/lang/core/type/atomic.cc
+++ b/src/tint/lang/core/type/atomic.cc
@@ -16,8 +16,8 @@
 
 #include "src/tint/lang/core/type/manager.h"
 #include "src/tint/lang/core/type/reference.h"
-#include "src/tint/utils/debug/debug.h"
 #include "src/tint/utils/diagnostic/diagnostic.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
@@ -32,7 +32,7 @@
                Flag::kFixedFootprint,
            }),
       subtype_(subtype) {
-    TINT_ASSERT(AST, !subtype->Is<Reference>());
+    TINT_ASSERT(!subtype->Is<Reference>());
 }
 
 bool Atomic::Equals(const type::UniqueNode& other) const {
diff --git a/src/tint/lang/core/type/builtin_structs.cc b/src/tint/lang/core/type/builtin_structs.cc
index c3d381e..c3fbbc0 100644
--- a/src/tint/lang/core/type/builtin_structs.cc
+++ b/src/tint/lang/core/type/builtin_structs.cc
@@ -81,12 +81,12 @@
                     return abstract;
                 },
                 [&](Default) {
-                    TINT_ASSERT(Builtin, false && "unhandled modf type");
+                    TINT_UNREACHABLE() << "unhandled modf type";
                     return nullptr;
                 });
         },
         [&](Default) {
-            TINT_ASSERT(Builtin, false && "unhandled modf type");
+            TINT_UNREACHABLE() << "unhandled modf type";
             return nullptr;
         });
 }
@@ -147,12 +147,12 @@
                     return abstract;
                 },
                 [&](Default) {
-                    TINT_ASSERT(Builtin, false && "unhandled frexp type");
+                    TINT_UNREACHABLE() << "unhandled frexp type";
                     return nullptr;
                 });
         },
         [&](Default) {
-            TINT_ASSERT(Builtin, false && "unhandled frexp type");
+            TINT_UNREACHABLE() << "unhandled frexp type";
             return nullptr;
         });
 }
@@ -170,7 +170,7 @@
         [&](const I32*) { return build(builtin::Builtin::kAtomicCompareExchangeResultI32); },
         [&](const U32*) { return build(builtin::Builtin::kAtomicCompareExchangeResultU32); },
         [&](Default) {
-            TINT_ASSERT(Builtin, false && "unhandled atomic_compare_exchange type");
+            TINT_UNREACHABLE() << "unhandled atomic_compare_exchange type";
             return nullptr;
         });
 }
diff --git a/src/tint/lang/core/type/depth_multisampled_texture.cc b/src/tint/lang/core/type/depth_multisampled_texture.cc
index 386ff3d..71983b9 100644
--- a/src/tint/lang/core/type/depth_multisampled_texture.cc
+++ b/src/tint/lang/core/type/depth_multisampled_texture.cc
@@ -16,8 +16,8 @@
 
 #include "src/tint/lang/core/type/manager.h"
 #include "src/tint/lang/core/type/texture_dimension.h"
-#include "src/tint/utils/debug/debug.h"
 #include "src/tint/utils/diagnostic/diagnostic.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
@@ -33,8 +33,8 @@
 }  // namespace
 
 DepthMultisampledTexture::DepthMultisampledTexture(TextureDimension dim)
-    : Base(Hash(tint::TypeInfo::Of<DepthMultisampledTexture>().full_hashcode, dim), dim) {
-    TINT_ASSERT(Type, IsValidDepthDimension(dim));
+    : Base(Hash(TypeInfo::Of<DepthMultisampledTexture>().full_hashcode, dim), dim) {
+    TINT_ASSERT(IsValidDepthDimension(dim));
 }
 
 DepthMultisampledTexture::~DepthMultisampledTexture() = default;
diff --git a/src/tint/lang/core/type/depth_texture.cc b/src/tint/lang/core/type/depth_texture.cc
index f4f989a..973bb56 100644
--- a/src/tint/lang/core/type/depth_texture.cc
+++ b/src/tint/lang/core/type/depth_texture.cc
@@ -16,8 +16,8 @@
 
 #include "src/tint/lang/core/type/manager.h"
 #include "src/tint/lang/core/type/texture_dimension.h"
-#include "src/tint/utils/debug/debug.h"
 #include "src/tint/utils/diagnostic/diagnostic.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
@@ -34,8 +34,8 @@
 }  // namespace
 
 DepthTexture::DepthTexture(TextureDimension dim)
-    : Base(Hash(tint::TypeInfo::Of<DepthTexture>().full_hashcode, dim), dim) {
-    TINT_ASSERT(Type, IsValidDepthDimension(dim));
+    : Base(Hash(TypeInfo::Of<DepthTexture>().full_hashcode, dim), dim) {
+    TINT_ASSERT(IsValidDepthDimension(dim));
 }
 
 DepthTexture::~DepthTexture() = default;
diff --git a/src/tint/lang/core/type/manager.cc b/src/tint/lang/core/type/manager.cc
index e624a3c..499c5d3 100644
--- a/src/tint/lang/core/type/manager.cc
+++ b/src/tint/lang/core/type/manager.cc
@@ -143,7 +143,7 @@
     if (stride == 0) {
         stride = implicit_stride;
     }
-    TINT_ASSERT(Type, stride >= implicit_stride);
+    TINT_ASSERT(stride >= implicit_stride);
 
     return Get<type::Array>(/* element type */ elem_ty,
                             /* element count */ Get<ConstantArrayCount>(count),
diff --git a/src/tint/lang/core/type/matrix.cc b/src/tint/lang/core/type/matrix.cc
index 50787a4..59e006a 100644
--- a/src/tint/lang/core/type/matrix.cc
+++ b/src/tint/lang/core/type/matrix.cc
@@ -16,8 +16,8 @@
 
 #include "src/tint/lang/core/type/manager.h"
 #include "src/tint/lang/core/type/vector.h"
-#include "src/tint/utils/debug/debug.h"
 #include "src/tint/utils/diagnostic/diagnostic.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
@@ -36,10 +36,10 @@
       column_type_(column_type),
       rows_(column_type->Width()),
       columns_(columns) {
-    TINT_ASSERT(AST, rows_ > 1);
-    TINT_ASSERT(AST, rows_ < 5);
-    TINT_ASSERT(AST, columns_ > 1);
-    TINT_ASSERT(AST, columns_ < 5);
+    TINT_ASSERT(rows_ > 1);
+    TINT_ASSERT(rows_ < 5);
+    TINT_ASSERT(columns_ > 1);
+    TINT_ASSERT(columns_ < 5);
 }
 
 Matrix::~Matrix() = default;
diff --git a/src/tint/lang/core/type/multisampled_texture.cc b/src/tint/lang/core/type/multisampled_texture.cc
index e49706e..20b9da3 100644
--- a/src/tint/lang/core/type/multisampled_texture.cc
+++ b/src/tint/lang/core/type/multisampled_texture.cc
@@ -16,8 +16,8 @@
 
 #include "src/tint/lang/core/type/manager.h"
 #include "src/tint/lang/core/type/texture_dimension.h"
-#include "src/tint/utils/debug/debug.h"
 #include "src/tint/utils/diagnostic/diagnostic.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
@@ -28,7 +28,7 @@
 MultisampledTexture::MultisampledTexture(TextureDimension dim, const Type* type)
     : Base(Hash(tint::TypeInfo::Of<MultisampledTexture>().full_hashcode, dim, type), dim),
       type_(type) {
-    TINT_ASSERT(Type, type_);
+    TINT_ASSERT(type_);
 }
 
 MultisampledTexture::~MultisampledTexture() = default;
diff --git a/src/tint/lang/core/type/pointer.cc b/src/tint/lang/core/type/pointer.cc
index 1104d1f..d1412dd 100644
--- a/src/tint/lang/core/type/pointer.cc
+++ b/src/tint/lang/core/type/pointer.cc
@@ -16,8 +16,8 @@
 
 #include "src/tint/lang/core/type/manager.h"
 #include "src/tint/lang/core/type/reference.h"
-#include "src/tint/utils/debug/debug.h"
 #include "src/tint/utils/diagnostic/diagnostic.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
@@ -31,8 +31,8 @@
       subtype_(subtype),
       address_space_(address_space),
       access_(access) {
-    TINT_ASSERT(Type, !subtype->Is<Reference>());
-    TINT_ASSERT(Type, access != builtin::Access::kUndefined);
+    TINT_ASSERT(!subtype->Is<Reference>());
+    TINT_ASSERT(access != builtin::Access::kUndefined);
 }
 
 bool Pointer::Equals(const UniqueNode& other) const {
diff --git a/src/tint/lang/core/type/reference.cc b/src/tint/lang/core/type/reference.cc
index 63dc855..f540631 100644
--- a/src/tint/lang/core/type/reference.cc
+++ b/src/tint/lang/core/type/reference.cc
@@ -15,8 +15,8 @@
 #include "src/tint/lang/core/type/reference.h"
 
 #include "src/tint/lang/core/type/manager.h"
-#include "src/tint/utils/debug/debug.h"
 #include "src/tint/utils/diagnostic/diagnostic.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
@@ -32,8 +32,8 @@
       subtype_(subtype),
       address_space_(address_space),
       access_(access) {
-    TINT_ASSERT(Type, !subtype->Is<Reference>());
-    TINT_ASSERT(Type, access != builtin::Access::kUndefined);
+    TINT_ASSERT(!subtype->Is<Reference>());
+    TINT_ASSERT(access != builtin::Access::kUndefined);
 }
 
 bool Reference::Equals(const UniqueNode& other) const {
diff --git a/src/tint/lang/core/type/sampled_texture.cc b/src/tint/lang/core/type/sampled_texture.cc
index 6290476..297287b 100644
--- a/src/tint/lang/core/type/sampled_texture.cc
+++ b/src/tint/lang/core/type/sampled_texture.cc
@@ -16,8 +16,8 @@
 
 #include "src/tint/lang/core/type/manager.h"
 #include "src/tint/lang/core/type/texture_dimension.h"
-#include "src/tint/utils/debug/debug.h"
 #include "src/tint/utils/diagnostic/diagnostic.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
@@ -26,8 +26,8 @@
 namespace tint::type {
 
 SampledTexture::SampledTexture(TextureDimension dim, const Type* type)
-    : Base(Hash(tint::TypeInfo::Of<SampledTexture>().full_hashcode, dim, type), dim), type_(type) {
-    TINT_ASSERT(Type, type_);
+    : Base(Hash(TypeInfo::Of<SampledTexture>().full_hashcode, dim, type), dim), type_(type) {
+    TINT_ASSERT(type_);
 }
 
 SampledTexture::~SampledTexture() = default;
diff --git a/src/tint/lang/core/type/type.cc b/src/tint/lang/core/type/type.cc
index 93adb19..3c5185f 100644
--- a/src/tint/lang/core/type/type.cc
+++ b/src/tint/lang/core/type/type.cc
@@ -37,7 +37,7 @@
 
 Type::Type(size_t hash, type::Flags flags) : Base(hash), flags_(flags) {
     if (IsConstructible()) {
-        TINT_ASSERT(Type, HasCreationFixedFootprint());
+        TINT_ASSERT(HasCreationFixedFootprint());
     }
 }
 
diff --git a/src/tint/lang/core/type/vector.cc b/src/tint/lang/core/type/vector.cc
index dd50a5d..5e7d865 100644
--- a/src/tint/lang/core/type/vector.cc
+++ b/src/tint/lang/core/type/vector.cc
@@ -15,8 +15,8 @@
 #include "src/tint/lang/core/type/vector.h"
 
 #include "src/tint/lang/core/type/manager.h"
-#include "src/tint/utils/debug/debug.h"
 #include "src/tint/utils/diagnostic/diagnostic.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
@@ -34,8 +34,8 @@
       subtype_(subtype),
       width_(width),
       packed_(packed) {
-    TINT_ASSERT(Type, width_ > 1);
-    TINT_ASSERT(Type, width_ < 5);
+    TINT_ASSERT(width_ > 1);
+    TINT_ASSERT(width_ < 5);
 }
 
 Vector::~Vector() = default;
diff --git a/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc b/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc
index 8d82da4..d07b8a8 100644
--- a/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc
+++ b/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc
@@ -78,7 +78,7 @@
 #include "src/tint/lang/wgsl/sem/value_conversion.h"
 #include "src/tint/lang/wgsl/sem/variable.h"
 #include "src/tint/utils/containers/map.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/macros/defer.h"
 #include "src/tint/utils/macros/scoped_assignment.h"
 #include "src/tint/utils/rtti/switch.h"
@@ -307,8 +307,7 @@
                 RecordExtension(enable);
             },
             [&](Default) {
-                TINT_ICE(Writer, diagnostics_)
-                    << "unhandled module-scope declaration: " << decl->TypeInfo().name;
+                TINT_ICE() << "unhandled module-scope declaration: " << decl->TypeInfo().name;
             });
     }
 
@@ -375,9 +374,9 @@
         // Source type must be vec2<f16> or vec4<f16>, since type f16 and vec3<f16> can only have
         // identity bitcast.
         auto* src_vec = src_type->As<type::Vector>();
-        TINT_ASSERT(Writer, src_vec);
-        TINT_ASSERT(Writer, ((src_vec->Width() == 2u) || (src_vec->Width() == 4u)));
-        std::string fn = tint::GetOrCreate(
+        TINT_ASSERT(src_vec);
+        TINT_ASSERT(((src_vec->Width() == 2u) || (src_vec->Width() == 4u)));
+        std::string fn = GetOrCreate(
             bitcast_funcs_, BinaryOperandType{{src_type, dst_type}}, [&]() -> std::string {
                 TextBuffer b;
                 TINT_DEFER(helpers_.Append(b));
@@ -429,9 +428,9 @@
     } else if (dst_type->DeepestElement()->Is<type::F16>()) {
         // Destination type must be vec2<f16> or vec4<f16>.
         auto* dst_vec = dst_type->As<type::Vector>();
-        TINT_ASSERT(Writer, dst_vec);
-        TINT_ASSERT(Writer, ((dst_vec->Width() == 2u) || (dst_vec->Width() == 4u)));
-        std::string fn = tint::GetOrCreate(
+        TINT_ASSERT(dst_vec);
+        TINT_ASSERT(((dst_vec->Width() == 2u) || (dst_vec->Width() == 4u)));
+        std::string fn = GetOrCreate(
             bitcast_funcs_, BinaryOperandType{{src_type, dst_type}}, [&]() -> std::string {
                 TextBuffer b;
                 TINT_DEFER(helpers_.Append(b));
@@ -452,9 +451,9 @@
                     ScopedIndent si(&b);
                     if (auto src_vec = src_type->As<type::Vector>()) {
                         // Source vector type must be vec2<f32/i32/u32>, destination type vec4<f16>.
-                        TINT_ASSERT(Writer, (src_vec->DeepestElement()
-                                                 ->IsAnyOf<type::I32, type::U32, type::F32>()));
-                        TINT_ASSERT(Writer, (src_vec->Width() == 2u));
+                        TINT_ASSERT((
+                            src_vec->DeepestElement()->IsAnyOf<type::I32, type::U32, type::F32>()));
+                        TINT_ASSERT((src_vec->Width() == 2u));
                         {
                             auto s = Line(&b);
                             s << "uvec2 r = ";
@@ -470,7 +469,7 @@
                         Line(&b) << "return f16vec4(v_xy.x, v_xy.y, v_zw.x, v_zw.y);";
                     } else {
                         // Source scalar type must be f32/i32/u32, destination type vec2<f16>.
-                        TINT_ASSERT(Writer, (src_type->IsAnyOf<type::I32, type::U32, type::F32>()));
+                        TINT_ASSERT((src_type->IsAnyOf<type::I32, type::U32, type::F32>()));
                         {
                             auto s = Line(&b);
                             s << "uint r = ";
@@ -572,7 +571,7 @@
     } else if (TINT_LIKELY(expr->op == ast::BinaryOp::kOr)) {
         out << " | ";
     } else {
-        TINT_ICE(Writer, diagnostics_) << "unexpected binary op: " << FriendlyName(expr->op);
+        TINT_ICE() << "unexpected binary op: " << FriendlyName(expr->op);
         return;
     }
 
@@ -698,7 +697,7 @@
         case ast::BinaryOp::kLogicalAnd:
         case ast::BinaryOp::kLogicalOr: {
             // These are both handled above.
-            TINT_UNREACHABLE(Writer, diagnostics_);
+            TINT_UNREACHABLE();
             return;
         }
         case ast::BinaryOp::kEqual:
@@ -786,8 +785,7 @@
         [&](const sem::ValueConversion* conv) { EmitValueConversion(out, call, conv); },
         [&](const sem::ValueConstructor* ctor) { EmitValueConstructor(out, call, ctor); },
         [&](Default) {
-            TINT_ICE(Writer, diagnostics_)
-                << "unhandled call target: " << call->Target()->TypeInfo().name;
+            TINT_ICE() << "unhandled call target: " << call->Target()->TypeInfo().name;
         });
 }
 
@@ -1018,7 +1016,7 @@
             break;
     }
 
-    TINT_UNREACHABLE(Writer, diagnostics_) << "unsupported atomic builtin: " << builtin->Type();
+    TINT_UNREACHABLE() << "unsupported atomic builtin: " << builtin->Type();
 }
 
 void ASTPrinter::EmitArrayLength(StringStream& out, const ast::CallExpression* expr) {
@@ -1167,7 +1165,7 @@
 void ASTPrinter::EmitModfCall(StringStream& out,
                               const ast::CallExpression* expr,
                               const sem::Builtin* builtin) {
-    TINT_ASSERT(Writer, expr->args.Length() == 1);
+    TINT_ASSERT(expr->args.Length() == 1);
     CallBuiltinHelper(out, expr, builtin,
                       [&](TextBuffer* b, const std::vector<std::string>& params) {
                           // Emit the builtin return type unique to this overload. This does not
@@ -1188,7 +1186,7 @@
 void ASTPrinter::EmitFrexpCall(StringStream& out,
                                const ast::CallExpression* expr,
                                const sem::Builtin* builtin) {
-    TINT_ASSERT(Writer, expr->args.Length() == 1);
+    TINT_ASSERT(expr->args.Length() == 1);
     CallBuiltinHelper(out, expr, builtin,
                       [&](TextBuffer* b, const std::vector<std::string>& params) {
                           // Emit the builtin return type unique to this overload. This does not
@@ -1269,8 +1267,7 @@
     } else if (builtin->Type() == builtin::Function::kStorageBarrier) {
         out << "{ barrier(); memoryBarrierBuffer(); }";
     } else {
-        TINT_UNREACHABLE(Writer, diagnostics_)
-            << "unexpected barrier builtin type " << builtin::str(builtin->Type());
+        TINT_UNREACHABLE() << "unexpected barrier builtin type " << builtin::str(builtin->Type());
     }
 }
 
@@ -1301,7 +1298,7 @@
 
     auto* texture = arg(Usage::kTexture);
     if (TINT_UNLIKELY(!texture)) {
-        TINT_ICE(Writer, diagnostics_) << "missing texture argument";
+        TINT_ICE() << "missing texture argument";
         return;
     }
 
@@ -1486,7 +1483,7 @@
 
     auto* param_coords = arg(Usage::kCoords);
     if (TINT_UNLIKELY(!param_coords)) {
-        TINT_ICE(Writer, diagnostics_) << "missing coords argument";
+        TINT_ICE() << "missing coords argument";
         return;
     }
 
@@ -1577,9 +1574,9 @@
         }
     }
     if (TINT_UNLIKELY(wgsl_ret_width > glsl_ret_width)) {
-        TINT_ICE(Writer, diagnostics_)
-            << "WGSL return width (" << wgsl_ret_width << ") is wider than GLSL return width ("
-            << glsl_ret_width << ") for " << builtin->Type();
+        TINT_ICE() << "WGSL return width (" << wgsl_ret_width
+                   << ") is wider than GLSL return width (" << glsl_ret_width << ") for "
+                   << builtin->Type();
         return;
     }
 }
@@ -1873,8 +1870,7 @@
                         "unhandled address space " + tint::ToString(sem->AddressSpace()));
                     return;
                 default: {
-                    TINT_ICE(Writer, diagnostics_)
-                        << "unhandled address space " << sem->AddressSpace();
+                    TINT_ICE() << "unhandled address space " << sem->AddressSpace();
                     break;
                 }
             }
@@ -1890,8 +1886,7 @@
             // Constants are embedded at their use
         },
         [&](Default) {
-            TINT_ICE(Writer, diagnostics_)
-                << "unhandled global variable type " << global->TypeInfo().name;
+            TINT_ICE() << "unhandled global variable type " << global->TypeInfo().name;
         });
 }
 
@@ -1899,7 +1894,7 @@
     auto* type = sem->Type()->UnwrapRef();
     auto* str = type->As<type::Struct>();
     if (TINT_UNLIKELY(!str)) {
-        TINT_ICE(Writer, builder_.Diagnostics()) << "storage variable must be of struct type";
+        TINT_ICE() << "storage variable must be of struct type";
         return;
     }
     auto bp = *sem->As<sem::GlobalVariable>()->BindingPoint();
@@ -1918,7 +1913,7 @@
     auto* type = sem->Type()->UnwrapRef();
     auto* str = type->As<type::Struct>();
     if (TINT_UNLIKELY(!str)) {
-        TINT_ICE(Writer, builder_.Diagnostics()) << "storage variable must be of struct type";
+        TINT_ICE() << "storage variable must be of struct type";
         return;
     }
     auto bp = *sem->As<sem::GlobalVariable>()->BindingPoint();
@@ -1944,8 +1939,7 @@
         out << "layout(";
         switch (storage->texel_format()) {
             case builtin::TexelFormat::kBgra8Unorm:
-                TINT_ICE(Writer, diagnostics_)
-                    << "bgra8unorm should have been polyfilled to rgba8unorm";
+                TINT_ICE() << "bgra8unorm should have been polyfilled to rgba8unorm";
                 break;
             case builtin::TexelFormat::kR32Uint:
                 out << "r32ui";
@@ -1996,7 +1990,7 @@
                 out << "rgba32f";
                 break;
             case builtin::TexelFormat::kUndefined:
-                TINT_ICE(Writer, diagnostics_) << "invalid texel format";
+                TINT_ICE() << "invalid texel format";
                 return;
         }
         out << ") ";
@@ -2173,7 +2167,7 @@
             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";
+                TINT_ICE() << "Unsupported non-struct entry point parameter";
             }
 
             if (!first) {
@@ -2539,10 +2533,7 @@
         [&](const sem::StructMemberAccess* member_access) {
             out << member_access->Member()->Name().Name();
         },
-        [&](Default) {
-            TINT_ICE(Writer, diagnostics_)
-                << "unknown member access type: " << sem->TypeInfo().name;
-        });
+        [&](Default) { TINT_ICE() << "unknown member access type: " << sem->TypeInfo().name; });
 }
 
 void ASTPrinter::EmitReturn(const ast::ReturnStatement* stmt) {
@@ -2585,8 +2576,7 @@
                     // Constants are embedded at their use
                 },
                 [&](Default) {  //
-                    TINT_ICE(Writer, diagnostics_)
-                        << "unknown variable type: " << v->variable->TypeInfo().name;
+                    TINT_ICE() << "unknown variable type: " << v->variable->TypeInfo().name;
                 });
         },
         [&](const ast::ConstAssert*) {
@@ -2684,7 +2674,7 @@
     } else if (type->Is<type::I32>()) {
         out << "int";
     } else if (auto* mat = type->As<type::Matrix>()) {
-        TINT_ASSERT(Writer, (mat->type()->IsAnyOf<type::F32, type::F16>()));
+        TINT_ASSERT((mat->type()->IsAnyOf<type::F32, type::F16>()));
         if (mat->type()->Is<type::F16>()) {
             out << "f16";
         }
@@ -2693,14 +2683,14 @@
             out << "x" << mat->rows();
         }
     } else if (TINT_UNLIKELY(type->Is<type::Pointer>())) {
-        TINT_ICE(Writer, diagnostics_) << "Attempting to emit pointer type. These should have been "
-                                          "removed with the SimplifyPointers transform";
+        TINT_ICE() << "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<type::Struct>()) {
         out << StructName(str);
     } else if (auto* tex = type->As<type::Texture>()) {
         if (TINT_UNLIKELY(tex->Is<type::ExternalTexture>())) {
-            TINT_ICE(Writer, diagnostics_) << "Multiplanar external texture transform was not run.";
+            TINT_ICE() << "Multiplanar external texture transform was not run.";
             return;
         }
 
@@ -2724,7 +2714,7 @@
         } else if (TINT_LIKELY(subtype->Is<type::U32>())) {
             out << "u";
         } else {
-            TINT_ICE(Writer, diagnostics_) << "Unsupported texture type";
+            TINT_ICE() << "Unsupported texture type";
             return;
         }
 
@@ -2750,8 +2740,7 @@
                 out << "CubeArray";
                 break;
             default:
-                TINT_UNREACHABLE(Writer, diagnostics_)
-                    << "unexpected TextureDimension " << tex->dim();
+                TINT_UNREACHABLE() << "unexpected TextureDimension " << tex->dim();
                 return;
         }
         if (tex->Is<type::DepthTexture>()) {
diff --git a/src/tint/lang/hlsl/writer/ast_printer/ast_printer.cc b/src/tint/lang/hlsl/writer/ast_printer/ast_printer.cc
index 94a6307..6699805 100644
--- a/src/tint/lang/hlsl/writer/ast_printer/ast_printer.cc
+++ b/src/tint/lang/hlsl/writer/ast_printer/ast_printer.cc
@@ -76,7 +76,7 @@
 #include "src/tint/lang/wgsl/sem/value_conversion.h"
 #include "src/tint/lang/wgsl/sem/variable.h"
 #include "src/tint/utils/containers/map.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/macros/compiler.h"
 #include "src/tint/utils/macros/defer.h"
 #include "src/tint/utils/macros/scoped_assignment.h"
@@ -394,8 +394,7 @@
                 return EmitFunction(func);
             },
             [&](Default) {
-                TINT_ICE(Writer, diagnostics_)
-                    << "unhandled module-scope declaration: " << decl->TypeInfo().name;
+                TINT_ICE() << "unhandled module-scope declaration: " << decl->TypeInfo().name;
                 return false;
             });
 
@@ -451,8 +450,7 @@
                     out << "vec = (idx.xxxx == int4(0, 1, 2, 3)) ? val.xxxx : vec;";
                     break;
                 default:
-                    TINT_UNREACHABLE(Writer, diagnostics_)
-                        << "invalid vector size " << vec->Width();
+                    TINT_UNREACHABLE() << "invalid vector size " << vec->Width();
                     break;
             }
         }
@@ -612,8 +610,7 @@
                                     auto* vec = TypeOf(lhs_row_access->object)
                                                     ->UnwrapRef()
                                                     ->As<type::Vector>();
-                                    TINT_UNREACHABLE(Writer, diagnostics_)
-                                        << "invalid vector size " << vec->Width();
+                                    TINT_UNREACHABLE() << "invalid vector size " << vec->Width();
                                     break;
                                 }
                             }
@@ -694,8 +691,8 @@
                 // Source type must be vec2<f16> or vec4<f16>, since type f16 and vec3<f16> can only
                 // have identity bitcast.
                 auto* src_vec = src_type->As<type::Vector>();
-                TINT_ASSERT(Writer, src_vec);
-                TINT_ASSERT(Writer, ((src_vec->Width() == 2u) || (src_vec->Width() == 4u)));
+                TINT_ASSERT(src_vec);
+                TINT_ASSERT(((src_vec->Width() == 2u) || (src_vec->Width() == 4u)));
 
                 // Bitcast f16 types to others by converting the given f16 value to f32 and call
                 // f32tof16 to get the bits. This should be safe, because the convertion is precise
@@ -759,14 +756,13 @@
             } else {
                 // Destination type must be vec2<f16> or vec4<f16>.
                 auto* dst_vec = dst_type->As<type::Vector>();
-                TINT_ASSERT(Writer,
-                            (dst_vec && ((dst_vec->Width() == 2u) || (dst_vec->Width() == 4u)) &&
+                TINT_ASSERT((dst_vec && ((dst_vec->Width() == 2u) || (dst_vec->Width() == 4u)) &&
                              dst_el_type->Is<type::F16>()));
                 // Source type must be f32/i32/u32 or vec2<f32/i32/u32>.
                 auto* src_vec = src_type->As<type::Vector>();
-                TINT_ASSERT(Writer, (src_type->IsAnyOf<type::I32, type::U32, type::F32>() ||
-                                     (src_vec && src_vec->Width() == 2u &&
-                                      src_el_type->IsAnyOf<type::I32, type::U32, type::F32>())));
+                TINT_ASSERT((src_type->IsAnyOf<type::I32, type::U32, type::F32>() ||
+                             (src_vec && src_vec->Width() == 2u &&
+                              src_el_type->IsAnyOf<type::I32, type::U32, type::F32>())));
                 std::string src_type_suffix = (src_vec ? "2" : "");
 
                 // Bitcast other types to f16 types by reinterpreting their bits as f16 using
@@ -854,7 +850,7 @@
     }
 
     // Otherwise, bitcasting between non-f16 types.
-    TINT_ASSERT(Writer, (!src_el_type->Is<type::F16>() && !dst_el_type->Is<type::F16>()));
+    TINT_ASSERT((!src_el_type->Is<type::F16>() && !dst_el_type->Is<type::F16>()));
     out << "as";
     if (!EmitType(out, dst_el_type, builtin::AddressSpace::kUndefined, builtin::Access::kReadWrite,
                   "")) {
@@ -989,7 +985,7 @@
         case ast::BinaryOp::kLogicalAnd:
         case ast::BinaryOp::kLogicalOr: {
             // These are both handled above.
-            TINT_UNREACHABLE(Writer, diagnostics_);
+            TINT_UNREACHABLE();
             return false;
         }
         case ast::BinaryOp::kEqual:
@@ -1097,7 +1093,7 @@
         [&](const sem::ValueConversion* conv) { return EmitValueConversion(out, call, conv); },
         [&](const sem::ValueConstructor* ctor) { return EmitValueConstructor(out, call, ctor); },
         [&](Default) {
-            TINT_ICE(Writer, diagnostics_) << "unhandled call target: " << target->TypeInfo().name;
+            TINT_ICE() << "unhandled call target: " << target->TypeInfo().name;
             return false;
         });
 }
@@ -1133,9 +1129,8 @@
                 }
                 break;
             default:
-                TINT_UNREACHABLE(Writer, diagnostics_)
-                    << "unsupported DecomposeMemoryAccess::Intrinsic address space:"
-                    << intrinsic->address_space;
+                TINT_UNREACHABLE() << "unsupported DecomposeMemoryAccess::Intrinsic address space:"
+                                   << intrinsic->address_space;
                 return false;
         }
     }
@@ -1278,7 +1273,7 @@
     // It could also be conversions between f16 and f32 matrix when f16 is properly supported.
     if (type->Is<type::Matrix>() && call->Arguments().Length() == 1) {
         if (!ctor->Parameters()[0]->Type()->UnwrapRef()->is_float_matrix()) {
-            TINT_UNREACHABLE(Writer, diagnostics_)
+            TINT_UNREACHABLE()
                 << "found a single-parameter matrix initializer that is not identity initializer";
             return false;
         }
@@ -1348,7 +1343,7 @@
     bool scalar_offset_constant = false;
 
     if (auto* val = builder_.Sem().GetVal(offset)->ConstantValue()) {
-        TINT_ASSERT(Writer, val->Type()->Is<type::U32>());
+        TINT_ASSERT(val->Type()->Is<type::U32>());
         scalar_offset_bytes = static_cast<uint32_t>(val->ValueAs<AInt>());
         scalar_offset_index = scalar_offset_bytes / 4;  // bytes -> scalar index
         scalar_offset_constant = true;
@@ -1601,16 +1596,15 @@
                 case DataType::kVec4F16:
                     return load_vec4_f16();
             }
-            TINT_UNREACHABLE(Writer, diagnostics_)
-                << "unsupported DecomposeMemoryAccess::Intrinsic::DataType: "
-                << static_cast<int>(intrinsic->type);
+            TINT_UNREACHABLE() << "unsupported DecomposeMemoryAccess::Intrinsic::DataType: "
+                               << static_cast<int>(intrinsic->type);
             return false;
         }
         default:
             break;
     }
-    TINT_UNREACHABLE(Writer, diagnostics_)
-        << "unsupported DecomposeMemoryAccess::Intrinsic::Op: " << static_cast<int>(intrinsic->op);
+    TINT_UNREACHABLE() << "unsupported DecomposeMemoryAccess::Intrinsic::Op: "
+                       << static_cast<int>(intrinsic->op);
     return false;
 }
 
@@ -1688,9 +1682,8 @@
                 case DataType::kVec4F16:
                     return templated_load("vector<float16_t, 4> ");
             }
-            TINT_UNREACHABLE(Writer, diagnostics_)
-                << "unsupported DecomposeMemoryAccess::Intrinsic::DataType: "
-                << static_cast<int>(intrinsic->type);
+            TINT_UNREACHABLE() << "unsupported DecomposeMemoryAccess::Intrinsic::DataType: "
+                               << static_cast<int>(intrinsic->type);
             return false;
         }
 
@@ -1760,9 +1753,8 @@
                 case DataType::kVec4F16:
                     return templated_store("vector<float16_t, 4> ");
             }
-            TINT_UNREACHABLE(Writer, diagnostics_)
-                << "unsupported DecomposeMemoryAccess::Intrinsic::DataType: "
-                << static_cast<int>(intrinsic->type);
+            TINT_UNREACHABLE() << "unsupported DecomposeMemoryAccess::Intrinsic::DataType: "
+                               << static_cast<int>(intrinsic->type);
             return false;
         }
         default:
@@ -1771,8 +1763,8 @@
             break;
     }
 
-    TINT_UNREACHABLE(Writer, diagnostics_)
-        << "unsupported DecomposeMemoryAccess::Intrinsic::Op: " << static_cast<int>(intrinsic->op);
+    TINT_UNREACHABLE() << "unsupported DecomposeMemoryAccess::Intrinsic::Op: "
+                       << static_cast<int>(intrinsic->op);
     return false;
 }
 
@@ -1978,9 +1970,8 @@
             break;
     }
 
-    TINT_UNREACHABLE(Writer, diagnostics_)
-        << "unsupported atomic DecomposeMemoryAccess::Intrinsic::Op: "
-        << static_cast<int>(intrinsic->op);
+    TINT_UNREACHABLE() << "unsupported atomic DecomposeMemoryAccess::Intrinsic::Op: "
+                       << static_cast<int>(intrinsic->op);
     return false;
 }
 
@@ -2155,7 +2146,7 @@
             break;
     }
 
-    TINT_UNREACHABLE(Writer, diagnostics_) << "unsupported atomic builtin: " << builtin->Type();
+    TINT_UNREACHABLE() << "unsupported atomic builtin: " << builtin->Type();
     return false;
 }
 
@@ -2493,8 +2484,7 @@
     } else if (builtin->Type() == builtin::Function::kStorageBarrier) {
         out << "DeviceMemoryBarrierWithGroupSync()";
     } else {
-        TINT_UNREACHABLE(Writer, diagnostics_)
-            << "unexpected barrier builtin type " << builtin::str(builtin->Type());
+        TINT_UNREACHABLE() << "unexpected barrier builtin type " << builtin::str(builtin->Type());
         return false;
     }
     return true;
@@ -2517,7 +2507,7 @@
 
     auto* texture = arg(Usage::kTexture);
     if (TINT_UNLIKELY(!texture)) {
-        TINT_ICE(Writer, diagnostics_) << "missing texture argument";
+        TINT_ICE() << "missing texture argument";
         return false;
     }
 
@@ -2538,7 +2528,7 @@
                 case builtin::Function::kTextureDimensions:
                     switch (texture_type->dim()) {
                         case type::TextureDimension::kNone:
-                            TINT_ICE(Writer, diagnostics_) << "texture dimension is kNone";
+                            TINT_ICE() << "texture dimension is kNone";
                             return false;
                         case type::TextureDimension::k1d:
                             num_dimensions = 1;
@@ -2566,7 +2556,7 @@
                 case builtin::Function::kTextureNumLayers:
                     switch (texture_type->dim()) {
                         default:
-                            TINT_ICE(Writer, diagnostics_) << "texture dimension is not arrayed";
+                            TINT_ICE() << "texture dimension is not arrayed";
                             return false;
                         case type::TextureDimension::k2dArray:
                             num_dimensions = is_ms ? 4 : 3;
@@ -2581,8 +2571,7 @@
                 case builtin::Function::kTextureNumLevels:
                     switch (texture_type->dim()) {
                         default:
-                            TINT_ICE(Writer, diagnostics_)
-                                << "texture dimension does not support mips";
+                            TINT_ICE() << "texture dimension does not support mips";
                             return false;
                         case type::TextureDimension::k1d:
                             num_dimensions = 2;
@@ -2604,8 +2593,7 @@
                 case builtin::Function::kTextureNumSamples:
                     switch (texture_type->dim()) {
                         default:
-                            TINT_ICE(Writer, diagnostics_)
-                                << "texture dimension does not support multisampling";
+                            TINT_ICE() << "texture dimension does not support multisampling";
                             return false;
                         case type::TextureDimension::k2d:
                             num_dimensions = 3;
@@ -2618,7 +2606,7 @@
                     }
                     break;
                 default:
-                    TINT_ICE(Writer, diagnostics_) << "unexpected builtin";
+                    TINT_ICE() << "unexpected builtin";
                     return false;
             }
 
@@ -2640,8 +2628,8 @@
             }
 
             if (TINT_UNLIKELY(num_dimensions > 4)) {
-                TINT_ICE(Writer, diagnostics_) << "Texture query builtin temporary vector has "
-                                               << num_dimensions << " dimensions";
+                TINT_ICE() << "Texture query builtin temporary vector has " << num_dimensions
+                           << " dimensions";
                 return false;
             }
 
@@ -2674,8 +2662,7 @@
                 } else {
                     static constexpr char xyzw[] = {'x', 'y', 'z', 'w'};
                     if (TINT_UNLIKELY(num_dimensions < 0 || num_dimensions > 4)) {
-                        TINT_ICE(Writer, diagnostics_)
-                            << "vector dimensions are " << num_dimensions;
+                        TINT_ICE() << "vector dimensions are " << num_dimensions;
                         return false;
                     }
                     for (int i = 0; i < num_dimensions; i++) {
@@ -2781,7 +2768,7 @@
 
     auto* param_coords = arg(Usage::kCoords);
     if (TINT_UNLIKELY(!param_coords)) {
-        TINT_ICE(Writer, diagnostics_) << "missing coords argument";
+        TINT_ICE() << "missing coords argument";
         return false;
     }
 
@@ -2864,9 +2851,9 @@
             }
         }
         if (TINT_UNLIKELY(wgsl_ret_width > hlsl_ret_width)) {
-            TINT_ICE(Writer, diagnostics_)
-                << "WGSL return width (" << wgsl_ret_width << ") is wider than HLSL return width ("
-                << hlsl_ret_width << ") for " << builtin->Type();
+            TINT_ICE() << "WGSL return width (" << wgsl_ret_width
+                       << ") is wider than HLSL return width (" << hlsl_ret_width << ") for "
+                       << builtin->Type();
             return false;
         }
     }
@@ -3184,7 +3171,7 @@
     // there is always an (unused) return statement.
 
     auto* sem = builder_.Sem().Get(func);
-    TINT_ASSERT(Writer, sem->DiscardStatement() && !sem->ReturnType()->Is<type::Void>());
+    TINT_ASSERT(sem->DiscardStatement() && !sem->ReturnType()->Is<type::Void>());
 
     ScopedIndent si(this);
     Line() << "if (true) {";
@@ -3232,8 +3219,7 @@
                         "unhandled address space " + tint::ToString(sem->AddressSpace()));
                     return false;
                 default: {
-                    TINT_ICE(Writer, diagnostics_)
-                        << "unhandled address space " << sem->AddressSpace();
+                    TINT_ICE() << "unhandled address space " << sem->AddressSpace();
                     return false;
                 }
             }
@@ -3249,8 +3235,7 @@
             return true;  // Constants are embedded at their use
         },
         [&](Default) {
-            TINT_ICE(Writer, diagnostics_)
-                << "unhandled global variable type " << global->TypeInfo().name;
+            TINT_ICE() << "unhandled global variable type " << global->TypeInfo().name;
 
             return false;
         });
@@ -3480,7 +3465,7 @@
             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";
+                TINT_ICE() << "Unsupported non-struct entry point parameter";
             }
 
             if (!first) {
@@ -3997,8 +3982,7 @@
             return true;
         },
         [&](Default) {
-            TINT_ICE(Writer, diagnostics_)
-                << "unknown member access type: " << sem->TypeInfo().name;
+            TINT_ICE() << "unknown member access type: " << sem->TypeInfo().name;
             return false;
         });
 }
@@ -4073,8 +4057,7 @@
                     return true;  // Constants are embedded at their use
                 },
                 [&](Default) {  //
-                    TINT_ICE(Writer, diagnostics_)
-                        << "unknown variable type: " << v->variable->TypeInfo().name;
+                    TINT_ICE() << "unknown variable type: " << v->variable->TypeInfo().name;
                     return false;
                 });
         },
@@ -4089,7 +4072,7 @@
 }
 
 bool ASTPrinter::EmitDefaultOnlySwitch(const ast::SwitchStatement* stmt) {
-    TINT_ASSERT(Writer, stmt->body.Length() == 1 && stmt->body[0]->ContainsDefault());
+    TINT_ASSERT(stmt->body.Length() == 1 && stmt->body[0]->ContainsDefault());
 
     // FXC fails to compile a switch with just a default case, ignoring the
     // default case body. We work around this here by emitting the default case
@@ -4184,7 +4167,7 @@
             std::vector<uint32_t> sizes;
             while (auto* arr = base_type->As<type::Array>()) {
                 if (TINT_UNLIKELY(arr->Count()->Is<type::RuntimeArrayCount>())) {
-                    TINT_ICE(Writer, diagnostics_)
+                    TINT_ICE()
                         << "runtime arrays may only exist in storage buffers, which should have "
                            "been transformed into a ByteAddressBuffer";
                     return false;
@@ -4253,8 +4236,8 @@
             return true;
         },
         [&](const type::Pointer*) {
-            TINT_ICE(Writer, diagnostics_) << "Attempting to emit pointer type. These should have "
-                                              "been removed with the SimplifyPointers transform";
+            TINT_ICE() << "Attempting to emit pointer type. These should have "
+                          "been removed with the SimplifyPointers transform";
             return false;
         },
         [&](const type::Sampler* sampler) {
@@ -4271,8 +4254,7 @@
         },
         [&](const type::Texture* tex) {
             if (TINT_UNLIKELY(tex->Is<type::ExternalTexture>())) {
-                TINT_ICE(Writer, diagnostics_)
-                    << "Multiplanar external texture transform was not run.";
+                TINT_ICE() << "Multiplanar external texture transform was not run.";
                 return false;
             }
 
@@ -4306,16 +4288,15 @@
                     out << "CubeArray";
                     break;
                 default:
-                    TINT_UNREACHABLE(Writer, diagnostics_)
-                        << "unexpected TextureDimension " << tex->dim();
+                    TINT_UNREACHABLE() << "unexpected TextureDimension " << tex->dim();
                     return false;
             }
 
             if (storage) {
                 auto* component = image_format_to_rwtexture_type(storage->texel_format());
                 if (TINT_UNLIKELY(!component)) {
-                    TINT_ICE(Writer, diagnostics_) << "Unsupported StorageTexture TexelFormat: "
-                                                   << static_cast<int>(storage->texel_format());
+                    TINT_ICE() << "Unsupported StorageTexture TexelFormat: "
+                               << static_cast<int>(storage->texel_format());
                     return false;
                 }
                 out << "<" << component << ">";
@@ -4331,7 +4312,7 @@
                 } else if (TINT_LIKELY(subtype->Is<type::U32>())) {
                     out << "uint4";
                 } else {
-                    TINT_ICE(Writer, diagnostics_) << "Unsupported multisampled texture type";
+                    TINT_ICE() << "Unsupported multisampled texture type";
                     return false;
                 }
                 out << ">";
@@ -4410,7 +4391,7 @@
             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";
+                    TINT_ICE() << "invalid entry point IO struct uses";
                 }
                 if (pipeline_stage_uses.count(type::PipelineStageUsage::kVertexInput)) {
                     post += " : TEXCOORD" + std::to_string(location.value());
@@ -4427,7 +4408,7 @@
                     }
 
                 } else {
-                    TINT_ICE(Writer, diagnostics_) << "invalid use of location attribute";
+                    TINT_ICE() << "invalid use of location attribute";
                 }
             }
             if (auto builtin = attributes.builtin) {
diff --git a/src/tint/lang/msl/writer/ast_printer/ast_printer.cc b/src/tint/lang/msl/writer/ast_printer/ast_printer.cc
index b9aa6c1..f9557c64 100644
--- a/src/tint/lang/msl/writer/ast_printer/ast_printer.cc
+++ b/src/tint/lang/msl/writer/ast_printer/ast_printer.cc
@@ -297,7 +297,7 @@
             },
             [&](Default) {
                 // These are pushed into the entry point by sanitizer transforms.
-                TINT_ICE(Writer, diagnostics_) << "unhandled type: " << decl->TypeInfo().name;
+                TINT_ICE() << "unhandled type: " << decl->TypeInfo().name;
                 return false;
             });
         if (!ok) {
@@ -614,7 +614,7 @@
         [&](const sem::ValueConversion* conv) { return EmitTypeConversion(out, call, conv); },
         [&](const sem::ValueConstructor* ctor) { return EmitTypeInitializer(out, call, ctor); },
         [&](Default) {
-            TINT_ICE(Writer, diagnostics_) << "unhandled call target: " << target->TypeInfo().name;
+            TINT_ICE() << "unhandled call target: " << target->TypeInfo().name;
             return false;
         });
 }
@@ -946,7 +946,7 @@
             break;
     }
 
-    TINT_UNREACHABLE(Writer, diagnostics_) << "unsupported atomic builtin: " << builtin->Type();
+    TINT_UNREACHABLE() << "unsupported atomic builtin: " << builtin->Type();
     return false;
 }
 
@@ -967,7 +967,7 @@
 
     auto* texture = arg(Usage::kTexture)->Declaration();
     if (TINT_UNLIKELY(!texture)) {
-        TINT_ICE(Writer, diagnostics_) << "missing texture arg";
+        TINT_ICE() << "missing texture arg";
         return false;
     }
 
@@ -1104,8 +1104,7 @@
             out << ".write(";
             break;
         default:
-            TINT_UNREACHABLE(Writer, diagnostics_)
-                << "Unhandled texture builtin '" << builtin->str() << "'";
+            TINT_UNREACHABLE() << "Unhandled texture builtin '" << builtin->str() << "'";
             return false;
     }
 
@@ -1138,7 +1137,7 @@
                         out << "uint3(";
                         break;
                     default:
-                        TINT_ICE(Writer, diagnostics_) << "unhandled texture dimensionality";
+                        TINT_ICE() << "unhandled texture dimensionality";
                         break;
                 }
             }
@@ -1252,7 +1251,7 @@
                 out << "component::w";
                 break;
             default:
-                TINT_ICE(Writer, diagnostics_) << "invalid textureGather component: " << c;
+                TINT_ICE() << "invalid textureGather component: " << c;
                 break;
         }
     }
@@ -1882,15 +1881,14 @@
     const uint32_t kInvalidBindingIndex = std::numeric_limits<uint32_t>::max();
     auto get_binding_index = [&](const ast::Parameter* param) -> uint32_t {
         if (TINT_UNLIKELY(!param->HasBindingPoint())) {
-            TINT_ICE(Writer, diagnostics_)
-                << "missing binding attributes for entry point parameter";
+            TINT_ICE() << "missing binding attributes for entry point parameter";
             return kInvalidBindingIndex;
         }
         auto* param_sem = builder_.Sem().Get<sem::Parameter>(param);
         auto bp = param_sem->BindingPoint();
         if (TINT_UNLIKELY(bp->group != 0)) {
-            TINT_ICE(Writer, diagnostics_) << "encountered non-zero resource group index (use "
-                                              "BindingRemapper to fix)";
+            TINT_ICE() << "encountered non-zero resource group index (use "
+                          "BindingRemapper to fix)";
             return kInvalidBindingIndex;
         }
         return bp->binding;
@@ -1965,8 +1963,7 @@
                         default:
                             break;
                     }
-                    TINT_ICE(Writer, diagnostics_)
-                        << "invalid pointer address space for entry point parameter";
+                    TINT_ICE() << "invalid pointer address space for entry point parameter";
                     return false;
                 },
                 [&](Default) {
@@ -1989,7 +1986,7 @@
                         out << " [[" << name << "]]";
                     }
                     if (TINT_UNLIKELY(!builtin_found)) {
-                        TINT_ICE(Writer, diagnostics_) << "Unsupported entry point parameter";
+                        TINT_ICE() << "Unsupported entry point parameter";
                         return false;
                     }
                     return true;
@@ -2294,8 +2291,7 @@
             return true;
         },
         [&](Default) {
-            TINT_ICE(Writer, diagnostics_)
-                << "unknown member access type: " << sem->TypeInfo().name;
+            TINT_ICE() << "unknown member access type: " << sem->TypeInfo().name;
             return false;
         });
 }
@@ -2381,8 +2377,7 @@
                     return true;  // Constants are embedded at their use
                 },
                 [&](Default) {  //
-                    TINT_ICE(Writer, diagnostics_)
-                        << "unknown statement type: " << stmt->TypeInfo().name;
+                    TINT_ICE() << "unknown statement type: " << stmt->TypeInfo().name;
                     return false;
                 });
         },
@@ -2446,8 +2441,7 @@
                 out << "atomic_uint";
                 return true;
             }
-            TINT_ICE(Writer, diagnostics_)
-                << "unhandled atomic type " << atomic->Type()->FriendlyName();
+            TINT_ICE() << "unhandled atomic type " << atomic->Type()->FriendlyName();
             return false;
         },
         [&](const type::Array* arr) {
@@ -2520,8 +2514,7 @@
         },
         [&](const type::Texture* tex) {
             if (TINT_UNLIKELY(tex->Is<type::ExternalTexture>())) {
-                TINT_ICE(Writer, diagnostics_)
-                    << "Multiplanar external texture transform was not run.";
+                TINT_ICE() << "Multiplanar external texture transform was not run.";
                 return false;
             }
 
@@ -2660,7 +2653,7 @@
         default:
             break;
     }
-    TINT_ICE(Writer, diagnostics_) << "unhandled address space: " << sc;
+    TINT_ICE() << "unhandled address space: " << sc;
     return false;
 }
 
@@ -2703,8 +2696,8 @@
         if (is_host_shareable) {
             if (TINT_UNLIKELY(wgsl_offset < msl_offset)) {
                 // Unimplementable layout
-                TINT_ICE(Writer, diagnostics_) << "Structure member WGSL offset (" << wgsl_offset
-                                               << ") is behind MSL offset (" << msl_offset << ")";
+                TINT_ICE() << "Structure member WGSL offset (" << wgsl_offset
+                           << ") is behind MSL offset (" << msl_offset << ")";
                 return false;
             }
 
@@ -2739,7 +2732,7 @@
         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";
+                TINT_ICE() << "invalid entry point IO struct uses";
                 return false;
             }
 
@@ -2758,7 +2751,7 @@
                     out << " [[color(" + std::to_string(location.value()) + ")]]";
                 }
             } else {
-                TINT_ICE(Writer, diagnostics_) << "invalid use of location decoration";
+                TINT_ICE() << "invalid use of location decoration";
                 return false;
             }
         }
@@ -2783,8 +2776,8 @@
             // Calculate new MSL offset
             auto size_align = MslPackedTypeSizeAndAlign(diagnostics_, ty);
             if (TINT_UNLIKELY(msl_offset % size_align.align)) {
-                TINT_ICE(Writer, diagnostics_)
-                    << "Misaligned MSL structure member " << ty->FriendlyName() << " " << mem_name;
+                TINT_ICE() << "Misaligned MSL structure member " << ty->FriendlyName() << " "
+                           << mem_name;
                 return false;
             }
             msl_offset += size_align.size;
@@ -2891,7 +2884,7 @@
             out << "threadgroup ";
             break;
         default:
-            TINT_ICE(Writer, diagnostics_) << "unhandled variable address space";
+            TINT_ICE() << "unhandled variable address space";
             return false;
     }
 
@@ -2936,7 +2929,7 @@
             out << "threadgroup ";
             break;
         default:
-            TINT_ICE(Writer, diagnostics_) << "unhandled variable address space";
+            TINT_ICE() << "unhandled variable address space";
             return false;
     }
 
diff --git a/src/tint/lang/msl/writer/printer/printer.cc b/src/tint/lang/msl/writer/printer/printer.cc
index 3427bce..ea0e938 100644
--- a/src/tint/lang/msl/writer/printer/printer.cc
+++ b/src/tint/lang/msl/writer/printer/printer.cc
@@ -48,9 +48,9 @@
 }  // namespace
 
 // Helper for calling TINT_UNIMPLEMENTED() from a Switch(object_ptr) default case.
-#define UNHANDLED_CASE(object_ptr)           \
-    TINT_UNIMPLEMENTED(Writer, diagnostics_) \
-        << "unhandled case in Switch(): " << (object_ptr ? object_ptr->TypeInfo().name : "<null>")
+#define UNHANDLED_CASE(object_ptr)                         \
+    TINT_UNIMPLEMENTED() << "unhandled case in Switch(): " \
+                         << (object_ptr ? object_ptr->TypeInfo().name : "<null>")
 
 Printer::Printer(ir::Module* module) : ir_(module) {}
 
@@ -149,7 +149,7 @@
             out << "constant";
             break;
         default:
-            TINT_ICE(Writer, diagnostics_) << "unhandled address space: " << sc;
+            TINT_ICE() << "unhandled address space: " << sc;
             break;
     }
 }
@@ -198,7 +198,7 @@
         out << "atomic_uint";
         return;
     }
-    TINT_ICE(Writer, diagnostics_) << "unhandled atomic type " << atomic->Type()->FriendlyName();
+    TINT_ICE();
 }
 
 void Printer::EmitArrayType(StringStream& out, const type::Array* arr) {
@@ -233,7 +233,7 @@
 
 void Printer::EmitTextureType(StringStream& out, const type::Texture* tex) {
     if (TINT_UNLIKELY(tex->Is<type::ExternalTexture>())) {
-        TINT_ICE(Writer, diagnostics_) << "Multiplanar external texture transform was not run.";
+        TINT_ICE() << "Multiplanar external texture transform was not run.";
         return;
     }
 
@@ -346,8 +346,8 @@
         if (is_host_shareable) {
             if (TINT_UNLIKELY(ir_offset < msl_offset)) {
                 // Unimplementable layout
-                TINT_ICE(Writer, diagnostics_) << "Structure member offset (" << ir_offset
-                                               << ") is behind MSL offset (" << msl_offset << ")";
+                TINT_ICE() << "Structure member offset (" << ir_offset << ") is behind MSL offset ("
+                           << msl_offset << ")";
                 return;
             }
 
@@ -380,7 +380,7 @@
         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";
+                TINT_ICE() << "invalid entry point IO struct uses";
                 return;
             }
 
@@ -394,7 +394,7 @@
                            pipeline_stage_uses.count(type::PipelineStageUsage::kFragmentOutput))) {
                 out << " [[color(" + std::to_string(location.value()) + ")]]";
             } else {
-                TINT_ICE(Writer, diagnostics_) << "invalid use of location decoration";
+                TINT_ICE() << "invalid use of location decoration";
                 return;
             }
         }
@@ -419,9 +419,9 @@
             // Calculate new MSL offset
             auto size_align = MslPackedTypeSizeAndAlign(diagnostics_, ty);
             if (TINT_UNLIKELY(msl_offset % size_align.align)) {
-                TINT_ICE(Writer, diagnostics_)
-                    << "Misaligned MSL structure member " << mem_name << " : " << ty->FriendlyName()
-                    << " offset: " << msl_offset << " align: " << size_align.align;
+                TINT_ICE() << "Misaligned MSL structure member " << mem_name << " : "
+                           << ty->FriendlyName() << " offset: " << msl_offset
+                           << " align: " << size_align.align;
                 return;
             }
             msl_offset += size_align.size;
diff --git a/src/tint/lang/msl/writer/printer_support.cc b/src/tint/lang/msl/writer/printer_support.cc
index b664b57..6c5ea87 100644
--- a/src/tint/lang/msl/writer/printer_support.cc
+++ b/src/tint/lang/msl/writer/printer_support.cc
@@ -26,7 +26,7 @@
 #include "src/tint/lang/core/type/struct.h"
 #include "src/tint/lang/core/type/u32.h"
 #include "src/tint/lang/core/type/vector.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/rtti/switch.h"
 #include "src/tint/utils/text/float_to_string.h"
 
@@ -134,8 +134,7 @@
                     return SizeAndAlign{num_els * el_size_align.size, num_els * el_size_align.size};
                 }
             }
-            TINT_UNREACHABLE(Writer, diagnostics)
-                << "Unhandled vector element type " << el_ty->TypeInfo().name;
+            TINT_UNREACHABLE() << "Unhandled vector element type " << el_ty->TypeInfo().name;
             return SizeAndAlign{};
         },
 
@@ -178,14 +177,13 @@
                 }
             }
 
-            TINT_UNREACHABLE(Writer, diagnostics)
-                << "Unhandled matrix element type " << el_ty->TypeInfo().name;
+            TINT_UNREACHABLE() << "Unhandled matrix element type " << el_ty->TypeInfo().name;
             return SizeAndAlign{};
         },
 
         [&](const type::Array* arr) {
             if (TINT_UNLIKELY(!arr->IsStrideImplicit())) {
-                TINT_ICE(Writer, diagnostics)
+                TINT_ICE()
                     << "arrays with explicit strides should not exist past the SPIR-V reader";
                 return SizeAndAlign{};
             }
@@ -211,7 +209,7 @@
         },
 
         [&](Default) {
-            TINT_UNREACHABLE(Writer, diagnostics) << "Unhandled type " << ty->TypeInfo().name;
+            TINT_UNREACHABLE() << "Unhandled type " << ty->TypeInfo().name;
             return SizeAndAlign{};
         });
 }
diff --git a/src/tint/lang/spirv/reader/ast_parser/ast_parser.cc b/src/tint/lang/spirv/reader/ast_parser/ast_parser.cc
index 80a2b3c..41276fe 100644
--- a/src/tint/lang/spirv/reader/ast_parser/ast_parser.cc
+++ b/src/tint/lang/spirv/reader/ast_parser/ast_parser.cc
@@ -882,8 +882,8 @@
             // Reuse the inner implementation owned by the first entry point.
             inner_implementation_name = where->second[0].inner_name;
         }
-        TINT_ASSERT(Reader, !inner_implementation_name.empty());
-        TINT_ASSERT(Reader, ep_name != inner_implementation_name);
+        TINT_ASSERT(!inner_implementation_name.empty());
+        TINT_ASSERT(ep_name != inner_implementation_name);
 
         UniqueVector<uint32_t, 8> inputs;
         UniqueVector<uint32_t, 8> outputs;
@@ -1490,7 +1490,7 @@
                               << var.type_id();
             }
         }
-        TINT_ASSERT(Reader, ast_store_type != nullptr);
+        TINT_ASSERT(ast_store_type != nullptr);
 
         const ast::Expression* ast_initializer = nullptr;
         if (var.NumInOperands() > 1) {
@@ -1771,7 +1771,7 @@
     builtin::InterpolationSampling sampling = builtin::InterpolationSampling::kUndefined;
 
     for (const auto& deco : decorations) {
-        TINT_ASSERT(Reader, deco.size() > 0);
+        TINT_ASSERT(deco.size() > 0);
         switch (static_cast<spv::Decoration>(deco[0])) {
             case spv::Decoration::Location:
                 if (deco.size() != 2) {
diff --git a/src/tint/lang/spirv/reader/ast_parser/function.cc b/src/tint/lang/spirv/reader/ast_parser/function.cc
index ad14013..e18b4ba 100644
--- a/src/tint/lang/spirv/reader/ast_parser/function.cc
+++ b/src/tint/lang/spirv/reader/ast_parser/function.cc
@@ -834,7 +834,7 @@
 FunctionEmitter::StatementBlock::~StatementBlock() = default;
 
 void FunctionEmitter::StatementBlock::Finalize(ProgramBuilder* pb) {
-    TINT_ASSERT(Reader, !finalized_ /* Finalize() must only be called once */);
+    TINT_ASSERT(!finalized_ /* Finalize() must only be called once */);
 
     for (size_t i = 0; i < statements_.Length(); i++) {
         if (auto* sb = statements_[i]->As<StatementBuilder>()) {
@@ -850,7 +850,7 @@
 }
 
 void FunctionEmitter::StatementBlock::Add(const ast::Statement* statement) {
-    TINT_ASSERT(Reader, !finalized_ /* Add() must not be called after Finalize() */);
+    TINT_ASSERT(!finalized_ /* Add() must not be called after Finalize() */);
     statements_.Push(statement);
 }
 
@@ -861,8 +861,8 @@
 }
 
 void FunctionEmitter::PushGuard(const std::string& guard_name, uint32_t end_id) {
-    TINT_ASSERT(Reader, !statements_stack_.IsEmpty());
-    TINT_ASSERT(Reader, !guard_name.empty());
+    TINT_ASSERT(!statements_stack_.IsEmpty());
+    TINT_ASSERT(!guard_name.empty());
     // Guard control flow by the guard variable.  Introduce a new
     // if-selection with a then-clause ending at the same block
     // as the statement block at the top of the stack.
@@ -877,7 +877,7 @@
 }
 
 void FunctionEmitter::PushTrueGuard(uint32_t end_id) {
-    TINT_ASSERT(Reader, !statements_stack_.IsEmpty());
+    TINT_ASSERT(!statements_stack_.IsEmpty());
     const auto& top = statements_stack_.Back();
 
     auto* cond = MakeTrue(Source{});
@@ -889,14 +889,14 @@
 }
 
 FunctionEmitter::StatementList FunctionEmitter::ast_body() {
-    TINT_ASSERT(Reader, !statements_stack_.IsEmpty());
+    TINT_ASSERT(!statements_stack_.IsEmpty());
     auto& entry = statements_stack_[0];
     entry.Finalize(&builder_);
     return entry.GetStatements();
 }
 
 const ast::Statement* FunctionEmitter::AddStatement(const ast::Statement* statement) {
-    TINT_ASSERT(Reader, !statements_stack_.IsEmpty());
+    TINT_ASSERT(!statements_stack_.IsEmpty());
     if (statement != nullptr) {
         statements_stack_.Back().Add(statement);
     }
@@ -904,9 +904,9 @@
 }
 
 const ast::Statement* FunctionEmitter::LastStatement() {
-    TINT_ASSERT(Reader, !statements_stack_.IsEmpty());
+    TINT_ASSERT(!statements_stack_.IsEmpty());
     auto& statement_list = statements_stack_.Back().GetStatements();
-    TINT_ASSERT(Reader, !statement_list.IsEmpty());
+    TINT_ASSERT(!statement_list.IsEmpty());
     return statement_list.Back();
 }
 
@@ -928,7 +928,7 @@
 
     bool make_body_function = true;
     if (ep_info_) {
-        TINT_ASSERT(Reader, !ep_info_->inner_name.empty());
+        TINT_ASSERT(!ep_info_->inner_name.empty());
         if (ep_info_->owns_inner_implementation) {
             // This is an entry point, and we want to emit it as a wrapper around
             // an implementation function.
@@ -958,7 +958,7 @@
 }
 
 const ast::BlockStatement* FunctionEmitter::MakeFunctionBody() {
-    TINT_ASSERT(Reader, statements_stack_.Length() == 1);
+    TINT_ASSERT(statements_stack_.Length() == 1);
 
     if (!EmitBody()) {
         return nullptr;
@@ -1250,8 +1250,8 @@
     // have already been created.
     for (uint32_t var_id : ep_info_->inputs) {
         const auto* var = def_use_mgr_->GetDef(var_id);
-        TINT_ASSERT(Reader, var != nullptr);
-        TINT_ASSERT(Reader, opcode(var) == spv::Op::OpVariable);
+        TINT_ASSERT(var != nullptr);
+        TINT_ASSERT(opcode(var) == spv::Op::OpVariable);
         auto* store_type = GetVariableStoreType(*var);
         auto* forced_param_type = store_type;
         Attributes param_attrs;
@@ -1275,7 +1275,7 @@
             // In Vulkan SPIR-V, the sample mask is an array. In WGSL it's a scalar.
             // Use the first element only.
             auto* sample_mask_array_type = store_type->UnwrapRef()->UnwrapAlias()->As<Array>();
-            TINT_ASSERT(Reader, sample_mask_array_type);
+            TINT_ASSERT(sample_mask_array_type);
             ok = EmitPipelineInput(var_name, store_type, {0}, sample_mask_array_type->type,
                                    forced_param_type, param_attrs, decl.params, stmts);
         } else {
@@ -1323,8 +1323,8 @@
 
             } else {
                 const auto* var = def_use_mgr_->GetDef(var_id);
-                TINT_ASSERT(Reader, var != nullptr);
-                TINT_ASSERT(Reader, opcode(var) == spv::Op::OpVariable);
+                TINT_ASSERT(var != nullptr);
+                TINT_ASSERT(opcode(var) == spv::Op::OpVariable);
                 const Type* store_type = GetVariableStoreType(*var);
                 const Type* forced_member_type = store_type;
                 Attributes out_attrs;
@@ -1345,7 +1345,7 @@
                     // scalar. Use the first element only.
                     auto* sample_mask_array_type =
                         store_type->UnwrapRef()->UnwrapAlias()->As<Array>();
-                    TINT_ASSERT(Reader, sample_mask_array_type);
+                    TINT_ASSERT(sample_mask_array_type);
                     ok = EmitPipelineOutput(var_name, store_type, {0}, sample_mask_array_type->type,
                                             forced_member_type, out_attrs, return_members,
                                             return_exprs);
@@ -1421,7 +1421,7 @@
     function_.ForEachParam([this, &ast_params](const spvtools::opt::Instruction* param) {
         // Valid SPIR-V requires function call parameters to be non-null
         // instructions.
-        TINT_ASSERT(Reader, param != nullptr);
+        TINT_ASSERT(param != nullptr);
         const Type* const type = IsHandleObj(*param)
                                      ? parser_impl_.GetHandleTypeForSpirvHandle(*param)
                                      : parser_impl_.ConvertType(param->type_id());
@@ -1449,9 +1449,9 @@
 }
 
 bool FunctionEmitter::IsHandleObj(const spvtools::opt::Instruction& obj) {
-    TINT_ASSERT(Reader, obj.type_id() != 0u);
+    TINT_ASSERT(obj.type_id() != 0u);
     auto* spirv_type = type_mgr_->GetType(obj.type_id());
-    TINT_ASSERT(Reader, spirv_type);
+    TINT_ASSERT(spirv_type);
     return spirv_type->AsImage() || spirv_type->AsSampler() ||
            (spirv_type->AsPointer() &&
             (static_cast<spv::StorageClass>(spirv_type->AsPointer()->storage_class()) ==
@@ -1765,7 +1765,7 @@
     //      block. Also mark the the most recent continue target for which we
     //      haven't reached the backedge block.
 
-    TINT_ASSERT(Reader, block_order_.size() > 0);
+    TINT_ASSERT(block_order_.size() > 0);
     constructs_.Clear();
     const auto entry_id = block_order_[0];
 
@@ -1785,8 +1785,8 @@
         // A loop construct is added right after its associated continue construct.
         // In that case, adjust the parent up.
         if (k == Construct::kLoop) {
-            TINT_ASSERT(Reader, parent);
-            TINT_ASSERT(Reader, parent->kind == Construct::kContinue);
+            TINT_ASSERT(parent);
+            TINT_ASSERT(parent->kind == Construct::kContinue);
             scope_end_pos = parent->end_pos;
             parent = parent->parent;
         }
@@ -1804,9 +1804,9 @@
 
     for (uint32_t i = 0; i < block_order_.size(); ++i) {
         const auto block_id = block_order_[i];
-        TINT_ASSERT(Reader, block_id > 0);
+        TINT_ASSERT(block_id > 0);
         auto* block_info = GetBlockInfo(block_id);
-        TINT_ASSERT(Reader, block_info);
+        TINT_ASSERT(block_info);
 
         if (enclosing.IsEmpty()) {
             return Fail() << "internal error: too many merge blocks before block " << block_id;
@@ -1875,7 +1875,7 @@
             }
         }
 
-        TINT_ASSERT(Reader, top);
+        TINT_ASSERT(top);
         block_info->construct = top;
     }
 
@@ -2076,9 +2076,9 @@
     //    NEC(S) is the parent of NEC(T).
 
     for (const auto src : block_order_) {
-        TINT_ASSERT(Reader, src > 0);
+        TINT_ASSERT(src > 0);
         auto* src_info = GetBlockInfo(src);
-        TINT_ASSERT(Reader, src_info);
+        TINT_ASSERT(src_info);
         const auto src_pos = src_info->pos;
         const auto& src_construct = *(src_info->construct);
 
@@ -2115,7 +2115,7 @@
         for (const auto dest : successors) {
             const auto* dest_info = GetBlockInfo(dest);
             // We've already checked terminators are valid.
-            TINT_ASSERT(Reader, dest_info);
+            TINT_ASSERT(dest_info);
             const auto dest_pos = dest_info->pos;
 
             // Insert the edge kind entry and keep a handle to update
@@ -2139,7 +2139,7 @@
                                   << src_construct.begin_id << " (violates post-dominance rule)";
                 }
                 const auto* ct_info = GetBlockInfo(continue_construct->begin_id);
-                TINT_ASSERT(Reader, ct_info);
+                TINT_ASSERT(ct_info);
                 if (ct_info->header_for_continue != dest) {
                     return Fail() << "Invalid backedge (" << src << "->" << dest
                                   << "): does not branch to the corresponding loop header, "
@@ -2422,7 +2422,7 @@
             // The first clause might be a then-clause or an else-clause.
             const auto second_head = std::max(true_head_pos, false_head_pos);
             const auto end_first_clause_pos = second_head - 1;
-            TINT_ASSERT(Reader, end_first_clause_pos < block_order_.size());
+            TINT_ASSERT(end_first_clause_pos < block_order_.size());
             const auto end_first_clause = block_order_[end_first_clause_pos];
             uint32_t premerge_id = 0;
             uint32_t if_break_id = 0;
@@ -2542,7 +2542,7 @@
         case SkipReason::kSinkPointerIntoUse: {
             // Replace the pointer with its source reference expression.
             auto source_expr = GetDefInfo(id)->sink_pointer_source_expr;
-            TINT_ASSERT(Reader, source_expr.type->Is<Reference>());
+            TINT_ASSERT(source_expr.type->Is<Reference>());
             return source_expr;
         }
         case SkipReason::kPointSizeBuiltinValue: {
@@ -2631,15 +2631,15 @@
 
     // Upon entry, the statement stack has one entry representing the whole
     // function.
-    TINT_ASSERT(Reader, !constructs_.IsEmpty());
+    TINT_ASSERT(!constructs_.IsEmpty());
     Construct* function_construct = constructs_[0].get();
-    TINT_ASSERT(Reader, function_construct != nullptr);
-    TINT_ASSERT(Reader, function_construct->kind == Construct::kFunction);
+    TINT_ASSERT(function_construct != nullptr);
+    TINT_ASSERT(function_construct->kind == Construct::kFunction);
     // Make the first entry valid by filling in the construct field, which
     // had not been computed at the time the entry was first created.
     // TODO(dneto): refactor how the first construct is created vs.
     // this statements stack entry is populated.
-    TINT_ASSERT(Reader, statements_stack_.Length() == 1);
+    TINT_ASSERT(statements_stack_.Length() == 1);
     statements_stack_[0].SetConstruct(function_construct);
 
     for (auto block_id : block_order()) {
@@ -2833,8 +2833,8 @@
 bool FunctionEmitter::EmitIfStart(const BlockInfo& block_info) {
     // The block is the if-header block.  So its construct is the if construct.
     auto* construct = block_info.construct;
-    TINT_ASSERT(Reader, construct->kind == Construct::kIfSelection);
-    TINT_ASSERT(Reader, construct->begin_id == block_info.id);
+    TINT_ASSERT(construct->kind == Construct::kIfSelection);
+    TINT_ASSERT(construct->begin_id == block_info.id);
 
     const uint32_t true_head = block_info.true_head;
     const uint32_t false_head = block_info.false_head;
@@ -2968,8 +2968,8 @@
 bool FunctionEmitter::EmitSwitchStart(const BlockInfo& block_info) {
     // The block is the if-header block.  So its construct is the if construct.
     auto* construct = block_info.construct;
-    TINT_ASSERT(Reader, construct->kind == Construct::kSwitchSelection);
-    TINT_ASSERT(Reader, construct->begin_id == block_info.id);
+    TINT_ASSERT(construct->kind == Construct::kSwitchSelection);
+    TINT_ASSERT(construct->begin_id == block_info.id);
     const auto* branch = block_info.basic_block->terminator();
 
     const auto selector_id = branch->GetSingleWordInOperand(0);
@@ -3016,7 +3016,7 @@
             clause_heads[w] = clause_heads[r];
         }
         // We know it's not empty because it always has at least a default clause.
-        TINT_ASSERT(Reader, !clause_heads.IsEmpty());
+        TINT_ASSERT(!clause_heads.IsEmpty());
         clause_heads.Resize(w + 1);
     }
 
@@ -3054,7 +3054,7 @@
             // Generate a default selector
             selectors.Push(create<ast::CaseSelector>(Source{}));
         }
-        TINT_ASSERT(Reader, !selectors.IsEmpty());
+        TINT_ASSERT(!selectors.IsEmpty());
 
         // Where does this clause end?
         const auto end_id =
@@ -3178,8 +3178,8 @@
                 block_info.construct && block_info.construct->kind == Construct::Kind::kContinue) {
                 auto* header = GetBlockInfo(block_info.construct->begin_id);
 
-                TINT_ASSERT(Reader, header->construct &&
-                                        header->construct->kind == Construct::Kind::kContinue);
+                TINT_ASSERT(header->construct &&
+                            header->construct->kind == Construct::Kind::kContinue);
                 if (!header->is_continue_entire_loop) {
                     needs_break_if = true;
                 }
@@ -3249,9 +3249,9 @@
         case EdgeKind::kSwitchBreak: {
             // Don't bother with a break at the end of a case/default clause.
             const auto header = dest_info.header_for_merge;
-            TINT_ASSERT(Reader, header != 0);
+            TINT_ASSERT(header != 0);
             const auto* exiting_construct = GetBlockInfo(header)->construct;
-            TINT_ASSERT(Reader, exiting_construct->kind == Construct::kSwitchSelection);
+            TINT_ASSERT(exiting_construct->kind == Construct::kSwitchSelection);
             const auto candidate_next_case_pos = src_info.pos + 1;
             // Leaving the last block from the last case?
             if (candidate_next_case_pos == dest_info.pos) {
@@ -3349,7 +3349,7 @@
     // Emit declarations of hoisted variables, in index order.
     for (auto id : sorted_by_index(block_info.hoisted_ids)) {
         const auto* def_inst = def_use_mgr_->GetDef(id);
-        TINT_ASSERT(Reader, def_inst);
+        TINT_ASSERT(def_inst);
         // Compute the store type.  Pointers are not storable, so there is
         // no need to remap pointer properties.
         auto* store_type = parser_impl_.ConvertType(def_inst->type_id());
@@ -3514,7 +3514,7 @@
         if (combinatorial_expr.expr != nullptr) {
             // If the expression is combinatorial, then it's not a direct access
             // of a builtin variable.
-            TINT_ASSERT(Reader, def_info->local.has_value());
+            TINT_ASSERT(def_info->local.has_value());
             if (def_info->requires_hoisted_var_def || def_info->requires_named_let_def ||
                 def_info->local->num_uses != 1) {
                 // Generate a const definition or an assignment to a hoisted definition
@@ -3595,7 +3595,7 @@
                     if (auto* arr = lhs.type->As<Array>()) {
                         lhs.type = arr->type;
                     }
-                    TINT_ASSERT(Reader, lhs.type);
+                    TINT_ASSERT(lhs.type);
                     break;
                 default:
                     break;
@@ -3994,7 +3994,7 @@
         switch (ext_opcode) {
             case GLSLstd450Determinant: {
                 auto m = MakeOperand(inst, 2);
-                TINT_ASSERT(Reader, m.type->Is<Matrix>());
+                TINT_ASSERT(m.type->Is<Matrix>());
                 return {ty_.F32(), builder_.Call("determinant", m.expr)};
             }
 
@@ -4012,9 +4012,9 @@
                 auto normal = MakeOperand(inst, 2);
                 auto incident = MakeOperand(inst, 3);
                 auto nref = MakeOperand(inst, 4);
-                TINT_ASSERT(Reader, normal.type->Is<F32>());
-                TINT_ASSERT(Reader, incident.type->Is<F32>());
-                TINT_ASSERT(Reader, nref.type->Is<F32>());
+                TINT_ASSERT(normal.type->Is<F32>());
+                TINT_ASSERT(incident.type->Is<F32>());
+                TINT_ASSERT(nref.type->Is<F32>());
                 return {
                     ty_.F32(),
                     builder_.Call(
@@ -4034,8 +4034,8 @@
                 // Compute  Incident - 2 * Normal * Normal * Incident
                 auto incident = MakeOperand(inst, 2);
                 auto normal = MakeOperand(inst, 3);
-                TINT_ASSERT(Reader, incident.type->Is<F32>());
-                TINT_ASSERT(Reader, normal.type->Is<F32>());
+                TINT_ASSERT(incident.type->Is<F32>());
+                TINT_ASSERT(normal.type->Is<F32>());
                 return {
                     ty_.F32(),
                     builder_.Sub(
@@ -4051,9 +4051,9 @@
                 auto incident = MakeOperand(inst, 2);
                 auto normal = MakeOperand(inst, 3);
                 auto eta = MakeOperand(inst, 4);
-                TINT_ASSERT(Reader, incident.type->Is<F32>());
-                TINT_ASSERT(Reader, normal.type->Is<F32>());
-                TINT_ASSERT(Reader, eta.type->Is<F32>());
+                TINT_ASSERT(incident.type->Is<F32>());
+                TINT_ASSERT(normal.type->Is<F32>());
+                TINT_ASSERT(eta.type->Is<F32>());
                 if (!success()) {
                     return {};
                 }
@@ -4111,8 +4111,8 @@
     const spvtools::opt::Instruction& inst) {
     auto mat = MakeOperand(inst, 2);
     auto* mat_ty = mat.type->As<Matrix>();
-    TINT_ASSERT(Reader, mat_ty);
-    TINT_ASSERT(Reader, mat_ty->columns == mat_ty->rows);
+    TINT_ASSERT(mat_ty);
+    TINT_ASSERT(mat_ty->columns == mat_ty->rows);
     auto& pb = builder_;
 
     auto idx = [&](size_t row, size_t col) {
@@ -4530,7 +4530,7 @@
         }
         const auto pointer_type_id = type_mgr_->FindPointerToType(pointee_type_id, address_space);
         auto* type = parser_impl_.ConvertType(pointer_type_id, PtrAs::Ref);
-        TINT_ASSERT(Reader, type && type->Is<Reference>());
+        TINT_ASSERT(type && type->Is<Reference>());
         current_expr = TypedExpression{type, next_expr};
     }
 
@@ -4712,7 +4712,7 @@
     // Helper to get the name for the component index `i`.
     auto component_name = [](uint32_t i) {
         constexpr const char* names[] = {"x", "y", "z", "w"};
-        TINT_ASSERT(Reader, i < 4);
+        TINT_ASSERT(i < 4);
         return names[i];
     };
 
@@ -4732,7 +4732,7 @@
         } else if (index < vec0_len + vec1_len) {
             vec_id = vec1_id;
             index -= vec0_len;
-            TINT_ASSERT(Reader, index < kMaxVectorLen);
+            TINT_ASSERT(index < kMaxVectorLen);
         } else if (index == 0xFFFFFFFF) {
             // By rule, this maps to OpUndef. Instead, take the first component of the first vector.
             vec_id = vec0_id;
@@ -4905,7 +4905,7 @@
             default:
                 break;
         }
-        TINT_ASSERT(Reader, false && "expected a memory object declaration");
+        TINT_UNREACHABLE() << "expected a memory object declaration";
         return {};
     };
 
@@ -4929,7 +4929,7 @@
         return info->pointer;
     }
     const auto* inst = def_use_mgr_->GetDef(id);
-    TINT_ASSERT(Reader, inst);
+    TINT_ASSERT(inst);
     return get_from_root_identifier(*inst);
 }
 
@@ -5151,7 +5151,7 @@
 
 const Construct* FunctionEmitter::GetEnclosingScope(uint32_t first_pos, uint32_t last_pos) const {
     const auto* enclosing_construct = GetBlockInfo(block_order_[first_pos])->construct;
-    TINT_ASSERT(Reader, enclosing_construct != nullptr);
+    TINT_ASSERT(enclosing_construct != nullptr);
     // Constructs are strictly nesting, so follow parent pointers
     while (enclosing_construct && !enclosing_construct->ScopeContainsPos(last_pos)) {
         // The scope of a continue construct is enclosed in its associated loop
@@ -5161,7 +5161,7 @@
         enclosing_construct = sibling_loop ? sibling_loop : enclosing_construct->parent;
     }
     // At worst, we go all the way out to the function construct.
-    TINT_ASSERT(Reader, enclosing_construct != nullptr);
+    TINT_ASSERT(enclosing_construct != nullptr);
     return enclosing_construct;
 }
 
@@ -5420,7 +5420,7 @@
         Fail();
         return {};
     }
-    TINT_ASSERT(Reader, type != nullptr);
+    TINT_ASSERT(type != nullptr);
     if (auto* result = type->UnwrapAll()->As<Texture>()) {
         return result;
     }
@@ -6095,9 +6095,9 @@
 
     // The texel type is always a 4-element vector.
     const uint32_t dest_count = 4u;
-    TINT_ASSERT(Reader, dest_type->Is<Vector>() && dest_type->As<Vector>()->size == dest_count);
-    TINT_ASSERT(Reader, dest_type->IsFloatVector() || dest_type->IsUnsignedIntegerVector() ||
-                            dest_type->IsSignedIntegerVector());
+    TINT_ASSERT(dest_type->Is<Vector>() && dest_type->As<Vector>()->size == dest_count);
+    TINT_ASSERT(dest_type->IsFloatVector() || dest_type->IsUnsignedIntegerVector() ||
+                dest_type->IsSignedIntegerVector());
 
     if (src_type == dest_type) {
         return texel.expr;
@@ -6115,7 +6115,7 @@
     }
 
     const auto required_count = parser_impl_.GetChannelCountForFormat(format);
-    TINT_ASSERT(Reader, 0 < required_count && required_count <= 4);
+    TINT_ASSERT(0 < required_count && required_count <= 4);
 
     const uint32_t src_count = src_type->IsScalar() ? 1 : src_type->As<Vector>()->size;
     if (src_count < required_count) {
diff --git a/src/tint/lang/spirv/reader/ast_parser/function.h b/src/tint/lang/spirv/reader/ast_parser/function.h
index 91544ab..29ad3da 100644
--- a/src/tint/lang/spirv/reader/ast_parser/function.h
+++ b/src/tint/lang/spirv/reader/ast_parser/function.h
@@ -1159,7 +1159,7 @@
     /// @return the built StatementBuilder
     template <typename T, typename... ARGS>
     T* AddStatementBuilder(ARGS&&... args) {
-        TINT_ASSERT(Reader, !statements_stack_.IsEmpty());
+        TINT_ASSERT(!statements_stack_.IsEmpty());
         return statements_stack_.Back().AddStatementBuilder<T>(std::forward<ARGS>(args)...);
     }
 
diff --git a/src/tint/lang/spirv/reader/ast_parser/namer.cc b/src/tint/lang/spirv/reader/ast_parser/namer.cc
index e48bc65..38581b5 100644
--- a/src/tint/lang/spirv/reader/ast_parser/namer.cc
+++ b/src/tint/lang/spirv/reader/ast_parser/namer.cc
@@ -18,7 +18,7 @@
 #include <unordered_set>
 
 #include "src/tint/lang/core/builtin/function.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/text/string_stream.h"
 
 namespace tint::spirv::reader {
@@ -234,14 +234,14 @@
         }
         i++;
     }
-    TINT_ASSERT(Reader, false /* FindUnusedDerivedName() overflowed u32 */);
+    TINT_UNREACHABLE() << "FindUnusedDerivedName() overflowed u32";
     return "<u32 overflow>";
 }
 
 std::string Namer::MakeDerivedName(const std::string& base_name) {
     auto result = FindUnusedDerivedName(base_name);
     const bool registered = RegisterWithoutId(result);
-    TINT_ASSERT(Reader, registered);
+    TINT_ASSERT(registered);
     return result;
 }
 
diff --git a/src/tint/lang/spirv/writer/ast_printer/builder.cc b/src/tint/lang/spirv/writer/ast_printer/builder.cc
index f317a93..4eadf19 100644
--- a/src/tint/lang/spirv/writer/ast_printer/builder.cc
+++ b/src/tint/lang/spirv/writer/ast_printer/builder.cc
@@ -301,8 +301,7 @@
 uint32_t Builder::LookupVariableID(const sem::Variable* var) {
     auto it = var_to_id_.find(var);
     if (it == var_to_id_.end()) {
-        TINT_ICE(Writer, builder_.Diagnostics())
-            << "unable to find ID for variable: " + var->Declaration()->name->symbol.Name();
+        TINT_ICE() << "unable to find ID for variable: " + var->Declaration()->name->symbol.Name();
         return 0;
     }
     return it->second;
@@ -376,7 +375,7 @@
 
 bool Builder::GenerateBreakStatement(const ast::BreakStatement*) {
     if (merge_stack_.empty()) {
-        TINT_ICE(Writer, builder_.Diagnostics()) << "Attempted to break without a merge block";
+        TINT_ICE() << "Attempted to break without a merge block";
         return false;
     }
     if (!push_function_inst(spv::Op::OpBranch, {Operand(merge_stack_.back())})) {
@@ -386,7 +385,7 @@
 }
 
 bool Builder::GenerateBreakIfStatement(const ast::BreakIfStatement* stmt) {
-    TINT_ASSERT(Writer, !backedge_stack_.empty());
+    TINT_ASSERT(!backedge_stack_.empty());
     const auto cond_id = GenerateExpression(stmt->condition);
     if (!cond_id) {
         return false;
@@ -400,8 +399,7 @@
 
 bool Builder::GenerateContinueStatement(const ast::ContinueStatement*) {
     if (continue_stack_.empty()) {
-        TINT_ICE(Writer, builder_.Diagnostics())
-            << "Attempted to continue without a continue block";
+        TINT_ICE() << "Attempted to continue without a continue block";
         return false;
     }
     if (!push_function_inst(spv::Op::OpBranch, {Operand(continue_stack_.back())})) {
@@ -423,7 +421,7 @@
 bool Builder::GenerateEntryPoint(const ast::Function* func, uint32_t id) {
     auto stage = pipeline_stage_to_execution_model(func->PipelineStage());
     if (stage == SpvExecutionModelMax) {
-        TINT_ICE(Writer, builder_.Diagnostics()) << "Unknown pipeline stage provided";
+        TINT_ICE() << "Unknown pipeline stage provided";
         return false;
     }
 
@@ -440,8 +438,8 @@
 
         uint32_t var_id = LookupVariableID(var);
         if (var_id == 0) {
-            TINT_ICE(Writer, builder_.Diagnostics()) << "unable to find ID for global variable: " +
-                                                            var->Declaration()->name->symbol.Name();
+            TINT_ICE() << "unable to find ID for global variable: " +
+                              var->Declaration()->name->symbol.Name();
             return false;
         }
 
@@ -464,7 +462,7 @@
 
         // Check if the workgroup_size uses pipeline-overridable constants.
         if (!wgsize[0].has_value() || !wgsize[1].has_value() || !wgsize[2].has_value()) {
-            TINT_ICE(Writer, builder_.Diagnostics())
+            TINT_ICE()
                 << "override-expressions should have been removed with the SubstituteOverride "
                    "transform";
             return false;
@@ -509,8 +507,7 @@
         [&](const ast::LiteralExpression* l) { return GenerateLiteralIfNeeded(l); },
         [&](const ast::UnaryOpExpression* u) { return GenerateUnaryOpExpression(u); },
         [&](Default) {
-            TINT_ICE(Writer, builder_.Diagnostics())
-                << "unknown expression type: " + std::string(expr->TypeInfo().name);
+            TINT_ICE() << "unknown expression type: " + std::string(expr->TypeInfo().name);
             return 0;
         });
 }
@@ -642,7 +639,7 @@
 
     if (v->Is<ast::Let>()) {
         if (!v->initializer) {
-            TINT_ICE(Writer, builder_.Diagnostics()) << "missing initializer for let";
+            TINT_ICE() << "missing initializer for let";
             return false;
         }
         RegisterVariable(sem, init_id);
@@ -693,8 +690,7 @@
 
     auto* sem = builder_.Sem().Get<sem::GlobalVariable>(v);
     if (TINT_UNLIKELY(!sem)) {
-        TINT_ICE(Writer, builder_.Diagnostics())
-            << "attempted to generate a global from a non-global variable";
+        TINT_ICE() << "attempted to generate a global from a non-global variable";
         return false;
     }
     auto* type = sem->Type()->UnwrapRef();
@@ -829,7 +825,7 @@
                 return true;  // ignored
             },
             [&](Default) {
-                TINT_ICE(Writer, builder_.Diagnostics()) << "unknown attribute";
+                TINT_ICE() << "unknown attribute";
                 return false;
             });
         if (!ok) {
@@ -898,7 +894,7 @@
         return true;
     }
 
-    TINT_ICE(Writer, builder_.Diagnostics()) << "unsupported index accessor expression";
+    TINT_ICE() << "unsupported index accessor expression";
     return false;
 }
 
@@ -1020,8 +1016,7 @@
             return true;
         },
         [&](Default) {
-            TINT_ICE(Writer, builder_.Diagnostics())
-                << "unhandled member index type: " << expr_sem->TypeInfo().name;
+            TINT_ICE() << "unhandled member index type: " << expr_sem->TypeInfo().name;
             return false;
         });
 }
@@ -1069,8 +1064,7 @@
                 return GenerateMemberAccessor(member, &info);
             },
             [&](Default) {
-                TINT_ICE(Writer, builder_.Diagnostics())
-                    << "invalid accessor in list: " + std::string(accessor->TypeInfo().name);
+                TINT_ICE() << "invalid accessor in list: " + std::string(accessor->TypeInfo().name);
                 return false;
             });
         if (!ok) {
@@ -1108,8 +1102,8 @@
             return LookupVariableID(user->Variable());
         }
     }
-    TINT_ICE(Writer, builder_.Diagnostics())
-        << "identifier '" + expr->identifier->symbol.Name() + "' does not resolve to a variable";
+    TINT_ICE() << "identifier '" + expr->identifier->symbol.Name() +
+                      "' does not resolve to a variable";
     return 0;
 }
 
@@ -1203,13 +1197,13 @@
             return GenerateValueConstructorOrConversion(call, var);
         }
     }
-    TINT_ICE(Writer, builder_.Diagnostics()) << "unknown constructor expression";
+    TINT_ICE() << "unknown constructor expression";
     return 0;
 }
 
 bool Builder::IsConstructorConst(const ast::Expression* expr) {
     bool is_const = true;
-    ast::TraverseExpressions(expr, builder_.Diagnostics(), [&](const ast::Expression* e) {
+    ast::TraverseExpressions(expr, [&](const ast::Expression* e) {
         if (e->Is<ast::LiteralExpression>()) {
             return ast::TraverseAction::Descend;
         }
@@ -1366,7 +1360,7 @@
                 ops.push_back(Operand(extract_id));
             }
         } else {
-            TINT_ICE(Writer, builder_.Diagnostics()) << "Unhandled type cast value type";
+            TINT_ICE() << "Unhandled type cast value type";
             return 0;
         }
     }
@@ -1409,9 +1403,8 @@
     // This should not happen as we rely on constant folding to obviate
     // casts/conversions for module-scope variables
     if (TINT_UNLIKELY(is_global_init)) {
-        TINT_ICE(Writer, builder_.Diagnostics())
-            << "Module-level conversions are not supported. Conversions should "
-               "have already been constant-folded by the FoldConstants transform.";
+        TINT_ICE() << "Module-level conversions are not supported. Conversions should "
+                      "have already been constant-folded by the FoldConstants transform.";
         return 0;
     }
 
@@ -1506,8 +1499,7 @@
             zero_id = GenerateConstantIfNeeded(ScalarConstant::I32(0));
             one_id = GenerateConstantIfNeeded(ScalarConstant::I32(1));
         } else {
-            TINT_ICE(Writer, builder_.Diagnostics())
-                << "invalid destination type for bool conversion";
+            TINT_ICE() << "invalid destination type for bool conversion";
             return false;
         }
         if (auto* to_vec = to_type->As<type::Vector>()) {
@@ -1535,17 +1527,15 @@
         if (TINT_LIKELY(from_mat == to_mat)) {
             return val_id;
         }
-        TINT_ICE(Writer, builder_.Diagnostics())
-            << "matrix conversion is not supported and should have been handled by "
-               "VectorizeMatrixConversions";
+        TINT_ICE() << "matrix conversion is not supported and should have been handled by "
+                      "VectorizeMatrixConversions";
     } else {
-        TINT_ICE(Writer, builder_.Diagnostics()) << "Invalid from_type";
+        TINT_ICE() << "Invalid from_type";
     }
 
     if (op == spv::Op::OpNop) {
-        TINT_ICE(Writer, builder_.Diagnostics())
-            << "unable to determine conversion type for cast, from: " + from_type->FriendlyName() +
-                   " to: " + to_type->FriendlyName();
+        TINT_ICE() << "unable to determine conversion type for cast, from: " +
+                          from_type->FriendlyName() + " to: " + to_type->FriendlyName();
         return 0;
     }
 
@@ -1590,7 +1580,7 @@
                     return;
             }
         },
-        [&](Default) { TINT_ICE(Writer, builder_.Diagnostics()) << "unknown literal type"; });
+        [&](Default) { TINT_ICE() << "unknown literal type"; });
 
     if (has_error()) {
         return false;
@@ -1663,15 +1653,14 @@
         [&](const type::Array* a) {
             auto count = a->ConstantCount();
             if (!count) {
-                TINT_ICE(Writer, builder_.Diagnostics()) << type::Array::kErrExpectedConstantCount;
+                TINT_ICE() << type::Array::kErrExpectedConstantCount;
                 return static_cast<uint32_t>(0);
             }
             return composite(count.value());
         },
         [&](const type::Struct* s) { return composite(s->Members().Length()); },
         [&](Default) {
-            TINT_ICE(Writer, builder_.Diagnostics())
-                << "unhandled constant type: " + ty->FriendlyName();
+            TINT_ICE() << "unhandled constant type: " + ty->FriendlyName();
             return 0;
         });
 }
@@ -1982,8 +1971,7 @@
 
         // This should already have been validated by resolver
         if (lhs_mat->rows() != rhs_mat->rows() || lhs_mat->columns() != rhs_mat->columns()) {
-            TINT_ICE(Writer, builder_.Diagnostics())
-                << "matrices must have same dimensionality for add or subtract";
+            TINT_ICE() << "matrices must have same dimensionality for add or subtract";
             return 0;
         }
 
@@ -2028,7 +2016,7 @@
         } else if (lhs_is_bool_or_vec) {
             op = spv::Op::OpLogicalAnd;
         } else {
-            TINT_ICE(Writer, builder_.Diagnostics()) << "invalid and expression";
+            TINT_ICE() << "invalid and expression";
             return 0;
         }
     } else if (expr->IsAdd()) {
@@ -2049,7 +2037,7 @@
         } else if (lhs_is_integer_or_vec) {
             op = spv::Op::OpIEqual;
         } else {
-            TINT_ICE(Writer, builder_.Diagnostics()) << "invalid equal expression";
+            TINT_ICE() << "invalid equal expression";
             return 0;
         }
     } else if (expr->IsGreaterThan()) {
@@ -2129,7 +2117,7 @@
             // float matrix * matrix
             op = spv::Op::OpMatrixTimesMatrix;
         } else {
-            TINT_ICE(Writer, builder_.Diagnostics()) << "invalid multiply expression";
+            TINT_ICE() << "invalid multiply expression";
             return 0;
         }
     } else if (expr->IsNotEqual()) {
@@ -2140,7 +2128,7 @@
         } else if (lhs_is_integer_or_vec) {
             op = spv::Op::OpINotEqual;
         } else {
-            TINT_ICE(Writer, builder_.Diagnostics()) << "invalid not-equal expression";
+            TINT_ICE() << "invalid not-equal expression";
             return 0;
         }
     } else if (expr->IsOr()) {
@@ -2149,7 +2137,7 @@
         } else if (lhs_is_bool_or_vec) {
             op = spv::Op::OpLogicalOr;
         } else {
-            TINT_ICE(Writer, builder_.Diagnostics()) << "invalid and expression";
+            TINT_ICE() << "invalid and expression";
             return 0;
         }
     } else if (expr->IsShiftLeft()) {
@@ -2164,7 +2152,7 @@
     } else if (expr->IsXor()) {
         op = spv::Op::OpBitwiseXor;
     } else {
-        TINT_ICE(Writer, builder_.Diagnostics()) << "unknown binary expression";
+        TINT_ICE() << "unknown binary expression";
         return 0;
     }
 
@@ -2203,8 +2191,7 @@
             return GenerateValueConstructorOrConversion(call, nullptr);
         },
         [&](Default) {
-            TINT_ICE(Writer, builder_.Diagnostics())
-                << "unhandled call target: " << target->TypeInfo().name;
+            TINT_ICE() << "unhandled call target: " << target->TypeInfo().name;
             return 0;
         });
 }
@@ -2225,8 +2212,7 @@
 
     auto func_id = func_symbol_to_id_[ident->symbol];
     if (func_id == 0) {
-        TINT_ICE(Writer, builder_.Diagnostics())
-            << "unable to find called function: " + ident->symbol.Name();
+        TINT_ICE() << "unable to find called function: " + ident->symbol.Name();
         return 0;
     }
     ops.push_back(Operand(func_id));
@@ -2330,18 +2316,16 @@
         case builtin::Function::kArrayLength: {
             auto* address_of = call->Arguments()[0]->Declaration()->As<ast::UnaryOpExpression>();
             if (!address_of || address_of->op != ast::UnaryOp::kAddressOf) {
-                TINT_ICE(Writer, builder_.Diagnostics())
-                    << "arrayLength() expected pointer to member access, got " +
-                           std::string(address_of->TypeInfo().name);
+                TINT_ICE() << "arrayLength() expected pointer to member access, got " +
+                                  std::string(address_of->TypeInfo().name);
                 return 0;
             }
             auto* array_expr = address_of->expr;
 
             auto* accessor = array_expr->As<ast::MemberAccessorExpression>();
             if (!accessor) {
-                TINT_ICE(Writer, builder_.Diagnostics())
-                    << "arrayLength() expected pointer to member access, got pointer to " +
-                           std::string(array_expr->TypeInfo().name);
+                TINT_ICE() << "arrayLength() expected pointer to member access, got pointer to " +
+                                  std::string(array_expr->TypeInfo().name);
                 return 0;
             }
 
@@ -2353,8 +2337,8 @@
 
             auto* type = TypeOf(accessor->object)->UnwrapRef();
             if (!type->Is<type::Struct>()) {
-                TINT_ICE(Writer, builder_.Diagnostics())
-                    << "invalid type (" + type->FriendlyName() + ") for runtime array length";
+                TINT_ICE() << "invalid type (" + type->FriendlyName() +
+                                  ") for runtime array length";
                 return 0;
             }
             // Runtime array must be the last member in the structure
@@ -2551,8 +2535,7 @@
         default: {
             auto inst_id = builtin_to_glsl_method(builtin);
             if (inst_id == 0) {
-                TINT_ICE(Writer, builder_.Diagnostics())
-                    << "unknown method " + std::string(builtin->str());
+                TINT_ICE() << "unknown method " + std::string(builtin->str());
                 return 0;
             }
             glsl_std450(inst_id);
@@ -2561,8 +2544,7 @@
     }
 
     if (op == spv::Op::OpNop) {
-        TINT_ICE(Writer, builder_.Diagnostics())
-            << "unable to determine operator for: " + std::string(builtin->str());
+        TINT_ICE() << "unable to determine operator for: " + std::string(builtin->str());
         return 0;
     }
 
@@ -2603,15 +2585,14 @@
     auto gen_arg = [&](Usage usage) {
         auto* argument = arg(usage);
         if (TINT_UNLIKELY(!argument)) {
-            TINT_ICE(Writer, builder_.Diagnostics())
-                << "missing argument " << static_cast<int>(usage);
+            TINT_ICE() << "missing argument " << static_cast<int>(usage);
         }
         return gen(argument);
     };
 
     auto* texture = arg(Usage::kTexture);
     if (TINT_UNLIKELY(!texture)) {
-        TINT_ICE(Writer, builder_.Diagnostics()) << "missing texture argument";
+        TINT_ICE() << "missing texture argument";
     }
 
     auto* texture_type = texture->Type()->UnwrapRef()->As<type::Texture>();
@@ -2753,7 +2734,7 @@
             uint32_t spirv_dims = 0;
             switch (texture_type->dim()) {
                 case type::TextureDimension::kNone:
-                    TINT_ICE(Writer, builder_.Diagnostics()) << "texture dimension is kNone";
+                    TINT_ICE() << "texture dimension is kNone";
                     return false;
                 case type::TextureDimension::k1d:
                 case type::TextureDimension::k2d:
@@ -2790,7 +2771,7 @@
             uint32_t spirv_dims = 0;
             switch (texture_type->dim()) {
                 default:
-                    TINT_ICE(Writer, builder_.Diagnostics()) << "texture is not arrayed";
+                    TINT_ICE() << "texture is not arrayed";
                     return false;
                 case type::TextureDimension::k2dArray:
                 case type::TextureDimension::kCubeArray:
@@ -2958,7 +2939,7 @@
             break;
         }
         default:
-            TINT_UNREACHABLE(Writer, builder_.Diagnostics());
+            TINT_UNREACHABLE();
             return false;
     }
 
@@ -2980,8 +2961,7 @@
     }
 
     if (op == spv::Op::OpNop) {
-        TINT_ICE(Writer, builder_.Diagnostics())
-            << "unable to determine operator for: " + std::string(builtin->str());
+        TINT_ICE() << "unable to determine operator for: " + std::string(builtin->str());
         return false;
     }
 
@@ -3011,8 +2991,7 @@
         semantics = static_cast<uint32_t>(spv::MemorySemanticsMask::AcquireRelease) |
                     static_cast<uint32_t>(spv::MemorySemanticsMask::UniformMemory);
     } else {
-        TINT_ICE(Writer, builder_.Diagnostics())
-            << "unexpected barrier builtin type " << builtin::str(builtin->Type());
+        TINT_ICE() << "unexpected barrier builtin type " << builtin::str(builtin->Type());
         return false;
     }
 
@@ -3049,8 +3028,7 @@
                 ScalarConstant::U32(static_cast<uint32_t>(spv::Scope::Device)));
             break;
         default:
-            TINT_UNREACHABLE(Writer, builder_.Diagnostics())
-                << "unhandled atomic address space " << address_space;
+            TINT_UNREACHABLE() << "unhandled atomic address space " << address_space;
             return false;
     }
     if (memory_id == 0) {
@@ -3232,8 +3210,7 @@
                                                                      });
         }
         default:
-            TINT_UNREACHABLE(Writer, builder_.Diagnostics())
-                << "unhandled atomic builtin " << builtin->Type();
+            TINT_UNREACHABLE() << "unhandled atomic builtin " << builtin->Type();
             return false;
     }
 }
@@ -3555,7 +3532,7 @@
     }
 
     // Generate the backedge.
-    TINT_ASSERT(Writer, !backedge_stack_.empty());
+    TINT_ASSERT(!backedge_stack_.empty());
     const Backedge& backedge = backedge_stack_.back();
     if (!push_function_inst(backedge.opcode, backedge.operands)) {
         return false;
@@ -3586,8 +3563,7 @@
             return true;  // Not emitted
         },
         [&](Default) {
-            TINT_ICE(Writer, builder_.Diagnostics())
-                << "unknown statement type: " + std::string(stmt->TypeInfo().name);
+            TINT_ICE() << "unknown statement type: " + std::string(stmt->TypeInfo().name);
             return false;
         });
 }
@@ -3598,7 +3574,7 @@
 
 uint32_t Builder::GenerateTypeIfNeeded(const type::Type* type) {
     if (type == nullptr) {
-        TINT_ICE(Writer, builder_.Diagnostics()) << "attempting to generate type from null type";
+        TINT_ICE() << "attempting to generate type from null type";
         return 0;
     }
 
@@ -3714,8 +3690,7 @@
                 return true;
             },
             [&](Default) {
-                TINT_ICE(Writer, builder_.Diagnostics())
-                    << "unable to convert type: " + type->FriendlyName();
+                TINT_ICE() << "unable to convert type: " + type->FriendlyName();
                 return false;
             });
 
@@ -3729,8 +3704,7 @@
 
 bool Builder::GenerateTextureType(const type::Texture* texture, const Operand& result) {
     if (TINT_UNLIKELY(texture->Is<type::ExternalTexture>())) {
-        TINT_ICE(Writer, builder_.Diagnostics())
-            << "Multiplanar external texture transform was not run.";
+        TINT_ICE() << "Multiplanar external texture transform was not run.";
         return false;
     }
 
@@ -3819,7 +3793,7 @@
     } else {
         auto count = arr->ConstantCount();
         if (!count) {
-            TINT_ICE(Writer, builder_.Diagnostics()) << type::Array::kErrExpectedConstantCount;
+            TINT_ICE() << type::Array::kErrExpectedConstantCount;
             return static_cast<uint32_t>(0);
         }
 
@@ -3857,7 +3831,7 @@
 
     auto stg_class = ConvertAddressSpace(ptr->AddressSpace());
     if (stg_class == SpvStorageClassMax) {
-        TINT_ICE(Writer, builder_.Diagnostics()) << "invalid address space for pointer";
+        TINT_ICE() << "invalid address space for pointer";
         return false;
     }
 
@@ -3874,7 +3848,7 @@
 
     auto stg_class = ConvertAddressSpace(ref->AddressSpace());
     if (stg_class == SpvStorageClassMax) {
-        TINT_ICE(Writer, builder_.Diagnostics()) << "invalid address space for reference";
+        TINT_ICE() << "invalid address space for reference";
         return false;
     }
 
@@ -3991,7 +3965,7 @@
             } else if (TINT_LIKELY(storage == builtin::AddressSpace::kOut)) {
                 return SpvBuiltInPosition;
             } else {
-                TINT_ICE(Writer, builder_.Diagnostics()) << "invalid address space for builtin";
+                TINT_ICE() << "invalid address space for builtin";
                 break;
             }
         case builtin::BuiltinValue::kVertexIndex:
@@ -4058,8 +4032,7 @@
 SpvImageFormat Builder::convert_texel_format_to_spv(const builtin::TexelFormat format) {
     switch (format) {
         case builtin::TexelFormat::kBgra8Unorm:
-            TINT_ICE(Writer, builder_.Diagnostics())
-                << "bgra8unorm should have been polyfilled to rgba8unorm";
+            TINT_ICE() << "bgra8unorm should have been polyfilled to rgba8unorm";
             return SpvImageFormatUnknown;
         case builtin::TexelFormat::kR32Uint:
             return SpvImageFormatR32ui;
@@ -4107,7 +4080,7 @@
         StringStream ss;
         ss << "Internal error: trying to add SPIR-V instruction " << int(op)
            << " outside a function";
-        TINT_ICE(Writer, builder_.Diagnostics()) << ss.str();
+        TINT_ICE() << ss.str();
         return false;
     }
     current_function_.push_inst(op, operands);
@@ -4146,9 +4119,9 @@
                                         uint32_t loop_id,
                                         uint32_t break_id)
     : last_statement(the_last_statement), loop_header_id(loop_id), break_target_id(break_id) {
-    TINT_ASSERT(Writer, last_statement != nullptr);
-    TINT_ASSERT(Writer, loop_header_id != 0u);
-    TINT_ASSERT(Writer, break_target_id != 0u);
+    TINT_ASSERT(last_statement != nullptr);
+    TINT_ASSERT(loop_header_id != 0u);
+    TINT_ASSERT(break_target_id != 0u);
 }
 
 Builder::Backedge::Backedge(spv::Op the_opcode, OperandList the_operands)
diff --git a/src/tint/lang/spirv/writer/ast_printer/builder.h b/src/tint/lang/spirv/writer/ast_printer/builder.h
index bebec35..b3d0ec6 100644
--- a/src/tint/lang/spirv/writer/ast_printer/builder.h
+++ b/src/tint/lang/spirv/writer/ast_printer/builder.h
@@ -116,8 +116,7 @@
     /// @param operands the variable operands
     void push_function_var(const OperandList& operands) {
         if (TINT_UNLIKELY(!current_function_)) {
-            TINT_ICE(Writer, builder_.Diagnostics())
-                << "push_function_var() called without a function";
+            TINT_ICE() << "push_function_var() called without a function";
         }
         current_function_.push_var(operands);
     }
diff --git a/src/tint/lang/spirv/writer/printer/printer.cc b/src/tint/lang/spirv/writer/printer/printer.cc
index 9457d67..83e702d 100644
--- a/src/tint/lang/spirv/writer/printer/printer.cc
+++ b/src/tint/lang/spirv/writer/printer/printer.cc
@@ -302,7 +302,7 @@
                 module_.PushType(spv::Op::OpConstantComposite, operands);
             },
             [&](const type::Array* arr) {
-                TINT_ASSERT(Writer, arr->ConstantCount());
+                TINT_ASSERT(arr->ConstantCount());
                 OperandList operands = {Type(ty), id};
                 for (uint32_t i = 0; i < arr->ConstantCount(); i++) {
                     operands.push_back(Constant(constant->Index(i)));
@@ -316,9 +316,7 @@
                 }
                 module_.PushType(spv::Op::OpConstantComposite, operands);
             },
-            [&](Default) {
-                TINT_ICE(Writer, diagnostics_) << "unhandled constant type: " << ty->FriendlyName();
-            });
+            [&](Default) { TINT_ICE() << "unhandled constant type: " << ty->FriendlyName(); });
         return id;
     });
 }
@@ -376,7 +374,7 @@
                     module_.PushType(spv::Op::OpTypeArray,
                                      {id, Type(arr->ElemType()), Constant(count)});
                 } else {
-                    TINT_ASSERT(Writer, arr->Count()->Is<type::RuntimeArrayCount>());
+                    TINT_ASSERT(arr->Count()->Is<type::RuntimeArrayCount>());
                     module_.PushType(spv::Op::OpTypeRuntimeArray, {id, Type(arr->ElemType())});
                 }
                 module_.PushAnnot(spv::Op::OpDecorate,
@@ -393,9 +391,7 @@
             [&](const ir::transform::BuiltinPolyfillSpirv::SampledImage* s) {
                 module_.PushType(spv::Op::OpTypeSampledImage, {id, Type(s->Image())});
             },
-            [&](Default) {
-                TINT_ICE(Writer, diagnostics_) << "unhandled type: " << ty->FriendlyName();
-            });
+            [&](Default) { TINT_ICE() << "unhandled type: " << ty->FriendlyName(); });
         return id;
     });
 }
@@ -663,7 +659,7 @@
             break;
         }
         case ir::Function::PipelineStage::kUndefined:
-            TINT_ICE(Writer, diagnostics_) << "undefined pipeline stage for entry point";
+            TINT_ICE() << "undefined pipeline stage for entry point";
             return;
     }
 
@@ -721,8 +717,7 @@
             inst,  //
             [&](ir::Var* v) { return EmitVar(v); },
             [&](Default) {
-                TINT_ICE(Writer, diagnostics_)
-                    << "unimplemented root block instruction: " << inst->TypeInfo().name;
+                TINT_ICE() << "unimplemented root block instruction: " << inst->TypeInfo().name;
             });
     }
 }
@@ -790,10 +785,7 @@
             [&](ir::Let* l) { EmitLet(l); },                                //
             [&](ir::If* i) { EmitIf(i); },                                  //
             [&](ir::Terminator* t) { EmitTerminator(t); },                  //
-            [&](Default) {
-                TINT_ICE(Writer, diagnostics_)
-                    << "unimplemented instruction: " << inst->TypeInfo().name;
-            });
+            [&](Default) { TINT_ICE() << "unimplemented instruction: " << inst->TypeInfo().name; });
 
         // Set the name for the SPIR-V result ID if provided in the module.
         if (inst->Result() && !inst->Is<ir::Var>()) {
@@ -814,7 +806,7 @@
         t,         //
         [&](ir::Return*) {
             if (!t->Args().IsEmpty()) {
-                TINT_ASSERT(Writer, t->Args().Length() == 1u);
+                TINT_ASSERT(t->Args().Length() == 1u);
                 OperandList operands;
                 operands.push_back(Value(t->Args()[0]));
                 current_function_.push_inst(spv::Op::OpReturnValue, operands);
@@ -845,9 +837,7 @@
         [&](ir::TerminateInvocation*) { current_function_.push_inst(spv::Op::OpKill, {}); },
         [&](ir::Unreachable*) { current_function_.push_inst(spv::Op::OpUnreachable, {}); },
 
-        [&](Default) {
-            TINT_ICE(Writer, diagnostics_) << "unimplemented branch: " << t->TypeInfo().name;
-        });
+        [&](Default) { TINT_ICE() << "unimplemented branch: " << t->TypeInfo().name; });
 }
 
 void Printer::EmitIf(ir::If* i) {
@@ -920,7 +910,7 @@
         } else {
             // The VarForDynamicIndex transform ensures that only value types that are vectors
             // will be dynamically indexed, as we can use OpVectorExtractDynamic for this case.
-            TINT_ASSERT(Writer, source_ty->Is<type::Vector>());
+            TINT_ASSERT(source_ty->Is<type::Vector>());
 
             // If this wasn't the first access in the chain then emit the chain so far as an
             // OpCompositeExtract, creating a new result ID for the resulting vector.
@@ -1417,9 +1407,9 @@
                                                       spv::MemorySemanticsMask::AcquireRelease))));
             break;
         default:
-            TINT_ICE(Writer, diagnostics_) << "unimplemented builtin function: " << builtin->Func();
+            TINT_ICE() << "unimplemented builtin function: " << builtin->Func();
     }
-    TINT_ASSERT(Writer, op != spv::Op::Max);
+    TINT_ASSERT(op != spv::Op::Max);
 
     // Add the arguments to the builtin call.
     for (auto* arg : builtin->Args()) {
@@ -1510,7 +1500,7 @@
                 one = ir_->constant_values.Get(1_u);
                 zero = ir_->constant_values.Get(0_u);
             });
-        TINT_ASSERT_OR_RETURN(Writer, one && zero);
+        TINT_ASSERT_OR_RETURN(one && zero);
 
         if (auto* vec = res_ty->As<type::Vector>()) {
             // Splat the scalars into vectors.
@@ -1522,7 +1512,7 @@
         operands.push_back(Constant(one));
         operands.push_back(Constant(zero));
     } else {
-        TINT_ICE(Writer, diagnostics_) << "unhandled convert instruction";
+        TINT_ICE() << "unhandled convert instruction";
     }
 
     current_function_.push_inst(op, std::move(operands));
@@ -1718,7 +1708,7 @@
             }
         }
     }
-    TINT_ASSERT(Writer, default_label != 0u);
+    TINT_ASSERT(default_label != 0u);
 
     // Build the operands to the OpSwitch instruction.
     OperandList switch_operands = {Value(swtch->Condition()), default_label};
@@ -1813,7 +1803,7 @@
 
     switch (ptr->AddressSpace()) {
         case builtin::AddressSpace::kFunction: {
-            TINT_ASSERT(Writer, current_function_);
+            TINT_ASSERT(current_function_);
             current_function_.push_var({ty, id, U32Operand(SpvStorageClassFunction)});
             if (var->Initializer()) {
                 current_function_.push_inst(spv::Op::OpStore, {id, Value(var->Initializer())});
@@ -1821,35 +1811,35 @@
             break;
         }
         case builtin::AddressSpace::kIn: {
-            TINT_ASSERT(Writer, !current_function_);
+            TINT_ASSERT(!current_function_);
             module_.PushType(spv::Op::OpVariable, {ty, id, U32Operand(SpvStorageClassInput)});
             break;
         }
         case builtin::AddressSpace::kPrivate: {
-            TINT_ASSERT(Writer, !current_function_);
+            TINT_ASSERT(!current_function_);
             OperandList operands = {ty, id, U32Operand(SpvStorageClassPrivate)};
             if (var->Initializer()) {
-                TINT_ASSERT(Writer, var->Initializer()->Is<ir::Constant>());
+                TINT_ASSERT(var->Initializer()->Is<ir::Constant>());
                 operands.push_back(Value(var->Initializer()));
             }
             module_.PushType(spv::Op::OpVariable, operands);
             break;
         }
         case builtin::AddressSpace::kPushConstant: {
-            TINT_ASSERT(Writer, !current_function_);
+            TINT_ASSERT(!current_function_);
             module_.PushType(spv::Op::OpVariable,
                              {ty, id, U32Operand(SpvStorageClassPushConstant)});
             break;
         }
         case builtin::AddressSpace::kOut: {
-            TINT_ASSERT(Writer, !current_function_);
+            TINT_ASSERT(!current_function_);
             module_.PushType(spv::Op::OpVariable, {ty, id, U32Operand(SpvStorageClassOutput)});
             break;
         }
         case builtin::AddressSpace::kHandle:
         case builtin::AddressSpace::kStorage:
         case builtin::AddressSpace::kUniform: {
-            TINT_ASSERT(Writer, !current_function_);
+            TINT_ASSERT(!current_function_);
             module_.PushType(spv::Op::OpVariable,
                              {ty, id, U32Operand(StorageClass(ptr->AddressSpace()))});
             auto bp = var->BindingPoint().value();
@@ -1860,7 +1850,7 @@
             break;
         }
         case builtin::AddressSpace::kWorkgroup: {
-            TINT_ASSERT(Writer, !current_function_);
+            TINT_ASSERT(!current_function_);
             OperandList operands = {ty, id, U32Operand(SpvStorageClassWorkgroup)};
             if (zero_init_workgroup_memory_) {
                 // If requested, use the VK_KHR_zero_initialize_workgroup_memory to zero-initialize
@@ -1871,8 +1861,7 @@
             break;
         }
         default: {
-            TINT_ICE(Writer, diagnostics_)
-                << "unimplemented variable address space " << ptr->AddressSpace();
+            TINT_ICE() << "unimplemented variable address space " << ptr->AddressSpace();
         }
     }
 
@@ -1922,8 +1911,7 @@
 uint32_t Printer::TexelFormat(const builtin::TexelFormat format) {
     switch (format) {
         case builtin::TexelFormat::kBgra8Unorm:
-            TINT_ICE(Writer, diagnostics_)
-                << "bgra8unorm should have been polyfilled to rgba8unorm";
+            TINT_ICE() << "bgra8unorm should have been polyfilled to rgba8unorm";
             return SpvImageFormatUnknown;
         case builtin::TexelFormat::kR32Uint:
             return SpvImageFormatR32ui;
diff --git a/src/tint/lang/wgsl/ast/accessor_expression.cc b/src/tint/lang/wgsl/ast/accessor_expression.cc
index 377466f..67c3728 100644
--- a/src/tint/lang/wgsl/ast/accessor_expression.cc
+++ b/src/tint/lang/wgsl/ast/accessor_expression.cc
@@ -25,8 +25,8 @@
                                        const Source& src,
                                        const Expression* obj)
     : Base(pid, nid, src), object(obj) {
-    TINT_ASSERT(AST, object);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, object, generation_id);
+    TINT_ASSERT(object);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(object, generation_id);
 }
 
 AccessorExpression::~AccessorExpression() = default;
diff --git a/src/tint/lang/wgsl/ast/alias.cc b/src/tint/lang/wgsl/ast/alias.cc
index dfb563d..79c2374 100644
--- a/src/tint/lang/wgsl/ast/alias.cc
+++ b/src/tint/lang/wgsl/ast/alias.cc
@@ -22,7 +22,7 @@
 
 Alias::Alias(GenerationID pid, NodeID nid, const Source& src, const Identifier* n, Type subtype)
     : Base(pid, nid, src, n), type(subtype) {
-    TINT_ASSERT(AST, type);
+    TINT_ASSERT(type);
 }
 
 Alias::~Alias() = default;
diff --git a/src/tint/lang/wgsl/ast/assignment_statement.cc b/src/tint/lang/wgsl/ast/assignment_statement.cc
index 173bbca..39307eb 100644
--- a/src/tint/lang/wgsl/ast/assignment_statement.cc
+++ b/src/tint/lang/wgsl/ast/assignment_statement.cc
@@ -26,10 +26,10 @@
                                          const Expression* l,
                                          const Expression* r)
     : Base(pid, nid, src), lhs(l), rhs(r) {
-    TINT_ASSERT(AST, lhs);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, lhs, generation_id);
-    TINT_ASSERT(AST, rhs);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, rhs, generation_id);
+    TINT_ASSERT(lhs);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(lhs, generation_id);
+    TINT_ASSERT(rhs);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(rhs, generation_id);
 }
 
 AssignmentStatement::~AssignmentStatement() = default;
diff --git a/src/tint/lang/wgsl/ast/binary_expression.cc b/src/tint/lang/wgsl/ast/binary_expression.cc
index dd1fdb4..4a58f1c 100644
--- a/src/tint/lang/wgsl/ast/binary_expression.cc
+++ b/src/tint/lang/wgsl/ast/binary_expression.cc
@@ -27,11 +27,11 @@
                                    const Expression* l,
                                    const Expression* r)
     : Base(pid, nid, src), op(o), lhs(l), rhs(r) {
-    TINT_ASSERT(AST, lhs);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, lhs, generation_id);
-    TINT_ASSERT(AST, rhs);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, rhs, generation_id);
-    TINT_ASSERT(AST, op != BinaryOp::kNone);
+    TINT_ASSERT(lhs);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(lhs, generation_id);
+    TINT_ASSERT(rhs);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(rhs, generation_id);
+    TINT_ASSERT(op != BinaryOp::kNone);
 }
 
 BinaryExpression::~BinaryExpression() = default;
diff --git a/src/tint/lang/wgsl/ast/bitcast_expression.cc b/src/tint/lang/wgsl/ast/bitcast_expression.cc
index 9fd5024..f943eca 100644
--- a/src/tint/lang/wgsl/ast/bitcast_expression.cc
+++ b/src/tint/lang/wgsl/ast/bitcast_expression.cc
@@ -26,9 +26,9 @@
                                      Type t,
                                      const Expression* e)
     : Base(pid, nid, src), type(t), expr(e) {
-    TINT_ASSERT(AST, type);
-    TINT_ASSERT(AST, expr);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, expr, generation_id);
+    TINT_ASSERT(type);
+    TINT_ASSERT(expr);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(expr, generation_id);
 }
 
 BitcastExpression::~BitcastExpression() = default;
diff --git a/src/tint/lang/wgsl/ast/block_statement.cc b/src/tint/lang/wgsl/ast/block_statement.cc
index 7bbec98..a49d07e 100644
--- a/src/tint/lang/wgsl/ast/block_statement.cc
+++ b/src/tint/lang/wgsl/ast/block_statement.cc
@@ -27,12 +27,12 @@
                                VectorRef<const Attribute*> attrs)
     : Base(pid, nid, src), statements(std::move(stmts)), attributes(attrs) {
     for (auto* stmt : statements) {
-        TINT_ASSERT(AST, stmt);
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, stmt, generation_id);
+        TINT_ASSERT(stmt);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(stmt, generation_id);
     }
     for (auto* attr : attributes) {
-        TINT_ASSERT(AST, attr);
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, attr, generation_id);
+        TINT_ASSERT(attr);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(attr, generation_id);
     }
 }
 
diff --git a/src/tint/lang/wgsl/ast/break_if_statement.cc b/src/tint/lang/wgsl/ast/break_if_statement.cc
index 3421b54..19431ef 100644
--- a/src/tint/lang/wgsl/ast/break_if_statement.cc
+++ b/src/tint/lang/wgsl/ast/break_if_statement.cc
@@ -25,8 +25,8 @@
                                    const Source& src,
                                    const Expression* cond)
     : Base(pid, nid, src), condition(cond) {
-    TINT_ASSERT(AST, condition);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, condition, generation_id);
+    TINT_ASSERT(condition);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(condition, generation_id);
 }
 
 BreakIfStatement::~BreakIfStatement() = default;
diff --git a/src/tint/lang/wgsl/ast/builtin_attribute.cc b/src/tint/lang/wgsl/ast/builtin_attribute.cc
index 4cfe251..22602ef 100644
--- a/src/tint/lang/wgsl/ast/builtin_attribute.cc
+++ b/src/tint/lang/wgsl/ast/builtin_attribute.cc
@@ -27,7 +27,7 @@
                                    const Source& src,
                                    const Expression* b)
     : Base(pid, nid, src), builtin(b) {
-    TINT_ASSERT_GENERATION_IDS_EQUAL(AST, b, generation_id);
+    TINT_ASSERT_GENERATION_IDS_EQUAL(b, generation_id);
 }
 
 BuiltinAttribute::~BuiltinAttribute() = default;
diff --git a/src/tint/lang/wgsl/ast/builtin_texture_helper_test.cc b/src/tint/lang/wgsl/ast/builtin_texture_helper_test.cc
index 1536b14..cb7b4eb 100644
--- a/src/tint/lang/wgsl/ast/builtin_texture_helper_test.cc
+++ b/src/tint/lang/wgsl/ast/builtin_texture_helper_test.cc
@@ -151,7 +151,7 @@
             return b->ty.i32();
     }
 
-    TINT_UNREACHABLE(AST, b->Diagnostics());
+    TINT_UNREACHABLE();
     return {};
 }
 
@@ -185,7 +185,7 @@
         }
     }
 
-    TINT_UNREACHABLE(AST, b->Diagnostics());
+    TINT_UNREACHABLE();
     return nullptr;
 }
 
diff --git a/src/tint/lang/wgsl/ast/call_expression.cc b/src/tint/lang/wgsl/ast/call_expression.cc
index 1eee4f9..7541e82 100644
--- a/src/tint/lang/wgsl/ast/call_expression.cc
+++ b/src/tint/lang/wgsl/ast/call_expression.cc
@@ -28,11 +28,11 @@
                                const IdentifierExpression* t,
                                VectorRef<const Expression*> a)
     : Base(pid, nid, src), target(t), args(std::move(a)) {
-    TINT_ASSERT(AST, target);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, target, generation_id);
+    TINT_ASSERT(target);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(target, generation_id);
     for (auto* arg : args) {
-        TINT_ASSERT(AST, arg);
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, arg, generation_id);
+        TINT_ASSERT(arg);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(arg, generation_id);
     }
 }
 
diff --git a/src/tint/lang/wgsl/ast/call_statement.cc b/src/tint/lang/wgsl/ast/call_statement.cc
index f19071f..abd8a038 100644
--- a/src/tint/lang/wgsl/ast/call_statement.cc
+++ b/src/tint/lang/wgsl/ast/call_statement.cc
@@ -25,8 +25,8 @@
                              const Source& src,
                              const CallExpression* call)
     : Base(pid, nid, src), expr(call) {
-    TINT_ASSERT(AST, expr);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, expr, generation_id);
+    TINT_ASSERT(expr);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(expr, generation_id);
 }
 
 CallStatement::~CallStatement() = default;
diff --git a/src/tint/lang/wgsl/ast/case_statement.cc b/src/tint/lang/wgsl/ast/case_statement.cc
index 0a4e3c2..f5f5e1f 100644
--- a/src/tint/lang/wgsl/ast/case_statement.cc
+++ b/src/tint/lang/wgsl/ast/case_statement.cc
@@ -28,12 +28,12 @@
                              VectorRef<const CaseSelector*> s,
                              const BlockStatement* b)
     : Base(pid, nid, src), selectors(std::move(s)), body(b) {
-    TINT_ASSERT(AST, body);
-    TINT_ASSERT(AST, !selectors.IsEmpty());
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, body, generation_id);
+    TINT_ASSERT(body);
+    TINT_ASSERT(!selectors.IsEmpty());
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(body, generation_id);
     for (auto* selector : selectors) {
-        TINT_ASSERT(AST, selector);
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, selector, generation_id);
+        TINT_ASSERT(selector);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(selector, generation_id);
     }
 }
 
diff --git a/src/tint/lang/wgsl/ast/clone_context.cc b/src/tint/lang/wgsl/ast/clone_context.cc
index b25a56e..5bc57ab 100644
--- a/src/tint/lang/wgsl/ast/clone_context.cc
+++ b/src/tint/lang/wgsl/ast/clone_context.cc
@@ -97,10 +97,10 @@
     return object->Clone(this);
 }
 
-void CloneContext::CheckedCastFailure(const Cloneable* got, const tint::TypeInfo& expected) {
-    TINT_ICE(Clone, Diagnostics()) << "Cloned object was not of the expected type\n"
-                                   << "got:      " << got->TypeInfo().name << "\n"
-                                   << "expected: " << expected.name;
+void CloneContext::CheckedCastFailure(const Cloneable* got, const TypeInfo& expected) {
+    TINT_ICE() << "Cloned object was not of the expected type\n"
+               << "got:      " << got->TypeInfo().name << "\n"
+               << "expected: " << expected.name;
 }
 
 diag::List& CloneContext::Diagnostics() const {
diff --git a/src/tint/lang/wgsl/ast/clone_context.h b/src/tint/lang/wgsl/ast/clone_context.h
index a4850de..92f6030 100644
--- a/src/tint/lang/wgsl/ast/clone_context.h
+++ b/src/tint/lang/wgsl/ast/clone_context.h
@@ -24,8 +24,10 @@
 #include "src/tint/utils/containers/hashmap.h"
 #include "src/tint/utils/containers/hashset.h"
 #include "src/tint/utils/containers/vector.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/diagnostic/diagnostic.h"
+#include "src/tint/utils/diagnostic/source.h"
 #include "src/tint/utils/generation_id.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/macros/compiler.h"
 #include "src/tint/utils/rtti/castable.h"
 #include "src/tint/utils/text/symbol.h"
@@ -109,11 +111,11 @@
     template <typename T>
     const T* Clone(const T* object) {
         if (src) {
-            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Clone, src, object);
+            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(src, object);
         }
         if (auto* cloned = CloneCloneable(object)) {
             auto* out = CheckedCast<T>(cloned);
-            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Clone, dst, out);
+            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(dst, out);
             return out;
         }
         return nullptr;
@@ -137,7 +139,7 @@
             return nullptr;
         }
         if (src) {
-            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Clone, src, a);
+            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(src, a);
         }
         auto* c = a->Clone(this);
         return CheckedCast<T>(c);
@@ -310,10 +312,10 @@
             bool already_registered = transform.typeinfo->Is(&tint::TypeInfo::Of<T>()) ||
                                       tint::TypeInfo::Of<T>().Is(transform.typeinfo);
             if (TINT_UNLIKELY(already_registered)) {
-                TINT_ICE(Clone, Diagnostics()) << "ReplaceAll() called with a handler for type "
-                                               << tint::TypeInfo::Of<T>().name
-                                               << " that is already handled by a handler for type "
-                                               << transform.typeinfo->name;
+                TINT_ICE() << "ReplaceAll() called with a handler for type "
+                           << TypeInfo::Of<T>().name
+                           << " that is already handled by a handler for type "
+                           << transform.typeinfo->name;
                 return *this;
             }
         }
@@ -335,8 +337,8 @@
     /// @returns this CloneContext so calls can be chained
     CloneContext& ReplaceAll(const SymbolTransform& replacer) {
         if (TINT_UNLIKELY(symbol_transform_)) {
-            TINT_ICE(Clone, Diagnostics()) << "ReplaceAll(const SymbolTransform&) called "
-                                              "multiple times on the same CloneContext";
+            TINT_ICE() << "ReplaceAll(const SymbolTransform&) called multiple times on the same "
+                          "CloneContext";
             return *this;
         }
         symbol_transform_ = replacer;
@@ -359,8 +361,8 @@
               typename WITH,
               typename = tint::traits::EnableIfIsType<WITH, Cloneable>>
     CloneContext& Replace(const WHAT* what, const WITH* with) {
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Clone, src, what);
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Clone, dst, with);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(src, what);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(dst, with);
         replacements_.Replace(what, [with]() -> const Cloneable* { return with; });
         return *this;
     }
@@ -380,7 +382,7 @@
     /// @returns this CloneContext so calls can be chained
     template <typename WHAT, typename WITH, typename = std::invoke_result_t<WITH>>
     CloneContext& Replace(const WHAT* what, WITH&& with) {
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Clone, src, what);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(src, what);
         replacements_.Replace(what, with);
         return *this;
     }
@@ -391,11 +393,10 @@
     /// the cloned vector.
     /// @returns this CloneContext so calls can be chained
     template <typename T, size_t N, typename OBJECT>
-    CloneContext& Remove(const tint::Vector<T, N>& vector, OBJECT* object) {
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Clone, src, object);
+    CloneContext& Remove(const Vector<T, N>& vector, OBJECT* object) {
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(src, object);
         if (TINT_UNLIKELY((std::find(vector.begin(), vector.end(), object) == vector.end()))) {
-            TINT_ICE(Clone, Diagnostics())
-                << "CloneContext::Remove() vector does not contain object";
+            TINT_ICE() << "CloneContext::Remove() vector does not contain object";
             return *this;
         }
 
@@ -409,8 +410,8 @@
     /// front of the vector
     /// @returns this CloneContext so calls can be chained
     template <typename T, size_t N, typename OBJECT>
-    CloneContext& InsertFront(const tint::Vector<T, N>& vector, OBJECT* object) {
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Clone, dst, object);
+    CloneContext& InsertFront(const Vector<T, N>& vector, OBJECT* object) {
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(dst, object);
         return InsertFront(vector, [object] { return object; });
     }
 
@@ -431,8 +432,8 @@
     /// end of the vector
     /// @returns this CloneContext so calls can be chained
     template <typename T, size_t N, typename OBJECT>
-    CloneContext& InsertBack(const tint::Vector<T, N>& vector, OBJECT* object) {
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Clone, dst, object);
+    CloneContext& InsertBack(const Vector<T, N>& vector, OBJECT* object) {
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(dst, object);
         return InsertBack(vector, [object] { return object; });
     }
 
@@ -458,11 +459,10 @@
     CloneContext& InsertBefore(const tint::Vector<T, N>& vector,
                                const BEFORE* before,
                                const OBJECT* object) {
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Clone, src, before);
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Clone, dst, object);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(src, before);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(dst, object);
         if (TINT_UNLIKELY((std::find(vector.begin(), vector.end(), before) == vector.end()))) {
-            TINT_ICE(Clone, Diagnostics())
-                << "CloneContext::InsertBefore() vector does not contain before";
+            TINT_ICE() << "CloneContext::InsertBefore() vector does not contain before";
             return *this;
         }
 
@@ -500,11 +500,10 @@
     CloneContext& InsertAfter(const tint::Vector<T, N>& vector,
                               const AFTER* after,
                               const OBJECT* object) {
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Clone, src, after);
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Clone, dst, object);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(src, after);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(dst, object);
         if (TINT_UNLIKELY((std::find(vector.begin(), vector.end(), after) == vector.end()))) {
-            TINT_ICE(Clone, Diagnostics())
-                << "CloneContext::InsertAfter() vector does not contain after";
+            TINT_ICE() << "CloneContext::InsertAfter() vector does not contain after";
             return *this;
         }
 
diff --git a/src/tint/lang/wgsl/ast/clone_context_test.cc b/src/tint/lang/wgsl/ast/clone_context_test.cc
index 936ca00..17d6e5f 100644
--- a/src/tint/lang/wgsl/ast/clone_context_test.cc
+++ b/src/tint/lang/wgsl/ast/clone_context_test.cc
@@ -1268,7 +1268,7 @@
             Allocator allocator;
             ctx.Clone(allocator.Create<ProgramNode>(GenerationID::New(), dst.ID()));
         },
-        R"(internal compiler error: TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Clone, src, object))");
+        R"(internal compiler error: TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(src, object))");
 }
 
 TEST_F(CloneContextTest, GenerationIDs_Clone_ObjectNotOwnedByDst) {
@@ -1280,7 +1280,7 @@
             Allocator allocator;
             ctx.Clone(allocator.Create<ProgramNode>(src.ID(), GenerationID::New()));
         },
-        R"(internal compiler error: TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Clone, dst, out))");
+        R"(internal compiler error: TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(dst, out))");
 }
 
 }  // namespace
diff --git a/src/tint/lang/wgsl/ast/compound_assignment_statement.cc b/src/tint/lang/wgsl/ast/compound_assignment_statement.cc
index d235bc6..7050a2c 100644
--- a/src/tint/lang/wgsl/ast/compound_assignment_statement.cc
+++ b/src/tint/lang/wgsl/ast/compound_assignment_statement.cc
@@ -27,10 +27,10 @@
                                                          const Expression* r,
                                                          BinaryOp o)
     : Base(pid, nid, src), lhs(l), rhs(r), op(o) {
-    TINT_ASSERT(AST, lhs);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, lhs, generation_id);
-    TINT_ASSERT(AST, rhs);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, rhs, generation_id);
+    TINT_ASSERT(lhs);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(lhs, generation_id);
+    TINT_ASSERT(rhs);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(rhs, generation_id);
 }
 
 CompoundAssignmentStatement::~CompoundAssignmentStatement() = default;
diff --git a/src/tint/lang/wgsl/ast/const.cc b/src/tint/lang/wgsl/ast/const.cc
index 7a7c7e9..62ab73b 100644
--- a/src/tint/lang/wgsl/ast/const.cc
+++ b/src/tint/lang/wgsl/ast/const.cc
@@ -30,7 +30,7 @@
              const Expression* init,
              VectorRef<const Attribute*> attrs)
     : Base(pid, nid, src, n, ty, init, std::move(attrs)) {
-    TINT_ASSERT(AST, init != nullptr);
+    TINT_ASSERT(init != nullptr);
 }
 
 Const::~Const() = default;
diff --git a/src/tint/lang/wgsl/ast/const_assert.cc b/src/tint/lang/wgsl/ast/const_assert.cc
index 59c1cf8..5775d94 100644
--- a/src/tint/lang/wgsl/ast/const_assert.cc
+++ b/src/tint/lang/wgsl/ast/const_assert.cc
@@ -22,8 +22,8 @@
 
 ConstAssert::ConstAssert(GenerationID pid, NodeID nid, const Source& src, const Expression* cond)
     : Base(pid, nid, src), condition(cond) {
-    TINT_ASSERT(AST, cond);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, cond, generation_id);
+    TINT_ASSERT(cond);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(cond, generation_id);
 }
 
 ConstAssert::~ConstAssert() = default;
diff --git a/src/tint/lang/wgsl/ast/diagnostic_control.cc b/src/tint/lang/wgsl/ast/diagnostic_control.cc
index c4e72be..f5e31df 100644
--- a/src/tint/lang/wgsl/ast/diagnostic_control.cc
+++ b/src/tint/lang/wgsl/ast/diagnostic_control.cc
@@ -27,7 +27,7 @@
 DiagnosticControl::DiagnosticControl(builtin::DiagnosticSeverity sev,
                                      const DiagnosticRuleName* rule)
     : severity(sev), rule_name(rule) {
-    TINT_ASSERT(AST, rule != nullptr);
+    TINT_ASSERT(rule != nullptr);
 }
 
 DiagnosticControl::DiagnosticControl(DiagnosticControl&&) = default;
diff --git a/src/tint/lang/wgsl/ast/diagnostic_rule_name.cc b/src/tint/lang/wgsl/ast/diagnostic_rule_name.cc
index 22ca445..0c3e180 100644
--- a/src/tint/lang/wgsl/ast/diagnostic_rule_name.cc
+++ b/src/tint/lang/wgsl/ast/diagnostic_rule_name.cc
@@ -27,11 +27,11 @@
                                        const Source& src,
                                        const Identifier* n)
     : Base(pid, nid, src), name(n) {
-    TINT_ASSERT(AST, name != nullptr);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, name, generation_id);
+    TINT_ASSERT(name != nullptr);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(name, generation_id);
     if (name) {
         // It is invalid for a diagnostic rule name to be templated
-        TINT_ASSERT(AST, !name->Is<TemplatedIdentifier>());
+        TINT_ASSERT(!name->Is<TemplatedIdentifier>());
     }
 }
 
@@ -41,16 +41,16 @@
                                        const Identifier* c,
                                        const Identifier* n)
     : Base(pid, nid, src), category(c), name(n) {
-    TINT_ASSERT(AST, name != nullptr);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, name, generation_id);
+    TINT_ASSERT(name != nullptr);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(name, generation_id);
     if (name) {
         // It is invalid for a diagnostic rule name to be templated
-        TINT_ASSERT(AST, !name->Is<TemplatedIdentifier>());
+        TINT_ASSERT(!name->Is<TemplatedIdentifier>());
     }
     if (category) {
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, category, generation_id);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(category, generation_id);
         // It is invalid for a diagnostic rule category to be templated
-        TINT_ASSERT(AST, !category->Is<TemplatedIdentifier>());
+        TINT_ASSERT(!category->Is<TemplatedIdentifier>());
     }
 }
 
diff --git a/src/tint/lang/wgsl/ast/for_loop_statement.cc b/src/tint/lang/wgsl/ast/for_loop_statement.cc
index 474c749..0f976e9 100644
--- a/src/tint/lang/wgsl/ast/for_loop_statement.cc
+++ b/src/tint/lang/wgsl/ast/for_loop_statement.cc
@@ -36,15 +36,15 @@
       continuing(cont),
       body(b),
       attributes(std::move(attrs)) {
-    TINT_ASSERT(AST, body);
+    TINT_ASSERT(body);
 
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, initializer, generation_id);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, condition, generation_id);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, continuing, generation_id);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, body, generation_id);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(initializer, generation_id);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(condition, generation_id);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(continuing, generation_id);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(body, generation_id);
     for (auto* attr : attributes) {
-        TINT_ASSERT(AST, attr);
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, attr, generation_id);
+        TINT_ASSERT(attr);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(attr, generation_id);
     }
 }
 
diff --git a/src/tint/lang/wgsl/ast/function.cc b/src/tint/lang/wgsl/ast/function.cc
index 103f247..144a4a8 100644
--- a/src/tint/lang/wgsl/ast/function.cc
+++ b/src/tint/lang/wgsl/ast/function.cc
@@ -38,22 +38,22 @@
       body(b),
       attributes(std::move(attrs)),
       return_type_attributes(std::move(return_type_attrs)) {
-    TINT_ASSERT(AST, name);
+    TINT_ASSERT(name);
     if (name) {
-        TINT_ASSERT(AST, !name->Is<TemplatedIdentifier>());
+        TINT_ASSERT(!name->Is<TemplatedIdentifier>());
     }
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, name, generation_id);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, return_ty, generation_id);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, body, generation_id);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(name, generation_id);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(return_ty, generation_id);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(body, generation_id);
     for (auto* param : params) {
-        TINT_ASSERT(AST, tint::Is<Parameter>(param));
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, param, generation_id);
+        TINT_ASSERT(tint::Is<Parameter>(param));
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(param, generation_id);
     }
     for (auto* attr : attributes) {
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, attr, generation_id);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(attr, generation_id);
     }
     for (auto* attr : return_type_attributes) {
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, attr, generation_id);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(attr, generation_id);
     }
 }
 
diff --git a/src/tint/lang/wgsl/ast/identifier.cc b/src/tint/lang/wgsl/ast/identifier.cc
index d31b9ad..827487b 100644
--- a/src/tint/lang/wgsl/ast/identifier.cc
+++ b/src/tint/lang/wgsl/ast/identifier.cc
@@ -22,8 +22,8 @@
 
 Identifier::Identifier(GenerationID pid, NodeID nid, const Source& src, Symbol sym)
     : Base(pid, nid, src), symbol(sym) {
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, symbol, generation_id);
-    TINT_ASSERT(AST, symbol.IsValid());
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(symbol, generation_id);
+    TINT_ASSERT(symbol.IsValid());
 }
 
 Identifier::~Identifier() = default;
diff --git a/src/tint/lang/wgsl/ast/identifier_expression.cc b/src/tint/lang/wgsl/ast/identifier_expression.cc
index 8666a10..028600e 100644
--- a/src/tint/lang/wgsl/ast/identifier_expression.cc
+++ b/src/tint/lang/wgsl/ast/identifier_expression.cc
@@ -25,8 +25,8 @@
                                            const Source& src,
                                            const Identifier* ident)
     : Base(pid, nid, src), identifier(ident) {
-    TINT_ASSERT(AST, identifier != nullptr);
-    TINT_ASSERT_GENERATION_IDS_EQUAL(AST, identifier, generation_id);
+    TINT_ASSERT(identifier != nullptr);
+    TINT_ASSERT_GENERATION_IDS_EQUAL(identifier, generation_id);
 }
 
 IdentifierExpression::~IdentifierExpression() = default;
diff --git a/src/tint/lang/wgsl/ast/if_statement.cc b/src/tint/lang/wgsl/ast/if_statement.cc
index 006c0dc..4168b63 100644
--- a/src/tint/lang/wgsl/ast/if_statement.cc
+++ b/src/tint/lang/wgsl/ast/if_statement.cc
@@ -32,17 +32,17 @@
       body(b),
       else_statement(else_stmt),
       attributes(std::move(attrs)) {
-    TINT_ASSERT(AST, condition);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, condition, generation_id);
-    TINT_ASSERT(AST, body);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, body, generation_id);
+    TINT_ASSERT(condition);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(condition, generation_id);
+    TINT_ASSERT(body);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(body, generation_id);
     if (else_statement) {
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, else_statement, generation_id);
-        TINT_ASSERT(AST, (else_statement->IsAnyOf<IfStatement, BlockStatement>()));
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(else_statement, generation_id);
+        TINT_ASSERT((else_statement->IsAnyOf<IfStatement, BlockStatement>()));
     }
     for (auto* attr : attributes) {
-        TINT_ASSERT(AST, attr);
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, attr, generation_id);
+        TINT_ASSERT(attr);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(attr, generation_id);
     }
 }
 
diff --git a/src/tint/lang/wgsl/ast/increment_decrement_statement.cc b/src/tint/lang/wgsl/ast/increment_decrement_statement.cc
index fc0bc29..4e90671 100644
--- a/src/tint/lang/wgsl/ast/increment_decrement_statement.cc
+++ b/src/tint/lang/wgsl/ast/increment_decrement_statement.cc
@@ -26,7 +26,7 @@
                                                          const Expression* l,
                                                          bool inc)
     : Base(pid, nid, src), lhs(l), increment(inc) {
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, lhs, generation_id);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(lhs, generation_id);
 }
 
 IncrementDecrementStatement::~IncrementDecrementStatement() = default;
diff --git a/src/tint/lang/wgsl/ast/index_accessor_expression.cc b/src/tint/lang/wgsl/ast/index_accessor_expression.cc
index 456f635..1419497 100644
--- a/src/tint/lang/wgsl/ast/index_accessor_expression.cc
+++ b/src/tint/lang/wgsl/ast/index_accessor_expression.cc
@@ -26,8 +26,8 @@
                                                  const Expression* obj,
                                                  const Expression* idx)
     : Base(pid, nid, src, obj), index(idx) {
-    TINT_ASSERT(AST, idx);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, idx, generation_id);
+    TINT_ASSERT(idx);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(idx, generation_id);
 }
 
 IndexAccessorExpression::~IndexAccessorExpression() = default;
diff --git a/src/tint/lang/wgsl/ast/let.cc b/src/tint/lang/wgsl/ast/let.cc
index f7f5e56..5f9d90b 100644
--- a/src/tint/lang/wgsl/ast/let.cc
+++ b/src/tint/lang/wgsl/ast/let.cc
@@ -30,7 +30,7 @@
          const Expression* init,
          VectorRef<const Attribute*> attrs)
     : Base(pid, nid, src, n, ty, init, std::move(attrs)) {
-    TINT_ASSERT(AST, init != nullptr);
+    TINT_ASSERT(init != nullptr);
 }
 
 Let::~Let() = default;
diff --git a/src/tint/lang/wgsl/ast/loop_statement.cc b/src/tint/lang/wgsl/ast/loop_statement.cc
index feebce2..0da9ad5 100644
--- a/src/tint/lang/wgsl/ast/loop_statement.cc
+++ b/src/tint/lang/wgsl/ast/loop_statement.cc
@@ -29,12 +29,12 @@
                              const BlockStatement* cont,
                              VectorRef<const ast::Attribute*> attrs)
     : Base(pid, nid, src), body(b), continuing(cont), attributes(std::move(attrs)) {
-    TINT_ASSERT(AST, body);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, body, generation_id);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, continuing, generation_id);
+    TINT_ASSERT(body);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(body, generation_id);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(continuing, generation_id);
     for (auto* attr : attributes) {
-        TINT_ASSERT(AST, attr);
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, attr, generation_id);
+        TINT_ASSERT(attr);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(attr, generation_id);
     }
 }
 
diff --git a/src/tint/lang/wgsl/ast/member_accessor_expression.cc b/src/tint/lang/wgsl/ast/member_accessor_expression.cc
index 4fc6f21..d9ec1a4 100644
--- a/src/tint/lang/wgsl/ast/member_accessor_expression.cc
+++ b/src/tint/lang/wgsl/ast/member_accessor_expression.cc
@@ -26,12 +26,12 @@
                                                    const Expression* obj,
                                                    const Identifier* mem)
     : Base(pid, nid, src, obj), member(mem) {
-    TINT_ASSERT(AST, member);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, member, generation_id);
+    TINT_ASSERT(member);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(member, generation_id);
 
     // It is currently invalid for a structure to hold a templated member
     if (member) {
-        TINT_ASSERT(AST, !member->Is<TemplatedIdentifier>());
+        TINT_ASSERT(!member->Is<TemplatedIdentifier>());
     }
 }
 
diff --git a/src/tint/lang/wgsl/ast/module.cc b/src/tint/lang/wgsl/ast/module.cc
index edc1771..a5b2797 100644
--- a/src/tint/lang/wgsl/ast/module.cc
+++ b/src/tint/lang/wgsl/ast/module.cc
@@ -32,8 +32,7 @@
         if (decl == nullptr) {
             continue;
         }
-        diag::List diags;
-        BinGlobalDeclaration(decl, diags);
+        BinGlobalDeclaration(decl);
     }
 }
 
@@ -49,79 +48,78 @@
 }
 
 void Module::AddGlobalDeclaration(const tint::ast::Node* decl) {
-    diag::List diags;
-    BinGlobalDeclaration(decl, diags);
+    BinGlobalDeclaration(decl);
     global_declarations_.Push(decl);
 }
 
-void Module::BinGlobalDeclaration(const tint::ast::Node* decl, diag::List& diags) {
+void Module::BinGlobalDeclaration(const tint::ast::Node* decl) {
     Switch(
         decl,  //
         [&](const TypeDecl* type) {
-            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, type, generation_id);
+            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(type, generation_id);
             type_decls_.Push(type);
         },
         [&](const Function* func) {
-            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, func, generation_id);
+            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(func, generation_id);
             functions_.Push(func);
         },
         [&](const Variable* var) {
-            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, var, generation_id);
+            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(var, generation_id);
             global_variables_.Push(var);
         },
         [&](const DiagnosticDirective* diagnostic) {
-            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, diagnostic, generation_id);
+            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(diagnostic, generation_id);
             diagnostic_directives_.Push(diagnostic);
         },
         [&](const Enable* enable) {
-            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, enable, generation_id);
+            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(enable, generation_id);
             enables_.Push(enable);
         },
         [&](const ConstAssert* assertion) {
-            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, assertion, generation_id);
+            TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(assertion, generation_id);
             const_asserts_.Push(assertion);
         },
-        [&](Default) { TINT_ICE(AST, diags) << "Unknown global declaration type"; });
+        [&](Default) { TINT_ICE() << "Unknown global declaration type"; });
 }
 
 void Module::AddDiagnosticDirective(const DiagnosticDirective* directive) {
-    TINT_ASSERT(AST, directive);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, directive, generation_id);
+    TINT_ASSERT(directive);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(directive, generation_id);
     global_declarations_.Push(directive);
     diagnostic_directives_.Push(directive);
 }
 
 void Module::AddEnable(const Enable* enable) {
-    TINT_ASSERT(AST, enable);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, enable, generation_id);
+    TINT_ASSERT(enable);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(enable, generation_id);
     global_declarations_.Push(enable);
     enables_.Push(enable);
 }
 
 void Module::AddGlobalVariable(const Variable* var) {
-    TINT_ASSERT(AST, var);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, var, generation_id);
+    TINT_ASSERT(var);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(var, generation_id);
     global_variables_.Push(var);
     global_declarations_.Push(var);
 }
 
 void Module::AddConstAssert(const ConstAssert* assertion) {
-    TINT_ASSERT(AST, assertion);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, assertion, generation_id);
+    TINT_ASSERT(assertion);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(assertion, generation_id);
     const_asserts_.Push(assertion);
     global_declarations_.Push(assertion);
 }
 
 void Module::AddTypeDecl(const TypeDecl* type) {
-    TINT_ASSERT(AST, type);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, type, generation_id);
+    TINT_ASSERT(type);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(type, generation_id);
     type_decls_.Push(type);
     global_declarations_.Push(type);
 }
 
 void Module::AddFunction(const Function* func) {
-    TINT_ASSERT(AST, func);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, func, generation_id);
+    TINT_ASSERT(func);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(func, generation_id);
     functions_.Push(func);
     global_declarations_.Push(func);
 }
@@ -145,10 +143,10 @@
 
     for (auto* decl : global_declarations_) {
         if (TINT_UNLIKELY(!decl)) {
-            TINT_ICE(AST, ctx->dst->Diagnostics()) << "src global declaration was nullptr";
+            TINT_ICE() << "src global declaration was nullptr";
             continue;
         }
-        BinGlobalDeclaration(decl, ctx->dst->Diagnostics());
+        BinGlobalDeclaration(decl);
     }
 }
 
diff --git a/src/tint/lang/wgsl/ast/module.h b/src/tint/lang/wgsl/ast/module.h
index 23e33e6..b0516bd 100644
--- a/src/tint/lang/wgsl/ast/module.h
+++ b/src/tint/lang/wgsl/ast/module.h
@@ -144,7 +144,7 @@
     /// * #global_declarations_
     /// * #type_decls_
     /// * #functions_
-    void BinGlobalDeclaration(const tint::ast::Node* decl, diag::List& diags);
+    void BinGlobalDeclaration(const tint::ast::Node* decl);
 
     tint::Vector<const Node*, 64> global_declarations_;
     tint::Vector<const TypeDecl*, 16> type_decls_;
diff --git a/src/tint/lang/wgsl/ast/return_statement.cc b/src/tint/lang/wgsl/ast/return_statement.cc
index ec3122e..b3ae820 100644
--- a/src/tint/lang/wgsl/ast/return_statement.cc
+++ b/src/tint/lang/wgsl/ast/return_statement.cc
@@ -28,7 +28,7 @@
                                  const Source& src,
                                  const Expression* val)
     : Base(pid, nid, src), value(val) {
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, value, generation_id);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(value, generation_id);
 }
 
 ReturnStatement::~ReturnStatement() = default;
diff --git a/src/tint/lang/wgsl/ast/struct.cc b/src/tint/lang/wgsl/ast/struct.cc
index a471a83..266b3a4 100644
--- a/src/tint/lang/wgsl/ast/struct.cc
+++ b/src/tint/lang/wgsl/ast/struct.cc
@@ -30,12 +30,12 @@
                VectorRef<const Attribute*> attrs)
     : Base(pid, nid, src, n), members(std::move(m)), attributes(std::move(attrs)) {
     for (auto* mem : members) {
-        TINT_ASSERT(AST, mem);
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, mem, generation_id);
+        TINT_ASSERT(mem);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(mem, generation_id);
     }
     for (auto* attr : attributes) {
-        TINT_ASSERT(AST, attr);
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, attr, generation_id);
+        TINT_ASSERT(attr);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(attr, generation_id);
     }
 }
 
diff --git a/src/tint/lang/wgsl/ast/struct_member.cc b/src/tint/lang/wgsl/ast/struct_member.cc
index 1c1c3b1..4ec5e7d 100644
--- a/src/tint/lang/wgsl/ast/struct_member.cc
+++ b/src/tint/lang/wgsl/ast/struct_member.cc
@@ -28,14 +28,14 @@
                            VectorRef<const Attribute*> attrs)
 
     : Base(pid, nid, src), name(n), type(ty), attributes(std::move(attrs)) {
-    TINT_ASSERT(AST, name);
+    TINT_ASSERT(name);
     if (name) {
-        TINT_ASSERT(AST, !name->Is<TemplatedIdentifier>());
+        TINT_ASSERT(!name->Is<TemplatedIdentifier>());
     }
-    TINT_ASSERT(AST, type);
+    TINT_ASSERT(type);
     for (auto* attr : attributes) {
-        TINT_ASSERT(AST, attr);
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, attr, generation_id);
+        TINT_ASSERT(attr);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(attr, generation_id);
     }
 }
 
diff --git a/src/tint/lang/wgsl/ast/switch_statement.cc b/src/tint/lang/wgsl/ast/switch_statement.cc
index a8b9f65..a830f3e 100644
--- a/src/tint/lang/wgsl/ast/switch_statement.cc
+++ b/src/tint/lang/wgsl/ast/switch_statement.cc
@@ -34,19 +34,19 @@
       body(std::move(b)),
       attributes(std::move(stmt_attrs)),
       body_attributes(std::move(body_attrs)) {
-    TINT_ASSERT(AST, condition);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, condition, generation_id);
+    TINT_ASSERT(condition);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(condition, generation_id);
     for (auto* stmt : body) {
-        TINT_ASSERT(AST, stmt);
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, stmt, generation_id);
+        TINT_ASSERT(stmt);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(stmt, generation_id);
     }
     for (auto* attr : attributes) {
-        TINT_ASSERT(AST, attr);
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, attr, generation_id);
+        TINT_ASSERT(attr);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(attr, generation_id);
     }
     for (auto* attr : body_attributes) {
-        TINT_ASSERT(AST, attr);
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, attr, generation_id);
+        TINT_ASSERT(attr);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(attr, generation_id);
     }
 }
 
diff --git a/src/tint/lang/wgsl/ast/templated_identifier.cc b/src/tint/lang/wgsl/ast/templated_identifier.cc
index 8d9bf5a..72d54f0 100644
--- a/src/tint/lang/wgsl/ast/templated_identifier.cc
+++ b/src/tint/lang/wgsl/ast/templated_identifier.cc
@@ -29,12 +29,12 @@
                                          VectorRef<const Expression*> args,
                                          VectorRef<const Attribute*> attrs)
     : Base(pid, nid, src, sym), arguments(std::move(args)), attributes(std::move(attrs)) {
-    TINT_ASSERT(AST, !arguments.IsEmpty());  // Should have been an Identifier if this fires.
+    TINT_ASSERT(!arguments.IsEmpty());  // Should have been an Identifier if this fires.
     for (auto* arg : arguments) {
-        TINT_ASSERT_GENERATION_IDS_EQUAL(AST, arg, generation_id);
+        TINT_ASSERT_GENERATION_IDS_EQUAL(arg, generation_id);
     }
     for (auto* attr : attributes) {
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, attr, generation_id);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(attr, generation_id);
     }
 }
 
diff --git a/src/tint/lang/wgsl/ast/transform/array_length_from_uniform.cc b/src/tint/lang/wgsl/ast/transform/array_length_from_uniform.cc
index 53ef521..cb44940 100644
--- a/src/tint/lang/wgsl/ast/transform/array_length_from_uniform.cc
+++ b/src/tint/lang/wgsl/ast/transform/array_length_from_uniform.cc
@@ -156,9 +156,8 @@
             } else if (auto* arr = storage_buffer_type->As<type::Array>()) {
                 array_type = arr;
             } else {
-                TINT_ICE(Transform, b.Diagnostics())
-                    << "expected form of arrayLength argument to be &array_var or "
-                       "&struct_var.array_member";
+                TINT_ICE() << "expected form of arrayLength argument to be &array_var or "
+                              "&struct_var.array_member";
                 return;
             }
             auto* array_length = b.Div(total_size, u32(array_type->Stride()));
@@ -224,9 +223,8 @@
             //   arrayLength(&array_var)
             auto* param = call_expr->args[0]->As<UnaryOpExpression>();
             if (TINT_UNLIKELY(!param || param->op != UnaryOp::kAddressOf)) {
-                TINT_ICE(Transform, b.Diagnostics())
-                    << "expected form of arrayLength argument to be &array_var or "
-                       "&struct_var.array_member";
+                TINT_ICE() << "expected form of arrayLength argument to be &array_var or "
+                              "&struct_var.array_member";
                 break;
             }
             auto* storage_buffer_expr = param->expr;
@@ -235,16 +233,15 @@
             }
             auto* storage_buffer_sem = sem.Get<sem::VariableUser>(storage_buffer_expr);
             if (TINT_UNLIKELY(!storage_buffer_sem)) {
-                TINT_ICE(Transform, b.Diagnostics())
-                    << "expected form of arrayLength argument to be &array_var or "
-                       "&struct_var.array_member";
+                TINT_ICE() << "expected form of arrayLength argument to be &array_var or "
+                              "&struct_var.array_member";
                 break;
             }
 
             // Get the index to use for the buffer size array.
             auto* var = tint::As<sem::GlobalVariable>(storage_buffer_sem->Variable());
             if (TINT_UNLIKELY(!var)) {
-                TINT_ICE(Transform, b.Diagnostics()) << "storage buffer is not a global variable";
+                TINT_ICE() << "storage buffer is not a global variable";
                 break;
             }
             functor(call_expr, storage_buffer_sem, var);
diff --git a/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc b/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc
index 839fbf2..8bf324b 100644
--- a/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc
+++ b/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc
@@ -193,8 +193,7 @@
                 break;
             }
             default:
-                TINT_ICE(Transform, b.Diagnostics())
-                    << "unhandled polyfill level: " << static_cast<int>(cfg.builtins.acosh);
+                TINT_ICE() << "unhandled polyfill level: " << static_cast<int>(cfg.builtins.acosh);
                 return {};
         }
 
@@ -246,8 +245,7 @@
                                           b.GreaterThanEqual("x", V(1.0_a)))));
                 break;
             default:
-                TINT_ICE(Transform, b.Diagnostics())
-                    << "unhandled polyfill level: " << static_cast<int>(cfg.builtins.acosh);
+                TINT_ICE() << "unhandled polyfill level: " << static_cast<int>(cfg.builtins.acosh);
                 return {};
         }
 
@@ -436,8 +434,8 @@
                 body.Push(b.Return(b.Call("extractBits", "v", "s", b.Sub("e", "s"))));
                 break;
             default:
-                TINT_ICE(Transform, b.Diagnostics())
-                    << "unhandled polyfill level: " << static_cast<int>(cfg.builtins.extract_bits);
+                TINT_ICE() << "unhandled polyfill level: "
+                           << static_cast<int>(cfg.builtins.extract_bits);
                 return {};
         }
 
@@ -592,7 +590,7 @@
 
         // Currently in WGSL parameters of insertBits must be i32, u32, vecN<i32> or vecN<u32>
         if (TINT_UNLIKELY(((!ty->DeepestElement()->IsAnyOf<type::I32, type::U32>())))) {
-            TINT_ICE(Transform, b.Diagnostics())
+            TINT_ICE()
                 << "insertBits polyfill only support i32, u32, and vector of i32 or u32, got "
                 << ty->FriendlyName();
             return {};
@@ -674,8 +672,8 @@
                 body.Push(b.Return(b.Call("insertBits", "v", "n", "s", b.Sub("e", "s"))));
                 break;
             default:
-                TINT_ICE(Transform, b.Diagnostics())
-                    << "unhandled polyfill level: " << static_cast<int>(cfg.builtins.insert_bits);
+                TINT_ICE() << "unhandled polyfill level: "
+                           << static_cast<int>(cfg.builtins.insert_bits);
                 return {};
         }
 
diff --git a/src/tint/lang/wgsl/ast/transform/calculate_array_length.cc b/src/tint/lang/wgsl/ast/transform/calculate_array_length.cc
index 01abe0d..abbe9a5 100644
--- a/src/tint/lang/wgsl/ast/transform/calculate_array_length.cc
+++ b/src/tint/lang/wgsl/ast/transform/calculate_array_length.cc
@@ -150,7 +150,7 @@
                     auto* arg = call_expr->args[0];
                     auto* address_of = arg->As<UnaryOpExpression>();
                     if (TINT_UNLIKELY(!address_of || address_of->op != UnaryOp::kAddressOf)) {
-                        TINT_ICE(Transform, b.Diagnostics())
+                        TINT_ICE()
                             << "arrayLength() expected address-of, got " << arg->TypeInfo().name;
                     }
                     auto* storage_buffer_expr = address_of->expr;
@@ -159,9 +159,8 @@
                     }
                     auto* storage_buffer_sem = sem.Get<sem::VariableUser>(storage_buffer_expr);
                     if (TINT_UNLIKELY(!storage_buffer_sem)) {
-                        TINT_ICE(Transform, b.Diagnostics())
-                            << "expected form of arrayLength argument to be &array_var or "
-                               "&struct_var.array_member";
+                        TINT_ICE() << "expected form of arrayLength argument to be &array_var or "
+                                      "&struct_var.array_member";
                         break;
                     }
                     auto* storage_buffer_var = storage_buffer_sem->Variable();
@@ -210,9 +209,8 @@
                                 [&](const type::Array* arr) { return arr; });
 
                             if (TINT_UNLIKELY(!array_type)) {
-                                TINT_ICE(Transform, b.Diagnostics())
-                                    << "expected form of arrayLength argument to be "
-                                       "&array_var or &struct_var.array_member";
+                                TINT_ICE() << "expected form of arrayLength argument to be "
+                                              "&array_var or &struct_var.array_member";
                                 return name;
                             }
 
diff --git a/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc
index f7dd53f..4dfce6a 100644
--- a/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc
+++ b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc
@@ -191,8 +191,7 @@
             // Obtain the builtin value from the semantic info.
             return ctx.src->Sem().Get(attr)->Value();
         }
-        TINT_ICE(Resolver, ctx.dst->Diagnostics())
-            << "could not obtain builtin value from attribute";
+        TINT_ICE() << "could not obtain builtin value from attribute";
         return builtin::BuiltinValue::kUndefined;
     }
 
@@ -375,7 +374,7 @@
         tint::Vector<const Expression*, 8> inner_struct_values;
         for (auto* member : str->Members()) {
             if (TINT_UNLIKELY(member->Type()->Is<type::Struct>())) {
-                TINT_ICE(Transform, ctx.dst->Diagnostics()) << "nested IO struct";
+                TINT_ICE() << "nested IO struct";
                 continue;
             }
 
@@ -404,7 +403,7 @@
         if (auto* str = inner_ret_type->As<sem::Struct>()) {
             for (auto* member : str->Members()) {
                 if (TINT_UNLIKELY(member->Type()->Is<type::Struct>())) {
-                    TINT_ICE(Transform, ctx.dst->Diagnostics()) << "nested IO struct";
+                    TINT_ICE() << "nested IO struct";
                     continue;
                 }
 
diff --git a/src/tint/lang/wgsl/ast/transform/clamp_frag_depth.cc b/src/tint/lang/wgsl/ast/transform/clamp_frag_depth.cc
index 9374f71..ccdd747 100644
--- a/src/tint/lang/wgsl/ast/transform/clamp_frag_depth.cc
+++ b/src/tint/lang/wgsl/ast/transform/clamp_frag_depth.cc
@@ -54,7 +54,7 @@
             if (auto* var = global->As<Var>()) {
                 auto* v = src->Sem().Get(var);
                 if (TINT_UNLIKELY(v->AddressSpace() == builtin::AddressSpace::kPushConstant)) {
-                    TINT_ICE(Transform, b.Diagnostics())
+                    TINT_ICE()
                         << "ClampFragDepth doesn't know how to handle module that already use push "
                            "constants";
                     return Program(std::move(b));
diff --git a/src/tint/lang/wgsl/ast/transform/decompose_memory_access.cc b/src/tint/lang/wgsl/ast/transform/decompose_memory_access.cc
index f74656f..fd5aa24 100644
--- a/src/tint/lang/wgsl/ast/transform/decompose_memory_access.cc
+++ b/src/tint/lang/wgsl/ast/transform/decompose_memory_access.cc
@@ -288,9 +288,8 @@
             op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicCompareExchangeWeak;
             break;
         default:
-            TINT_ICE(Transform, builder->Diagnostics())
-                << "invalid IntrinsicType for DecomposeMemoryAccess::Intrinsic: "
-                << ty->TypeInfo().name;
+            TINT_ICE() << "invalid IntrinsicType for DecomposeMemoryAccess::Intrinsic: "
+                       << ty->TypeInfo().name;
             break;
     }
 
@@ -433,7 +432,7 @@
     /// @param expr the expression that performs the access
     /// @param access the access
     void AddAccess(const Expression* expr, const BufferAccess& access) {
-        TINT_ASSERT(Transform, access.type);
+        TINT_ASSERT(access.type);
         accesses.emplace(expr, access);
         expression_order.emplace_back(expr);
     }
@@ -495,7 +494,7 @@
                     // * Override-expression counts can only be applied to workgroup arrays, and
                     //   this method only handles storage and uniform.
                     // * Runtime-sized arrays are not loadable.
-                    TINT_ICE(Transform, b.Diagnostics()) << "unexpected non-constant array count";
+                    TINT_ICE() << "unexpected non-constant array count";
                     arr_cnt = 1;
                 }
                 auto* for_cond = b.create<BinaryExpression>(BinaryOp::kLessThan, b.Expr(i),
@@ -581,8 +580,7 @@
                             // * Override-expression counts can only be applied to workgroup
                             //   arrays, and this method only handles storage and uniform.
                             // * Runtime-sized arrays are not storable.
-                            TINT_ICE(Transform, b.Diagnostics())
-                                << "unexpected non-constant array count";
+                            TINT_ICE() << "unexpected non-constant array count";
                             arr_cnt = 1;
                         }
                         auto* for_cond = b.create<BinaryExpression>(BinaryOp::kLessThan, b.Expr(i),
@@ -651,9 +649,8 @@
 
             auto* atomic = IntrinsicAtomicFor(ctx.dst, op, el_ty, buffer);
             if (TINT_UNLIKELY(!atomic)) {
-                TINT_ICE(Transform, b.Diagnostics())
-                    << "IntrinsicAtomicFor() returned nullptr for op " << op << " and type "
-                    << el_ty->TypeInfo().name;
+                TINT_ICE() << "IntrinsicAtomicFor() returned nullptr for op " << op << " and type "
+                           << el_ty->TypeInfo().name;
             }
 
             Type ret_ty = CreateASTTypeFor(ctx, intrinsic->ReturnType());
diff --git a/src/tint/lang/wgsl/ast/transform/demote_to_helper.cc b/src/tint/lang/wgsl/ast/transform/demote_to_helper.cc
index 0caacab..2e950d9 100644
--- a/src/tint/lang/wgsl/ast/transform/demote_to_helper.cc
+++ b/src/tint/lang/wgsl/ast/transform/demote_to_helper.cc
@@ -134,7 +134,7 @@
                         // Skip these.
                         return;
                     default:
-                        TINT_UNREACHABLE(Transform, b.Diagnostics())
+                        TINT_UNREACHABLE()
                             << "write to unhandled address space: " << ref->AddressSpace();
                 }
 
diff --git a/src/tint/lang/wgsl/ast/transform/direct_variable_access.cc b/src/tint/lang/wgsl/ast/transform/direct_variable_access.cc
index 9e651fa..7cfc434 100644
--- a/src/tint/lang/wgsl/ast/transform/direct_variable_access.cc
+++ b/src/tint/lang/wgsl/ast/transform/direct_variable_access.cc
@@ -1103,7 +1103,7 @@
                 continue;
             }
 
-            TINT_ICE(Transform, b.Diagnostics()) << "unhandled variant for access chain";
+            TINT_ICE() << "unhandled variant for access chain";
             break;
         }
         return ss.str();
@@ -1151,7 +1151,7 @@
             return b.MemberAccessor(expr, ctx.Clone(*member));
         }
 
-        TINT_ICE(Transform, b.Diagnostics()) << "unhandled variant type for access chain";
+        TINT_ICE() << "unhandled variant type for access chain";
         return nullptr;
     }
 
diff --git a/src/tint/lang/wgsl/ast/transform/fold_trivial_lets.cc b/src/tint/lang/wgsl/ast/transform/fold_trivial_lets.cc
index a7cbd26..2d81ceb 100644
--- a/src/tint/lang/wgsl/ast/transform/fold_trivial_lets.cc
+++ b/src/tint/lang/wgsl/ast/transform/fold_trivial_lets.cc
@@ -56,11 +56,11 @@
 
         // Helper that folds pending let declarations into `expr` if possible.
         auto fold_lets = [&](const Expression* expr) {
-            TraverseExpressions(expr, b.Diagnostics(), [&](const IdentifierExpression* ident) {
+            TraverseExpressions(expr, [&](const IdentifierExpression* ident) {
                 if (auto* user = sem.Get<sem::VariableUser>(ident)) {
                     auto itr = pending_lets.Find(user->Variable());
                     if (itr) {
-                        TINT_ASSERT(Transform, itr->remaining_uses > 0);
+                        TINT_ASSERT(itr->remaining_uses > 0);
 
                         // We found a reference to a pending let, so replace it with the inlined
                         // initializer expression.
diff --git a/src/tint/lang/wgsl/ast/transform/localize_struct_array_assignment.cc b/src/tint/lang/wgsl/ast/transform/localize_struct_array_assignment.cc
index 1e7160e..1e617bf 100644
--- a/src/tint/lang/wgsl/ast/transform/localize_struct_array_assignment.cc
+++ b/src/tint/lang/wgsl/ast/transform/localize_struct_array_assignment.cc
@@ -161,7 +161,7 @@
     /// structure member of array type.
     bool ContainsStructArrayIndex(const Expression* expr) {
         bool result = false;
-        TraverseExpressions(expr, b.Diagnostics(), [&](const IndexAccessorExpression* ia) {
+        TraverseExpressions(expr, [&](const IndexAccessorExpression* ia) {
             // Indexing using a runtime value?
             auto* idx_sem = src->Sem().GetVal(ia->index);
             if (!idx_sem->ConstantValue()) {
@@ -187,9 +187,8 @@
         const AssignmentStatement* assign_stmt) {
         auto* root_ident = src->Sem().GetVal(assign_stmt->lhs)->RootIdentifier();
         if (TINT_UNLIKELY(!root_ident)) {
-            TINT_ICE(Transform, b.Diagnostics())
-                << "Unable to determine originating variable for lhs of assignment "
-                   "statement";
+            TINT_ICE() << "Unable to determine originating variable for lhs of assignment "
+                          "statement";
             return {};
         }
 
@@ -202,9 +201,8 @@
                 return std::make_pair(ptr->StoreType(), ptr->AddressSpace());
             },
             [&](Default) {
-                TINT_ICE(Transform, b.Diagnostics())
-                    << "Expecting to find variable of type pointer or reference on lhs "
-                       "of assignment statement";
+                TINT_ICE() << "Expecting to find variable of type pointer or reference on lhs "
+                              "of assignment statement";
                 return std::pair<const type::Type*, builtin::AddressSpace>{};
             });
     }
diff --git a/src/tint/lang/wgsl/ast/transform/merge_return.cc b/src/tint/lang/wgsl/ast/transform/merge_return.cc
index 478d09e..ec25627 100644
--- a/src/tint/lang/wgsl/ast/transform/merge_return.cc
+++ b/src/tint/lang/wgsl/ast/transform/merge_return.cc
@@ -140,7 +140,7 @@
                 TINT_SCOPED_ASSIGNMENT(is_in_loop_or_switch, true);
                 ProcessStatement(w->body);
             },
-            [&](Default) { TINT_ICE(Transform, b.Diagnostics()) << "unhandled statement type"; });
+            [&](Default) { TINT_ICE() << "unhandled statement type"; });
     }
 
     void ProcessBlock(const BlockStatement* block) {
diff --git a/src/tint/lang/wgsl/ast/transform/module_scope_var_to_entry_point_param.cc b/src/tint/lang/wgsl/ast/transform/module_scope_var_to_entry_point_param.cc
index 4b3eb50..b29ed3f 100644
--- a/src/tint/lang/wgsl/ast/transform/module_scope_var_to_entry_point_param.cc
+++ b/src/tint/lang/wgsl/ast/transform/module_scope_var_to_entry_point_param.cc
@@ -205,8 +205,7 @@
                 break;
             }
             default: {
-                TINT_ICE(Transform, ctx.dst->Diagnostics())
-                    << "unhandled module-scope address space (" << sc << ")";
+                TINT_ICE() << "unhandled module-scope address space (" << sc << ")";
                 break;
             }
         }
@@ -241,8 +240,7 @@
                 break;
             }
             default: {
-                TINT_ICE(Transform, ctx.dst->Diagnostics())
-                    << "unhandled module-scope address space (" << sc << ")";
+                TINT_ICE() << "unhandled module-scope address space (" << sc << ")";
             }
         }
 
diff --git a/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc b/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc
index e059ba1..6689242 100644
--- a/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc
+++ b/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc
@@ -353,7 +353,7 @@
                 plane_1_call = b.Call("textureLoad", "plane1", "coord1", 0_a);
                 break;
             default:
-                TINT_ICE(Transform, b.Diagnostics()) << "unhandled builtin: " << call_type;
+                TINT_ICE() << "unhandled builtin: " << call_type;
         }
 
         // var color: vec3<f32>;
@@ -402,10 +402,9 @@
         const Expression* plane_0_binding_param = ctx.Clone(expr->args[0]);
 
         if (TINT_UNLIKELY(expr->args.Length() != 3)) {
-            TINT_ICE(Transform, b.Diagnostics())
-                << "expected textureSampleBaseClampToEdge call with a "
-                   "texture_external to have 3 parameters, found "
-                << expr->args.Length() << " parameters";
+            TINT_ICE() << "expected textureSampleBaseClampToEdge call with a "
+                          "texture_external to have 3 parameters, found "
+                       << expr->args.Length() << " parameters";
         }
 
         // TextureSampleExternal calls the gammaCorrection function, so ensure it
@@ -447,7 +446,7 @@
     /// @returns a call expression to textureLoadExternal
     const CallExpression* createTextureLoad(const sem::Call* call, NewBindingSymbols syms) {
         if (TINT_UNLIKELY(call->Arguments().Length() != 2)) {
-            TINT_ICE(Transform, b.Diagnostics())
+            TINT_ICE()
                 << "expected textureLoad call with a texture_external to have 2 arguments, found "
                 << call->Arguments().Length() << " arguments";
         }
diff --git a/src/tint/lang/wgsl/ast/transform/packed_vec3.cc b/src/tint/lang/wgsl/ast/transform/packed_vec3.cc
index 3042898..688a778 100644
--- a/src/tint/lang/wgsl/ast/transform/packed_vec3.cc
+++ b/src/tint/lang/wgsl/ast/transform/packed_vec3.cc
@@ -96,7 +96,7 @@
     /// @returns the new AST type
     Type MakePackedVec3(const type::Type* ty) {
         auto* vec = ty->As<type::Vector>();
-        TINT_ASSERT(Transform, vec != nullptr && vec->Width() == 3);
+        TINT_ASSERT(vec != nullptr && vec->Width() == 3);
         return b.ty(builtin::Builtin::kPackedVec3, CreateASTTypeFor(ctx, vec->type()));
     }
 
@@ -152,8 +152,7 @@
                     } else if (auto count = arr->ConstantCount()) {
                         return b.ty.array(new_type, u32(count.value()), std::move(attrs));
                     } else {
-                        TINT_ICE(Transform, b.Diagnostics())
-                            << type::Array::kErrExpectedConstantCount;
+                        TINT_ICE() << type::Array::kErrExpectedConstantCount;
                         return {};
                     }
                 }
@@ -247,7 +246,7 @@
         Switch(
             ty,
             [&](const type::Array* arr) {
-                TINT_ASSERT(Transform, arr->ConstantCount());
+                TINT_ASSERT(arr->ConstantCount());
                 copy_array_elements(arr->ConstantCount().value(), arr->ElemType());
             },
             [&](const type::Matrix* mat) {
@@ -461,7 +460,7 @@
 
         // Apply all of the pending unpack operations that we have collected.
         for (auto* expr : to_unpack_sorted) {
-            TINT_ASSERT(Transform, ContainsVec3(expr->Type()));
+            TINT_ASSERT(ContainsVec3(expr->Type()));
             auto* packed = ctx.Clone(expr->Declaration());
             const Expression* unpacked = nullptr;
             if (IsVec3(expr->Type())) {
@@ -476,13 +475,13 @@
                 // Use a helper function to unpack an array or matrix.
                 unpacked = UnpackComposite(packed, expr->Type());
             }
-            TINT_ASSERT(Transform, unpacked != nullptr);
+            TINT_ASSERT(unpacked != nullptr);
             ctx.Replace(expr->Declaration(), unpacked);
         }
 
         // Apply all of the pending pack operations that we have collected.
         for (auto* expr : to_pack_sorted) {
-            TINT_ASSERT(Transform, ContainsVec3(expr->Type()));
+            TINT_ASSERT(ContainsVec3(expr->Type()));
             auto* unpacked = ctx.Clone(expr->Declaration());
             const Expression* packed = nullptr;
             if (IsVec3(expr->Type())) {
@@ -492,7 +491,7 @@
                 // Use a helper function to pack an array or matrix.
                 packed = PackComposite(unpacked, expr->Type());
             }
-            TINT_ASSERT(Transform, packed != nullptr);
+            TINT_ASSERT(packed != nullptr);
             ctx.Replace(expr->Declaration(), packed);
         }
 
diff --git a/src/tint/lang/wgsl/ast/transform/preserve_padding.cc b/src/tint/lang/wgsl/ast/transform/preserve_padding.cc
index d4fb411..4dda687 100644
--- a/src/tint/lang/wgsl/ast/transform/preserve_padding.cc
+++ b/src/tint/lang/wgsl/ast/transform/preserve_padding.cc
@@ -174,7 +174,7 @@
                 });
             },
             [&](Default) {
-                TINT_ICE(Transform, b.Diagnostics()) << "unhandled type with padding";
+                TINT_ICE() << "unhandled type with padding";
                 return nullptr;
             });
     }
diff --git a/src/tint/lang/wgsl/ast/transform/promote_initializers_to_let.cc b/src/tint/lang/wgsl/ast/transform/promote_initializers_to_let.cc
index 7a520bb..4bb5bee 100644
--- a/src/tint/lang/wgsl/ast/transform/promote_initializers_to_let.cc
+++ b/src/tint/lang/wgsl/ast/transform/promote_initializers_to_let.cc
@@ -104,7 +104,7 @@
                 // visit leaf-expressions first, this means the content of const_chains only
                 // contains the outer-most constant expressions.
                 auto* expr = sem->Declaration();
-                bool ok = TraverseExpressions(expr, b.Diagnostics(), [&](const Expression* child) {
+                bool ok = TraverseExpressions(expr, [&](const Expression* child) {
                     const_chains.Remove(child);
                     return child == expr ? TraverseAction::Descend : TraverseAction::Skip;
                 });
diff --git a/src/tint/lang/wgsl/ast/transform/promote_side_effects_to_decl.cc b/src/tint/lang/wgsl/ast/transform/promote_side_effects_to_decl.cc
index 2aa2cd0..1e989f9 100644
--- a/src/tint/lang/wgsl/ast/transform/promote_side_effects_to_decl.cc
+++ b/src/tint/lang/wgsl/ast/transform/promote_side_effects_to_decl.cc
@@ -166,7 +166,7 @@
                 return false;
             },
             [&](Default) {
-                TINT_ICE(Transform, b.Diagnostics()) << "Unhandled expression type";
+                TINT_ICE() << "Unhandled expression type";
                 return false;
             });
     }
@@ -328,7 +328,7 @@
                 return false;
             },
             [&](Default) {
-                TINT_ICE(Transform, b.Diagnostics()) << "Unhandled expression type";
+                TINT_ICE() << "Unhandled expression type";
                 return false;
             });
     }
@@ -511,8 +511,7 @@
                 return clone_maybe_hoisted(phony);  // Leaf expression, just clone as is
             },
             [&](Default) {
-                TINT_ICE(AST, b.Diagnostics())
-                    << "unhandled expression type: " << expr->TypeInfo().name;
+                TINT_ICE() << "unhandled expression type: " << expr->TypeInfo().name;
                 return nullptr;
             });
     }
diff --git a/src/tint/lang/wgsl/ast/transform/remove_phonies.cc b/src/tint/lang/wgsl/ast/transform/remove_phonies.cc
index 92e6526..2f51084 100644
--- a/src/tint/lang/wgsl/ast/transform/remove_phonies.cc
+++ b/src/tint/lang/wgsl/ast/transform/remove_phonies.cc
@@ -58,25 +58,24 @@
                     made_changes = true;
 
                     std::vector<const Expression*> side_effects;
-                    if (!TraverseExpressions(
-                            stmt->rhs, b.Diagnostics(), [&](const CallExpression* expr) {
-                                // CallExpression may map to a function or builtin call
-                                // (both may have side-effects), or a value constructor or value
-                                // conversion (both do not have side effects).
-                                auto* call = sem.Get<sem::Call>(expr);
-                                if (!call) {
-                                    // Semantic node must be a Materialize, in which case the
-                                    // expression was creation-time (compile time), so could not
-                                    // have side effects. Just skip.
-                                    return TraverseAction::Skip;
-                                }
-                                if (call->Target()->IsAnyOf<sem::Function, sem::Builtin>() &&
-                                    call->HasSideEffects()) {
-                                    side_effects.push_back(expr);
-                                    return TraverseAction::Skip;
-                                }
-                                return TraverseAction::Descend;
-                            })) {
+                    if (!TraverseExpressions(stmt->rhs, [&](const CallExpression* expr) {
+                            // CallExpression may map to a function or builtin call
+                            // (both may have side-effects), or a value constructor or value
+                            // conversion (both do not have side effects).
+                            auto* call = sem.Get<sem::Call>(expr);
+                            if (!call) {
+                                // Semantic node must be a Materialize, in which case the
+                                // expression was creation-time (compile time), so could not
+                                // have side effects. Just skip.
+                                return TraverseAction::Skip;
+                            }
+                            if (call->Target()->IsAnyOf<sem::Function, sem::Builtin>() &&
+                                call->HasSideEffects()) {
+                                side_effects.push_back(expr);
+                                return TraverseAction::Skip;
+                            }
+                            return TraverseAction::Descend;
+                        })) {
                         return;
                     }
 
diff --git a/src/tint/lang/wgsl/ast/transform/robustness.cc b/src/tint/lang/wgsl/ast/transform/robustness.cc
index ecebc7d..3f3e93f 100644
--- a/src/tint/lang/wgsl/ast/transform/robustness.cc
+++ b/src/tint/lang/wgsl/ast/transform/robustness.cc
@@ -261,9 +261,8 @@
                 return nullptr;
             },
             [&](Default) -> const Expression* {
-                TINT_ICE(Transform, b.Diagnostics())
-                    << "unhandled object type in robustness of array index: "
-                    << obj_type->UnwrapRef()->FriendlyName();
+                TINT_ICE() << "unhandled object type in robustness of array index: "
+                           << obj_type->UnwrapRef()->FriendlyName();
                 return nullptr;
             });
     }
@@ -641,7 +640,7 @@
             default:
                 break;
         }
-        TINT_UNREACHABLE(Transform, b.Diagnostics()) << "unhandled address space" << address_space;
+        TINT_UNREACHABLE() << "unhandled address space" << address_space;
         return Action::kDefault;
     }
 
diff --git a/src/tint/lang/wgsl/ast/transform/single_entry_point.cc b/src/tint/lang/wgsl/ast/transform/single_entry_point.cc
index 35723ef..4019eb7 100644
--- a/src/tint/lang/wgsl/ast/transform/single_entry_point.cc
+++ b/src/tint/lang/wgsl/ast/transform/single_entry_point.cc
@@ -117,8 +117,7 @@
             [&](const Enable* ext) { b.AST().AddEnable(ctx.Clone(ext)); },
             [&](const DiagnosticDirective* d) { b.AST().AddDiagnosticDirective(ctx.Clone(d)); },
             [&](Default) {
-                TINT_UNREACHABLE(Transform, b.Diagnostics())
-                    << "unhandled global declaration: " << decl->TypeInfo().name;
+                TINT_UNREACHABLE() << "unhandled global declaration: " << decl->TypeInfo().name;
             });
     }
 
diff --git a/src/tint/lang/wgsl/ast/transform/spirv_atomic.cc b/src/tint/lang/wgsl/ast/transform/spirv_atomic.cc
index d5a64f2..96d5525 100644
--- a/src/tint/lang/wgsl/ast/transform/spirv_atomic.cc
+++ b/src/tint/lang/wgsl/ast/transform/spirv_atomic.cc
@@ -220,7 +220,7 @@
             },
             [&](const type::Reference* ref) { return AtomicTypeFor(ref->StoreType()); },
             [&](Default) {
-                TINT_ICE(Transform, b.Diagnostics()) << "unhandled type: " << ty->FriendlyName();
+                TINT_ICE();
                 return Type{};
             });
     }
diff --git a/src/tint/lang/wgsl/ast/transform/std140.cc b/src/tint/lang/wgsl/ast/transform/std140.cc
index 0b7939c..0a18620 100644
--- a/src/tint/lang/wgsl/ast/transform/std140.cc
+++ b/src/tint/lang/wgsl/ast/transform/std140.cc
@@ -437,8 +437,7 @@
                         // * Override-expression counts can only be applied to workgroup arrays, and
                         //   this method only handles types transitively used as uniform buffers.
                         // * Runtime-sized arrays cannot be used in uniform buffers.
-                        TINT_ICE(Transform, b.Diagnostics())
-                            << "unexpected non-constant array count";
+                        TINT_ICE() << "unexpected non-constant array count";
                         count = 1;
                     }
                     return b.ty.array(std140, b.Expr(u32(count.value())), std::move(attrs));
@@ -523,9 +522,8 @@
                         expr = user->Variable()->Initializer();
                         return Action::kContinue;
                     }
-                    TINT_ICE(Transform, b.Diagnostics())
-                        << "unexpected variable found walking access chain: "
-                        << user->Variable()->Declaration()->name->symbol.Name();
+                    TINT_ICE() << "unexpected variable found walking access chain: "
+                               << user->Variable()->Declaration()->name->symbol.Name();
                     return Action::kError;
                 },
                 [&](const sem::StructMemberAccess* a) {
@@ -580,18 +578,16 @@
                                               expr = sem.GetVal(u->expr);
                                               return Action::kContinue;
                                           default:
-                                              TINT_ICE(Transform, b.Diagnostics())
-                                                  << "unhandled unary op for access chain: "
-                                                  << u->op;
+                                              TINT_ICE() << "unhandled unary op for access chain: "
+                                                         << u->op;
                                               return Action::kError;
                                       }
                                   });
                 },
                 [&](Default) {
-                    TINT_ICE(Transform, b.Diagnostics())
-                        << "unhandled expression type for access chain\n"
-                        << "AST: " << expr->Declaration()->TypeInfo().name << "\n"
-                        << "SEM: " << expr->TypeInfo().name;
+                    TINT_ICE() << "unhandled expression type for access chain\n"
+                               << "AST: " << expr->Declaration()->TypeInfo().name << "\n"
+                               << "SEM: " << expr->TypeInfo().name;
                     return Action::kError;
                 });
 
@@ -636,7 +632,7 @@
                     // * Override-expression counts can only be applied to workgroup arrays, and
                     //   this method only handles types transitively used as uniform buffers.
                     // * Runtime-sized arrays cannot be used in uniform buffers.
-                    TINT_ICE(Transform, b.Diagnostics()) << "unexpected non-constant array count";
+                    TINT_ICE() << "unexpected non-constant array count";
                     count = 1;
                 }
                 return "arr" + std::to_string(count.value()) + "_" + ConvertSuffix(arr->ElemType());
@@ -648,8 +644,7 @@
             [&](const type::F32*) { return "f32"; },  //
             [&](const type::F16*) { return "f16"; },
             [&](Default) {
-                TINT_ICE(Transform, b.Diagnostics())
-                    << "unhandled type for conversion name: " << ty->FriendlyName();
+                TINT_ICE() << "unhandled type for conversion name: " << ty->FriendlyName();
                 return "";
             });
     }
@@ -724,7 +719,7 @@
                         });
                         stmts.Push(b.Return(b.Call(mat_ty, std::move(mat_args))));
                     } else {
-                        TINT_ICE(Transform, b.Diagnostics())
+                        TINT_ICE()
                             << "failed to find std140 matrix info for: " << ty->FriendlyName();
                     }
                 },  //
@@ -742,8 +737,7 @@
                         // * Override-expression counts can only be applied to workgroup arrays, and
                         //   this method only handles types transitively used as uniform buffers.
                         // * Runtime-sized arrays cannot be used in uniform buffers.
-                        TINT_ICE(Transform, b.Diagnostics())
-                            << "unexpected non-constant array count";
+                        TINT_ICE() << "unexpected non-constant array count";
                         count = 1;
                     }
                     stmts.Push(b.Decl(var));
@@ -754,8 +748,7 @@
                     stmts.Push(b.Return(var));
                 },
                 [&](Default) {
-                    TINT_ICE(Transform, b.Diagnostics())
-                        << "unhandled type for conversion: " << ty->FriendlyName();
+                    TINT_ICE() << "unhandled type for conversion: " << ty->FriendlyName();
                 });
 
             // Generate the function
@@ -1100,8 +1093,7 @@
                     return {expr, vec->type(), name};
                 },  //
                 [&](Default) -> ExprTypeName {
-                    TINT_ICE(Transform, b.Diagnostics())
-                        << "unhandled type for access chain: " << ty->FriendlyName();
+                    TINT_ICE() << "unhandled type for access chain: " << ty->FriendlyName();
                     return {};
                 });
         }
@@ -1121,8 +1113,7 @@
                     return {expr, swizzle_ty, rhs};
                 },  //
                 [&](Default) -> ExprTypeName {
-                    TINT_ICE(Transform, b.Diagnostics())
-                        << "unhandled type for access chain: " << ty->FriendlyName();
+                    TINT_ICE() << "unhandled type for access chain: " << ty->FriendlyName();
                     return {};
                 });
         }
@@ -1150,8 +1141,7 @@
                 return {expr, vec->type(), std::to_string(idx)};
             },  //
             [&](Default) -> ExprTypeName {
-                TINT_ICE(Transform, b.Diagnostics())
-                    << "unhandled type for access chain: " << ty->FriendlyName();
+                TINT_ICE() << "unhandled type for access chain: " << ty->FriendlyName();
                 return {};
             });
     }
diff --git a/src/tint/lang/wgsl/ast/transform/transform.cc b/src/tint/lang/wgsl/ast/transform/transform.cc
index ab0bdfb..5b561bb 100644
--- a/src/tint/lang/wgsl/ast/transform/transform.cc
+++ b/src/tint/lang/wgsl/ast/transform/transform.cc
@@ -59,8 +59,7 @@
         ctx.Replace(stmt, static_cast<Expression*>(nullptr));
         return;
     }
-    TINT_ICE(Transform, ctx.dst->Diagnostics())
-        << "unable to remove statement from parent of type " << sem->TypeInfo().name;
+    TINT_ICE() << "unable to remove statement from parent of type " << sem->TypeInfo().name;
 }
 
 Type Transform::CreateASTTypeFor(CloneContext& ctx, const type::Type* ty) {
@@ -89,7 +88,7 @@
     if (auto* v = ty->As<type::Vector>()) {
         auto el = CreateASTTypeFor(ctx, v->type());
         if (v->Packed()) {
-            TINT_ASSERT(Transform, v->Width() == 3u);
+            TINT_ASSERT(v->Width() == 3u);
             return ctx.dst->ty(builtin::Builtin::kPackedVec3, el);
         } else {
             return ctx.dst->ty.vec(el, v->Width());
@@ -127,7 +126,7 @@
         }
         auto count = a->ConstantCount();
         if (TINT_UNLIKELY(!count)) {
-            TINT_ICE(Transform, ctx.dst->Diagnostics()) << type::Array::kErrExpectedConstantCount;
+            TINT_ICE() << type::Array::kErrExpectedConstantCount;
             return ctx.dst->ty.array(el, u32(1), std::move(attrs));
         }
         return ctx.dst->ty.array(el, u32(count.value()), std::move(attrs));
@@ -171,8 +170,7 @@
                           : builtin::Access::kUndefined;
         return ctx.dst->ty.ptr(address_space, CreateASTTypeFor(ctx, p->StoreType()), access);
     }
-    TINT_UNREACHABLE(Transform, ctx.dst->Diagnostics())
-        << "Unhandled type: " << ty->TypeInfo().name;
+    TINT_UNREACHABLE() << "Unhandled type: " << ty->TypeInfo().name;
     return Type{};
 }
 
diff --git a/src/tint/lang/wgsl/ast/transform/truncate_interstage_variables.cc b/src/tint/lang/wgsl/ast/transform/truncate_interstage_variables.cc
index 5f076f6..1e6f3e4 100644
--- a/src/tint/lang/wgsl/ast/transform/truncate_interstage_variables.cc
+++ b/src/tint/lang/wgsl/ast/transform/truncate_interstage_variables.cc
@@ -86,10 +86,9 @@
         // 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"
-                << "TruncateInterstageVariables transform needs to run after "
-                   "CanonicalizeEntryPointIO transform.";
+            TINT_ICE() << "Entrypoint function return type is non-struct.\n"
+                       << "TruncateInterstageVariables transform needs to run after "
+                          "CanonicalizeEntryPointIO transform.";
             continue;
         }
 
diff --git a/src/tint/lang/wgsl/ast/transform/unshadow.cc b/src/tint/lang/wgsl/ast/transform/unshadow.cc
index 09ba661..17da2d1 100644
--- a/src/tint/lang/wgsl/ast/transform/unshadow.cc
+++ b/src/tint/lang/wgsl/ast/transform/unshadow.cc
@@ -74,8 +74,7 @@
                     return b.Param(source, symbol, type, attributes);
                 },
                 [&](Default) {
-                    TINT_ICE(Transform, b.Diagnostics())
-                        << "unexpected variable type: " << decl->TypeInfo().name;
+                    TINT_ICE() << "unexpected variable type: " << decl->TypeInfo().name;
                     return nullptr;
                 });
         };
diff --git a/src/tint/lang/wgsl/ast/transform/utils/get_insertion_point.cc b/src/tint/lang/wgsl/ast/transform/utils/get_insertion_point.cc
index d5f541e..641028d 100644
--- a/src/tint/lang/wgsl/ast/transform/utils/get_insertion_point.cc
+++ b/src/tint/lang/wgsl/ast/transform/utils/get_insertion_point.cc
@@ -14,15 +14,14 @@
 
 #include "src/tint/lang/wgsl/ast/transform/utils/get_insertion_point.h"
 #include "src/tint/lang/wgsl/sem/for_loop_statement.h"
-#include "src/tint/utils/debug/debug.h"
 #include "src/tint/utils/diagnostic/diagnostic.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/rtti/switch.h"
 
 namespace tint::ast::transform::utils {
 
 InsertionPoint GetInsertionPoint(CloneContext& ctx, const Statement* stmt) {
     auto& sem = ctx.src->Sem();
-    auto& diag = ctx.dst->Diagnostics();
     using RetType = std::pair<const sem::BlockStatement*, const Statement*>;
 
     if (auto* sem_stmt = sem.Get(stmt)) {
@@ -46,8 +45,8 @@
                 return {};
             },
             [&](Default) -> RetType {
-                TINT_ICE(Transform, diag) << "expected parent of statement to be "
-                                             "either a block or for loop";
+                TINT_ICE() << "expected parent of statement to be "
+                              "either a block or for loop";
                 return {};
             });
     }
diff --git a/src/tint/lang/wgsl/ast/transform/utils/get_insertion_point_test.cc b/src/tint/lang/wgsl/ast/transform/utils/get_insertion_point_test.cc
index 5e8deb4..8a779ce 100644
--- a/src/tint/lang/wgsl/ast/transform/utils/get_insertion_point_test.cc
+++ b/src/tint/lang/wgsl/ast/transform/utils/get_insertion_point_test.cc
@@ -18,7 +18,7 @@
 #include "src/tint/lang/wgsl/ast/transform/test_helper.h"
 #include "src/tint/lang/wgsl/ast/transform/utils/get_insertion_point.h"
 #include "src/tint/lang/wgsl/program/program_builder.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 
 using namespace tint::number_suffixes;  // NOLINT
 
@@ -41,8 +41,7 @@
     ProgramBuilder cloned_b;
     CloneContext ctx(&cloned_b, &original);
 
-    // Can insert in block containing the variable, above or below the input
-    // statement.
+    // Can insert in block containing the variable, above or below the input statement.
     auto ip = utils::GetInsertionPoint(ctx, var);
     ASSERT_EQ(ip.first->Declaration(), block);
     ASSERT_EQ(ip.second, var);
@@ -85,8 +84,7 @@
     ProgramBuilder cloned_b;
     CloneContext ctx(&cloned_b, &original);
 
-    // Can't insert before/after for loop continue statement (would ned to be
-    // converted to loop).
+    // Can't insert before/after for loop continue statement (would ned to be converted to loop).
     auto ip = utils::GetInsertionPoint(ctx, var);
     ASSERT_EQ(ip.first, nullptr);
     ASSERT_EQ(ip.second, nullptr);
diff --git a/src/tint/lang/wgsl/ast/transform/utils/hoist_to_decl_before.cc b/src/tint/lang/wgsl/ast/transform/utils/hoist_to_decl_before.cc
index 8f81f37..49a2950 100644
--- a/src/tint/lang/wgsl/ast/transform/utils/hoist_to_decl_before.cc
+++ b/src/tint/lang/wgsl/ast/transform/utils/hoist_to_decl_before.cc
@@ -45,7 +45,7 @@
         switch (kind) {
             case VariableKind::kLet: {
                 auto* ty = ctx.src->Sem().GetVal(expr)->Type();
-                TINT_ASSERT(Transform, !ty->HoldsAbstract());
+                TINT_ASSERT(!ty->HoldsAbstract());
                 auto builder = [this, expr, name, ty] {
                     return b.Decl(b.Let(name, Transform::CreateASTTypeFor(ctx, ty),
                                         ctx.CloneWithoutTransform(expr)));
@@ -58,7 +58,7 @@
 
             case VariableKind::kVar: {
                 auto* ty = ctx.src->Sem().GetVal(expr)->Type();
-                TINT_ASSERT(Transform, !ty->HoldsAbstract());
+                TINT_ASSERT(!ty->HoldsAbstract());
                 auto builder = [this, expr, name, ty] {
                     return b.Decl(b.Var(name, Transform::CreateASTTypeFor(ctx, ty),
                                         ctx.CloneWithoutTransform(expr)));
@@ -397,12 +397,11 @@
                 return true;
             }
 
-            TINT_ICE(Transform, b.Diagnostics()) << "unhandled use of expression in for-loop";
+            TINT_ICE() << "unhandled use of expression in for-loop";
             return false;
         }
 
-        TINT_ICE(Transform, b.Diagnostics())
-            << "unhandled expression parent statement type: " << parent->TypeInfo().name;
+        TINT_ICE() << "unhandled expression parent statement type: " << parent->TypeInfo().name;
         return false;
     }
 };
diff --git a/src/tint/lang/wgsl/ast/transform/vectorize_matrix_conversions.cc b/src/tint/lang/wgsl/ast/transform/vectorize_matrix_conversions.cc
index 482abfe..05d89a8 100644
--- a/src/tint/lang/wgsl/ast/transform/vectorize_matrix_conversions.cc
+++ b/src/tint/lang/wgsl/ast/transform/vectorize_matrix_conversions.cc
@@ -96,8 +96,7 @@
         // The source and destination type of a matrix conversion must have a same shape.
         if (TINT_UNLIKELY(!(src_type->rows() == dst_type->rows() &&
                             src_type->columns() == dst_type->columns()))) {
-            TINT_ICE(Transform, b.Diagnostics())
-                << "source and destination matrix has different shape in matrix conversion";
+            TINT_ICE() << "source and destination matrix has different shape in matrix conversion";
             return nullptr;
         }
 
diff --git a/src/tint/lang/wgsl/ast/transform/vectorize_scalar_matrix_initializers.cc b/src/tint/lang/wgsl/ast/transform/vectorize_scalar_matrix_initializers.cc
index bb55628..cbdcfc3 100644
--- a/src/tint/lang/wgsl/ast/transform/vectorize_scalar_matrix_initializers.cc
+++ b/src/tint/lang/wgsl/ast/transform/vectorize_scalar_matrix_initializers.cc
@@ -134,8 +134,7 @@
             });
         }
 
-        TINT_ICE(Transform, b.Diagnostics())
-            << "matrix initializer has unexpected number of arguments";
+        TINT_ICE() << "matrix initializer has unexpected number of arguments";
         return nullptr;
     });
 
diff --git a/src/tint/lang/wgsl/ast/transform/vertex_pulling.cc b/src/tint/lang/wgsl/ast/transform/vertex_pulling.cc
index 17bcf6f..40630d3 100644
--- a/src/tint/lang/wgsl/ast/transform/vertex_pulling.cc
+++ b/src/tint/lang/wgsl/ast/transform/vertex_pulling.cc
@@ -426,7 +426,7 @@
                             value = b.MemberAccessor(fetch, "xyz");
                             break;
                         default:
-                            TINT_UNREACHABLE(Transform, b.Diagnostics()) << var_dt.width;
+                            TINT_UNREACHABLE() << var_dt.width;
                             return nullptr;
                     }
                 } else if (var_dt.width > fmt_dt.width) {
@@ -668,7 +668,7 @@
                                          b.Call("unpack2x16float", load_next_u32()));
         }
 
-        TINT_UNREACHABLE(Transform, b.Diagnostics()) << "format " << static_cast<int>(format);
+        TINT_UNREACHABLE();
         return nullptr;
     }
 
@@ -721,8 +721,7 @@
             default:
                 break;
         }
-        TINT_UNREACHABLE(Transform, b.Diagnostics())
-            << "invalid format for LoadPrimitive" << static_cast<int>(format);
+        TINT_UNREACHABLE() << "invalid format for LoadPrimitive" << static_cast<int>(format);
         return nullptr;
     }
 
@@ -772,14 +771,14 @@
             info.type = sem->Type();
 
             if (TINT_UNLIKELY(!sem->Location().has_value())) {
-                TINT_ICE(Transform, b.Diagnostics()) << "Location missing value";
+                TINT_ICE() << "Location missing value";
                 return;
             }
             location_info[sem->Location().value()] = info;
         } else {
             auto* builtin_attr = GetAttribute<BuiltinAttribute>(param->attributes);
             if (TINT_UNLIKELY(!builtin_attr)) {
-                TINT_ICE(Transform, b.Diagnostics()) << "Invalid entry point parameter";
+                TINT_ICE() << "Invalid entry point parameter";
                 return;
             }
             auto builtin = src->Sem().Get(builtin_attr)->Value();
@@ -827,13 +826,13 @@
                 auto* sem = src->Sem().Get(member);
                 info.type = sem->Type();
 
-                TINT_ASSERT(Transform, sem->Attributes().location.has_value());
+                TINT_ASSERT(sem->Attributes().location.has_value());
                 location_info[sem->Attributes().location.value()] = info;
                 has_locations = true;
             } else {
                 auto* builtin_attr = GetAttribute<BuiltinAttribute>(member->attributes);
                 if (TINT_UNLIKELY(!builtin_attr)) {
-                    TINT_ICE(Transform, b.Diagnostics()) << "Invalid entry point parameter";
+                    TINT_ICE() << "Invalid entry point parameter";
                     return;
                 }
                 auto builtin = src->Sem().Get(builtin_attr)->Value();
diff --git a/src/tint/lang/wgsl/ast/transform/zero_init_workgroup_memory.cc b/src/tint/lang/wgsl/ast/transform/zero_init_workgroup_memory.cc
index c8772d6..eec3828 100644
--- a/src/tint/lang/wgsl/ast/transform/zero_init_workgroup_memory.cc
+++ b/src/tint/lang/wgsl/ast/transform/zero_init_workgroup_memory.cc
@@ -359,8 +359,7 @@
             return BuildZeroingStatements(arr->ElemType(), get_el);
         }
 
-        TINT_UNREACHABLE(Transform, b.Diagnostics())
-            << "could not zero workgroup type: " << ty->FriendlyName();
+        TINT_UNREACHABLE() << "could not zero workgroup type: " << ty->FriendlyName();
         return false;
     }
 
diff --git a/src/tint/lang/wgsl/ast/traverse_expressions.h b/src/tint/lang/wgsl/ast/traverse_expressions.h
index f3ecd3c..17688c2 100644
--- a/src/tint/lang/wgsl/ast/traverse_expressions.h
+++ b/src/tint/lang/wgsl/ast/traverse_expressions.h
@@ -55,15 +55,14 @@
 /// from `root`, calling `callback` for each of the visited expressions that
 /// match the predicate parameter type, in pre-ordering (root first).
 /// @param root the root expression node
-/// @param diags the diagnostics used for error messages
 /// @param callback the callback function. Must be of the signature:
 ///        `TraverseAction(const T* expr)` or `TraverseAction(const T* expr, size_t depth)` where T
 ///        is an Expression type.
 /// @return true on success, false on error
 template <TraverseOrder ORDER = TraverseOrder::LeftToRight, typename CALLBACK>
-bool TraverseExpressions(const Expression* root, diag::List& diags, CALLBACK&& callback) {
-    using EXPR_TYPE = std::remove_pointer_t<tint::traits::ParameterType<CALLBACK, 0>>;
-    constexpr static bool kHasDepthArg = tint::traits::SignatureOfT<CALLBACK>::parameter_count == 2;
+bool TraverseExpressions(const Expression* root, CALLBACK&& callback) {
+    using EXPR_TYPE = std::remove_pointer_t<traits::ParameterType<CALLBACK, 0>>;
+    constexpr static bool kHasDepthArg = traits::SignatureOfT<CALLBACK>::parameter_count == 2;
 
     struct Pending {
         const Expression* expr;
@@ -147,8 +146,8 @@
                                                PhonyExpression>()))) {
                     return true;  // Leaf expression
                 }
-                TINT_ICE(AST, diags)
-                    << "unhandled expression type: " << (expr ? expr->TypeInfo().name : "<null>");
+                TINT_ICE() << "unhandled expression type: "
+                           << (expr ? expr->TypeInfo().name : "<null>");
                 return false;
             });
         if (!ok) {
diff --git a/src/tint/lang/wgsl/ast/traverse_expressions_test.cc b/src/tint/lang/wgsl/ast/traverse_expressions_test.cc
index 7fd864a..4f9d567 100644
--- a/src/tint/lang/wgsl/ast/traverse_expressions_test.cc
+++ b/src/tint/lang/wgsl/ast/traverse_expressions_test.cc
@@ -31,20 +31,18 @@
     auto* root = IndexAccessor(i[0], i[1]);
     {
         std::vector<const Expression*> l2r;
-        TraverseExpressions<TraverseOrder::LeftToRight>(root, Diagnostics(),
-                                                        [&](const Expression* expr) {
-                                                            l2r.push_back(expr);
-                                                            return TraverseAction::Descend;
-                                                        });
+        TraverseExpressions<TraverseOrder::LeftToRight>(root, [&](const Expression* expr) {
+            l2r.push_back(expr);
+            return TraverseAction::Descend;
+        });
         EXPECT_THAT(l2r, ElementsAre(root, i[0], e[0], e[1], i[1], e[2], e[3]));
     }
     {
         std::vector<const Expression*> r2l;
-        TraverseExpressions<TraverseOrder::RightToLeft>(root, Diagnostics(),
-                                                        [&](const Expression* expr) {
-                                                            r2l.push_back(expr);
-                                                            return TraverseAction::Descend;
-                                                        });
+        TraverseExpressions<TraverseOrder::RightToLeft>(root, [&](const Expression* expr) {
+            r2l.push_back(expr);
+            return TraverseAction::Descend;
+        });
         EXPECT_THAT(r2l, ElementsAre(root, i[1], e[3], e[2], i[0], e[1], e[0]));
     }
 }
@@ -55,20 +53,18 @@
     auto* root = Mul(i[0], i[1]);
     {
         std::vector<const Expression*> l2r;
-        TraverseExpressions<TraverseOrder::LeftToRight>(root, Diagnostics(),
-                                                        [&](const Expression* expr) {
-                                                            l2r.push_back(expr);
-                                                            return TraverseAction::Descend;
-                                                        });
+        TraverseExpressions<TraverseOrder::LeftToRight>(root, [&](const Expression* expr) {
+            l2r.push_back(expr);
+            return TraverseAction::Descend;
+        });
         EXPECT_THAT(l2r, ElementsAre(root, i[0], e[0], e[1], i[1], e[2], e[3]));
     }
     {
         std::vector<const Expression*> r2l;
-        TraverseExpressions<TraverseOrder::RightToLeft>(root, Diagnostics(),
-                                                        [&](const Expression* expr) {
-                                                            r2l.push_back(expr);
-                                                            return TraverseAction::Descend;
-                                                        });
+        TraverseExpressions<TraverseOrder::RightToLeft>(root, [&](const Expression* expr) {
+            r2l.push_back(expr);
+            return TraverseAction::Descend;
+        });
         EXPECT_THAT(r2l, ElementsAre(root, i[1], e[3], e[2], i[0], e[1], e[0]));
     }
 }
@@ -82,7 +78,7 @@
     size_t depths[] = {0, 1, 2, 2, 1, 2, 2};
     {
         TraverseExpressions<TraverseOrder::LeftToRight>(  //
-            root, Diagnostics(), [&](const Expression* expr, size_t depth) {
+            root, [&](const Expression* expr, size_t depth) {
                 (void)expr;
                 EXPECT_THAT(depth, depths[j++]);
                 return TraverseAction::Descend;
@@ -97,21 +93,19 @@
     auto* b2 = Bitcast<i32>(b1);
     auto* root = Bitcast<i32>(b2);
     {
-        tint::Vector<const Expression*, 8> l2r;
-        TraverseExpressions<TraverseOrder::LeftToRight>(root, Diagnostics(),
-                                                        [&](const Expression* expr) {
-                                                            l2r.Push(expr);
-                                                            return TraverseAction::Descend;
-                                                        });
+        Vector<const Expression*, 8> l2r;
+        TraverseExpressions<TraverseOrder::LeftToRight>(root, [&](const Expression* expr) {
+            l2r.Push(expr);
+            return TraverseAction::Descend;
+        });
         EXPECT_THAT(l2r, ElementsAre(root, b2, b1, b0, e));
     }
     {
-        tint::Vector<const Expression*, 8> r2l;
-        TraverseExpressions<TraverseOrder::RightToLeft>(root, Diagnostics(),
-                                                        [&](const Expression* expr) {
-                                                            r2l.Push(expr);
-                                                            return TraverseAction::Descend;
-                                                        });
+        Vector<const Expression*, 8> r2l;
+        TraverseExpressions<TraverseOrder::RightToLeft>(root, [&](const Expression* expr) {
+            r2l.Push(expr);
+            return TraverseAction::Descend;
+        });
         EXPECT_THAT(r2l, ElementsAre(root, b2, b1, b0, e));
     }
 }
@@ -121,21 +115,19 @@
     tint::Vector c{Call("a", e[0], e[1]), Call("b", e[2], e[3])};
     auto* root = Call("c", c[0], c[1]);
     {
-        tint::Vector<const Expression*, 8> l2r;
-        TraverseExpressions<TraverseOrder::LeftToRight>(root, Diagnostics(),
-                                                        [&](const Expression* expr) {
-                                                            l2r.Push(expr);
-                                                            return TraverseAction::Descend;
-                                                        });
+        Vector<const Expression*, 8> l2r;
+        TraverseExpressions<TraverseOrder::LeftToRight>(root, [&](const Expression* expr) {
+            l2r.Push(expr);
+            return TraverseAction::Descend;
+        });
         EXPECT_THAT(l2r, ElementsAre(root, c[0], e[0], e[1], c[1], e[2], e[3]));
     }
     {
-        tint::Vector<const Expression*, 8> r2l;
-        TraverseExpressions<TraverseOrder::RightToLeft>(root, Diagnostics(),
-                                                        [&](const Expression* expr) {
-                                                            r2l.Push(expr);
-                                                            return TraverseAction::Descend;
-                                                        });
+        Vector<const Expression*, 8> r2l;
+        TraverseExpressions<TraverseOrder::RightToLeft>(root, [&](const Expression* expr) {
+            r2l.Push(expr);
+            return TraverseAction::Descend;
+        });
         EXPECT_THAT(r2l, ElementsAre(root, c[1], e[3], e[2], c[0], e[1], e[0]));
     }
 }
@@ -146,20 +138,18 @@
     auto* root = MemberAccessor(m, "b");
     {
         std::vector<const Expression*> l2r;
-        TraverseExpressions<TraverseOrder::LeftToRight>(root, Diagnostics(),
-                                                        [&](const Expression* expr) {
-                                                            l2r.push_back(expr);
-                                                            return TraverseAction::Descend;
-                                                        });
+        TraverseExpressions<TraverseOrder::LeftToRight>(root, [&](const Expression* expr) {
+            l2r.push_back(expr);
+            return TraverseAction::Descend;
+        });
         EXPECT_THAT(l2r, ElementsAre(root, m, e));
     }
     {
         std::vector<const Expression*> r2l;
-        TraverseExpressions<TraverseOrder::RightToLeft>(root, Diagnostics(),
-                                                        [&](const Expression* expr) {
-                                                            r2l.push_back(expr);
-                                                            return TraverseAction::Descend;
-                                                        });
+        TraverseExpressions<TraverseOrder::RightToLeft>(root, [&](const Expression* expr) {
+            r2l.push_back(expr);
+            return TraverseAction::Descend;
+        });
         EXPECT_THAT(r2l, ElementsAre(root, m, e));
     }
 }
@@ -174,20 +164,18 @@
     auto* root = IndexAccessor(c, f);
     {
         std::vector<const Expression*> l2r;
-        TraverseExpressions<TraverseOrder::LeftToRight>(root, Diagnostics(),
-                                                        [&](const Expression* expr) {
-                                                            l2r.push_back(expr);
-                                                            return TraverseAction::Descend;
-                                                        });
+        TraverseExpressions<TraverseOrder::LeftToRight>(root, [&](const Expression* expr) {
+            l2r.push_back(expr);
+            return TraverseAction::Descend;
+        });
         EXPECT_THAT(l2r, ElementsAre(root, c, a, b, f, d, e));
     }
     {
         std::vector<const Expression*> r2l;
-        TraverseExpressions<TraverseOrder::RightToLeft>(root, Diagnostics(),
-                                                        [&](const Expression* expr) {
-                                                            r2l.push_back(expr);
-                                                            return TraverseAction::Descend;
-                                                        });
+        TraverseExpressions<TraverseOrder::RightToLeft>(root, [&](const Expression* expr) {
+            r2l.push_back(expr);
+            return TraverseAction::Descend;
+        });
         EXPECT_THAT(r2l, ElementsAre(root, f, e, d, c, b, a));
     }
 }
@@ -200,20 +188,18 @@
     auto* root = Deref(u2);
     {
         std::vector<const Expression*> l2r;
-        TraverseExpressions<TraverseOrder::LeftToRight>(root, Diagnostics(),
-                                                        [&](const Expression* expr) {
-                                                            l2r.push_back(expr);
-                                                            return TraverseAction::Descend;
-                                                        });
+        TraverseExpressions<TraverseOrder::LeftToRight>(root, [&](const Expression* expr) {
+            l2r.push_back(expr);
+            return TraverseAction::Descend;
+        });
         EXPECT_THAT(l2r, ElementsAre(root, u2, u1, u0, e));
     }
     {
         std::vector<const Expression*> r2l;
-        TraverseExpressions<TraverseOrder::RightToLeft>(root, Diagnostics(),
-                                                        [&](const Expression* expr) {
-                                                            r2l.push_back(expr);
-                                                            return TraverseAction::Descend;
-                                                        });
+        TraverseExpressions<TraverseOrder::RightToLeft>(root, [&](const Expression* expr) {
+            r2l.push_back(expr);
+            return TraverseAction::Descend;
+        });
         EXPECT_THAT(r2l, ElementsAre(root, u2, u1, u0, e));
     }
 }
@@ -223,11 +209,10 @@
     std::vector<const Expression*> i = {IndexAccessor(e[0], e[1]), IndexAccessor(e[2], e[3])};
     auto* root = IndexAccessor(i[0], i[1]);
     std::vector<const Expression*> order;
-    TraverseExpressions<TraverseOrder::LeftToRight>(
-        root, Diagnostics(), [&](const Expression* expr) {
-            order.push_back(expr);
-            return expr == i[0] ? TraverseAction::Skip : TraverseAction::Descend;
-        });
+    TraverseExpressions<TraverseOrder::LeftToRight>(root, [&](const Expression* expr) {
+        order.push_back(expr);
+        return expr == i[0] ? TraverseAction::Skip : TraverseAction::Descend;
+    });
     EXPECT_THAT(order, ElementsAre(root, i[0], i[1], e[2], e[3]));
 }
 
@@ -236,11 +221,10 @@
     std::vector<const Expression*> i = {IndexAccessor(e[0], e[1]), IndexAccessor(e[2], e[3])};
     auto* root = IndexAccessor(i[0], i[1]);
     std::vector<const Expression*> order;
-    TraverseExpressions<TraverseOrder::LeftToRight>(
-        root, Diagnostics(), [&](const Expression* expr) {
-            order.push_back(expr);
-            return expr == i[0] ? TraverseAction::Stop : TraverseAction::Descend;
-        });
+    TraverseExpressions<TraverseOrder::LeftToRight>(root, [&](const Expression* expr) {
+        order.push_back(expr);
+        return expr == i[0] ? TraverseAction::Stop : TraverseAction::Descend;
+    });
     EXPECT_THAT(order, ElementsAre(root, i[0]));
 }
 
diff --git a/src/tint/lang/wgsl/ast/type_decl.cc b/src/tint/lang/wgsl/ast/type_decl.cc
index 0581f85..ed4d6b1 100644
--- a/src/tint/lang/wgsl/ast/type_decl.cc
+++ b/src/tint/lang/wgsl/ast/type_decl.cc
@@ -22,9 +22,9 @@
 
 TypeDecl::TypeDecl(GenerationID pid, NodeID nid, const Source& src, const Identifier* n)
     : Base(pid, nid, src), name(n) {
-    TINT_ASSERT(AST, name);
+    TINT_ASSERT(name);
     if (name) {
-        TINT_ASSERT(AST, !name->Is<TemplatedIdentifier>());
+        TINT_ASSERT(!name->Is<TemplatedIdentifier>());
     }
 }
 
diff --git a/src/tint/lang/wgsl/ast/unary_op_expression.cc b/src/tint/lang/wgsl/ast/unary_op_expression.cc
index 9defa6b..6ed63c0 100644
--- a/src/tint/lang/wgsl/ast/unary_op_expression.cc
+++ b/src/tint/lang/wgsl/ast/unary_op_expression.cc
@@ -26,8 +26,8 @@
                                      UnaryOp o,
                                      const Expression* e)
     : Base(pid, nid, src), op(o), expr(e) {
-    TINT_ASSERT(AST, expr);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, expr, generation_id);
+    TINT_ASSERT(expr);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(expr, generation_id);
 }
 
 UnaryOpExpression::~UnaryOpExpression() = default;
diff --git a/src/tint/lang/wgsl/ast/variable.cc b/src/tint/lang/wgsl/ast/variable.cc
index a2cfc5e..72395f7 100644
--- a/src/tint/lang/wgsl/ast/variable.cc
+++ b/src/tint/lang/wgsl/ast/variable.cc
@@ -29,11 +29,11 @@
                    const Expression* init,
                    VectorRef<const Attribute*> attrs)
     : Base(pid, nid, src), name(n), type(ty), initializer(init), attributes(std::move(attrs)) {
-    TINT_ASSERT(AST, name);
+    TINT_ASSERT(name);
     if (name) {
-        TINT_ASSERT(AST, !name->Is<TemplatedIdentifier>());
+        TINT_ASSERT(!name->Is<TemplatedIdentifier>());
     }
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, initializer, generation_id);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(initializer, generation_id);
 }
 
 Variable::~Variable() = default;
diff --git a/src/tint/lang/wgsl/ast/variable_decl_statement.cc b/src/tint/lang/wgsl/ast/variable_decl_statement.cc
index 1f830e3..b9717a9 100644
--- a/src/tint/lang/wgsl/ast/variable_decl_statement.cc
+++ b/src/tint/lang/wgsl/ast/variable_decl_statement.cc
@@ -25,8 +25,8 @@
                                              const Source& src,
                                              const Variable* var)
     : Base(pid, nid, src), variable(var) {
-    TINT_ASSERT(AST, variable);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, variable, generation_id);
+    TINT_ASSERT(variable);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(variable, generation_id);
 }
 
 VariableDeclStatement::~VariableDeclStatement() = default;
diff --git a/src/tint/lang/wgsl/ast/while_statement.cc b/src/tint/lang/wgsl/ast/while_statement.cc
index 0019916..3b29852 100644
--- a/src/tint/lang/wgsl/ast/while_statement.cc
+++ b/src/tint/lang/wgsl/ast/while_statement.cc
@@ -29,14 +29,14 @@
                                const BlockStatement* b,
                                VectorRef<const ast::Attribute*> attrs)
     : Base(pid, nid, src), condition(cond), body(b), attributes(std::move(attrs)) {
-    TINT_ASSERT(AST, cond);
-    TINT_ASSERT(AST, body);
+    TINT_ASSERT(cond);
+    TINT_ASSERT(body);
 
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, condition, generation_id);
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, body, generation_id);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(condition, generation_id);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(body, generation_id);
     for (auto* attr : attributes) {
-        TINT_ASSERT(AST, attr);
-        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(AST, attr, generation_id);
+        TINT_ASSERT(attr);
+        TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(attr, generation_id);
     }
 }
 
diff --git a/src/tint/lang/wgsl/helpers/append_vector.cc b/src/tint/lang/wgsl/helpers/append_vector.cc
index 221001f..24be535 100644
--- a/src/tint/lang/wgsl/helpers/append_vector.cc
+++ b/src/tint/lang/wgsl/helpers/append_vector.cc
@@ -58,8 +58,7 @@
     } else if (ty->Is<type::Bool>()) {
         expr = b.Expr(false);
     } else {
-        TINT_UNREACHABLE(Writer, b.Diagnostics())
-            << "unsupported vector element type: " << ty->TypeInfo().name;
+        TINT_UNREACHABLE() << "unsupported vector element type: " << ty->TypeInfo().name;
         return nullptr;
     }
     auto* sem = b.create<sem::ValueExpression>(expr, ty, sem::EvaluationStage::kRuntime, stmt,
@@ -94,8 +93,8 @@
         [&](const type::F32*) { return b->ty.f32(); },
         [&](const type::Bool*) { return b->ty.bool_(); },
         [&](Default) {
-            TINT_UNREACHABLE(Writer, b->Diagnostics())
-                << "unsupported vector element type: " << packed_el_sem_ty->TypeInfo().name;
+            TINT_UNREACHABLE() << "unsupported vector element type: "
+                               << packed_el_sem_ty->TypeInfo().name;
             return ast::Type{};
         });
 
diff --git a/src/tint/lang/wgsl/inspector/inspector.cc b/src/tint/lang/wgsl/inspector/inspector.cc
index 6a77a16..f4b0317 100644
--- a/src/tint/lang/wgsl/inspector/inspector.cc
+++ b/src/tint/lang/wgsl/inspector/inspector.cc
@@ -65,7 +65,7 @@
 
 void AppendResourceBindings(std::vector<ResourceBinding>* dest,
                             const std::vector<ResourceBinding>& orig) {
-    TINT_ASSERT(Inspector, dest);
+    TINT_ASSERT(dest);
     if (!dest) {
         return;
     }
@@ -77,7 +77,7 @@
 std::tuple<ComponentType, CompositionType> CalculateComponentAndComposition(
     const type::Type* type) {
     // entry point in/out variables must of numeric scalar or vector types.
-    TINT_ASSERT(Inspector, type->is_numeric_scalar_or_vector());
+    TINT_ASSERT(type->is_numeric_scalar_or_vector());
 
     ComponentType componentType = Switch(
         type->DeepestElement(),  //
@@ -86,8 +86,7 @@
         [&](const type::I32*) { return ComponentType::kI32; },
         [&](const type::U32*) { return ComponentType::kU32; },
         [&](Default) {
-            tint::diag::List diagnostics;
-            TINT_UNREACHABLE(Inspector, diagnostics) << "unhandled component type";
+            TINT_UNREACHABLE() << "unhandled component type";
             return ComponentType::kUnknown;
         });
 
@@ -107,8 +106,7 @@
                 break;
             }
             default: {
-                tint::diag::List diagnostics;
-                TINT_UNREACHABLE(Inspector, diagnostics) << "unhandled composition type";
+                TINT_UNREACHABLE() << "unhandled composition type";
                 compositionType = CompositionType::kUnknown;
                 break;
             }
@@ -128,8 +126,8 @@
 
 EntryPoint Inspector::GetEntryPoint(const tint::ast::Function* func) {
     EntryPoint entry_point;
-    TINT_ASSERT(Inspector, func != nullptr);
-    TINT_ASSERT(Inspector, func->IsEntryPoint());
+    TINT_ASSERT(func != nullptr);
+    TINT_ASSERT(func->IsEntryPoint());
 
     auto* sem = program_->Sem().Get(func);
 
@@ -156,8 +154,8 @@
             break;
         }
         default: {
-            TINT_UNREACHABLE(Inspector, diagnostics_)
-                << "invalid pipeline stage for entry point '" << entry_point.name << "'";
+            TINT_UNREACHABLE() << "invalid pipeline stage for entry point '" << entry_point.name
+                               << "'";
             break;
         }
     }
@@ -200,7 +198,7 @@
             override.name = name;
             override.id = global->OverrideId();
             auto* type = var->Type();
-            TINT_ASSERT(Inspector, type->Is<type::Scalar>());
+            TINT_ASSERT(type->Is<type::Scalar>());
             if (type->is_bool_scalar_or_vector()) {
                 override.type = Override::Type::kBool;
             } else if (type->is_float_scalar()) {
@@ -214,7 +212,7 @@
             } else if (type->is_unsigned_integer_scalar()) {
                 override.type = Override::Type::kUint32;
             } else {
-                TINT_UNREACHABLE(Inspector, diagnostics_);
+                TINT_UNREACHABLE();
             }
 
             override.is_initialized = global->Declaration()->initializer;
@@ -632,7 +630,7 @@
     std::tie(stage_variable.component_type, stage_variable.composition_type) =
         CalculateComponentAndComposition(type);
 
-    TINT_ASSERT(Inspector, location.has_value());
+    TINT_ASSERT(location.has_value());
     stage_variable.has_location_attribute = true;
     stage_variable.location_attribute = location.value();
 
@@ -913,8 +911,7 @@
 template <size_t N, typename F>
 void Inspector::GetOriginatingResources(std::array<const ast::Expression*, N> exprs, F&& callback) {
     if (TINT_UNLIKELY(!program_->IsValid())) {
-        TINT_ICE(Inspector, diagnostics_)
-            << "attempting to get originating resources in invalid program";
+        TINT_ICE() << "attempting to get originating resources in invalid program";
         return;
     }
 
@@ -940,9 +937,8 @@
             }
             parameters[i] = param;
         } else {
-            TINT_ICE(Inspector, diagnostics_)
-                << "cannot resolve originating resource with expression type "
-                << exprs[i]->TypeInfo().name;
+            TINT_ICE() << "cannot resolve originating resource with expression type "
+                       << exprs[i]->TypeInfo().name;
             return;
         }
     }
diff --git a/src/tint/lang/wgsl/program/program.cc b/src/tint/lang/wgsl/program/program.cc
index 0e8e619..45900e5 100644
--- a/src/tint/lang/wgsl/program/program.cc
+++ b/src/tint/lang/wgsl/program/program.cc
@@ -132,7 +132,7 @@
 }
 
 void Program::AssertNotMoved() const {
-    TINT_ASSERT(Program, !moved_);
+    TINT_ASSERT(!moved_);
 }
 
 }  // namespace tint
diff --git a/src/tint/lang/wgsl/program/program_builder.cc b/src/tint/lang/wgsl/program/program_builder.cc
index 9059f34..06cc052 100644
--- a/src/tint/lang/wgsl/program/program_builder.cc
+++ b/src/tint/lang/wgsl/program/program_builder.cc
@@ -20,7 +20,7 @@
 #include "src/tint/lang/wgsl/sem/type_expression.h"
 #include "src/tint/lang/wgsl/sem/value_expression.h"
 #include "src/tint/lang/wgsl/sem/variable.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/macros/compiler.h"
 #include "src/tint/utils/rtti/switch.h"
 
@@ -92,8 +92,7 @@
 
 void ProgramBuilder::AssertNotMoved() const {
     if (TINT_UNLIKELY(moved_)) {
-        TINT_ICE(ProgramBuilder, const_cast<ProgramBuilder*>(this)->diagnostics_)
-            << "Attempting to use ProgramBuilder after it has been moved";
+        TINT_ICE() << "Attempting to use ProgramBuilder after it has been moved";
     }
 }
 
diff --git a/src/tint/lang/wgsl/program/program_builder.h b/src/tint/lang/wgsl/program/program_builder.h
index fde203e..f2f87d4 100644
--- a/src/tint/lang/wgsl/program/program_builder.h
+++ b/src/tint/lang/wgsl/program/program_builder.h
@@ -615,7 +615,7 @@
                 case 4:
                     return vec4(source, type);
             }
-            TINT_ICE(ProgramBuilder, builder->Diagnostics()) << "invalid vector width " << n;
+            TINT_ICE() << "invalid vector width " << n;
             return ast::Type{};
         }
 
@@ -716,7 +716,7 @@
                 case 4:
                     return vec4<T>(source);
             }
-            TINT_ICE(ProgramBuilder, builder->Diagnostics()) << "invalid vector width " << n;
+            TINT_ICE() << "invalid vector width " << n;
             return ast::Type{};
         }
 
@@ -756,8 +756,7 @@
                 auto i = (columns - 2) * 3 + (rows - 2);
                 return (*this)(source, names[i], type);
             }
-            TINT_ICE(ProgramBuilder, builder->Diagnostics())
-                << "invalid matrix dimensions " << columns << "x" << rows;
+            TINT_ICE() << "invalid matrix dimensions " << columns << "x" << rows;
             return ast::Type{};
         }
 
@@ -976,8 +975,7 @@
                 case 8:
                     return mat4x4<T>(source);
                 default:
-                    TINT_ICE(ProgramBuilder, builder->Diagnostics())
-                        << "invalid matrix dimensions " << columns << "x" << rows;
+                    TINT_ICE() << "invalid matrix dimensions " << columns << "x" << rows;
                     return ast::Type{};
             }
         }
@@ -1235,7 +1233,7 @@
                 case type::SamplerKind::kComparisonSampler:
                     return (*this)(source, "sampler_comparison");
             }
-            TINT_ICE(ProgramBuilder, builder->Diagnostics()) << "invalid sampler kind " << kind;
+            TINT_ICE() << "invalid sampler kind " << kind;
             return ast::Type{};
         }
 
@@ -1261,8 +1259,7 @@
                 default:
                     break;
             }
-            TINT_ICE(ProgramBuilder, builder->Diagnostics())
-                << "invalid depth_texture dimensions: " << dims;
+            TINT_ICE() << "invalid depth_texture dimensions: " << dims;
             return ast::Type{};
         }
 
@@ -1280,8 +1277,7 @@
             if (dims == type::TextureDimension::k2d) {
                 return (*this)(source, "texture_depth_multisampled_2d");
             }
-            TINT_ICE(ProgramBuilder, builder->Diagnostics())
-                << "invalid depth_multisampled_texture dimensions: " << dims;
+            TINT_ICE() << "invalid depth_multisampled_texture dimensions: " << dims;
             return ast::Type{};
         }
 
@@ -1315,8 +1311,7 @@
                 default:
                     break;
             }
-            TINT_ICE(ProgramBuilder, builder->Diagnostics())
-                << "invalid sampled_texture dimensions: " << dims;
+            TINT_ICE() << "invalid sampled_texture dimensions: " << dims;
             return ast::Type{};
         }
 
@@ -1337,8 +1332,7 @@
             if (dims == type::TextureDimension::k2d) {
                 return (*this)(source, "texture_multisampled_2d", subtype);
             }
-            TINT_ICE(ProgramBuilder, builder->Diagnostics())
-                << "invalid multisampled_texture dimensions: " << dims;
+            TINT_ICE() << "invalid multisampled_texture dimensions: " << dims;
             return ast::Type{};
         }
 
@@ -1373,8 +1367,7 @@
                 default:
                     break;
             }
-            TINT_ICE(ProgramBuilder, builder->Diagnostics())
-                << "invalid storage_texture  dimensions: " << dims;
+            TINT_ICE() << "invalid storage_texture  dimensions: " << dims;
             return ast::Type{};
         }
 
diff --git a/src/tint/lang/wgsl/reader/parser/classify_template_args.cc b/src/tint/lang/wgsl/reader/parser/classify_template_args.cc
index 2cf8b9f..62af8e9 100644
--- a/src/tint/lang/wgsl/reader/parser/classify_template_args.cc
+++ b/src/tint/lang/wgsl/reader/parser/classify_template_args.cc
@@ -17,7 +17,7 @@
 #include <vector>
 
 #include "src/tint/utils/containers/vector.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 
 namespace tint::wgsl::reader {
 
@@ -31,17 +31,17 @@
     Token* token = &tokens[idx];
     switch (token->type()) {
         case Token::Type::kShiftRight:  //  '>>'
-            TINT_ASSERT(Reader, token[1].type() == Token::Type::kPlaceholder);
+            TINT_ASSERT(token[1].type() == Token::Type::kPlaceholder);
             token[0].SetType(Token::Type::kGreaterThan);
             token[1].SetType(Token::Type::kGreaterThan);
             break;
         case Token::Type::kGreaterThanEqual:  //  '>='
-            TINT_ASSERT(Reader, token[1].type() == Token::Type::kPlaceholder);
+            TINT_ASSERT(token[1].type() == Token::Type::kPlaceholder);
             token[0].SetType(Token::Type::kGreaterThan);
             token[1].SetType(Token::Type::kEqual);
             break;
         case Token::Type::kShiftRightEqual:  // '>>='
-            TINT_ASSERT(Reader, token[1].type() == Token::Type::kPlaceholder);
+            TINT_ASSERT(token[1].type() == Token::Type::kPlaceholder);
             token[0].SetType(Token::Type::kGreaterThan);
             token[1].SetType(Token::Type::kGreaterThanEqual);
             break;
diff --git a/src/tint/lang/wgsl/reader/parser/lexer.cc b/src/tint/lang/wgsl/reader/parser/lexer.cc
index 132925b..673d83d 100644
--- a/src/tint/lang/wgsl/reader/parser/lexer.cc
+++ b/src/tint/lang/wgsl/reader/parser/lexer.cc
@@ -26,7 +26,7 @@
 #include <utility>
 
 #include "src/tint/lang/core/builtin/number.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/text/parse_num.h"
 #include "src/tint/utils/text/unicode.h"
 
@@ -637,7 +637,7 @@
     // Note: it's not enough to check mantissa == 0 as we drop the initial bit,
     // whether it's in the integer part or the fractional part.
     const bool is_zero = !seen_prior_one_bits;
-    TINT_ASSERT(Reader, !is_zero || mantissa == 0);
+    TINT_ASSERT(!is_zero || mantissa == 0);
 
     // Parse the optional exponent.
     // ((p|P)(\+|-)?[0-9]+)?
@@ -800,10 +800,10 @@
             // 2^-148 > v >= 2^-149, binary32 s_00000000_00000000000000000000001, 0 arbitrary bit.
 
             // signed_exponent must be in range -149 + 1023 = 874 to -127 + 1023 = 896, inclusive
-            TINT_ASSERT(Reader, (874 <= signed_exponent) && (signed_exponent <= 896));
+            TINT_ASSERT((874 <= signed_exponent) && (signed_exponent <= 896));
             int unbiased_exponent =
                 static_cast<int>(signed_exponent) - static_cast<int>(kExponentBias);
-            TINT_ASSERT(Reader, (-149 <= unbiased_exponent) && (unbiased_exponent <= -127));
+            TINT_ASSERT((-149 <= unbiased_exponent) && (unbiased_exponent <= -127));
             valid_mantissa_bits = unbiased_exponent + 149;  // 0 for -149, and 22 for -127
         } else if (abs_result_f64 != 0.0) {
             // The result is smaller than the smallest subnormal f32 value, but not equal to zero.
@@ -812,7 +812,7 @@
                          "value cannot be exactly represented as 'f32'"};
         }
         // Check the low 52-valid_mantissa_bits mantissa bits must be 0.
-        TINT_ASSERT(Reader, (0 <= valid_mantissa_bits) && (valid_mantissa_bits <= 23));
+        TINT_ASSERT((0 <= valid_mantissa_bits) && (valid_mantissa_bits <= 23));
         if (result_u64 & ((uint64_t(1) << (52 - valid_mantissa_bits)) - 1)) {
             return Token{Token::Type::kError, source,
                          "value cannot be exactly represented as 'f32'"};
@@ -853,10 +853,10 @@
             // 2^-23 > v >= 2^-24, binary16 s_00000_0000000001, 0 arbitrary bits.
 
             // signed_exponent must be in range -24 + 1023 = 999 to -15 + 1023 = 1008, inclusive
-            TINT_ASSERT(Reader, (999 <= signed_exponent) && (signed_exponent <= 1008));
+            TINT_ASSERT((999 <= signed_exponent) && (signed_exponent <= 1008));
             int unbiased_exponent =
                 static_cast<int>(signed_exponent) - static_cast<int>(kExponentBias);
-            TINT_ASSERT(Reader, (-24 <= unbiased_exponent) && (unbiased_exponent <= -15));
+            TINT_ASSERT((-24 <= unbiased_exponent) && (unbiased_exponent <= -15));
             valid_mantissa_bits = unbiased_exponent + 24;  // 0 for -24, and 9 for -15
         } else if (abs_result_f64 != 0.0) {
             // The result is smaller than the smallest subnormal f16 value, but not equal to zero.
@@ -865,7 +865,7 @@
                          "value cannot be exactly represented as 'f16'"};
         }
         // Check the low 52-valid_mantissa_bits mantissa bits must be 0.
-        TINT_ASSERT(Reader, (0 <= valid_mantissa_bits) && (valid_mantissa_bits <= 10));
+        TINT_ASSERT((0 <= valid_mantissa_bits) && (valid_mantissa_bits <= 10));
         if (result_u64 & ((uint64_t(1) << (52 - valid_mantissa_bits)) - 1)) {
             return Token{Token::Type::kError, source,
                          "value cannot be exactly represented as 'f16'"};
diff --git a/src/tint/lang/wgsl/reader/parser/parser.cc b/src/tint/lang/wgsl/reader/parser/parser.cc
index ea686d2..67d027d 100644
--- a/src/tint/lang/wgsl/reader/parser/parser.cc
+++ b/src/tint/lang/wgsl/reader/parser/parser.cc
@@ -290,15 +290,13 @@
 
 void Parser::split_token(Token::Type lhs, Token::Type rhs) {
     if (TINT_UNLIKELY(next_token_idx_ == 0)) {
-        TINT_ICE(Reader, builder_.Diagnostics())
-            << "attempt to update placeholder at beginning of tokens";
+        TINT_ICE() << "attempt to update placeholder at beginning of tokens";
     }
     if (TINT_UNLIKELY(next_token_idx_ >= tokens_.size())) {
-        TINT_ICE(Reader, builder_.Diagnostics())
-            << "attempt to update placeholder past end of tokens";
+        TINT_ICE() << "attempt to update placeholder past end of tokens";
     }
     if (TINT_UNLIKELY(!tokens_[next_token_idx_].IsPlaceholder())) {
-        TINT_ICE(Reader, builder_.Diagnostics()) << "attempt to update non-placeholder token";
+        TINT_ICE() << "attempt to update non-placeholder token";
     }
     tokens_[next_token_idx_ - 1].SetType(lhs);
     tokens_[next_token_idx_].SetType(rhs);
@@ -3389,7 +3387,7 @@
     --parse_depth_;
 
     if (TINT_UNLIKELY(sync_tokens_.back() != tok)) {
-        TINT_ICE(Reader, builder_.Diagnostics()) << "sync_tokens is out of sync";
+        TINT_ICE() << "sync_tokens is out of sync";
     }
     sync_tokens_.pop_back();
 
diff --git a/src/tint/lang/wgsl/reader/parser/parser.h b/src/tint/lang/wgsl/reader/parser/parser.h
index 9adc95c..67d676d 100644
--- a/src/tint/lang/wgsl/reader/parser/parser.h
+++ b/src/tint/lang/wgsl/reader/parser/parser.h
@@ -26,6 +26,7 @@
 #include "src/tint/lang/wgsl/program/program_builder.h"
 #include "src/tint/lang/wgsl/reader/parser/detail.h"
 #include "src/tint/lang/wgsl/reader/parser/token.h"
+#include "src/tint/utils/diagnostic/formatter.h"
 
 namespace tint::ast {
 class BreakStatement;
@@ -122,7 +123,7 @@
         /// return type will always be a pointer to a non-pointer type. #errored
         /// must be false to call.
         inline typename detail::OperatorArrow<T>::type operator->() {
-            TINT_ASSERT(Reader, !errored);
+            TINT_ASSERT(!errored);
             return detail::OperatorArrow<T>::ptr(value);
         }
 
@@ -184,7 +185,7 @@
         /// return type will always be a pointer to a non-pointer type. #errored
         /// must be false to call.
         inline typename detail::OperatorArrow<T>::type operator->() {
-            TINT_ASSERT(Reader, !errored);
+            TINT_ASSERT(!errored);
             return detail::OperatorArrow<T>::ptr(value);
         }
 
diff --git a/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir.cc b/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir.cc
index e0c3c0f..1d64f4b 100644
--- a/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir.cc
+++ b/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir.cc
@@ -192,8 +192,8 @@
     bool NeedTerminator() { return current_block_ && !current_block_->HasTerminator(); }
 
     void SetTerminator(ir::Terminator* terminator) {
-        TINT_ASSERT(IR, current_block_);
-        TINT_ASSERT(IR, !current_block_->HasTerminator());
+        TINT_ASSERT(current_block_);
+        TINT_ASSERT(!current_block_->HasTerminator());
 
         current_block_->Append(terminator);
         current_block_ = nullptr;
@@ -276,7 +276,7 @@
 
     void EmitFunction(const ast::Function* ast_func) {
         // The flow stack should have been emptied when the previous function finished building.
-        TINT_ASSERT(IR, control_stack_.IsEmpty());
+        TINT_ASSERT(control_stack_.IsEmpty());
 
         const auto* sem = program_->Sem().Get(ast_func);
 
@@ -303,7 +303,7 @@
                     break;
                 }
                 default: {
-                    TINT_ICE(IR, diagnostics_) << "Invalid pipeline stage";
+                    TINT_ICE() << "Invalid pipeline stage";
                     return;
                 }
             }
@@ -337,13 +337,12 @@
                                         ir::Function::ReturnBuiltin::kSampleMask);
                                     break;
                                 default:
-                                    TINT_ICE(IR, diagnostics_)
-                                        << "Unknown builtin value in return attributes "
-                                        << ident_sem->Value();
+                                    TINT_ICE() << "Unknown builtin value in return attributes "
+                                               << ident_sem->Value();
                                     return;
                             }
                         } else {
-                            TINT_ICE(IR, diagnostics_) << "Builtin attribute sem invalid";
+                            TINT_ICE() << "Builtin attribute sem invalid";
                             return;
                         }
                     });
@@ -415,13 +414,12 @@
                                     param->SetBuiltin(ir::FunctionParam::Builtin::kSampleMask);
                                     break;
                                 default:
-                                    TINT_ICE(IR, diagnostics_)
-                                        << "Unknown builtin value in parameter attributes "
-                                        << ident_sem->Value();
+                                    TINT_ICE() << "Unknown builtin value in parameter attributes "
+                                               << ident_sem->Value();
                                     return;
                             }
                         } else {
-                            TINT_ICE(IR, diagnostics_) << "Builtin attribute sem invalid";
+                            TINT_ICE() << "Builtin attribute sem invalid";
                             return;
                         }
                     });
@@ -452,7 +450,7 @@
             }
         }
 
-        TINT_ASSERT(IR, control_stack_.IsEmpty());
+        TINT_ASSERT(control_stack_.IsEmpty());
         current_block_ = nullptr;
         current_function_ = nullptr;
     }
@@ -781,25 +779,25 @@
 
     void EmitBreak(const ast::BreakStatement*) {
         auto* current_control = FindEnclosingControl(ControlFlags::kNone);
-        TINT_ASSERT(IR, current_control);
+        TINT_ASSERT(current_control);
 
         if (auto* c = current_control->As<ir::Loop>()) {
             SetTerminator(builder_.ExitLoop(c));
         } else if (auto* s = current_control->As<ir::Switch>()) {
             SetTerminator(builder_.ExitSwitch(s));
         } else {
-            TINT_UNREACHABLE(IR, diagnostics_);
+            TINT_UNREACHABLE();
         }
     }
 
     void EmitContinue(const ast::ContinueStatement*) {
         auto* current_control = FindEnclosingControl(ControlFlags::kExcludeSwitch);
-        TINT_ASSERT(IR, current_control);
+        TINT_ASSERT(current_control);
 
         if (auto* c = current_control->As<ir::Loop>()) {
             SetTerminator(builder_.Continue(c));
         } else {
-            TINT_UNREACHABLE(IR, diagnostics_);
+            TINT_UNREACHABLE();
         }
     }
 
@@ -881,7 +879,7 @@
                 if (auto** val = std::get_if<ir::Value*>(&res)) {
                     return *val;
                 }
-                TINT_ICE(IR, impl.diagnostics_) << "expression did not resolve to a value";
+                TINT_ICE() << "expression did not resolve to a value";
                 return nullptr;
             }
 
@@ -913,7 +911,7 @@
 
                 auto* obj = GetValue(expr->object);
                 if (!obj) {
-                    TINT_ASSERT(IR, false && "no object result");
+                    TINT_UNREACHABLE() << "no object result";
                     return;
                 }
 
@@ -933,7 +931,7 @@
                             if (auto* cv = v->Clone(impl.clone_ctx_)) {
                                 return impl.builder_.Constant(cv);
                             }
-                            TINT_ASSERT(IR, false && "constant clone failed");
+                            TINT_UNREACHABLE() << "constant clone failed";
                             return nullptr;
                         }
                         return GetValue(idx->Index()->Declaration());
@@ -954,8 +952,7 @@
                         return nullptr;
                     },
                     [&](Default) {
-                        TINT_ICE(Writer, impl.diagnostics_)
-                            << "invalid accessor: " + std::string(sem->TypeInfo().name);
+                        TINT_ICE() << "invalid accessor: " + std::string(sem->TypeInfo().name);
                         return nullptr;
                     });
 
@@ -1089,7 +1086,7 @@
                 } else if (sem->Target()->Is<sem::ValueConversion>()) {
                     inst = impl.builder_.Convert(ty, args[0]);
                 } else if (expr->target->identifier->Is<ast::TemplatedIdentifier>()) {
-                    TINT_UNIMPLEMENTED(IR, impl.diagnostics_) << "missing templated ident support";
+                    TINT_UNIMPLEMENTED() << "missing templated ident support";
                     return;
                 } else {
                     // Not a builtin and not a templated call, so this is a user function.
@@ -1200,7 +1197,7 @@
                 auto res = GetValue(b);
                 auto* src = res->As<ir::InstructionResult>()->Source();
                 auto* if_ = src->As<ir::If>();
-                TINT_ASSERT_OR_RETURN(IR, if_);
+                TINT_ASSERT_OR_RETURN(if_);
                 auto rhs = GetValue(b->rhs);
                 if (!rhs) {
                     return;
@@ -1271,7 +1268,7 @@
         if (auto** val = std::get_if<ir::Value*>(&res)) {
             return *val;
         }
-        TINT_ICE(IR, diagnostics_) << "expression did not resolve to a value";
+        TINT_ICE() << "expression did not resolve to a value";
         return nullptr;
     }
 
@@ -1388,13 +1385,13 @@
                 return builder_.Modulo(ty, lhs, rhs);
             case ast::BinaryOp::kLogicalAnd:
             case ast::BinaryOp::kLogicalOr:
-                TINT_ICE(IR, diagnostics_) << "short circuit op should have already been handled";
+                TINT_ICE() << "short circuit op should have already been handled";
                 return nullptr;
             case ast::BinaryOp::kNone:
-                TINT_ICE(IR, diagnostics_) << "missing binary operand type";
+                TINT_ICE() << "missing binary operand type";
                 return nullptr;
         }
-        TINT_UNREACHABLE(IR, diagnostics_);
+        TINT_UNREACHABLE();
         return nullptr;
     }
 };
diff --git a/src/tint/lang/wgsl/resolver/const_eval.cc b/src/tint/lang/wgsl/resolver/const_eval.cc
index aa5c67c..e33c37b 100644
--- a/src/tint/lang/wgsl/resolver/const_eval.cc
+++ b/src/tint/lang/wgsl/resolver/const_eval.cc
@@ -320,7 +320,7 @@
             return ctx.builder.constants.Get<constant::Scalar<TO>>(target_ty,
                                                                    static_cast<TO>(scalar->value));
         }
-        TINT_UNREACHABLE(Resolver, ctx.builder.Diagnostics()) << "Expression is not constant";
+        TINT_UNREACHABLE() << "Expression is not constant";
         return nullptr;
     });
     TINT_END_DISABLE_WARNING(UNREACHABLE_CODE);
@@ -355,14 +355,14 @@
         auto next = pending.Pop();
 
         if (auto* build = std::get_if<ActionBuildSplat>(&next)) {
-            TINT_ASSERT(Resolver, value_stack.Length() >= 1);
+            TINT_ASSERT(value_stack.Length() >= 1);
             auto* el = value_stack.Pop();
             value_stack.Push(ctx.builder.constants.Splat(build->type, el, build->count));
             continue;
         }
 
         if (auto* build = std::get_if<ActionBuildComposite>(&next)) {
-            TINT_ASSERT(Resolver, value_stack.Length() >= build->count);
+            TINT_ASSERT(value_stack.Length() >= build->count);
             // Take build->count elements off the top of value_stack
             // Note: The values are ordered with the first composite value at the top of the stack.
             Vector<const constant::Value*, 32> elements;
@@ -421,7 +421,7 @@
                     // default materialization type.
                     for (size_t i = 1; i < members.Length(); i++) {
                         if (members[i]->Type() != target_el_ty) {
-                            TINT_ICE(Resolver, ctx.builder.Diagnostics())
+                            TINT_ICE()
                                 << "inconsistent target struct member types for SplatConvert";
                             return false;
                         }
@@ -443,7 +443,7 @@
 
                 if (auto* str = convert->target_ty->As<type::Struct>()) {
                     if (TINT_UNLIKELY(str->Members().Length() != el_count)) {
-                        TINT_ICE(Resolver, ctx.builder.Diagnostics())
+                        TINT_ICE()
                             << "const-eval conversion of structure has mismatched element counts";
                         return false;
                     }
@@ -468,7 +468,7 @@
         }
     }
 
-    TINT_ASSERT(Resolver, value_stack.Length() == 1);
+    TINT_ASSERT(value_stack.Length() == 1);
     return value_stack.Pop();
 }
 
@@ -567,7 +567,7 @@
 template <typename T>
 ConstEval::Result ConstEval::CreateScalar(const Source& source, const type::Type* t, T v) {
     static_assert(IsNumber<T> || std::is_same_v<T, bool>, "T must be a Number or bool");
-    TINT_ASSERT(Resolver, t->Is<type::Scalar>());
+    TINT_ASSERT(t->Is<type::Scalar>());
 
     if constexpr (IsFloatingPoint<T>) {
         if (!std::isfinite(v.value)) {
@@ -622,7 +622,7 @@
         [&](Default) -> const constant::Value* {
             return ZeroTypeDispatch(type, [&](auto zero) -> const constant::Value* {
                 auto el = CreateScalar(Source{}, type, zero);
-                TINT_ASSERT(Resolver, el);
+                TINT_ASSERT(el);
                 return el.Get();
             });
         });
@@ -1171,7 +1171,7 @@
                                  const constant::Value* v1,
                                  const constant::Value* v2) {
     auto* vec_ty = v1->Type()->As<type::Vector>();
-    TINT_ASSERT(Resolver, vec_ty);
+    TINT_ASSERT(vec_ty);
     auto* elem_ty = vec_ty->type();
     switch (vec_ty->Width()) {
         case 2:
@@ -1190,8 +1190,8 @@
                 v1->Index(0), v1->Index(1), v1->Index(2), v1->Index(3),  //
                 v2->Index(0), v2->Index(1), v2->Index(2), v2->Index(3));
     }
-    TINT_ICE(Resolver, builder.Diagnostics()) << "Expected vector";
-    return tint::Failure;
+    TINT_ICE() << "Expected vector";
+    return Failure;
 }
 
 ConstEval::Result ConstEval::Length(const Source& source,
@@ -1468,14 +1468,14 @@
     auto src_el_ty = src_elements.type;
     auto src_count = src_elements.count;
 
-    TINT_ASSERT(Resolver, dst_count * dst_el_ty->Size() == src_count * src_el_ty->Size());
+    TINT_ASSERT(dst_count * dst_el_ty->Size() == src_count * src_el_ty->Size());
     uint32_t total_bitwidth = dst_count * dst_el_ty->Size();
     // Buffer holding the bits from source value, result value reinterpreted from it.
     Vector<std::byte, 16> buffer;
     buffer.Reserve(total_bitwidth);
 
     // Ensure elements are of 32-bit or 16-bit numerical scalar type.
-    TINT_ASSERT(Resolver, (src_el_ty->IsAnyOf<type::F32, type::I32, type::U32, type::F16>()));
+    TINT_ASSERT((src_el_ty->IsAnyOf<type::F32, type::I32, type::U32, type::F16>()));
     // Pushes bits from source value into the buffer.
     auto push_src_element_bits = [&](const constant::Value* element) {
         auto push_32_bits = [&](uint32_t v) {
@@ -1564,7 +1564,7 @@
             });
     };
 
-    TINT_ASSERT(Resolver, (buffer.Length() == total_bitwidth));
+    TINT_ASSERT((buffer.Length() == total_bitwidth));
     for (size_t i = 0; i < dst_count; i++) {
         if (!push_dst_element(i * dst_el_ty->Size())) {
             return tint::Failure;
@@ -1914,7 +1914,7 @@
                                           const Source& source) {
     // Due to short-circuiting, this function is only called if lhs is true, so we only return the
     // value of the rhs.
-    TINT_ASSERT(Resolver, args[0]->ValueAs<bool>());
+    TINT_ASSERT(args[0]->ValueAs<bool>());
     return CreateScalar(source, ty, args[1]->ValueAs<bool>());
 }
 
@@ -1923,7 +1923,7 @@
                                          const Source& source) {
     // Due to short-circuiting, this function is only called if lhs is false, so we only only return
     // the value of the rhs.
-    TINT_ASSERT(Resolver, !args[0]->ValueAs<bool>());
+    TINT_ASSERT(!args[0]->ValueAs<bool>());
     return CreateScalar(source, ty, args[1]->ValueAs<bool>());
 }
 
@@ -2070,9 +2070,8 @@
     };
 
     if (TINT_UNLIKELY(!args[1]->Type()->DeepestElement()->Is<type::U32>())) {
-        TINT_ICE(Resolver, builder.Diagnostics())
-            << "Element type of rhs of ShiftLeft must be a u32";
-        return tint::Failure;
+        TINT_ICE() << "Element type of rhs of ShiftLeft must be a u32";
+        return Failure;
     }
 
     return TransformElements(builder, ty, transform, args[0], args[1]);
@@ -2138,9 +2137,8 @@
     };
 
     if (TINT_UNLIKELY(!args[1]->Type()->DeepestElement()->Is<type::U32>())) {
-        TINT_ICE(Resolver, builder.Diagnostics())
-            << "Element type of rhs of ShiftLeft must be a u32";
-        return tint::Failure;
+        TINT_ICE() << "Element type of rhs of ShiftLeft must be a u32";
+        return Failure;
     }
 
     return TransformElements(builder, ty, transform, args[0], args[1]);
@@ -2506,8 +2504,8 @@
                                            me(0, 2), me(1, 2), me(2, 2), me(3, 2),  //
                                            me(0, 3), me(1, 3), me(2, 3), me(3, 3));
         }
-        TINT_ICE(Resolver, builder.Diagnostics()) << "Unexpected number of matrix rows";
-        return tint::Failure;
+        TINT_ICE() << "Unexpected number of matrix rows";
+        return Failure;
     };
     auto r = calculate();
     if (!r) {
@@ -2826,10 +2824,9 @@
                 };
             },
             [&](Default) {
-                TINT_ICE(Resolver, builder.Diagnostics())
-                    << "unhandled element type for frexp() const-eval: "
-                    << s->Type()->FriendlyName();
-                return FractExp{tint::Failure, tint::Failure};
+                TINT_ICE() << "unhandled element type for frexp() const-eval: "
+                           << s->Type()->FriendlyName();
+                return FractExp{Failure, Failure};
             });
     };
 
diff --git a/src/tint/lang/wgsl/resolver/const_eval_binary_op_test.cc b/src/tint/lang/wgsl/resolver/const_eval_binary_op_test.cc
index 2bd91fb..881246c 100644
--- a/src/tint/lang/wgsl/resolver/const_eval_binary_op_test.cc
+++ b/src/tint/lang/wgsl/resolver/const_eval_binary_op_test.cc
@@ -2425,8 +2425,6 @@
     auto program = wgsl::reader::Parse(file.get());
 
     if (should_pass) {
-        diag::Formatter::Style style;
-        style.print_newline_at_end = false;
         auto error = program.Diagnostics().str();
 
         EXPECT_TRUE(program.IsValid()) << error;
diff --git a/src/tint/lang/wgsl/resolver/dependency_graph.cc b/src/tint/lang/wgsl/resolver/dependency_graph.cc
index d5ceb40..f6399fd 100644
--- a/src/tint/lang/wgsl/resolver/dependency_graph.cc
+++ b/src/tint/lang/wgsl/resolver/dependency_graph.cc
@@ -124,8 +124,8 @@
 using GlobalMap = Hashmap<Symbol, Global*, 16>;
 
 /// Raises an ICE that a global ast::Node type was not handled by this system.
-void UnhandledNode(diag::List& diagnostics, const ast::Node* node) {
-    TINT_ICE(Resolver, diagnostics) << "unhandled node type: " << node->TypeInfo().name;
+void UnhandledNode(const ast::Node* node) {
+    TINT_ICE() << "unhandled node type: " << node->TypeInfo().name;
 }
 
 /// Raises an error diagnostic with the given message and source.
@@ -194,7 +194,7 @@
                 // Enable directives do not affect the dependency graph.
             },
             [&](const ast::ConstAssert* assertion) { TraverseExpression(assertion->condition); },
-            [&](Default) { UnhandledNode(diagnostics_, global->node); });
+            [&](Default) { UnhandledNode(global->node); });
     }
 
   private:
@@ -318,7 +318,7 @@
             [&](Default) {
                 if (TINT_UNLIKELY((!stmt->IsAnyOf<ast::BreakStatement, ast::ContinueStatement,
                                                   ast::DiscardStatement>()))) {
-                    UnhandledNode(diagnostics_, stmt);
+                    UnhandledNode(stmt);
                 }
             });
     }
@@ -343,7 +343,8 @@
 
         Vector<const ast::Expression*, 8> pending{root_expr};
         while (!pending.IsEmpty()) {
-            ast::TraverseExpressions(pending.Pop(), diagnostics_, [&](const ast::Expression* expr) {
+            auto* next = pending.Pop();
+            bool ok = ast::TraverseExpressions(next, [&](const ast::Expression* expr) {
                 Switch(
                     expr,
                     [&](const ast::IdentifierExpression* e) {
@@ -358,6 +359,10 @@
                     [&](const ast::BitcastExpression* cast) { TraverseExpression(cast->type); });
                 return ast::TraverseAction::Descend;
             });
+            if (!ok) {
+                AddError(diagnostics_, "TraverseExpressions failed", next->source);
+                return;
+            }
         }
     }
 
@@ -434,7 +439,7 @@
             return;
         }
 
-        UnhandledNode(diagnostics_, attr);
+        UnhandledNode(attr);
     }
 
     /// The type of builtin that a symbol could represent.
@@ -636,7 +641,7 @@
             [&](const ast::Enable*) { return Symbol(); },
             [&](const ast::ConstAssert*) { return Symbol(); },
             [&](Default) {
-                UnhandledNode(diagnostics_, node);
+                UnhandledNode(node);
                 return Symbol{};
             });
     }
@@ -660,7 +665,7 @@
             [&](const ast::Variable* v) { return v->Kind(); },        //
             [&](const ast::ConstAssert*) { return "const_assert"; },  //
             [&](Default) {
-                UnhandledNode(diagnostics_, node);
+                UnhandledNode(node);
                 return "<error>";
             });
     }
@@ -779,8 +784,7 @@
 
             if (TINT_UNLIKELY(!stack.IsEmpty())) {
                 // Each stack.push() must have a corresponding stack.pop_back().
-                TINT_ICE(Resolver, diagnostics_)
-                    << "stack not empty after returning from TraverseDependencies()";
+                TINT_ICE() << "stack not empty after returning from TraverseDependencies()";
             }
         }
     }
@@ -793,9 +797,8 @@
         if (TINT_LIKELY(info)) {
             return *info;
         }
-        TINT_ICE(Resolver, diagnostics_)
-            << "failed to find dependency info for edge: '" << NameOf(from->node) << "' -> '"
-            << NameOf(to->node) << "'";
+        TINT_ICE() << "failed to find dependency info for edge: '" << NameOf(from->node) << "' -> '"
+                   << NameOf(to->node) << "'";
         return {};
     }
 
@@ -888,7 +891,7 @@
     return da.Run(module);
 }
 
-std::string ResolvedIdentifier::String(diag::List& diagnostics) const {
+std::string ResolvedIdentifier::String() const {
     if (auto* node = Node()) {
         return Switch(
             node,
@@ -914,8 +917,7 @@
                 return "parameter '" + n->name->symbol.Name() + "'";
             },
             [&](Default) {
-                TINT_UNREACHABLE(Resolver, diagnostics)
-                    << "unhandled ast::Node: " << node->TypeInfo().name;
+                TINT_UNREACHABLE() << "unhandled ast::Node: " << node->TypeInfo().name;
                 return "<unknown>";
             });
     }
@@ -947,7 +949,7 @@
         return "unresolved identifier '" + unresolved->name + "'";
     }
 
-    TINT_UNREACHABLE(Resolver, diagnostics) << "unhandled ResolvedIdentifier";
+    TINT_UNREACHABLE() << "unhandled ResolvedIdentifier";
     return "<unknown>";
 }
 
diff --git a/src/tint/lang/wgsl/resolver/dependency_graph.h b/src/tint/lang/wgsl/resolver/dependency_graph.h
index e555c09..4a14588 100644
--- a/src/tint/lang/wgsl/resolver/dependency_graph.h
+++ b/src/tint/lang/wgsl/resolver/dependency_graph.h
@@ -163,9 +163,8 @@
         return !(*this == other);
     }
 
-    /// @param diagnostics diagnostics used to report ICEs
     /// @return a description of the resolved symbol
-    std::string String(diag::List& diagnostics) const;
+    std::string String() const;
 
   private:
     std::variant<UnresolvedIdentifier,
diff --git a/src/tint/lang/wgsl/resolver/dependency_graph_test.cc b/src/tint/lang/wgsl/resolver/dependency_graph_test.cc
index 2459649..2c49fc6 100644
--- a/src/tint/lang/wgsl/resolver/dependency_graph_test.cc
+++ b/src/tint/lang/wgsl/resolver/dependency_graph_test.cc
@@ -1190,7 +1190,7 @@
 
     auto resolved = Build().resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
-    EXPECT_EQ(resolved->BuiltinFunction(), builtin) << resolved->String(Diagnostics());
+    EXPECT_EQ(resolved->BuiltinFunction(), builtin) << resolved->String();
 }
 
 INSTANTIATE_TEST_SUITE_P(Types,
@@ -1229,8 +1229,7 @@
 
     auto resolved = Build().resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
-    EXPECT_EQ(resolved->BuiltinType(), builtin::ParseBuiltin(name))
-        << resolved->String(Diagnostics());
+    EXPECT_EQ(resolved->BuiltinType(), builtin::ParseBuiltin(name)) << resolved->String();
 }
 
 INSTANTIATE_TEST_SUITE_P(Types,
@@ -1269,7 +1268,7 @@
 
     auto resolved = Build().resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
-    EXPECT_EQ(resolved->Access(), builtin::ParseAccess(name)) << resolved->String(Diagnostics());
+    EXPECT_EQ(resolved->Access(), builtin::ParseAccess(name)) << resolved->String();
 }
 
 INSTANTIATE_TEST_SUITE_P(Types,
@@ -1308,8 +1307,7 @@
 
     auto resolved = Build().resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
-    EXPECT_EQ(resolved->AddressSpace(), builtin::ParseAddressSpace(name))
-        << resolved->String(Diagnostics());
+    EXPECT_EQ(resolved->AddressSpace(), builtin::ParseAddressSpace(name)) << resolved->String();
 }
 
 INSTANTIATE_TEST_SUITE_P(Types,
@@ -1348,8 +1346,7 @@
 
     auto resolved = Build().resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
-    EXPECT_EQ(resolved->BuiltinValue(), builtin::ParseBuiltinValue(name))
-        << resolved->String(Diagnostics());
+    EXPECT_EQ(resolved->BuiltinValue(), builtin::ParseBuiltinValue(name)) << resolved->String();
 }
 
 INSTANTIATE_TEST_SUITE_P(Types,
@@ -1389,7 +1386,7 @@
     auto resolved = Build().resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
     EXPECT_EQ(resolved->InterpolationSampling(), builtin::ParseInterpolationSampling(name))
-        << resolved->String(Diagnostics());
+        << resolved->String();
 }
 
 INSTANTIATE_TEST_SUITE_P(Types,
@@ -1429,7 +1426,7 @@
     auto resolved = Build().resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
     EXPECT_EQ(resolved->InterpolationType(), builtin::ParseInterpolationType(name))
-        << resolved->String(Diagnostics());
+        << resolved->String();
 }
 
 INSTANTIATE_TEST_SUITE_P(
@@ -1471,8 +1468,7 @@
 
     auto resolved = Build().resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
-    EXPECT_EQ(resolved->TexelFormat(), builtin::ParseTexelFormat(name))
-        << resolved->String(Diagnostics());
+    EXPECT_EQ(resolved->TexelFormat(), builtin::ParseTexelFormat(name)) << resolved->String();
 }
 
 INSTANTIATE_TEST_SUITE_P(Types,
@@ -1553,7 +1549,7 @@
 
     auto resolved = Build().resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
-    EXPECT_EQ(resolved->Node(), decl) << resolved->String(Diagnostics());
+    EXPECT_EQ(resolved->Node(), decl) << resolved->String();
 }
 
 TEST_P(ResolverDependencyGraphShadowKindTest, ShadowedByStruct) {
@@ -1570,7 +1566,7 @@
 
     auto resolved = Build().resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
-    EXPECT_EQ(resolved->Node(), decl) << resolved->String(Diagnostics());
+    EXPECT_EQ(resolved->Node(), decl) << resolved->String();
 }
 
 TEST_P(ResolverDependencyGraphShadowKindTest, ShadowedByFunc) {
@@ -1585,7 +1581,7 @@
 
     auto resolved = Build().resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
-    EXPECT_EQ(resolved->Node(), decl) << resolved->String(Diagnostics());
+    EXPECT_EQ(resolved->Node(), decl) << resolved->String();
 }
 
 INSTANTIATE_TEST_SUITE_P(Access,
diff --git a/src/tint/lang/wgsl/resolver/intrinsic_table.cc b/src/tint/lang/wgsl/resolver/intrinsic_table.cc
index c28013a..718b8c5 100644
--- a/src/tint/lang/wgsl/resolver/intrinsic_table.cc
+++ b/src/tint/lang/wgsl/resolver/intrinsic_table.cc
@@ -1429,7 +1429,7 @@
         return_type =
             Match(match.templates, match.overload, indices, earliest_eval_stage).Type(&any);
         if (TINT_UNLIKELY(!return_type)) {
-            TINT_ICE(Resolver, builder.Diagnostics()) << "MatchState.Match() returned null";
+            TINT_ICE() << "MatchState.Match() returned null";
             return {};
         }
     } else {
@@ -1763,7 +1763,7 @@
             ss << std::endl;
         }
     }
-    TINT_ICE(Resolver, builder.Diagnostics()) << ss.str();
+    TINT_ICE() << ss.str();
 }
 
 }  // namespace
diff --git a/src/tint/lang/wgsl/resolver/resolver.cc b/src/tint/lang/wgsl/resolver/resolver.cc
index 4fb716d..6e2ffcc 100644
--- a/src/tint/lang/wgsl/resolver/resolver.cc
+++ b/src/tint/lang/wgsl/resolver/resolver.cc
@@ -136,7 +136,7 @@
     bool result = ResolveInternal();
 
     if (TINT_UNLIKELY(!result && !diagnostics_.contains_errors())) {
-        TINT_ICE(Resolver, diagnostics_) << "resolving failed, but no error was raised";
+        AddICE("resolving failed, but no error was raised", {});
         return false;
     }
 
@@ -179,8 +179,7 @@
                 [&](const ast::Variable* var) { return GlobalVariable(var); },
                 [&](const ast::ConstAssert* ca) { return ConstAssert(ca); },
                 [&](Default) {
-                    TINT_UNREACHABLE(Resolver, diagnostics_)
-                        << "unhandled global declaration: " << decl->TypeInfo().name;
+                    TINT_UNREACHABLE() << "unhandled global declaration: " << decl->TypeInfo().name;
                     return false;
                 })) {
             return false;
@@ -208,10 +207,10 @@
     bool result = true;
     for (auto* node : builder_->ASTNodes().Objects()) {
         if (TINT_UNLIKELY(!marked_[node->node_id.value])) {
-            TINT_ICE(Resolver, diagnostics_)
-                << "AST node '" << node->TypeInfo().name << "' was not reached by the resolver\n"
-                << "At: " << node->source << "\n"
+            StringStream err;
+            err << "AST node '" << node->TypeInfo().name << "' was not reached by the resolver\n"
                 << "Pointer: " << node;
+            AddICE(err.str(), node->source);
             result = false;
         }
     }
@@ -229,9 +228,10 @@
         [&](const ast::Override* override) { return Override(override); },
         [&](const ast::Const* const_) { return Const(const_, is_global); },
         [&](Default) {
-            TINT_ICE(Resolver, diagnostics_)
-                << "Resolver::GlobalVariable() called with a unknown variable type: "
+            StringStream err;
+            err << "Resolver::GlobalVariable() called with a unknown variable type: "
                 << v->TypeInfo().name;
+            AddICE(err.str(), v->source);
             return nullptr;
         });
 }
@@ -876,10 +876,10 @@
     for (auto it : dependencies_.shadows) {
         CastableBase* b = sem_.Get(it.value);
         if (TINT_UNLIKELY(!b)) {
-            TINT_ICE(Resolver, diagnostics_)
-                << "AST node '" << it.value->TypeInfo().name << "' had no semantic info\n"
-                << "At: " << it.value->source << "\n"
+            StringStream err;
+            err << "AST node '" << it.value->TypeInfo().name << "' had no semantic info\n"
                 << "Pointer: " << it.value;
+            AddICE(err.str(), it.value->source);
         }
 
         Switch(
@@ -1145,8 +1145,9 @@
     if (decl->body) {
         Mark(decl->body);
         if (TINT_UNLIKELY(current_compound_statement_)) {
-            TINT_ICE(Resolver, diagnostics_)
-                << "Resolver::Function() called with a current compound statement";
+            StringStream err;
+            err << "Resolver::Function() called with a current compound statement";
+            AddICE(err.str(), decl->body->source);
             return nullptr;
         }
         auto* body = StatementScope(decl->body, builder_->create<sem::FunctionBlockStatement>(func),
@@ -1467,7 +1468,7 @@
     constexpr size_t kMaxExpressionDepth = 512U;
     bool failed = false;
     if (!ast::TraverseExpressions<ast::TraverseOrder::RightToLeft>(
-            root, diagnostics_, [&](const ast::Expression* expr, size_t depth) {
+            root, [&](const ast::Expression* expr, size_t depth) {
                 if (depth > kMaxExpressionDepth) {
                     AddError(
                         "reached max expression depth of " + std::to_string(kMaxExpressionDepth),
@@ -1487,6 +1488,7 @@
                 sorted.Push(expr);
                 return ast::TraverseAction::Descend;
             })) {
+        AddError("TraverseExpressions failed", root->source);
         return nullptr;
     }
 
@@ -1513,8 +1515,9 @@
                                                               /* has_side_effects */ false);
             },
             [&](Default) {
-                TINT_ICE(Resolver, diagnostics_)
-                    << "unhandled expression type: " << expr->TypeInfo().name;
+                StringStream err;
+                err << "unhandled expression type: " << expr->TypeInfo().name;
+                AddICE(err.str(), expr->source);
                 return nullptr;
             });
         if (!sem_expr) {
@@ -1546,11 +1549,12 @@
                     ((*binary)->IsLogicalOr() && lhs_is_true)) {
                     // Mark entire expression tree to not const-evaluate
                     auto r = ast::TraverseExpressions(  //
-                        (*binary)->rhs, diagnostics_, [&](const ast::Expression* e) {
+                        (*binary)->rhs, [&](const ast::Expression* e) {
                             skip_const_eval_.Add(e);
                             return ast::TraverseAction::Descend;
                         });
                     if (!r) {
+                        AddError("TraverseExpressions failed", root->source);
                         return nullptr;
                     }
                 }
@@ -1558,7 +1562,7 @@
         }
     }
 
-    TINT_ICE(Resolver, diagnostics_) << "Expression() did not find root node";
+    AddICE("Expression() did not find root node", root->source);
     return nullptr;
 }
 
@@ -1837,9 +1841,10 @@
     if (!skip_const_eval_.Contains(decl)) {
         auto expr_val = expr->ConstantValue();
         if (TINT_UNLIKELY(!expr_val)) {
-            TINT_ICE(Resolver, diagnostics_)
-                << decl->source << "Materialize(" << decl->TypeInfo().name
+            StringStream err;
+            err << decl->source << "Materialize(" << decl->TypeInfo().name
                 << ") called on expression with no constant value";
+            AddICE(err.str(), expr->Declaration()->source);
             return nullptr;
         }
 
@@ -1850,9 +1855,10 @@
         }
         materialized_val = val.Get();
         if (TINT_UNLIKELY(!materialized_val)) {
-            TINT_ICE(Resolver, diagnostics_)
-                << decl->source << "ConvertValue(" << expr_val->Type()->FriendlyName() << " -> "
+            StringStream err;
+            err << decl->source << "ConvertValue(" << expr_val->Type()->FriendlyName() << " -> "
                 << concrete_ty->FriendlyName() << ") returned invalid value";
+            AddICE(err.str(), expr->Declaration()->source);
             return nullptr;
         }
     }
@@ -2126,7 +2132,7 @@
             [&](const type::Bool*) { return ctor_or_conv(CtorConvIntrinsic::kBool, nullptr); },
             [&](const type::Vector* v) {
                 if (v->Packed()) {
-                    TINT_ASSERT(Resolver, v->Width() == 3u);
+                    TINT_ASSERT(v->Width() == 3u);
                     return ctor_or_conv(CtorConvIntrinsic::kPackedVec3, v->type());
                 }
                 return ctor_or_conv(VectorCtorConvIntrinsic(v->Width()), v->type());
@@ -2225,8 +2231,9 @@
     auto call = [&]() -> sem::Call* {
         auto resolved = dependencies_.resolved_identifiers.Get(ident);
         if (!resolved) {
-            TINT_ICE(Resolver, diagnostics_)
-                << "identifier '" << ident->symbol.Name() << "' was not resolved";
+            StringStream err;
+            err << "identifier '" << ident->symbol.Name() << "' was not resolved";
+            AddICE(err.str(), ident->source);
             return nullptr;
         }
 
@@ -2882,7 +2889,9 @@
     }
 
     auto name = ident->symbol.Name();
-    TINT_ICE(Resolver, diagnostics_) << ident->source << " unhandled builtin type '" << name << "'";
+    StringStream err;
+    err << " unhandled builtin type '" << name << "'";
+    AddICE(err.str(), ident->source);
     return nullptr;
 }
 
@@ -2905,7 +2914,10 @@
     const auto& signature = builtin->Signature();
     int texture_index = signature.IndexOf(sem::ParameterUsage::kTexture);
     if (TINT_UNLIKELY(texture_index == -1)) {
-        TINT_ICE(Resolver, diagnostics_) << "texture builtin without texture parameter";
+        StringStream err;
+        err << "texture builtin without texture parameter";
+        AddICE(err.str(), {});
+        return;
     }
     if (auto* user =
             args[static_cast<size_t>(texture_index)]->UnwrapLoad()->As<sem::VariableUser>()) {
@@ -3013,8 +3025,7 @@
                 case ast::IntLiteralExpression::Suffix::kU:
                     return builder_->create<type::U32>();
             }
-            TINT_UNREACHABLE(Resolver, diagnostics_)
-                << "Unhandled integer literal suffix: " << i->suffix;
+            TINT_UNREACHABLE() << "Unhandled integer literal suffix: " << i->suffix;
             return nullptr;
         },
         [&](const ast::FloatLiteralExpression* f) -> type::Type* {
@@ -3028,14 +3039,12 @@
                                ? builder_->create<type::F16>()
                                : nullptr;
             }
-            TINT_UNREACHABLE(Resolver, diagnostics_)
-                << "Unhandled float literal suffix: " << f->suffix;
+            TINT_UNREACHABLE() << "Unhandled float literal suffix: " << f->suffix;
             return nullptr;
         },
         [&](const ast::BoolLiteralExpression*) { return builder_->create<type::Bool>(); },
         [&](Default) {
-            TINT_UNREACHABLE(Resolver, diagnostics_)
-                << "Unhandled literal type: " << literal->TypeInfo().name;
+            TINT_UNREACHABLE() << "Unhandled literal type: " << literal->TypeInfo().name;
             return nullptr;
         });
 
@@ -3066,8 +3075,9 @@
 
     auto resolved = dependencies_.resolved_identifiers.Get(ident);
     if (!resolved) {
-        TINT_ICE(Resolver, diagnostics_)
-            << "identifier '" << ident->symbol.Name() << "' was not resolved";
+        StringStream err;
+        err << "identifier '" << ident->symbol.Name() << "' was not resolved";
+        AddICE(err.str(), expr->source);
         return nullptr;
     }
 
@@ -3253,8 +3263,7 @@
         return nullptr;
     }
 
-    TINT_UNREACHABLE(Resolver, diagnostics_)
-        << "unhandled resolved identifier: " << resolved->String(diagnostics_);
+    TINT_UNREACHABLE() << "unhandled resolved identifier: " << resolved->String();
     return nullptr;
 }
 
@@ -3853,7 +3862,7 @@
     } else if (auto* str = named_type->As<ast::Struct>()) {
         result = Structure(str);
     } else {
-        TINT_UNREACHABLE(Resolver, diagnostics_) << "Unhandled TypeDecl";
+        TINT_UNREACHABLE() << "Unhandled TypeDecl";
     }
 
     if (!result) {
@@ -4271,7 +4280,7 @@
         return nullptr;
     }
     if (TINT_UNLIKELY(struct_align > std::numeric_limits<uint32_t>::max())) {
-        TINT_ICE(Resolver, diagnostics_) << "calculated struct stride exceeds uint32";
+        AddICE("calculated struct stride exceeds uint32", str->source);
         return nullptr;
     }
 
@@ -4749,7 +4758,7 @@
 
 bool Resolver::Mark(const ast::Node* node) {
     if (TINT_UNLIKELY(node == nullptr)) {
-        TINT_ICE(Resolver, diagnostics_) << "Resolver::Mark() called with nullptr";
+        AddICE("Resolver::Mark() called with nullptr", {});
         return false;
     }
     auto marked_bit_ref = marked_[node->node_id.value];
@@ -4757,10 +4766,11 @@
         marked_bit_ref = true;
         return true;
     }
-    TINT_ICE(Resolver, diagnostics_) << "AST node '" << node->TypeInfo().name
-                                     << "' was encountered twice in the same AST of a Program\n"
-                                     << "At: " << node->source << "\n"
-                                     << "Pointer: " << node;
+    StringStream err;
+    err << "AST node '" << node->TypeInfo().name
+        << "' was encountered twice in the same AST of a Program\n"
+        << "Pointer: " << node;
+    AddICE(err.str(), node->source);
     return false;
 }
 
@@ -4789,7 +4799,7 @@
 void Resolver::ErrorMismatchedResolvedIdentifier(const Source& source,
                                                  const ResolvedIdentifier& resolved,
                                                  std::string_view wanted) {
-    AddError("cannot use " + resolved.String(diagnostics_) + " as " + std::string(wanted), source);
+    AddError("cannot use " + resolved.String() + " as " + std::string(wanted), source);
     sem_.NoteDeclarationSource(resolved.Node());
 }
 
@@ -4797,6 +4807,20 @@
     AddError("@" + attr->Name() + " is not valid for " + std::string(use), attr->source);
 }
 
+void Resolver::AddICE(const std::string& msg, const Source& source) const {
+    if (source.file) {
+        TINT_ICE() << source << ": " << msg;
+    } else {
+        TINT_ICE() << msg;
+    }
+    diag::Diagnostic err{};
+    err.severity = diag::Severity::InternalCompilerError;
+    err.system = diag::System::Resolver;
+    err.source = source;
+    err.message = msg;
+    diagnostics_.add(std::move(err));
+}
+
 void Resolver::AddError(const std::string& msg, const Source& source) const {
     diagnostics_.add_error(diag::System::Resolver, msg, source);
 }
diff --git a/src/tint/lang/wgsl/resolver/resolver.h b/src/tint/lang/wgsl/resolver/resolver.h
index 64008a6..322965a 100644
--- a/src/tint/lang/wgsl/resolver/resolver.h
+++ b/src/tint/lang/wgsl/resolver/resolver.h
@@ -538,6 +538,9 @@
     /// @param use the thing that the attribute was applied to
     void ErrorInvalidAttribute(const ast::Attribute* attr, std::string_view use);
 
+    /// Adds the given internal compiler error message to the diagnostics
+    void AddICE(const std::string& msg, const Source& source) const;
+
     /// Adds the given error message to the diagnostics
     void AddError(const std::string& msg, const Source& source) const;
 
diff --git a/src/tint/lang/wgsl/resolver/sem_helper.cc b/src/tint/lang/wgsl/resolver/sem_helper.cc
index 92531ef..eb161a8 100644
--- a/src/tint/lang/wgsl/resolver/sem_helper.cc
+++ b/src/tint/lang/wgsl/resolver/sem_helper.cc
@@ -88,8 +88,8 @@
             return "texel format '" + tint::ToString(fmt->Value()) + "'";
         },
         [&](Default) -> std::string {
-            TINT_ICE(Resolver, builder_->Diagnostics())
-                << "unhandled sem::Expression type: " << (expr ? expr->TypeInfo().name : "<null>");
+            TINT_ICE() << "unhandled sem::Expression type: "
+                       << (expr ? expr->TypeInfo().name : "<null>");
             return "<unknown>";
         });
 }
diff --git a/src/tint/lang/wgsl/resolver/sem_helper.h b/src/tint/lang/wgsl/resolver/sem_helper.h
index 4f567e8..dd46bac 100644
--- a/src/tint/lang/wgsl/resolver/sem_helper.h
+++ b/src/tint/lang/wgsl/resolver/sem_helper.h
@@ -48,10 +48,9 @@
         using T = sem::Info::GetResultType<SEM, AST>;
         auto* sem = builder_->Sem().Get(ast);
         if (TINT_UNLIKELY(!sem)) {
-            TINT_ICE(Resolver, builder_->Diagnostics())
-                << "AST node '" << ast->TypeInfo().name << "' had no semantic info\n"
-                << "At: " << ast->source << "\n"
-                << "Pointer: " << ast;
+            TINT_ICE() << "AST node '" << ast->TypeInfo().name << "' had no semantic info\n"
+                       << "At: " << ast->source << "\n"
+                       << "Pointer: " << ast;
         }
         return const_cast<T*>(As<T>(sem));
     }
diff --git a/src/tint/lang/wgsl/resolver/uniformity.cc b/src/tint/lang/wgsl/resolver/uniformity.cc
index 392449f..7d19804bd6 100644
--- a/src/tint/lang/wgsl/resolver/uniformity.cc
+++ b/src/tint/lang/wgsl/resolver/uniformity.cc
@@ -140,7 +140,7 @@
     /// Add an edge to the `to` node.
     /// @param to the destination node
     void AddEdge(Node* to) {
-        TINT_ASSERT(Resolver, to != nullptr);
+        TINT_ASSERT(to != nullptr);
         edges.Add(to);
     }
 };
@@ -273,7 +273,7 @@
             case builtin::DiagnosticSeverity::kInfo:
                 return required_to_be_uniform_info;
             default:
-                TINT_ASSERT(Resolver, false && "unhandled severity");
+                TINT_UNREACHABLE() << "unhandled severity";
                 return nullptr;
         }
     }
@@ -1053,7 +1053,7 @@
                     current_function_->value_return->AddEdge(v);
                     cf_ret = cf1;
                 } else {
-                    TINT_ASSERT(Resolver, cf != nullptr);
+                    TINT_ASSERT(cf != nullptr);
                     cf_ret = cf;
                 }
 
@@ -1161,8 +1161,7 @@
             },
 
             [&](Default) {
-                TINT_ICE(Resolver, diagnostics_)
-                    << "unknown statement type: " << std::string(stmt->TypeInfo().name);
+                TINT_ICE() << "unknown statement type: " << std::string(stmt->TypeInfo().name);
                 return nullptr;
             });
     }
@@ -1190,7 +1189,7 @@
 
         auto* node = CreateNode({NameFor(ident), "_ident_expr"}, ident);
         auto* sem_ident = sem_.GetVal(ident);
-        TINT_ASSERT(Resolver, sem_ident);
+        TINT_ASSERT(sem_ident);
         auto* var_user = sem_ident->Unwrap()->As<sem::VariableUser>();
         auto* sem = var_user->Variable();
         return Switch(
@@ -1294,8 +1293,8 @@
             },
 
             [&](Default) {
-                TINT_ICE(Resolver, diagnostics_)
-                    << "unknown identifier expression type: " << std::string(sem->TypeInfo().name);
+                TINT_ICE() << "unknown identifier expression type: "
+                           << std::string(sem->TypeInfo().name);
                 return std::pair<Node*, Node*>(nullptr, nullptr);
             });
     }
@@ -1367,8 +1366,7 @@
             },
 
             [&](Default) {
-                TINT_ICE(Resolver, diagnostics_)
-                    << "unknown expression type: " << std::string(expr->TypeInfo().name);
+                TINT_ICE() << "unknown expression type: " << std::string(expr->TypeInfo().name);
                 return std::pair<Node*, Node*>(nullptr, nullptr);
             });
     }
@@ -1377,7 +1375,7 @@
     /// @returns true if `u` is an indirection unary expression that ultimately dereferences a
     /// partial pointer, false otherwise.
     bool IsDerefOfPartialPointer(const ast::UnaryOpExpression* u) {
-        TINT_ASSERT(Resolver, u->op == ast::UnaryOp::kIndirection);
+        TINT_ASSERT(u->op == ast::UnaryOp::kIndirection);
 
         // To determine if we're dereferencing a partial pointer, unwrap *&
         // chains; if the final expression is an identifier, see if it's a
@@ -1389,7 +1387,7 @@
                 return true;
             }
         } else {
-            TINT_ASSERT(Resolver, e->Is<ast::AccessorExpression>());
+            TINT_ASSERT(e->Is<ast::AccessorExpression>());
             return true;
         }
         return false;
@@ -1436,9 +1434,8 @@
 
                     return LValue{cf, value, local};
                 } else {
-                    TINT_ICE(Resolver, diagnostics_)
-                        << "unknown lvalue identifier expression type: "
-                        << std::string(sem->Variable()->TypeInfo().name);
+                    TINT_ICE() << "unknown lvalue identifier expression type: "
+                               << std::string(sem->Variable()->TypeInfo().name);
                     return LValue{};
                 }
             },
@@ -1476,8 +1473,8 @@
             },
 
             [&](Default) {
-                TINT_ICE(Resolver, diagnostics_)
-                    << "unknown lvalue expression type: " << std::string(expr->TypeInfo().name);
+                TINT_ICE() << "unknown lvalue expression type: "
+                           << std::string(expr->TypeInfo().name);
                 return LValue{};
             });
     }
@@ -1577,7 +1574,7 @@
                 // We must have already analyzed the user-defined function since we process
                 // functions in dependency order.
                 auto info = functions_.Find(func->Declaration());
-                TINT_ASSERT(Resolver, info != nullptr);
+                TINT_ASSERT(info != nullptr);
                 callsite_tag = info->callsite_tag;
                 function_tag = info->function_tag;
                 func_info = info;
@@ -1590,9 +1587,7 @@
                 callsite_tag = {CallSiteTag::CallSiteNoRestriction};
                 function_tag = NoRestriction;
             },
-            [&](Default) {
-                TINT_ICE(Resolver, diagnostics_) << "unhandled function call target: " << name;
-            });
+            [&](Default) { TINT_ICE() << "unhandled function call target: " << name; });
 
         cf_after->AddEdge(call_node);
 
@@ -1662,7 +1657,7 @@
 
                     // Update the current stored value for this pointer argument.
                     auto* root_ident = sem_arg->RootIdentifier();
-                    TINT_ASSERT(Resolver, root_ident);
+                    TINT_ASSERT(root_ident);
                     current_function_->variables.Set(root_ident, ptr_result);
                 }
             } else {
@@ -1746,9 +1741,9 @@
                     return FindBuiltinThatRequiresUniformity(child_call, severity);
                 }
             }
-            TINT_ASSERT(Resolver, false && "unable to find child call with uniformity requirement");
+            TINT_UNREACHABLE() << "unable to find child call with uniformity requirement";
         } else {
-            TINT_ASSERT(Resolver, false && "unexpected call expression type");
+            TINT_UNREACHABLE() << "unexpected call expression type";
         }
         return nullptr;
     }
@@ -1766,7 +1761,7 @@
 
         // Get the source of the non-uniform value.
         auto* non_uniform_source = may_be_non_uniform->visited_from;
-        TINT_ASSERT(Resolver, non_uniform_source);
+        TINT_ASSERT(non_uniform_source);
 
         // Show where the non-uniform value results in non-uniform control flow.
         auto* control_flow = TraceBackAlongPathUntil(
@@ -1789,7 +1784,7 @@
     /// Add a diagnostic note to show the origin of a non-uniform value.
     /// @param non_uniform_source the node that represents a non-uniform value
     void ShowSourceOfNonUniformity(Node* non_uniform_source) {
-        TINT_ASSERT(Resolver, non_uniform_source);
+        TINT_ASSERT(non_uniform_source);
 
         auto var_type = [&](const sem::Variable* var) {
             switch (var->AddressSpace()) {
@@ -1874,7 +1869,7 @@
                         break;
                     }
                     default: {
-                        TINT_ICE(Resolver, diagnostics_) << "unhandled source of non-uniformity";
+                        TINT_ICE() << "unhandled source of non-uniformity";
                         break;
                     }
                 }
@@ -1883,9 +1878,7 @@
                 diagnostics_.add_note(diag::System::Resolver,
                                       "result of expression may be non-uniform", e->source);
             },
-            [&](Default) {
-                TINT_ICE(Resolver, diagnostics_) << "unhandled source of non-uniformity";
-            });
+            [&](Default) { TINT_ICE() << "unhandled source of non-uniformity"; });
     }
 
     /// Generate a diagnostic message for a uniformity issue.
@@ -1908,7 +1901,7 @@
         // Traverse the graph to generate a path from RequiredToBeUniform to the source node.
         function.ResetVisited();
         Traverse(function.RequiredToBeUniform(severity));
-        TINT_ASSERT(Resolver, source_node->visited_from);
+        TINT_ASSERT(source_node->visited_from);
 
         // Find a node that is required to be uniform that has a path to the source node.
         auto* cause = TraceBackAlongPathUntil(source_node, [&](Node* node) {
@@ -1917,7 +1910,7 @@
 
         // The node will always have a corresponding call expression.
         auto* call = cause->ast->As<ast::CallExpression>();
-        TINT_ASSERT(Resolver, call);
+        TINT_ASSERT(call);
         auto* target = SemCall(call)->Target();
         auto func_name = NameFor(call->target);
 
diff --git a/src/tint/lang/wgsl/resolver/validation_test.cc b/src/tint/lang/wgsl/resolver/validation_test.cc
index c6c399e..8a23f2d 100644
--- a/src/tint/lang/wgsl/resolver/validation_test.cc
+++ b/src/tint/lang/wgsl/resolver/validation_test.cc
@@ -155,8 +155,7 @@
             b.WrapInFunction(b.create<FakeExpr>());
             Resolver(&b).Resolve();
         },
-        "internal compiler error: unhandled expression type: "
-        "tint::resolver::FakeExpr");
+        "internal compiler error: unhandled expression type: tint::resolver::FakeExpr");
 }
 
 TEST_F(ResolverValidationTest, UsingUndefinedVariable_Fail) {
diff --git a/src/tint/lang/wgsl/resolver/validator.cc b/src/tint/lang/wgsl/resolver/validator.cc
index 1716e50..b7e4780 100644
--- a/src/tint/lang/wgsl/resolver/validator.cc
+++ b/src/tint/lang/wgsl/resolver/validator.cc
@@ -127,22 +127,19 @@
 }
 
 template <typename CALLBACK>
-void TraverseCallChain(diag::List& diagnostics,
-                       const sem::Function* from,
-                       const sem::Function* to,
-                       CALLBACK&& callback) {
+void TraverseCallChain(const sem::Function* from, const sem::Function* to, CALLBACK&& callback) {
     for (auto* f : from->TransitivelyCalledFunctions()) {
         if (f == to) {
             callback(f);
             return;
         }
         if (f->TransitivelyCalledFunctions().Contains(to)) {
-            TraverseCallChain(diagnostics, f, to, callback);
+            TraverseCallChain(f, to, callback);
             callback(f);
             return;
         }
     }
-    TINT_ICE(Resolver, diagnostics) << "TraverseCallChain() 'from' does not transitively call 'to'";
+    TINT_ICE() << "TraverseCallChain() 'from' does not transitively call 'to'";
 }
 
 }  // namespace
@@ -571,9 +568,8 @@
         [&](const ast::Let*) { return Let(local); },  //
         [&](const ast::Const*) { return true; },      //
         [&](Default) {
-            TINT_ICE(Resolver, diagnostics_)
-                << "Validator::Variable() called with a unknown variable type: "
-                << decl->TypeInfo().name;
+            TINT_ICE() << "Validator::Variable() called with a unknown variable type: "
+                       << decl->TypeInfo().name;
             return false;
         });
 }
@@ -611,9 +607,8 @@
         [&](const ast::Override*) { return Override(global, override_ids); },
         [&](const ast::Const*) { return Const(global); },
         [&](Default) {
-            TINT_ICE(Resolver, diagnostics_)
-                << "Validator::GlobalVariable() called with a unknown variable type: "
-                << decl->TypeInfo().name;
+            TINT_ICE() << "Validator::GlobalVariable() called with a unknown variable type: "
+                       << decl->TypeInfo().name;
             return false;
         });
 
@@ -1018,8 +1013,7 @@
             }
         } else if (TINT_UNLIKELY(IsValidationEnabled(
                        decl->attributes, ast::DisabledValidation::kFunctionHasNoBody))) {
-            TINT_ICE(Resolver, diagnostics_)
-                << "Function " << decl->name->symbol.Name() << " has no body";
+            TINT_ICE() << "Function " << decl->name->symbol.Name() << " has no body";
         }
     }
 
@@ -1034,8 +1028,7 @@
     if (TINT_UNLIKELY(func->Behaviors() != sem::Behaviors{} &&
                       func->Behaviors() != sem::Behavior::kNext)) {
         auto name = decl->name->symbol.Name();
-        TINT_ICE(Resolver, diagnostics_)
-            << "function '" << name << "' behaviors are: " << func->Behaviors();
+        TINT_ICE() << "function '" << name << "' behaviors are: " << func->Behaviors();
     }
 
     return true;
@@ -1110,7 +1103,7 @@
                 bool is_input = param_or_ret == ParamOrRetType::kParameter;
 
                 if (TINT_UNLIKELY(!location.has_value())) {
-                    TINT_ICE(Resolver, diagnostics_) << "Location has no value";
+                    TINT_ICE() << "Location has no value";
                     return false;
                 }
 
@@ -1663,10 +1656,10 @@
         return false;
     }
 
-    TINT_ASSERT(Resolver, call->Arguments().Length() > 0);
+    TINT_ASSERT(call->Arguments().Length() > 0);
     auto* arg = call->Arguments()[0];
     auto* ptr = arg->Type()->As<type::Pointer>();
-    TINT_ASSERT(Resolver, ptr != nullptr);
+    TINT_ASSERT(ptr != nullptr);
     auto* ty = ptr->StoreType();
 
     if (ty->Is<type::Atomic>() || atomic_composite_info_.Contains(ty)) {
@@ -1763,7 +1756,7 @@
             auto* root = call->Arguments()[i]->RootIdentifier();
             auto* root_ptr_ty = root->Type()->As<type::Pointer>();
             auto* root_ref_ty = root->Type()->As<type::Reference>();
-            TINT_ASSERT(Resolver, root_ptr_ty || root_ref_ty);
+            TINT_ASSERT(root_ptr_ty || root_ref_ty);
             const type::Type* root_store_type;
             if (root_ptr_ty) {
                 root_store_type = root_ptr_ty->StoreType();
@@ -1865,7 +1858,7 @@
     }
 
     if (TINT_UNLIKELY(!c->Is<type::ConstantArrayCount>())) {
-        TINT_ICE(Resolver, diagnostics_) << "Invalid ArrayCount found";
+        TINT_ICE() << "Invalid ArrayCount found";
         return false;
     }
 
@@ -1899,7 +1892,7 @@
 bool Validator::PipelineStages(VectorRef<sem::Function*> entry_points) const {
     auto backtrace = [&](const sem::Function* func, const sem::Function* entry_point) {
         if (func != entry_point) {
-            TraverseCallChain(diagnostics_, entry_point, func, [&](const sem::Function* f) {
+            TraverseCallChain(entry_point, func, [&](const sem::Function* f) {
                 AddNote("called by function '" + f->Declaration()->name->symbol.Name() + "'",
                         f->Declaration()->source);
             });
@@ -2017,7 +2010,7 @@
                 AddNote("first 'push_constant' variable declaration is here",
                         var->Declaration()->source);
                 if (func != ep) {
-                    TraverseCallChain(diagnostics_, ep, func, [&](const sem::Function* f) {
+                    TraverseCallChain(ep, func, [&](const sem::Function* f) {
                         AddNote(
                             "called by function '" + f->Declaration()->name->symbol.Name() + "'",
                             f->Declaration()->source);
@@ -2029,12 +2022,11 @@
                 AddNote("second 'push_constant' variable declaration is here",
                         push_constant_var->Declaration()->source);
                 if (push_constant_func != ep) {
-                    TraverseCallChain(diagnostics_, ep, push_constant_func,
-                                      [&](const sem::Function* f) {
-                                          AddNote("called by function '" +
-                                                      f->Declaration()->name->symbol.Name() + "'",
-                                                  f->Declaration()->source);
-                                      });
+                    TraverseCallChain(ep, push_constant_func, [&](const sem::Function* f) {
+                        AddNote(
+                            "called by function '" + f->Declaration()->name->symbol.Name() + "'",
+                            f->Declaration()->source);
+                    });
                     AddNote(
                         "called by entry point '" + ep->Declaration()->name->symbol.Name() + "'",
                         ep->Declaration()->source);
@@ -2145,7 +2137,7 @@
                 },
                 [&](const ast::LocationAttribute* location) {
                     location_attribute = location;
-                    TINT_ASSERT(Resolver, member->Attributes().location.has_value());
+                    TINT_ASSERT(member->Attributes().location.has_value());
                     if (!LocationAttribute(location, member->Type(), stage,
                                            member->Declaration()->source)) {
                         return false;
@@ -2394,7 +2386,7 @@
         lhs = compound->lhs;
         rhs = compound->rhs;
     } else {
-        TINT_ICE(Resolver, diagnostics_) << "invalid assignment statement";
+        TINT_ICE() << "invalid assignment statement";
         return false;
     }
 
diff --git a/src/tint/lang/wgsl/sem/array_count.cc b/src/tint/lang/wgsl/sem/array_count.cc
index 2e867a4..407d6b2 100644
--- a/src/tint/lang/wgsl/sem/array_count.cc
+++ b/src/tint/lang/wgsl/sem/array_count.cc
@@ -38,7 +38,7 @@
 }
 
 type::ArrayCount* NamedOverrideArrayCount::Clone(type::CloneContext&) const {
-    TINT_ASSERT(Type, false && "Named override array count clone not available");
+    TINT_UNREACHABLE() << "Named override array count clone not available";
     return nullptr;
 }
 
@@ -59,7 +59,7 @@
 }
 
 type::ArrayCount* UnnamedOverrideArrayCount::Clone(type::CloneContext&) const {
-    TINT_ASSERT(Type, false && "Unnamed override array count clone not available");
+    TINT_UNREACHABLE() << "Unnamed override array count clone not available";
     return nullptr;
 }
 
diff --git a/src/tint/lang/wgsl/sem/block_statement.cc b/src/tint/lang/wgsl/sem/block_statement.cc
index 19c9211..8c2bf7a 100644
--- a/src/tint/lang/wgsl/sem/block_statement.cc
+++ b/src/tint/lang/wgsl/sem/block_statement.cc
@@ -37,7 +37,7 @@
 
 FunctionBlockStatement::FunctionBlockStatement(const sem::Function* function)
     : Base(function->Declaration()->body, nullptr, function) {
-    TINT_ASSERT(Semantic, function);
+    TINT_ASSERT(function);
 }
 
 FunctionBlockStatement::~FunctionBlockStatement() = default;
@@ -46,8 +46,8 @@
                                        const CompoundStatement* parent,
                                        const sem::Function* function)
     : Base(declaration, parent, function) {
-    TINT_ASSERT(Semantic, parent);
-    TINT_ASSERT(Semantic, function);
+    TINT_ASSERT(parent);
+    TINT_ASSERT(function);
 }
 LoopBlockStatement::~LoopBlockStatement() = default;
 
diff --git a/src/tint/lang/wgsl/sem/call.cc b/src/tint/lang/wgsl/sem/call.cc
index dede66b..643849b 100644
--- a/src/tint/lang/wgsl/sem/call.cc
+++ b/src/tint/lang/wgsl/sem/call.cc
@@ -32,8 +32,7 @@
       target_(target),
       arguments_(std::move(arguments)) {
     // Check that the stage is no earlier than the target supports
-    TINT_ASSERT(Semantic,
-                (target->Stage() <= stage) || (stage == sem::EvaluationStage::kNotEvaluated));
+    TINT_ASSERT((target->Stage() <= stage) || (stage == sem::EvaluationStage::kNotEvaluated));
 }
 
 Call::~Call() = default;
diff --git a/src/tint/lang/wgsl/sem/call_target.cc b/src/tint/lang/wgsl/sem/call_target.cc
index b5ce684..cee9cb8 100644
--- a/src/tint/lang/wgsl/sem/call_target.cc
+++ b/src/tint/lang/wgsl/sem/call_target.cc
@@ -34,7 +34,7 @@
     for (auto* param : parameters) {
         AddParameter(param);
     }
-    TINT_ASSERT(Semantic, return_type);
+    TINT_ASSERT(return_type);
 }
 
 CallTarget::CallTarget(const CallTarget&) = default;
diff --git a/src/tint/lang/wgsl/sem/info.cc b/src/tint/lang/wgsl/sem/info.cc
index 750836e..dabdaeb 100644
--- a/src/tint/lang/wgsl/sem/info.cc
+++ b/src/tint/lang/wgsl/sem/info.cc
@@ -73,7 +73,7 @@
 
     // Query the diagnostic severity from the semantic node that corresponds to the AST node.
     auto* sem = Get(ast_node);
-    TINT_ASSERT(Resolver, sem != nullptr);
+    TINT_ASSERT(sem != nullptr);
     auto severity = Switch(
         sem,  //
         [&](const sem::ValueExpression* expr) { return check_stmt(expr->Stmt()); },
@@ -83,7 +83,7 @@
             // Use the global severity set on the module.
             return check(module_);
         });
-    TINT_ASSERT(Resolver, severity != builtin::DiagnosticSeverity::kUndefined);
+    TINT_ASSERT(severity != builtin::DiagnosticSeverity::kUndefined);
     return severity;
 }
 
diff --git a/src/tint/lang/wgsl/sem/info.h b/src/tint/lang/wgsl/sem/info.h
index 91cbcce..649c9f0 100644
--- a/src/tint/lang/wgsl/sem/info.h
+++ b/src/tint/lang/wgsl/sem/info.h
@@ -25,7 +25,7 @@
 #include "src/tint/lang/wgsl/sem/node.h"
 #include "src/tint/lang/wgsl/sem/type_mappings.h"
 #include "src/tint/utils/containers/unique_vector.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 
 // Forward declarations
 namespace tint::sem {
@@ -104,7 +104,7 @@
     void Add(const AST* ast_node, const SemanticNodeTypeFor<AST>* sem_node) {
         Reserve(ast_node->node_id);
         // Check there's no semantic info already existing for the AST node
-        TINT_ASSERT(Semantic, nodes_[ast_node->node_id.value] == nullptr);
+        TINT_ASSERT(nodes_[ast_node->node_id.value] == nullptr);
         nodes_[ast_node->node_id.value] = sem_node;
     }
 
diff --git a/src/tint/lang/wgsl/sem/load.cc b/src/tint/lang/wgsl/sem/load.cc
index 2d57224..129f926 100644
--- a/src/tint/lang/wgsl/sem/load.cc
+++ b/src/tint/lang/wgsl/sem/load.cc
@@ -15,7 +15,7 @@
 #include "src/tint/lang/wgsl/sem/load.h"
 
 #include "src/tint/lang/core/type/reference.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::sem::Load);
 
@@ -29,7 +29,7 @@
            /* has_side_effects */ ref->HasSideEffects(),
            /* root_ident */ ref->RootIdentifier()),
       reference_(ref) {
-    TINT_ASSERT(Semantic, ref->Type()->Is<type::Reference>());
+    TINT_ASSERT(ref->Type()->Is<type::Reference>());
 }
 
 Load::~Load() = default;
diff --git a/src/tint/lang/wgsl/sem/loop_statement.cc b/src/tint/lang/wgsl/sem/loop_statement.cc
index b125176..f6605f2 100644
--- a/src/tint/lang/wgsl/sem/loop_statement.cc
+++ b/src/tint/lang/wgsl/sem/loop_statement.cc
@@ -26,8 +26,8 @@
                              const CompoundStatement* parent,
                              const sem::Function* function)
     : Base(declaration, parent, function) {
-    TINT_ASSERT(Semantic, parent);
-    TINT_ASSERT(Semantic, function);
+    TINT_ASSERT(parent);
+    TINT_ASSERT(function);
 }
 
 LoopStatement::~LoopStatement() = default;
@@ -36,8 +36,8 @@
                                                            const CompoundStatement* parent,
                                                            const sem::Function* function)
     : Base(declaration, parent, function) {
-    TINT_ASSERT(Semantic, parent);
-    TINT_ASSERT(Semantic, function);
+    TINT_ASSERT(parent);
+    TINT_ASSERT(function);
 }
 LoopContinuingBlockStatement::~LoopContinuingBlockStatement() = default;
 
diff --git a/src/tint/lang/wgsl/sem/struct.cc b/src/tint/lang/wgsl/sem/struct.cc
index e779ac0..07d79f8 100644
--- a/src/tint/lang/wgsl/sem/struct.cc
+++ b/src/tint/lang/wgsl/sem/struct.cc
@@ -28,7 +28,7 @@
                uint32_t size,
                uint32_t size_no_padding)
     : Base(name, members, align, size, size_no_padding), declaration_(declaration) {
-    TINT_ASSERT(Semantic, declaration != nullptr);
+    TINT_ASSERT(declaration != nullptr);
 }
 
 Struct::~Struct() = default;
@@ -42,7 +42,7 @@
                            uint32_t size,
                            const type::StructMemberAttributes& attributes)
     : Base(name, type, index, offset, align, size, attributes), declaration_(declaration) {
-    TINT_ASSERT(Semantic, declaration != nullptr);
+    TINT_ASSERT(declaration != nullptr);
 }
 
 StructMember::~StructMember() = default;
diff --git a/src/tint/lang/wgsl/sem/switch_statement.cc b/src/tint/lang/wgsl/sem/switch_statement.cc
index 53213d6..e3d0c67 100644
--- a/src/tint/lang/wgsl/sem/switch_statement.cc
+++ b/src/tint/lang/wgsl/sem/switch_statement.cc
@@ -27,8 +27,8 @@
                                  const CompoundStatement* parent,
                                  const sem::Function* function)
     : Base(declaration, parent, function) {
-    TINT_ASSERT(Semantic, parent);
-    TINT_ASSERT(Semantic, function);
+    TINT_ASSERT(parent);
+    TINT_ASSERT(function);
 }
 
 SwitchStatement::~SwitchStatement() = default;
@@ -41,8 +41,8 @@
                              const CompoundStatement* parent,
                              const sem::Function* function)
     : Base(declaration, parent, function) {
-    TINT_ASSERT(Semantic, parent);
-    TINT_ASSERT(Semantic, function);
+    TINT_ASSERT(parent);
+    TINT_ASSERT(function);
 }
 CaseStatement::~CaseStatement() = default;
 
diff --git a/src/tint/lang/wgsl/sem/value_expression.cc b/src/tint/lang/wgsl/sem/value_expression.cc
index 5d69e97..28d5104 100644
--- a/src/tint/lang/wgsl/sem/value_expression.cc
+++ b/src/tint/lang/wgsl/sem/value_expression.cc
@@ -37,10 +37,10 @@
       stage_(stage),
       constant_(std::move(constant)),
       has_side_effects_(has_side_effects) {
-    TINT_ASSERT(Semantic, type_);
-    TINT_ASSERT(Semantic, (constant != nullptr) == (stage == EvaluationStage::kConstant));
+    TINT_ASSERT(type_);
+    TINT_ASSERT((constant != nullptr) == (stage == EvaluationStage::kConstant));
     if (constant != nullptr) {
-        TINT_ASSERT(Semantic, type_ == constant->Type());
+        TINT_ASSERT(type_ == constant->Type());
     }
 }
 
diff --git a/src/tint/lang/wgsl/writer/ast_printer/ast_printer.cc b/src/tint/lang/wgsl/writer/ast_printer/ast_printer.cc
index 07a2edf..c21bb65 100644
--- a/src/tint/lang/wgsl/writer/ast_printer/ast_printer.cc
+++ b/src/tint/lang/wgsl/writer/ast_printer/ast_printer.cc
@@ -109,7 +109,7 @@
             [&](const ast::Function* func) { return EmitFunction(func); },
             [&](const ast::Variable* var) { return EmitVariable(Line(), var); },
             [&](const ast::ConstAssert* ca) { return EmitConstAssert(ca); },
-            [&](Default) { TINT_UNREACHABLE(Writer, diagnostics_); });
+            [&](Default) { TINT_UNREACHABLE(); });
         if (decl != program_->AST().GlobalDeclarations().Back()) {
             Line();
         }
@@ -420,9 +420,7 @@
         },
         [&](const ast::Let*) { out << "let"; }, [&](const ast::Override*) { out << "override"; },
         [&](const ast::Const*) { out << "const"; },
-        [&](Default) {
-            TINT_ICE(Writer, diagnostics_) << "unhandled variable type " << v->TypeInfo().name;
-        });
+        [&](Default) { TINT_ICE() << "unhandled variable type " << v->TypeInfo().name; });
 
     out << " " << v->name->symbol.Name();
 
@@ -526,8 +524,7 @@
                 out << "internal(" << internal->InternalName() << ")";
             },
             [&](Default) {
-                TINT_ICE(Writer, diagnostics_)
-                    << "Unsupported attribute '" << attr->TypeInfo().name << "'";
+                TINT_ICE() << "Unsupported attribute '" << attr->TypeInfo().name << "'";
             });
     }
 }
diff --git a/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc b/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc
index ffe0443..4ee82b2 100644
--- a/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc
+++ b/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc
@@ -74,9 +74,9 @@
 #include "src/tint/utils/rtti/switch.h"
 
 // Helper for calling TINT_UNIMPLEMENTED() from a Switch(object_ptr) default case.
-#define UNHANDLED_CASE(object_ptr)          \
-    TINT_UNIMPLEMENTED(IR, b.Diagnostics()) \
-        << "unhandled case in Switch(): " << (object_ptr ? object_ptr->TypeInfo().name : "<null>")
+#define UNHANDLED_CASE(object_ptr)                         \
+    TINT_UNIMPLEMENTED() << "unhandled case in Switch(): " \
+                         << (object_ptr ? object_ptr->TypeInfo().name : "<null>")
 
 // Helper for incrementing nesting_depth_ and then decrementing nesting_depth_ at the end
 // of the scope that holds the call.
@@ -495,8 +495,7 @@
 
         // Return has arguments - this is the return value.
         if (ret->Args().Length() != 1) {
-            TINT_ICE(IR, b.Diagnostics())
-                << "expected 1 value for return, got " << ret->Args().Length();
+            TINT_ICE() << "expected 1 value for return, got " << ret->Args().Length();
             return;
         }
 
@@ -641,13 +640,12 @@
                 [&](const type::Struct* s) {
                     if (auto* c = index->As<ir::Constant>()) {
                         auto i = c->Value()->ValueAs<uint32_t>();
-                        TINT_ASSERT_OR_RETURN(IR, i < s->Members().Length());
+                        TINT_ASSERT_OR_RETURN(i < s->Members().Length());
                         auto* member = s->Members()[i];
                         obj_ty = member->Type();
                         expr = b.MemberAccessor(expr, member->Name().NameView());
                     } else {
-                        TINT_ICE(IR, b.Diagnostics())
-                            << "invalid index for struct type: " << index->TypeInfo().name;
+                        TINT_ICE() << "invalid index for struct type: " << index->TypeInfo().name;
                     }
                 },
                 [&](Default) { UNHANDLED_CASE(obj_ty); });
@@ -660,7 +658,7 @@
         Vector<char, 4> components;
         for (uint32_t i : s->Indices()) {
             if (TINT_UNLIKELY(i >= 4)) {
-                TINT_ICE(IR, b.Diagnostics()) << "invalid swizzle index: " << i;
+                TINT_ICE() << "invalid swizzle index: " << i;
                 return;
             }
             components.Push("xyzw"[i]);
@@ -748,9 +746,8 @@
             [&](Default) -> ExprAndPtrKind {
                 auto lookup = bindings_.Find(value);
                 if (TINT_UNLIKELY(!lookup)) {
-                    TINT_ICE(IR, b.Diagnostics())
-                        << "Expr(" << (value ? value->TypeInfo().name : "null")
-                        << ") value has no expression";
+                    TINT_ICE() << "Expr(" << (value ? value->TypeInfo().name : "null")
+                               << ") value has no expression";
                     return {};
                 }
                 return std::visit(
@@ -769,10 +766,10 @@
                         }
 
                         if constexpr (std::is_same_v<T, ConsumedValue>) {
-                            TINT_ICE(IR, b.Diagnostics()) << "Expr(" << value->TypeInfo().name
-                                                          << ") called twice on the same value";
+                            TINT_ICE() << "Expr(" << value->TypeInfo().name
+                                       << ") called twice on the same value";
                         } else {
-                            TINT_ICE(IR, b.Diagnostics())
+                            TINT_ICE()
                                 << "Expr(" << value->TypeInfo().name << ") has unhandled value";
                         }
                         return {};
@@ -868,7 +865,7 @@
             [&](const type::Vector* v) {
                 auto el = Type(v->type());
                 if (v->Packed()) {
-                    TINT_ASSERT(IR, v->Width() == 3u);
+                    TINT_ASSERT(v->Width() == 3u);
                     return b.ty(builtin::Builtin::kPackedVec3, el);
                 } else {
                     return b.ty.vec(el, v->Width());
@@ -885,7 +882,7 @@
                 }
                 auto count = a->ConstantCount();
                 if (TINT_UNLIKELY(!count)) {
-                    TINT_ICE(IR, b.Diagnostics()) << type::Array::kErrExpectedConstantCount;
+                    TINT_ICE() << type::Array::kErrExpectedConstantCount;
                     return b.ty.array(el, u32(1), std::move(attrs));
                 }
                 return b.ty.array(el, u32(count.value()), std::move(attrs));
@@ -920,7 +917,7 @@
                 return b.ty.ptr(address_space, el, access);
             },
             [&](const type::Reference*) {
-                TINT_ICE(IR, b.Diagnostics()) << "reference types should never appear in the IR";
+                TINT_ICE() << "reference types should never appear in the IR";
                 return b.ty.i32();
             },
             [&](Default) {
@@ -1002,7 +999,7 @@
     /// Associates the IR value @p value with the AST expression @p expr.
     /// @p ptr_kind defines how pointer values are represented by @p expr.
     void Bind(ir::Value* value, const ast::Expression* expr, PtrKind ptr_kind = PtrKind::kRef) {
-        TINT_ASSERT(IR, value);
+        TINT_ASSERT(value);
         if (can_inline_.Remove(value)) {
             // Value will be inlined at its place of usage.
             if (TINT_LIKELY(bindings_.Add(value, InlinedValue{expr, ptr_kind}))) {
@@ -1026,20 +1023,18 @@
             return;
         }
 
-        TINT_ICE(IR, b.Diagnostics())
-            << "Bind(" << value->TypeInfo().name << ") called twice for same value";
+        TINT_ICE() << "Bind(" << value->TypeInfo().name << ") called twice for same value";
     }
 
     /// Associates the IR value @p value with the AST 'var', 'let' or parameter with the name @p
     /// name.
     /// @p ptr_kind defines how pointer values are represented by @p expr.
     void Bind(ir::Value* value, Symbol name, PtrKind ptr_kind) {
-        TINT_ASSERT(IR, value);
+        TINT_ASSERT(value);
 
         bool added = bindings_.Add(value, VariableValue{name, ptr_kind});
         if (TINT_UNLIKELY(!added)) {
-            TINT_ICE(IR, b.Diagnostics())
-                << "Bind(" << value->TypeInfo().name << ") called twice for same value";
+            TINT_ICE() << "Bind(" << value->TypeInfo().name << ") called twice for same value";
         }
     }
 
diff --git a/src/tint/lang/wgsl/writer/ir_to_program/rename_conflicts.cc b/src/tint/lang/wgsl/writer/ir_to_program/rename_conflicts.cc
index f7f62f7..8795491 100644
--- a/src/tint/lang/wgsl/writer/ir_to_program/rename_conflicts.cc
+++ b/src/tint/lang/wgsl/writer/ir_to_program/rename_conflicts.cc
@@ -261,9 +261,7 @@
             [&](ir::Value* value) { ir->SetName(value, new_name); },
             [&](type::Struct* str) { str->SetName(new_name); },
             [&](Default) {
-                diag::List diags;
-                TINT_ICE(Transform, diags)
-                    << "unhandled type for renaming: " << thing->TypeInfo().name;
+                TINT_ICE() << "unhandled type for renaming: " << thing->TypeInfo().name;
             });
     }
 
diff --git a/src/tint/lang/wgsl/writer/syntax_tree_printer/syntax_tree_printer.cc b/src/tint/lang/wgsl/writer/syntax_tree_printer/syntax_tree_printer.cc
index 5de0f1e..7d0e627 100644
--- a/src/tint/lang/wgsl/writer/syntax_tree_printer/syntax_tree_printer.cc
+++ b/src/tint/lang/wgsl/writer/syntax_tree_printer/syntax_tree_printer.cc
@@ -91,7 +91,7 @@
             [&](const ast::Function* func) { EmitFunction(func); },
             [&](const ast::Variable* var) { EmitVariable(var); },
             [&](const ast::ConstAssert* ca) { EmitConstAssert(ca); },
-            [&](Default) { TINT_UNREACHABLE(Writer, diagnostics_); });
+            [&](Default) { TINT_UNREACHABLE(); });
 
         if (decl != program_->AST().GlobalDeclarations().Back()) {
             Line();
@@ -485,9 +485,7 @@
             [&](const ast::Let*) { Line() << "Let []"; },
             [&](const ast::Override*) { Line() << "Override []"; },
             [&](const ast::Const*) { Line() << "Const []"; },
-            [&](Default) {
-                TINT_ICE(Writer, diagnostics_) << "unhandled variable type " << v->TypeInfo().name;
-            });
+            [&](Default) { TINT_ICE() << "unhandled variable type " << v->TypeInfo().name; });
 
         Line() << "name: " << v->name->symbol.Name();
 
@@ -637,8 +635,7 @@
                 Line() << "InternalAttribute [" << internal->InternalName() << "]";
             },
             [&](Default) {
-                TINT_ICE(Writer, diagnostics_)
-                    << "Unsupported attribute '" << attr->TypeInfo().name << "'";
+                TINT_ICE() << "Unsupported attribute '" << attr->TypeInfo().name << "'";
             });
     }
 }
diff --git a/src/tint/test_main.cc b/src/tint/test_main.cc
index 1c75902..4f7ae8d 100644
--- a/src/tint/test_main.cc
+++ b/src/tint/test_main.cc
@@ -13,17 +13,12 @@
 // limitations under the License.
 
 #include "gmock/gmock.h"
-#include "src/tint/lang/wgsl/program/program.h"
 #include "tint/tint.h"
 
-#if TINT_BUILD_SPV_READER
-#include "src/tint/lang/spirv/reader/ast_parser/test_helper.h"
-#endif
-
 namespace {
 
-void TintInternalCompilerErrorReporter(const tint::diag::List& diagnostics) {
-    FAIL() << diagnostics.str();
+void TintInternalCompilerErrorReporter(const tint::InternalCompilerError& err) {
+    FAIL() << err.Error();
 }
 
 struct Flags {
@@ -58,12 +53,6 @@
         return -1;
     }
 
-#if TINT_BUILD_SPV_READER
-    if (flags.spirv_reader_dump_converted) {
-        tint::spirv::reader::test::DumpSuccessfullyConvertedSpirv();
-    }
-#endif  // TINT_BUILD_SPV_READER
-
     tint::SetInternalCompilerErrorReporter(&TintInternalCompilerErrorReporter);
 
     auto res = RUN_ALL_TESTS();
diff --git a/src/tint/utils/containers/hashmap.h b/src/tint/utils/containers/hashmap.h
index bfbe7fc..d3c7b96 100644
--- a/src/tint/utils/containers/hashmap.h
+++ b/src/tint/utils/containers/hashmap.h
@@ -21,7 +21,7 @@
 
 #include "src/tint/utils/containers/hashmap_base.h"
 #include "src/tint/utils/containers/vector.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/math/hash.h"
 
 namespace tint {
@@ -74,7 +74,7 @@
         /// trigger a TINT_ASSERT, or invalid pointer dereference.
         T* operator->() const {
             auto* hashmap_reference_lookup = Get();
-            TINT_ASSERT(Utils, hashmap_reference_lookup != nullptr);
+            TINT_ASSERT(hashmap_reference_lookup != nullptr);
             return hashmap_reference_lookup;
         }
 
diff --git a/src/tint/utils/containers/hashmap_base.h b/src/tint/utils/containers/hashmap_base.h
index a77299b..753564d 100644
--- a/src/tint/utils/containers/hashmap_base.h
+++ b/src/tint/utils/containers/hashmap_base.h
@@ -22,7 +22,7 @@
 #include <utility>
 
 #include "src/tint/utils/containers/vector.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/math/hash.h"
 
 #define TINT_ASSERT_ITERATORS_NOT_INVALIDATED
@@ -194,8 +194,8 @@
         /// @returns the value pointed to by this iterator
         EntryRef<IS_CONST> operator->() const {
 #ifdef TINT_ASSERT_ITERATORS_NOT_INVALIDATED
-            TINT_ASSERT(Utils, map.Generation() == initial_generation &&
-                                   "iterator invalidated by container modification");
+            TINT_ASSERT(map.Generation() == initial_generation &&
+                        "iterator invalidated by container modification");
 #endif
             return *this;
         }
@@ -203,8 +203,8 @@
         /// @returns a reference to the value at the iterator
         EntryRef<IS_CONST> operator*() const {
 #ifdef TINT_ASSERT_ITERATORS_NOT_INVALIDATED
-            TINT_ASSERT(Utils, map.Generation() == initial_generation &&
-                                   "iterator invalidated by container modification");
+            TINT_ASSERT(map.Generation() == initial_generation &&
+                        "iterator invalidated by container modification");
 #endif
             auto& ref = current->entry.value();
             if constexpr (ValueIsVoid) {
@@ -218,8 +218,8 @@
         /// @returns this iterator
         IteratorT& operator++() {
 #ifdef TINT_ASSERT_ITERATORS_NOT_INVALIDATED
-            TINT_ASSERT(Utils, map.Generation() == initial_generation &&
-                                   "iterator invalidated by container modification");
+            TINT_ASSERT(map.Generation() == initial_generation &&
+                        "iterator invalidated by container modification");
 #endif
             if (current == end) {
                 return *this;
@@ -234,8 +234,8 @@
         /// @returns true if this iterator is equal to other
         bool operator==(const IteratorT& other) const {
 #ifdef TINT_ASSERT_ITERATORS_NOT_INVALIDATED
-            TINT_ASSERT(Utils, map.Generation() == initial_generation &&
-                                   "iterator invalidated by container modification");
+            TINT_ASSERT(map.Generation() == initial_generation &&
+                        "iterator invalidated by container modification");
 #endif
             return current == other.current;
         }
@@ -245,8 +245,8 @@
         /// @returns true if this iterator is not equal to other
         bool operator!=(const IteratorT& other) const {
 #ifdef TINT_ASSERT_ITERATORS_NOT_INVALIDATED
-            TINT_ASSERT(Utils, map.Generation() == initial_generation &&
-                                   "iterator invalidated by container modification");
+            TINT_ASSERT(map.Generation() == initial_generation &&
+                        "iterator invalidated by container modification");
 #endif
             return current != other.current;
         }
@@ -436,11 +436,11 @@
             if (slot.entry.has_value()) {
                 num_alive++;
                 auto const [index, hash] = Hash(KeyOf(*slot.entry));
-                TINT_ASSERT(Utils, hash == slot.hash);
-                TINT_ASSERT(Utils, slot_idx == Wrap(index + slot.distance));
+                TINT_ASSERT(hash == slot.hash);
+                TINT_ASSERT(slot_idx == Wrap(index + slot.distance));
             }
         }
-        TINT_ASSERT(Utils, num_alive == count_);
+        TINT_ASSERT(num_alive == count_);
     }
 
   protected:
@@ -530,8 +530,7 @@
             index = (index == count - 1) ? 0 : index + 1;
         }
 
-        tint::diag::List diags;
-        TINT_ICE(Utils, diags) << "HashmapBase::Put() looped entire map without finding a slot";
+        TINT_ICE() << "HashmapBase::Put() looped entire map without finding a slot";
         return PutResult{};
     }
 
@@ -581,8 +580,7 @@
             index = (index == count - 1) ? 0 : index + 1;
         }
 
-        tint::diag::List diags;
-        TINT_ICE(Utils, diags) << "HashmapBase::IndexOf() looped entire map without finding a slot";
+        TINT_ICE() << "HashmapBase::IndexOf() looped entire map without finding a slot";
         return {/* found */ false, /* index */ 0};
     }
 
diff --git a/src/tint/utils/containers/hashset.h b/src/tint/utils/containers/hashset.h
index e3bc40b..1203047 100644
--- a/src/tint/utils/containers/hashset.h
+++ b/src/tint/utils/containers/hashset.h
@@ -24,7 +24,6 @@
 
 #include "src/tint/utils/containers/hashmap.h"
 #include "src/tint/utils/containers/vector.h"
-#include "src/tint/utils/debug/debug.h"
 
 namespace tint {
 
diff --git a/src/tint/utils/containers/slice.h b/src/tint/utils/containers/slice.h
index 7097409..d25c1de 100644
--- a/src/tint/utils/containers/slice.h
+++ b/src/tint/utils/containers/slice.h
@@ -18,7 +18,7 @@
 #include <cstdint>
 #include <iterator>
 
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/memory/bitcast.h"
 #include "src/tint/utils/rtti/castable.h"
 #include "src/tint/utils/traits/traits.h"
@@ -188,7 +188,7 @@
     /// @param i the element index. Must be less than `len`.
     /// @returns a reference to the i'th element.
     T& operator[](size_t i) {
-        TINT_ASSERT(Utils, i < Length());
+        TINT_ASSERT(i < Length());
         return data[i];
     }
 
@@ -196,31 +196,31 @@
     /// @param i the element index. Must be less than `len`.
     /// @returns a reference to the i'th element.
     const T& operator[](size_t i) const {
-        TINT_ASSERT(Utils, i < Length());
+        TINT_ASSERT(i < Length());
         return data[i];
     }
 
     /// @returns a reference to the first element in the vector
     T& Front() {
-        TINT_ASSERT(Utils, !IsEmpty());
+        TINT_ASSERT(!IsEmpty());
         return data[0];
     }
 
     /// @returns a reference to the first element in the vector
     const T& Front() const {
-        TINT_ASSERT(Utils, !IsEmpty());
+        TINT_ASSERT(!IsEmpty());
         return data[0];
     }
 
     /// @returns a reference to the last element in the vector
     T& Back() {
-        TINT_ASSERT(Utils, !IsEmpty());
+        TINT_ASSERT(!IsEmpty());
         return data[len - 1];
     }
 
     /// @returns a reference to the last element in the vector
     const T& Back() const {
-        TINT_ASSERT(Utils, !IsEmpty());
+        TINT_ASSERT(!IsEmpty());
         return data[len - 1];
     }
 
diff --git a/src/tint/utils/containers/vector.h b/src/tint/utils/containers/vector.h
index 32d42e3..c437731 100644
--- a/src/tint/utils/containers/vector.h
+++ b/src/tint/utils/containers/vector.h
@@ -24,7 +24,7 @@
 #include <vector>
 
 #include "src/tint/utils/containers/slice.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/macros/compiler.h"
 #include "src/tint/utils/memory/bitcast.h"
 #include "src/tint/utils/text/string_stream.h"
@@ -216,7 +216,7 @@
     /// @param i the element index. Must be less than `len`.
     /// @returns a reference to the i'th element.
     T& operator[](size_t i) {
-        TINT_ASSERT(Utils, i < Length());
+        TINT_ASSERT(i < Length());
         return impl_.slice[i];
     }
 
@@ -224,7 +224,7 @@
     /// @param i the element index. Must be less than `len`.
     /// @returns a reference to the i'th element.
     const T& operator[](size_t i) const {
-        TINT_ASSERT(Utils, i < Length());
+        TINT_ASSERT(i < Length());
         return impl_.slice[i];
     }
 
@@ -325,7 +325,7 @@
     /// Removes and returns the last element from the vector.
     /// @returns the popped element
     T Pop() {
-        TINT_ASSERT(Utils, !IsEmpty());
+        TINT_ASSERT(!IsEmpty());
         auto& el = impl_.slice.data[--impl_.slice.len];
         auto val = std::move(el);
         el.~T();
@@ -337,7 +337,7 @@
     /// @param element the element to insert
     template <typename EL>
     void Insert(size_t before, EL&& element) {
-        TINT_ASSERT(Utils, before <= Length());
+        TINT_ASSERT(before <= Length());
         size_t n = Length();
         Resize(Length() + 1);
         // Shuffle
@@ -354,8 +354,8 @@
     /// @param start the index of the first element to remove
     /// @param count the number of elements to remove
     void Erase(size_t start, size_t count = 1) {
-        TINT_ASSERT(Utils, start < Length());
-        TINT_ASSERT(Utils, (start + count) <= Length());
+        TINT_ASSERT(start < Length());
+        TINT_ASSERT((start + count) <= Length());
         // Shuffle
         for (size_t i = start + count; i < impl_.slice.len; i++) {
             auto& src = impl_.slice.data[i];
diff --git a/src/tint/utils/debug/debug.h b/src/tint/utils/debug/debug.h
deleted file mode 100644
index c039861..0000000
--- a/src/tint/utils/debug/debug.h
+++ /dev/null
@@ -1,156 +0,0 @@
-// Copyright 2021 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_UTILS_DEBUG_DEBUG_H_
-#define SRC_TINT_UTILS_DEBUG_DEBUG_H_
-
-#include <utility>
-
-#include "src/tint/utils/diagnostic/diagnostic.h"
-#include "src/tint/utils/diagnostic/formatter.h"
-#include "src/tint/utils/diagnostic/printer.h"
-#include "src/tint/utils/macros/compiler.h"
-#include "src/tint/utils/text/string_stream.h"
-
-namespace tint {
-
-/// Function type used for registering an internal compiler error reporter
-using InternalCompilerErrorReporter = void(const diag::List&);
-
-/// Sets the global error reporter to be called in case of internal compiler
-/// errors.
-/// @param reporter the error reporter
-void SetInternalCompilerErrorReporter(InternalCompilerErrorReporter* reporter);
-
-/// InternalCompilerError is a helper for reporting internal compiler errors.
-/// Construct the InternalCompilerError with the source location of the ICE
-/// fault and append any error details with the `<<` operator.
-/// When the InternalCompilerError is destructed, the concatenated error message
-/// is appended to the diagnostics list with the severity of
-/// tint::diag::Severity::InternalCompilerError, and if a
-/// InternalCompilerErrorReporter is set, then it is called with the diagnostic
-/// list.
-class InternalCompilerError {
-  public:
-    /// Constructor
-    /// @param file the file containing the ICE
-    /// @param line the line containing the ICE
-    /// @param system the Tint system that has raised the ICE
-    /// @param diagnostics the list of diagnostics to append the ICE message to
-    InternalCompilerError(const char* file,
-                          size_t line,
-                          diag::System system,
-                          diag::List& diagnostics);
-
-    /// Destructor.
-    /// Adds the internal compiler error message to the diagnostics list, and then
-    /// calls the InternalCompilerErrorReporter if one is set.
-    ~InternalCompilerError();
-
-    /// Appends `arg` to the ICE message.
-    /// @param arg the argument to append to the ICE message
-    /// @returns this object so calls can be chained
-    template <typename T>
-    InternalCompilerError& operator<<(T&& arg) {
-        msg_ << std::forward<T>(arg);
-        return *this;
-    }
-
-  private:
-    char const* const file_;
-    const size_t line_;
-    diag::System system_;
-    diag::List& diagnostics_;
-    StringStream msg_;
-};
-
-}  // namespace tint
-
-/// TINT_ICE() is a macro for appending an internal compiler error message
-/// to the diagnostics list `diagnostics`, and calling the
-/// InternalCompilerErrorReporter with the full diagnostic list if a reporter is
-/// set.
-/// The ICE message contains the callsite's file and line.
-/// Use the `<<` operator to append an error message to the ICE.
-#define TINT_ICE(system, diagnostics) \
-    tint::InternalCompilerError(__FILE__, __LINE__, ::tint::diag::System::system, diagnostics)
-
-/// TINT_UNREACHABLE() is a macro for appending a "TINT_UNREACHABLE"
-/// internal compiler error message to the diagnostics list `diagnostics`, and
-/// calling the InternalCompilerErrorReporter with the full diagnostic list if a
-/// reporter is set.
-/// The ICE message contains the callsite's file and line.
-/// Use the `<<` operator to append an error message to the ICE.
-#define TINT_UNREACHABLE(system, diagnostics) TINT_ICE(system, diagnostics) << "TINT_UNREACHABLE "
-
-/// TINT_UNIMPLEMENTED() is a macro for appending a "TINT_UNIMPLEMENTED"
-/// internal compiler error message to the diagnostics list `diagnostics`, and
-/// calling the InternalCompilerErrorReporter with the full diagnostic list if a
-/// reporter is set.
-/// The ICE message contains the callsite's file and line.
-/// Use the `<<` operator to append an error message to the ICE.
-#define TINT_UNIMPLEMENTED(system, diagnostics) \
-    TINT_ICE(system, diagnostics) << "TINT_UNIMPLEMENTED "
-
-/// TINT_ASSERT() is a macro for checking the expression is true, triggering a
-/// TINT_ICE if it is not.
-/// The ICE message contains the callsite's file and line.
-/// @warning: Unlike TINT_ICE() and TINT_UNREACHABLE(), TINT_ASSERT() does not
-/// append a message to an existing tint::diag::List. As such, TINT_ASSERT()
-/// may silently fail in builds where SetInternalCompilerErrorReporter() is not
-/// called. Only use in places where there's no sensible place to put proper
-/// error handling.
-#define TINT_ASSERT(system, condition)                                                   \
-    do {                                                                                 \
-        if (TINT_UNLIKELY(!(condition))) {                                               \
-            tint::diag::List diagnostics;                                                \
-            TINT_ICE(system, diagnostics) << "TINT_ASSERT(" #system ", " #condition ")"; \
-        }                                                                                \
-    } while (false)
-
-/// TINT_ASSERT_OR_RETURN() is a macro for checking the expression is true, triggering a
-/// TINT_ICE if it is not and returning from the calling function.
-/// The ICE message contains the callsite's file and line.
-/// @warning: Unlike TINT_ICE() and TINT_UNREACHABLE(), TINT_ASSERT_OR_RETURN() does not
-/// append a message to an existing tint::diag::List. As such, TINT_ASSERT_OR_RETURN()
-/// may silently fail in builds where SetInternalCompilerErrorReporter() is not
-/// called. Only use in places where there's no sensible place to put proper
-/// error handling.
-#define TINT_ASSERT_OR_RETURN(system, condition)                                         \
-    do {                                                                                 \
-        if (TINT_UNLIKELY(!(condition))) {                                               \
-            tint::diag::List diagnostics;                                                \
-            TINT_ICE(system, diagnostics) << "TINT_ASSERT(" #system ", " #condition ")"; \
-            return;                                                                      \
-        }                                                                                \
-    } while (false)
-
-/// TINT_ASSERT_OR_RETURN_VALUE() is a macro for checking the expression is true, triggering a
-/// TINT_ICE if it is not and returning a value from the calling function.
-/// The ICE message contains the callsite's file and line.
-/// @warning: Unlike TINT_ICE() and TINT_UNREACHABLE(), TINT_ASSERT_OR_RETURN_VALUE() does not
-/// append a message to an existing tint::diag::List. As such, TINT_ASSERT_OR_RETURN_VALUE()
-/// may silently fail in builds where SetInternalCompilerErrorReporter() is not
-/// called. Only use in places where there's no sensible place to put proper
-/// error handling.
-#define TINT_ASSERT_OR_RETURN_VALUE(system, condition, value)                            \
-    do {                                                                                 \
-        if (TINT_UNLIKELY(!(condition))) {                                               \
-            tint::diag::List diagnostics;                                                \
-            TINT_ICE(system, diagnostics) << "TINT_ASSERT(" #system ", " #condition ")"; \
-            return value;                                                                \
-        }                                                                                \
-    } while (false)
-
-#endif  // SRC_TINT_UTILS_DEBUG_DEBUG_H_
diff --git a/src/tint/utils/file/tmpfile_posix.cc b/src/tint/utils/file/tmpfile_posix.cc
index 9d6505b..47b92c1 100644
--- a/src/tint/utils/file/tmpfile_posix.cc
+++ b/src/tint/utils/file/tmpfile_posix.cc
@@ -17,7 +17,7 @@
 #include <unistd.h>
 #include <limits>
 
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 
 namespace tint {
 
@@ -34,7 +34,7 @@
     // (when the source value exceeds the representable range) is implementation
     // defined. While such a large file extension is unlikely in practice, we
     // enforce this here at runtime.
-    TINT_ASSERT(Utils, ext.length() <= static_cast<size_t>(std::numeric_limits<int>::max()));
+    TINT_ASSERT(ext.length() <= static_cast<size_t>(std::numeric_limits<int>::max()));
     std::string name = std::string(dir) + "/tint_XXXXXX" + ext;
     int file = mkstemps(&name[0], static_cast<int>(ext.length()));
     if (file != -1) {
diff --git a/src/tint/utils/generation_id.cc b/src/tint/utils/generation_id.cc
index bbcc984..b0b9a60 100644
--- a/src/tint/utils/generation_id.cc
+++ b/src/tint/utils/generation_id.cc
@@ -40,7 +40,6 @@
 void AssertGenerationIDsEqual(GenerationID a,
                               GenerationID b,
                               bool if_valid,
-                              diag::System system,
                               const char* msg,
                               const char* file,
                               size_t line) {
@@ -50,8 +49,7 @@
     if (if_valid && (!a || !b)) {
         return;  //  a or b were not valid
     }
-    diag::List diagnostics;
-    tint::InternalCompilerError(file, line, system, diagnostics) << msg;
+    tint::InternalCompilerError(file, line) << msg;
 }
 
 }  // namespace detail
diff --git a/src/tint/utils/generation_id.h b/src/tint/utils/generation_id.h
index fd8455a..6a9249b 100644
--- a/src/tint/utils/generation_id.h
+++ b/src/tint/utils/generation_id.h
@@ -18,7 +18,7 @@
 #include <stdint.h>
 #include <utility>
 
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/text/string_stream.h"
 
 namespace tint {
@@ -88,7 +88,6 @@
 void AssertGenerationIDsEqual(GenerationID a,
                               GenerationID b,
                               bool if_valid,
-                              diag::System system,
                               const char* msg,
                               const char* file,
                               size_t line);
@@ -102,15 +101,14 @@
 /// that the generation identifiers for A and B are equal, if both A and B have
 /// valid generation identifiers.
 #if TINT_CHECK_FOR_CROSS_GENERATION_LEAKS
-#define TINT_ASSERT_GENERATION_IDS_EQUAL(system, a, b)                           \
-    tint::detail::AssertGenerationIDsEqual(                                      \
-        GenerationIDOf(a), GenerationIDOf(b), false, tint::diag::System::system, \
-        "TINT_ASSERT_GENERATION_IDS_EQUAL(" #system "," #a ", " #b ")", __FILE__, __LINE__)
-#define TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(system, a, b)                             \
-    tint::detail::AssertGenerationIDsEqual(                                                 \
-        GenerationIDOf(a), GenerationIDOf(b), true, tint::diag::System::system,             \
-        "TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(" #system ", " #a ", " #b ")", __FILE__, \
-        __LINE__)
+#define TINT_ASSERT_GENERATION_IDS_EQUAL(a, b)                                                 \
+    tint::detail::AssertGenerationIDsEqual(GenerationIDOf(a), GenerationIDOf(b), false,        \
+                                           "TINT_ASSERT_GENERATION_IDS_EQUAL(" #a ", " #b ")", \
+                                           __FILE__, __LINE__)
+#define TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(a, b) \
+    tint::detail::AssertGenerationIDsEqual(             \
+        GenerationIDOf(a), GenerationIDOf(b), true,     \
+        "TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(" #a ", " #b ")", __FILE__, __LINE__)
 #else
 #define TINT_ASSERT_GENERATION_IDS_EQUAL(a, b) \
     do {                                       \
diff --git a/src/tint/utils/debug/debug.cc b/src/tint/utils/ice/ice.cc
similarity index 62%
rename from src/tint/utils/debug/debug.cc
rename to src/tint/utils/ice/ice.cc
index c5c07f1..df5c567 100644
--- a/src/tint/utils/debug/debug.cc
+++ b/src/tint/utils/ice/ice.cc
@@ -12,9 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 
 #include <memory>
+#include <string>
 
 #include "src/tint/utils/debug/debugger.h"
 
@@ -29,22 +30,19 @@
     ice_reporter = reporter;
 }
 
-InternalCompilerError::InternalCompilerError(const char* file,
-                                             size_t line,
-                                             diag::System system,
-                                             diag::List& diagnostics)
-    : file_(file), line_(line), system_(system), diagnostics_(diagnostics) {}
+InternalCompilerError::InternalCompilerError(const char* file, size_t line)
+    : file_(file), line_(line) {}
 
 InternalCompilerError::~InternalCompilerError() {
-    auto file = std::make_shared<Source::File>(file_, "");
-    Source source{Source::Range{{line_}}, file.get()};
-    diagnostics_.add_ice(system_, msg_.str(), source, std::move(file));
-
     if (ice_reporter) {
-        ice_reporter(diagnostics_);
+        ice_reporter(*this);
     }
-
     debugger::Break();
 }
 
+std::string InternalCompilerError::Error() const {
+    return std::string(File()) + +":" + std::to_string(Line()) +
+           " internal compiler error: " + Message();
+}
+
 }  // namespace tint
diff --git a/src/tint/utils/ice/ice.h b/src/tint/utils/ice/ice.h
new file mode 100644
index 0000000..63966f7
--- /dev/null
+++ b/src/tint/utils/ice/ice.h
@@ -0,0 +1,127 @@
+// Copyright 2021 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_UTILS_ICE_ICE_H_
+#define SRC_TINT_UTILS_ICE_ICE_H_
+
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include "src/tint/utils/macros/compiler.h"
+#include "src/tint/utils/text/string_stream.h"
+
+namespace tint {
+
+/// InternalCompilerError is a helper for reporting internal compiler errors.
+/// Construct the InternalCompilerError with the source location of the ICE fault and append any
+/// error details with the `<<` operator. When the InternalCompilerError is destructed, the
+/// concatenated error message is passed to the InternalCompilerErrorReporter.
+class InternalCompilerError {
+  public:
+    /// Constructor
+    /// @param file the file containing the ICE
+    /// @param line the line containing the ICE
+    InternalCompilerError(const char* file, size_t line);
+
+    /// Destructor.
+    /// Adds the internal compiler error message to the diagnostics list, and then
+    /// calls the InternalCompilerErrorReporter if one is set.
+    ~InternalCompilerError();
+
+    /// Appends `arg` to the ICE message.
+    /// @param arg the argument to append to the ICE message
+    /// @returns this object so calls can be chained
+    template <typename T>
+    InternalCompilerError& operator<<(T&& arg) {
+        msg_ << std::forward<T>(arg);
+        return *this;
+    }
+
+    /// @returns the file that triggered the ICE
+    const char* File() const { return file_; }
+
+    /// @returns the line that triggered the ICE
+    size_t Line() const { return line_; }
+
+    /// @returns the ICE message
+    std::string Message() const { return msg_.str(); }
+
+    /// @returns the ICE file, line and message
+    std::string Error() const;
+
+  private:
+    char const* const file_;
+    const size_t line_;
+    StringStream msg_;
+};
+
+/// Function type used for registering an internal compiler error reporter
+using InternalCompilerErrorReporter = void(const InternalCompilerError&);
+
+/// Sets the global error reporter to be called in case of internal compiler
+/// errors.
+/// @param reporter the error reporter
+void SetInternalCompilerErrorReporter(InternalCompilerErrorReporter* reporter);
+
+}  // namespace tint
+
+/// TINT_ICE() is a macro to invoke the InternalCompilerErrorReporter for an Internal Compiler
+/// Error. The ICE message contains the callsite's file and line. Use the `<<` operator to append an
+/// error message to the ICE.
+#define TINT_ICE() tint::InternalCompilerError(__FILE__, __LINE__)
+
+/// TINT_UNREACHABLE() is a macro invoke the InternalCompilerErrorReporter when an expectedly
+/// unreachable statement is reached. The ICE message contains the callsite's file and line. Use the
+/// `<<` operator to append an error message to the ICE.
+#define TINT_UNREACHABLE() TINT_ICE() << "TINT_UNREACHABLE "
+
+/// TINT_UNIMPLEMENTED() is a macro to invoke the InternalCompilerErrorReporter when unimplemented
+/// code is executed. The ICE message contains the callsite's file and line. Use the `<<` operator
+/// to append an error message to the ICE.
+#define TINT_UNIMPLEMENTED() TINT_ICE() << "TINT_UNIMPLEMENTED "
+
+/// TINT_ASSERT() is a macro for checking the expression is true, triggering a
+/// TINT_ICE if it is not.
+/// The ICE message contains the callsite's file and line.
+#define TINT_ASSERT(condition)                           \
+    do {                                                 \
+        if (TINT_UNLIKELY(!(condition))) {               \
+            TINT_ICE() << "TINT_ASSERT(" #condition ")"; \
+        }                                                \
+    } while (false)
+
+/// TINT_ASSERT_OR_RETURN() is a macro for checking the expression is true, triggering a
+/// TINT_ICE if it is not and returning from the calling function.
+/// The ICE message contains the callsite's file and line.
+#define TINT_ASSERT_OR_RETURN(condition)                 \
+    do {                                                 \
+        if (TINT_UNLIKELY(!(condition))) {               \
+            TINT_ICE() << "TINT_ASSERT(" #condition ")"; \
+            return;                                      \
+        }                                                \
+    } while (false)
+
+/// TINT_ASSERT_OR_RETURN_VALUE() is a macro for checking the expression is true, triggering a
+/// TINT_ICE if it is not and returning a value from the calling function.
+/// The ICE message contains the callsite's file and line.
+#define TINT_ASSERT_OR_RETURN_VALUE(condition, value)    \
+    do {                                                 \
+        if (TINT_UNLIKELY(!(condition))) {               \
+            TINT_ICE() << "TINT_ASSERT(" #condition ")"; \
+            return value;                                \
+        }                                                \
+    } while (false)
+
+#endif  // SRC_TINT_UTILS_ICE_ICE_H_
diff --git a/src/tint/utils/debug/debug_test.cc b/src/tint/utils/ice/ice_test.cc
similarity index 62%
rename from src/tint/utils/debug/debug_test.cc
rename to src/tint/utils/ice/ice_test.cc
index 3566427..36c4e17 100644
--- a/src/tint/utils/debug/debug_test.cc
+++ b/src/tint/utils/ice/ice_test.cc
@@ -12,28 +12,23 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 
 #include "gtest/gtest-spi.h"
 
 namespace tint {
 namespace {
 
-TEST(DebugTest, Unreachable) {
-    EXPECT_FATAL_FAILURE(
-        {
-            diag::List diagnostics;
-            TINT_UNREACHABLE(Test, diagnostics);
-        },
-        "internal compiler error");
+TEST(ICETest_AssertTrue_Test, Unreachable) {
+    EXPECT_FATAL_FAILURE({ TINT_UNREACHABLE(); }, "internal compiler error");
 }
 
-TEST(DebugTest, AssertTrue) {
-    TINT_ASSERT(Test, true);
+TEST(ICETest_AssertTrue_Test, AssertTrue) {
+    TINT_ASSERT(true);
 }
 
-TEST(DebugTest, AssertFalse) {
-    EXPECT_FATAL_FAILURE({ TINT_ASSERT(Test, false); }, "internal compiler error");
+TEST(ICETest_AssertTrue_Test, AssertFalse) {
+    EXPECT_FATAL_FAILURE({ TINT_ASSERT(false); }, "internal compiler error");
 }
 
 }  // namespace
diff --git a/src/tint/utils/result/result.h b/src/tint/utils/result/result.h
index ee87ecd..ad7e864 100644
--- a/src/tint/utils/result/result.h
+++ b/src/tint/utils/result/result.h
@@ -18,7 +18,7 @@
 #include <utility>
 #include <variant>
 
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/text/string_stream.h"
 
 namespace tint {
@@ -152,7 +152,7 @@
     }
 
   private:
-    void Validate() const { TINT_ASSERT(Utils, !std::holds_alternative<std::monostate>(value)); }
+    void Validate() const { TINT_ASSERT(!std::holds_alternative<std::monostate>(value)); }
 
     /// The result. Either a success of failure value.
     std::variant<std::monostate, SUCCESS_TYPE, FAILURE_TYPE> value;
diff --git a/src/tint/utils/text/float_to_string.cc b/src/tint/utils/text/float_to_string.cc
index cfbfc00..462af68 100644
--- a/src/tint/utils/text/float_to_string.cc
+++ b/src/tint/utils/text/float_to_string.cc
@@ -20,7 +20,7 @@
 #include <iomanip>
 #include <limits>
 
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/text/string_stream.h"
 
 namespace tint::writer {
@@ -122,7 +122,7 @@
                 }
             } else {
                 // Subnormal, and not zero.
-                TINT_ASSERT(Writer, mantissa != 0);
+                TINT_ASSERT(mantissa != 0);
                 const auto kTopBit = static_cast<uint_t>(1u) << T::kMantissaBits;
 
                 // Shift left until we get 1.x
diff --git a/src/tint/utils/text/symbol.cc b/src/tint/utils/text/symbol.cc
index 7b51f7f..336083f 100644
--- a/src/tint/utils/text/symbol.cc
+++ b/src/tint/utils/text/symbol.cc
@@ -34,17 +34,17 @@
 Symbol& Symbol::operator=(Symbol&& o) = default;
 
 bool Symbol::operator==(const Symbol& other) const {
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Symbol, generation_id_, other.generation_id_);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(generation_id_, other.generation_id_);
     return val_ == other.val_;
 }
 
 bool Symbol::operator!=(const Symbol& other) const {
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Symbol, generation_id_, other.generation_id_);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(generation_id_, other.generation_id_);
     return val_ != other.val_;
 }
 
 bool Symbol::operator<(const Symbol& other) const {
-    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(Symbol, generation_id_, other.generation_id_);
+    TINT_ASSERT_GENERATION_IDS_EQUAL_IF_VALID(generation_id_, other.generation_id_);
     return val_ < other.val_;
 }
 
diff --git a/src/tint/utils/text/symbol_table.cc b/src/tint/utils/text/symbol_table.cc
index 5bfca8c0..9276232 100644
--- a/src/tint/utils/text/symbol_table.cc
+++ b/src/tint/utils/text/symbol_table.cc
@@ -14,7 +14,7 @@
 
 #include "src/tint/utils/text/symbol_table.h"
 
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 
 namespace tint {
 
@@ -27,7 +27,7 @@
 SymbolTable& SymbolTable::operator=(SymbolTable&&) = default;
 
 Symbol SymbolTable::Register(std::string_view name) {
-    TINT_ASSERT(Symbol, !name.empty());
+    TINT_ASSERT(!name.empty());
 
     auto it = name_to_symbol_.Find(name);
     if (it) {
diff --git a/src/tint/utils/text/text_generator.cc b/src/tint/utils/text/text_generator.cc
index dec64b0..e3d1a0a 100644
--- a/src/tint/utils/text/text_generator.cc
+++ b/src/tint/utils/text/text_generator.cc
@@ -18,7 +18,7 @@
 #include <limits>
 
 #include "src/tint/utils/containers/map.h"
-#include "src/tint/utils/debug/debug.h"
+#include "src/tint/utils/ice/ice.h"
 
 namespace tint {
 
@@ -27,7 +27,7 @@
 TextGenerator::~TextGenerator() = default;
 
 std::string TextGenerator::UniqueIdentifier(const std::string& /* = "" */) {
-    TINT_UNIMPLEMENTED(Utils, diagnostics_) << "UniqueIdentifier() not overridden";
+    TINT_UNIMPLEMENTED() << "UniqueIdentifier() not overridden";
     return "<error>";
 }
 
@@ -70,10 +70,9 @@
 
 void TextGenerator::TextBuffer::Insert(const std::string& line, size_t before, uint32_t indent) {
     if (TINT_UNLIKELY(before >= lines.size())) {
-        diag::List d;
-        TINT_ICE(Writer, d) << "TextBuffer::Insert() called with before >= lines.size()\n"
-                            << "  before:" << before << "\n"
-                            << "  lines.size(): " << lines.size();
+        TINT_ICE() << "TextBuffer::Insert() called with before >= lines.size()\n"
+                   << "  before:" << before << "\n"
+                   << "  lines.size(): " << lines.size();
         return;
     }
     using DT = decltype(lines)::difference_type;
@@ -89,10 +88,9 @@
 
 void TextGenerator::TextBuffer::Insert(const TextBuffer& tb, size_t before, uint32_t indent) {
     if (TINT_UNLIKELY(before >= lines.size())) {
-        diag::List d;
-        TINT_ICE(Writer, d) << "TextBuffer::Insert() called with before >= lines.size()\n"
-                            << "  before:" << before << "\n"
-                            << "  lines.size(): " << lines.size();
+        TINT_ICE() << "TextBuffer::Insert() called with before >= lines.size()\n"
+                   << "  before:" << before << "\n"
+                   << "  lines.size(): " << lines.size();
         return;
     }
     size_t idx = 0;