diff --git a/src/BUILD.gn b/src/BUILD.gn
index 6f81fbc..a7c9334 100644
--- a/src/BUILD.gn
+++ b/src/BUILD.gn
@@ -493,6 +493,7 @@
     "reader/reader.cc",
     "reader/reader.h",
     "resolver/resolver.cc",
+    "resolver/resolver_constants.cc",
     "resolver/resolver.h",
     "scope_stack.h",
     "sem/array.h",
@@ -503,6 +504,8 @@
     "sem/bool_type.h",
     "sem/call.h",
     "sem/call_target.h",
+    "sem/constant.cc",
+    "sem/constant.h",
     "sem/depth_texture_type.cc",
     "sem/depth_texture_type.h",
     "sem/expression.h",
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index dd3f2d1..9761dc1 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -240,6 +240,7 @@
   reader/reader.cc
   reader/reader.h
   resolver/resolver.cc
+  resolver/resolver_constants.cc
   resolver/resolver.h
   scope_stack.h
   sem/array.cc
@@ -253,6 +254,8 @@
   sem/call_target.h
   sem/call.cc
   sem/call.h
+  sem/constant.cc
+  sem/constant.h
   sem/expression.cc
   sem/expression.h
   sem/function.cc
@@ -633,6 +636,7 @@
     resolver/is_storeable_test.cc
     resolver/ptr_ref_test.cc
     resolver/ptr_ref_validation_test.cc
+    resolver/resolver_constants_test.cc
     resolver/pipeline_overridable_constant_test.cc
     resolver/resolver_test_helper.cc
     resolver/resolver_test_helper.h
diff --git a/src/ast/matrix.cc b/src/ast/matrix.cc
index 3564513..23ab60b 100644
--- a/src/ast/matrix.cc
+++ b/src/ast/matrix.cc
@@ -30,6 +30,7 @@
       subtype_(subtype),
       rows_(rows),
       columns_(columns) {
+  TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, subtype, program_id);
   TINT_ASSERT(AST, rows > 1);
   TINT_ASSERT(AST, rows < 5);
   TINT_ASSERT(AST, columns > 1);
diff --git a/src/ast/vector.cc b/src/ast/vector.cc
index 781ef95..23619d7 100644
--- a/src/ast/vector.cc
+++ b/src/ast/vector.cc
@@ -26,6 +26,7 @@
                Type const* subtype,
                uint32_t size)
     : Base(program_id, source), subtype_(subtype), size_(size) {
+  TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, subtype, program_id);
   TINT_ASSERT(AST, size_ > 1);
   TINT_ASSERT(AST, size_ < 5);
 }
diff --git a/src/resolver/resolver.cc b/src/resolver/resolver.cc
index fe559f3..a324667 100644
--- a/src/resolver/resolver.cc
+++ b/src/resolver/resolver.cc
@@ -2067,7 +2067,7 @@
     ret = builder_->create<sem::Reference>(ret, ref->StorageClass(),
                                            ref->Access());
   }
-  SetType(expr, ret);
+  SetExprInfo(expr, ret);
 
   return true;
 }
@@ -2085,7 +2085,7 @@
     AddError("cannot cast to a pointer", expr->source());
     return false;
   }
-  SetType(expr, ty, expr->type()->FriendlyName(builder_->Symbols()));
+  SetExprInfo(expr, ty, expr->type()->FriendlyName(builder_->Symbols()));
   return true;
 }
 
@@ -2167,7 +2167,7 @@
 
   builder_->Sem().Add(
       call, builder_->create<sem::Call>(call, result, current_statement_));
-  SetType(call, result->ReturnType());
+  SetExprInfo(call, result->ReturnType());
 
   current_function_->intrinsic_calls.emplace_back(
       IntrinsicCallInfo{call, result});
@@ -2239,7 +2239,7 @@
 
   function_calls_.emplace(call,
                           FunctionCallInfo{callee_func, current_statement_});
-  SetType(call, callee_func->return_type, callee_func->return_type_name);
+  SetExprInfo(call, callee_func->return_type, callee_func->return_type_name);
 
   return true;
 }
@@ -2258,7 +2258,7 @@
       return false;
     }
 
-    SetType(expr, type, type_ctor->type()->FriendlyName(builder_->Symbols()));
+    auto type_name = type_ctor->type()->FriendlyName(builder_->Symbols());
 
     // Now that the argument types have been determined, make sure that they
     // obey the constructor type rules laid out in
@@ -2267,33 +2267,38 @@
       AddError("cannot cast to a pointer", expr->source());
       return false;
     }
+
+    bool ok = true;
     if (auto* vec_type = type->As<sem::Vector>()) {
-      return ValidateVectorConstructor(type_ctor, vec_type);
+      ok = ValidateVectorConstructor(type_ctor, vec_type, type_name);
+    } else if (auto* mat_type = type->As<sem::Matrix>()) {
+      ok = ValidateMatrixConstructor(type_ctor, mat_type, type_name);
+    } else if (type->is_scalar()) {
+      ok = ValidateScalarConstructor(type_ctor, type, type_name);
+    } else if (auto* arr_type = type->As<sem::Array>()) {
+      ok = ValidateArrayConstructor(type_ctor, arr_type);
+    } else if (auto* struct_type = type->As<sem::Struct>()) {
+      ok = ValidateStructureConstructor(type_ctor, struct_type);
     }
-    if (auto* mat_type = type->As<sem::Matrix>()) {
-      return ValidateMatrixConstructor(type_ctor, mat_type);
+    if (!ok) {
+      return false;
     }
-    if (type->is_scalar()) {
-      return ValidateScalarConstructor(type_ctor, type);
-    }
-    if (auto* arr_type = type->As<sem::Array>()) {
-      return ValidateArrayConstructor(type_ctor, arr_type);
-    }
-    if (auto* struct_type = type->As<sem::Struct>()) {
-      return ValidateStructureConstructor(type_ctor, struct_type);
-    }
-  } else if (auto* scalar_ctor = expr->As<ast::ScalarConstructorExpression>()) {
+    SetExprInfo(expr, type, type_name);
+    return true;
+  }
+
+  if (auto* scalar_ctor = expr->As<ast::ScalarConstructorExpression>()) {
     Mark(scalar_ctor->literal());
     auto* type = TypeOf(scalar_ctor->literal());
     if (!type) {
       return false;
     }
-    SetType(expr, type);
-  } else {
-    TINT_ICE(Resolver, diagnostics_)
-        << "unexpected constructor expression type";
+    SetExprInfo(expr, type);
+    return true;
   }
