diff --git a/src/tint/resolver/resolver.cc b/src/tint/resolver/resolver.cc
index d222d1d..d19f9bd 100644
--- a/src/tint/resolver/resolver.cc
+++ b/src/tint/resolver/resolver.cc
@@ -1249,23 +1249,13 @@
             return nullptr;
         }
         auto expr_val = EvaluateConstantValue(decl, expr->Type());
-        if (!expr_val) {
-            return nullptr;
-        }
-        if (!expr_val->IsValid()) {
-            TINT_ICE(Resolver, builder_->Diagnostics())
-                << decl->source
-                << "EvaluateConstantValue() returned invalid value for materialized value of type: "
-                << builder_->FriendlyName(src_ty);
-            return nullptr;
-        }
-        auto materialized_val = ConvertValue(expr_val.Get(), target_ty, decl->source);
+        auto materialized_val = ConvertValue(std::move(expr_val), target_ty, decl->source);
         if (!materialized_val) {
             return nullptr;
         }
         if (!materialized_val->IsValid()) {
             TINT_ICE(Resolver, builder_->Diagnostics())
-                << decl->source << "ConvertValue(" << builder_->FriendlyName(expr_val->Type())
+                << decl->source << "ConvertValue(" << builder_->FriendlyName(expr_val.Type())
                 << " -> " << builder_->FriendlyName(target_ty) << ") returned invalid value";
             return nullptr;
         }
@@ -1368,11 +1358,8 @@
     }
 
     auto val = EvaluateConstantValue(expr, ty);
-    if (!val) {
-        return nullptr;
-    }
     bool has_side_effects = idx->HasSideEffects() || obj->HasSideEffects();
-    auto* sem = builder_->create<sem::Expression>(expr, ty, current_statement_, val.Get(),
+    auto* sem = builder_->create<sem::Expression>(expr, ty, current_statement_, std::move(val),
                                                   has_side_effects, obj->SourceVariable());
     sem->Behaviors() = idx->Behaviors() + obj->Behaviors();
     return sem;
@@ -1389,10 +1376,7 @@
     }
 
     auto val = EvaluateConstantValue(expr, ty);
-    if (!val) {
-        return nullptr;
-    }
-    auto* sem = builder_->create<sem::Expression>(expr, ty, current_statement_, val.Get(),
+    auto* sem = builder_->create<sem::Expression>(expr, ty, current_statement_, std::move(val),
                                                   inner->HasSideEffects());
 
     sem->Behaviors() = inner->Behaviors();
@@ -1440,11 +1424,8 @@
             return nullptr;
         }
         auto val = EvaluateConstantValue(expr, call_target->ReturnType());
-        if (!val) {
-            return nullptr;
-        }
         return builder_->create<sem::Call>(expr, call_target, std::move(args), current_statement_,
-                                           val.Get(), has_side_effects);
+                                           std::move(val), has_side_effects);
     };
 
     // ct_ctor_or_conv is a helper for building either a sem::TypeConstructor or sem::TypeConversion
@@ -1481,11 +1462,9 @@
                     return nullptr;
                 }
                 auto val = EvaluateConstantValue(expr, call_target->ReturnType());
-                if (!val) {
-                    return nullptr;
-                }
                 return builder_->create<sem::Call>(expr, call_target, std::move(args),
-                                                   current_statement_, val.Get(), has_side_effects);
+                                                   current_statement_, std::move(val),
+                                                   has_side_effects);
             },
             [&](const sem::Struct* str) -> sem::Call* {
                 auto* call_target = utils::GetOrCreate(
@@ -1506,11 +1485,9 @@
                     return nullptr;
                 }
                 auto val = EvaluateConstantValue(expr, call_target->ReturnType());
-                if (!val) {
-                    return nullptr;
-                }
                 return builder_->create<sem::Call>(expr, call_target, std::move(args),
-                                                   current_statement_, val.Get(), has_side_effects);
+                                                   current_statement_, std::move(val),
+                                                   has_side_effects);
             },
             [&](Default) {
                 AddError("type is not constructible", expr->source);
@@ -1812,10 +1789,7 @@
     }
 
     auto val = EvaluateConstantValue(literal, ty);
-    if (!val) {
-        return nullptr;
-    }
-    return builder_->create<sem::Expression>(literal, ty, current_statement_, val.Get(),
+    return builder_->create<sem::Expression>(literal, ty, current_statement_, std::move(val),
                                              /* has_side_effects */ false);
 }
 
