diff --git a/src/tint/fuzzers/BUILD.gn b/src/tint/fuzzers/BUILD.gn
index 25e475e..d0c72a7 100644
--- a/src/tint/fuzzers/BUILD.gn
+++ b/src/tint/fuzzers/BUILD.gn
@@ -33,8 +33,6 @@
       rebase_path(fuzzer_corpus_wgsl_dir, root_build_dir),
     ]
     outputs = [ fuzzer_corpus_wgsl_stamp ]
-
-    deps = [ "${dawn_root}/generator:remove_stale_autogen_files" ]
   }
 
   tint_fuzzer_common_libfuzzer_options = [
diff --git a/src/tint/fuzzers/tint_ast_fuzzer/BUILD.gn b/src/tint/fuzzers/tint_ast_fuzzer/BUILD.gn
index 58a36ea..416128c 100644
--- a/src/tint/fuzzers/tint_ast_fuzzer/BUILD.gn
+++ b/src/tint/fuzzers/tint_ast_fuzzer/BUILD.gn
@@ -23,7 +23,6 @@
     sources = [ "protobufs/tint_ast_fuzzer.proto" ]
     generate_python = false
     use_protobuf_full = true
-    deps = [ "${dawn_root}/generator:remove_stale_autogen_files" ]
   }
 
   source_set("tint_ast_fuzzer") {
diff --git a/src/tint/reader/spirv/function.cc b/src/tint/reader/spirv/function.cc
index 59a98e1..00b49d9 100644
--- a/src/tint/reader/spirv/function.cc
+++ b/src/tint/reader/spirv/function.cc
@@ -759,17 +759,22 @@
 
 BlockInfo::~BlockInfo() = default;
 
-DefInfo::DefInfo(const spvtools::opt::Instruction& def_inst,
-                 bool the_locally_defined,
-                 uint32_t the_block_pos,
-                 size_t the_index)
-    : inst(def_inst),
-      locally_defined(the_locally_defined),
-      block_pos(the_block_pos),
-      index(the_index) {}
+DefInfo::DefInfo(size_t the_index,
+                 const spvtools::opt::Instruction& def_inst,
+                 uint32_t the_block_pos)
+    : index(the_index), inst(def_inst), local(DefInfo::Local(the_block_pos)) {}
+
+DefInfo::DefInfo(size_t the_index, const spvtools::opt::Instruction& def_inst)
+    : index(the_index), inst(def_inst) {}
 
 DefInfo::~DefInfo() = default;
 
+DefInfo::Local::Local(uint32_t the_block_pos) : block_pos(the_block_pos) {}
+
+DefInfo::Local::Local(const Local& other) = default;
+
+DefInfo::Local::~Local() = default;
+
 ast::Node* StatementBuilder::Clone(CloneContext*) const {
     return nullptr;
 }
@@ -3380,7 +3385,7 @@
         utils::Vector<BlockInfo::PhiAssignment, 4> worklist;
         worklist.Reserve(block_info.phi_assignments.Length());
         for (const auto assignment : block_info.phi_assignments) {
-            if (GetDefInfo(assignment.phi_id)->num_uses > 0) {
+            if (GetDefInfo(assignment.phi_id)->local->num_uses > 0) {
                 worklist.Push(assignment);
             }
         }
@@ -3462,7 +3467,7 @@
                                         TypedExpression expr) {
     const auto result_id = inst.result_id();
     const auto* def_info = GetDefInfo(result_id);
-    if (def_info && def_info->requires_hoisted_def) {
+    if (def_info && def_info->requires_hoisted_var_def) {
         auto name = namer_.Name(result_id);
         // Emit an assignment of the expression to the hoisted variable.
         AddStatement(create<ast::AssignmentStatement>(
@@ -3512,8 +3517,11 @@
         }
 
         if (combinatorial_expr.expr != nullptr) {
-            if (def_info->requires_hoisted_def || def_info->requires_named_const_def ||
-                def_info->num_uses != 1) {
+            // If the expression is combinatorial, then it's not a direct access
+            // of a builtin variable.
+            TINT_ASSERT(Reader, 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
                 // now and later use the const or variable name at the uses of this
                 // value.
@@ -4739,7 +4747,7 @@
         const auto id = special_var.first;
         const auto builtin = special_var.second;
         const auto* var = def_use_mgr_->GetDef(id);
-        def_info_[id] = std::make_unique<DefInfo>(*var, false, 0, index);
+        def_info_[id] = std::make_unique<DefInfo>(index, *var);
         ++index;
         auto& def = def_info_[id];
         // Builtins are always defined outside the function.
@@ -4787,7 +4795,7 @@
             if ((result_id == 0) || inst.opcode() == SpvOpLabel) {
                 continue;
             }
-            def_info_[result_id] = std::make_unique<DefInfo>(inst, true, block_pos, index);
+            def_info_[result_id] = std::make_unique<DefInfo>(index, inst, block_pos);
             ++index;
             auto& info = def_info_[result_id];
 
@@ -4876,7 +4884,7 @@
         const auto id = inst.GetSingleWordInOperand(static_cast<uint32_t>(in_operand_index));
         auto* const operand_def = GetDefInfo(id);
         if (operand_def) {
-            operand_def->requires_named_const_def = true;
+            operand_def->requires_named_let_def = true;
         }
     };
     for (auto& id_def_info_pair : def_info_) {
@@ -4913,18 +4921,21 @@
     // Ignores values defined outside this function.
     auto record_value_use = [this](uint32_t id, const BlockInfo* block_info) {
         if (auto* def_info = GetDefInfo(id)) {
-            // Update usage count.
-            def_info->num_uses++;
-            // Update usage span.
-            def_info->first_use_pos = std::min(def_info->first_use_pos, block_info->pos);
-            def_info->last_use_pos = std::max(def_info->last_use_pos, block_info->pos);
+            if (def_info->local.has_value()) {
+                auto& local_def = def_info->local.value();
+                // Update usage count.
+                local_def.num_uses++;
+                // Update usage span.
+                local_def.first_use_pos = std::min(local_def.first_use_pos, block_info->pos);
+                local_def.last_use_pos = std::max(local_def.last_use_pos, block_info->pos);
 
-            // Determine whether this ID is defined in a different construct
-            // from this use.
-            const auto defining_block = block_order_[def_info->block_pos];
-            const auto* def_in_construct = GetBlockInfo(defining_block)->construct;
-            if (def_in_construct != block_info->construct) {
-                def_info->used_in_another_construct = true;
+                // Determine whether this ID is defined in a different construct
+                // from this use.
+                const auto defining_block = block_order_[local_def.block_pos];
+                const auto* def_in_construct = GetBlockInfo(defining_block)->construct;
+                if (def_in_construct != block_info->construct) {
+                    local_def.used_in_another_construct = true;
+                }
             }
         }
     };
@@ -4941,8 +4952,8 @@
                 // in the parent block B.
 
                 const auto phi_id = inst.result_id();
-                auto* phi_def_info = GetDefInfo(phi_id);
-                phi_def_info->is_phi = true;
+                auto& phi_local_def = GetDefInfo(phi_id)->local.value();
+                phi_local_def.is_phi = true;
 
                 // Track all the places where we need to mention the variable,
                 // so we can place its declaration.  First, record the location of
@@ -4962,9 +4973,9 @@
                         // Track where P needs to be in scope.  It's not an ordinary use, so don't
                         // count it as one.
                         const auto pred_pos = pred_block_info->pos;
-                        phi_def_info->first_use_pos =
-                            std::min(phi_def_info->first_use_pos, pred_pos);
-                        phi_def_info->last_use_pos = std::max(phi_def_info->last_use_pos, pred_pos);
+                        phi_local_def.first_use_pos =
+                            std::min(phi_local_def.first_use_pos, pred_pos);
+                        phi_local_def.last_use_pos = std::max(phi_local_def.last_use_pos, pred_pos);
 
                         // Record the assignment that needs to occur at the end
                         // of the predecessor block.
@@ -4974,7 +4985,7 @@
 
                 // Schedule the declaration of the state variable.
                 const auto* enclosing_construct =
-                    GetEnclosingScope(phi_def_info->first_use_pos, phi_def_info->last_use_pos);
+                    GetEnclosingScope(phi_local_def.first_use_pos, phi_local_def.last_use_pos);
                 GetBlockInfo(enclosing_construct->begin_id)->phis_needing_state_vars.Push(phi_id);
             } else {
                 inst.ForEachInId([block_info, &record_value_use](const uint32_t* id_ptr) {
@@ -4998,22 +5009,24 @@
     for (auto& id_def_info_pair : def_info_) {
         const auto def_id = id_def_info_pair.first;
         auto* def_info = id_def_info_pair.second.get();
-        if (def_info->num_uses == 0) {
-            // There is no need to adjust the location of the declaration.
-            continue;
-        }
-        if (!def_info->locally_defined) {
+        if (!def_info->local.has_value()) {
             // Never hoist a variable declared at module scope.
             // This occurs for builtin variables, which are mapped to module-scope
             // private variables.
             continue;
         }
+        auto& local_def = def_info->local.value();
 
-        const auto* def_in_construct = GetBlockInfo(block_order_[def_info->block_pos])->construct;
+        if (local_def.num_uses == 0) {
+            // There is no need to adjust the location of the declaration.
+            continue;
+        }
+
+        const auto* def_in_construct = GetBlockInfo(block_order_[local_def.block_pos])->construct;
         // A definition in the first block of an kIfSelection or kSwitchSelection
         // occurs before the branch, and so that definition should count as
         // having been defined at the scope of the parent construct.
-        if (def_info->block_pos == def_in_construct->begin_pos) {
+        if (local_def.block_pos == def_in_construct->begin_pos) {
             if ((def_in_construct->kind == Construct::kIfSelection) ||
                 (def_in_construct->kind == Construct::kSwitchSelection)) {
                 def_in_construct = def_in_construct->parent;
@@ -5022,12 +5035,12 @@
 
         // We care about the earliest between the place of definition, and the first
         // use of the value.
-        const auto first_pos = std::min(def_info->block_pos, def_info->first_use_pos);
-        const auto last_use_pos = def_info->last_use_pos;
+        const auto first_pos = std::min(local_def.block_pos, local_def.first_use_pos);
+        const auto last_use_pos = local_def.last_use_pos;
 
         bool should_hoist_to_let = false;
         bool should_hoist_to_var = false;
-        if (def_info->is_phi) {
+        if (local_def.is_phi) {
             // We need to generate a variable, and assignments to that variable in
             // all the phi parent blocks.
             should_hoist_to_var = true;
@@ -5041,7 +5054,7 @@
             // simple heuristic to avoid changing the cost of an operation
             // by moving it into or out of a loop, for example.
             if ((def_info->storage_class == ast::StorageClass::kInvalid) &&
-                def_info->used_in_another_construct) {
+                local_def.used_in_another_construct) {
                 should_hoist_to_let = true;
             }
         }
@@ -5050,11 +5063,11 @@
             const auto* enclosing_construct = GetEnclosingScope(first_pos, last_use_pos);
             if (should_hoist_to_let && (enclosing_construct == def_in_construct)) {
                 // We can use a plain 'let' declaration.
-                def_info->requires_named_const_def = true;
+                def_info->requires_named_let_def = true;
             } else {
                 // We need to make a hoisted variable definition.
                 // TODO(dneto): Handle non-storable types, particularly pointers.
-                def_info->requires_hoisted_def = true;
+                def_info->requires_hoisted_var_def = true;
                 auto* hoist_to_block = GetBlockInfo(enclosing_construct->begin_id);
                 hoist_to_block->hoisted_ids.Push(def_id);
             }
diff --git a/src/tint/reader/spirv/function.h b/src/tint/reader/spirv/function.h
index ff7336e..53c983c 100644
--- a/src/tint/reader/spirv/function.h
+++ b/src/tint/reader/spirv/function.h
@@ -159,7 +159,7 @@
 
     /// The result IDs that this block is responsible for declaring as a
     /// hoisted variable.
-    /// @see DefInfo#requires_hoisted_def
+    /// @see DefInfo#requires_hoisted_var_def
     utils::Vector<uint32_t, 4> hoisted_ids;
 
     /// A PhiAssignment represents the assignment of a value to the state
@@ -241,57 +241,74 @@
 ///    function.
 /// - certain module-scope builtin variables.
 struct DefInfo {
-    /// Constructor.
+    /// Constructor for a locally defined value.
+    /// @param index an ordering index for uniqueness.
     /// @param def_inst the SPIR-V instruction defining the ID
-    /// @param locally_defined true if the defining instruction is in the function
-    /// @param block_pos the position of the basic block where the ID is defined
-    /// @param index an ordering index for this local definition
-    DefInfo(const spvtools::opt::Instruction& def_inst,
-            bool locally_defined,
-            uint32_t block_pos,
-            size_t index);
+    /// @param block_pos the position of the first basic block dominated by the
+    ///   definition
+    DefInfo(size_t index, const spvtools::opt::Instruction& def_inst, uint32_t block_pos);
+    /// Constructor for a value defined at module scope.
+    /// @param index an ordering index for uniqueness.
+    /// @param def_inst the SPIR-V instruction defining the ID
+    DefInfo(size_t index, const spvtools::opt::Instruction& def_inst);
+
     /// Destructor.
     ~DefInfo();
 
-    /// The SPIR-V instruction that defines the ID.
-    const spvtools::opt::Instruction& inst;
-
-    /// True if the definition of this ID is inside the function.
-    const bool locally_defined = true;
-
-    /// For IDs defined in the function, this is the position of the block
-    /// containing the definition of the ID, in function block order.
-    /// For IDs defined outside of the function, it is 0.
-    /// See method `FunctionEmitter::ComputeBlockOrderAndPositions`
-    const uint32_t block_pos = 0;
-
     /// An index for uniquely and deterministically ordering all DefInfo records
     /// in a function.
     const size_t index = 0;
 
-    /// The number of uses of this ID.
-    uint32_t num_uses = 0;
+    /// The SPIR-V instruction that defines the ID.
+    const spvtools::opt::Instruction& inst;
 
-    /// The block position of the first use of this ID, or MAX_UINT if it is not
-    /// used at all.  The "first" ordering is determined by the function block
-    /// order.  The first use of an ID might be in an OpPhi that precedes the
-    /// definition of the ID.
-    /// The ID defined by an OpPhi is counted as being "used" in each of its
-    /// parent blocks.
-    uint32_t first_use_pos = std::numeric_limits<uint32_t>::max();
-    /// The block position of the last use of this ID, or 0 if it is not used
-    /// at all.  The "last" ordering is determined by the function block order.
-    /// The ID defined by an OpPhi is counted as being "used" in each of its
-    /// parent blocks.
-    uint32_t last_use_pos = 0;
+    /// Information about a definition created inside a function.
+    struct Local {
+        /// Constructor.
+        /// @param block_pos the position of the basic block defining the value.
+        explicit Local(uint32_t block_pos);
+        /// Copy constructor.
+        /// @param other the original object to copy from.
+        Local(const Local& other);
+        /// Destructor.
+        ~Local();
 
-    /// Is this value used in a construct other than the one in which it was
-    /// defined?
-    bool used_in_another_construct = false;
+        /// The position of the basic block defininig the value, in function
+        /// block order.
+        /// See method `FunctionEmitter::ComputeBlockOrderAndPositions` for block
+        /// ordering.
+        const uint32_t block_pos = 0;
 
-    /// True if this ID requires a WGSL 'const' definition, due to context. It
+        /// The number of uses of this ID.
+        uint32_t num_uses = 0;
+
+        /// The block position of the first use of this ID, or MAX_UINT if it is not
+        /// used at all.  The "first" ordering is determined by the function block
+        /// order.  The first use of an ID might be in an OpPhi that precedes the
+        /// definition of the ID.
+        /// The ID defined by an OpPhi is counted as being "used" in each of its
+        /// parent blocks.
+        uint32_t first_use_pos = std::numeric_limits<uint32_t>::max();
+        /// The block position of the last use of this ID, or 0 if it is not used
+        /// at all.  The "last" ordering is determined by the function block order.
+        /// The ID defined by an OpPhi is counted as being "used" in each of its
+        /// parent blocks.
+        uint32_t last_use_pos = 0;
+
+        /// Is this value used in a construct other than the one in which it was
+        /// defined?
+        bool used_in_another_construct = false;
+        /// Is this ID an OpPhi?
+        bool is_phi = false;
+    };
+
+    /// Information about a definition inside the function. Populated if and only
+    /// if the definition actually is inside the function.
+    std::optional<Local> local;
+
+    /// True if this ID requires a WGSL 'let' definition, due to context. It
     /// might get one anyway (so this is *not* an if-and-only-if condition).
-    bool requires_named_const_def = false;
+    bool requires_named_let_def = false;
 
     /// True if this ID must map to a WGSL variable declaration before the
     /// corresponding position of the ID definition in SPIR-V.  This compensates
@@ -306,10 +323,7 @@
     /// variable.
     /// TODO(dneto): This works for constants of storable type, but not, for
     /// example, pointers. crbug.com/tint/98
-    bool requires_hoisted_def = false;
-
-    /// Is this ID an OpPhi?
-    bool is_phi = false;
+    bool requires_hoisted_var_def = false;
 
     /// The storage class to use for this value, if it is of pointer type.
     /// This is required to carry a storage class override from a storage
@@ -336,14 +350,16 @@
 /// @returns the ostream so calls can be chained
 inline std::ostream& operator<<(std::ostream& o, const DefInfo& di) {
     o << "DefInfo{"
-      << " inst.result_id: " << di.inst.result_id()
-      << " locally_defined: " << (di.locally_defined ? "true" : "false")
-      << " block_pos: " << di.block_pos << " num_uses: " << di.num_uses
-      << " first_use_pos: " << di.first_use_pos << " last_use_pos: " << di.last_use_pos
-      << " used_in_another_construct: " << (di.used_in_another_construct ? "true" : "false")
-      << " requires_named_const_def: " << (di.requires_named_const_def ? "true" : "false")
-      << " requires_hoisted_def: " << (di.requires_hoisted_def ? "true" : "false")
-      << " is_phi: " << (di.is_phi ? "true" : "false") << "";
+      << " inst.result_id: " << di.inst.result_id();
+    if (di.local.has_value()) {
+        const auto& dil = di.local.value();
+        o << " block_pos: " << dil.block_pos << " num_uses: " << dil.num_uses
+          << " first_use_pos: " << dil.first_use_pos << " last_use_pos: " << dil.last_use_pos
+          << " used_in_another_construct: " << (dil.used_in_another_construct ? "true" : "false")
+          << " is_phi: " << (dil.is_phi ? "true" : "false") << "";
+    }
+    o << " requires_named_let_def: " << (di.requires_named_let_def ? "true" : "false")
+      << " requires_hoisted_var_def: " << (di.requires_hoisted_var_def ? "true" : "false");
     if (di.storage_class != ast::StorageClass::kNone) {
         o << " sc:" << int(di.storage_class);
     }
@@ -616,14 +632,14 @@
     ///  - When a SPIR-V instruction might use the dynamically computed value
     ///    only once, but the WGSL code might reference it multiple times.
     ///    For example, this occurs for the vector operands of OpVectorShuffle.
-    ///    In this case the definition's DefInfo#requires_named_const_def property
+    ///    In this case the definition's DefInfo#requires_named_let_def property
     ///    is set to true.
     ///  - When a definition and at least one of its uses are not in the
     ///    same structured construct.
-    ///    In this case the definition's DefInfo#requires_named_const_def property
+    ///    In this case the definition's DefInfo#requires_named_let_def property
     ///    is set to true.
     ///  - When a definition is in a construct that does not enclose all the
-    ///    uses.  In this case the definition's DefInfo#requires_hoisted_def
+    ///    uses.  In this case the definition's DefInfo#requires_hoisted_var_def
     ///    property is set to true.
     /// Updates the `def_info_` mapping.
     void FindValuesNeedingNamedOrHoistedDefinition();
diff --git a/src/tint/resolver/const_eval.cc b/src/tint/resolver/const_eval.cc
index 7e33244..8208236 100644
--- a/src/tint/resolver/const_eval.cc
+++ b/src/tint/resolver/const_eval.cc
@@ -182,24 +182,27 @@
     return ss.str();
 }
 
-/// Constant inherits from sem::Constant to add an private implementation method for conversion.
-struct Constant : public sem::Constant {
+/// ImplConstant inherits from sem::Constant to add an private implementation method for conversion.
+struct ImplConstant : public sem::Constant {
     /// Convert attempts to convert the constant value to the given type. On error, Convert()
     /// creates a new diagnostic message and returns a Failure.
-    virtual utils::Result<const Constant*> Convert(ProgramBuilder& builder,
-                                                   const sem::Type* target_ty,
-                                                   const Source& source) const = 0;
+    virtual utils::Result<const ImplConstant*> Convert(ProgramBuilder& builder,
+                                                       const sem::Type* target_ty,
+                                                       const Source& source) const = 0;
 };
 
+/// A result templated with a ImplConstant.
+using ImplResult = utils::Result<const ImplConstant*>;
+
 // Forward declaration
-const Constant* CreateComposite(ProgramBuilder& builder,
-                                const sem::Type* type,
-                                utils::VectorRef<const sem::Constant*> elements);
+const ImplConstant* CreateComposite(ProgramBuilder& builder,
+                                    const sem::Type* type,
+                                    utils::VectorRef<const sem::Constant*> elements);
 
 /// Element holds a single scalar or abstract-numeric value.
 /// Element implements the Constant interface.
 template <typename T>
-struct Element : Constant {
+struct Element : ImplConstant {
     static_assert(!std::is_same_v<UnwrapNumber<T>, T> || std::is_same_v<T, bool>,
                   "T must be a Number or bool");
 
@@ -219,16 +222,15 @@
     bool AllEqual() const override { return true; }
     size_t Hash() const override { return utils::Hash(type, ValueOf(value)); }
 
-    utils::Result<const Constant*> Convert(ProgramBuilder& builder,
-                                           const sem::Type* target_ty,
-                                           const Source& source) const override {
+    ImplResult Convert(ProgramBuilder& builder,
+                       const sem::Type* target_ty,
+                       const Source& source) const override {
         TINT_BEGIN_DISABLE_WARNING(UNREACHABLE_CODE);
         if (target_ty == type) {
             // If the types are identical, then no conversion is needed.
             return this;
         }
-        bool failed = false;
-        auto* res = ZeroTypeDispatch(target_ty, [&](auto zero_to) -> const Constant* {
+        return ZeroTypeDispatch(target_ty, [&](auto zero_to) -> ImplResult {
             // `T` is the source type, `value` is the source value.
             // `TO` is the target type.
             using TO = std::decay_t<decltype(zero_to)>;
@@ -248,7 +250,7 @@
                 ss << "value " << value << " cannot be represented as ";
                 ss << "'" << builder.FriendlyName(target_ty) << "'";
                 builder.Diagnostics().add_error(tint::diag::System::Resolver, ss.str(), source);
-                failed = true;
+                return utils::Failure;
             } else if constexpr (IsFloatingPoint<UnwrapNumber<TO>>) {
                 // [x -> floating-point] - number not exactly representable
                 // https://www.w3.org/TR/WGSL/#floating-point-conversion
@@ -270,11 +272,6 @@
             }
             return nullptr;  // Expression is not constant.
         });
-        if (failed) {
-            // A diagnostic error has been raised, and resolving should abort.
-            return utils::Failure;
-        }
-        return res;
         TINT_END_DISABLE_WARNING(UNREACHABLE_CODE);
     }
 
@@ -286,7 +283,7 @@
 /// Splat is used for zero-initializers, 'splat' constructors, or constructors where each element is
 /// identical. Splat may be of a vector, matrix or array type.
 /// Splat implements the Constant interface.
-struct Splat : Constant {
+struct Splat : ImplConstant {
     Splat(const sem::Type* t, const sem::Constant* e, size_t n) : type(t), el(e), count(n) {}
     ~Splat() override = default;
     const sem::Type* Type() const override { return type; }
@@ -297,13 +294,13 @@
     bool AllEqual() const override { return true; }
     size_t Hash() const override { return utils::Hash(type, el->Hash(), count); }
 
-    utils::Result<const Constant*> Convert(ProgramBuilder& builder,
-                                           const sem::Type* target_ty,
-                                           const Source& source) const override {
+    ImplResult Convert(ProgramBuilder& builder,
+                       const sem::Type* target_ty,
+                       const Source& source) const override {
         // Convert the single splatted element type.
         // Note: This file is the only place where `sem::Constant`s are created, so this static_cast
         // is safe.
-        auto conv_el = static_cast<const Constant*>(el)->Convert(
+        auto conv_el = static_cast<const ImplConstant*>(el)->Convert(
             builder, sem::Type::ElementOf(target_ty), source);
         if (!conv_el) {
             return utils::Failure;
@@ -324,7 +321,7 @@
 /// If each element is the same type and value, then a Splat would be a more efficient constant
 /// implementation. Use CreateComposite() to create the appropriate Constant type.
 /// Composite implements the Constant interface.
-struct Composite : Constant {
+struct Composite : ImplConstant {
     Composite(const sem::Type* t,
               utils::VectorRef<const sem::Constant*> els,
               bool all_0,
@@ -341,9 +338,9 @@
     bool AllEqual() const override { return false; /* otherwise this should be a Splat */ }
     size_t Hash() const override { return hash; }
 
-    utils::Result<const Constant*> Convert(ProgramBuilder& builder,
-                                           const sem::Type* target_ty,
-                                           const Source& source) const override {
+    ImplResult Convert(ProgramBuilder& builder,
+                       const sem::Type* target_ty,
+                       const Source& source) const override {
         // Convert each of the composite element types.
         auto* el_ty = sem::Type::ElementOf(target_ty);
         utils::Vector<const sem::Constant*, 4> conv_els;
@@ -351,7 +348,7 @@
         for (auto* el : elements) {
             // Note: This file is the only place where `sem::Constant`s are created, so this
             // static_cast is safe.
-            auto conv_el = static_cast<const Constant*>(el)->Convert(builder, el_ty, source);
+            auto conv_el = static_cast<const ImplConstant*>(el)->Convert(builder, el_ty, source);
             if (!conv_el) {
                 return utils::Failure;
             }
@@ -380,30 +377,30 @@
 
 /// CreateElement constructs and returns an Element<T>.
 template <typename T>
-const Constant* CreateElement(ProgramBuilder& builder, const sem::Type* t, T v) {
+const ImplConstant* CreateElement(ProgramBuilder& builder, const sem::Type* t, T v) {
     return builder.create<Element<T>>(t, v);
 }
 
 /// ZeroValue returns a Constant for the zero-value of the type `type`.
-const Constant* ZeroValue(ProgramBuilder& builder, const sem::Type* type) {
+const ImplConstant* ZeroValue(ProgramBuilder& builder, const sem::Type* type) {
     return Switch(
         type,  //
-        [&](const sem::Vector* v) -> const Constant* {
+        [&](const sem::Vector* v) -> const ImplConstant* {
             auto* zero_el = ZeroValue(builder, v->type());
             return builder.create<Splat>(type, zero_el, v->Width());
         },
-        [&](const sem::Matrix* m) -> const Constant* {
+        [&](const sem::Matrix* m) -> const ImplConstant* {
             auto* zero_el = ZeroValue(builder, m->ColumnType());
             return builder.create<Splat>(type, zero_el, m->columns());
         },
-        [&](const sem::Array* a) -> const Constant* {
+        [&](const sem::Array* a) -> const ImplConstant* {
             if (auto* zero_el = ZeroValue(builder, a->ElemType())) {
                 return builder.create<Splat>(type, zero_el, a->Count());
             }
             return nullptr;
         },
-        [&](const sem::Struct* s) -> const Constant* {
-            std::unordered_map<const sem::Type*, const Constant*> zero_by_type;
+        [&](const sem::Struct* s) -> const ImplConstant* {
+            std::unordered_map<const sem::Type*, const ImplConstant*> zero_by_type;
             utils::Vector<const sem::Constant*, 4> zeros;
             zeros.Reserve(s->Members().size());
             for (auto* member : s->Members()) {
@@ -420,8 +417,8 @@
             }
             return CreateComposite(builder, s, std::move(zeros));
         },
-        [&](Default) -> const Constant* {
-            return ZeroTypeDispatch(type, [&](auto zero) -> const Constant* {
+        [&](Default) -> const ImplConstant* {
+            return ZeroTypeDispatch(type, [&](auto zero) -> const ImplConstant* {
                 return CreateElement(builder, type, zero);
             });
         });
@@ -467,9 +464,9 @@
 /// CreateComposite is used to construct a constant of a vector, matrix or array type.
 /// CreateComposite examines the element values and will return either a Composite or a Splat,
 /// depending on the element types and values.
-const Constant* CreateComposite(ProgramBuilder& builder,
-                                const sem::Type* type,
-                                utils::VectorRef<const sem::Constant*> elements) {
+const ImplConstant* CreateComposite(ProgramBuilder& builder,
+                                    const sem::Type* type,
+                                    utils::VectorRef<const sem::Constant*> elements) {
     if (elements.IsEmpty()) {
         return nullptr;
     }
@@ -504,10 +501,10 @@
 /// transformation function 'f' on each of the most deeply nested elements of 'cs'. Assumes that all
 /// input constants `cs` are of the same type.
 template <typename F, typename... CONSTANTS>
-const Constant* TransformElements(ProgramBuilder& builder,
-                                  const sem::Type* composite_ty,
-                                  F&& f,
-                                  CONSTANTS&&... cs) {
+ImplResult TransformElements(ProgramBuilder& builder,
+                             const sem::Type* composite_ty,
+                             F&& f,
+                             CONSTANTS&&... cs) {
     uint32_t n = 0;
     auto* ty = First(cs...)->Type();
     auto* el_ty = sem::Type::ElementOf(ty, &n);
@@ -517,8 +514,13 @@
     utils::Vector<const sem::Constant*, 8> els;
     els.Reserve(n);
     for (uint32_t i = 0; i < n; i++) {
-        els.Push(TransformElements(builder, sem::Type::ElementOf(composite_ty), std::forward<F>(f),
-                                   cs->Index(i)...));
+        if (auto el = TransformElements(builder, sem::Type::ElementOf(composite_ty),
+                                        std::forward<F>(f), cs->Index(i)...)) {
+            els.Push(el.Get());
+
+        } else {
+            return el.Failure();
+        }
     }
     return CreateComposite(builder, composite_ty, std::move(els));
 }
@@ -528,11 +530,11 @@
 /// Unlike TransformElements, this function handles the constants being of different types, e.g.
 /// vector-scalar, scalar-vector.
 template <typename F>
-const Constant* TransformBinaryElements(ProgramBuilder& builder,
-                                        const sem::Type* composite_ty,
-                                        F&& f,
-                                        const sem::Constant* c0,
-                                        const sem::Constant* c1) {
+ImplResult TransformBinaryElements(ProgramBuilder& builder,
+                                   const sem::Type* composite_ty,
+                                   F&& f,
+                                   const sem::Constant* c0,
+                                   const sem::Constant* c1) {
     uint32_t n0 = 0, n1 = 0;
     sem::Type::ElementOf(c0->Type(), &n0);
     sem::Type::ElementOf(c1->Type(), &n1);
@@ -551,9 +553,13 @@
             }
             return c->Index(i);
         };
-        els.Push(TransformBinaryElements(builder, sem::Type::ElementOf(composite_ty),
-                                         std::forward<F>(f), nested_or_self(c0, n0),
-                                         nested_or_self(c1, n1)));
+        if (auto el = TransformBinaryElements(builder, sem::Type::ElementOf(composite_ty),
+                                              std::forward<F>(f), nested_or_self(c0, n0),
+                                              nested_or_self(c1, n1))) {
+            els.Push(el.Get());
+        } else {
+            return el.Failure();
+        }
     }
     return CreateComposite(builder, composite_ty, std::move(els));
 }
@@ -703,7 +709,7 @@
 }
 
 auto ConstEval::AddFunc(const sem::Type* elem_ty) {
-    return [=](auto a1, auto a2) -> utils::Result<const Constant*> {
+    return [=](auto a1, auto a2) -> ImplResult {
         if (auto r = Add(a1, a2)) {
             return CreateElement(builder, elem_ty, r.Get());
         }
@@ -712,7 +718,7 @@
 }
 
 auto ConstEval::MulFunc(const sem::Type* elem_ty) {
-    return [=](auto a1, auto a2) -> utils::Result<const Constant*> {
+    return [=](auto a1, auto a2) -> ImplResult {
         if (auto r = Mul(a1, a2)) {
             return CreateElement(builder, elem_ty, r.Get());
         }
@@ -721,7 +727,7 @@
 }
 
 auto ConstEval::Dot2Func(const sem::Type* elem_ty) {
-    return [=](auto a1, auto a2, auto b1, auto b2) -> utils::Result<const Constant*> {
+    return [=](auto a1, auto a2, auto b1, auto b2) -> ImplResult {
         if (auto r = Dot2(a1, a2, b1, b2)) {
             return CreateElement(builder, elem_ty, r.Get());
         }
@@ -730,8 +736,7 @@
 }
 
 auto ConstEval::Dot3Func(const sem::Type* elem_ty) {
-    return [=](auto a1, auto a2, auto a3, auto b1, auto b2,
-               auto b3) -> utils::Result<const Constant*> {
+    return [=](auto a1, auto a2, auto a3, auto b1, auto b2, auto b3) -> ImplResult {
         if (auto r = Dot3(a1, a2, a3, b1, b2, b3)) {
             return CreateElement(builder, elem_ty, r.Get());
         }
@@ -740,23 +745,22 @@
 }
 
 auto ConstEval::Dot4Func(const sem::Type* elem_ty) {
-    return [=](auto a1, auto a2, auto a3, auto a4, auto b1, auto b2, auto b3,
-               auto b4) -> utils::Result<const Constant*> {
-        if (auto r = Dot4(a1, a2, a3, a4, b1, b2, b3, b4)) {
-            return CreateElement(builder, elem_ty, r.Get());
-        }
-        return utils::Failure;
-    };
+    return
+        [=](auto a1, auto a2, auto a3, auto a4, auto b1, auto b2, auto b3, auto b4) -> ImplResult {
+            if (auto r = Dot4(a1, a2, a3, a4, b1, b2, b3, b4)) {
+                return CreateElement(builder, elem_ty, r.Get());
+            }
+            return utils::Failure;
+        };
 }
 
-ConstEval::ConstantResult ConstEval::Literal(const sem::Type* ty,
-                                             const ast::LiteralExpression* literal) {
+ConstEval::Result ConstEval::Literal(const sem::Type* ty, const ast::LiteralExpression* literal) {
     return Switch(
         literal,
         [&](const ast::BoolLiteralExpression* lit) {
             return CreateElement(builder, ty, lit->value);
         },
-        [&](const ast::IntLiteralExpression* lit) -> const Constant* {
+        [&](const ast::IntLiteralExpression* lit) -> ImplResult {
             switch (lit->suffix) {
                 case ast::IntLiteralExpression::Suffix::kNone:
                     return CreateElement(builder, ty, AInt(lit->value));
@@ -767,7 +771,7 @@
             }
             return nullptr;
         },
-        [&](const ast::FloatLiteralExpression* lit) -> const Constant* {
+        [&](const ast::FloatLiteralExpression* lit) -> ImplResult {
             switch (lit->suffix) {
                 case ast::FloatLiteralExpression::Suffix::kNone:
                     return CreateElement(builder, ty, AFloat(lit->value));
@@ -780,9 +784,8 @@
         });
 }
 
-ConstEval::ConstantResult ConstEval::ArrayOrStructCtor(
-    const sem::Type* ty,
-    utils::VectorRef<const sem::Expression*> args) {
+ConstEval::Result ConstEval::ArrayOrStructCtor(const sem::Type* ty,
+                                               utils::VectorRef<const sem::Expression*> args) {
     if (args.IsEmpty()) {
         return ZeroValue(builder, ty);
     }
@@ -801,9 +804,9 @@
     return CreateComposite(builder, ty, std::move(els));
 }
 
-ConstEval::ConstantResult ConstEval::Conv(const sem::Type* ty,
-                                          utils::VectorRef<const sem::Constant*> args,
-                                          const Source& source) {
+ConstEval::Result ConstEval::Conv(const sem::Type* ty,
+                                  utils::VectorRef<const sem::Constant*> args,
+                                  const Source& source) {
     uint32_t el_count = 0;
     auto* el_ty = sem::Type::ElementOf(ty, &el_count);
     if (!el_ty) {
@@ -821,36 +824,36 @@
     return nullptr;
 }
 
-ConstEval::ConstantResult ConstEval::Zero(const sem::Type* ty,
-                                          utils::VectorRef<const sem::Constant*>,
-                                          const Source&) {
+ConstEval::Result ConstEval::Zero(const sem::Type* ty,
+                                  utils::VectorRef<const sem::Constant*>,
+                                  const Source&) {
     return ZeroValue(builder, ty);
 }
 
-ConstEval::ConstantResult ConstEval::Identity(const sem::Type*,
-                                              utils::VectorRef<const sem::Constant*> args,
-                                              const Source&) {
+ConstEval::Result ConstEval::Identity(const sem::Type*,
+                                      utils::VectorRef<const sem::Constant*> args,
+                                      const Source&) {
     return args[0];
 }
 
-ConstEval::ConstantResult ConstEval::VecSplat(const sem::Type* ty,
-                                              utils::VectorRef<const sem::Constant*> args,
-                                              const Source&) {
+ConstEval::Result ConstEval::VecSplat(const sem::Type* ty,
+                                      utils::VectorRef<const sem::Constant*> args,
+                                      const Source&) {
     if (auto* arg = args[0]) {
         return builder.create<Splat>(ty, arg, static_cast<const sem::Vector*>(ty)->Width());
     }
     return nullptr;
 }
 
-ConstEval::ConstantResult ConstEval::VecCtorS(const sem::Type* ty,
-                                              utils::VectorRef<const sem::Constant*> args,
-                                              const Source&) {
+ConstEval::Result ConstEval::VecCtorS(const sem::Type* ty,
+                                      utils::VectorRef<const sem::Constant*> args,
+                                      const Source&) {
     return CreateComposite(builder, ty, args);
 }
 
-ConstEval::ConstantResult ConstEval::VecCtorM(const sem::Type* ty,
-                                              utils::VectorRef<const sem::Constant*> args,
-                                              const Source&) {
+ConstEval::Result ConstEval::VecCtorM(const sem::Type* ty,
+                                      utils::VectorRef<const sem::Constant*> args,
+                                      const Source&) {
     utils::Vector<const sem::Constant*, 4> els;
     for (auto* arg : args) {
         auto* val = arg;
@@ -874,9 +877,9 @@
     return CreateComposite(builder, ty, std::move(els));
 }
 
-ConstEval::ConstantResult ConstEval::MatCtorS(const sem::Type* ty,
-                                              utils::VectorRef<const sem::Constant*> args,
-                                              const Source&) {
+ConstEval::Result ConstEval::MatCtorS(const sem::Type* ty,
+                                      utils::VectorRef<const sem::Constant*> args,
+                                      const Source&) {
     auto* m = static_cast<const sem::Matrix*>(ty);
 
     utils::Vector<const sem::Constant*, 4> els;
@@ -891,14 +894,14 @@
     return CreateComposite(builder, ty, std::move(els));
 }
 
-ConstEval::ConstantResult ConstEval::MatCtorV(const sem::Type* ty,
-                                              utils::VectorRef<const sem::Constant*> args,
-                                              const Source&) {
+ConstEval::Result ConstEval::MatCtorV(const sem::Type* ty,
+                                      utils::VectorRef<const sem::Constant*> args,
+                                      const Source&) {
     return CreateComposite(builder, ty, args);
 }
 
-ConstEval::ConstantResult ConstEval::Index(const sem::Expression* obj_expr,
-                                           const sem::Expression* idx_expr) {
+ConstEval::Result ConstEval::Index(const sem::Expression* obj_expr,
+                                   const sem::Expression* idx_expr) {
     auto idx_val = idx_expr->ConstantValue();
     if (!idx_val) {
         return nullptr;
@@ -926,8 +929,8 @@
     return obj_val->Index(static_cast<size_t>(idx));
 }
 
-ConstEval::ConstantResult ConstEval::MemberAccess(const sem::Expression* obj_expr,
-                                                  const sem::StructMember* member) {
+ConstEval::Result ConstEval::MemberAccess(const sem::Expression* obj_expr,
+                                          const sem::StructMember* member) {
     auto obj_val = obj_expr->ConstantValue();
     if (!obj_val) {
         return nullptr;
@@ -935,30 +938,29 @@
     return obj_val->Index(static_cast<size_t>(member->Index()));
 }
 
-ConstEval::ConstantResult ConstEval::Swizzle(const sem::Type* ty,
-                                             const sem::Expression* vec_expr,
-                                             utils::VectorRef<uint32_t> indices) {
+ConstEval::Result ConstEval::Swizzle(const sem::Type* ty,
+                                     const sem::Expression* vec_expr,
+                                     utils::VectorRef<uint32_t> indices) {
     auto* vec_val = vec_expr->ConstantValue();
     if (!vec_val) {
         return nullptr;
     }
     if (indices.Length() == 1) {
         return vec_val->Index(static_cast<size_t>(indices[0]));
-    } else {
-        auto values = utils::Transform<4>(
-            indices, [&](uint32_t i) { return vec_val->Index(static_cast<size_t>(i)); });
-        return CreateComposite(builder, ty, std::move(values));
     }
+    auto values = utils::Transform<4>(
+        indices, [&](uint32_t i) { return vec_val->Index(static_cast<size_t>(i)); });
+    return CreateComposite(builder, ty, std::move(values));
 }
 
-ConstEval::ConstantResult ConstEval::Bitcast(const sem::Type*, const sem::Expression*) {
+ConstEval::Result ConstEval::Bitcast(const sem::Type*, const sem::Expression*) {
     // TODO(crbug.com/tint/1581): Implement @const intrinsics
     return nullptr;
 }
 
-ConstEval::ConstantResult ConstEval::OpComplement(const sem::Type* ty,
-                                                  utils::VectorRef<const sem::Constant*> args,
-                                                  const Source&) {
+ConstEval::Result ConstEval::OpComplement(const sem::Type* ty,
+                                          utils::VectorRef<const sem::Constant*> args,
+                                          const Source&) {
     auto transform = [&](const sem::Constant* c) {
         auto create = [&](auto i) {
             return CreateElement(builder, c->Type(), decltype(i)(~i.value));
@@ -968,9 +970,9 @@
     return TransformElements(builder, ty, transform, args[0]);
 }
 
-ConstEval::ConstantResult ConstEval::OpUnaryMinus(const sem::Type* ty,
-                                                  utils::VectorRef<const sem::Constant*> args,
-                                                  const Source&) {
+ConstEval::Result ConstEval::OpUnaryMinus(const sem::Type* ty,
+                                          utils::VectorRef<const sem::Constant*> args,
+                                          const Source&) {
     auto transform = [&](const sem::Constant* c) {
         auto create = [&](auto i) {
             // For signed integrals, avoid C++ UB by not negating the
@@ -993,9 +995,9 @@
     return TransformElements(builder, ty, transform, args[0]);
 }
 
-ConstEval::ConstantResult ConstEval::OpNot(const sem::Type* ty,
-                                           utils::VectorRef<const sem::Constant*> args,
-                                           const Source&) {
+ConstEval::Result ConstEval::OpNot(const sem::Type* ty,
+                                   utils::VectorRef<const sem::Constant*> args,
+                                   const Source&) {
     auto transform = [&](const sem::Constant* c) {
         auto create = [&](auto i) { return CreateElement(builder, c->Type(), decltype(i)(!i)); };
         return Dispatch_bool(create, c);
@@ -1003,29 +1005,22 @@
     return TransformElements(builder, ty, transform, args[0]);
 }
 
-ConstEval::ConstantResult ConstEval::OpPlus(const sem::Type* ty,
-                                            utils::VectorRef<const sem::Constant*> args,
-                                            const Source& source) {
+ConstEval::Result ConstEval::OpPlus(const sem::Type* ty,
+                                    utils::VectorRef<const sem::Constant*> args,
+                                    const Source& source) {
     TINT_SCOPED_ASSIGNMENT(current_source, &source);
-    auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) -> const Constant* {
-        if (auto r = Dispatch_fia_fiu32_f16(AddFunc(c0->Type()), c0, c1)) {
-            return r.Get();
-        }
-        return nullptr;
+    auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
+        return Dispatch_fia_fiu32_f16(AddFunc(c0->Type()), c0, c1);
     };
 
-    auto r = TransformBinaryElements(builder, ty, transform, args[0], args[1]);
-    if (builder.Diagnostics().contains_errors()) {
-        return utils::Failure;
-    }
-    return r;
+    return TransformBinaryElements(builder, ty, transform, args[0], args[1]);
 }
 
-ConstEval::ConstantResult ConstEval::OpMinus(const sem::Type* ty,
-                                             utils::VectorRef<const sem::Constant*> args,
-                                             const Source& source) {
+ConstEval::Result ConstEval::OpMinus(const sem::Type* ty,
+                                     utils::VectorRef<const sem::Constant*> args,
+                                     const Source& source) {
     auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
-        auto create = [&](auto i, auto j) -> const Constant* {
+        auto create = [&](auto i, auto j) -> ImplResult {
             using NumberT = decltype(i);
             NumberT result;
             if constexpr (std::is_same_v<NumberT, AInt> || std::is_same_v<NumberT, AFloat>) {
@@ -1034,7 +1029,7 @@
                     result = r->value;
                 } else {
                     AddError(OverflowErrorMessage(i, "-", j), source);
-                    return nullptr;
+                    return utils::Failure;
                 }
             } else {
                 using T = UnwrapNumber<NumberT>;
@@ -1054,41 +1049,30 @@
         return Dispatch_fia_fiu32_f16(create, c0, c1);
     };
 
-    auto r = TransformBinaryElements(builder, ty, transform, args[0], args[1]);
-    if (builder.Diagnostics().contains_errors()) {
-        return utils::Failure;
-    }
-    return r;
+    return TransformBinaryElements(builder, ty, transform, args[0], args[1]);
 }
 
-ConstEval::ConstantResult ConstEval::OpMultiply(const sem::Type* ty,
-                                                utils::VectorRef<const sem::Constant*> args,
-                                                const Source& source) {
+ConstEval::Result ConstEval::OpMultiply(const sem::Type* ty,
+                                        utils::VectorRef<const sem::Constant*> args,
+                                        const Source& source) {
     TINT_SCOPED_ASSIGNMENT(current_source, &source);
-    auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) -> const Constant* {
-        if (auto r = Dispatch_fia_fiu32_f16(MulFunc(c0->Type()), c0, c1)) {
-            return r.Get();
-        }
-        return nullptr;
+    auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
+        return Dispatch_fia_fiu32_f16(MulFunc(c0->Type()), c0, c1);
     };
 
-    auto r = TransformBinaryElements(builder, ty, transform, args[0], args[1]);
-    if (builder.Diagnostics().contains_errors()) {
-        return utils::Failure;
-    }
-    return r;
+    return TransformBinaryElements(builder, ty, transform, args[0], args[1]);
 }
 
-ConstEval::ConstantResult ConstEval::OpMultiplyMatVec(const sem::Type* ty,
-                                                      utils::VectorRef<const sem::Constant*> args,
-                                                      const Source& source) {
+ConstEval::Result ConstEval::OpMultiplyMatVec(const sem::Type* ty,
+                                              utils::VectorRef<const sem::Constant*> args,
+                                              const Source& source) {
     TINT_SCOPED_ASSIGNMENT(current_source, &source);
     auto* mat_ty = args[0]->Type()->As<sem::Matrix>();
     auto* vec_ty = args[1]->Type()->As<sem::Vector>();
     auto* elem_ty = vec_ty->type();
 
     auto dot = [&](const sem::Constant* m, size_t row, const sem::Constant* v) {
-        utils::Result<const Constant*> result;
+        ImplResult result;
         switch (mat_ty->columns()) {
             case 2:
                 result = Dispatch_fa_f32_f16(Dot2Func(elem_ty),        //
@@ -1130,16 +1114,16 @@
     }
     return CreateComposite(builder, ty, result);
 }
-ConstEval::ConstantResult ConstEval::OpMultiplyVecMat(const sem::Type* ty,
-                                                      utils::VectorRef<const sem::Constant*> args,
-                                                      const Source& source) {
+ConstEval::Result ConstEval::OpMultiplyVecMat(const sem::Type* ty,
+                                              utils::VectorRef<const sem::Constant*> args,
+                                              const Source& source) {
     TINT_SCOPED_ASSIGNMENT(current_source, &source);
     auto* vec_ty = args[0]->Type()->As<sem::Vector>();
     auto* mat_ty = args[1]->Type()->As<sem::Matrix>();
     auto* elem_ty = vec_ty->type();
 
     auto dot = [&](const sem::Constant* v, const sem::Constant* m, size_t col) {
-        utils::Result<const Constant*> result;
+        ImplResult result;
         switch (mat_ty->rows()) {
             case 2:
                 result = Dispatch_fa_f32_f16(Dot2Func(elem_ty),        //
@@ -1182,9 +1166,9 @@
     return CreateComposite(builder, ty, result);
 }
 
-ConstEval::ConstantResult ConstEval::OpMultiplyMatMat(const sem::Type* ty,
-                                                      utils::VectorRef<const sem::Constant*> args,
-                                                      const Source& source) {
+ConstEval::Result ConstEval::OpMultiplyMatMat(const sem::Type* ty,
+                                              utils::VectorRef<const sem::Constant*> args,
+                                              const Source& source) {
     TINT_SCOPED_ASSIGNMENT(current_source, &source);
     auto* mat1 = args[0];
     auto* mat2 = args[1];
@@ -1196,7 +1180,7 @@
         auto m1e = [&](size_t r, size_t c) { return m1->Index(c)->Index(r); };
         auto m2e = [&](size_t r, size_t c) { return m2->Index(c)->Index(r); };
 
-        utils::Result<const Constant*> result;
+        ImplResult result;
         switch (mat1_ty->columns()) {
             case 2:
                 result = Dispatch_fa_f32_f16(Dot2Func(elem_ty),  //
@@ -1247,11 +1231,11 @@
     return CreateComposite(builder, ty, result_mat);
 }
 
-ConstEval::ConstantResult ConstEval::OpDivide(const sem::Type* ty,
-                                              utils::VectorRef<const sem::Constant*> args,
-                                              const Source& source) {
+ConstEval::Result ConstEval::OpDivide(const sem::Type* ty,
+                                      utils::VectorRef<const sem::Constant*> args,
+                                      const Source& source) {
     auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
-        auto create = [&](auto i, auto j) -> const Constant* {
+        auto create = [&](auto i, auto j) -> ImplResult {
             using NumberT = decltype(i);
             NumberT result;
             if constexpr (std::is_same_v<NumberT, AInt> || std::is_same_v<NumberT, AFloat>) {
@@ -1260,7 +1244,7 @@
                     result = r->value;
                 } else {
                     AddError(OverflowErrorMessage(i, "/", j), source);
-                    return nullptr;
+                    return utils::Failure;
                 }
             } else {
                 using T = UnwrapNumber<NumberT>;
@@ -1288,120 +1272,92 @@
         return Dispatch_fia_fiu32_f16(create, c0, c1);
     };
 
-    auto r = TransformBinaryElements(builder, ty, transform, args[0], args[1]);
-    if (builder.Diagnostics().contains_errors()) {
-        return utils::Failure;
-    }
-    return r;
+    return TransformBinaryElements(builder, ty, transform, args[0], args[1]);
 }
 
-ConstEval::ConstantResult ConstEval::OpEqual(const sem::Type* ty,
-                                             utils::VectorRef<const sem::Constant*> args,
-                                             const Source&) {
+ConstEval::Result ConstEval::OpEqual(const sem::Type* ty,
+                                     utils::VectorRef<const sem::Constant*> args,
+                                     const Source&) {
     auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
-        auto create = [&](auto i, auto j) -> const Constant* {
+        auto create = [&](auto i, auto j) -> ImplResult {
             return CreateElement(builder, sem::Type::DeepestElementOf(ty), i == j);
         };
         return Dispatch_fia_fiu32_f16_bool(create, c0, c1);
     };
 
-    auto r = TransformElements(builder, ty, transform, args[0], args[1]);
-    if (builder.Diagnostics().contains_errors()) {
-        return utils::Failure;
-    }
-    return r;
+    return TransformElements(builder, ty, transform, args[0], args[1]);
 }
 
-ConstEval::ConstantResult ConstEval::OpNotEqual(const sem::Type* ty,
-                                                utils::VectorRef<const sem::Constant*> args,
-                                                const Source&) {
+ConstEval::Result ConstEval::OpNotEqual(const sem::Type* ty,
+                                        utils::VectorRef<const sem::Constant*> args,
+                                        const Source&) {
     auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
-        auto create = [&](auto i, auto j) -> const Constant* {
+        auto create = [&](auto i, auto j) -> ImplResult {
             return CreateElement(builder, sem::Type::DeepestElementOf(ty), i != j);
         };
         return Dispatch_fia_fiu32_f16_bool(create, c0, c1);
     };
 
-    auto r = TransformElements(builder, ty, transform, args[0], args[1]);
-    if (builder.Diagnostics().contains_errors()) {
-        return utils::Failure;
-    }
-    return r;
+    return TransformElements(builder, ty, transform, args[0], args[1]);
 }
 
-ConstEval::ConstantResult ConstEval::OpLessThan(const sem::Type* ty,
-                                                utils::VectorRef<const sem::Constant*> args,
-                                                const Source&) {
+ConstEval::Result ConstEval::OpLessThan(const sem::Type* ty,
+                                        utils::VectorRef<const sem::Constant*> args,
+                                        const Source&) {
     auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
-        auto create = [&](auto i, auto j) -> const Constant* {
+        auto create = [&](auto i, auto j) -> ImplResult {
             return CreateElement(builder, sem::Type::DeepestElementOf(ty), i < j);
         };
         return Dispatch_fia_fiu32_f16(create, c0, c1);
     };
 
-    auto r = TransformElements(builder, ty, transform, args[0], args[1]);
-    if (builder.Diagnostics().contains_errors()) {
-        return utils::Failure;
-    }
-    return r;
+    return TransformElements(builder, ty, transform, args[0], args[1]);
 }
 
-ConstEval::ConstantResult ConstEval::OpGreaterThan(const sem::Type* ty,
-                                                   utils::VectorRef<const sem::Constant*> args,
-                                                   const Source&) {
+ConstEval::Result ConstEval::OpGreaterThan(const sem::Type* ty,
+                                           utils::VectorRef<const sem::Constant*> args,
+                                           const Source&) {
     auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
-        auto create = [&](auto i, auto j) -> const Constant* {
+        auto create = [&](auto i, auto j) -> ImplResult {
             return CreateElement(builder, sem::Type::DeepestElementOf(ty), i > j);
         };
         return Dispatch_fia_fiu32_f16(create, c0, c1);
     };
 
-    auto r = TransformElements(builder, ty, transform, args[0], args[1]);
-    if (builder.Diagnostics().contains_errors()) {
-        return utils::Failure;
-    }
-    return r;
+    return TransformElements(builder, ty, transform, args[0], args[1]);
 }
 
-ConstEval::ConstantResult ConstEval::OpLessThanEqual(const sem::Type* ty,
-                                                     utils::VectorRef<const sem::Constant*> args,
-                                                     const Source&) {
+ConstEval::Result ConstEval::OpLessThanEqual(const sem::Type* ty,
+                                             utils::VectorRef<const sem::Constant*> args,
+                                             const Source&) {
     auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
-        auto create = [&](auto i, auto j) -> const Constant* {
+        auto create = [&](auto i, auto j) -> ImplResult {
             return CreateElement(builder, sem::Type::DeepestElementOf(ty), i <= j);
         };
         return Dispatch_fia_fiu32_f16(create, c0, c1);
     };
 
-    auto r = TransformElements(builder, ty, transform, args[0], args[1]);
-    if (builder.Diagnostics().contains_errors()) {
-        return utils::Failure;
-    }
-    return r;
+    return TransformElements(builder, ty, transform, args[0], args[1]);
 }
 
-ConstEval::ConstantResult ConstEval::OpGreaterThanEqual(const sem::Type* ty,
-                                                        utils::VectorRef<const sem::Constant*> args,
-                                                        const Source&) {
+ConstEval::Result ConstEval::OpGreaterThanEqual(const sem::Type* ty,
+                                                utils::VectorRef<const sem::Constant*> args,
+                                                const Source&) {
     auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
-        auto create = [&](auto i, auto j) -> const Constant* {
+        auto create = [&](auto i, auto j) -> ImplResult {
             return CreateElement(builder, sem::Type::DeepestElementOf(ty), i >= j);
         };
         return Dispatch_fia_fiu32_f16(create, c0, c1);
     };
 
-    auto r = TransformElements(builder, ty, transform, args[0], args[1]);
-    if (builder.Diagnostics().contains_errors()) {
-        return utils::Failure;
-    }
-    return r;
+    return TransformElements(builder, ty, transform, args[0], args[1]);
 }
 
-ConstEval::ConstantResult ConstEval::OpAnd(const sem::Type* ty,
-                                           utils::VectorRef<const sem::Constant*> args,
-                                           const Source&) {
+ConstEval::Result ConstEval::OpAnd(const sem::Type* ty,
+                                   utils::VectorRef<const sem::Constant*> args,
+                                   const Source&) {
     auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
-        auto create = [&](auto i, auto j) -> const Constant* {
+        auto create = [&](auto i, auto j) -> ImplResult {
             using T = decltype(i);
             T result;
             if constexpr (std::is_same_v<T, bool>) {
@@ -1414,18 +1370,14 @@
         return Dispatch_ia_iu32_bool(create, c0, c1);
     };
 
-    auto r = TransformElements(builder, ty, transform, args[0], args[1]);
-    if (builder.Diagnostics().contains_errors()) {
-        return utils::Failure;
-    }
-    return r;
+    return TransformElements(builder, ty, transform, args[0], args[1]);
 }
 
-ConstEval::ConstantResult ConstEval::OpOr(const sem::Type* ty,
-                                          utils::VectorRef<const sem::Constant*> args,
-                                          const Source&) {
+ConstEval::Result ConstEval::OpOr(const sem::Type* ty,
+                                  utils::VectorRef<const sem::Constant*> args,
+                                  const Source&) {
     auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
-        auto create = [&](auto i, auto j) -> const Constant* {
+        auto create = [&](auto i, auto j) -> ImplResult {
             using T = decltype(i);
             T result;
             if constexpr (std::is_same_v<T, bool>) {
@@ -1438,18 +1390,14 @@
         return Dispatch_ia_iu32_bool(create, c0, c1);
     };
 
-    auto r = TransformElements(builder, ty, transform, args[0], args[1]);
-    if (builder.Diagnostics().contains_errors()) {
-        return utils::Failure;
-    }
-    return r;
+    return TransformElements(builder, ty, transform, args[0], args[1]);
 }
 
-ConstEval::ConstantResult ConstEval::OpXor(const sem::Type* ty,
-                                           utils::VectorRef<const sem::Constant*> args,
-                                           const Source&) {
+ConstEval::Result ConstEval::OpXor(const sem::Type* ty,
+                                   utils::VectorRef<const sem::Constant*> args,
+                                   const Source&) {
     auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
-        auto create = [&](auto i, auto j) -> const Constant* {
+        auto create = [&](auto i, auto j) -> const ImplConstant* {
             return CreateElement(builder, sem::Type::DeepestElementOf(ty), decltype(i){i ^ j});
         };
         return Dispatch_ia_iu32(create, c0, c1);
@@ -1462,9 +1410,9 @@
     return r;
 }
 
-ConstEval::ConstantResult ConstEval::atan2(const sem::Type* ty,
-                                           utils::VectorRef<const sem::Constant*> args,
-                                           const Source&) {
+ConstEval::Result ConstEval::atan2(const sem::Type* ty,
+                                   utils::VectorRef<const sem::Constant*> args,
+                                   const Source&) {
     auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
         auto create = [&](auto i, auto j) {
             return CreateElement(builder, c0->Type(), decltype(i)(std::atan2(i.value, j.value)));
@@ -1474,9 +1422,9 @@
     return TransformElements(builder, ty, transform, args[0], args[1]);
 }
 
-ConstEval::ConstantResult ConstEval::clamp(const sem::Type* ty,
-                                           utils::VectorRef<const sem::Constant*> args,
-                                           const Source&) {
+ConstEval::Result ConstEval::clamp(const sem::Type* ty,
+                                   utils::VectorRef<const sem::Constant*> args,
+                                   const Source&) {
     auto transform = [&](const sem::Constant* c0, const sem::Constant* c1,
                          const sem::Constant* c2) {
         auto create = [&](auto e, auto low, auto high) {
@@ -1488,17 +1436,13 @@
     return TransformElements(builder, ty, transform, args[0], args[1], args[2]);
 }
 
-utils::Result<const sem::Constant*> ConstEval::Convert(const sem::Type* target_ty,
-                                                       const sem::Constant* value,
-                                                       const Source& source) {
+ConstEval::Result ConstEval::Convert(const sem::Type* target_ty,
+                                     const sem::Constant* value,
+                                     const Source& source) {
     if (value->Type() == target_ty) {
         return value;
     }
-    auto conv = static_cast<const Constant*>(value)->Convert(builder, target_ty, source);
-    if (!conv) {
-        return utils::Failure;
-    }
-    return conv.Get();
+    return static_cast<const ImplConstant*>(value)->Convert(builder, target_ty, source);
 }
 
 void ConstEval::AddError(const std::string& msg, const Source& source) const {
diff --git a/src/tint/resolver/const_eval.h b/src/tint/resolver/const_eval.h
index 04e2282..10a4d60 100644
--- a/src/tint/resolver/const_eval.h
+++ b/src/tint/resolver/const_eval.h
@@ -53,12 +53,12 @@
     /// * `utils::Failure`. Returned when there was a resolver error. In this situation the method
     ///   will have already reported a diagnostic error message, and the caller should abort
     ///   resolving.
-    using ConstantResult = utils::Result<const sem::Constant*>;
+    using Result = utils::Result<const sem::Constant*>;
 
     /// Typedef for a constant evaluation function
-    using Function = ConstantResult (ConstEval::*)(const sem::Type* result_ty,
-                                                   utils::VectorRef<const sem::Constant*>,
-                                                   const Source&);
+    using Function = Result (ConstEval::*)(const sem::Type* result_ty,
+                                           utils::VectorRef<const sem::Constant*>,
+                                           const Source&);
 
     /// Constructor
     /// @param b the program builder
@@ -71,44 +71,43 @@
     /// @param ty the target type - must be an array or constructor
     /// @param args the input arguments
     /// @return the constructed value, or null if the value cannot be calculated
-    ConstantResult ArrayOrStructCtor(const sem::Type* ty,
-                                     utils::VectorRef<const sem::Expression*> args);
+    Result ArrayOrStructCtor(const sem::Type* ty, utils::VectorRef<const sem::Expression*> args);
 
     /// @param ty the target type
     /// @param expr the input expression
     /// @return the bit-cast of the given expression to the given type, or null if the value cannot
     ///         be calculated
-    ConstantResult Bitcast(const sem::Type* ty, const sem::Expression* expr);
+    Result Bitcast(const sem::Type* ty, const sem::Expression* expr);
 
     /// @param obj the object being indexed
     /// @param idx the index expression
     /// @return the result of the index, or null if the value cannot be calculated
-    ConstantResult Index(const sem::Expression* obj, const sem::Expression* idx);
+    Result Index(const sem::Expression* obj, const sem::Expression* idx);
 
     /// @param ty the result type
     /// @param lit the literal AST node
     /// @return the constant value of the literal
-    ConstantResult Literal(const sem::Type* ty, const ast::LiteralExpression* lit);
+    Result Literal(const sem::Type* ty, const ast::LiteralExpression* lit);
 
     /// @param obj the object being accessed
     /// @param member the member
     /// @return the result of the member access, or null if the value cannot be calculated
-    ConstantResult MemberAccess(const sem::Expression* obj, const sem::StructMember* member);
+    Result MemberAccess(const sem::Expression* obj, const sem::StructMember* member);
 
     /// @param ty the result type
     /// @param vector the vector being swizzled
     /// @param indices the swizzle indices
     /// @return the result of the swizzle, or null if the value cannot be calculated
-    ConstantResult Swizzle(const sem::Type* ty,
-                           const sem::Expression* vector,
-                           utils::VectorRef<uint32_t> indices);
+    Result Swizzle(const sem::Type* ty,
+                   const sem::Expression* vector,
+                   utils::VectorRef<uint32_t> indices);
 
     /// Convert the `value` to `target_type`
     /// @param ty the result type
     /// @param value the value being converted
     /// @param source the source location of the conversion
     /// @return the converted value, or null if the value cannot be calculated
-    ConstantResult Convert(const sem::Type* ty, const sem::Constant* value, const Source& source);
+    Result Convert(const sem::Type* ty, const sem::Constant* value, const Source& source);
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
     // Constant value evaluation methods, to be indirectly called via the intrinsic table
@@ -119,72 +118,72 @@
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the converted value, or null if the value cannot be calculated
-    ConstantResult Conv(const sem::Type* ty,
-                        utils::VectorRef<const sem::Constant*> args,
-                        const Source& source);
+    Result Conv(const sem::Type* ty,
+                utils::VectorRef<const sem::Constant*> args,
+                const Source& source);
 
     /// Zero value type constructor
     /// @param ty the result type
     /// @param args the input arguments (no arguments provided)
     /// @param source the source location of the conversion
     /// @return the constructed value, or null if the value cannot be calculated
-    ConstantResult Zero(const sem::Type* ty,
-                        utils::VectorRef<const sem::Constant*> args,
-                        const Source& source);
+    Result Zero(const sem::Type* ty,
+                utils::VectorRef<const sem::Constant*> args,
+                const Source& source);
 
     /// Identity value type constructor
     /// @param ty the result type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the constructed value, or null if the value cannot be calculated
-    ConstantResult Identity(const sem::Type* ty,
-                            utils::VectorRef<const sem::Constant*> args,
-                            const Source& source);
+    Result Identity(const sem::Type* ty,
+                    utils::VectorRef<const sem::Constant*> args,
+                    const Source& source);
 
     /// Vector splat constructor
     /// @param ty the vector type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the constructed value, or null if the value cannot be calculated
-    ConstantResult VecSplat(const sem::Type* ty,
-                            utils::VectorRef<const sem::Constant*> args,
-                            const Source& source);
+    Result VecSplat(const sem::Type* ty,
+                    utils::VectorRef<const sem::Constant*> args,
+                    const Source& source);
 
     /// Vector constructor using scalars
     /// @param ty the vector type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the constructed value, or null if the value cannot be calculated
-    ConstantResult VecCtorS(const sem::Type* ty,
-                            utils::VectorRef<const sem::Constant*> args,
-                            const Source& source);
+    Result VecCtorS(const sem::Type* ty,
+                    utils::VectorRef<const sem::Constant*> args,
+                    const Source& source);
 
     /// Vector constructor using a mix of scalars and smaller vectors
     /// @param ty the vector type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the constructed value, or null if the value cannot be calculated
-    ConstantResult VecCtorM(const sem::Type* ty,
-                            utils::VectorRef<const sem::Constant*> args,
-                            const Source& source);
+    Result VecCtorM(const sem::Type* ty,
+                    utils::VectorRef<const sem::Constant*> args,
+                    const Source& source);
 
     /// Matrix constructor using scalar values
     /// @param ty the matrix type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the constructed value, or null if the value cannot be calculated
-    ConstantResult MatCtorS(const sem::Type* ty,
-                            utils::VectorRef<const sem::Constant*> args,
-                            const Source& source);
+    Result MatCtorS(const sem::Type* ty,
+                    utils::VectorRef<const sem::Constant*> args,
+                    const Source& source);
 
     /// Matrix constructor using column vectors
     /// @param ty the matrix type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the constructed value, or null if the value cannot be calculated
-    ConstantResult MatCtorV(const sem::Type* ty,
-                            utils::VectorRef<const sem::Constant*> args,
-                            const Source& source);
+    Result MatCtorV(const sem::Type* ty,
+                    utils::VectorRef<const sem::Constant*> args,
+                    const Source& source);
 
     ////////////////////////////////////////////////////////////////////////////
     // Unary Operators
@@ -195,27 +194,27 @@
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpComplement(const sem::Type* ty,
-                                utils::VectorRef<const sem::Constant*> args,
-                                const Source& source);
+    Result OpComplement(const sem::Type* ty,
+                        utils::VectorRef<const sem::Constant*> args,
+                        const Source& source);
 
     /// Unary minus operator '-'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpUnaryMinus(const sem::Type* ty,
-                                utils::VectorRef<const sem::Constant*> args,
-                                const Source& source);
+    Result OpUnaryMinus(const sem::Type* ty,
+                        utils::VectorRef<const sem::Constant*> args,
+                        const Source& source);
 
     /// Unary not operator '!'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpNot(const sem::Type* ty,
-                         utils::VectorRef<const sem::Constant*> args,
-                         const Source& source);
+    Result OpNot(const sem::Type* ty,
+                 utils::VectorRef<const sem::Constant*> args,
+                 const Source& source);
 
     ////////////////////////////////////////////////////////////////////////////
     // Binary Operators
@@ -226,142 +225,142 @@
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpPlus(const sem::Type* ty,
-                          utils::VectorRef<const sem::Constant*> args,
-                          const Source& source);
+    Result OpPlus(const sem::Type* ty,
+                  utils::VectorRef<const sem::Constant*> args,
+                  const Source& source);
 
     /// Minus operator '-'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpMinus(const sem::Type* ty,
-                           utils::VectorRef<const sem::Constant*> args,
-                           const Source& source);
+    Result OpMinus(const sem::Type* ty,
+                   utils::VectorRef<const sem::Constant*> args,
+                   const Source& source);
 
     /// Multiply operator '*' for the same type on the LHS and RHS
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpMultiply(const sem::Type* ty,
-                              utils::VectorRef<const sem::Constant*> args,
-                              const Source& source);
+    Result OpMultiply(const sem::Type* ty,
+                      utils::VectorRef<const sem::Constant*> args,
+                      const Source& source);
 
     /// Multiply operator '*' for matCxR<T> * vecC<T>
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpMultiplyMatVec(const sem::Type* ty,
-                                    utils::VectorRef<const sem::Constant*> args,
-                                    const Source& source);
+    Result OpMultiplyMatVec(const sem::Type* ty,
+                            utils::VectorRef<const sem::Constant*> args,
+                            const Source& source);
 
     /// Multiply operator '*' for vecR<T> * matCxR<T>
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpMultiplyVecMat(const sem::Type* ty,
-                                    utils::VectorRef<const sem::Constant*> args,
-                                    const Source& source);
+    Result OpMultiplyVecMat(const sem::Type* ty,
+                            utils::VectorRef<const sem::Constant*> args,
+                            const Source& source);
 
     /// Multiply operator '*' for matKxR<T> * matCxK<T>
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpMultiplyMatMat(const sem::Type* ty,
-                                    utils::VectorRef<const sem::Constant*> args,
-                                    const Source& source);
+    Result OpMultiplyMatMat(const sem::Type* ty,
+                            utils::VectorRef<const sem::Constant*> args,
+                            const Source& source);
 
     /// Divide operator '/'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpDivide(const sem::Type* ty,
-                            utils::VectorRef<const sem::Constant*> args,
-                            const Source& source);
+    Result OpDivide(const sem::Type* ty,
+                    utils::VectorRef<const sem::Constant*> args,
+                    const Source& source);
 
     /// Equality operator '=='
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpEqual(const sem::Type* ty,
-                           utils::VectorRef<const sem::Constant*> args,
-                           const Source& source);
+    Result OpEqual(const sem::Type* ty,
+                   utils::VectorRef<const sem::Constant*> args,
+                   const Source& source);
 
     /// Inequality operator '!='
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpNotEqual(const sem::Type* ty,
-                              utils::VectorRef<const sem::Constant*> args,
-                              const Source& source);
+    Result OpNotEqual(const sem::Type* ty,
+                      utils::VectorRef<const sem::Constant*> args,
+                      const Source& source);
 
     /// Less than operator '<'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpLessThan(const sem::Type* ty,
-                              utils::VectorRef<const sem::Constant*> args,
-                              const Source& source);
+    Result OpLessThan(const sem::Type* ty,
+                      utils::VectorRef<const sem::Constant*> args,
+                      const Source& source);
 
     /// Greater than operator '>'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpGreaterThan(const sem::Type* ty,
-                                 utils::VectorRef<const sem::Constant*> args,
-                                 const Source& source);
+    Result OpGreaterThan(const sem::Type* ty,
+                         utils::VectorRef<const sem::Constant*> args,
+                         const Source& source);
 
     /// Less than or equal operator '<='
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpLessThanEqual(const sem::Type* ty,
-                                   utils::VectorRef<const sem::Constant*> args,
-                                   const Source& source);
+    Result OpLessThanEqual(const sem::Type* ty,
+                           utils::VectorRef<const sem::Constant*> args,
+                           const Source& source);
 
     /// Greater than or equal operator '>='
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpGreaterThanEqual(const sem::Type* ty,
-                                      utils::VectorRef<const sem::Constant*> args,
-                                      const Source& source);
+    Result OpGreaterThanEqual(const sem::Type* ty,
+                              utils::VectorRef<const sem::Constant*> args,
+                              const Source& source);
 
     /// Bitwise and operator '&'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpAnd(const sem::Type* ty,
-                         utils::VectorRef<const sem::Constant*> args,
-                         const Source& source);
+    Result OpAnd(const sem::Type* ty,
+                 utils::VectorRef<const sem::Constant*> args,
+                 const Source& source);
 
     /// Bitwise or operator '|'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpOr(const sem::Type* ty,
-                        utils::VectorRef<const sem::Constant*> args,
-                        const Source& source);
+    Result OpOr(const sem::Type* ty,
+                utils::VectorRef<const sem::Constant*> args,
+                const Source& source);
 
     /// Bitwise xor operator '^'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult OpXor(const sem::Type* ty,
+    Result OpXor(const sem::Type* ty,
                          utils::VectorRef<const sem::Constant*> args,
                          const Source& source);
 
@@ -374,18 +373,18 @@
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult atan2(const sem::Type* ty,
-                         utils::VectorRef<const sem::Constant*> args,
-                         const Source& source);
+    Result atan2(const sem::Type* ty,
+                 utils::VectorRef<const sem::Constant*> args,
+                 const Source& source);
 
     /// clamp builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location of the conversion
     /// @return the result value, or null if the value cannot be calculated
-    ConstantResult clamp(const sem::Type* ty,
-                         utils::VectorRef<const sem::Constant*> args,
-                         const Source& source);
+    Result clamp(const sem::Type* ty,
+                 utils::VectorRef<const sem::Constant*> args,
+                 const Source& source);
 
   private:
     /// Adds the given error message to the diagnostics
diff --git a/src/tint/utils/result.h b/src/tint/utils/result.h
index 6a14352..baca65f 100644
--- a/src/tint/utils/result.h
+++ b/src/tint/utils/result.h
@@ -17,6 +17,7 @@
 
 #include <ostream>
 #include <variant>
+
 #include "src/tint/debug.h"
 
 namespace tint::utils {
@@ -50,6 +51,20 @@
     Result(const FAILURE_TYPE& failure)  // NOLINT(runtime/explicit):
         : value{failure} {}
 
+    /// Copy constructor with success / failure casting
+    /// @param other the Result to copy
+    template <typename S,
+              typename F,
+              typename = std::void_t<decltype(SUCCESS_TYPE{std::declval<S>()}),
+                                     decltype(FAILURE_TYPE{std::declval<F>()})>>
+    Result(const Result<S, F>& other) {  // NOLINT(runtime/explicit):
+        if (other) {
+            value = SUCCESS_TYPE{other.Get()};
+        } else {
+            value = FAILURE_TYPE{other.Failure()};
+        }
+    }
+
     /// @returns true if the result was a success
     operator bool() const {
         Validate();
diff --git a/src/tint/utils/result_test.cc b/src/tint/utils/result_test.cc
index ce125f4..6614028 100644
--- a/src/tint/utils/result_test.cc
+++ b/src/tint/utils/result_test.cc
@@ -51,5 +51,17 @@
     EXPECT_EQ(r.Failure(), "oh noes!");
 }
 
+TEST(ResultTest, ValueCast) {
+    struct X {};
+    struct Y : X {};
+
+    Y* y = nullptr;
+    auto r_y = Result<Y*>{y};
+    auto r_x = Result<X*>{r_y};
+
+    (void)r_x;
+    (void)r_y;
+}
+
 }  // namespace
 }  // namespace tint::utils