-  return true;
+
+  TINT_ICE(Resolver, diagnostics_) << "unexpected constructor expression type";
+  return false;
 }
 
 bool Resolver::ValidateStructureConstructor(
@@ -2366,7 +2371,8 @@
 
 bool Resolver::ValidateVectorConstructor(
     const ast::TypeConstructorExpression* ctor,
-    const sem::Vector* vec_type) {
+    const sem::Vector* vec_type,
+    const std::string& type_name) {
   auto& values = ctor->values();
   auto* elem_type = vec_type->type();
   size_t value_cardinality_sum = 0;
@@ -2423,7 +2429,7 @@
     }
     const Source& values_start = values[0]->source();
     const Source& values_end = values[values.size() - 1]->source();
-    AddError("attempted to construct '" + TypeNameOf(ctor) + "' with " +
+    AddError("attempted to construct '" + type_name + "' with " +
                  std::to_string(value_cardinality_sum) + " component(s)",
              Source::Combine(values_start, values_end));
     return false;
@@ -2450,7 +2456,8 @@
 
 bool Resolver::ValidateMatrixConstructor(
     const ast::TypeConstructorExpression* ctor,
-    const sem::Matrix* matrix_type) {
+    const sem::Matrix* matrix_type,
+    const std::string& type_name) {
   auto& values = ctor->values();
   // Zero Value expression
   if (values.empty()) {
@@ -2467,8 +2474,8 @@
     const Source& values_end = values[values.size() - 1]->source();
     AddError("expected " + std::to_string(matrix_type->columns()) + " '" +
                  VectorPretty(matrix_type->rows(), elem_type) +
-                 "' arguments in '" + TypeNameOf(ctor) +
-                 "' constructor, found " + std::to_string(values.size()),
+                 "' arguments in '" + type_name + "' constructor, found " +
+                 std::to_string(values.size()),
              Source::Combine(values_start, values_end));
     return false;
   }
@@ -2481,8 +2488,8 @@
         elem_type != value_vec->type()) {
       AddError("expected argument type '" +
                    VectorPretty(matrix_type->rows(), elem_type) + "' in '" +
-                   TypeNameOf(ctor) + "' constructor, found '" +
-                   TypeNameOf(value) + "'",
+                   type_name + "' constructor, found '" + TypeNameOf(value) +
+                   "'",
                value->source());
       return false;
     }
@@ -2493,7 +2500,8 @@
 
 bool Resolver::ValidateScalarConstructor(
     const ast::TypeConstructorExpression* ctor,
-    const sem::Type* type) {
+    const sem::Type* type,
+    const std::string& type_name) {
   if (ctor->values().size() == 0) {
     return true;
   }
@@ -2519,8 +2527,8 @@
       (type->Is<U32>() && value_type->IsAnyOf<I32, U32, F32>()) ||
       (type->Is<F32>() && value_type->IsAnyOf<I32, U32, F32>());
   if (!is_valid) {
-    AddError("cannot construct '" + TypeNameOf(ctor) +
-                 "' with a value of type '" + TypeNameOf(value) + "'",
+    AddError("cannot construct '" + type_name + "' with a value of type '" +
+                 TypeNameOf(value) + "'",
              ctor->source());
 
     return false;
@@ -2533,7 +2541,7 @@
   auto symbol = expr->symbol();
   VariableInfo* var;
   if (variable_stack_.get(symbol, &var)) {
-    SetType(expr, var->type, var->type_name);
+    SetExprInfo(expr, var->type, var->type_name);
 
     var->users.push_back(expr);
     set_referenced_from_function_if_needed(var, true);
@@ -2707,7 +2715,7 @@
     return false;
   }
 
-  SetType(expr, ret);
+  SetExprInfo(expr, ret);
 
   return true;
 }
@@ -2745,17 +2753,17 @@
   // Binary logical expressions
   if (expr->IsLogicalAnd() || expr->IsLogicalOr()) {
     if (matching_types && lhs_type->Is<Bool>()) {
-      SetType(expr, lhs_type);
+      SetExprInfo(expr, lhs_type);
       return true;
     }
   }
   if (expr->IsOr() || expr->IsAnd()) {
     if (matching_types && lhs_type->Is<Bool>()) {
-      SetType(expr, lhs_type);
+      SetExprInfo(expr, lhs_type);
       return true;
     }
     if (matching_types && lhs_vec_elem_type && lhs_vec_elem_type->Is<Bool>()) {
-      SetType(expr, lhs_type);
+      SetExprInfo(expr, lhs_type);
       return true;
     }
   }
@@ -2764,14 +2772,14 @@
   if (expr->IsArithmetic()) {
     // Binary arithmetic expressions over scalars
     if (matching_types && lhs_type->is_numeric_scalar()) {
-      SetType(expr, lhs_type);
+      SetExprInfo(expr, lhs_type);
       return true;
     }
 
     // Binary arithmetic expressions over vectors
     if (matching_types && lhs_vec_elem_type &&
         lhs_vec_elem_type->is_numeric_scalar()) {
-      SetType(expr, lhs_type);
+      SetExprInfo(expr, lhs_type);
       return true;
     }
 
@@ -2779,22 +2787,22 @@
     if (lhs_vec_elem_type && (lhs_vec_elem_type == rhs_type)) {
       if (expr->IsModulo()) {
         if (rhs_type->is_integer_scalar()) {
-          SetType(expr, lhs_type);
+          SetExprInfo(expr, lhs_type);
           return true;
         }
       } else if (rhs_type->is_numeric_scalar()) {
-        SetType(expr, lhs_type);
+        SetExprInfo(expr, lhs_type);
         return true;
       }
     }
     if (rhs_vec_elem_type && (rhs_vec_elem_type == lhs_type)) {
       if (expr->IsModulo()) {
         if (lhs_type->is_integer_scalar()) {
-          SetType(expr, rhs_type);
+          SetExprInfo(expr, rhs_type);
           return true;
         }
       } else if (lhs_type->is_numeric_scalar()) {
-        SetType(expr, rhs_type);
+        SetExprInfo(expr, rhs_type);
         return true;
       }
     }
@@ -2811,19 +2819,19 @@
       rhs_mat_elem_type->Is<F32>() &&
       (lhs_mat->columns() == rhs_mat->columns()) &&
       (lhs_mat->rows() == rhs_mat->rows())) {
-    SetType(expr, rhs_type);
+    SetExprInfo(expr, rhs_type);
     return true;
   }
   if (expr->IsMultiply()) {
     // Multiplication of a matrix and a scalar
     if (lhs_type->Is<F32>() && rhs_mat_elem_type &&
         rhs_mat_elem_type->Is<F32>()) {
-      SetType(expr, rhs_type);
+      SetExprInfo(expr, rhs_type);
       return true;
     }
     if (lhs_mat_elem_type && lhs_mat_elem_type->Is<F32>() &&
         rhs_type->Is<F32>()) {
-      SetType(expr, lhs_type);
+      SetExprInfo(expr, lhs_type);
       return true;
     }
 
@@ -2831,8 +2839,8 @@
     if (lhs_vec_elem_type && lhs_vec_elem_type->Is<F32>() &&
         rhs_mat_elem_type && rhs_mat_elem_type->Is<F32>() &&
         (lhs_vec->size() == rhs_mat->rows())) {
-      SetType(expr, builder_->create<sem::Vector>(lhs_vec->type(),
-                                                  rhs_mat->columns()));
+      SetExprInfo(expr, builder_->create<sem::Vector>(lhs_vec->type(),
+                                                      rhs_mat->columns()));
       return true;
     }
 
@@ -2840,8 +2848,8 @@
     if (lhs_mat_elem_type && lhs_mat_elem_type->Is<F32>() &&
         rhs_vec_elem_type && rhs_vec_elem_type->Is<F32>() &&
         (lhs_mat->columns() == rhs_vec->size())) {
-      SetType(expr,
-              builder_->create<sem::Vector>(rhs_vec->type(), lhs_mat->rows()));
+      SetExprInfo(expr, builder_->create<sem::Vector>(rhs_vec->type(),
+                                                      lhs_mat->rows()));
       return true;
     }
 
@@ -2849,10 +2857,10 @@
     if (lhs_mat_elem_type && lhs_mat_elem_type->Is<F32>() &&
         rhs_mat_elem_type && rhs_mat_elem_type->Is<F32>() &&
         (lhs_mat->columns() == rhs_mat->rows())) {
-      SetType(expr, builder_->create<sem::Matrix>(
-                        builder_->create<sem::Vector>(lhs_mat_elem_type,
-                                                      lhs_mat->rows()),
-                        rhs_mat->columns()));
+      SetExprInfo(expr, builder_->create<sem::Matrix>(
+                            builder_->create<sem::Vector>(lhs_mat_elem_type,
+                                                          lhs_mat->rows()),
+                            rhs_mat->columns()));
       return true;
     }
   }
@@ -2862,13 +2870,13 @@
     if (matching_types) {
       // Special case for bools: only == and !=
       if (lhs_type->Is<Bool>() && (expr->IsEqual() || expr->IsNotEqual())) {
-        SetType(expr, builder_->create<sem::Bool>());
+        SetExprInfo(expr, builder_->create<sem::Bool>());
         return true;
       }
 
       // For the rest, we can compare i32, u32, and f32
       if (lhs_type->IsAnyOf<I32, U32, F32>()) {
-        SetType(expr, builder_->create<sem::Bool>());
+        SetExprInfo(expr, builder_->create<sem::Bool>());
         return true;
       }
     }
@@ -2877,14 +2885,14 @@
     if (matching_vec_elem_types) {
       if (lhs_vec_elem_type->Is<Bool>() &&
           (expr->IsEqual() || expr->IsNotEqual())) {
-        SetType(expr, builder_->create<sem::Vector>(
-                          builder_->create<sem::Bool>(), lhs_vec->size()));
+        SetExprInfo(expr, builder_->create<sem::Vector>(
+                              builder_->create<sem::Bool>(), lhs_vec->size()));
         return true;
       }
 
       if (lhs_vec_elem_type->is_numeric_scalar()) {
-        SetType(expr, builder_->create<sem::Vector>(
-                          builder_->create<sem::Bool>(), lhs_vec->size()));
+        SetExprInfo(expr, builder_->create<sem::Vector>(
+                              builder_->create<sem::Bool>(), lhs_vec->size()));
         return true;
       }
     }
@@ -2893,7 +2901,7 @@
   // Binary bitwise operations
   if (expr->IsBitwise()) {
     if (matching_types && lhs_type->is_integer_scalar_or_vector()) {
-      SetType(expr, lhs_type);
+      SetExprInfo(expr, lhs_type);
       return true;
     }
   }
@@ -2905,13 +2913,13 @@
     // logical depending on lhs type).
 
     if (lhs_type->IsAnyOf<I32, U32>() && rhs_type->Is<U32>()) {
-      SetType(expr, lhs_type);
+      SetExprInfo(expr, lhs_type);
       return true;
     }
 
     if (lhs_vec_elem_type && lhs_vec_elem_type->IsAnyOf<I32, U32>() &&
         rhs_vec_elem_type && rhs_vec_elem_type->Is<U32>()) {
-      SetType(expr, lhs_type);
+      SetExprInfo(expr, lhs_type);
       return true;
     }
   }
@@ -3002,7 +3010,7 @@
       break;
   }
 
-  SetType(unary, type);
+  SetExprInfo(unary, type);
   return true;
 }
 
@@ -3131,18 +3139,20 @@
   return nullptr;
 }
 