@@ -2027,12 +2001,9 @@
     }
 
     auto val = EvaluateConstantValue(expr, op.result);
-    if (!val) {
-        return nullptr;
-    }
     bool has_side_effects = lhs->HasSideEffects() || rhs->HasSideEffects();
-    auto* sem = builder_->create<sem::Expression>(expr, op.result, current_statement_, val.Get(),
-                                                  has_side_effects);
+    auto* sem = builder_->create<sem::Expression>(expr, op.result, current_statement_,
+                                                  std::move(val), has_side_effects);
     sem->Behaviors() = lhs->Behaviors() + rhs->Behaviors();
 
     return sem;
@@ -2104,10 +2075,7 @@
     }
 
     auto val = EvaluateConstantValue(unary, ty);
-    if (!val) {
-        return nullptr;
-    }
-    auto* sem = builder_->create<sem::Expression>(unary, ty, current_statement_, val.Get(),
+    auto* sem = builder_->create<sem::Expression>(unary, ty, current_statement_, std::move(val),
                                                   expr->HasSideEffects(), source_var);
     sem->Behaviors() = expr->Behaviors();
     return sem;
diff --git a/src/tint/resolver/resolver.h b/src/tint/resolver/resolver.h
index 5b73e9d..0b52ec9 100644
--- a/src/tint/resolver/resolver.h
+++ b/src/tint/resolver/resolver.h
@@ -391,10 +391,10 @@
     ConstantResult ConvertValue(const sem::Constant& value,
                                 const sem::Type* target_type,
                                 const Source& source);
-    ConstantResult EvaluateConstantValue(const ast::Expression* expr, const sem::Type* type);
-    ConstantResult EvaluateConstantValue(const ast::LiteralExpression* literal,
-                                         const sem::Type* type);
-    ConstantResult EvaluateConstantValue(const ast::CallExpression* call, const sem::Type* type);
+    sem::Constant EvaluateConstantValue(const ast::Expression* expr, const sem::Type* type);
+    sem::Constant EvaluateConstantValue(const ast::LiteralExpression* literal,
+                                        const sem::Type* type);
+    sem::Constant EvaluateConstantValue(const ast::CallExpression* call, const sem::Type* type);
 
     /// @returns true if the symbol is the name of a builtin function.
     bool IsBuiltin(Symbol) const;
diff --git a/src/tint/resolver/resolver_constants.cc b/src/tint/resolver/resolver_constants.cc
index 24c57d4..95b494e 100644
--- a/src/tint/resolver/resolver_constants.cc
+++ b/src/tint/resolver/resolver_constants.cc
@@ -151,19 +151,18 @@
 
 }  // namespace
 
-utils::Result<sem::Constant> Resolver::EvaluateConstantValue(const ast::Expression* expr,
-                                                             const sem::Type* type) {
+sem::Constant Resolver::EvaluateConstantValue(const ast::Expression* expr, const sem::Type* type) {
     if (auto* e = expr->As<ast::LiteralExpression>()) {
         return EvaluateConstantValue(e, type);
     }
     if (auto* e = expr->As<ast::CallExpression>()) {
         return EvaluateConstantValue(e, type);
     }
-    return sem::Constant{};
+    return {};
 }
 
-utils::Result<sem::Constant> Resolver::EvaluateConstantValue(const ast::LiteralExpression* literal,
-                                                             const sem::Type* type) {
+sem::Constant Resolver::EvaluateConstantValue(const ast::LiteralExpression* literal,
+                                              const sem::Type* type) {
     return Switch(
         literal,
         [&](const ast::BoolLiteralExpression* lit) {
@@ -177,8 +176,8 @@
         });
 }
 
-utils::Result<sem::Constant> Resolver::EvaluateConstantValue(const ast::CallExpression* call,
-                                                             const sem::Type* ty) {
+sem::Constant Resolver::EvaluateConstantValue(const ast::CallExpression* call,
+                                              const sem::Type* ty) {
     uint32_t result_size = 0;
     auto* el_ty = sem::Type::ElementOf(ty, &result_size);
     if (!el_ty) {
@@ -212,11 +211,11 @@
     for (auto* expr : call->args) {
         auto* arg = builder_->Sem().Get(expr);
         if (!arg) {
-            return sem::Constant{};
+            return {};
         }
         auto value = arg->ConstantValue();
         if (!value) {
-            return sem::Constant{};
+            return {};
         }
 
         // Convert the elements to the desired type.