-void Resolver::SetType(const ast::Expression* expr, const sem::Type* type) {
-  SetType(expr, type, type->FriendlyName(builder_->Symbols()));
-}
-
-void Resolver::SetType(const ast::Expression* expr,
-                       const sem::Type* type,
-                       const std::string& type_name) {
+void Resolver::SetExprInfo(const ast::Expression* expr,
+                           const sem::Type* type,
+                           std::string type_name) {
   if (expr_info_.count(expr)) {
     TINT_ICE(Resolver, diagnostics_)
-        << "SetType() called twice for the same expression";
+        << "SetExprInfo() called twice for the same expression";
   }
-  expr_info_.emplace(expr, ExpressionInfo{type, type_name, current_statement_});
+  if (type_name.empty()) {
+    type_name = type->FriendlyName(builder_->Symbols());
+  }
+  auto constant_value = EvaluateConstantValue(expr, type);
+  expr_info_.emplace(
+      expr, ExpressionInfo{type, std::move(type_name), current_statement_,
+                           std::move(constant_value)});
 }
 
 bool Resolver::ValidatePipelineStages() {
@@ -3313,10 +3323,11 @@
       // Create semantic node for the identifier expression if necessary
       auto* sem_expr = sem.Get(user);
       if (sem_expr == nullptr) {
-        auto* type = expr_info_.at(user).type;
-        auto* stmt = expr_info_.at(user).statement;
-        auto* sem_user =
-            builder_->create<sem::VariableUser>(user, type, stmt, sem_var);
+        auto& expr_info = expr_info_.at(user);
+        auto* type = expr_info.type;
+        auto* stmt = expr_info.statement;
+        auto* sem_user = builder_->create<sem::VariableUser>(
+            user, type, stmt, sem_var, expr_info.constant_value);
         sem_var->AddUser(sem_user);
         sem.Add(user, sem_user);
       } else {
@@ -3372,9 +3383,9 @@
       // Expression has already been assigned a semantic node
       continue;
     }
-    sem.Add(expr,
-            builder_->create<sem::Expression>(
-                const_cast<ast::Expression*>(expr), info.type, info.statement));
+    sem.Add(expr, builder_->create<sem::Expression>(
+                      const_cast<ast::Expression*>(expr), info.type,
+                      info.statement, info.constant_value));
   }
 }
 
diff --git a/src/resolver/resolver.h b/src/resolver/resolver.h
index 04b7326..822d6bc 100644
--- a/src/resolver/resolver.h
+++ b/src/resolver/resolver.h
@@ -26,6 +26,7 @@
 #include "src/scope_stack.h"
 #include "src/sem/binding_point.h"
 #include "src/sem/block_statement.h"
+#include "src/sem/constant.h"
 #include "src/sem/function.h"
 #include "src/sem/struct.h"
 #include "src/utils/unique_vector.h"
@@ -152,6 +153,7 @@
     sem::Type const* type;
     std::string const type_name;  // Declared type name
     sem::Statement* statement;
+    sem::Constant constant_value;
   };
 
   /// Structure holding semantic information about a call expression to an
@@ -282,8 +284,6 @@
   bool ValidateInterpolateDecoration(const ast::InterpolateDecoration* deco,
                                      const sem::Type* storage_type);
   bool ValidateMatrix(const sem::Matrix* ty, const Source& source);
-  bool ValidateMatrixConstructor(const ast::TypeConstructorExpression* ctor,
-                                 const sem::Matrix* matrix_type);
   bool ValidateFunctionParameter(const ast::Function* func,
                                  const VariableInfo* info);
   bool ValidateNoDuplicateDefinition(Symbol sym,
@@ -305,9 +305,14 @@
                                    const std::string& rhs_type_name);
   bool ValidateVector(const sem::Vector* ty, const Source& source);
   bool ValidateVectorConstructor(const ast::TypeConstructorExpression* ctor,
-                                 const sem::Vector* vec_type);
+                                 const sem::Vector* vec_type,
+                                 const std::string& type_name);
+  bool ValidateMatrixConstructor(const ast::TypeConstructorExpression* ctor,
+                                 const sem::Matrix* matrix_type,
+                                 const std::string& type_name);
   bool ValidateScalarConstructor(const ast::TypeConstructorExpression* ctor,
-                                 const sem::Type* type);
+                                 const sem::Type* type,
+                                 const std::string& type_name);
   bool ValidateArrayConstructor(const ast::TypeConstructorExpression* ctor,
                                 const sem::Array* arr_type);
   bool ValidateTypeDecl(const ast::TypeDecl* named_type) const;
@@ -380,21 +385,14 @@
   /// @param lit the literal
   sem::Type* TypeOf(const ast::Literal* lit);
 
-  /// Creates a sem::Expression node with the resolved type `type`, and
-  /// assigns this semantic node to the expression `expr`.
-  /// @param expr the expression
-  /// @param type the resolved type
-  void SetType(const ast::Expression* expr, const sem::Type* type);
-
-  /// Creates a sem::Expression node with the resolved type `type`, the declared
-  /// type name `type_name` and assigns this semantic node to the expression
-  /// `expr`.
+  /// Records the semantic information for the expression node with the resolved
+  /// type `type` and optional declared type name `type_name`.
   /// @param expr the expression
   /// @param type the resolved type
   /// @param type_name the declared type name
-  void SetType(const ast::Expression* expr,
-               const sem::Type* type,
-               const std::string& type_name);
+  void SetExprInfo(const ast::Expression* expr,
+                   const sem::Type* type,
+                   std::string type_name = "");
 
   /// Resolve the value of a scalar const_expr.
   /// @param expr the expression
@@ -435,6 +433,26 @@
                          FunctionInfo* to,
                          CALLBACK&& callback) const;
 
+  //////////////////////////////////////////////////////////////////////////////
+  /// Constant value evaluation methods
+  //////////////////////////////////////////////////////////////////////////////
+  /// @return the Constant value of the given Expression
+  sem::Constant ConstantValueOf(const ast::Expression* expr);
+
+  /// Cast `Value` to `target_type`
+  /// @return the casted value
+  sem::Constant ConstantCast(const sem::Constant& value,
+                             const sem::Type* target_elem_type);
+
+  sem::Constant EvaluateConstantValue(const ast::Expression* expr,
+                                      const sem::Type* type);
+  sem::Constant EvaluateConstantValue(
+      const ast::ScalarConstructorExpression* scalar_ctor,
+      const sem::Type* type);
+  sem::Constant EvaluateConstantValue(
+      const ast::TypeConstructorExpression* type_ctor,
+      const sem::Type* type);
+
   ProgramBuilder* const builder_;
   diag::List& diagnostics_;
   std::unique_ptr<IntrinsicTable> const intrinsic_table_;
diff --git a/src/resolver/resolver_constants.cc b/src/resolver/resolver_constants.cc
new file mode 100644
index 0000000..45de987
--- /dev/null
+++ b/src/resolver/resolver_constants.cc
@@ -0,0 +1,153 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/resolver/resolver.h"
+
+#include "src/sem/constant.h"
+
+namespace tint {
+namespace resolver {
+namespace {
+
+using i32 = ProgramBuilder::i32;
+using u32 = ProgramBuilder::u32;
+using f32 = ProgramBuilder::f32;
+
+}  // namespace
+
+sem::Constant Resolver::ConstantCast(const sem::Constant& value,
+                                     const sem::Type* target_elem_type) {
+  if (value.ElementType() == target_elem_type) {
+    return value;
+  }
+
+  sem::Constant::Scalars elems;
+  for (size_t i = 0; i < value.Elements().size(); ++i) {
+    if (target_elem_type->Is<sem::I32>()) {
+      elems.emplace_back(
+          value.WithScalarAt(i, [](auto&& s) { return static_cast<i32>(s); }));
+    } else if (target_elem_type->Is<sem::U32>()) {
+      elems.emplace_back(
+          value.WithScalarAt(i, [](auto&& s) { return static_cast<u32>(s); }));
+    } else if (target_elem_type->Is<sem::F32>()) {
+      elems.emplace_back(
+          value.WithScalarAt(i, [](auto&& s) { return static_cast<f32>(s); }));
+    } else if (target_elem_type->Is<sem::Bool>()) {
+      elems.emplace_back(
+          value.WithScalarAt(i, [](auto&& s) { return static_cast<bool>(s); }));
+    }
+  }
+
+  auto* target_type =
+      value.Type()->Is<sem::Vector>()
+          ? builder_->create<sem::Vector>(target_elem_type,
+                                          static_cast<uint32_t>(elems.size()))
+          : target_elem_type;
+
+  return sem::Constant(target_type, elems);
+}
+
+sem::Constant Resolver::ConstantValueOf(const ast::Expression* expr) {
+  auto it = expr_info_.find(expr);
+  if (it != expr_info_.end()) {
+    return it->second.constant_value;
+  }
+  return {};
+}
+
+sem::Constant Resolver::EvaluateConstantValue(const ast::Expression* expr,
+                                              const sem::Type* type) {
+  if (auto* e = expr->As<ast::ScalarConstructorExpression>()) {
+    return EvaluateConstantValue(e, type);
+  }
+  if (auto* e = expr->As<ast::TypeConstructorExpression>()) {
+    return EvaluateConstantValue(e, type);
+  }
+  return {};
+}
+
+sem::Constant Resolver::EvaluateConstantValue(
+    const ast::ScalarConstructorExpression* scalar_ctor,
+    const sem::Type* type) {
+  auto* literal = scalar_ctor->literal();
+  if (auto* lit = literal->As<ast::SintLiteral>()) {
+    return {type, {lit->value_as_i32()}};
+  }
+  if (auto* lit = literal->As<ast::UintLiteral>()) {
+    return {type, {lit->value_as_u32()}};
+  }
+  if (auto* lit = literal->As<ast::FloatLiteral>()) {
+    return {type, {lit->value()}};
+  }
+  if (auto* lit = literal->As<ast::BoolLiteral>()) {
+    return {type, {lit->IsTrue()}};
+  }
+  TINT_UNREACHABLE(Resolver, builder_->Diagnostics());
+  return {};
+}
+
+sem::Constant Resolver::EvaluateConstantValue(
+    const ast::TypeConstructorExpression* type_ctor,
+    const sem::Type* type) {
+  auto& ctor_values = type_ctor->values();
+  auto* vec = type->As<sem::Vector>();
+
+  // For now, only fold scalars and vectors
+  if (!type->is_scalar() && !vec) {
+    return {};
+  }
+
+  auto* elem_type = vec ? vec->type() : type;
+  int result_size = vec ? static_cast<int>(vec->size()) : 1;
+
+  // For zero value init, return 0s
+  if (ctor_values.empty()) {
+    if (elem_type->Is<sem::I32>()) {
+      return sem::Constant(type, sem::Constant::Scalars(result_size, 0));
+    }
+    if (elem_type->Is<sem::U32>()) {
+      return sem::Constant(type, sem::Constant::Scalars(result_size, 0u));
+    }
+    if (elem_type->Is<sem::F32>()) {
+      return sem::Constant(type, sem::Constant::Scalars(result_size, 0.f));
+    }
+    if (elem_type->Is<sem::Bool>()) {
+      return sem::Constant(type, sem::Constant::Scalars(result_size, false));
+    }
+  }
+
+  // Build value for type_ctor from each child value by casting to
+  // type_ctor's type.
+  sem::Constant::Scalars elems;
+  for (auto* cv : ctor_values) {
+    auto value = ConstantValueOf(cv);
+    if (!value.IsValid()) {
+      return {};
+    }
+    auto cast = ConstantCast(value, elem_type);
+    elems.insert(elems.end(), cast.Elements().begin(), cast.Elements().end());
+  }
+
+  // Splat single-value initializers
+  if (elems.size() == 1) {
+    for (int i = 0; i < result_size - 1; ++i) {
+      elems.emplace_back(elems[0]);
+    }
+  }
+
+  return sem::Constant(type, std::move(elems));
+}
+
+}  // namespace resolver
+}  // namespace tint
diff --git a/src/resolver/resolver_constants_test.cc b/src/resolver/resolver_constants_test.cc
new file mode 100644
index 0000000..198cd3b
--- /dev/null
+++ b/src/resolver/resolver_constants_test.cc
@@ -0,0 +1,433 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/resolver/resolver.h"
+
+#include "gtest/gtest.h"
+#include "src/resolver/resolver_test_helper.h"
+#include "src/sem/expression.h"
+
+namespace tint {
+namespace resolver {
+namespace {
+
+using Scalar = sem::Constant::Scalar;
+
+using ResolverConstantsTest = ResolverTest;
+
+TEST_F(ResolverConstantsTest, Scalar_i32) {
+  auto* expr = Expr(99);
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  EXPECT_TRUE(sem->Type()->Is<sem::I32>());
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_EQ(sem->ConstantValue().ElementType(), sem->Type());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 1u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].i32, 99);
+}
+
+TEST_F(ResolverConstantsTest, Scalar_u32) {
+  auto* expr = Expr(99u);
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  EXPECT_TRUE(sem->Type()->Is<sem::U32>());
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_EQ(sem->ConstantValue().ElementType(), sem->Type());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 1u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].u32, 99u);
+}
+
+TEST_F(ResolverConstantsTest, Scalar_f32) {
+  auto* expr = Expr(9.9f);
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  EXPECT_TRUE(sem->Type()->Is<sem::F32>());
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_EQ(sem->ConstantValue().ElementType(), sem->Type());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 1u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].f32, 9.9f);
+}
+
+TEST_F(ResolverConstantsTest, Scalar_bool) {
+  auto* expr = Expr(true);
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  EXPECT_TRUE(sem->Type()->Is<sem::Bool>());
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_EQ(sem->ConstantValue().ElementType(), sem->Type());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 1u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].bool_, true);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_ZeroInit_i32) {
+  auto* expr = vec3<i32>();
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::I32>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::I32>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].i32, 0);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].i32, 0);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].i32, 0);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_ZeroInit_u32) {
+  auto* expr = vec3<u32>();
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::U32>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::U32>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].u32, 0u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].u32, 0u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].u32, 0u);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_ZeroInit_f32) {
+  auto* expr = vec3<f32>();
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::F32>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::F32>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].f32, 0u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].f32, 0u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].f32, 0u);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_ZeroInit_bool) {
+  auto* expr = vec3<bool>();
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::Bool>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::Bool>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].bool_, false);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].bool_, false);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].bool_, false);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_Splat_i32) {
+  auto* expr = vec3<i32>(99);
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::I32>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::I32>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].i32, 99);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].i32, 99);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].i32, 99);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_Splat_u32) {
+  auto* expr = vec3<u32>(99u);
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::U32>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::U32>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].u32, 99u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].u32, 99u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].u32, 99u);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_Splat_f32) {
+  auto* expr = vec3<f32>(9.9f);
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::F32>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::F32>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].f32, 9.9f);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].f32, 9.9f);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].f32, 9.9f);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_Splat_bool) {
+  auto* expr = vec3<bool>(true);
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::Bool>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::Bool>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].bool_, true);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].bool_, true);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].bool_, true);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_FullConstruct_i32) {
+  auto* expr = vec3<i32>(1, 2, 3);
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::I32>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::I32>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].i32, 1);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].i32, 2);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].i32, 3);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_FullConstruct_u32) {
+  auto* expr = vec3<u32>(1u, 2u, 3u);
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::U32>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::U32>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].u32, 1u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].u32, 2u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].u32, 3u);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_FullConstruct_f32) {
+  auto* expr = vec3<f32>(1.f, 2.f, 3.f);
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::F32>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::F32>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].f32, 1.f);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].f32, 2.f);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].f32, 3.f);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_FullConstruct_bool) {
+  auto* expr = vec3<bool>(true, false, true);
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::Bool>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::Bool>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].bool_, true);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].bool_, false);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].bool_, true);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_MixConstruct_i32) {
+  auto* expr = vec3<i32>(1, vec2<i32>(2, 3));
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::I32>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::I32>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].i32, 1);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].i32, 2);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].i32, 3);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_MixConstruct_u32) {
+  auto* expr = vec3<u32>(vec2<u32>(1u, 2u), 3u);
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::U32>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::U32>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].u32, 1u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].u32, 2u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].u32, 3u);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_MixConstruct_f32) {
+  auto* expr = vec3<f32>(1.f, vec2<f32>(2.f, 3.f));
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::F32>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::F32>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].f32, 1.f);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].f32, 2.f);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].f32, 3.f);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_MixConstruct_bool) {
+  auto* expr = vec3<bool>(vec2<bool>(true, false), true);
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::Bool>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::Bool>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].bool_, true);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].bool_, false);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].bool_, true);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_Cast_f32_to_32) {
+  auto* expr = vec3<i32>(vec3<f32>(1.1f, 2.2f, 3.3f));
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::I32>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::I32>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].i32, 1);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].i32, 2);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].i32, 3);
+}
+
+TEST_F(ResolverConstantsTest, Vec3_Cast_u32_to_f32) {
+  auto* expr = vec3<f32>(vec3<u32>(10u, 20u, 30u));
+  WrapInFunction(expr);
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+  auto* sem = Sem().Get(expr);
+  EXPECT_NE(sem, nullptr);
+  ASSERT_TRUE(sem->Type()->Is<sem::Vector>());
+  EXPECT_TRUE(sem->Type()->As<sem::Vector>()->type()->Is<sem::F32>());
+  EXPECT_EQ(sem->Type()->As<sem::Vector>()->size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Type(), sem->Type());
+  EXPECT_TRUE(sem->ConstantValue().ElementType()->Is<sem::F32>());
+  ASSERT_EQ(sem->ConstantValue().Elements().size(), 3u);
+  EXPECT_EQ(sem->ConstantValue().Elements()[0].f32, 10.f);
+  EXPECT_EQ(sem->ConstantValue().Elements()[1].f32, 20.f);
+  EXPECT_EQ(sem->ConstantValue().Elements()[2].f32, 30.f);
+}
+
+}  // namespace
+}  // namespace resolver
+}  // namespace tint
diff --git a/src/sem/call.cc b/src/sem/call.cc
index 3abb91e..774056d 100644
--- a/src/sem/call.cc
+++ b/src/sem/call.cc
@@ -22,7 +22,8 @@
 Call::Call(const ast::Expression* declaration,
            const CallTarget* target,
            Statement* statement)
-    : Base(declaration, target->ReturnType(), statement), target_(target) {}
+    : Base(declaration, target->ReturnType(), statement, Constant{}),
+      target_(target) {}
 
 Call::~Call() = default;
 
diff --git a/src/sem/constant.cc b/src/sem/constant.cc
new file mode 100644
index 0000000..8c5553b
--- /dev/null
+++ b/src/sem/constant.cc
@@ -0,0 +1,63 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0(the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/sem/constant.h"
+
+#include <utility>
+
+#include "src/debug.h"
+#include "src/program_builder.h"
+#include "src/sem/type.h"
+
+namespace tint {
+namespace sem {
+
+namespace {
+
+const Type* ElemType(const Type* ty, size_t num_elements) {
+  diag::List diag;
+  if (ty->is_scalar()) {
+    if (num_elements != 1) {
+      TINT_ICE(Semantic, diag)
+          << "sem::Constant() type <-> num_element mismatch. type: '"
+          << ty->type_name() << "' num_elements: " << num_elements;
+    }
+    return ty;
+  }
+  if (auto* vec = ty->As<Vector>()) {
+    if (num_elements != vec->size()) {
+      TINT_ICE(Semantic, diag)
+          << "sem::Constant() type <-> num_element mismatch. type: '"
+          << ty->type_name() << "' num_elements: " << num_elements;
+    }
+    TINT_ASSERT(Semantic, vec->type()->is_scalar());
+    return vec->type();
+  }
+  TINT_UNREACHABLE(Semantic, diag) << "Unsupported sem::Constant type";
+  return nullptr;
+}
+
+}  // namespace
+
+Constant::Constant() {}
+
+Constant::Constant(const sem::Type* ty, Scalars els)
+    : type_(ty), elem_type_(ElemType(ty, els.size())), elems_(std::move(els)) {}
+
+Constant::Constant(const Constant&) = default;
+
+Constant::~Constant() = default;
+
+}  // namespace sem
+}  // namespace tint
diff --git a/src/sem/constant.h b/src/sem/constant.h
new file mode 100644
index 0000000..27895ff
--- /dev/null
+++ b/src/sem/constant.h
@@ -0,0 +1,130 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0(the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_SEM_CONSTANT_H_
+#define SRC_SEM_CONSTANT_H_
+
+#include <vector>
+
+#include "src/program_builder.h"
+#include "src/sem/type.h"
+
+namespace tint {
+namespace sem {
+
+/// A Constant is compile-time known expression value, expressed as a flattened
+/// list of scalar values. Value may be of a scalar or vector type.
+class Constant {
+  using i32 = ProgramBuilder::i32;
+  using u32 = ProgramBuilder::u32;
+  using f32 = ProgramBuilder::f32;
+
+ public:
+  /// Scalar holds a single constant scalar value, as a union of an i32, u32,
+  /// f32 or boolean.
+  union Scalar {
+    /// The scalar value as a i32
+    int32_t i32;
+    /// The scalar value as a u32
+    uint32_t u32;
+    /// The scalar value as a f32
+    float f32;
+    /// The scalar value as a bool
+    bool bool_;
+
+    /// Constructs the scalar with the i32 value `v`
+    /// @param v the value of the Scalar
+    Scalar(ProgramBuilder::i32 v) : i32(v) {}  // NOLINT
+
+    /// Constructs the scalar with the u32 value `v`
+    /// @param v the value of the Scalar
+    Scalar(ProgramBuilder::u32 v) : u32(v) {}  // NOLINT
+
+    /// Constructs the scalar with the f32 value `v`
+    /// @param v the value of the Scalar
+    Scalar(ProgramBuilder::f32 v) : f32(v) {}  // NOLINT
+
+    /// Constructs the scalar with the bool value `v`
+    /// @param v the value of the Scalar
+    Scalar(bool v) : bool_(v) {}  // NOLINT
+  };
+
+  /// Scalars is a list of scalar values
+  using Scalars = std::vector<Scalar>;
+
+  /// Constructs an invalid Constant
+  Constant();
+
+  /// Constructs a Constant of the given type and element values
+  /// @param ty the Constant type
+  /// @param els the Constant element values
+  Constant(const Type* ty, Scalars els);
+
+  /// Copy constructor
+  Constant(const Constant&);
+
+  /// Destructor
+  ~Constant();
+
+  /// @returns true if the Constant has been initialized
+  bool IsValid() const { return type_ != nullptr; }
+
+  /// @return true if the Constant has been initialized
+  operator bool() const { return IsValid(); }
+
+  /// @returns the type of the Constant
+  const sem::Type* Type() const { return type_; }
+
+  /// @returns the element type of the Constant
+  const sem::Type* ElementType() const { return elem_type_; }
+
+  /// @returns the constant's scalar elements
+  const Scalars& Elements() const { return elems_; }
+
+  /// Calls `func(s)` with s being the current scalar value at `index`.
+  /// `func` is typically a lambda of the form '[](auto&& s)'.
+  /// @param index the index of the scalar value
+  /// @param func a function with signature `T(S)`
+  /// @return the value returned by func.
+  template <typename Func>
+  auto WithScalarAt(size_t index, Func&& func) const {
+    auto* elem_type = ElementType();
+    if (elem_type->Is<I32>()) {
+      return func(elems_[index].i32);
+    }
+    if (elem_type->Is<U32>()) {
+      return func(elems_[index].u32);
+    }
+    if (elem_type->Is<F32>()) {
+      return func(elems_[index].f32);
+    }
+    if (elem_type->Is<Bool>()) {
+      return func(elems_[index].bool_);
+    }
+    diag::List diags;
+    TINT_UNREACHABLE(Semantic, diags)
+        << "invalid scalar type " << type_->type_name();
+    return func(~0);
+  }
+
+ private:
+  const sem::Type* type_ = nullptr;
+  const sem::Type* elem_type_ = nullptr;
+  Scalars elems_;
+};
+
+}  // namespace sem
+}  // namespace tint
+
+#endif  // SRC_SEM_CONSTANT_H_
diff --git a/src/sem/expression.cc b/src/sem/expression.cc
index b5ee7f4..f6ce44b 100644
--- a/src/sem/expression.cc
+++ b/src/sem/expression.cc
@@ -14,6 +14,8 @@
 
 #include "src/sem/expression.h"
 
+#include <utility>
+
 TINT_INSTANTIATE_TYPEINFO(tint::sem::Expression);
 
 namespace tint {
@@ -21,10 +23,16 @@
 
 Expression::Expression(const ast::Expression* declaration,
                        const sem::Type* type,
-                       Statement* statement)
-    : declaration_(declaration), type_(type), statement_(statement) {
+                       Statement* statement,
+                       Constant constant)
+    : declaration_(declaration),
+      type_(type),
+      statement_(statement),
+      constant_(std::move(constant)) {
   TINT_ASSERT(Semantic, type_);
 }
 
+Expression::~Expression() = default;
+
 }  // namespace sem
 }  // namespace tint
diff --git a/src/sem/expression.h b/src/sem/expression.h
index 8c2e304..ccb7dd8 100644
--- a/src/sem/expression.h
+++ b/src/sem/expression.h
@@ -16,6 +16,7 @@
 #define SRC_SEM_EXPRESSION_H_
 
 #include "src/ast/expression.h"
+#include "src/sem/constant.h"
 #include "src/sem/node.h"
 
 namespace tint {
@@ -31,9 +32,14 @@
   /// @param declaration the AST node
   /// @param type the resolved type of the expression
   /// @param statement the statement that owns this expression
+  /// @param constant the constant value of the expression. May be invalid
   Expression(const ast::Expression* declaration,
              const sem::Type* type,
-             Statement* statement);
+             Statement* statement,
+             Constant constant);
+
+  /// Destructor
+  ~Expression() override;
 
   /// @return the resolved type of the expression
   sem::Type* Type() const { return const_cast<sem::Type*>(type_); }
@@ -41,6 +47,9 @@
   /// @return the statement that owns this expression
   Statement* Stmt() const { return statement_; }
 
+  /// @return the constant value of this expression
+  const Constant& ConstantValue() const { return constant_; }
+
   /// @returns the AST node
   ast::Expression* Declaration() const {
     return const_cast<ast::Expression*>(declaration_);
@@ -50,6 +59,7 @@
   const ast::Expression* declaration_;
   const sem::Type* const type_;
   Statement* const statement_;
+  Constant const constant_;
 };
 
 }  // namespace sem
diff --git a/src/sem/member_accessor_expression.cc b/src/sem/member_accessor_expression.cc
index 78f55b2..309785b 100644
--- a/src/sem/member_accessor_expression.cc
+++ b/src/sem/member_accessor_expression.cc
@@ -28,7 +28,7 @@
     ast::MemberAccessorExpression* declaration,
     const sem::Type* type,
     Statement* statement)
-    : Base(declaration, type, statement) {}
+    : Base(declaration, type, statement, Constant{}) {}
 
 MemberAccessorExpression::~MemberAccessorExpression() = default;
 
diff --git a/src/sem/type.h b/src/sem/type.h
index 86be66d..f48fa5f 100644
--- a/src/sem/type.h
+++ b/src/sem/type.h
@@ -52,7 +52,6 @@
   /// @returns the inner type if this is a reference, `this` otherwise
   const Type* UnwrapRef() const;
 
-
   /// @returns true if this type is a scalar
   bool is_scalar() const;
   /// @returns true if this type is a numeric scalar
diff --git a/src/sem/variable.cc b/src/sem/variable.cc
index a7758dd..490f890 100644
--- a/src/sem/variable.cc
+++ b/src/sem/variable.cc
@@ -14,6 +14,8 @@
 
 #include "src/sem/variable.h"
 
+#include <utility>
+
 #include "src/ast/identifier_expression.h"
 #include "src/ast/variable.h"
 
@@ -50,8 +52,10 @@
 VariableUser::VariableUser(ast::IdentifierExpression* declaration,
                            const sem::Type* type,
                            Statement* statement,
-                           sem::Variable* variable)
-    : Base(declaration, type, statement), variable_(variable) {}
+                           sem::Variable* variable,
+                           Constant constant_value)
+    : Base(declaration, type, statement, std::move(constant_value)),
+      variable_(variable) {}
 
 }  // namespace sem
 }  // namespace tint
diff --git a/src/sem/variable.h b/src/sem/variable.h
index 55275cc..356ed9b 100644
--- a/src/sem/variable.h
+++ b/src/sem/variable.h
@@ -109,10 +109,12 @@
   /// @param type the resolved type of the expression
   /// @param statement the statement that owns this expression
   /// @param variable the semantic variable
+  /// @param constant_value the constant value for the variable. May be invalid
   VariableUser(ast::IdentifierExpression* declaration,
                const sem::Type* type,
                Statement* statement,
-               sem::Variable* variable);
+               sem::Variable* variable,
+               Constant constant_value);
 
   /// @returns the variable that this expression refers to
   const sem::Variable* Variable() const { return variable_; }
diff --git a/src/transform/fold_constants.cc b/src/transform/fold_constants.cc
index 6fcc798..6d7760a 100644
--- a/src/transform/fold_constants.cc
+++ b/src/transform/fold_constants.cc
@@ -19,271 +19,43 @@
 #include <vector>
 
 #include "src/program_builder.h"
+#include "src/sem/expression.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::transform::FoldConstants);
 
 namespace tint {
+namespace transform {
 
-namespace {
+FoldConstants::FoldConstants() = default;
 
-using i32 = ProgramBuilder::i32;
-using u32 = ProgramBuilder::u32;
-using f32 = ProgramBuilder::f32;
+FoldConstants::~FoldConstants() = default;
 
-/// A Value is a sequence of scalars
-struct Value {
-  enum class Type {
-    i32,  //
-    u32,
-    f32,
-    bool_
-  };
-
-  union Scalar {
-    ProgramBuilder::i32 i32;
-    ProgramBuilder::u32 u32;
-    ProgramBuilder::f32 f32;
-    bool bool_;
-
-    Scalar(ProgramBuilder::i32 v) : i32(v) {}  // NOLINT
-    Scalar(ProgramBuilder::u32 v) : u32(v) {}  // NOLINT
-    Scalar(ProgramBuilder::f32 v) : f32(v) {}  // NOLINT
-    Scalar(bool v) : bool_(v) {}               // NOLINT
-  };
-
-  using Elems = std::vector<Scalar>;
-
-  Type type;
-  Elems elems;
-
-  Value() {}
-
-  Value(ProgramBuilder::i32 v) : type(Type::i32), elems{v} {}  // NOLINT
-  Value(ProgramBuilder::u32 v) : type(Type::u32), elems{v} {}  // NOLINT
-  Value(ProgramBuilder::f32 v) : type(Type::f32), elems{v} {}  // NOLINT
-  Value(bool v) : type(Type::bool_), elems{v} {}               // NOLINT
-
-  explicit Value(Type t, Elems e = {}) : type(t), elems(std::move(e)) {}
-
-  bool Valid() const { return elems.size() != 0; }
-  operator bool() const { return Valid(); }
-
-  void Append(const Value& value) {
-    TINT_ASSERT(Transform, value.type == type);
-    elems.insert(elems.end(), value.elems.begin(), value.elems.end());
-  }
-
-  /// Calls `func`(s) with s being the current scalar value at `index`.
-  /// `func` is typically a lambda of the form '[](auto&& s)'.
-  template <typename Func>
-  auto WithScalarAt(size_t index, Func&& func) const {
-    switch (type) {
-      case Value::Type::i32: {
-        return func(elems[index].i32);
-      }
-      case Value::Type::u32: {
-        return func(elems[index].u32);
-      }
-      case Value::Type::f32: {
-        return func(elems[index].f32);
-      }
-      case Value::Type::bool_: {
-        return func(elems[index].bool_);
-      }
+void FoldConstants::Run(CloneContext& ctx, const DataMap&, DataMap&) {
+  ctx.ReplaceAll([&](ast::Expression* expr) -> ast::Expression* {
+    auto* sem = ctx.src->Sem().Get(expr);
+    if (!sem) {
+      return nullptr;
     }
-    TINT_ASSERT(Transform, false && "Unreachable");
-    return func(~0);
-  }
-};
 
-/// Returns the Value::Type that maps to the ast::Type*
-Value::Type AstToValueType(ast::Type* t) {
-  if (t->Is<ast::I32>()) {
-    return Value::Type::i32;
-  } else if (t->Is<ast::U32>()) {
-    return Value::Type::u32;
-  } else if (t->Is<ast::F32>()) {
-    return Value::Type::f32;
-  } else if (t->Is<ast::Bool>()) {
-    return Value::Type::bool_;
-  }
-  TINT_ASSERT(Transform, false && "Invalid type");
-  return {};
-}
-
-/// Cast `Value` to `target_type`
-/// @return the casted value
-Value Cast(const Value& value, Value::Type target_type) {
-  if (value.type == target_type) {
-    return value;
-  }
-
-  Value result(target_type);
-  for (size_t i = 0; i < value.elems.size(); ++i) {
-    switch (target_type) {
-      case Value::Type::i32:
-        result.Append(value.WithScalarAt(
-            i, [](auto&& s) { return static_cast<i32>(s); }));
-        break;
-
-      case Value::Type::u32:
-        result.Append(value.WithScalarAt(
-            i, [](auto&& s) { return static_cast<u32>(s); }));
-        break;
-
-      case Value::Type::f32:
-        result.Append(value.WithScalarAt(
-            i, [](auto&& s) { return static_cast<f32>(s); }));
-        break;
-
-      case Value::Type::bool_:
-        result.Append(value.WithScalarAt(
-            i, [](auto&& s) { return static_cast<bool>(s); }));
-        break;
+    auto value = sem->ConstantValue();
+    if (!value.IsValid()) {
+      return nullptr;
     }
-  }
 
-  return result;
-}
+    auto* ty = sem->Type();
 
-/// Type that maps `ast::Expression*` to `Value`
-using ExprToValue = std::unordered_map<const ast::Expression*, Value>;
-
-/// Adds mapping of `expr` to `value` to `expr_to_value`
-/// @returns true if add succeded
-bool AddExpr(ExprToValue& expr_to_value,
-             const ast::Expression* expr,
-             Value value) {
-  auto r = expr_to_value.emplace(expr, std::move(value));
-  return r.second;
-}
-
-/// @returns the `Value` in `expr_to_value` at `expr`, leaving it in the map, or
-/// invalid Value if not in map
-Value PeekExpr(ExprToValue& expr_to_value, ast::Expression* expr) {
-  auto iter = expr_to_value.find(expr);
-  if (iter != expr_to_value.end()) {
-    return iter->second;
-  }
-  return {};
-}
-
-/// @returns the `Value` in `expr_to_value` at `expr`, removing it from the map,
-/// or invalid Value if not in map
-Value TakeExpr(ExprToValue& expr_to_value, ast::Expression* expr) {
-  auto iter = expr_to_value.find(expr);
-  if (iter != expr_to_value.end()) {
-    auto result = std::move(iter->second);
-    expr_to_value.erase(iter);
-    return result;
-  }
-  return {};
-}
-
-/// Folds a `ScalarConstructorExpression` into a `Value`
-Value Fold(const ast::ScalarConstructorExpression* scalar_ctor) {
-  auto* literal = scalar_ctor->literal();
-  if (auto* lit = literal->As<ast::SintLiteral>()) {
-    return {lit->value_as_i32()};
-  }
-  if (auto* lit = literal->As<ast::UintLiteral>()) {
-    return {lit->value_as_u32()};
-  }
-  if (auto* lit = literal->As<ast::FloatLiteral>()) {
-    return {lit->value()};
-  }
-  if (auto* lit = literal->As<ast::BoolLiteral>()) {
-    return {lit->IsTrue()};
-  }
-  TINT_ASSERT(Transform, false && "Unreachable");
-  return {};
-}
-
-/// Folds a `TypeConstructorExpression` into a `Value` if possible.
-/// @returns a valid `Value` with 1 element for scalars, and 2/3/4 elements for
-/// vectors.
-Value Fold(const ast::TypeConstructorExpression* type_ctor,
-           ExprToValue& expr_to_value) {
-  auto& ctor_values = type_ctor->values();
-  auto* type = type_ctor->type();
-  auto* vec = type->As<ast::Vector>();
-
-  // For now, only fold scalars and vectors
-  if (!type->is_scalar() && !vec) {
-    return {};
-  }
-
-  auto* elem_type = vec ? vec->type() : type;
-  int result_size = vec ? static_cast<int>(vec->size()) : 1;
-
-  // For zero value init, return 0s
-  if (ctor_values.empty()) {
-    if (elem_type->Is<ast::I32>()) {
-      return Value(Value::Type::i32, Value::Elems(result_size, 0));
-    } else if (elem_type->Is<ast::U32>()) {
-      return Value(Value::Type::u32, Value::Elems(result_size, 0u));
-    } else if (elem_type->Is<ast::F32>()) {
-      return Value(Value::Type::f32, Value::Elems(result_size, 0.0f));
-    } else if (elem_type->Is<ast::Bool>()) {
-      return Value(Value::Type::bool_, Value::Elems(result_size, false));
+    auto* ctor = expr->As<ast::TypeConstructorExpression>();
+    if (!ctor) {
+      return nullptr;
     }
-  }
 
-  // If not all ctor_values are foldable, we can't fold this node
-  for (auto* cv : ctor_values) {
-    if (!PeekExpr(expr_to_value, cv)) {
-      return {};
-    }
-  }
-
-  // Build value for type_ctor from each child value by casting to
-  // type_ctor's type.
-  Value new_value(AstToValueType(elem_type));
-  for (auto* cv : ctor_values) {
-    auto value = TakeExpr(expr_to_value, cv);
-    new_value.Append(Cast(value, AstToValueType(elem_type)));
-  }
-
-  // Splat single-value initializers
-  if (new_value.elems.size() == 1) {
-    auto first_value = new_value;
-    for (int i = 0; i < result_size - 1; ++i) {
-      new_value.Append(first_value);
-    }
-  }
-
-  return new_value;
-}
-
-/// @returns a `ConstructorExpression` to replace `expr` with, or nullptr if we
-/// shouldn't replace it.
-ast::ConstructorExpression* Build(CloneContext& ctx,
-                                  const ast::Expression* expr,
-                                  const Value& value) {
-  // If original ctor expression had no init values, don't replace the
-  // expression
-  if (auto* ctor = expr->As<ast::TypeConstructorExpression>()) {
+    // If original ctor expression had no init values, don't replace the
+    // expression
     if (ctor->values().size() == 0) {
       return nullptr;
     }
-  }
 
-  auto make_ast_type = [&]() -> ast::Type* {
-    switch (value.type) {
-      case Value::Type::i32:
-        return ctx.dst->ty.i32();
-      case Value::Type::u32:
-        return ctx.dst->ty.u32();
-      case Value::Type::f32:
-        return ctx.dst->ty.f32();
-      case Value::Type::bool_:
-        return ctx.dst->ty.bool_();
-    }
-    return nullptr;
-  };
-
-  if (auto* type_ctor = expr->As<ast::TypeConstructorExpression>()) {
-    if (auto* vec = type_ctor->type()->As<ast::Vector>()) {
+    if (auto* vec = ty->As<sem::Vector>()) {
       uint32_t vec_size = static_cast<uint32_t>(vec->size());
 
       // We'd like to construct the new vector with the same number of
@@ -294,9 +66,9 @@
       //
       // In this case, creating a vec3 with 2 args is invalid, so we should
       // create it with 3. So what we do is construct with vec_size args,
-      // except if the original vector was single-value initialized, in which
-      // case, we only construct with one arg again.
-      uint32_t ctor_size = (type_ctor->values().size() == 1) ? 1 : vec_size;
+      // except if the original vector was single-value initialized, in
+      // which case, we only construct with one arg again.
+      uint32_t ctor_size = (ctor->values().size() == 1) ? 1 : vec_size;
 
       ast::ExpressionList ctors;
       for (uint32_t i = 0; i < ctor_size; ++i) {
@@ -304,44 +76,16 @@
             i, [&](auto&& s) { ctors.emplace_back(ctx.dst->Expr(s)); });
       }
 
-      return ctx.dst->vec(make_ast_type(), vec_size, ctors);
-    } else if (type_ctor->type()->is_scalar()) {
+      auto* el_ty = CreateASTTypeFor(&ctx, vec->type());
+      return ctx.dst->vec(el_ty, vec_size, ctors);
+    }
+
+    if (ty->is_scalar()) {
       return value.WithScalarAt(0, [&](auto&& s) { return ctx.dst->Expr(s); });
     }
-  }
-  return nullptr;
-}
 
-}  // namespace
-
-namespace transform {
-
-FoldConstants::FoldConstants() = default;
-
-FoldConstants::~FoldConstants() = default;
-
-void FoldConstants::Run(CloneContext& ctx, const DataMap&, DataMap&) {
-  ExprToValue expr_to_value;
-
-  // Visit inner expressions before outer expressions
-  for (auto* node : ctx.src->ASTNodes().Objects()) {
-    if (auto* scalar_ctor = node->As<ast::ScalarConstructorExpression>()) {
-      if (auto v = Fold(scalar_ctor)) {
-        AddExpr(expr_to_value, scalar_ctor, std::move(v));
-      }
-    }
-    if (auto* type_ctor = node->As<ast::TypeConstructorExpression>()) {
-      if (auto v = Fold(type_ctor, expr_to_value)) {
-        AddExpr(expr_to_value, type_ctor, std::move(v));
-      }
-    }
-  }
-
-  for (auto& kvp : expr_to_value) {
-    if (auto* ctor_expr = Build(ctx, kvp.first, kvp.second)) {
-      ctx.Replace(kvp.first, ctor_expr);
-    }
-  }
+    return nullptr;
+  });
 
   ctx.Clone();
 }
diff --git a/src/transform/spirv.cc b/src/transform/spirv.cc
index 1582db4..84cd1f8 100644
--- a/src/transform/spirv.cc
+++ b/src/transform/spirv.cc
@@ -54,6 +54,10 @@
   manager.Add<ForLoopToLoop>();  // Must come after ZeroInitWorkgroupMemory
   auto transformedInput = manager.Run(in, data);
 
+  if (transformedInput.program.Diagnostics().contains_errors()) {
+    return transformedInput;
+  }
+
   auto* cfg = data.Get<Config>();
 
   ProgramBuilder out;
diff --git a/src/writer/append_vector.cc b/src/writer/append_vector.cc
index 9763c18..f8e1356 100644
--- a/src/writer/append_vector.cc
+++ b/src/writer/append_vector.cc
@@ -96,8 +96,9 @@
 
       for (uint32_t i = 0; i < packed_size - 1; i++) {
         auto* zero = buildZero();
-        b->Sem().Add(zero, b->create<sem::Expression>(zero, packed_el_sem_ty,
-                                                      statement));
+        b->Sem().Add(
+            zero, b->create<sem::Expression>(zero, packed_el_sem_ty, statement,
+                                             sem::Constant{}));
         packed.emplace_back(zero);
       }
     }
@@ -107,16 +108,18 @@
   if (packed_el_sem_ty != b->TypeOf(scalar)->UnwrapRef()) {
     // Cast scalar to the vector element type
     auto* scalar_cast = b->Construct(packed_el_ty, scalar);
-    b->Sem().Add(scalar_cast, b->create<sem::Expression>(
-                                  scalar_cast, packed_el_sem_ty, statement));
+    b->Sem().Add(scalar_cast,
+                 b->create<sem::Expression>(scalar_cast, packed_el_sem_ty,
+                                            statement, sem::Constant{}));
     packed.emplace_back(scalar_cast);
   } else {
     packed.emplace_back(scalar);
   }
 
   auto* constructor = b->Construct(packed_ty, std::move(packed));
-  b->Sem().Add(constructor, b->create<sem::Expression>(
-                                constructor, packed_sem_ty, statement));
+  b->Sem().Add(constructor,
+               b->create<sem::Expression>(constructor, packed_sem_ty, statement,
+                                          sem::Constant{}));
 
   return constructor;
 }
diff --git a/src/writer/hlsl/generator_impl.cc b/src/writer/hlsl/generator_impl.cc
index d4c0ed6..0f5fad6 100644
--- a/src/writer/hlsl/generator_impl.cc
+++ b/src/writer/hlsl/generator_impl.cc
@@ -1764,7 +1764,8 @@
     auto* i32 = builder_.create<sem::I32>();
     auto* zero = builder_.Expr(0);
     auto* stmt = builder_.Sem().Get(vector)->Stmt();
-    builder_.Sem().Add(zero, builder_.create<sem::Expression>(zero, i32, stmt));
+    builder_.Sem().Add(zero, builder_.create<sem::Expression>(zero, i32, stmt,
+                                                              sem::Constant{}));
     auto* packed = AppendVector(&builder_, vector, zero);
     return EmitExpression(out, packed);
   };
diff --git a/test/BUILD.gn b/test/BUILD.gn
index 7439a56..2fd1d31 100644
--- a/test/BUILD.gn
+++ b/test/BUILD.gn
@@ -243,6 +243,7 @@
     "../src/resolver/pipeline_overridable_constant_test.cc",
     "../src/resolver/ptr_ref_test.cc",
     "../src/resolver/ptr_ref_validation_test.cc",
+    "../src/resolver/resolver_constants_test.cc",
     "../src/resolver/resolver_test.cc",
     "../src/resolver/resolver_test_helper.cc",
     "../src/resolver/resolver_test_helper.h",