diff --git a/src/tint/cmd/generate_external_texture_bindings.cc b/src/tint/cmd/generate_external_texture_bindings.cc
index d9ddb73..891435e 100644
--- a/src/tint/cmd/generate_external_texture_bindings.cc
+++ b/src/tint/cmd/generate_external_texture_bindings.cc
@@ -39,7 +39,7 @@
                 auto& n = group_to_next_binding_number[bp->group];
                 n = std::max(n, bp->binding + 1);
 
-                if (sem_var->Type()->UnwrapRef()->Is<type::ExternalTexture>()) {
+                if (sem_var->Type()->UnwrapRef()->Is<core::type::ExternalTexture>()) {
                     ext_tex_bps.emplace_back(*bp);
                 }
             }
diff --git a/src/tint/cmd/info.cc b/src/tint/cmd/info.cc
index 34593f2..76a9f3d 100644
--- a/src/tint/cmd/info.cc
+++ b/src/tint/cmd/info.cc
@@ -224,10 +224,10 @@
 
     bool struct_first = true;
     for (const auto* ty : program->Types()) {
-        if (!ty->Is<tint::type::Struct>()) {
+        if (!ty->Is<tint::core::type::Struct>()) {
             continue;
         }
-        const auto* s = ty->As<tint::type::Struct>();
+        const auto* s = ty->As<tint::core::type::Struct>();
 
         if (!struct_first) {
             std::cout << ",";
@@ -291,7 +291,7 @@
 
     bool has_struct = false;
     for (const auto* ty : program->Types()) {
-        if (!ty->Is<tint::type::Struct>()) {
+        if (!ty->Is<tint::core::type::Struct>()) {
             continue;
         }
         has_struct = true;
@@ -301,10 +301,10 @@
     if (has_struct) {
         std::cout << "Structures" << std::endl;
         for (const auto* ty : program->Types()) {
-            if (!ty->Is<tint::type::Struct>()) {
+            if (!ty->Is<tint::core::type::Struct>()) {
                 continue;
             }
-            const auto* s = ty->As<tint::type::Struct>();
+            const auto* s = ty->As<tint::core::type::Struct>();
             std::cout << s->Layout() << std::endl << std::endl;
         }
     }
diff --git a/src/tint/fuzzers/tint_ast_clone_fuzzer.cc b/src/tint/fuzzers/tint_ast_clone_fuzzer.cc
index 7b5f870..cb571ed 100644
--- a/src/tint/fuzzers/tint_ast_clone_fuzzer.cc
+++ b/src/tint/fuzzers/tint_ast_clone_fuzzer.cc
@@ -74,7 +74,7 @@
     for (auto* src_node : src.ASTNodes().Objects()) {
         src_nodes.emplace(src_node);
     }
-    std::unordered_set<const tint::type::Type*> src_types;
+    std::unordered_set<const tint::core::type::Type*> src_types;
     for (auto* src_type : src.Types()) {
         src_types.emplace(src_type);
     }
diff --git a/src/tint/fuzzers/tint_ast_fuzzer/mutation_finders/change_unary_operators.cc b/src/tint/fuzzers/tint_ast_fuzzer/mutation_finders/change_unary_operators.cc
index 6e2a4c6..39f1e131 100644
--- a/src/tint/fuzzers/tint_ast_fuzzer/mutation_finders/change_unary_operators.cc
+++ b/src/tint/fuzzers/tint_ast_fuzzer/mutation_finders/change_unary_operators.cc
@@ -42,8 +42,9 @@
 
         // Get the type of the unary expression.
         const auto* type = program.Sem().Get(unary_expr)->Type();
-        const auto* basic_type =
-            type->Is<type::Reference>() ? type->As<type::Reference>()->StoreType() : type;
+        const auto* basic_type = type->Is<core::type::Reference>()
+                                     ? type->As<core::type::Reference>()->StoreType()
+                                     : type;
 
         // Only signed integer or vector of signed integer can be mutated.
         if (!basic_type->is_signed_integer_scalar_or_vector()) {
diff --git a/src/tint/fuzzers/tint_ast_fuzzer/mutations/change_binary_operator.cc b/src/tint/fuzzers/tint_ast_fuzzer/mutations/change_binary_operator.cc
index 6b554ef..ae07736 100644
--- a/src/tint/fuzzers/tint_ast_fuzzer/mutations/change_binary_operator.cc
+++ b/src/tint/fuzzers/tint_ast_fuzzer/mutations/change_binary_operator.cc
@@ -24,7 +24,7 @@
 
 namespace {
 
-bool IsSuitableForShift(const type::Type* lhs_type, const type::Type* rhs_type) {
+bool IsSuitableForShift(const core::type::Type* lhs_type, const core::type::Type* rhs_type) {
     // `a << b` requires b to be an unsigned scalar or vector, and `a` to be an
     // integer scalar or vector with the same width as `b`. Similar for `a >> b`.
 
@@ -37,8 +37,8 @@
     return false;
 }
 
-bool CanReplaceAddSubtractWith(const type::Type* lhs_type,
-                               const type::Type* rhs_type,
+bool CanReplaceAddSubtractWith(const core::type::Type* lhs_type,
+                               const core::type::Type* rhs_type,
                                core::BinaryOp new_operator) {
     // The program is assumed to be well-typed, so this method determines when
     // 'new_operator' can be used as a type-preserving replacement in an '+' or
@@ -71,8 +71,8 @@
     }
 }
 
-bool CanReplaceMultiplyWith(const type::Type* lhs_type,
-                            const type::Type* rhs_type,
+bool CanReplaceMultiplyWith(const core::type::Type* lhs_type,
+                            const core::type::Type* rhs_type,
                             core::BinaryOp new_operator) {
     // The program is assumed to be well-typed, so this method determines when
     // 'new_operator' can be used as a type-preserving replacement in a '*'
@@ -107,8 +107,8 @@
     }
 }
 
-bool CanReplaceDivideOrModuloWith(const type::Type* lhs_type,
-                                  const type::Type* rhs_type,
+bool CanReplaceDivideOrModuloWith(const core::type::Type* lhs_type,
+                                  const core::type::Type* rhs_type,
                                   core::BinaryOp new_operator) {
     // The program is assumed to be well-typed, so this method determines when
     // 'new_operator' can be used as a type-preserving replacement in a '/'
@@ -149,8 +149,8 @@
     }
 }
 
-bool CanReplaceAndOrWith(const type::Type* lhs_type,
-                         const type::Type* rhs_type,
+bool CanReplaceAndOrWith(const core::type::Type* lhs_type,
+                         const core::type::Type* rhs_type,
                          core::BinaryOp new_operator) {
     switch (new_operator) {
         case core::BinaryOp::kAnd:
@@ -173,7 +173,7 @@
         case core::BinaryOp::kLogicalOr:
             // '&' and '|' can be applied to booleans, and for boolean scalar
             // scalar contexts, their logical counterparts work.
-            return lhs_type->Is<type::Bool>();
+            return lhs_type->Is<core::type::Bool>();
         case core::BinaryOp::kEqual:
         case core::BinaryOp::kNotEqual:
             // '&' and '|' can be applied to booleans, and in these contexts equality
@@ -184,8 +184,8 @@
     }
 }
 
-bool CanReplaceXorWith(const type::Type* lhs_type,
-                       const type::Type* rhs_type,
+bool CanReplaceXorWith(const core::type::Type* lhs_type,
+                       const core::type::Type* rhs_type,
                        core::BinaryOp new_operator) {
     switch (new_operator) {
         case core::BinaryOp::kAdd:
@@ -207,8 +207,8 @@
     }
 }
 
-bool CanReplaceShiftLeftShiftRightWith(const type::Type* lhs_type,
-                                       const type::Type* rhs_type,
+bool CanReplaceShiftLeftShiftRightWith(const core::type::Type* lhs_type,
+                                       const core::type::Type* rhs_type,
                                        core::BinaryOp new_operator) {
     switch (new_operator) {
         case core::BinaryOp::kShiftLeft:
@@ -232,7 +232,7 @@
     }
 }
 
-bool CanReplaceEqualNotEqualWith(const type::Type* lhs_type, core::BinaryOp new_operator) {
+bool CanReplaceEqualNotEqualWith(const core::type::Type* lhs_type, core::BinaryOp new_operator) {
     switch (new_operator) {
         case core::BinaryOp::kEqual:
         case core::BinaryOp::kNotEqual:
@@ -249,7 +249,7 @@
         case core::BinaryOp::kLogicalOr:
             // An equality comparison between boolean scalars can be turned into a
             // logical operation.
-            return lhs_type->Is<type::Bool>();
+            return lhs_type->Is<core::type::Bool>();
         case core::BinaryOp::kAnd:
         case core::BinaryOp::kOr:
             // An equality comparison between boolean scalars or vectors can be turned
@@ -301,10 +301,12 @@
     const auto* rhs_type = program.Sem().GetVal(binary_expr.rhs)->Type();
 
     // If these are reference types, unwrap them to get the pointee type.
-    const type::Type* lhs_basic_type =
-        lhs_type->Is<type::Reference>() ? lhs_type->As<type::Reference>()->StoreType() : lhs_type;
-    const type::Type* rhs_basic_type =
-        rhs_type->Is<type::Reference>() ? rhs_type->As<type::Reference>()->StoreType() : rhs_type;
+    const core::type::Type* lhs_basic_type =
+        lhs_type->Is<core::type::Reference>() ? lhs_type->As<core::type::Reference>()->StoreType()
+                                              : lhs_type;
+    const core::type::Type* rhs_basic_type =
+        rhs_type->Is<core::type::Reference>() ? rhs_type->As<core::type::Reference>()->StoreType()
+                                              : rhs_type;
 
     switch (binary_expr.op) {
         case core::BinaryOp::kAdd:
diff --git a/src/tint/fuzzers/tint_ast_fuzzer/mutations/change_unary_operator.cc b/src/tint/fuzzers/tint_ast_fuzzer/mutations/change_unary_operator.cc
index e17661a..838125c 100644
--- a/src/tint/fuzzers/tint_ast_fuzzer/mutations/change_unary_operator.cc
+++ b/src/tint/fuzzers/tint_ast_fuzzer/mutations/change_unary_operator.cc
@@ -48,7 +48,7 @@
     // Get the type of the unary expression.
     const auto* type = program.Sem().Get(unary_expr_node)->Type();
     const auto* basic_type =
-        type->Is<type::Reference>() ? type->As<type::Reference>()->StoreType() : type;
+        type->Is<core::type::Reference>() ? type->As<core::type::Reference>()->StoreType() : type;
 
     // Only signed integer or vector of signed integer has more than 1
     // unary operators to change between.
diff --git a/src/tint/fuzzers/tint_common_fuzzer.cc b/src/tint/fuzzers/tint_common_fuzzer.cc
index 7be9578..d7d4ace 100644
--- a/src/tint/fuzzers/tint_common_fuzzer.cc
+++ b/src/tint/fuzzers/tint_common_fuzzer.cc
@@ -246,7 +246,7 @@
                     auto& n = group_to_next_binding_number[bp->group];
                     n = std::max(n, bp->binding + 1);
 
-                    if (sem_var->Type()->UnwrapRef()->Is<type::ExternalTexture>()) {
+                    if (sem_var->Type()->UnwrapRef()->Is<core::type::ExternalTexture>()) {
                         ext_tex_bps.emplace_back(*bp);
                     }
                 }
diff --git a/src/tint/lang/core/constant/clone_context.h b/src/tint/lang/core/constant/clone_context.h
index 1556613..3a61e7e 100644
--- a/src/tint/lang/core/constant/clone_context.h
+++ b/src/tint/lang/core/constant/clone_context.h
@@ -27,7 +27,7 @@
 /// Context information for cloning of constants
 struct CloneContext {
     /// The context for cloning type information
-    type::CloneContext type_ctx;
+    core::type::CloneContext type_ctx;
 
     /// Destination information
     constant::Manager& dst;
diff --git a/src/tint/lang/core/constant/composite.cc b/src/tint/lang/core/constant/composite.cc
index 05f4604..d13ba7d 100644
--- a/src/tint/lang/core/constant/composite.cc
+++ b/src/tint/lang/core/constant/composite.cc
@@ -22,7 +22,7 @@
 
 namespace tint::core::constant {
 
-Composite::Composite(const type::Type* t, VectorRef<const Value*> els, bool all_0, bool any_0)
+Composite::Composite(const core::type::Type* t, VectorRef<const Value*> els, bool all_0, bool any_0)
     : type(t), elements(std::move(els)), all_zero(all_0), any_zero(any_0), hash(CalcHash()) {
     TINT_ASSERT(!elements.IsEmpty());
 }
diff --git a/src/tint/lang/core/constant/composite.h b/src/tint/lang/core/constant/composite.h
index 6af48f8..b749c70 100644
--- a/src/tint/lang/core/constant/composite.h
+++ b/src/tint/lang/core/constant/composite.h
@@ -35,11 +35,11 @@
     /// @param els the composite elements
     /// @param all_0 true if all elements are 0
     /// @param any_0 true if any element is 0
-    Composite(const type::Type* t, VectorRef<const Value*> els, bool all_0, bool any_0);
+    Composite(const core::type::Type* t, VectorRef<const Value*> els, bool all_0, bool any_0);
     ~Composite() override;
 
     /// @copydoc Value::Type()
-    const type::Type* Type() const override { return type; }
+    const core::type::Type* Type() const override { return type; }
 
     /// @copydoc Value::Index()
     const Value* Index(size_t i) const override {
@@ -64,7 +64,7 @@
     const Composite* Clone(CloneContext& ctx) const override;
 
     /// The composite type
-    type::Type const* const type;
+    core::type::Type const* const type;
     /// The composite elements
     const Vector<const Value*, 4> elements;
     /// True if all elements are zero
diff --git a/src/tint/lang/core/constant/composite_test.cc b/src/tint/lang/core/constant/composite_test.cc
index 5ffeb63..2f2bb10 100644
--- a/src/tint/lang/core/constant/composite_test.cc
+++ b/src/tint/lang/core/constant/composite_test.cc
@@ -25,7 +25,7 @@
 using ConstantTest_Composite = TestHelper;
 
 TEST_F(ConstantTest_Composite, AllZero) {
-    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
+    auto* vec3f = create<core::type::Vector>(create<core::type::F32>(), 3u);
 
     auto* fPos0 = constants.Get(0_f);
     auto* fNeg0 = constants.Get(-0_f);
@@ -41,7 +41,7 @@
 }
 
 TEST_F(ConstantTest_Composite, AnyZero) {
-    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
+    auto* vec3f = create<core::type::Vector>(create<core::type::F32>(), 3u);
 
     auto* fPos0 = constants.Get(0_f);
     auto* fNeg0 = constants.Get(-0_f);
@@ -57,7 +57,7 @@
 }
 
 TEST_F(ConstantTest_Composite, Index) {
-    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
+    auto* vec3f = create<core::type::Vector>(create<core::type::F32>(), 3u);
 
     auto* fPos0 = constants.Get(0_f);
     auto* fPos1 = constants.Get(1_f);
@@ -75,7 +75,7 @@
 }
 
 TEST_F(ConstantTest_Composite, Clone) {
-    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
+    auto* vec3f = create<core::type::Vector>(create<core::type::F32>(), 3u);
 
     auto* fPos0 = constants.Get(0_f);
     auto* fPos1 = constants.Get(1_f);
@@ -83,11 +83,11 @@
     auto* composite = constants.Composite(vec3f, Vector{fPos1, fPos0});
 
     constant::Manager mgr;
-    constant::CloneContext ctx{type::CloneContext{{nullptr}, {nullptr, &mgr.types}}, mgr};
+    constant::CloneContext ctx{core::type::CloneContext{{nullptr}, {nullptr, &mgr.types}}, mgr};
 
     auto* r = composite->As<Composite>()->Clone(ctx);
     ASSERT_NE(r, nullptr);
-    EXPECT_TRUE(r->type->Is<type::Vector>());
+    EXPECT_TRUE(r->type->Is<core::type::Vector>());
     EXPECT_FALSE(r->all_zero);
     EXPECT_TRUE(r->any_zero);
     ASSERT_EQ(r->elements.Length(), 2u);
diff --git a/src/tint/lang/core/constant/eval.cc b/src/tint/lang/core/constant/eval.cc
index 5ef8af3..daac5a9 100644
--- a/src/tint/lang/core/constant/eval.cc
+++ b/src/tint/lang/core/constant/eval.cc
@@ -63,8 +63,8 @@
 auto Dispatch_iu32(F&& f, CONSTANTS&&... cs) {
     return Switch(
         First(cs...)->Type(),  //
-        [&](const type::I32*) { return f(cs->template ValueAs<i32>()...); },
-        [&](const type::U32*) { return f(cs->template ValueAs<u32>()...); });
+        [&](const core::type::I32*) { return f(cs->template ValueAs<i32>()...); },
+        [&](const core::type::U32*) { return f(cs->template ValueAs<u32>()...); });
 }
 
 /// Helper that calls `f` passing in the value of all `cs`.
@@ -73,9 +73,9 @@
 auto Dispatch_ia_iu32(F&& f, CONSTANTS&&... cs) {
     return Switch(
         First(cs...)->Type(),  //
-        [&](const type::AbstractInt*) { return f(cs->template ValueAs<AInt>()...); },
-        [&](const type::I32*) { return f(cs->template ValueAs<i32>()...); },
-        [&](const type::U32*) { return f(cs->template ValueAs<u32>()...); });
+        [&](const core::type::AbstractInt*) { return f(cs->template ValueAs<AInt>()...); },
+        [&](const core::type::I32*) { return f(cs->template ValueAs<i32>()...); },
+        [&](const core::type::U32*) { return f(cs->template ValueAs<u32>()...); });
 }
 
 /// Helper that calls `f` passing in the value of all `cs`.
@@ -84,10 +84,10 @@
 auto Dispatch_ia_iu32_bool(F&& f, CONSTANTS&&... cs) {
     return Switch(
         First(cs...)->Type(),  //
-        [&](const type::AbstractInt*) { return f(cs->template ValueAs<AInt>()...); },
-        [&](const type::I32*) { return f(cs->template ValueAs<i32>()...); },
-        [&](const type::U32*) { return f(cs->template ValueAs<u32>()...); },
-        [&](const type::Bool*) { return f(cs->template ValueAs<bool>()...); });
+        [&](const core::type::AbstractInt*) { return f(cs->template ValueAs<AInt>()...); },
+        [&](const core::type::I32*) { return f(cs->template ValueAs<i32>()...); },
+        [&](const core::type::U32*) { return f(cs->template ValueAs<u32>()...); },
+        [&](const core::type::Bool*) { return f(cs->template ValueAs<bool>()...); });
 }
 
 /// Helper that calls `f` passing in the value of all `cs`.
@@ -96,11 +96,11 @@
 auto Dispatch_fia_fi32_f16(F&& f, CONSTANTS&&... cs) {
     return Switch(
         First(cs...)->Type(),  //
-        [&](const type::AbstractInt*) { return f(cs->template ValueAs<AInt>()...); },
-        [&](const type::AbstractFloat*) { return f(cs->template ValueAs<AFloat>()...); },
-        [&](const type::F32*) { return f(cs->template ValueAs<f32>()...); },
-        [&](const type::I32*) { return f(cs->template ValueAs<i32>()...); },
-        [&](const type::F16*) { return f(cs->template ValueAs<f16>()...); });
+        [&](const core::type::AbstractInt*) { return f(cs->template ValueAs<AInt>()...); },
+        [&](const core::type::AbstractFloat*) { return f(cs->template ValueAs<AFloat>()...); },
+        [&](const core::type::F32*) { return f(cs->template ValueAs<f32>()...); },
+        [&](const core::type::I32*) { return f(cs->template ValueAs<i32>()...); },
+        [&](const core::type::F16*) { return f(cs->template ValueAs<f16>()...); });
 }
 
 /// Helper that calls `f` passing in the value of all `cs`.
@@ -109,12 +109,12 @@
 auto Dispatch_fia_fiu32_f16(F&& f, CONSTANTS&&... cs) {
     return Switch(
         First(cs...)->Type(),  //
-        [&](const type::AbstractInt*) { return f(cs->template ValueAs<AInt>()...); },
-        [&](const type::AbstractFloat*) { return f(cs->template ValueAs<AFloat>()...); },
-        [&](const type::F32*) { return f(cs->template ValueAs<f32>()...); },
-        [&](const type::I32*) { return f(cs->template ValueAs<i32>()...); },
-        [&](const type::U32*) { return f(cs->template ValueAs<u32>()...); },
-        [&](const type::F16*) { return f(cs->template ValueAs<f16>()...); });
+        [&](const core::type::AbstractInt*) { return f(cs->template ValueAs<AInt>()...); },
+        [&](const core::type::AbstractFloat*) { return f(cs->template ValueAs<AFloat>()...); },
+        [&](const core::type::F32*) { return f(cs->template ValueAs<f32>()...); },
+        [&](const core::type::I32*) { return f(cs->template ValueAs<i32>()...); },
+        [&](const core::type::U32*) { return f(cs->template ValueAs<u32>()...); },
+        [&](const core::type::F16*) { return f(cs->template ValueAs<f16>()...); });
 }
 
 /// Helper that calls `f` passing in the value of all `cs`.
@@ -123,13 +123,13 @@
 auto Dispatch_fia_fiu32_f16_bool(F&& f, CONSTANTS&&... cs) {
     return Switch(
         First(cs...)->Type(),  //
-        [&](const type::AbstractInt*) { return f(cs->template ValueAs<AInt>()...); },
-        [&](const type::AbstractFloat*) { return f(cs->template ValueAs<AFloat>()...); },
-        [&](const type::F32*) { return f(cs->template ValueAs<f32>()...); },
-        [&](const type::I32*) { return f(cs->template ValueAs<i32>()...); },
-        [&](const type::U32*) { return f(cs->template ValueAs<u32>()...); },
-        [&](const type::F16*) { return f(cs->template ValueAs<f16>()...); },
-        [&](const type::Bool*) { return f(cs->template ValueAs<bool>()...); });
+        [&](const core::type::AbstractInt*) { return f(cs->template ValueAs<AInt>()...); },
+        [&](const core::type::AbstractFloat*) { return f(cs->template ValueAs<AFloat>()...); },
+        [&](const core::type::F32*) { return f(cs->template ValueAs<f32>()...); },
+        [&](const core::type::I32*) { return f(cs->template ValueAs<i32>()...); },
+        [&](const core::type::U32*) { return f(cs->template ValueAs<u32>()...); },
+        [&](const core::type::F16*) { return f(cs->template ValueAs<f16>()...); },
+        [&](const core::type::Bool*) { return f(cs->template ValueAs<bool>()...); });
 }
 
 /// Helper that calls `f` passing in the value of all `cs`.
@@ -138,9 +138,9 @@
 auto Dispatch_fa_f32_f16(F&& f, CONSTANTS&&... cs) {
     return Switch(
         First(cs...)->Type(),  //
-        [&](const type::AbstractFloat*) { return f(cs->template ValueAs<AFloat>()...); },
-        [&](const type::F32*) { return f(cs->template ValueAs<f32>()...); },
-        [&](const type::F16*) { return f(cs->template ValueAs<f16>()...); });
+        [&](const core::type::AbstractFloat*) { return f(cs->template ValueAs<AFloat>()...); },
+        [&](const core::type::F32*) { return f(cs->template ValueAs<f32>()...); },
+        [&](const core::type::F16*) { return f(cs->template ValueAs<f16>()...); });
 }
 
 /// Helper that calls `f` passing in the value of all `cs`.
@@ -151,23 +151,23 @@
 }
 
 /// ZeroTypeDispatch is a helper for calling the function `f`, passing a single zero-value argument
-/// of the C++ type that corresponds to the type::Type `type`. For example, calling
+/// of the C++ type that corresponds to the core::type::Type `type`. For example, calling
 /// `ZeroTypeDispatch()` with a type of `type::I32*` will call the function f with a single argument
 /// of `i32(0)`.
 /// @returns the value returned by calling `f`.
 /// @note `type` must be a scalar or abstract numeric type. Other types will not call `f`, and will
 /// return the zero-initialized value of the return type for `f`.
 template <typename F>
-auto ZeroTypeDispatch(const type::Type* type, F&& f) {
+auto ZeroTypeDispatch(const core::type::Type* type, F&& f) {
     return Switch(
-        type,                                                      //
-        [&](const type::AbstractInt*) { return f(AInt(0)); },      //
-        [&](const type::AbstractFloat*) { return f(AFloat(0)); },  //
-        [&](const type::I32*) { return f(i32(0)); },               //
-        [&](const type::U32*) { return f(u32(0)); },               //
-        [&](const type::F32*) { return f(f32(0)); },               //
-        [&](const type::F16*) { return f(f16(0)); },               //
-        [&](const type::Bool*) { return f(static_cast<bool>(0)); });
+        type,                                                            //
+        [&](const core::type::AbstractInt*) { return f(AInt(0)); },      //
+        [&](const core::type::AbstractFloat*) { return f(AFloat(0)); },  //
+        [&](const core::type::I32*) { return f(i32(0)); },               //
+        [&](const core::type::U32*) { return f(u32(0)); },               //
+        [&](const core::type::F32*) { return f(f32(0)); },               //
+        [&](const core::type::F16*) { return f(f16(0)); },               //
+        [&](const core::type::Bool*) { return f(static_cast<bool>(0)); });
 }
 
 template <typename NumberT>
@@ -240,7 +240,7 @@
 /// @returns the converted scalar, or nullptr on error.
 template <typename T>
 const ScalarBase* ScalarConvert(const Scalar<T>* scalar,
-                                const type::Type* target_ty,
+                                const core::type::Type* target_ty,
                                 ConvertContext& ctx) {
     TINT_BEGIN_DISABLE_WARNING(UNREACHABLE_CODE);
     if (target_ty == scalar->type) {
@@ -317,19 +317,19 @@
 /// Converts the constant value to the target type.
 /// @returns the converted value, or nullptr on error.
 const Value* ConvertInternal(const Value* root_value,
-                             const type::Type* root_target_ty,
+                             const core::type::Type* root_target_ty,
                              ConvertContext& ctx) {
     struct ActionConvert {
         const Value* value = nullptr;
-        const type::Type* target_ty = nullptr;
+        const core::type::Type* target_ty = nullptr;
     };
     struct ActionBuildSplat {
         size_t count = 0;
-        const type::Type* type = nullptr;
+        const core::type::Type* type = nullptr;
     };
     struct ActionBuildComposite {
         size_t count = 0;
-        const type::Type* type = nullptr;
+        const core::type::Type* type = nullptr;
     };
     using Action = std::variant<ActionConvert, ActionBuildSplat, ActionBuildComposite>;
 
@@ -398,8 +398,8 @@
                 return true;
             },
             [&](const Splat* splat) {
-                const type::Type* target_el_ty = nullptr;
-                if (auto* str = convert->target_ty->As<type::Struct>()) {
+                const core::type::Type* target_el_ty = nullptr;
+                if (auto* str = convert->target_ty->As<core::type::Struct>()) {
                     // Structure conversion.
                     auto members = str->Members();
                     target_el_ty = members[0]->Type();
@@ -429,7 +429,7 @@
                 // Build the new composite from the converted element types.
                 pending.Push(ActionBuildComposite{el_count, convert->target_ty});
 
-                if (auto* str = convert->target_ty->As<type::Struct>()) {
+                if (auto* str = convert->target_ty->As<core::type::Struct>()) {
                     if (TINT_UNLIKELY(str->Members().Length() != el_count)) {
                         TINT_ICE()
                             << "const-eval conversion of structure has mismatched element counts";
@@ -464,7 +464,7 @@
 /// Implementation of TransformElements
 template <typename F, typename... CONSTANTS>
 Eval::Result TransformElements(Manager& mgr,
-                               const type::Type* composite_ty,
+                               const core::type::Type* composite_ty,
                                F&& f,
                                size_t index,
                                CONSTANTS&&... cs) {
@@ -503,7 +503,7 @@
 /// the most deeply nested aggregate type will be passed in.
 template <typename F, typename... CONSTANTS>
 Eval::Result TransformElements(Manager& mgr,
-                               const type::Type* composite_ty,
+                               const core::type::Type* composite_ty,
                                F&& f,
                                CONSTANTS&&... cs) {
     return detail::TransformElements(mgr, composite_ty, f, 0, cs...);
@@ -515,7 +515,7 @@
 /// vector-scalar, scalar-vector.
 template <typename F>
 Eval::Result TransformBinaryElements(Manager& mgr,
-                                     const type::Type* composite_ty,
+                                     const core::type::Type* composite_ty,
                                      F&& f,
                                      const Value* c0,
                                      const Value* c1) {
@@ -553,9 +553,9 @@
     : mgr(manager), diags(diagnostics), use_runtime_semantics_(use_runtime_semantics) {}
 
 template <typename T>
-Eval::Result Eval::CreateScalar(const Source& source, const type::Type* t, T v) {
+Eval::Result Eval::CreateScalar(const Source& source, const core::type::Type* t, T v) {
     static_assert(IsNumber<T> || std::is_same_v<T, bool>, "T must be a Number or bool");
-    TINT_ASSERT(t->Is<type::Scalar>());
+    TINT_ASSERT(t->Is<core::type::Scalar>());
 
     if constexpr (IsFloatingPoint<T>) {
         if (!std::isfinite(v.value)) {
@@ -570,18 +570,18 @@
     return mgr.Get<Scalar<T>>(t, v);
 }
 
-const Value* Eval::ZeroValue(const type::Type* type) {
+const Value* Eval::ZeroValue(const core::type::Type* type) {
     return Switch(
         type,  //
-        [&](const type::Vector* v) -> const Value* {
+        [&](const core::type::Vector* v) -> const Value* {
             auto* zero_el = ZeroValue(v->type());
             return mgr.Splat(type, zero_el, v->Width());
         },
-        [&](const type::Matrix* m) -> const Value* {
+        [&](const core::type::Matrix* m) -> const Value* {
             auto* zero_el = ZeroValue(m->ColumnType());
             return mgr.Splat(type, zero_el, m->columns());
         },
-        [&](const type::Array* a) -> const Value* {
+        [&](const core::type::Array* a) -> const Value* {
             if (auto n = a->ConstantCount()) {
                 if (auto* zero_el = ZeroValue(a->ElemType())) {
                     return mgr.Splat(type, zero_el, n.value());
@@ -589,8 +589,8 @@
             }
             return nullptr;
         },
-        [&](const type::Struct* s) -> const Value* {
-            Hashmap<const type::Type*, const Value*, 8> zero_by_type;
+        [&](const core::type::Struct* s) -> const Value* {
+            Hashmap<const core::type::Type*, const Value*, 8> zero_by_type;
             Vector<const Value*, 4> zeros;
             zeros.Reserve(s->Members().Length());
             for (auto* member : s->Members()) {
@@ -1047,7 +1047,7 @@
     return NumberT{std::sqrt(v)};
 }
 
-auto Eval::SqrtFunc(const Source& source, const type::Type* elem_ty) {
+auto Eval::SqrtFunc(const Source& source, const core::type::Type* elem_ty) {
     return [=](auto v) -> Eval::Result {
         if (auto r = Sqrt(source, v)) {
             return CreateScalar(source, elem_ty, r.Get());
@@ -1069,7 +1069,7 @@
     return NumberT{std::min(std::max(e, low), high)};
 }
 
-auto Eval::ClampFunc(const Source& source, const type::Type* elem_ty) {
+auto Eval::ClampFunc(const Source& source, const core::type::Type* elem_ty) {
     return [=](auto e, auto low, auto high) -> Eval::Result {
         if (auto r = Clamp(source, e, low, high)) {
             return CreateScalar(source, elem_ty, r.Get());
@@ -1078,7 +1078,7 @@
     };
 }
 
-auto Eval::AddFunc(const Source& source, const type::Type* elem_ty) {
+auto Eval::AddFunc(const Source& source, const core::type::Type* elem_ty) {
     return [=](auto a1, auto a2) -> Eval::Result {
         if (auto r = Add(source, a1, a2)) {
             return CreateScalar(source, elem_ty, r.Get());
@@ -1087,7 +1087,7 @@
     };
 }
 
-auto Eval::SubFunc(const Source& source, const type::Type* elem_ty) {
+auto Eval::SubFunc(const Source& source, const core::type::Type* elem_ty) {
     return [=](auto a1, auto a2) -> Eval::Result {
         if (auto r = Sub(source, a1, a2)) {
             return CreateScalar(source, elem_ty, r.Get());
@@ -1096,7 +1096,7 @@
     };
 }
 
-auto Eval::MulFunc(const Source& source, const type::Type* elem_ty) {
+auto Eval::MulFunc(const Source& source, const core::type::Type* elem_ty) {
     return [=](auto a1, auto a2) -> Eval::Result {
         if (auto r = Mul(source, a1, a2)) {
             return CreateScalar(source, elem_ty, r.Get());
@@ -1105,7 +1105,7 @@
     };
 }
 
-auto Eval::DivFunc(const Source& source, const type::Type* elem_ty) {
+auto Eval::DivFunc(const Source& source, const core::type::Type* elem_ty) {
     return [=](auto a1, auto a2) -> Eval::Result {
         if (auto r = Div(source, a1, a2)) {
             return CreateScalar(source, elem_ty, r.Get());
@@ -1114,7 +1114,7 @@
     };
 }
 
-auto Eval::ModFunc(const Source& source, const type::Type* elem_ty) {
+auto Eval::ModFunc(const Source& source, const core::type::Type* elem_ty) {
     return [=](auto a1, auto a2) -> Eval::Result {
         if (auto r = Mod(source, a1, a2)) {
             return CreateScalar(source, elem_ty, r.Get());
@@ -1123,7 +1123,7 @@
     };
 }
 
-auto Eval::Dot2Func(const Source& source, const type::Type* elem_ty) {
+auto Eval::Dot2Func(const Source& source, const core::type::Type* elem_ty) {
     return [=](auto a1, auto a2, auto b1, auto b2) -> Eval::Result {
         if (auto r = Dot2(source, a1, a2, b1, b2)) {
             return CreateScalar(source, elem_ty, r.Get());
@@ -1132,7 +1132,7 @@
     };
 }
 
-auto Eval::Dot3Func(const Source& source, const type::Type* elem_ty) {
+auto Eval::Dot3Func(const Source& source, const core::type::Type* elem_ty) {
     return [=](auto a1, auto a2, auto a3, auto b1, auto b2, auto b3) -> Eval::Result {
         if (auto r = Dot3(source, a1, a2, a3, b1, b2, b3)) {
             return CreateScalar(source, elem_ty, r.Get());
@@ -1141,7 +1141,7 @@
     };
 }
 
-auto Eval::Dot4Func(const Source& source, const type::Type* elem_ty) {
+auto Eval::Dot4Func(const Source& source, const core::type::Type* elem_ty) {
     return [=](auto a1, auto a2, auto a3, auto a4, auto b1, auto b2, auto b3,
                auto b4) -> Eval::Result {
         if (auto r = Dot4(source, a1, a2, a3, a4, b1, b2, b3, b4)) {
@@ -1152,7 +1152,7 @@
 }
 
 Eval::Result Eval::Dot(const Source& source, const Value* v1, const Value* v2) {
-    auto* vec_ty = v1->Type()->As<type::Vector>();
+    auto* vec_ty = v1->Type()->As<core::type::Vector>();
     TINT_ASSERT(vec_ty);
     auto* elem_ty = vec_ty->type();
     switch (vec_ty->Width()) {
@@ -1176,8 +1176,8 @@
     return Failure;
 }
 
-Eval::Result Eval::Length(const Source& source, const type::Type* ty, const Value* c0) {
-    auto* vec_ty = c0->Type()->As<type::Vector>();
+Eval::Result Eval::Length(const Source& source, const core::type::Type* ty, const Value* c0) {
+    auto* vec_ty = c0->Type()->As<core::type::Vector>();
     // Evaluates to the absolute value of e if T is scalar.
     if (vec_ty == nullptr) {
         auto create = [&](auto e) {
@@ -1196,7 +1196,7 @@
 }
 
 Eval::Result Eval::Mul(const Source& source,
-                       const type::Type* ty,
+                       const core::type::Type* ty,
                        const Value* v1,
                        const Value* v2) {
     auto transform = [&](const Value* c0, const Value* c1) {
@@ -1206,7 +1206,7 @@
 }
 
 Eval::Result Eval::Sub(const Source& source,
-                       const type::Type* ty,
+                       const core::type::Type* ty,
                        const Value* v1,
                        const Value* v2) {
     auto transform = [&](const Value* c0, const Value* c1) {
@@ -1215,7 +1215,7 @@
     return TransformBinaryElements(mgr, ty, transform, v1, v2);
 }
 
-auto Eval::Det2Func(const Source& source, const type::Type* elem_ty) {
+auto Eval::Det2Func(const Source& source, const core::type::Type* elem_ty) {
     return [=](auto a, auto b, auto c, auto d) -> Eval::Result {
         if (auto r = Det2(source, a, b, c, d)) {
             return CreateScalar(source, elem_ty, r.Get());
@@ -1224,7 +1224,7 @@
     };
 }
 
-auto Eval::Det3Func(const Source& source, const type::Type* elem_ty) {
+auto Eval::Det3Func(const Source& source, const core::type::Type* elem_ty) {
     return [=](auto a, auto b, auto c, auto d, auto e, auto f, auto g, auto h,
                auto i) -> Eval::Result {
         if (auto r = Det3(source, a, b, c, d, e, f, g, h, i)) {
@@ -1234,7 +1234,7 @@
     };
 }
 
-auto Eval::Det4Func(const Source& source, const type::Type* elem_ty) {
+auto Eval::Det4Func(const Source& source, const core::type::Type* elem_ty) {
     return [=](auto a, auto b, auto c, auto d, auto e, auto f, auto g, auto h, auto i, auto j,
                auto k, auto l, auto m, auto n, auto o, auto p) -> Eval::Result {
         if (auto r = Det4(source, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)) {
@@ -1244,7 +1244,7 @@
     };
 }
 
-Eval::Result Eval::ArrayOrStructCtor(const type::Type* ty, VectorRef<const Value*> args) {
+Eval::Result Eval::ArrayOrStructCtor(const core::type::Type* ty, VectorRef<const Value*> args) {
     if (args.IsEmpty()) {
         return ZeroValue(ty);
     }
@@ -1258,7 +1258,9 @@
     return mgr.Composite(ty, std::move(args));
 }
 
-Eval::Result Eval::Conv(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::Conv(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source) {
     auto* el_ty = ty->Elements(ty).type;
     if (!el_ty) {
         return nullptr;
@@ -1271,26 +1273,32 @@
     return Convert(ty, args[0], source);
 }
 
-Eval::Result Eval::Zero(const type::Type* ty, VectorRef<const Value*>, const Source&) {
+Eval::Result Eval::Zero(const core::type::Type* ty, VectorRef<const Value*>, const Source&) {
     return ZeroValue(ty);
 }
 
-Eval::Result Eval::Identity(const type::Type*, VectorRef<const Value*> args, const Source&) {
+Eval::Result Eval::Identity(const core::type::Type*, VectorRef<const Value*> args, const Source&) {
     return args[0];
 }
 
-Eval::Result Eval::VecSplat(const type::Type* ty, VectorRef<const Value*> args, const Source&) {
+Eval::Result Eval::VecSplat(const core::type::Type* ty,
+                            VectorRef<const Value*> args,
+                            const Source&) {
     if (auto* arg = args[0]) {
-        return mgr.Splat(ty, arg, static_cast<const type::Vector*>(ty)->Width());
+        return mgr.Splat(ty, arg, static_cast<const core::type::Vector*>(ty)->Width());
     }
     return nullptr;
 }
 
-Eval::Result Eval::VecInitS(const type::Type* ty, VectorRef<const Value*> args, const Source&) {
+Eval::Result Eval::VecInitS(const core::type::Type* ty,
+                            VectorRef<const Value*> args,
+                            const Source&) {
     return mgr.Composite(ty, args);
 }
 
-Eval::Result Eval::VecInitM(const type::Type* ty, VectorRef<const Value*> args, const Source&) {
+Eval::Result Eval::VecInitM(const core::type::Type* ty,
+                            VectorRef<const Value*> args,
+                            const Source&) {
     Vector<const Value*, 4> els;
     for (auto* arg : args) {
         auto* val = arg;
@@ -1298,7 +1306,7 @@
             return nullptr;
         }
         auto* arg_ty = arg->Type();
-        if (auto* arg_vec = arg_ty->As<type::Vector>()) {
+        if (auto* arg_vec = arg_ty->As<core::type::Vector>()) {
             // Extract out vector elements.
             for (uint32_t j = 0; j < arg_vec->Width(); j++) {
                 auto* el = val->Index(j);
@@ -1314,8 +1322,10 @@
     return mgr.Composite(ty, std::move(els));
 }
 
-Eval::Result Eval::MatInitS(const type::Type* ty, VectorRef<const Value*> args, const Source&) {
-    auto* m = static_cast<const type::Matrix*>(ty);
+Eval::Result Eval::MatInitS(const core::type::Type* ty,
+                            VectorRef<const Value*> args,
+                            const Source&) {
+    auto* m = static_cast<const core::type::Matrix*>(ty);
 
     Vector<const Value*, 4> els;
     for (uint32_t c = 0; c < m->columns(); c++) {
@@ -1329,12 +1339,14 @@
     return mgr.Composite(ty, std::move(els));
 }
 
-Eval::Result Eval::MatInitV(const type::Type* ty, VectorRef<const Value*> args, const Source&) {
+Eval::Result Eval::MatInitV(const core::type::Type* ty,
+                            VectorRef<const Value*> args,
+                            const Source&) {
     return mgr.Composite(ty, args);
 }
 
 Eval::Result Eval::Index(const Value* obj_val,
-                         const type::Type* obj_ty,
+                         const core::type::Type* obj_ty,
                          const Value* idx_val,
                          const Source& idx_source) {
     auto el = obj_ty->UnwrapRef()->Elements();
@@ -1356,7 +1368,9 @@
     return obj_val ? obj_val->Index(static_cast<size_t>(idx)) : nullptr;
 }
 
-Eval::Result Eval::Swizzle(const type::Type* ty, const Value* object, VectorRef<uint32_t> indices) {
+Eval::Result Eval::Swizzle(const core::type::Type* ty,
+                           const Value* object,
+                           VectorRef<uint32_t> indices) {
     if (indices.Length() == 1) {
         return object->Index(static_cast<size_t>(indices[0]));
     }
@@ -1365,7 +1379,7 @@
     return mgr.Composite(ty, std::move(values));
 }
 
-Eval::Result Eval::Bitcast(const type::Type* ty, const Value* value, const Source& source) {
+Eval::Result Eval::Bitcast(const core::type::Type* ty, const Value* value, const Source& source) {
     // Target type
     auto dst_elements = ty->Elements(ty->DeepestElement(), 1u);
     auto dst_el_ty = dst_elements.type;
@@ -1382,7 +1396,8 @@
     buffer.Reserve(total_bitwidth);
 
     // Ensure elements are of 32-bit or 16-bit numerical scalar type.
-    TINT_ASSERT((src_el_ty->IsAnyOf<type::F32, type::I32, type::U32, type::F16>()));
+    TINT_ASSERT(
+        (src_el_ty->IsAnyOf<core::type::F32, core::type::I32, core::type::U32, core::type::F16>()));
     // Pushes bits from source value into the buffer.
     auto push_src_element_bits = [&](const Value* element) {
         auto push_32_bits = [&](uint32_t v) {
@@ -1397,19 +1412,19 @@
         };
         Switch(
             src_el_ty,
-            [&](const type::U32*) {  //
+            [&](const core::type::U32*) {  //
                 uint32_t r = element->ValueAs<u32>();
                 push_32_bits(r);
             },
-            [&](const type::I32*) {  //
+            [&](const core::type::I32*) {  //
                 uint32_t r = tint::Bitcast<u32>(element->ValueAs<i32>());
                 push_32_bits(r);
             },
-            [&](const type::F32*) {  //
+            [&](const core::type::F32*) {  //
                 uint32_t r = tint::Bitcast<u32>(element->ValueAs<f32>());
                 push_32_bits(r);
             },
-            [&](const type::F16*) {  //
+            [&](const core::type::F16*) {  //
                 uint16_t r = element->ValueAs<f16>().BitsRepresentation();
                 push_16_bits(r);
             });
@@ -1441,28 +1456,28 @@
 
         return Switch(
             dst_el_ty,
-            [&](const type::U32*) {  //
+            [&](const core::type::U32*) {  //
                 auto r = CreateScalar(source, dst_el_ty, u32(v));
                 if (r) {
                     els.Push(r.Get());
                 }
                 return r;
             },
-            [&](const type::I32*) {  //
+            [&](const core::type::I32*) {  //
                 auto r = CreateScalar(source, dst_el_ty, tint::Bitcast<i32>(v));
                 if (r) {
                     els.Push(r.Get());
                 }
                 return r;
             },
-            [&](const type::F32*) {  //
+            [&](const core::type::F32*) {  //
                 auto r = CreateScalar(source, dst_el_ty, tint::Bitcast<f32>(v));
                 if (r) {
                     els.Push(r.Get());
                 }
                 return r;
             },
-            [&](const type::F16*) {  //
+            [&](const core::type::F16*) {  //
                 auto r = CreateScalar(source, dst_el_ty, f16::FromBits(static_cast<uint16_t>(v)));
                 if (r) {
                     els.Push(r.Get());
@@ -1484,7 +1499,7 @@
     return mgr.Composite(ty, std::move(els));
 }
 
-Eval::Result Eval::Complement(const type::Type* ty,
+Eval::Result Eval::Complement(const core::type::Type* ty,
                               VectorRef<const Value*> args,
                               const Source& source) {
     auto transform = [&](const Value* c) {
@@ -1496,7 +1511,7 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::UnaryMinus(const type::Type* ty,
+Eval::Result Eval::UnaryMinus(const core::type::Type* ty,
                               VectorRef<const Value*> args,
                               const Source& source) {
     auto transform = [&](const Value* c) {
@@ -1521,7 +1536,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::Not(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::Not(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source) {
     auto transform = [&](const Value* c) {
         auto create = [&](auto i) { return CreateScalar(source, c->Type(), decltype(i)(!i)); };
         return Dispatch_bool(create, c);
@@ -1529,7 +1546,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::Plus(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::Plus(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
         return Dispatch_fia_fiu32_f16(AddFunc(source, c0->Type()), c0, c1);
     };
@@ -1537,21 +1556,23 @@
     return TransformBinaryElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::Minus(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::Minus(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source) {
     return Sub(source, ty, args[0], args[1]);
 }
 
-Eval::Result Eval::Multiply(const type::Type* ty,
+Eval::Result Eval::Multiply(const core::type::Type* ty,
                             VectorRef<const Value*> args,
                             const Source& source) {
     return Mul(source, ty, args[0], args[1]);
 }
 
-Eval::Result Eval::MultiplyMatVec(const type::Type* ty,
+Eval::Result Eval::MultiplyMatVec(const core::type::Type* ty,
                                   VectorRef<const Value*> args,
                                   const Source& source) {
-    auto* mat_ty = args[0]->Type()->As<type::Matrix>();
-    auto* vec_ty = args[1]->Type()->As<type::Vector>();
+    auto* mat_ty = args[0]->Type()->As<core::type::Matrix>();
+    auto* vec_ty = args[1]->Type()->As<core::type::Vector>();
     auto* elem_ty = vec_ty->type();
 
     auto dot = [&](const Value* m, size_t row, const Value* v) {
@@ -1597,11 +1618,11 @@
     }
     return mgr.Composite(ty, result);
 }
-Eval::Result Eval::MultiplyVecMat(const type::Type* ty,
+Eval::Result Eval::MultiplyVecMat(const core::type::Type* ty,
                                   VectorRef<const Value*> args,
                                   const Source& source) {
-    auto* vec_ty = args[0]->Type()->As<type::Vector>();
-    auto* mat_ty = args[1]->Type()->As<type::Matrix>();
+    auto* vec_ty = args[0]->Type()->As<core::type::Vector>();
+    auto* mat_ty = args[1]->Type()->As<core::type::Matrix>();
     auto* elem_ty = vec_ty->type();
 
     auto dot = [&](const Value* v, const Value* m, size_t col) {
@@ -1648,13 +1669,13 @@
     return mgr.Composite(ty, result);
 }
 
-Eval::Result Eval::MultiplyMatMat(const type::Type* ty,
+Eval::Result Eval::MultiplyMatMat(const core::type::Type* ty,
                                   VectorRef<const Value*> args,
                                   const Source& source) {
     auto* mat1 = args[0];
     auto* mat2 = args[1];
-    auto* mat1_ty = mat1->Type()->As<type::Matrix>();
-    auto* mat2_ty = mat2->Type()->As<type::Matrix>();
+    auto* mat1_ty = mat1->Type()->As<core::type::Matrix>();
+    auto* mat2_ty = mat2->Type()->As<core::type::Matrix>();
     auto* elem_ty = mat1_ty->type();
 
     auto dot = [&](const Value* m1, size_t row, const Value* m2, size_t col) {
@@ -1706,13 +1727,13 @@
         }
 
         // Add column vector to matrix
-        auto* col_vec_ty = ty->As<type::Matrix>()->ColumnType();
+        auto* col_vec_ty = ty->As<core::type::Matrix>()->ColumnType();
         result_mat.Push(mgr.Composite(col_vec_ty, col_vec));
     }
     return mgr.Composite(ty, result_mat);
 }
 
-Eval::Result Eval::Divide(const type::Type* ty,
+Eval::Result Eval::Divide(const core::type::Type* ty,
                           VectorRef<const Value*> args,
                           const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
@@ -1722,7 +1743,7 @@
     return TransformBinaryElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::Modulo(const type::Type* ty,
+Eval::Result Eval::Modulo(const core::type::Type* ty,
                           VectorRef<const Value*> args,
                           const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
@@ -1732,7 +1753,9 @@
     return TransformBinaryElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::Equal(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::Equal(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
         auto create = [&](auto i, auto j) -> Eval::Result {
             return CreateScalar(source, ty->DeepestElement(), i == j);
@@ -1743,7 +1766,7 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::NotEqual(const type::Type* ty,
+Eval::Result Eval::NotEqual(const core::type::Type* ty,
                             VectorRef<const Value*> args,
                             const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
@@ -1756,7 +1779,7 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::LessThan(const type::Type* ty,
+Eval::Result Eval::LessThan(const core::type::Type* ty,
                             VectorRef<const Value*> args,
                             const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
@@ -1769,7 +1792,7 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::GreaterThan(const type::Type* ty,
+Eval::Result Eval::GreaterThan(const core::type::Type* ty,
                                VectorRef<const Value*> args,
                                const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
@@ -1782,7 +1805,7 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::LessThanEqual(const type::Type* ty,
+Eval::Result Eval::LessThanEqual(const core::type::Type* ty,
                                  VectorRef<const Value*> args,
                                  const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
@@ -1795,7 +1818,7 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::GreaterThanEqual(const type::Type* ty,
+Eval::Result Eval::GreaterThanEqual(const core::type::Type* ty,
                                     VectorRef<const Value*> args,
                                     const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
@@ -1808,7 +1831,7 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::LogicalAnd(const type::Type* ty,
+Eval::Result Eval::LogicalAnd(const core::type::Type* ty,
                               VectorRef<const Value*> args,
                               const Source& source) {
     // Due to short-circuiting, this function is only called if lhs is true, so we only return the
@@ -1817,7 +1840,7 @@
     return CreateScalar(source, ty, args[1]->ValueAs<bool>());
 }
 
-Eval::Result Eval::LogicalOr(const type::Type* ty,
+Eval::Result Eval::LogicalOr(const core::type::Type* ty,
                              VectorRef<const Value*> args,
                              const Source& source) {
     // Due to short-circuiting, this function is only called if lhs is false, so we only only return
@@ -1826,7 +1849,9 @@
     return CreateScalar(source, ty, args[1]->ValueAs<bool>());
 }
 
-Eval::Result Eval::And(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::And(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
         auto create = [&](auto i, auto j) -> Eval::Result {
             using T = decltype(i);
@@ -1844,7 +1869,9 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::Or(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::Or(const core::type::Type* ty,
+                      VectorRef<const Value*> args,
+                      const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
         auto create = [&](auto i, auto j) -> Eval::Result {
             using T = decltype(i);
@@ -1862,7 +1889,9 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::Xor(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::Xor(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
         auto create = [&](auto i, auto j) -> Eval::Result {
             return CreateScalar(source, ty->DeepestElement(), decltype(i){i ^ j});
@@ -1873,7 +1902,7 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::ShiftLeft(const type::Type* ty,
+Eval::Result Eval::ShiftLeft(const core::type::Type* ty,
                              VectorRef<const Value*> args,
                              const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
@@ -1962,7 +1991,7 @@
         return Dispatch_ia_iu32(create, c0, c1);
     };
 
-    if (TINT_UNLIKELY(!args[1]->Type()->DeepestElement()->Is<type::U32>())) {
+    if (TINT_UNLIKELY(!args[1]->Type()->DeepestElement()->Is<core::type::U32>())) {
         TINT_ICE() << "Element type of rhs of ShiftLeft must be a u32";
         return Failure;
     }
@@ -1970,7 +1999,7 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::ShiftRight(const type::Type* ty,
+Eval::Result Eval::ShiftRight(const core::type::Type* ty,
                               VectorRef<const Value*> args,
                               const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
@@ -2029,7 +2058,7 @@
         return Dispatch_ia_iu32(create, c0, c1);
     };
 
-    if (TINT_UNLIKELY(!args[1]->Type()->DeepestElement()->Is<type::U32>())) {
+    if (TINT_UNLIKELY(!args[1]->Type()->DeepestElement()->Is<core::type::U32>())) {
         TINT_ICE() << "Element type of rhs of ShiftLeft must be a u32";
         return Failure;
     }
@@ -2037,7 +2066,9 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::abs(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::abs(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto e) {
             using NumberT = decltype(e);
@@ -2060,7 +2091,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::acos(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::acos(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto i) -> Eval::Result {
             using NumberT = decltype(i);
@@ -2080,7 +2113,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::acosh(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::acosh(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto i) -> Eval::Result {
             using NumberT = decltype(i);
@@ -2100,15 +2135,21 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::all(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::all(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source) {
     return CreateScalar(source, ty, !args[0]->AnyZero());
 }
 
-Eval::Result Eval::any(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::any(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source) {
     return CreateScalar(source, ty, !args[0]->AllZero());
 }
 
-Eval::Result Eval::asin(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::asin(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto i) -> Eval::Result {
             using NumberT = decltype(i);
@@ -2128,7 +2169,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::asinh(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::asinh(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto i) {
             return CreateScalar(source, c0->Type(), decltype(i)(std::asinh(i.value)));
@@ -2139,7 +2182,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::atan(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::atan(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto i) {
             return CreateScalar(source, c0->Type(), decltype(i)(std::atan(i.value)));
@@ -2149,7 +2194,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::atanh(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::atanh(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto i) -> Eval::Result {
             using NumberT = decltype(i);
@@ -2170,7 +2217,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::atan2(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::atan2(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
         auto create = [&](auto i, auto j) {
             return CreateScalar(source, c0->Type(), decltype(i)(std::atan2(i.value, j.value)));
@@ -2180,7 +2229,9 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::ceil(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::ceil(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto e) {
             return CreateScalar(source, c0->Type(), decltype(e)(std::ceil(e)));
@@ -2190,14 +2241,18 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::clamp(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::clamp(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1, const Value* c2) {
         return Dispatch_fia_fiu32_f16(ClampFunc(source, c0->Type()), c0, c1, c2);
     };
     return TransformElements(mgr, ty, transform, args[0], args[1], args[2]);
 }
 
-Eval::Result Eval::cos(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::cos(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto i) -> Eval::Result {
             using NumberT = decltype(i);
@@ -2208,7 +2263,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::cosh(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::cosh(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto i) -> Eval::Result {
             using NumberT = decltype(i);
@@ -2219,7 +2276,7 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::countLeadingZeros(const type::Type* ty,
+Eval::Result Eval::countLeadingZeros(const core::type::Type* ty,
                                      VectorRef<const Value*> args,
                                      const Source& source) {
     auto transform = [&](const Value* c0) {
@@ -2234,7 +2291,7 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::countOneBits(const type::Type* ty,
+Eval::Result Eval::countOneBits(const core::type::Type* ty,
                                 VectorRef<const Value*> args,
                                 const Source& source) {
     auto transform = [&](const Value* c0) {
@@ -2258,7 +2315,7 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::countTrailingZeros(const type::Type* ty,
+Eval::Result Eval::countTrailingZeros(const core::type::Type* ty,
                                       VectorRef<const Value*> args,
                                       const Source& source) {
     auto transform = [&](const Value* c0) {
@@ -2273,10 +2330,12 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::cross(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::cross(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source) {
     auto* u = args[0];
     auto* v = args[1];
-    auto* elem_ty = u->Type()->As<type::Vector>()->type();
+    auto* elem_ty = u->Type()->As<core::type::Vector>()->type();
 
     // cross product of a v3 is the determinant of the 3x3 matrix:
     //
@@ -2313,7 +2372,7 @@
     return mgr.Composite(ty, Vector<const Value*, 3>{x.Get(), y.Get(), z.Get()});
 }
 
-Eval::Result Eval::degrees(const type::Type* ty,
+Eval::Result Eval::degrees(const core::type::Type* ty,
                            VectorRef<const Value*> args,
                            const Source& source) {
     auto transform = [&](const Value* c0) {
@@ -2339,12 +2398,12 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::determinant(const type::Type* ty,
+Eval::Result Eval::determinant(const core::type::Type* ty,
                                VectorRef<const Value*> args,
                                const Source& source) {
     auto calculate = [&]() -> Eval::Result {
         auto* m = args[0];
-        auto* mat_ty = m->Type()->As<type::Matrix>();
+        auto* mat_ty = m->Type()->As<core::type::Matrix>();
         auto me = [&](size_t r, size_t c) { return m->Index(c)->Index(r); };
         switch (mat_ty->rows()) {
             case 2:
@@ -2375,7 +2434,7 @@
     return r;
 }
 
-Eval::Result Eval::distance(const type::Type* ty,
+Eval::Result Eval::distance(const core::type::Type* ty,
                             VectorRef<const Value*> args,
                             const Source& source) {
     auto err = [&]() -> Eval::Result {
@@ -2395,7 +2454,9 @@
     return len;
 }
 
-Eval::Result Eval::dot(const type::Type*, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::dot(const core::type::Type*,
+                       VectorRef<const Value*> args,
+                       const Source& source) {
     auto r = Dot(source, args[0], args[1]);
     if (!r) {
         AddNote("when calculating dot", source);
@@ -2403,7 +2464,9 @@
     return r;
 }
 
-Eval::Result Eval::exp(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::exp(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto e0) -> Eval::Result {
             using NumberT = decltype(e0);
@@ -2423,7 +2486,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::exp2(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::exp2(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto e0) -> Eval::Result {
             using NumberT = decltype(e0);
@@ -2443,7 +2508,7 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::extractBits(const type::Type* ty,
+Eval::Result Eval::extractBits(const core::type::Type* ty,
                                VectorRef<const Value*> args,
                                const Source& source) {
     auto transform = [&](const Value* c0) {
@@ -2503,7 +2568,7 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::faceForward(const type::Type* ty,
+Eval::Result Eval::faceForward(const core::type::Type* ty,
                                VectorRef<const Value*> args,
                                const Source& source) {
     // Returns e1 if dot(e2, e3) is negative, and -e1 otherwise.
@@ -2522,7 +2587,7 @@
     return UnaryMinus(ty, Vector{e1}, source);
 }
 
-Eval::Result Eval::firstLeadingBit(const type::Type* ty,
+Eval::Result Eval::firstLeadingBit(const core::type::Type* ty,
                                    VectorRef<const Value*> args,
                                    const Source& source) {
     auto transform = [&](const Value* c0) {
@@ -2566,7 +2631,7 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::firstTrailingBit(const type::Type* ty,
+Eval::Result Eval::firstTrailingBit(const core::type::Type* ty,
                                     VectorRef<const Value*> args,
                                     const Source& source) {
     auto transform = [&](const Value* c0) {
@@ -2592,7 +2657,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::floor(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::floor(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto e) {
             return CreateScalar(source, c0->Type(), decltype(e)(std::floor(e)));
@@ -2602,7 +2669,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::fma(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::fma(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source) {
     auto transform = [&](const Value* c1, const Value* c2, const Value* c3) {
         auto create = [&](auto e1, auto e2, auto e3) -> Eval::Result {
             auto err_msg = [&] {
@@ -2626,7 +2695,9 @@
     return TransformElements(mgr, ty, transform, args[0], args[1], args[2]);
 }
 
-Eval::Result Eval::fract(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::fract(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source) {
     auto transform = [&](const Value* c1) {
         auto create = [&](auto e) -> Eval::Result {
             using NumberT = decltype(e);
@@ -2638,7 +2709,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::frexp(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::frexp(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source) {
     auto* arg = args[0];
 
     struct FractExp {
@@ -2651,19 +2724,19 @@
         double fract = std::frexp(s->ValueAs<AFloat>(), &exp);
         return Switch(
             s->Type(),
-            [&](const type::F32*) {
+            [&](const core::type::F32*) {
                 return FractExp{
                     CreateScalar(source, mgr.types.f32(), f32(fract)),
                     CreateScalar(source, mgr.types.i32(), i32(exp)),
                 };
             },
-            [&](const type::F16*) {
+            [&](const core::type::F16*) {
                 return FractExp{
                     CreateScalar(source, mgr.types.f16(), f16(fract)),
                     CreateScalar(source, mgr.types.i32(), i32(exp)),
                 };
             },
-            [&](const type::AbstractFloat*) {
+            [&](const core::type::AbstractFloat*) {
                 return FractExp{
                     CreateScalar(source, mgr.types.AFloat(), AFloat(fract)),
                     CreateScalar(source, mgr.types.AInt(), AInt(exp)),
@@ -2676,7 +2749,7 @@
             });
     };
 
-    if (auto* vec = arg->Type()->As<type::Vector>()) {
+    if (auto* vec = arg->Type()->As<core::type::Vector>()) {
         Vector<const Value*, 4> fract_els;
         Vector<const Value*, 4> exp_els;
         for (uint32_t i = 0; i < vec->Width(); i++) {
@@ -2705,7 +2778,7 @@
     }
 }
 
-Eval::Result Eval::insertBits(const type::Type* ty,
+Eval::Result Eval::insertBits(const core::type::Type* ty,
                               VectorRef<const Value*> args,
                               const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
@@ -2762,7 +2835,7 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::inverseSqrt(const type::Type* ty,
+Eval::Result Eval::inverseSqrt(const core::type::Type* ty,
                                VectorRef<const Value*> args,
                                const Source& source) {
     auto transform = [&](const Value* c0) {
@@ -2800,7 +2873,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::ldexp(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::ldexp(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source) {
     auto transform = [&](const Value* c1, size_t index) {
         auto create = [&](auto e1) -> Eval::Result {
             using E1Type = decltype(e1);
@@ -2809,7 +2884,7 @@
 
             E2Type e2;
             auto* c2 = args[1];
-            if (c2->Type()->Is<type::Vector>()) {
+            if (c2->Type()->Is<core::type::Vector>()) {
                 e2 = c2->Index(index)->ValueAs<E2Type>();
             } else {
                 e2 = c2->ValueAs<E2Type>();
@@ -2844,7 +2919,7 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::length(const type::Type* ty,
+Eval::Result Eval::length(const core::type::Type* ty,
                           VectorRef<const Value*> args,
                           const Source& source) {
     auto r = Length(source, ty, args[0]);
@@ -2854,7 +2929,9 @@
     return r;
 }
 
-Eval::Result Eval::log(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::log(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto v) -> Eval::Result {
             using NumberT = decltype(v);
@@ -2873,7 +2950,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::log2(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::log2(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto v) -> Eval::Result {
             using NumberT = decltype(v);
@@ -2892,7 +2971,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::max(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::max(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
         auto create = [&](auto e0, auto e1) {
             return CreateScalar(source, c0->Type(), decltype(e0)(std::max(e0, e1)));
@@ -2902,7 +2983,9 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::min(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::min(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
         auto create = [&](auto e0, auto e1) {
             return CreateScalar(source, c0->Type(), decltype(e0)(std::min(e0, e1)));
@@ -2912,14 +2995,16 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::mix(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::mix(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1, size_t index) {
         auto create = [&](auto e1, auto e2) -> Eval::Result {
             using NumberT = decltype(e1);
             // e3 is either a vector or a scalar
             NumberT e3;
             auto* c2 = args[2];
-            if (c2->Type()->Is<type::Vector>()) {
+            if (c2->Type()->Is<core::type::Vector>()) {
                 e3 = c2->Index(index)->ValueAs<NumberT>();
             } else {
                 e3 = c2->ValueAs<NumberT>();
@@ -2953,7 +3038,9 @@
     return r;
 }
 
-Eval::Result Eval::modf(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::modf(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source) {
     auto transform_fract = [&](const Value* c) {
         auto create = [&](auto e) {
             return CreateScalar(source, c->Type(), decltype(e)(e.value - std::trunc(e.value)));
@@ -2984,7 +3071,7 @@
     return mgr.Composite(ty, std::move(fields));
 }
 
-Eval::Result Eval::normalize(const type::Type* ty,
+Eval::Result Eval::normalize(const core::type::Type* ty,
                              VectorRef<const Value*> args,
                              const Source& source) {
     auto* len_ty = ty->DeepestElement();
@@ -3005,7 +3092,7 @@
     return Divide(ty, Vector{args[0], v}, source);
 }
 
-Eval::Result Eval::pack2x16float(const type::Type* ty,
+Eval::Result Eval::pack2x16float(const core::type::Type* ty,
                                  VectorRef<const Value*> args,
                                  const Source& source) {
     auto convert = [&](f32 val) -> tint::Result<uint32_t> {
@@ -3037,7 +3124,7 @@
     return CreateScalar(source, ty, ret);
 }
 
-Eval::Result Eval::pack2x16snorm(const type::Type* ty,
+Eval::Result Eval::pack2x16snorm(const core::type::Type* ty,
                                  VectorRef<const Value*> args,
                                  const Source& source) {
     auto calc = [&](f32 val) -> u32 {
@@ -3054,7 +3141,7 @@
     return CreateScalar(source, ty, ret);
 }
 
-Eval::Result Eval::pack2x16unorm(const type::Type* ty,
+Eval::Result Eval::pack2x16unorm(const core::type::Type* ty,
                                  VectorRef<const Value*> args,
                                  const Source& source) {
     auto calc = [&](f32 val) -> u32 {
@@ -3070,7 +3157,7 @@
     return CreateScalar(source, ty, ret);
 }
 
-Eval::Result Eval::pack4x8snorm(const type::Type* ty,
+Eval::Result Eval::pack4x8snorm(const core::type::Type* ty,
                                 VectorRef<const Value*> args,
                                 const Source& source) {
     auto calc = [&](f32 val) -> u32 {
@@ -3090,7 +3177,7 @@
     return CreateScalar(source, ty, ret);
 }
 
-Eval::Result Eval::pack4x8unorm(const type::Type* ty,
+Eval::Result Eval::pack4x8unorm(const core::type::Type* ty,
                                 VectorRef<const Value*> args,
                                 const Source& source) {
     auto calc = [&](f32 val) -> u32 {
@@ -3109,7 +3196,9 @@
     return CreateScalar(source, ty, ret);
 }
 
-Eval::Result Eval::pow(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::pow(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
         auto create = [&](auto e1, auto e2) -> Eval::Result {
             auto r = CheckedPow(e1, e2);
@@ -3128,7 +3217,7 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::radians(const type::Type* ty,
+Eval::Result Eval::radians(const core::type::Type* ty,
                            VectorRef<const Value*> args,
                            const Source& source) {
     auto transform = [&](const Value* c0) {
@@ -3154,7 +3243,7 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::reflect(const type::Type* ty,
+Eval::Result Eval::reflect(const core::type::Type* ty,
                            VectorRef<const Value*> args,
                            const Source& source) {
     auto calculate = [&]() -> Eval::Result {
@@ -3162,7 +3251,7 @@
         // e1 - 2 * dot(e2, e1) * e2.
         auto* e1 = args[0];
         auto* e2 = args[1];
-        auto* vec_ty = ty->As<type::Vector>();
+        auto* vec_ty = ty->As<core::type::Vector>();
         auto* el_ty = vec_ty->type();
 
         // dot(e2, e1)
@@ -3197,10 +3286,10 @@
     return r;
 }
 
-Eval::Result Eval::refract(const type::Type* ty,
+Eval::Result Eval::refract(const core::type::Type* ty,
                            VectorRef<const Value*> args,
                            const Source& source) {
-    auto* vec_ty = ty->As<type::Vector>();
+    auto* vec_ty = ty->As<core::type::Vector>();
     auto* el_ty = vec_ty->type();
 
     auto compute_k = [&](auto e3, auto dot_e2_e1) -> Eval::Result {
@@ -3295,7 +3384,7 @@
     return r;
 }
 
-Eval::Result Eval::reverseBits(const type::Type* ty,
+Eval::Result Eval::reverseBits(const core::type::Type* ty,
                                VectorRef<const Value*> args,
                                const Source& source) {
     auto transform = [&](const Value* c0) {
@@ -3322,7 +3411,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::round(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::round(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto e) {
             using NumberT = decltype(e);
@@ -3356,7 +3447,7 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::saturate(const type::Type* ty,
+Eval::Result Eval::saturate(const core::type::Type* ty,
                             VectorRef<const Value*> args,
                             const Source& source) {
     auto transform = [&](const Value* c0) {
@@ -3370,7 +3461,7 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::select_bool(const type::Type* ty,
+Eval::Result Eval::select_bool(const core::type::Type* ty,
                                VectorRef<const Value*> args,
                                const Source& source) {
     auto cond = args[2]->ValueAs<bool>();
@@ -3384,7 +3475,7 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::select_boolvec(const type::Type* ty,
+Eval::Result Eval::select_boolvec(const core::type::Type* ty,
                                   VectorRef<const Value*> args,
                                   const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1, size_t index) {
@@ -3399,7 +3490,9 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::sign(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::sign(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto e) -> Eval::Result {
             using NumberT = decltype(e);
@@ -3419,7 +3512,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::sin(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::sin(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto i) -> Eval::Result {
             using NumberT = decltype(i);
@@ -3430,7 +3525,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::sinh(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::sinh(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto i) -> Eval::Result {
             using NumberT = decltype(i);
@@ -3441,7 +3538,7 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::smoothstep(const type::Type* ty,
+Eval::Result Eval::smoothstep(const core::type::Type* ty,
                               VectorRef<const Value*> args,
                               const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1, const Value* c2) {
@@ -3491,7 +3588,9 @@
     return TransformElements(mgr, ty, transform, args[0], args[1], args[2]);
 }
 
-Eval::Result Eval::step(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::step(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source) {
     auto transform = [&](const Value* c0, const Value* c1) {
         auto create = [&](auto edge, auto x) -> Eval::Result {
             using NumberT = decltype(edge);
@@ -3503,7 +3602,9 @@
     return TransformElements(mgr, ty, transform, args[0], args[1]);
 }
 
-Eval::Result Eval::sqrt(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::sqrt(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source) {
     auto transform = [&](const Value* c0) {
         return Dispatch_fa_f32_f16(SqrtFunc(source, c0->Type()), c0);
     };
@@ -3511,7 +3612,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::tan(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::tan(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto i) -> Eval::Result {
             using NumberT = decltype(i);
@@ -3522,7 +3625,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::tanh(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::tanh(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto i) -> Eval::Result {
             using NumberT = decltype(i);
@@ -3533,11 +3638,13 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::transpose(const type::Type* ty, VectorRef<const Value*> args, const Source&) {
+Eval::Result Eval::transpose(const core::type::Type* ty,
+                             VectorRef<const Value*> args,
+                             const Source&) {
     auto* m = args[0];
-    auto* mat_ty = m->Type()->As<type::Matrix>();
+    auto* mat_ty = m->Type()->As<core::type::Matrix>();
     auto me = [&](size_t r, size_t c) { return m->Index(c)->Index(r); };
-    auto* result_mat_ty = ty->As<type::Matrix>();
+    auto* result_mat_ty = ty->As<core::type::Matrix>();
 
     // Produce column vectors from each row
     Vector<const Value*, 4> result_mat;
@@ -3551,7 +3658,9 @@
     return mgr.Composite(ty, result_mat);
 }
 
-Eval::Result Eval::trunc(const type::Type* ty, VectorRef<const Value*> args, const Source& source) {
+Eval::Result Eval::trunc(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source) {
     auto transform = [&](const Value* c0) {
         auto create = [&](auto i) {
             return CreateScalar(source, c0->Type(), decltype(i)(std::trunc(i.value)));
@@ -3561,7 +3670,7 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::unpack2x16float(const type::Type* ty,
+Eval::Result Eval::unpack2x16float(const core::type::Type* ty,
                                    VectorRef<const Value*> args,
                                    const Source& source) {
     auto* inner_ty = ty->DeepestElement();
@@ -3589,7 +3698,7 @@
     return mgr.Composite(ty, std::move(els));
 }
 
-Eval::Result Eval::unpack2x16snorm(const type::Type* ty,
+Eval::Result Eval::unpack2x16snorm(const core::type::Type* ty,
                                    VectorRef<const Value*> args,
                                    const Source& source) {
     auto* inner_ty = ty->DeepestElement();
@@ -3609,7 +3718,7 @@
     return mgr.Composite(ty, std::move(els));
 }
 
-Eval::Result Eval::unpack2x16unorm(const type::Type* ty,
+Eval::Result Eval::unpack2x16unorm(const core::type::Type* ty,
                                    VectorRef<const Value*> args,
                                    const Source& source) {
     auto* inner_ty = ty->DeepestElement();
@@ -3628,7 +3737,7 @@
     return mgr.Composite(ty, std::move(els));
 }
 
-Eval::Result Eval::unpack4x8snorm(const type::Type* ty,
+Eval::Result Eval::unpack4x8snorm(const core::type::Type* ty,
                                   VectorRef<const Value*> args,
                                   const Source& source) {
     auto* inner_ty = ty->DeepestElement();
@@ -3648,7 +3757,7 @@
     return mgr.Composite(ty, std::move(els));
 }
 
-Eval::Result Eval::unpack4x8unorm(const type::Type* ty,
+Eval::Result Eval::unpack4x8unorm(const core::type::Type* ty,
                                   VectorRef<const Value*> args,
                                   const Source& source) {
     auto* inner_ty = ty->DeepestElement();
@@ -3667,7 +3776,7 @@
     return mgr.Composite(ty, std::move(els));
 }
 
-Eval::Result Eval::quantizeToF16(const type::Type* ty,
+Eval::Result Eval::quantizeToF16(const core::type::Type* ty,
                                  VectorRef<const Value*> args,
                                  const Source& source) {
     auto transform = [&](const Value* c) -> Eval::Result {
@@ -3686,7 +3795,9 @@
     return TransformElements(mgr, ty, transform, args[0]);
 }
 
-Eval::Result Eval::Convert(const type::Type* target_ty, const Value* value, const Source& source) {
+Eval::Result Eval::Convert(const core::type::Type* target_ty,
+                           const Value* value,
+                           const Source& source) {
     if (value->Type() == target_ty) {
         return value;
     }
diff --git a/src/tint/lang/core/constant/eval.h b/src/tint/lang/core/constant/eval.h
index 6a81c42..035f353 100644
--- a/src/tint/lang/core/constant/eval.h
+++ b/src/tint/lang/core/constant/eval.h
@@ -16,6 +16,7 @@
 #define SRC_TINT_LANG_CORE_CONSTANT_EVAL_H_
 
 #include <stddef.h>
+#include <algorithm>
 #include <string>
 
 #include "src/tint/lang/core/number.h"
@@ -51,7 +52,7 @@
     using Result = tint::Result<const Value*>;
 
     /// Typedef for a constant evaluation function
-    using Function = Result (Eval::*)(const type::Type* result_ty,
+    using Function = Result (Eval::*)(const core::type::Type* result_ty,
                                       VectorRef<const Value*>,
                                       const Source&);
 
@@ -69,14 +70,14 @@
     /// @param ty the target type - must be an array or struct
     /// @param args the input arguments
     /// @return the constructed value, or null if the value cannot be calculated
-    Result ArrayOrStructCtor(const type::Type* ty, VectorRef<const Value*> args);
+    Result ArrayOrStructCtor(const core::type::Type* ty, VectorRef<const Value*> args);
 
     /// @param ty the target type
     /// @param value the value being converted
     /// @param source the source location
     /// @return the bit-cast of the given expression to the given type, or null if the value cannot
     ///         be calculated
-    Result Bitcast(const type::Type* ty, const Value* value, const Source& source);
+    Result Bitcast(const core::type::Type* ty, const Value* value, const Source& source);
 
     /// @param obj the object being indexed. May be null, in which case Index() will still validate
     /// the index is in bounds for the type.
@@ -85,7 +86,7 @@
     /// @param idx_source the source of the index expression
     /// @return the result of the index, or null if the value cannot be calculated
     Result Index(const Value* obj,
-                 const type::Type* obj_ty,
+                 const core::type::Type* obj_ty,
                  const Value* idx,
                  const Source& idx_source);
 
@@ -93,14 +94,14 @@
     /// @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
-    Result Swizzle(const type::Type* ty, const Value* vector, VectorRef<uint32_t> indices);
+    Result Swizzle(const core::type::Type* ty, const Value* vector, 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
     /// @return the converted value, or null if the value cannot be calculated
-    Result Convert(const type::Type* ty, const Value* value, const Source& source);
+    Result Convert(const core::type::Type* ty, const Value* value, const Source& source);
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
     // Constant value evaluation methods, to be indirectly called via the intrinsic table
@@ -111,56 +112,56 @@
     /// @param args the input arguments
     /// @param source the source location
     /// @return the converted value, or null if the value cannot be calculated
-    Result Conv(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result Conv(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// Zero value constructor
     /// @param ty the result type
     /// @param args the input arguments (no arguments provided)
     /// @param source the source location
     /// @return the constructed value, or null if the value cannot be calculated
-    Result Zero(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result Zero(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// Identity value constructor
     /// @param ty the result type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the constructed value, or null if the value cannot be calculated
-    Result Identity(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result Identity(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// Vector splat constructor
     /// @param ty the vector type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the constructed value, or null if the value cannot be calculated
-    Result VecSplat(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result VecSplat(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// Vector constructor using scalars
     /// @param ty the vector type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the constructed value, or null if the value cannot be calculated
-    Result VecInitS(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result VecInitS(const core::type::Type* ty, VectorRef<const Value*> 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
     /// @return the constructed value, or null if the value cannot be calculated
-    Result VecInitM(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result VecInitM(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// Matrix constructor using scalar values
     /// @param ty the matrix type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the constructed value, or null if the value cannot be calculated
-    Result MatInitS(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result MatInitS(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// Matrix constructor using column vectors
     /// @param ty the matrix type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the constructed value, or null if the value cannot be calculated
-    Result MatInitV(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result MatInitV(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     ////////////////////////////////////////////////////////////////////////////
     // Unary Operators
@@ -171,21 +172,25 @@
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result Complement(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result Complement(const core::type::Type* ty,
+                      VectorRef<const Value*> args,
+                      const Source& source);
 
     /// Unary minus operator '-'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result UnaryMinus(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result UnaryMinus(const core::type::Type* ty,
+                      VectorRef<const Value*> args,
+                      const Source& source);
 
     /// Unary not operator '!'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result Not(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result Not(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     ////////////////////////////////////////////////////////////////////////////
     // Binary Operators
@@ -196,98 +201,108 @@
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result Plus(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result Plus(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// Minus operator '-'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result Minus(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result Minus(const core::type::Type* ty, VectorRef<const Value*> 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
     /// @return the result value, or null if the value cannot be calculated
-    Result Multiply(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result Multiply(const core::type::Type* ty, VectorRef<const Value*> 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
     /// @return the result value, or null if the value cannot be calculated
-    Result MultiplyMatVec(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result MultiplyMatVec(const core::type::Type* ty,
+                          VectorRef<const Value*> 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
     /// @return the result value, or null if the value cannot be calculated
-    Result MultiplyVecMat(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result MultiplyVecMat(const core::type::Type* ty,
+                          VectorRef<const Value*> 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
     /// @return the result value, or null if the value cannot be calculated
-    Result MultiplyMatMat(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result MultiplyMatMat(const core::type::Type* ty,
+                          VectorRef<const Value*> args,
+                          const Source& source);
 
     /// Divide operator '/'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result Divide(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result Divide(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// Modulo operator '%'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result Modulo(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result Modulo(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// Equality operator '=='
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result Equal(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result Equal(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// Inequality operator '!='
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result NotEqual(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result NotEqual(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// Less than operator '<'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result LessThan(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result LessThan(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// Greater than operator '>'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result GreaterThan(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result GreaterThan(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source);
 
     /// Less than or equal operator '<='
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result LessThanEqual(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result LessThanEqual(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source);
 
     /// Greater than or equal operator '>='
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result GreaterThanEqual(const type::Type* ty,
+    Result GreaterThanEqual(const core::type::Type* ty,
                             VectorRef<const Value*> args,
                             const Source& source);
 
@@ -296,49 +311,57 @@
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result LogicalAnd(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result LogicalAnd(const core::type::Type* ty,
+                      VectorRef<const Value*> args,
+                      const Source& source);
 
     /// Logical or operator '||'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result LogicalOr(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result LogicalOr(const core::type::Type* ty,
+                     VectorRef<const Value*> args,
+                     const Source& source);
 
     /// Bitwise and operator '&'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result And(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result And(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// Bitwise or operator '|'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result Or(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result Or(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// Bitwise xor operator '^'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result Xor(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result Xor(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// Bitwise shift left operator '<<'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result ShiftLeft(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result ShiftLeft(const core::type::Type* ty,
+                     VectorRef<const Value*> args,
+                     const Source& source);
 
     /// Bitwise shift right operator '<<'
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result ShiftRight(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result ShiftRight(const core::type::Type* ty,
+                      VectorRef<const Value*> args,
+                      const Source& source);
 
     ////////////////////////////////////////////////////////////////////////////
     // Builtins
@@ -349,105 +372,105 @@
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result abs(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result abs(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// acos builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result acos(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result acos(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// acosh builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result acosh(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result acosh(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// all builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result all(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result all(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// any builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result any(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result any(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// asin builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result asin(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result asin(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// asinh builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result asinh(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result asinh(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// atan builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result atan(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result atan(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// atanh builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result atanh(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result atanh(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// atan2 builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result atan2(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result atan2(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// ceil builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result ceil(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result ceil(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// clamp builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result clamp(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result clamp(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// cos builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result cos(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result cos(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// cosh builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result cosh(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result cosh(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// countLeadingZeros builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result countLeadingZeros(const type::Type* ty,
+    Result countLeadingZeros(const core::type::Type* ty,
                              VectorRef<const Value*> args,
                              const Source& source);
 
@@ -456,14 +479,16 @@
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result countOneBits(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result countOneBits(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source);
 
     /// countTrailingZeros builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result countTrailingZeros(const type::Type* ty,
+    Result countTrailingZeros(const core::type::Type* ty,
                               VectorRef<const Value*> args,
                               const Source& source);
 
@@ -472,70 +497,76 @@
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result cross(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result cross(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// degrees 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
-    Result degrees(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result degrees(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// determinant 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
-    Result determinant(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result determinant(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source);
 
     /// distance 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
-    Result distance(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result distance(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// dot builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result dot(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result dot(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// exp builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result exp(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result exp(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// exp2 builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result exp2(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result exp2(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// extractBits builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result extractBits(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result extractBits(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source);
 
     /// faceForward builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result faceForward(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result faceForward(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source);
 
     /// firstLeadingBit builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result firstLeadingBit(const type::Type* ty,
+    Result firstLeadingBit(const core::type::Type* ty,
                            VectorRef<const Value*> args,
                            const Source& source);
 
@@ -544,7 +575,7 @@
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result firstTrailingBit(const type::Type* ty,
+    Result firstTrailingBit(const core::type::Type* ty,
                             VectorRef<const Value*> args,
                             const Source& source);
 
@@ -553,282 +584,309 @@
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result floor(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result floor(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// fma builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result fma(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result fma(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// fract builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result fract(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result fract(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// frexp builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result frexp(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result frexp(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// insertBits builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result insertBits(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result insertBits(const core::type::Type* ty,
+                      VectorRef<const Value*> args,
+                      const Source& source);
 
     /// inverseSqrt builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result inverseSqrt(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result inverseSqrt(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source);
 
     /// ldexp builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result ldexp(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result ldexp(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// length builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result length(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result length(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// log builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result log(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result log(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// log2 builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result log2(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result log2(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// max builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result max(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result max(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// min builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result min(const type::Type* ty,  // NOLINT(build/include_what_you_use)  -- confused by min
-               VectorRef<const Value*> args,
-               const Source& source);
+    Result min(
+        const core::type::Type* ty,  // NOLINT(build/include_what_you_use)  -- confused by min
+        VectorRef<const Value*> args,
+        const Source& source);
 
     /// mix builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result mix(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result mix(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// modf builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result modf(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result modf(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// normalize builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result normalize(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result normalize(const core::type::Type* ty,
+                     VectorRef<const Value*> args,
+                     const Source& source);
 
     /// pack2x16float builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result pack2x16float(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result pack2x16float(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source);
 
     /// pack2x16snorm builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result pack2x16snorm(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result pack2x16snorm(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source);
 
     /// pack2x16unorm builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result pack2x16unorm(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result pack2x16unorm(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source);
 
     /// pack4x8snorm builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result pack4x8snorm(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result pack4x8snorm(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source);
 
     /// pack4x8unorm builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result pack4x8unorm(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result pack4x8unorm(const core::type::Type* ty,
+                        VectorRef<const Value*> args,
+                        const Source& source);
 
     /// pow builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result pow(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result pow(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// radians 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
-    Result radians(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result radians(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// reflect 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
-    Result reflect(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result reflect(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// refract 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
-    Result refract(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result refract(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// reverseBits builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result reverseBits(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result reverseBits(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source);
 
     /// round builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result round(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result round(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// saturate builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result saturate(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result saturate(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// select builtin with single bool third arg
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result select_bool(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result select_bool(const core::type::Type* ty,
+                       VectorRef<const Value*> args,
+                       const Source& source);
 
     /// select builtin with vector of bool third arg
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result select_boolvec(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result select_boolvec(const core::type::Type* ty,
+                          VectorRef<const Value*> args,
+                          const Source& source);
 
     /// sign builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result sign(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result sign(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// sin builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result sin(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result sin(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// sinh builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result sinh(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result sinh(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// smoothstep builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result smoothstep(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result smoothstep(const core::type::Type* ty,
+                      VectorRef<const Value*> args,
+                      const Source& source);
 
     /// step builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result step(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result step(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// sqrt builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result sqrt(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result sqrt(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// tan builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result tan(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result tan(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// tanh builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result tanh(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result tanh(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// transpose builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result transpose(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result transpose(const core::type::Type* ty,
+                     VectorRef<const Value*> args,
+                     const Source& source);
 
     /// trunc builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result trunc(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result trunc(const core::type::Type* ty, VectorRef<const Value*> args, const Source& source);
 
     /// unpack2x16float builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result unpack2x16float(const type::Type* ty,
+    Result unpack2x16float(const core::type::Type* ty,
                            VectorRef<const Value*> args,
                            const Source& source);
 
@@ -837,7 +895,7 @@
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result unpack2x16snorm(const type::Type* ty,
+    Result unpack2x16snorm(const core::type::Type* ty,
                            VectorRef<const Value*> args,
                            const Source& source);
 
@@ -846,7 +904,7 @@
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result unpack2x16unorm(const type::Type* ty,
+    Result unpack2x16unorm(const core::type::Type* ty,
                            VectorRef<const Value*> args,
                            const Source& source);
 
@@ -855,21 +913,27 @@
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result unpack4x8snorm(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result unpack4x8snorm(const core::type::Type* ty,
+                          VectorRef<const Value*> args,
+                          const Source& source);
 
     /// unpack4x8unorm builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result unpack4x8unorm(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result unpack4x8unorm(const core::type::Type* ty,
+                          VectorRef<const Value*> args,
+                          const Source& source);
 
     /// quantizeToF16 builtin
     /// @param ty the expression type
     /// @param args the input arguments
     /// @param source the source location
     /// @return the result value, or null if the value cannot be calculated
-    Result quantizeToF16(const type::Type* ty, VectorRef<const Value*> args, const Source& source);
+    Result quantizeToF16(const core::type::Type* ty,
+                         VectorRef<const Value*> args,
+                         const Source& source);
 
   private:
     /// Adds the given error message to the diagnostics
@@ -887,10 +951,10 @@
     /// @param v the scalar value
     /// @return the constant value with the same type and value
     template <typename T>
-    Eval::Result CreateScalar(const Source& source, const type::Type* t, T v);
+    Eval::Result CreateScalar(const Source& source, const core::type::Type* t, T v);
 
     /// ZeroValue returns a Constant for the zero-value of the type `type`.
-    const Value* ZeroValue(const type::Type* type);
+    const Value* ZeroValue(const core::type::Type* type);
 
     /// Adds two Number<T>s
     /// @param source the source location
@@ -1085,91 +1149,91 @@
     /// @param source the source location
     /// @param elem_ty the element type of the Constant to create on success
     /// @returns the callable function
-    auto AddFunc(const Source& source, const type::Type* elem_ty);
+    auto AddFunc(const Source& source, const core::type::Type* elem_ty);
 
     /// Returns a callable that calls Sub, and creates a Constant with its result of type `elem_ty`
     /// if successful, or returns Failure otherwise.
     /// @param source the source location
     /// @param elem_ty the element type of the Constant to create on success
     /// @returns the callable function
-    auto SubFunc(const Source& source, const type::Type* elem_ty);
+    auto SubFunc(const Source& source, const core::type::Type* elem_ty);
 
     /// Returns a callable that calls Mul, and creates a Constant with its result of type `elem_ty`
     /// if successful, or returns Failure otherwise.
     /// @param source the source location
     /// @param elem_ty the element type of the Constant to create on success
     /// @returns the callable function
-    auto MulFunc(const Source& source, const type::Type* elem_ty);
+    auto MulFunc(const Source& source, const core::type::Type* elem_ty);
 
     /// Returns a callable that calls Div, and creates a Constant with its result of type `elem_ty`
     /// if successful, or returns Failure otherwise.
     /// @param source the source location
     /// @param elem_ty the element type of the Constant to create on success
     /// @returns the callable function
-    auto DivFunc(const Source& source, const type::Type* elem_ty);
+    auto DivFunc(const Source& source, const core::type::Type* elem_ty);
 
     /// Returns a callable that calls Mod, and creates a Constant with its result of type `elem_ty`
     /// if successful, or returns Failure otherwise.
     /// @param source the source location
     /// @param elem_ty the element type of the Constant to create on success
     /// @returns the callable function
-    auto ModFunc(const Source& source, const type::Type* elem_ty);
+    auto ModFunc(const Source& source, const core::type::Type* elem_ty);
 
     /// Returns a callable that calls Dot2, and creates a Constant with its result of type `elem_ty`
     /// if successful, or returns Failure otherwise.
     /// @param source the source location
     /// @param elem_ty the element type of the Constant to create on success
     /// @returns the callable function
-    auto Dot2Func(const Source& source, const type::Type* elem_ty);
+    auto Dot2Func(const Source& source, const core::type::Type* elem_ty);
 
     /// Returns a callable that calls Dot3, and creates a Constant with its result of type `elem_ty`
     /// if successful, or returns Failure otherwise.
     /// @param source the source location
     /// @param elem_ty the element type of the Constant to create on success
     /// @returns the callable function
-    auto Dot3Func(const Source& source, const type::Type* elem_ty);
+    auto Dot3Func(const Source& source, const core::type::Type* elem_ty);
 
     /// Returns a callable that calls Dot4, and creates a Constant with its result of type `elem_ty`
     /// if successful, or returns Failure otherwise.
     /// @param source the source location
     /// @param elem_ty the element type of the Constant to create on success
     /// @returns the callable function
-    auto Dot4Func(const Source& source, const type::Type* elem_ty);
+    auto Dot4Func(const Source& source, const core::type::Type* elem_ty);
 
     /// Returns a callable that calls Det2, and creates a Constant with its result of type `elem_ty`
     /// if successful, or returns Failure otherwise.
     /// @param source the source location
     /// @param elem_ty the element type of the Constant to create on success
     /// @returns the callable function
-    auto Det2Func(const Source& source, const type::Type* elem_ty);
+    auto Det2Func(const Source& source, const core::type::Type* elem_ty);
 
     /// Returns a callable that calls Det3, and creates a Constant with its result of type `elem_ty`
     /// if successful, or returns Failure otherwise.
     /// @param source the source location
     /// @param elem_ty the element type of the Constant to create on success
     /// @returns the callable function
-    auto Det3Func(const Source& source, const type::Type* elem_ty);
+    auto Det3Func(const Source& source, const core::type::Type* elem_ty);
 
     /// Returns a callable that calls Det4, and creates a Constant with its result of type `elem_ty`
     /// if successful, or returns Failure otherwise.
     /// @param source the source location
     /// @param elem_ty the element type of the Constant to create on success
     /// @returns the callable function
-    auto Det4Func(const Source& source, const type::Type* elem_ty);
+    auto Det4Func(const Source& source, const core::type::Type* elem_ty);
 
     /// Returns a callable that calls Clamp, and creates a Constant with its result of type
     /// `elem_ty` if successful, or returns Failure otherwise.
     /// @param source the source location
     /// @param elem_ty the element type of the Constant to create on success
     /// @returns the callable function
-    auto ClampFunc(const Source& source, const type::Type* elem_ty);
+    auto ClampFunc(const Source& source, const core::type::Type* elem_ty);
 
     /// Returns a callable that calls SqrtFunc, and creates a Constant with its
     /// result of type `elem_ty` if successful, or returns Failure otherwise.
     /// @param source the source location
     /// @param elem_ty the element type of the Constant to create on success
     /// @returns the callable function
-    auto SqrtFunc(const Source& source, const type::Type* elem_ty);
+    auto SqrtFunc(const Source& source, const core::type::Type* elem_ty);
 
     /// Returns the dot product of v1 and v2.
     /// @param source the source location
@@ -1183,7 +1247,7 @@
     /// @param ty the return type
     /// @param c0 the constant to calculate the length of
     /// @returns the length of c0
-    Result Length(const Source& source, const type::Type* ty, const Value* c0);
+    Result Length(const Source& source, const core::type::Type* ty, const Value* c0);
 
     /// Returns the product of v1 and v2
     /// @param source the source location
@@ -1191,7 +1255,7 @@
     /// @param v1 lhs value
     /// @param v2 rhs value
     /// @returns the product of v1 and v2
-    Result Mul(const Source& source, const type::Type* ty, const Value* v1, const Value* v2);
+    Result Mul(const Source& source, const core::type::Type* ty, const Value* v1, const Value* v2);
 
     /// Returns the difference between v2 and v1
     /// @param source the source location
@@ -1199,7 +1263,7 @@
     /// @param v1 lhs value
     /// @param v2 rhs value
     /// @returns the difference between v2 and v1
-    Result Sub(const Source& source, const type::Type* ty, const Value* v1, const Value* v2);
+    Result Sub(const Source& source, const core::type::Type* ty, const Value* v1, const Value* v2);
 
   private:
     Manager& mgr;
diff --git a/src/tint/lang/core/constant/eval_binary_op_test.cc b/src/tint/lang/core/constant/eval_binary_op_test.cc
index 89e2247..8eff2f8 100644
--- a/src/tint/lang/core/constant/eval_binary_op_test.cc
+++ b/src/tint/lang/core/constant/eval_binary_op_test.cc
@@ -1195,7 +1195,7 @@
     auto* sem2 = Sem().Get(expr2);
     ASSERT_NE(sem2, nullptr);
 
-    auto aint_ty = create<type::AbstractInt>();
+    auto aint_ty = create<core::type::AbstractInt>();
     EXPECT_EQ(sem1->Type(), aint_ty);
     EXPECT_EQ(sem2->Type(), aint_ty);
 }
diff --git a/src/tint/lang/core/constant/eval_builtin_test.cc b/src/tint/lang/core/constant/eval_builtin_test.cc
index 75d1c11..22e8bf4 100644
--- a/src/tint/lang/core/constant/eval_builtin_test.cc
+++ b/src/tint/lang/core/constant/eval_builtin_test.cc
@@ -166,7 +166,7 @@
         ASSERT_NE(value, nullptr);
         EXPECT_TYPE(value->Type(), sem->Type());
 
-        if (value->Type()->Is<type::Struct>()) {
+        if (value->Type()->Is<core::type::Struct>()) {
             // The result type of the constant-evaluated expression is a structure.
             // Compare each of the fields individually.
             for (size_t i = 0; i < expected_case.values.Length(); i++) {
diff --git a/src/tint/lang/core/constant/eval_construction_test.cc b/src/tint/lang/core/constant/eval_construction_test.cc
index e5c7b3d..4e9ae4ea 100644
--- a/src/tint/lang/core/constant/eval_construction_test.cc
+++ b/src/tint/lang/core/constant/eval_construction_test.cc
@@ -29,7 +29,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    EXPECT_TRUE(sem->Type()->Is<type::AbstractFloat>());
+    EXPECT_TRUE(sem->Type()->Is<core::type::AbstractFloat>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
@@ -45,7 +45,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    EXPECT_TRUE(sem->Type()->Is<type::AbstractInt>());
+    EXPECT_TRUE(sem->Type()->Is<core::type::AbstractInt>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
@@ -60,7 +60,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    EXPECT_TRUE(sem->Type()->Is<type::I32>());
+    EXPECT_TRUE(sem->Type()->Is<core::type::I32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
@@ -75,7 +75,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    EXPECT_TRUE(sem->Type()->Is<type::U32>());
+    EXPECT_TRUE(sem->Type()->Is<core::type::U32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
@@ -90,7 +90,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    EXPECT_TRUE(sem->Type()->Is<type::F32>());
+    EXPECT_TRUE(sem->Type()->Is<core::type::F32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
@@ -107,7 +107,7 @@
 
     auto* sem = Sem().Get(expr);
     EXPECT_NE(sem, nullptr);
-    EXPECT_TRUE(sem->Type()->Is<type::F16>());
+    EXPECT_TRUE(sem->Type()->Is<core::type::F16>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
@@ -123,7 +123,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    EXPECT_TRUE(sem->Type()->Is<type::Bool>());
+    EXPECT_TRUE(sem->Type()->Is<core::type::Bool>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
@@ -155,16 +155,16 @@
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    if (sem->Type()->Is<type::Scalar>()) {
+    if (sem->Type()->Is<core::type::Scalar>()) {
         EXPECT_EQ(sem->ConstantValue()->Index(0), nullptr);
         EXPECT_EQ(sem->ConstantValue()->ValueAs<f32>(), 0.0f);
-    } else if (auto* vec = sem->Type()->As<type::Vector>()) {
+    } else if (auto* vec = sem->Type()->As<core::type::Vector>()) {
         for (size_t i = 0; i < vec->Width(); ++i) {
             EXPECT_TRUE(sem->ConstantValue()->Index(i)->AnyZero());
             EXPECT_TRUE(sem->ConstantValue()->Index(i)->AllZero());
             EXPECT_EQ(sem->ConstantValue()->Index(i)->ValueAs<f32>(), 0.0f);
         }
-    } else if (auto* mat = sem->Type()->As<type::Matrix>()) {
+    } else if (auto* mat = sem->Type()->As<core::type::Matrix>()) {
         for (size_t i = 0; i < mat->columns(); ++i) {
             EXPECT_TRUE(sem->ConstantValue()->Index(i)->AnyZero());
             EXPECT_TRUE(sem->ConstantValue()->Index(i)->AllZero());
@@ -174,7 +174,7 @@
                 EXPECT_EQ(sem->ConstantValue()->Index(i)->Index(j)->ValueAs<f32>(), 0.0f);
             }
         }
-    } else if (auto* arr = sem->Type()->As<type::Array>()) {
+    } else if (auto* arr = sem->Type()->As<core::type::Array>()) {
         for (size_t i = 0; i < *(arr->ConstantCount()); ++i) {
             EXPECT_TRUE(sem->ConstantValue()->Index(i)->AnyZero());
             EXPECT_TRUE(sem->ConstantValue()->Index(i)->AllZero());
@@ -216,9 +216,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::I32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::I32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
@@ -245,9 +245,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::U32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::U32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
@@ -274,9 +274,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
@@ -305,9 +305,9 @@
 
     auto* sem = Sem().Get(expr);
     EXPECT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F16>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
@@ -334,9 +334,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::Bool>());
+    EXPECT_TRUE(vec->type()->Is<core::type::Bool>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
@@ -363,9 +363,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::I32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::I32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -392,9 +392,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::U32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::U32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -421,9 +421,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -452,9 +452,9 @@
 
     auto* sem = Sem().Get(expr);
     EXPECT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F16>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -482,9 +482,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::Bool>());
+    EXPECT_TRUE(vec->type()->Is<core::type::Bool>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -512,9 +512,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::AbstractInt>());
+    EXPECT_TRUE(vec->type()->Is<core::type::AbstractInt>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -542,9 +542,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::AbstractFloat>());
+    EXPECT_TRUE(vec->type()->Is<core::type::AbstractFloat>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -571,9 +571,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::I32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::I32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -600,9 +600,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::U32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::U32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -629,9 +629,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -660,9 +660,9 @@
 
     auto* sem = Sem().Get(expr);
     EXPECT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F16>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -689,9 +689,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::Bool>());
+    EXPECT_TRUE(vec->type()->Is<core::type::Bool>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
@@ -718,9 +718,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::I32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::I32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -747,9 +747,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::U32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::U32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -776,9 +776,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -805,9 +805,9 @@
 
     auto* sem = Sem().Get(expr);
     EXPECT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -834,9 +834,9 @@
 
     auto* sem = Sem().Get(expr);
     EXPECT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
@@ -863,9 +863,9 @@
 
     auto* sem = Sem().Get(expr);
     EXPECT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -892,9 +892,9 @@
 
     auto* sem = Sem().Get(expr);
     EXPECT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
@@ -923,9 +923,9 @@
 
     auto* sem = Sem().Get(expr);
     EXPECT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F16>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -954,9 +954,9 @@
 
     auto* sem = Sem().Get(expr);
     EXPECT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F16>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -985,9 +985,9 @@
 
     auto* sem = Sem().Get(expr);
     EXPECT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F16>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
@@ -1016,9 +1016,9 @@
 
     auto* sem = Sem().Get(expr);
     EXPECT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F16>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -1047,9 +1047,9 @@
 
     auto* sem = Sem().Get(expr);
     EXPECT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F16>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
@@ -1076,9 +1076,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::Bool>());
+    EXPECT_TRUE(vec->type()->Is<core::type::Bool>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
@@ -1105,9 +1105,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::Bool>());
+    EXPECT_TRUE(vec->type()->Is<core::type::Bool>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -1134,9 +1134,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::Bool>());
+    EXPECT_TRUE(vec->type()->Is<core::type::Bool>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
@@ -1163,9 +1163,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* mat = sem->Type()->As<type::Matrix>();
+    auto* mat = sem->Type()->As<core::type::Matrix>();
     ASSERT_NE(mat, nullptr);
-    EXPECT_TRUE(mat->type()->Is<type::F32>());
+    EXPECT_TRUE(mat->type()->Is<core::type::F32>());
     EXPECT_EQ(mat->columns(), 2u);
     EXPECT_EQ(mat->rows(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
@@ -1207,9 +1207,9 @@
 
     auto* sem = Sem().Get(expr);
     EXPECT_NE(sem, nullptr);
-    auto* mat = sem->Type()->As<type::Matrix>();
+    auto* mat = sem->Type()->As<core::type::Matrix>();
     ASSERT_NE(mat, nullptr);
-    EXPECT_TRUE(mat->type()->Is<type::F16>());
+    EXPECT_TRUE(mat->type()->Is<core::type::F16>());
     EXPECT_EQ(mat->columns(), 2u);
     EXPECT_EQ(mat->rows(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
@@ -1249,9 +1249,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* mat = sem->Type()->As<type::Matrix>();
+    auto* mat = sem->Type()->As<core::type::Matrix>();
     ASSERT_NE(mat, nullptr);
-    EXPECT_TRUE(mat->type()->Is<type::F32>());
+    EXPECT_TRUE(mat->type()->Is<core::type::F32>());
     EXPECT_EQ(mat->columns(), 3u);
     EXPECT_EQ(mat->rows(), 2u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
@@ -1294,9 +1294,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* mat = sem->Type()->As<type::Matrix>();
+    auto* mat = sem->Type()->As<core::type::Matrix>();
     ASSERT_NE(mat, nullptr);
-    EXPECT_TRUE(mat->type()->Is<type::F32>());
+    EXPECT_TRUE(mat->type()->Is<core::type::F32>());
     EXPECT_EQ(mat->columns(), 3u);
     EXPECT_EQ(mat->rows(), 2u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
@@ -1336,9 +1336,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* arr = sem->Type()->As<type::Array>();
+    auto* arr = sem->Type()->As<core::type::Array>();
     ASSERT_NE(arr, nullptr);
-    EXPECT_TRUE(arr->ElemType()->Is<type::I32>());
+    EXPECT_TRUE(arr->ElemType()->Is<core::type::I32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
@@ -1368,9 +1368,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* arr = sem->Type()->As<type::Array>();
+    auto* arr = sem->Type()->As<core::type::Array>();
     ASSERT_NE(arr, nullptr);
-    EXPECT_TRUE(arr->ElemType()->Is<type::F32>());
+    EXPECT_TRUE(arr->ElemType()->Is<core::type::F32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
@@ -1400,9 +1400,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* arr = sem->Type()->As<type::Array>();
+    auto* arr = sem->Type()->As<core::type::Array>();
     ASSERT_NE(arr, nullptr);
-    EXPECT_TRUE(arr->ElemType()->Is<type::Vector>());
+    EXPECT_TRUE(arr->ElemType()->Is<core::type::Vector>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
@@ -1444,9 +1444,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* arr = sem->Type()->As<type::Array>();
+    auto* arr = sem->Type()->As<core::type::Array>();
     ASSERT_NE(arr, nullptr);
-    EXPECT_TRUE(arr->ElemType()->Is<type::Struct>());
+    EXPECT_TRUE(arr->ElemType()->Is<core::type::Struct>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
@@ -1476,9 +1476,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* arr = sem->Type()->As<type::Array>();
+    auto* arr = sem->Type()->As<core::type::Array>();
     ASSERT_NE(arr, nullptr);
-    EXPECT_TRUE(arr->ElemType()->Is<type::I32>());
+    EXPECT_TRUE(arr->ElemType()->Is<core::type::I32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
@@ -1523,7 +1523,7 @@
 
     auto* sem = Sem().GetVal(expr);
     ASSERT_NE(sem, nullptr);
-    auto* arr = sem->Type()->As<type::Array>();
+    auto* arr = sem->Type()->As<core::type::Array>();
     ASSERT_NE(arr, nullptr);
 
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
@@ -1568,10 +1568,10 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* outer_arr = sem->Type()->As<type::Array>();
+    auto* outer_arr = sem->Type()->As<core::type::Array>();
     ASSERT_NE(outer_arr, nullptr);
-    EXPECT_TRUE(outer_arr->ElemType()->Is<type::Array>());
-    EXPECT_TRUE(outer_arr->ElemType()->As<type::Array>()->ElemType()->Is<type::F32>());
+    EXPECT_TRUE(outer_arr->ElemType()->Is<core::type::Array>());
+    EXPECT_TRUE(outer_arr->ElemType()->As<core::type::Array>()->ElemType()->Is<core::type::F32>());
 
     auto* arr = sem->ConstantValue();
     EXPECT_FALSE(arr->AnyZero());
@@ -1600,9 +1600,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* arr = sem->Type()->As<type::Array>();
+    auto* arr = sem->Type()->As<core::type::Array>();
     ASSERT_NE(arr, nullptr);
-    EXPECT_TRUE(arr->ElemType()->Is<type::F32>());
+    EXPECT_TRUE(arr->ElemType()->Is<core::type::F32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
@@ -1633,9 +1633,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* arr = sem->Type()->As<type::Array>();
+    auto* arr = sem->Type()->As<core::type::Array>();
     ASSERT_NE(arr, nullptr);
-    EXPECT_TRUE(arr->ElemType()->Is<type::Vector>());
+    EXPECT_TRUE(arr->ElemType()->Is<core::type::Vector>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
@@ -1661,9 +1661,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* arr = sem->Type()->As<type::Array>();
+    auto* arr = sem->Type()->As<core::type::Array>();
     ASSERT_NE(arr, nullptr);
-    EXPECT_TRUE(arr->ElemType()->Is<type::Struct>());
+    EXPECT_TRUE(arr->ElemType()->Is<core::type::Struct>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
@@ -1703,7 +1703,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<type::Struct>();
+    auto* str = sem->Type()->As<core::type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 5u);
 
@@ -1711,15 +1711,15 @@
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->AllZero());
 
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::I32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<core::type::I32>());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<i32>(), 0);
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::U32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<core::type::U32>());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<u32>(), 0u);
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<type::F32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<core::type::F32>());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<f32>(), 0.0f);
-    EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<type::F16>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<core::type::F16>());
     EXPECT_EQ(sem->ConstantValue()->Index(3)->ValueAs<f16>(), 0.0f);
-    EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<type::Bool>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<core::type::Bool>());
     EXPECT_EQ(sem->ConstantValue()->Index(4)->ValueAs<bool>(), false);
 
     for (size_t i = 0; i < str->Members().Length(); ++i) {
@@ -1750,7 +1750,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<type::Struct>();
+    auto* str = sem->Type()->As<core::type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 1u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
@@ -1761,15 +1761,15 @@
     EXPECT_TRUE(inner_struct->AnyZero());
     EXPECT_TRUE(inner_struct->AllZero());
 
-    EXPECT_TRUE(inner_struct->Index(0)->Type()->Is<type::I32>());
+    EXPECT_TRUE(inner_struct->Index(0)->Type()->Is<core::type::I32>());
     EXPECT_EQ(inner_struct->Index(0)->ValueAs<i32>(), 0);
-    EXPECT_TRUE(inner_struct->Index(1)->Type()->Is<type::U32>());
+    EXPECT_TRUE(inner_struct->Index(1)->Type()->Is<core::type::U32>());
     EXPECT_EQ(inner_struct->Index(1)->ValueAs<u32>(), 0u);
-    EXPECT_TRUE(inner_struct->Index(2)->Type()->Is<type::F32>());
+    EXPECT_TRUE(inner_struct->Index(2)->Type()->Is<core::type::F32>());
     EXPECT_EQ(inner_struct->Index(2)->ValueAs<f32>(), 0.0f);
-    EXPECT_TRUE(inner_struct->Index(3)->Type()->Is<type::F16>());
+    EXPECT_TRUE(inner_struct->Index(3)->Type()->Is<core::type::F16>());
     EXPECT_EQ(inner_struct->Index(3)->ValueAs<f16>(), 0.0f);
-    EXPECT_TRUE(inner_struct->Index(4)->Type()->Is<type::Bool>());
+    EXPECT_TRUE(inner_struct->Index(4)->Type()->Is<core::type::Bool>());
     EXPECT_EQ(inner_struct->Index(4)->ValueAs<bool>(), false);
 
     for (size_t i = 0; i < str->Members().Length(); ++i) {
@@ -1787,7 +1787,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<type::Struct>();
+    auto* str = sem->Type()->As<core::type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 3u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
@@ -1797,17 +1797,17 @@
 
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::I32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<core::type::I32>());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<i32>(), 0_i);
 
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::I32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<core::type::I32>());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<i32>(), 0_i);
 
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<type::I32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<core::type::I32>());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<i32>(), 0_i);
 }
 
@@ -1828,7 +1828,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<type::Struct>();
+    auto* str = sem->Type()->As<core::type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 5u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
@@ -1838,27 +1838,27 @@
 
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::I32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<core::type::I32>());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<i32>(), 0_i);
 
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::U32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<core::type::U32>());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<u32>(), 0_u);
 
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<type::F32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<core::type::F32>());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<f32>(), 0._f);
 
     EXPECT_TRUE(sem->ConstantValue()->Index(3)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(3)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<type::F16>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<core::type::F16>());
     EXPECT_EQ(sem->ConstantValue()->Index(3)->ValueAs<f16>(), 0._h);
 
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<type::Bool>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<core::type::Bool>());
     EXPECT_EQ(sem->ConstantValue()->Index(4)->ValueAs<bool>(), false);
 }
 
@@ -1875,7 +1875,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<type::Struct>();
+    auto* str = sem->Type()->As<core::type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 3u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
@@ -1885,27 +1885,39 @@
 
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::Vector>());
-    EXPECT_TRUE(
-        sem->ConstantValue()->Index(0)->Type()->As<type::Vector>()->type()->Is<type::F32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(sem->ConstantValue()
+                    ->Index(0)
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::F32>());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<f32>(), 0._f);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<f32>(), 0._f);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(2)->ValueAs<f32>(), 0._f);
 
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::Vector>());
-    EXPECT_TRUE(
-        sem->ConstantValue()->Index(1)->Type()->As<type::Vector>()->type()->Is<type::F32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(sem->ConstantValue()
+                    ->Index(1)
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::F32>());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->ValueAs<f32>(), 0._f);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<f32>(), 0._f);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->ValueAs<f32>(), 0._f);
 
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<type::Vector>());
-    EXPECT_TRUE(
-        sem->ConstantValue()->Index(2)->Type()->As<type::Vector>()->type()->Is<type::F32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(sem->ConstantValue()
+                    ->Index(2)
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::F32>());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(0)->ValueAs<f32>(), 0._f);
     EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(1)->ValueAs<f32>(), 0._f);
     EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(2)->ValueAs<f32>(), 0._f);
@@ -1928,7 +1940,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<type::Struct>();
+    auto* str = sem->Type()->As<core::type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 5u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
@@ -1938,26 +1950,38 @@
 
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::Vector>());
-    EXPECT_TRUE(
-        sem->ConstantValue()->Index(0)->Type()->As<type::Vector>()->type()->Is<type::I32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(sem->ConstantValue()
+                    ->Index(0)
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::I32>());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<i32>(), 0_i);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<i32>(), 0_i);
 
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::Vector>());
-    EXPECT_TRUE(
-        sem->ConstantValue()->Index(1)->Type()->As<type::Vector>()->type()->Is<type::U32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(sem->ConstantValue()
+                    ->Index(1)
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::U32>());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->ValueAs<u32>(), 0_u);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<u32>(), 0_u);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->ValueAs<u32>(), 0_u);
 
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(2)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<type::Vector>());
-    EXPECT_TRUE(
-        sem->ConstantValue()->Index(2)->Type()->As<type::Vector>()->type()->Is<type::F32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(sem->ConstantValue()
+                    ->Index(2)
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::F32>());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(0)->ValueAs<f32>(), 0._f);
     EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(1)->ValueAs<f32>(), 0._f);
     EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(2)->ValueAs<f32>(), 0._f);
@@ -1965,18 +1989,26 @@
 
     EXPECT_TRUE(sem->ConstantValue()->Index(3)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(3)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<type::Vector>());
-    EXPECT_TRUE(
-        sem->ConstantValue()->Index(3)->Type()->As<type::Vector>()->type()->Is<type::F16>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(sem->ConstantValue()
+                    ->Index(3)
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::F16>());
     EXPECT_EQ(sem->ConstantValue()->Index(3)->Index(0)->ValueAs<f16>(), 0._h);
     EXPECT_EQ(sem->ConstantValue()->Index(3)->Index(1)->ValueAs<f16>(), 0._h);
     EXPECT_EQ(sem->ConstantValue()->Index(3)->Index(2)->ValueAs<f16>(), 0._h);
 
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<type::Vector>());
-    EXPECT_TRUE(
-        sem->ConstantValue()->Index(4)->Type()->As<type::Vector>()->type()->Is<type::Bool>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(sem->ConstantValue()
+                    ->Index(4)
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::Bool>());
     EXPECT_EQ(sem->ConstantValue()->Index(4)->Index(0)->ValueAs<bool>(), false);
     EXPECT_EQ(sem->ConstantValue()->Index(4)->Index(1)->ValueAs<bool>(), false);
 }
@@ -1999,7 +2031,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<type::Struct>();
+    auto* str = sem->Type()->As<core::type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 2u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
@@ -2009,14 +2041,14 @@
 
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::Struct>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<core::type::Struct>());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<i32>(), 0_i);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<u32>(), 0_u);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(2)->ValueAs<f32>(), 0_f);
 
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::Struct>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<core::type::Struct>());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->ValueAs<i32>(), 0_i);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<u32>(), 0_u);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->ValueAs<f32>(), 0_f);
@@ -2039,7 +2071,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<type::Struct>();
+    auto* str = sem->Type()->As<core::type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 5u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
@@ -2049,27 +2081,27 @@
 
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::I32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<core::type::I32>());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->ValueAs<i32>(), 1_i);
 
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::U32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<core::type::U32>());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->ValueAs<u32>(), 2_u);
 
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<type::F32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<core::type::F32>());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->ValueAs<f32>(), 3._f);
 
     EXPECT_FALSE(sem->ConstantValue()->Index(3)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(3)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<type::F16>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<core::type::F16>());
     EXPECT_EQ(sem->ConstantValue()->Index(3)->ValueAs<f16>(), 4._h);
 
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<type::Bool>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<core::type::Bool>());
     EXPECT_EQ(sem->ConstantValue()->Index(4)->ValueAs<bool>(), false);
 }
 
@@ -2091,7 +2123,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<type::Struct>();
+    auto* str = sem->Type()->As<core::type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 5u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
@@ -2101,26 +2133,38 @@
 
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::Vector>());
-    EXPECT_TRUE(
-        sem->ConstantValue()->Index(0)->Type()->As<type::Vector>()->type()->Is<type::I32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(sem->ConstantValue()
+                    ->Index(0)
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::I32>());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<i32>(), 1_i);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<i32>(), 1_i);
 
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::Vector>());
-    EXPECT_TRUE(
-        sem->ConstantValue()->Index(1)->Type()->As<type::Vector>()->type()->Is<type::U32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(sem->ConstantValue()
+                    ->Index(1)
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::U32>());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->ValueAs<u32>(), 2_u);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<u32>(), 2_u);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->ValueAs<u32>(), 2_u);
 
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(2)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<type::Vector>());
-    EXPECT_TRUE(
-        sem->ConstantValue()->Index(2)->Type()->As<type::Vector>()->type()->Is<type::F32>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(2)->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(sem->ConstantValue()
+                    ->Index(2)
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::F32>());
     EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(0)->ValueAs<f32>(), 3._f);
     EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(1)->ValueAs<f32>(), 3._f);
     EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(2)->ValueAs<f32>(), 3._f);
@@ -2128,18 +2172,26 @@
 
     EXPECT_FALSE(sem->ConstantValue()->Index(3)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(3)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<type::Vector>());
-    EXPECT_TRUE(
-        sem->ConstantValue()->Index(3)->Type()->As<type::Vector>()->type()->Is<type::F16>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(3)->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(sem->ConstantValue()
+                    ->Index(3)
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::F16>());
     EXPECT_EQ(sem->ConstantValue()->Index(3)->Index(0)->ValueAs<f16>(), 4._h);
     EXPECT_EQ(sem->ConstantValue()->Index(3)->Index(1)->ValueAs<f16>(), 4._h);
     EXPECT_EQ(sem->ConstantValue()->Index(3)->Index(2)->ValueAs<f16>(), 4._h);
 
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->AnyZero());
     EXPECT_TRUE(sem->ConstantValue()->Index(4)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<type::Vector>());
-    EXPECT_TRUE(
-        sem->ConstantValue()->Index(4)->Type()->As<type::Vector>()->type()->Is<type::Bool>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(4)->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(sem->ConstantValue()
+                    ->Index(4)
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::Bool>());
     EXPECT_EQ(sem->ConstantValue()->Index(4)->Index(0)->ValueAs<bool>(), false);
     EXPECT_EQ(sem->ConstantValue()->Index(4)->Index(1)->ValueAs<bool>(), false);
 }
@@ -2163,7 +2215,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<type::Struct>();
+    auto* str = sem->Type()->As<core::type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 2u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
@@ -2173,14 +2225,14 @@
 
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::Struct>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<core::type::Struct>());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<i32>(), 1_i);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<u32>(), 2_u);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(2)->ValueAs<f32>(), 3_f);
 
     EXPECT_TRUE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::Struct>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<core::type::Struct>());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->ValueAs<i32>(), 4_i);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<u32>(), 0_u);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->ValueAs<f32>(), 6_f);
@@ -2199,7 +2251,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* str = sem->Type()->As<type::Struct>();
+    auto* str = sem->Type()->As<core::type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 2u);
     ASSERT_NE(sem->ConstantValue(), nullptr);
@@ -2209,13 +2261,13 @@
 
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(0)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<type::Array>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(0)->Type()->Is<core::type::Array>());
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(0)->ValueAs<i32>(), 1_i);
     EXPECT_EQ(sem->ConstantValue()->Index(0)->Index(1)->ValueAs<u32>(), 2_i);
 
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->Index(1)->AllZero());
-    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<type::Array>());
+    EXPECT_TRUE(sem->ConstantValue()->Index(1)->Type()->Is<core::type::Array>());
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(0)->ValueAs<i32>(), 1_f);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->ValueAs<u32>(), 2_f);
     EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->ValueAs<f32>(), 3_f);
diff --git a/src/tint/lang/core/constant/eval_conversion_test.cc b/src/tint/lang/core/constant/eval_conversion_test.cc
index b7e952d..23279d4 100644
--- a/src/tint/lang/core/constant/eval_conversion_test.cc
+++ b/src/tint/lang/core/constant/eval_conversion_test.cc
@@ -82,7 +82,7 @@
 
     auto* target_sem_ty = type.sem(*this);
     if (kind == Kind::kVector) {
-        target_sem_ty = create<type::Vector>(target_sem_ty, 3u);
+        target_sem_ty = create<core::type::Vector>(target_sem_ty, 3u);
     }
 
     if (unrepresentable) {
@@ -233,9 +233,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::I32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::I32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -262,9 +262,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -293,9 +293,9 @@
 
     auto* sem = Sem().Get(expr);
     EXPECT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::I32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::I32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -324,9 +324,9 @@
 
     auto* sem = Sem().Get(expr);
     EXPECT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F16>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -353,9 +353,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::I32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::I32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
@@ -382,9 +382,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::U32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::U32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
@@ -423,9 +423,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F16>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F16>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_TRUE(sem->ConstantValue()->AnyZero());
@@ -466,12 +466,12 @@
 
     EXPECT_TRUE(c->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(c->ConstantValue()->Index(0)->AllZero());
-    EXPECT_TRUE(c->ConstantValue()->Index(0)->Type()->Is<type::AbstractFloat>());
+    EXPECT_TRUE(c->ConstantValue()->Index(0)->Type()->Is<core::type::AbstractFloat>());
     EXPECT_EQ(c->ConstantValue()->Index(0)->ValueAs<AFloat>(), 0_f);
 
     EXPECT_TRUE(c->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(c->ConstantValue()->Index(1)->AllZero());
-    EXPECT_TRUE(c->ConstantValue()->Index(1)->Type()->Is<type::AbstractFloat>());
+    EXPECT_TRUE(c->ConstantValue()->Index(1)->Type()->Is<core::type::AbstractFloat>());
     EXPECT_EQ(c->ConstantValue()->Index(1)->ValueAs<AFloat>(), 0_a);
 
     auto* v = Sem().GetVal(materialized);
@@ -483,12 +483,12 @@
 
     EXPECT_TRUE(v->ConstantValue()->Index(0)->AnyZero());
     EXPECT_TRUE(v->ConstantValue()->Index(0)->AllZero());
-    EXPECT_TRUE(v->ConstantValue()->Index(0)->Type()->Is<type::F32>());
+    EXPECT_TRUE(v->ConstantValue()->Index(0)->Type()->Is<core::type::F32>());
     EXPECT_EQ(v->ConstantValue()->Index(0)->ValueAs<f32>(), 0_f);
 
     EXPECT_TRUE(v->ConstantValue()->Index(1)->AnyZero());
     EXPECT_TRUE(v->ConstantValue()->Index(1)->AllZero());
-    EXPECT_TRUE(v->ConstantValue()->Index(1)->Type()->Is<type::F32>());
+    EXPECT_TRUE(v->ConstantValue()->Index(1)->Type()->Is<core::type::F32>());
     EXPECT_EQ(v->ConstantValue()->Index(1)->ValueAs<f32>(), 0_f);
 }
 
diff --git a/src/tint/lang/core/constant/eval_indexing_test.cc b/src/tint/lang/core/constant/eval_indexing_test.cc
index 8ee61b4..c84a71e 100644
--- a/src/tint/lang/core/constant/eval_indexing_test.cc
+++ b/src/tint/lang/core/constant/eval_indexing_test.cc
@@ -28,7 +28,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    ASSERT_TRUE(sem->Type()->Is<type::I32>());
+    ASSERT_TRUE(sem->Type()->Is<core::type::I32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
@@ -131,7 +131,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    ASSERT_TRUE(sem->Type()->Is<type::I32>());
+    ASSERT_TRUE(sem->Type()->Is<core::type::I32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
@@ -146,7 +146,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
     EXPECT_EQ(vec->Width(), 2u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
@@ -170,7 +170,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    ASSERT_TRUE(sem->Type()->Is<type::I32>());
+    ASSERT_TRUE(sem->Type()->Is<core::type::I32>());
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
     EXPECT_FALSE(sem->ConstantValue()->AnyZero());
     EXPECT_FALSE(sem->ConstantValue()->AllZero());
@@ -188,7 +188,7 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
     EXPECT_EQ(vec->Width(), 2u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
@@ -235,9 +235,9 @@
 
     auto* sem = Sem().Get(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
-    EXPECT_TRUE(vec->type()->Is<type::F32>());
+    EXPECT_TRUE(vec->type()->Is<core::type::F32>());
     EXPECT_EQ(vec->Width(), 3u);
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
 
@@ -303,9 +303,9 @@
     {
         auto* mat = Sem().Get(mat_expr);
         EXPECT_NE(mat, nullptr);
-        auto* ty = mat->Type()->As<type::Matrix>();
+        auto* ty = mat->Type()->As<core::type::Matrix>();
         ASSERT_NE(mat->Type(), nullptr);
-        EXPECT_TRUE(ty->ColumnType()->Is<type::Vector>());
+        EXPECT_TRUE(ty->ColumnType()->Is<core::type::Vector>());
         EXPECT_EQ(ty->columns(), 2u);
         EXPECT_EQ(ty->rows(), 3u);
         EXPECT_EQ(mat->ConstantValue()->Type(), mat->Type());
@@ -339,9 +339,9 @@
     {
         auto* vec = Sem().Get(vec_expr);
         EXPECT_NE(vec, nullptr);
-        auto* ty = vec->Type()->As<type::Vector>();
+        auto* ty = vec->Type()->As<core::type::Vector>();
         ASSERT_NE(vec->Type(), nullptr);
-        EXPECT_TRUE(ty->type()->Is<type::F32>());
+        EXPECT_TRUE(ty->type()->Is<core::type::F32>());
         EXPECT_EQ(ty->Width(), 3u);
         EXPECT_EQ(vec->ConstantValue()->Type(), vec->Type());
         EXPECT_TRUE(vec->ConstantValue()->AnyZero());
@@ -362,7 +362,7 @@
     {
         auto* f = Sem().Get(f32_expr);
         EXPECT_NE(f, nullptr);
-        EXPECT_TRUE(f->Type()->Is<type::F32>());
+        EXPECT_TRUE(f->Type()->Is<core::type::F32>());
         EXPECT_EQ(f->ConstantValue()->Type(), f->Type());
         EXPECT_FALSE(f->ConstantValue()->AnyZero());
         EXPECT_FALSE(f->ConstantValue()->AllZero());
diff --git a/src/tint/lang/core/constant/eval_member_access_test.cc b/src/tint/lang/core/constant/eval_member_access_test.cc
index 34a3007..fb6271d 100644
--- a/src/tint/lang/core/constant/eval_member_access_test.cc
+++ b/src/tint/lang/core/constant/eval_member_access_test.cc
@@ -42,7 +42,7 @@
 
     auto* outer = Sem().Get(outer_expr);
     ASSERT_NE(outer, nullptr);
-    auto* str = outer->Type()->As<type::Struct>();
+    auto* str = outer->Type()->As<core::type::Struct>();
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Members().Length(), 2u);
     ASSERT_NE(outer->ConstantValue(), nullptr);
@@ -54,7 +54,7 @@
     ASSERT_NE(o1->ConstantValue(), nullptr);
     EXPECT_FALSE(o1->ConstantValue()->AnyZero());
     EXPECT_FALSE(o1->ConstantValue()->AllZero());
-    EXPECT_TRUE(o1->ConstantValue()->Type()->Is<type::Struct>());
+    EXPECT_TRUE(o1->ConstantValue()->Type()->Is<core::type::Struct>());
     EXPECT_EQ(o1->ConstantValue()->Index(0)->ValueAs<i32>(), 1_i);
     EXPECT_EQ(o1->ConstantValue()->Index(1)->ValueAs<u32>(), 2_u);
     EXPECT_EQ(o1->ConstantValue()->Index(2)->ValueAs<f32>(), 3_f);
@@ -64,7 +64,7 @@
     ASSERT_NE(i2->ConstantValue(), nullptr);
     EXPECT_FALSE(i2->ConstantValue()->AnyZero());
     EXPECT_FALSE(i2->ConstantValue()->AllZero());
-    EXPECT_TRUE(i2->ConstantValue()->Type()->Is<type::U32>());
+    EXPECT_TRUE(i2->ConstantValue()->Type()->Is<core::type::U32>());
     EXPECT_EQ(i2->ConstantValue()->ValueAs<u32>(), 2_u);
 }
 
@@ -78,11 +78,11 @@
 
     auto* sem = Sem().Get(c);
     ASSERT_NE(sem, nullptr);
-    EXPECT_TRUE(sem->Type()->Is<type::Matrix>());
+    EXPECT_TRUE(sem->Type()->Is<core::type::Matrix>());
     auto* cv = sem->ConstantValue();
     EXPECT_TYPE(cv->Type(), sem->Type());
-    EXPECT_TRUE(cv->Index(0)->Type()->Is<type::Vector>());
-    EXPECT_TRUE(cv->Index(0)->Index(0)->Type()->Is<type::AbstractFloat>());
+    EXPECT_TRUE(cv->Index(0)->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(cv->Index(0)->Index(0)->Type()->Is<core::type::AbstractFloat>());
     EXPECT_FALSE(cv->AnyZero());
     EXPECT_FALSE(cv->AllZero());
     auto* c0 = cv->Index(0);
@@ -116,56 +116,56 @@
 
     auto* sem = Sem().Get(c);
     ASSERT_NE(sem, nullptr);
-    EXPECT_TRUE(sem->Type()->Is<type::Matrix>());
+    EXPECT_TRUE(sem->Type()->Is<core::type::Matrix>());
     auto* cv = sem->ConstantValue();
     EXPECT_TYPE(cv->Type(), sem->Type());
-    EXPECT_TRUE(cv->Index(0)->Type()->Is<type::Vector>());
-    EXPECT_TRUE(cv->Index(0)->Index(0)->Type()->Is<type::AbstractFloat>());
+    EXPECT_TRUE(cv->Index(0)->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(cv->Index(0)->Index(0)->Type()->Is<core::type::AbstractFloat>());
     EXPECT_FALSE(cv->AnyZero());
     EXPECT_FALSE(cv->AllZero());
 
     auto* sem_col0 = Sem().Get(col_0);
     ASSERT_NE(sem_col0, nullptr);
-    EXPECT_TRUE(sem_col0->Type()->Is<type::Vector>());
+    EXPECT_TRUE(sem_col0->Type()->Is<core::type::Vector>());
     EXPECT_EQ(sem_col0->ConstantValue()->Index(0)->ValueAs<AFloat>(), 1.0);
     EXPECT_EQ(sem_col0->ConstantValue()->Index(1)->ValueAs<AFloat>(), 2.0);
     EXPECT_EQ(sem_col0->ConstantValue()->Index(2)->ValueAs<AFloat>(), 3.0);
 
     auto* sem_col1 = Sem().Get(col_1);
     ASSERT_NE(sem_col1, nullptr);
-    EXPECT_TRUE(sem_col1->Type()->Is<type::Vector>());
+    EXPECT_TRUE(sem_col1->Type()->Is<core::type::Vector>());
     EXPECT_EQ(sem_col1->ConstantValue()->Index(0)->ValueAs<AFloat>(), 4.0);
     EXPECT_EQ(sem_col1->ConstantValue()->Index(1)->ValueAs<AFloat>(), 5.0);
     EXPECT_EQ(sem_col1->ConstantValue()->Index(2)->ValueAs<AFloat>(), 6.0);
 
     auto* sem_e00 = Sem().Get(e00);
     ASSERT_NE(sem_e00, nullptr);
-    EXPECT_TRUE(sem_e00->Type()->Is<type::AbstractFloat>());
+    EXPECT_TRUE(sem_e00->Type()->Is<core::type::AbstractFloat>());
     EXPECT_EQ(sem_e00->ConstantValue()->ValueAs<AFloat>(), 1.0);
 
     auto* sem_e01 = Sem().Get(e01);
     ASSERT_NE(sem_e01, nullptr);
-    EXPECT_TRUE(sem_e01->Type()->Is<type::AbstractFloat>());
+    EXPECT_TRUE(sem_e01->Type()->Is<core::type::AbstractFloat>());
     EXPECT_EQ(sem_e01->ConstantValue()->ValueAs<AFloat>(), 2.0);
 
     auto* sem_e02 = Sem().Get(e02);
     ASSERT_NE(sem_e02, nullptr);
-    EXPECT_TRUE(sem_e02->Type()->Is<type::AbstractFloat>());
+    EXPECT_TRUE(sem_e02->Type()->Is<core::type::AbstractFloat>());
     EXPECT_EQ(sem_e02->ConstantValue()->ValueAs<AFloat>(), 3.0);
 
     auto* sem_e10 = Sem().Get(e10);
     ASSERT_NE(sem_e10, nullptr);
-    EXPECT_TRUE(sem_e10->Type()->Is<type::AbstractFloat>());
+    EXPECT_TRUE(sem_e10->Type()->Is<core::type::AbstractFloat>());
     EXPECT_EQ(sem_e10->ConstantValue()->ValueAs<AFloat>(), 4.0);
 
     auto* sem_e11 = Sem().Get(e11);
     ASSERT_NE(sem_e11, nullptr);
-    EXPECT_TRUE(sem_e11->Type()->Is<type::AbstractFloat>());
+    EXPECT_TRUE(sem_e11->Type()->Is<core::type::AbstractFloat>());
     EXPECT_EQ(sem_e11->ConstantValue()->ValueAs<AFloat>(), 5.0);
 
     auto* sem_e12 = Sem().Get(e12);
     ASSERT_NE(sem_e12, nullptr);
-    EXPECT_TRUE(sem_e12->Type()->Is<type::AbstractFloat>());
+    EXPECT_TRUE(sem_e12->Type()->Is<core::type::AbstractFloat>());
     EXPECT_EQ(sem_e12->ConstantValue()->ValueAs<AFloat>(), 6.0);
 }
 
@@ -192,56 +192,56 @@
 
     auto* sem = Sem().Get(c);
     ASSERT_NE(sem, nullptr);
-    EXPECT_TRUE(sem->Type()->Is<type::Matrix>());
+    EXPECT_TRUE(sem->Type()->Is<core::type::Matrix>());
     auto* cv = sem->ConstantValue();
     EXPECT_TYPE(cv->Type(), sem->Type());
-    EXPECT_TRUE(cv->Index(0)->Type()->Is<type::Vector>());
-    EXPECT_TRUE(cv->Index(0)->Index(0)->Type()->Is<type::F32>());
+    EXPECT_TRUE(cv->Index(0)->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(cv->Index(0)->Index(0)->Type()->Is<core::type::F32>());
     EXPECT_FALSE(cv->AnyZero());
     EXPECT_FALSE(cv->AllZero());
 
     auto* sem_col0 = Sem().Get(col_0);
     ASSERT_NE(sem_col0, nullptr);
-    EXPECT_TRUE(sem_col0->Type()->Is<type::Vector>());
+    EXPECT_TRUE(sem_col0->Type()->Is<core::type::Vector>());
     EXPECT_EQ(sem_col0->ConstantValue()->Index(0)->ValueAs<f32>(), 1.0f);
     EXPECT_EQ(sem_col0->ConstantValue()->Index(1)->ValueAs<f32>(), 2.0f);
     EXPECT_EQ(sem_col0->ConstantValue()->Index(2)->ValueAs<f32>(), 3.0f);
 
     auto* sem_col1 = Sem().Get(col_1);
     ASSERT_NE(sem_col1, nullptr);
-    EXPECT_TRUE(sem_col1->Type()->Is<type::Vector>());
+    EXPECT_TRUE(sem_col1->Type()->Is<core::type::Vector>());
     EXPECT_EQ(sem_col1->ConstantValue()->Index(0)->ValueAs<f32>(), 4.0f);
     EXPECT_EQ(sem_col1->ConstantValue()->Index(1)->ValueAs<f32>(), 5.0f);
     EXPECT_EQ(sem_col1->ConstantValue()->Index(2)->ValueAs<f32>(), 6.0f);
 
     auto* sem_e00 = Sem().Get(e00);
     ASSERT_NE(sem_e00, nullptr);
-    EXPECT_TRUE(sem_e00->Type()->Is<type::F32>());
+    EXPECT_TRUE(sem_e00->Type()->Is<core::type::F32>());
     EXPECT_EQ(sem_e00->ConstantValue()->ValueAs<f32>(), 1.0f);
 
     auto* sem_e01 = Sem().Get(e01);
     ASSERT_NE(sem_e01, nullptr);
-    EXPECT_TRUE(sem_e01->Type()->Is<type::F32>());
+    EXPECT_TRUE(sem_e01->Type()->Is<core::type::F32>());
     EXPECT_EQ(sem_e01->ConstantValue()->ValueAs<f32>(), 2.0f);
 
     auto* sem_e02 = Sem().Get(e02);
     ASSERT_NE(sem_e02, nullptr);
-    EXPECT_TRUE(sem_e02->Type()->Is<type::F32>());
+    EXPECT_TRUE(sem_e02->Type()->Is<core::type::F32>());
     EXPECT_EQ(sem_e02->ConstantValue()->ValueAs<f32>(), 3.0f);
 
     auto* sem_e10 = Sem().Get(e10);
     ASSERT_NE(sem_e10, nullptr);
-    EXPECT_TRUE(sem_e10->Type()->Is<type::F32>());
+    EXPECT_TRUE(sem_e10->Type()->Is<core::type::F32>());
     EXPECT_EQ(sem_e10->ConstantValue()->ValueAs<f32>(), 4.0f);
 
     auto* sem_e11 = Sem().Get(e11);
     ASSERT_NE(sem_e11, nullptr);
-    EXPECT_TRUE(sem_e11->Type()->Is<type::F32>());
+    EXPECT_TRUE(sem_e11->Type()->Is<core::type::F32>());
     EXPECT_EQ(sem_e11->ConstantValue()->ValueAs<f32>(), 5.0f);
 
     auto* sem_e12 = Sem().Get(e12);
     ASSERT_NE(sem_e12, nullptr);
-    EXPECT_TRUE(sem_e12->Type()->Is<type::F32>());
+    EXPECT_TRUE(sem_e12->Type()->Is<core::type::F32>());
     EXPECT_EQ(sem_e12->ConstantValue()->ValueAs<f32>(), 6.0f);
 }
 
@@ -281,7 +281,7 @@
 
     auto* sem = Sem().GetVal(expr);
     ASSERT_NE(sem, nullptr);
-    auto* arr = sem->Type()->As<type::Array>();
+    auto* arr = sem->Type()->As<core::type::Array>();
     ASSERT_NE(arr, nullptr);
 
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
@@ -356,7 +356,7 @@
 
     auto* sem = Sem().GetVal(expr);
     ASSERT_NE(sem, nullptr);
-    auto* vec = sem->Type()->As<type::Vector>();
+    auto* vec = sem->Type()->As<core::type::Vector>();
     ASSERT_NE(vec, nullptr);
 
     EXPECT_TYPE(sem->ConstantValue()->Type(), sem->Type());
diff --git a/src/tint/lang/core/constant/eval_runtime_semantics_test.cc b/src/tint/lang/core/constant/eval_runtime_semantics_test.cc
index f9b5dec..1407e86 100644
--- a/src/tint/lang/core/constant/eval_runtime_semantics_test.cc
+++ b/src/tint/lang/core/constant/eval_runtime_semantics_test.cc
@@ -433,7 +433,8 @@
 TEST_F(ConstEvalRuntimeSemanticsTest, Normalize_ZeroLength) {
     auto* zero = constants.Get(f32(0));
     auto* vec =
-        eval.VecSplat(create<type::Vector>(create<type::F32>(), 4u), Vector{zero}, {}).Get();
+        eval.VecSplat(create<core::type::Vector>(create<core::type::F32>(), 4u), Vector{zero}, {})
+            .Get();
     auto result = eval.normalize(vec->Type(), Vector{vec}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->Index(0)->ValueAs<f32>(), 0.f);
@@ -447,8 +448,9 @@
     auto* a = constants.Get(f32(75250.f));
     auto* b = constants.Get(f32(42.1f));
     auto* vec =
-        eval.VecInitS(create<type::Vector>(create<type::F32>(), 2u), Vector{a, b}, {}).Get();
-    auto result = eval.pack2x16float(create<type::U32>(), Vector{vec}, {});
+        eval.VecInitS(create<core::type::Vector>(create<core::type::F32>(), 2u), Vector{a, b}, {})
+            .Get();
+    auto result = eval.pack2x16float(create<core::type::U32>(), Vector{vec}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<u32>(), 0x51430000);
     EXPECT_EQ(error(), R"(warning: value 75250.0 cannot be represented as 'f16')");
@@ -465,7 +467,7 @@
 
 TEST_F(ConstEvalRuntimeSemanticsTest, Unpack2x16Float_OutOfRange) {
     auto* a = constants.Get(u32(0x51437C00));
-    auto result = eval.unpack2x16float(create<type::U32>(), Vector{a}, {});
+    auto result = eval.unpack2x16float(create<core::type::U32>(), Vector{a}, {});
     ASSERT_TRUE(result);
     EXPECT_FLOAT_EQ(result.Get()->Index(0)->ValueAs<f32>(), 0.f);
     EXPECT_FLOAT_EQ(result.Get()->Index(1)->ValueAs<f32>(), 42.09375f);
@@ -474,7 +476,7 @@
 
 TEST_F(ConstEvalRuntimeSemanticsTest, QuantizeToF16_OutOfRange) {
     auto* a = constants.Get(f32(75250.f));
-    auto result = eval.quantizeToF16(create<type::U32>(), Vector{a}, {});
+    auto result = eval.quantizeToF16(create<core::type::U32>(), Vector{a}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<u32>(), 0);
     EXPECT_EQ(error(), R"(warning: value 75250.0 cannot be represented as 'f16')");
@@ -500,7 +502,7 @@
 
 TEST_F(ConstEvalRuntimeSemanticsTest, Bitcast_Infinity) {
     auto* a = constants.Get(u32(0x7F800000));
-    auto result = eval.Bitcast(create<type::F32>(), a, {});
+    auto result = eval.Bitcast(create<core::type::F32>(), a, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
     EXPECT_EQ(error(), R"(warning: value inf cannot be represented as 'f32')");
@@ -508,7 +510,7 @@
 
 TEST_F(ConstEvalRuntimeSemanticsTest, Bitcast_NaN) {
     auto* a = constants.Get(u32(0x7FC00000));
-    auto result = eval.Bitcast(create<type::F32>(), a, {});
+    auto result = eval.Bitcast(create<core::type::F32>(), a, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
     EXPECT_EQ(error(), R"(warning: value nan cannot be represented as 'f32')");
@@ -516,7 +518,7 @@
 
 TEST_F(ConstEvalRuntimeSemanticsTest, Convert_F32_TooHigh) {
     auto* a = constants.Get(AFloat::Highest());
-    auto result = eval.Convert(create<type::F32>(), a, {});
+    auto result = eval.Convert(create<core::type::F32>(), a, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), f32::kHighestValue);
     EXPECT_EQ(
@@ -526,7 +528,7 @@
 
 TEST_F(ConstEvalRuntimeSemanticsTest, Convert_F32_TooLow) {
     auto* a = constants.Get(AFloat::Lowest());
-    auto result = eval.Convert(create<type::F32>(), a, {});
+    auto result = eval.Convert(create<core::type::F32>(), a, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), f32::kLowestValue);
     EXPECT_EQ(
@@ -536,7 +538,7 @@
 
 TEST_F(ConstEvalRuntimeSemanticsTest, Convert_F16_TooHigh) {
     auto* a = constants.Get(f32(1000000.0));
-    auto result = eval.Convert(create<type::F16>(), a, {});
+    auto result = eval.Convert(create<core::type::F16>(), a, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), f16::kHighestValue);
     EXPECT_EQ(error(), R"(warning: value 1000000.0 cannot be represented as 'f16')");
@@ -544,7 +546,7 @@
 
 TEST_F(ConstEvalRuntimeSemanticsTest, Convert_F16_TooLow) {
     auto* a = constants.Get(f32(-1000000.0));
-    auto result = eval.Convert(create<type::F16>(), a, {});
+    auto result = eval.Convert(create<core::type::F16>(), a, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), f16::kLowestValue);
     EXPECT_EQ(error(), R"(warning: value -1000000.0 cannot be represented as 'f16')");
@@ -552,7 +554,7 @@
 
 TEST_F(ConstEvalRuntimeSemanticsTest, Vec_Overflow_SingleComponent) {
     // Test that overflow for an element-wise vector operation only affects a single component.
-    auto* vec4f = create<type::Vector>(create<type::F32>(), 4u);
+    auto* vec4f = create<core::type::Vector>(create<core::type::F32>(), 4u);
     auto* a = eval.VecInitS(vec4f,
                             Vector{
                                 constants.Get(f32(1)),
diff --git a/src/tint/lang/core/constant/eval_test.h b/src/tint/lang/core/constant/eval_test.h
index 0752b23..b874287 100644
--- a/src/tint/lang/core/constant/eval_test.h
+++ b/src/tint/lang/core/constant/eval_test.h
@@ -53,13 +53,13 @@
 inline void CollectScalars(const constant::Value* c, Vector<builder::Scalar, N>& scalars) {
     Switch(
         c->Type(),  //
-        [&](const type::AbstractInt*) { scalars.Push(c->ValueAs<AInt>()); },
-        [&](const type::AbstractFloat*) { scalars.Push(c->ValueAs<AFloat>()); },
-        [&](const type::Bool*) { scalars.Push(c->ValueAs<bool>()); },
-        [&](const type::I32*) { scalars.Push(c->ValueAs<i32>()); },
-        [&](const type::U32*) { scalars.Push(c->ValueAs<u32>()); },
-        [&](const type::F32*) { scalars.Push(c->ValueAs<f32>()); },
-        [&](const type::F16*) { scalars.Push(c->ValueAs<f16>()); },
+        [&](const core::type::AbstractInt*) { scalars.Push(c->ValueAs<AInt>()); },
+        [&](const core::type::AbstractFloat*) { scalars.Push(c->ValueAs<AFloat>()); },
+        [&](const core::type::Bool*) { scalars.Push(c->ValueAs<bool>()); },
+        [&](const core::type::I32*) { scalars.Push(c->ValueAs<i32>()); },
+        [&](const core::type::U32*) { scalars.Push(c->ValueAs<u32>()); },
+        [&](const core::type::F32*) { scalars.Push(c->ValueAs<f32>()); },
+        [&](const core::type::F16*) { scalars.Push(c->ValueAs<f16>()); },
         [&](Default) {
             size_t i = 0;
             while (auto* child = c->Index(i++)) {
diff --git a/src/tint/lang/core/constant/manager.cc b/src/tint/lang/core/constant/manager.cc
index 19d0b01..0a23ab4 100644
--- a/src/tint/lang/core/constant/manager.cc
+++ b/src/tint/lang/core/constant/manager.cc
@@ -37,7 +37,7 @@
 
 Manager::~Manager() = default;
 
-const constant::Value* Manager::Composite(const type::Type* type,
+const constant::Value* Manager::Composite(const core::type::Type* type,
                                           VectorRef<const constant::Value*> elements) {
     if (elements.IsEmpty()) {
         return nullptr;
@@ -68,7 +68,7 @@
     return Get<constant::Composite>(type, std::move(elements), all_zero, any_zero);
 }
 
-const constant::Splat* Manager::Splat(const type::Type* type,
+const constant::Splat* Manager::Splat(const core::type::Type* type,
                                       const constant::Value* element,
                                       size_t n) {
     return Get<constant::Splat>(type, element, n);
diff --git a/src/tint/lang/core/constant/manager.h b/src/tint/lang/core/constant/manager.h
index 1ce7188..3cc27be 100644
--- a/src/tint/lang/core/constant/manager.h
+++ b/src/tint/lang/core/constant/manager.h
@@ -63,7 +63,7 @@
     static Manager Wrap(const Manager& inner) {
         Manager out;
         out.values_.Wrap(inner.values_);
-        out.types = type::Manager::Wrap(inner.types);
+        out.types = core::type::Manager::Wrap(inner.types);
         return out;
     }
 
@@ -89,7 +89,7 @@
     /// @param type the composite type
     /// @param elements the composite elements
     /// @returns the value pointer
-    const constant::Value* Composite(const type::Type* type,
+    const constant::Value* Composite(const core::type::Type* type,
                                      VectorRef<const constant::Value*> elements);
 
     /// Constructs a splat constant.
@@ -97,7 +97,9 @@
     /// @param element the splat element
     /// @param n the number of elements
     /// @returns the value pointer
-    const constant::Splat* Splat(const type::Type* type, const constant::Value* element, size_t n);
+    const constant::Splat* Splat(const core::type::Type* type,
+                                 const constant::Value* element,
+                                 size_t n);
 
     /// @param value the constant value
     /// @return a Scalar holding the i32 value @p value
@@ -128,7 +130,7 @@
     const Scalar<AInt>* Get(AInt value);
 
     /// The type manager
-    type::Manager types;
+    core::type::Manager types;
 
   private:
     /// A specialization of Hasher for constant::Value
diff --git a/src/tint/lang/core/constant/manager_test.cc b/src/tint/lang/core/constant/manager_test.cc
index 6116644..f01a612 100644
--- a/src/tint/lang/core/constant/manager_test.cc
+++ b/src/tint/lang/core/constant/manager_test.cc
@@ -95,7 +95,7 @@
 
     auto* c = cm.Get(1_i);
     static_assert(std::is_same_v<const Scalar<i32>*, decltype(c)>);
-    ASSERT_TRUE(Is<type::I32>(c->Type()));
+    ASSERT_TRUE(Is<core::type::I32>(c->Type()));
     EXPECT_EQ(c->value, 1_i);
 }
 
@@ -104,7 +104,7 @@
 
     auto* c = cm.Get(1_u);
     static_assert(std::is_same_v<const Scalar<u32>*, decltype(c)>);
-    ASSERT_TRUE(Is<type::U32>(c->Type()));
+    ASSERT_TRUE(Is<core::type::U32>(c->Type()));
     EXPECT_EQ(c->value, 1_u);
 }
 
@@ -113,7 +113,7 @@
 
     auto* c = cm.Get(1_f);
     static_assert(std::is_same_v<const Scalar<f32>*, decltype(c)>);
-    ASSERT_TRUE(Is<type::F32>(c->Type()));
+    ASSERT_TRUE(Is<core::type::F32>(c->Type()));
     EXPECT_EQ(c->value, 1_f);
 }
 
@@ -122,7 +122,7 @@
 
     auto* c = cm.Get(1_h);
     static_assert(std::is_same_v<const Scalar<f16>*, decltype(c)>);
-    ASSERT_TRUE(Is<type::F16>(c->Type()));
+    ASSERT_TRUE(Is<core::type::F16>(c->Type()));
     EXPECT_EQ(c->value, 1_h);
 }
 
@@ -131,7 +131,7 @@
 
     auto* c = cm.Get(true);
     static_assert(std::is_same_v<const Scalar<bool>*, decltype(c)>);
-    ASSERT_TRUE(Is<type::Bool>(c->Type()));
+    ASSERT_TRUE(Is<core::type::Bool>(c->Type()));
     EXPECT_EQ(c->value, true);
 }
 
@@ -140,7 +140,7 @@
 
     auto* c = cm.Get(1._a);
     static_assert(std::is_same_v<const Scalar<AFloat>*, decltype(c)>);
-    ASSERT_TRUE(Is<type::AbstractFloat>(c->Type()));
+    ASSERT_TRUE(Is<core::type::AbstractFloat>(c->Type()));
     EXPECT_EQ(c->value, 1._a);
 }
 
@@ -149,7 +149,7 @@
 
     auto* c = cm.Get(1_a);
     static_assert(std::is_same_v<const Scalar<AInt>*, decltype(c)>);
-    ASSERT_TRUE(Is<type::AbstractInt>(c->Type()));
+    ASSERT_TRUE(Is<core::type::AbstractInt>(c->Type()));
     EXPECT_EQ(c->value, 1_a);
 }
 
@@ -172,12 +172,12 @@
     Manager inner;
     Manager outer = Manager::Wrap(inner);
 
-    inner.types.Get<type::I32>();
+    inner.types.Get<core::type::I32>();
 
     EXPECT_EQ(count(inner.types), 1u);
     EXPECT_EQ(count(outer.types), 0u);
 
-    outer.types.Get<type::U32>();
+    outer.types.Get<core::type::U32>();
 
     EXPECT_EQ(count(inner.types), 1u);
     EXPECT_EQ(count(outer.types), 1u);
diff --git a/src/tint/lang/core/constant/scalar.h b/src/tint/lang/core/constant/scalar.h
index 4db63dc..2389d44 100644
--- a/src/tint/lang/core/constant/scalar.h
+++ b/src/tint/lang/core/constant/scalar.h
@@ -41,7 +41,7 @@
     /// Constructor
     /// @param t the scalar type
     /// @param v the scalar value
-    Scalar(const type::Type* t, T v) : type(t), value(v) {
+    Scalar(const core::type::Type* t, T v) : type(t), value(v) {
         if constexpr (IsFloatingPoint<T>) {
             TINT_ASSERT(std::isfinite(v.value));
         }
@@ -49,7 +49,7 @@
     ~Scalar() override = default;
 
     /// @copydoc Value::Type()
-    const type::Type* Type() const override { return type; }
+    const core::type::Type* Type() const override { return type; }
 
     /// @return nullptr, as Scalar does not hold any elements.
     const Value* Index(size_t) const override { return nullptr; }
@@ -91,7 +91,7 @@
     }
 
     /// The scalar type
-    type::Type const* const type;
+    core::type::Type const* const type;
     /// The scalar value
     const T value;
 
diff --git a/src/tint/lang/core/constant/scalar_test.cc b/src/tint/lang/core/constant/scalar_test.cc
index 8b991d4..e4651de 100644
--- a/src/tint/lang/core/constant/scalar_test.cc
+++ b/src/tint/lang/core/constant/scalar_test.cc
@@ -167,11 +167,11 @@
     auto* val = constants.Get(12_i);
 
     constant::Manager mgr;
-    constant::CloneContext ctx{type::CloneContext{{nullptr}, {nullptr, &mgr.types}}, mgr};
+    constant::CloneContext ctx{core::type::CloneContext{{nullptr}, {nullptr, &mgr.types}}, mgr};
 
     auto* r = val->Clone(ctx);
     ASSERT_NE(r, nullptr);
-    EXPECT_TRUE(r->type->Is<type::I32>());
+    EXPECT_TRUE(r->type->Is<core::type::I32>());
     EXPECT_EQ(r->value, 12);
 }
 
diff --git a/src/tint/lang/core/constant/splat.cc b/src/tint/lang/core/constant/splat.cc
index 097010b..66e3ce9 100644
--- a/src/tint/lang/core/constant/splat.cc
+++ b/src/tint/lang/core/constant/splat.cc
@@ -20,7 +20,8 @@
 
 namespace tint::core::constant {
 
-Splat::Splat(const type::Type* t, const constant::Value* e, size_t n) : type(t), el(e), count(n) {}
+Splat::Splat(const core::type::Type* t, const constant::Value* e, size_t n)
+    : type(t), el(e), count(n) {}
 
 Splat::~Splat() = default;
 
diff --git a/src/tint/lang/core/constant/splat.h b/src/tint/lang/core/constant/splat.h
index 3ba3e13..9ea51ec 100644
--- a/src/tint/lang/core/constant/splat.h
+++ b/src/tint/lang/core/constant/splat.h
@@ -32,11 +32,11 @@
     /// @param t the splat type
     /// @param e the splat element
     /// @param n the number of items in the splat
-    Splat(const type::Type* t, const Value* e, size_t n);
+    Splat(const core::type::Type* t, const Value* e, size_t n);
     ~Splat() override;
 
     /// @returns the type of the splat
-    const type::Type* Type() const override { return type; }
+    const core::type::Type* Type() const override { return type; }
 
     /// Retrieve item at index @p i
     /// @param i the index to retrieve
@@ -60,7 +60,7 @@
     const Splat* Clone(CloneContext& ctx) const override;
 
     /// The type of the splat element
-    type::Type const* const type;
+    core::type::Type const* const type;
     /// The element stored in the splat
     const Value* el;
     /// The number of items in the splat
diff --git a/src/tint/lang/core/constant/splat_test.cc b/src/tint/lang/core/constant/splat_test.cc
index 796ab5f..8e3fa47 100644
--- a/src/tint/lang/core/constant/splat_test.cc
+++ b/src/tint/lang/core/constant/splat_test.cc
@@ -25,7 +25,7 @@
 using ConstantTest_Splat = TestHelper;
 
 TEST_F(ConstantTest_Splat, AllZero) {
-    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
+    auto* vec3f = create<core::type::Vector>(create<core::type::F32>(), 3u);
 
     auto* fPos0 = constants.Get(0_f);
     auto* fNeg0 = constants.Get(-0_f);
@@ -41,7 +41,7 @@
 }
 
 TEST_F(ConstantTest_Splat, AnyZero) {
-    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
+    auto* vec3f = create<core::type::Vector>(create<core::type::F32>(), 3u);
 
     auto* fPos0 = constants.Get(0_f);
     auto* fNeg0 = constants.Get(-0_f);
@@ -57,7 +57,7 @@
 }
 
 TEST_F(ConstantTest_Splat, Index) {
-    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
+    auto* vec3f = create<core::type::Vector>(create<core::type::F32>(), 3u);
 
     auto* f1 = constants.Get(1_f);
     auto* sp = constants.Splat(vec3f, f1, 2);
@@ -71,16 +71,16 @@
 }
 
 TEST_F(ConstantTest_Splat, Clone) {
-    auto* vec3i = create<type::Vector>(create<type::I32>(), 3u);
+    auto* vec3i = create<core::type::Vector>(create<core::type::I32>(), 3u);
     auto* val = constants.Get(12_i);
     auto* sp = constants.Splat(vec3i, val, 2);
 
     constant::Manager mgr;
-    constant::CloneContext ctx{type::CloneContext{{nullptr}, {nullptr, &mgr.types}}, mgr};
+    constant::CloneContext ctx{core::type::CloneContext{{nullptr}, {nullptr, &mgr.types}}, mgr};
 
     auto* r = sp->Clone(ctx);
     ASSERT_NE(r, nullptr);
-    EXPECT_TRUE(r->type->Is<type::Vector>());
+    EXPECT_TRUE(r->type->Is<core::type::Vector>());
     EXPECT_TRUE(r->el->Is<Scalar<tint::i32>>());
     EXPECT_EQ(r->count, 2u);
 }
diff --git a/src/tint/lang/core/constant/value.cc b/src/tint/lang/core/constant/value.cc
index c078af4..22806f7 100644
--- a/src/tint/lang/core/constant/value.cc
+++ b/src/tint/lang/core/constant/value.cc
@@ -84,10 +84,10 @@
 
     return Switch(
         Type(),  //
-        [&](const type::Vector* vec) { return elements_equal(vec->Width()); },
-        [&](const type::Matrix* mat) { return elements_equal(mat->columns()); },
-        [&](const type::Struct* str) { return elements_equal(str->Members().Length()); },
-        [&](const type::Array* arr) {
+        [&](const core::type::Vector* vec) { return elements_equal(vec->Width()); },
+        [&](const core::type::Matrix* mat) { return elements_equal(mat->columns()); },
+        [&](const core::type::Struct* str) { return elements_equal(str->Members().Length()); },
+        [&](const core::type::Array* arr) {
             if (auto n = arr->ConstantCount()) {
                 return elements_equal(*n);
             }
diff --git a/src/tint/lang/core/constant/value.h b/src/tint/lang/core/constant/value.h
index 0e55b0c..b1bf5b3 100644
--- a/src/tint/lang/core/constant/value.h
+++ b/src/tint/lang/core/constant/value.h
@@ -35,7 +35,7 @@
     ~Value() override;
 
     /// @returns the type of the value
-    virtual const type::Type* Type() const = 0;
+    virtual const core::type::Type* Type() const = 0;
 
     /// @param i the index of the element
     /// @returns the child element with the given index, or nullptr if there are no children, or
diff --git a/src/tint/lang/core/constant/value_test.cc b/src/tint/lang/core/constant/value_test.cc
index 2fcc934..a8f9308 100644
--- a/src/tint/lang/core/constant/value_test.cc
+++ b/src/tint/lang/core/constant/value_test.cc
@@ -39,7 +39,7 @@
 }
 
 TEST_F(ConstantTest_Value, Equal_Splat_Splat) {
-    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
+    auto* vec3f = create<core::type::Vector>(create<core::type::F32>(), 3u);
 
     auto* vec3f_1_1_1 = constants.Splat(vec3f, constants.Get(1_f), 3);
     auto* vec3f_2_2_2 = constants.Splat(vec3f, constants.Get(2_f), 3);
@@ -50,7 +50,7 @@
 }
 
 TEST_F(ConstantTest_Value, Equal_Composite_Composite) {
-    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
+    auto* vec3f = create<core::type::Vector>(create<core::type::F32>(), 3u);
 
     auto* vec3f_1_1_2 = constants.Composite(
         vec3f, Vector{constants.Get(1_f), constants.Get(1_f), constants.Get(2_f)});
@@ -63,7 +63,7 @@
 }
 
 TEST_F(ConstantTest_Value, Equal_Splat_Composite) {
-    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
+    auto* vec3f = create<core::type::Vector>(create<core::type::F32>(), 3u);
 
     auto* vec3f_1_1_1 = constants.Splat(vec3f, constants.Get(1_f), 3);
     auto* vec3f_1_2_1 = constants.Composite(
diff --git a/src/tint/lang/core/intrinsic/table.cc b/src/tint/lang/core/intrinsic/table.cc
index 65443b0..9c29b12 100644
--- a/src/tint/lang/core/intrinsic/table.cc
+++ b/src/tint/lang/core/intrinsic/table.cc
@@ -35,10 +35,10 @@
 const Number Number::any{Number::kAny};
 const Number Number::invalid{Number::kInvalid};
 
-Any::Any() : Base(0u, type::Flags{}) {}
+Any::Any() : Base(0u, core::type::Flags{}) {}
 Any::~Any() = default;
 
-bool Any::Equals(const type::UniqueNode&) const {
+bool Any::Equals(const core::type::UniqueNode&) const {
     return false;
 }
 
@@ -46,7 +46,7 @@
     return "<any>";
 }
 
-type::Type* Any::Clone(type::CloneContext&) const {
+core::type::Type* Any::Clone(core::type::CloneContext&) const {
     return nullptr;
 }
 
@@ -61,28 +61,28 @@
 /// Impl is the private implementation of the Table interface.
 class Impl : public Table {
   public:
-    Impl(const TableData& td, type::Manager& tys, SymbolTable& syms, diag::List& d);
+    Impl(const TableData& td, core::type::Manager& tys, SymbolTable& syms, diag::List& d);
 
     Result<Overload> Lookup(core::Function builtin_type,
-                            VectorRef<const type::Type*> args,
+                            VectorRef<const core::type::Type*> args,
                             EvaluationStage earliest_eval_stage,
                             const Source& source) override;
 
     Result<Overload> Lookup(core::UnaryOp op,
-                            const type::Type* arg,
+                            const core::type::Type* arg,
                             EvaluationStage earliest_eval_stage,
                             const Source& source) override;
 
     Result<Overload> Lookup(core::BinaryOp op,
-                            const type::Type* lhs,
-                            const type::Type* rhs,
+                            const core::type::Type* lhs,
+                            const core::type::Type* rhs,
                             EvaluationStage earliest_eval_stage,
                             const Source& source,
                             bool is_compound) override;
 
     Result<Overload> Lookup(CtorConv type,
-                            const type::Type* template_arg,
-                            VectorRef<const type::Type*> args,
+                            const core::type::Type* template_arg,
+                            VectorRef<const core::type::Type*> args,
                             EvaluationStage earliest_eval_stage,
                             const Source& source) override;
 
@@ -126,7 +126,7 @@
     /// @returns the matched intrinsic
     Result<Table::Overload> MatchIntrinsic(const IntrinsicInfo& intrinsic,
                                            const char* intrinsic_name,
-                                           VectorRef<const type::Type*> args,
+                                           VectorRef<const core::type::Type*> args,
                                            EvaluationStage earliest_eval_stage,
                                            TemplateState templates,
                                            const OnNoMatch& on_no_match) const;
@@ -139,7 +139,7 @@
     ///                  template as `f32`.
     /// @returns the evaluated Candidate information.
     Candidate ScoreOverload(const OverloadInfo& overload,
-                            VectorRef<const type::Type*> args,
+                            VectorRef<const core::type::Type*> args,
                             EvaluationStage earliest_eval_stage,
                             const TemplateState& templates) const;
 
@@ -155,7 +155,7 @@
     /// @returns the resolved Candidate.
     Candidate ResolveCandidate(Candidates&& candidates,
                                const char* intrinsic_name,
-                               VectorRef<const type::Type*> args,
+                               VectorRef<const core::type::Type*> args,
                                TemplateState templates) const;
 
     /// Match constructs a new MatchState
@@ -181,12 +181,12 @@
 
     /// Raises an error when no overload is a clear winner of overload resolution
     void ErrAmbiguousOverload(const char* intrinsic_name,
-                              VectorRef<const type::Type*> args,
+                              VectorRef<const core::type::Type*> args,
                               TemplateState templates,
                               VectorRef<Candidate> candidates) const;
 
     const TableData& data;
-    type::Manager& types;
+    core::type::Manager& types;
     SymbolTable& symbols;
     diag::List& diags;
 };
@@ -194,8 +194,8 @@
 /// @return a string representing a call to a builtin with the given argument
 /// types.
 std::string CallSignature(const char* intrinsic_name,
-                          VectorRef<const type::Type*> args,
-                          const type::Type* template_arg = nullptr) {
+                          VectorRef<const core::type::Type*> args,
+                          const core::type::Type* template_arg = nullptr) {
     StringStream ss;
     ss << intrinsic_name;
     if (template_arg) {
@@ -217,11 +217,11 @@
     return ss.str();
 }
 
-Impl::Impl(const TableData& td, type::Manager& tys, SymbolTable& syms, diag::List& d)
+Impl::Impl(const TableData& td, core::type::Manager& tys, SymbolTable& syms, diag::List& d)
     : data(td), types(tys), symbols(syms), diags(d) {}
 
 Result<Table::Overload> Impl::Lookup(core::Function builtin_type,
-                                     VectorRef<const type::Type*> args,
+                                     VectorRef<const core::type::Type*> args,
                                      EvaluationStage earliest_eval_stage,
                                      const Source& source) {
     const char* intrinsic_name = core::str(builtin_type);
@@ -245,7 +245,7 @@
 }
 
 Result<Table::Overload> Impl::Lookup(core::UnaryOp op,
-                                     const type::Type* arg,
+                                     const core::type::Type* arg,
                                      EvaluationStage earliest_eval_stage,
                                      const Source& source) {
     const IntrinsicInfo* intrinsic_info = nullptr;
@@ -289,8 +289,8 @@
 }
 
 Result<Table::Overload> Impl::Lookup(core::BinaryOp op,
-                                     const type::Type* lhs,
-                                     const type::Type* rhs,
+                                     const core::type::Type* lhs,
+                                     const core::type::Type* rhs,
                                      EvaluationStage earliest_eval_stage,
                                      const Source& source,
                                      bool is_compound) {
@@ -392,8 +392,8 @@
 }
 
 Result<Table::Overload> Impl::Lookup(CtorConv type,
-                                     const type::Type* template_arg,
-                                     VectorRef<const type::Type*> args,
+                                     const core::type::Type* template_arg,
+                                     VectorRef<const core::type::Type*> args,
                                      EvaluationStage earliest_eval_stage,
                                      const Source& source) {
     auto name = str(type);
@@ -439,7 +439,7 @@
 
 Result<Table::Overload> Impl::MatchIntrinsic(const IntrinsicInfo& intrinsic,
                                              const char* intrinsic_name,
-                                             VectorRef<const type::Type*> args,
+                                             VectorRef<const core::type::Type*> args,
                                              EvaluationStage earliest_eval_stage,
                                              TemplateState templates,
                                              const OnNoMatch& on_no_match) const {
@@ -479,7 +479,7 @@
     }
 
     // Build the return type
-    const type::Type* return_type = nullptr;
+    const core::type::Type* return_type = nullptr;
     if (auto* type_indices = data[match.overload->return_type_matcher_indices]) {
         auto* number_indices = data[match.overload->return_number_matcher_indices];
         Any any;
@@ -499,7 +499,7 @@
 }
 
 Impl::Candidate Impl::ScoreOverload(const OverloadInfo& overload,
-                                    VectorRef<const type::Type*> args,
+                                    VectorRef<const core::type::Type*> args,
                                     EvaluationStage earliest_eval_stage,
                                     const TemplateState& in_templates) const {
     // Penalty weights for overload mismatching.
@@ -617,7 +617,7 @@
 
 Impl::Candidate Impl::ResolveCandidate(Impl::Candidates&& candidates,
                                        const char* intrinsic_name,
-                                       VectorRef<const type::Type*> args,
+                                       VectorRef<const core::type::Type*> args,
                                        TemplateState templates) const {
     Vector<uint32_t, kNumFixedParams> best_ranks;
     best_ranks.Resize(args.Length(), 0xffffffff);
@@ -630,7 +630,7 @@
         bool some_won = false;   // An argument ranked less than the 'best' overload's argument
         bool some_lost = false;  // An argument ranked more than the 'best' overload's argument
         for (size_t i = 0; i < args.Length(); i++) {
-            auto rank = type::Type::ConversionRank(args[i], candidate.parameters[i].type);
+            auto rank = core::type::Type::ConversionRank(args[i], candidate.parameters[i].type);
             if (best_ranks[i] > rank) {
                 best_ranks[i] = rank;
                 some_won = true;
@@ -784,7 +784,7 @@
 }
 
 void Impl::ErrAmbiguousOverload(const char* intrinsic_name,
-                                VectorRef<const type::Type*> args,
+                                VectorRef<const core::type::Type*> args,
                                 TemplateState templates,
                                 VectorRef<Candidate> candidates) const {
     StringStream ss;
@@ -822,7 +822,7 @@
 }  // namespace
 
 std::unique_ptr<Table> Table::Create(const TableData& data,
-                                     type::Manager& types,
+                                     core::type::Manager& types,
                                      SymbolTable& symbols,
                                      diag::List& diags) {
     return std::make_unique<Impl>(data, types, symbols, diags);
diff --git a/src/tint/lang/core/intrinsic/table.h b/src/tint/lang/core/intrinsic/table.h
index 91bdbbe..faae544 100644
--- a/src/tint/lang/core/intrinsic/table.h
+++ b/src/tint/lang/core/intrinsic/table.h
@@ -45,7 +45,7 @@
     /// @param diags the diagnostic list to append errors to
     /// @return a pointer to a newly created Table
     static std::unique_ptr<Table> Create(const TableData& data,
-                                         type::Manager& types,
+                                         core::type::Manager& types,
                                          SymbolTable& symbols,
                                          diag::List& diags);
 
@@ -57,7 +57,7 @@
         /// Parameter describes a single parameter
         struct Parameter {
             /// Parameter type
-            const type::Type* const type;
+            const core::type::Type* const type;
             /// Parameter usage
             core::ParameterUsage const usage = core::ParameterUsage::kNone;
 
@@ -78,7 +78,7 @@
         const OverloadInfo* info = nullptr;
 
         /// The resolved overload return type
-        type::Type const* return_type = nullptr;
+        core::type::Type const* return_type = nullptr;
 
         /// The resolved overload parameters
         Vector<Parameter, 8> parameters;
@@ -113,7 +113,7 @@
     /// @param source the source of the builtin call
     /// @return the resolved builtin function overload
     virtual Result<Overload> Lookup(core::Function type,
-                                    VectorRef<const type::Type*> args,
+                                    VectorRef<const core::type::Type*> args,
                                     EvaluationStage earliest_eval_stage,
                                     const Source& source) = 0;
 
@@ -130,7 +130,7 @@
     /// @param source the source of the operator call
     /// @return the resolved unary operator overload
     virtual Result<Overload> Lookup(core::UnaryOp op,
-                                    const type::Type* arg,
+                                    const core::type::Type* arg,
                                     EvaluationStage earliest_eval_stage,
                                     const Source& source) = 0;
 
@@ -149,8 +149,8 @@
     /// @param is_compound true if the binary operator is being used as a compound assignment
     /// @return the resolved binary operator overload
     virtual Result<Overload> Lookup(core::BinaryOp op,
-                                    const type::Type* lhs,
-                                    const type::Type* rhs,
+                                    const core::type::Type* lhs,
+                                    const core::type::Type* rhs,
                                     EvaluationStage earliest_eval_stage,
                                     const Source& source,
                                     bool is_compound) = 0;
@@ -168,8 +168,8 @@
     /// @param source the source of the call
     /// @return the resolved type constructor or conversion function overload
     virtual Result<Overload> Lookup(CtorConv type,
-                                    const type::Type* template_arg,
-                                    VectorRef<const type::Type*> args,
+                                    const core::type::Type* template_arg,
+                                    VectorRef<const core::type::Type*> args,
                                     EvaluationStage earliest_eval_stage,
                                     const Source& source) = 0;
 };
diff --git a/src/tint/lang/core/intrinsic/table_data.h b/src/tint/lang/core/intrinsic/table_data.h
index 34c8083..baea171 100644
--- a/src/tint/lang/core/intrinsic/table_data.h
+++ b/src/tint/lang/core/intrinsic/table_data.h
@@ -256,17 +256,17 @@
 };
 
 /// A special type that matches all TypeMatchers
-class Any final : public Castable<Any, type::Type> {
+class Any final : public Castable<Any, core::type::Type> {
   public:
     Any();
     ~Any() override;
 
-    /// @copydoc type::UniqueNode::Equals
-    bool Equals(const type::UniqueNode& other) const override;
-    /// @copydoc type::Type::FriendlyName
+    /// @copydoc core::type::UniqueNode::Equals
+    bool Equals(const core::type::UniqueNode& other) const override;
+    /// @copydoc core::type::Type::FriendlyName
     std::string FriendlyName() const override;
-    /// @copydoc type::Type::Clone
-    type::Type* Clone(type::CloneContext& ctx) const override;
+    /// @copydoc core::type::Type::Clone
+    core::type::Type* Clone(core::type::CloneContext& ctx) const override;
 };
 
 /// TemplateState holds the state of the template numbers and types.
@@ -282,7 +282,7 @@
     /// @param idx the index of the template type
     /// @param ty the type
     /// @returns true on match or newly defined
-    const type::Type* Type(size_t idx, const type::Type* ty) {
+    const core::type::Type* Type(size_t idx, const core::type::Type* ty) {
         if (idx >= types_.Length()) {
             types_.Resize(idx + 1);
         }
@@ -291,7 +291,7 @@
             t = ty;
             return ty;
         }
-        ty = type::Type::Common(Vector{t, ty});
+        ty = core::type::Type::Common(Vector{t, ty});
         if (ty) {
             t = ty;
         }
@@ -319,7 +319,7 @@
     /// @param idx the index of the template type
     /// @returns the template type with index @p idx, or nullptr if the type was not
     /// defined.
-    const type::Type* Type(size_t idx) const {
+    const core::type::Type* Type(size_t idx) const {
         if (idx >= types_.Length()) {
             return nullptr;
         }
@@ -329,7 +329,7 @@
     /// SetType replaces the template type with index @p idx with type @p ty.
     /// @param idx the index of the template type
     /// @param ty the new type for the template
-    void SetType(size_t idx, const type::Type* ty) {
+    void SetType(size_t idx, const core::type::Type* ty) {
         if (idx >= types_.Length()) {
             types_.Resize(idx + 1);
         }
@@ -349,7 +349,7 @@
     size_t Count() const { return types_.Length() + numbers_.Length(); }
 
   private:
-    Vector<const type::Type*, 4> types_;
+    Vector<const core::type::Type*, 4> types_;
     Vector<Number, 2> numbers_;
 };
 
@@ -366,7 +366,7 @@
     /// @param type_matcher_indices the remaining type matcher indices
     /// @param number_matcher_indices the remaining number matcher indices
     /// @param s the required evaluation stage of the overload
-    MatchState(type::Manager& ty_mgr,
+    MatchState(core::type::Manager& ty_mgr,
                SymbolTable& syms,
                TemplateState& t,
                const TableData& d,
@@ -384,7 +384,7 @@
           number_matcher_indices_(number_matcher_indices) {}
 
     /// The type manager
-    type::Manager& types;
+    core::type::Manager& types;
 
     /// The symbol manager
     SymbolTable& symbols;
@@ -405,7 +405,7 @@
     /// @param ty the type to try matching
     /// @returns the canonical expected type if the type matches, otherwise nullptr.
     /// @note: The matcher indices are progressed on calling.
-    inline const type::Type* Type(const type::Type* ty);
+    inline const core::type::Type* Type(const core::type::Type* ty);
 
     /// Num uses the next NumMatcher from the matcher indices to match @p number.
     /// @param number the number to try matching
@@ -435,7 +435,7 @@
     /// Match may define and refine the template types and numbers in state.
     /// The parameter `type` is the type to match
     /// Returns the canonicalized type on match, otherwise nullptr
-    using MatchFn = const type::Type*(MatchState& state, const type::Type* type);
+    using MatchFn = const core::type::Type*(MatchState& state, const core::type::Type* type);
 
     /// @see #MatchFn
     MatchFn* const match;
@@ -604,7 +604,7 @@
     const IntrinsicInfo& unary_minus;
 };
 
-const type::Type* MatchState::Type(const type::Type* ty) {
+const core::type::Type* MatchState::Type(const core::type::Type* ty) {
     TypeMatcherIndex matcher_index{(*type_matcher_indices_++).value};
     auto& matcher = data[matcher_index];
     return matcher.match(*this, ty);
@@ -637,7 +637,7 @@
     /// The TypeMatcher for the template type with the index `INDEX`
     static constexpr TypeMatcher matcher{
         /* match */
-        [](MatchState& state, const type::Type* type) -> const type::Type* {
+        [](MatchState& state, const core::type::Type* type) -> const core::type::Type* {
             if (type->Is<Any>()) {
                 return state.templates.Type(INDEX);
             }
diff --git a/src/tint/lang/core/intrinsic/table_test.cc b/src/tint/lang/core/intrinsic/table_test.cc
index 3a63789..62aff6e 100644
--- a/src/tint/lang/core/intrinsic/table_test.cc
+++ b/src/tint/lang/core/intrinsic/table_test.cc
@@ -55,7 +55,7 @@
 };
 
 TEST_F(IntrinsicTableTest, MatchF32) {
-    auto* f32 = create<type::F32>();
+    auto* f32 = create<core::type::F32>();
     auto result =
         table->Lookup(core::Function::kCos, Vector{f32}, EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -66,7 +66,7 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchF32) {
-    auto* i32 = create<type::I32>();
+    auto* i32 = create<core::type::I32>();
     auto result =
         table->Lookup(core::Function::kCos, Vector{i32}, EvaluationStage::kConstant, Source{});
     ASSERT_FALSE(result);
@@ -74,9 +74,9 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchU32) {
-    auto* f32 = create<type::F32>();
-    auto* u32 = create<type::U32>();
-    auto* vec2_f32 = create<type::Vector>(f32, 2u);
+    auto* f32 = create<core::type::F32>();
+    auto* u32 = create<core::type::U32>();
+    auto* vec2_f32 = create<core::type::Vector>(f32, 2u);
     auto result = table->Lookup(core::Function::kUnpack2X16Float, Vector{u32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -87,7 +87,7 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchU32) {
-    auto* f32 = create<type::F32>();
+    auto* f32 = create<core::type::F32>();
     auto result = table->Lookup(core::Function::kUnpack2X16Float, Vector{f32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_FALSE(result);
@@ -95,10 +95,10 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchI32) {
-    auto* f32 = create<type::F32>();
-    auto* i32 = create<type::I32>();
-    auto* vec4_f32 = create<type::Vector>(f32, 4u);
-    auto* tex = create<type::SampledTexture>(type::TextureDimension::k1d, f32);
+    auto* f32 = create<core::type::F32>();
+    auto* i32 = create<core::type::I32>();
+    auto* vec4_f32 = create<core::type::Vector>(f32, 4u);
+    auto* tex = create<core::type::SampledTexture>(core::type::TextureDimension::k1d, f32);
     auto result = table->Lookup(core::Function::kTextureLoad, Vector{tex, i32, i32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -114,8 +114,8 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchI32) {
-    auto* f32 = create<type::F32>();
-    auto* tex = create<type::SampledTexture>(type::TextureDimension::k1d, f32);
+    auto* f32 = create<core::type::F32>();
+    auto* tex = create<core::type::SampledTexture>(core::type::TextureDimension::k1d, f32);
     auto result = table->Lookup(core::Function::kTextureLoad, Vector{tex, f32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_FALSE(result);
@@ -123,7 +123,7 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchIU32AsI32) {
-    auto* i32 = create<type::I32>();
+    auto* i32 = create<core::type::I32>();
     auto result = table->Lookup(core::Function::kCountOneBits, Vector{i32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -134,7 +134,7 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchIU32AsU32) {
-    auto* u32 = create<type::U32>();
+    auto* u32 = create<core::type::U32>();
     auto result = table->Lookup(core::Function::kCountOneBits, Vector{u32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -145,7 +145,7 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchIU32) {
-    auto* f32 = create<type::F32>();
+    auto* f32 = create<core::type::F32>();
     auto result = table->Lookup(core::Function::kCountOneBits, Vector{f32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_FALSE(result);
@@ -153,7 +153,7 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchFIU32AsI32) {
-    auto* i32 = create<type::I32>();
+    auto* i32 = create<core::type::I32>();
     auto result = table->Lookup(core::Function::kClamp, Vector{i32, i32, i32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -166,7 +166,7 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchFIU32AsU32) {
-    auto* u32 = create<type::U32>();
+    auto* u32 = create<core::type::U32>();
     auto result = table->Lookup(core::Function::kClamp, Vector{u32, u32, u32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -179,7 +179,7 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchFIU32AsF32) {
-    auto* f32 = create<type::F32>();
+    auto* f32 = create<core::type::F32>();
     auto result = table->Lookup(core::Function::kClamp, Vector{f32, f32, f32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -192,7 +192,7 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchFIU32) {
-    auto* bool_ = create<type::Bool>();
+    auto* bool_ = create<core::type::Bool>();
     auto result = table->Lookup(core::Function::kClamp, Vector{bool_, bool_, bool_},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_FALSE(result);
@@ -200,8 +200,8 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchBool) {
-    auto* f32 = create<type::F32>();
-    auto* bool_ = create<type::Bool>();
+    auto* f32 = create<core::type::F32>();
+    auto* bool_ = create<core::type::Bool>();
     auto result = table->Lookup(core::Function::kSelect, Vector{f32, f32, bool_},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -214,7 +214,7 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchBool) {
-    auto* f32 = create<type::F32>();
+    auto* f32 = create<core::type::F32>();
     auto result = table->Lookup(core::Function::kSelect, Vector{f32, f32, f32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_FALSE(result);
@@ -222,10 +222,10 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchPointer) {
-    auto* i32 = create<type::I32>();
-    auto* atomicI32 = create<type::Atomic>(i32);
-    auto* ptr =
-        create<type::Pointer>(core::AddressSpace::kWorkgroup, atomicI32, core::Access::kReadWrite);
+    auto* i32 = create<core::type::I32>();
+    auto* atomicI32 = create<core::type::Atomic>(i32);
+    auto* ptr = create<core::type::Pointer>(core::AddressSpace::kWorkgroup, atomicI32,
+                                            core::Access::kReadWrite);
     auto result = table->Lookup(core::Function::kAtomicLoad, Vector{ptr},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -236,8 +236,8 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchPointer) {
-    auto* i32 = create<type::I32>();
-    auto* atomicI32 = create<type::Atomic>(i32);
+    auto* i32 = create<core::type::I32>();
+    auto* atomicI32 = create<core::type::Atomic>(i32);
     auto result = table->Lookup(core::Function::kAtomicLoad, Vector{atomicI32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_FALSE(result);
@@ -245,23 +245,23 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchArray) {
-    auto* arr =
-        create<type::Array>(create<type::U32>(), create<type::RuntimeArrayCount>(), 4u, 4u, 4u, 4u);
+    auto* arr = create<core::type::Array>(create<core::type::U32>(),
+                                          create<core::type::RuntimeArrayCount>(), 4u, 4u, 4u, 4u);
     auto* arr_ptr =
-        create<type::Pointer>(core::AddressSpace::kStorage, arr, core::Access::kReadWrite);
+        create<core::type::Pointer>(core::AddressSpace::kStorage, arr, core::Access::kReadWrite);
     auto result = table->Lookup(core::Function::kArrayLength, Vector{arr_ptr},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_TRUE(result->return_type->Is<type::U32>());
+    EXPECT_TRUE(result->return_type->Is<core::type::U32>());
     ASSERT_EQ(result->parameters.Length(), 1u);
     auto* param_type = result->parameters[0].type;
-    ASSERT_TRUE(param_type->Is<type::Pointer>());
-    EXPECT_TRUE(param_type->As<type::Pointer>()->StoreType()->Is<type::Array>());
+    ASSERT_TRUE(param_type->Is<core::type::Pointer>());
+    EXPECT_TRUE(param_type->As<core::type::Pointer>()->StoreType()->Is<core::type::Array>());
 }
 
 TEST_F(IntrinsicTableTest, MismatchArray) {
-    auto* f32 = create<type::F32>();
+    auto* f32 = create<core::type::F32>();
     auto result = table->Lookup(core::Function::kArrayLength, Vector{f32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_FALSE(result);
@@ -269,11 +269,11 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchSampler) {
-    auto* f32 = create<type::F32>();
-    auto* vec2_f32 = create<type::Vector>(f32, 2u);
-    auto* vec4_f32 = create<type::Vector>(f32, 4u);
-    auto* tex = create<type::SampledTexture>(type::TextureDimension::k2d, f32);
-    auto* sampler = create<type::Sampler>(type::SamplerKind::kSampler);
+    auto* f32 = create<core::type::F32>();
+    auto* vec2_f32 = create<core::type::Vector>(f32, 2u);
+    auto* vec4_f32 = create<core::type::Vector>(f32, 4u);
+    auto* tex = create<core::type::SampledTexture>(core::type::TextureDimension::k2d, f32);
+    auto* sampler = create<core::type::Sampler>(core::type::SamplerKind::kSampler);
     auto result = table->Lookup(core::Function::kTextureSample, Vector{tex, sampler, vec2_f32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -289,9 +289,9 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchSampler) {
-    auto* f32 = create<type::F32>();
-    auto* vec2_f32 = create<type::Vector>(f32, 2u);
-    auto* tex = create<type::SampledTexture>(type::TextureDimension::k2d, f32);
+    auto* f32 = create<core::type::F32>();
+    auto* vec2_f32 = create<core::type::Vector>(f32, 2u);
+    auto* tex = create<core::type::SampledTexture>(core::type::TextureDimension::k2d, f32);
     auto result = table->Lookup(core::Function::kTextureSample, Vector{tex, f32, vec2_f32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_FALSE(result);
@@ -299,11 +299,11 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchSampledTexture) {
-    auto* i32 = create<type::I32>();
-    auto* f32 = create<type::F32>();
-    auto* vec2_i32 = create<type::Vector>(i32, 2u);
-    auto* vec4_f32 = create<type::Vector>(f32, 4u);
-    auto* tex = create<type::SampledTexture>(type::TextureDimension::k2d, f32);
+    auto* i32 = create<core::type::I32>();
+    auto* f32 = create<core::type::F32>();
+    auto* vec2_i32 = create<core::type::Vector>(i32, 2u);
+    auto* vec4_f32 = create<core::type::Vector>(f32, 4u);
+    auto* tex = create<core::type::SampledTexture>(core::type::TextureDimension::k2d, f32);
     auto result = table->Lookup(core::Function::kTextureLoad, Vector{tex, vec2_i32, i32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -319,11 +319,11 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchMultisampledTexture) {
-    auto* i32 = create<type::I32>();
-    auto* f32 = create<type::F32>();
-    auto* vec2_i32 = create<type::Vector>(i32, 2u);
-    auto* vec4_f32 = create<type::Vector>(f32, 4u);
-    auto* tex = create<type::MultisampledTexture>(type::TextureDimension::k2d, f32);
+    auto* i32 = create<core::type::I32>();
+    auto* f32 = create<core::type::F32>();
+    auto* vec2_i32 = create<core::type::Vector>(i32, 2u);
+    auto* vec4_f32 = create<core::type::Vector>(f32, 4u);
+    auto* tex = create<core::type::MultisampledTexture>(core::type::TextureDimension::k2d, f32);
     auto result = table->Lookup(core::Function::kTextureLoad, Vector{tex, vec2_i32, i32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -339,10 +339,10 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchDepthTexture) {
-    auto* f32 = create<type::F32>();
-    auto* i32 = create<type::I32>();
-    auto* vec2_i32 = create<type::Vector>(i32, 2u);
-    auto* tex = create<type::DepthTexture>(type::TextureDimension::k2d);
+    auto* f32 = create<core::type::F32>();
+    auto* i32 = create<core::type::I32>();
+    auto* vec2_i32 = create<core::type::Vector>(i32, 2u);
+    auto* tex = create<core::type::DepthTexture>(core::type::TextureDimension::k2d);
     auto result = table->Lookup(core::Function::kTextureLoad, Vector{tex, vec2_i32, i32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -358,10 +358,10 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchDepthMultisampledTexture) {
-    auto* f32 = create<type::F32>();
-    auto* i32 = create<type::I32>();
-    auto* vec2_i32 = create<type::Vector>(i32, 2u);
-    auto* tex = create<type::DepthMultisampledTexture>(type::TextureDimension::k2d);
+    auto* f32 = create<core::type::F32>();
+    auto* i32 = create<core::type::I32>();
+    auto* vec2_i32 = create<core::type::Vector>(i32, 2u);
+    auto* tex = create<core::type::DepthMultisampledTexture>(core::type::TextureDimension::k2d);
     auto result = table->Lookup(core::Function::kTextureLoad, Vector{tex, vec2_i32, i32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -377,11 +377,11 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchExternalTexture) {
-    auto* f32 = create<type::F32>();
-    auto* i32 = create<type::I32>();
-    auto* vec2_i32 = create<type::Vector>(i32, 2u);
-    auto* vec4_f32 = create<type::Vector>(f32, 4u);
-    auto* tex = create<type::ExternalTexture>();
+    auto* f32 = create<core::type::F32>();
+    auto* i32 = create<core::type::I32>();
+    auto* vec2_i32 = create<core::type::Vector>(i32, 2u);
+    auto* vec4_f32 = create<core::type::Vector>(f32, 4u);
+    auto* tex = create<core::type::ExternalTexture>();
     auto result = table->Lookup(core::Function::kTextureLoad, Vector{tex, vec2_i32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -395,13 +395,14 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchWOStorageTexture) {
-    auto* f32 = create<type::F32>();
-    auto* i32 = create<type::I32>();
-    auto* vec2_i32 = create<type::Vector>(i32, 2u);
-    auto* vec4_f32 = create<type::Vector>(f32, 4u);
-    auto* subtype = type::StorageTexture::SubtypeFor(core::TexelFormat::kR32Float, Types());
-    auto* tex = create<type::StorageTexture>(
-        type::TextureDimension::k2d, core::TexelFormat::kR32Float, core::Access::kWrite, subtype);
+    auto* f32 = create<core::type::F32>();
+    auto* i32 = create<core::type::I32>();
+    auto* vec2_i32 = create<core::type::Vector>(i32, 2u);
+    auto* vec4_f32 = create<core::type::Vector>(f32, 4u);
+    auto* subtype = core::type::StorageTexture::SubtypeFor(core::TexelFormat::kR32Float, Types());
+    auto* tex = create<core::type::StorageTexture>(core::type::TextureDimension::k2d,
+                                                   core::TexelFormat::kR32Float,
+                                                   core::Access::kWrite, subtype);
 
     auto result = table->Lookup(core::Function::kTextureStore, Vector{tex, vec2_i32, vec4_f32},
                                 EvaluationStage::kConstant, Source{});
@@ -418,9 +419,9 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchTexture) {
-    auto* f32 = create<type::F32>();
-    auto* i32 = create<type::I32>();
-    auto* vec2_i32 = create<type::Vector>(i32, 2u);
+    auto* f32 = create<core::type::F32>();
+    auto* i32 = create<core::type::I32>();
+    auto* vec2_i32 = create<core::type::Vector>(i32, 2u);
     auto result = table->Lookup(core::Function::kTextureLoad, Vector{f32, vec2_i32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_FALSE(result);
@@ -428,13 +429,13 @@
 }
 
 TEST_F(IntrinsicTableTest, ImplicitLoadOnReference) {
-    auto* f32 = create<type::F32>();
-    auto result = table->Lookup(
-        core::Function::kCos,
-        Vector{
-            create<type::Reference>(core::AddressSpace::kFunction, f32, core::Access::kReadWrite),
-        },
-        EvaluationStage::kConstant, Source{});
+    auto* f32 = create<core::type::F32>();
+    auto result = table->Lookup(core::Function::kCos,
+                                Vector{
+                                    create<core::type::Reference>(core::AddressSpace::kFunction,
+                                                                  f32, core::Access::kReadWrite),
+                                },
+                                EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
     EXPECT_EQ(result->return_type, f32);
@@ -443,7 +444,7 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchTemplateType) {
-    auto* f32 = create<type::F32>();
+    auto* f32 = create<core::type::F32>();
     auto result = table->Lookup(core::Function::kClamp, Vector{f32, f32, f32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -455,8 +456,8 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchTemplateType) {
-    auto* f32 = create<type::F32>();
-    auto* u32 = create<type::U32>();
+    auto* f32 = create<core::type::F32>();
+    auto* u32 = create<core::type::U32>();
     auto result = table->Lookup(core::Function::kClamp, Vector{f32, u32, f32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_FALSE(result);
@@ -464,8 +465,8 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchOpenSizeVector) {
-    auto* f32 = create<type::F32>();
-    auto* vec2_f32 = create<type::Vector>(f32, 2u);
+    auto* f32 = create<core::type::F32>();
+    auto* vec2_f32 = create<core::type::Vector>(f32, 2u);
     auto result = table->Lookup(core::Function::kClamp, Vector{vec2_f32, vec2_f32, vec2_f32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -478,9 +479,9 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchOpenSizeVector) {
-    auto* f32 = create<type::F32>();
-    auto* u32 = create<type::U32>();
-    auto* vec2_f32 = create<type::Vector>(f32, 2u);
+    auto* f32 = create<core::type::F32>();
+    auto* u32 = create<core::type::U32>();
+    auto* vec2_f32 = create<core::type::Vector>(f32, 2u);
     auto result = table->Lookup(core::Function::kClamp, Vector{vec2_f32, u32, vec2_f32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_FALSE(result);
@@ -488,9 +489,9 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchOpenSizeMatrix) {
-    auto* f32 = create<type::F32>();
-    auto* vec3_f32 = create<type::Vector>(f32, 3u);
-    auto* mat3_f32 = create<type::Matrix>(vec3_f32, 3u);
+    auto* f32 = create<core::type::F32>();
+    auto* vec3_f32 = create<core::type::Vector>(f32, 3u);
+    auto* mat3_f32 = create<core::type::Matrix>(vec3_f32, 3u);
     auto result = table->Lookup(core::Function::kDeterminant, Vector{mat3_f32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -501,9 +502,9 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchOpenSizeMatrix) {
-    auto* f32 = create<type::F32>();
-    auto* vec2_f32 = create<type::Vector>(f32, 2u);
-    auto* mat3x2_f32 = create<type::Matrix>(vec2_f32, 3u);
+    auto* f32 = create<core::type::F32>();
+    auto* vec2_f32 = create<core::type::Vector>(f32, 2u);
+    auto* mat3x2_f32 = create<core::type::Matrix>(vec2_f32, 3u);
     auto result = table->Lookup(core::Function::kDeterminant, Vector{mat3x2_f32},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_FALSE(result);
@@ -511,8 +512,8 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchDifferentArgsElementType_Builtin_ConstantEval) {
-    auto* af = create<type::AbstractFloat>();
-    auto* bool_ = create<type::Bool>();
+    auto* af = create<core::type::AbstractFloat>();
+    auto* bool_ = create<core::type::Bool>();
     auto result = table->Lookup(core::Function::kSelect, Vector{af, af, bool_},
                                 EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -526,24 +527,24 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchDifferentArgsElementType_Builtin_RuntimeEval) {
-    auto* af = create<type::AbstractFloat>();
-    auto* bool_ref = create<type::Reference>(core::AddressSpace::kFunction, create<type::Bool>(),
-                                             core::Access::kReadWrite);
+    auto* af = create<core::type::AbstractFloat>();
+    auto* bool_ref = create<core::type::Reference>(
+        core::AddressSpace::kFunction, create<core::type::Bool>(), core::Access::kReadWrite);
     auto result = table->Lookup(core::Function::kSelect, Vector{af, af, bool_ref},
                                 EvaluationStage::kRuntime, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
     EXPECT_NE(result->const_eval_fn, nullptr);
-    EXPECT_TRUE(result->return_type->Is<type::F32>());
+    EXPECT_TRUE(result->return_type->Is<core::type::F32>());
     ASSERT_EQ(result->parameters.Length(), 3u);
-    EXPECT_TRUE(result->parameters[0].type->Is<type::F32>());
-    EXPECT_TRUE(result->parameters[1].type->Is<type::F32>());
-    EXPECT_TRUE(result->parameters[2].type->Is<type::Bool>());
+    EXPECT_TRUE(result->parameters[0].type->Is<core::type::F32>());
+    EXPECT_TRUE(result->parameters[1].type->Is<core::type::F32>());
+    EXPECT_TRUE(result->parameters[2].type->Is<core::type::Bool>());
 }
 
 TEST_F(IntrinsicTableTest, MatchDifferentArgsElementType_Binary_ConstantEval) {
-    auto* ai = create<type::AbstractInt>();
-    auto* u32 = create<type::U32>();
+    auto* ai = create<core::type::AbstractInt>();
+    auto* u32 = create<core::type::U32>();
     auto result = table->Lookup(core::BinaryOp::kShiftLeft, ai, u32, EvaluationStage::kConstant,
                                 Source{}, false);
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -555,22 +556,22 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchDifferentArgsElementType_Binary_RuntimeEval) {
-    auto* ai = create<type::AbstractInt>();
-    auto* u32 = create<type::U32>();
+    auto* ai = create<core::type::AbstractInt>();
+    auto* u32 = create<core::type::U32>();
     auto result = table->Lookup(core::BinaryOp::kShiftLeft, ai, u32, EvaluationStage::kRuntime,
                                 Source{}, false);
     ASSERT_TRUE(result) << Diagnostics().str();
     ASSERT_NE(result->const_eval_fn, nullptr) << Diagnostics().str();
     ASSERT_EQ(Diagnostics().str(), "");
-    EXPECT_TRUE(result->return_type->Is<type::I32>());
-    EXPECT_TRUE(result->parameters[0].type->Is<type::I32>());
-    EXPECT_TRUE(result->parameters[1].type->Is<type::U32>());
+    EXPECT_TRUE(result->return_type->Is<core::type::I32>());
+    EXPECT_TRUE(result->parameters[0].type->Is<core::type::I32>());
+    EXPECT_TRUE(result->parameters[1].type->Is<core::type::U32>());
 }
 
 TEST_F(IntrinsicTableTest, OverloadOrderByNumberOfParameters) {
     // None of the arguments match, so expect the overloads with 2 parameters to
     // come first
-    auto* bool_ = create<type::Bool>();
+    auto* bool_ = create<core::type::Bool>();
     auto result = table->Lookup(core::Function::kTextureDimensions, Vector{bool_, bool_},
                                 EvaluationStage::kConstant, Source{});
     EXPECT_FALSE(result);
@@ -609,8 +610,8 @@
 }
 
 TEST_F(IntrinsicTableTest, OverloadOrderByMatchingParameter) {
-    auto* tex = create<type::DepthTexture>(type::TextureDimension::k2d);
-    auto* bool_ = create<type::Bool>();
+    auto* tex = create<core::type::DepthTexture>(core::type::TextureDimension::k2d);
+    auto* bool_ = create<core::type::Bool>();
     auto result = table->Lookup(core::Function::kTextureDimensions, Vector{tex, bool_},
                                 EvaluationStage::kConstant, Source{});
     EXPECT_FALSE(result);
@@ -649,8 +650,8 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchUnaryOp) {
-    auto* i32 = create<type::I32>();
-    auto* vec3_i32 = create<type::Vector>(i32, 3u);
+    auto* i32 = create<core::type::I32>();
+    auto* vec3_i32 = create<core::type::Vector>(i32, 3u);
     auto result = table->Lookup(core::UnaryOp::kNegation, vec3_i32, EvaluationStage::kConstant,
                                 Source{{12, 34}});
     EXPECT_EQ(result->return_type, vec3_i32);
@@ -658,7 +659,7 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchUnaryOp) {
-    auto* bool_ = create<type::Bool>();
+    auto* bool_ = create<core::type::Bool>();
     auto result = table->Lookup(core::UnaryOp::kNegation, bool_, EvaluationStage::kConstant,
                                 Source{{12, 34}});
     ASSERT_FALSE(result);
@@ -671,7 +672,7 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchUnaryOp_Constant) {
-    auto* ai = create<type::AbstractInt>();
+    auto* ai = create<core::type::AbstractInt>();
     auto result =
         table->Lookup(core::UnaryOp::kNegation, ai, EvaluationStage::kConstant, Source{{12, 34}});
     EXPECT_EQ(result->return_type, ai);
@@ -679,17 +680,17 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchUnaryOp_Runtime) {
-    auto* ai = create<type::AbstractInt>();
+    auto* ai = create<core::type::AbstractInt>();
     auto result =
         table->Lookup(core::UnaryOp::kNegation, ai, EvaluationStage::kRuntime, Source{{12, 34}});
     EXPECT_NE(result->return_type, ai);
-    EXPECT_TRUE(result->return_type->Is<type::I32>());
+    EXPECT_TRUE(result->return_type->Is<core::type::I32>());
     EXPECT_EQ(Diagnostics().str(), "");
 }
 
 TEST_F(IntrinsicTableTest, MatchBinaryOp) {
-    auto* i32 = create<type::I32>();
-    auto* vec3_i32 = create<type::Vector>(i32, 3u);
+    auto* i32 = create<core::type::I32>();
+    auto* vec3_i32 = create<core::type::Vector>(i32, 3u);
     auto result = table->Lookup(core::BinaryOp::kMultiply, i32, vec3_i32,
                                 EvaluationStage::kConstant, Source{{12, 34}},
                                 /* is_compound */ false);
@@ -700,8 +701,8 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchBinaryOp) {
-    auto* f32 = create<type::F32>();
-    auto* bool_ = create<type::Bool>();
+    auto* f32 = create<core::type::F32>();
+    auto* bool_ = create<core::type::Bool>();
     auto result = table->Lookup(core::BinaryOp::kMultiply, f32, bool_, EvaluationStage::kConstant,
                                 Source{{12, 34}},
                                 /* is_compound */ false);
@@ -722,8 +723,8 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchCompoundOp) {
-    auto* i32 = create<type::I32>();
-    auto* vec3_i32 = create<type::Vector>(i32, 3u);
+    auto* i32 = create<core::type::I32>();
+    auto* vec3_i32 = create<core::type::Vector>(i32, 3u);
     auto result = table->Lookup(core::BinaryOp::kMultiply, i32, vec3_i32,
                                 EvaluationStage::kConstant, Source{{12, 34}},
                                 /* is_compound */ true);
@@ -734,8 +735,8 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchCompoundOp) {
-    auto* f32 = create<type::F32>();
-    auto* bool_ = create<type::Bool>();
+    auto* f32 = create<core::type::F32>();
+    auto* bool_ = create<core::type::Bool>();
     auto result = table->Lookup(core::BinaryOp::kMultiply, f32, bool_, EvaluationStage::kConstant,
                                 Source{{12, 34}},
                                 /* is_compound */ true);
@@ -756,8 +757,8 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchTypeInitializerImplicit) {
-    auto* i32 = create<type::I32>();
-    auto* vec3_i32 = create<type::Vector>(i32, 3u);
+    auto* i32 = create<core::type::I32>();
+    auto* vec3_i32 = create<core::type::Vector>(i32, 3u);
     auto result = table->Lookup(CtorConv::kVec3, nullptr, Vector{i32, i32, i32},
                                 EvaluationStage::kConstant, Source{{12, 34}});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -771,8 +772,8 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchTypeInitializerExplicit) {
-    auto* i32 = create<type::I32>();
-    auto* vec3_i32 = create<type::Vector>(i32, 3u);
+    auto* i32 = create<core::type::I32>();
+    auto* vec3_i32 = create<core::type::Vector>(i32, 3u);
     auto result = table->Lookup(CtorConv::kVec3, i32, Vector{i32, i32, i32},
                                 EvaluationStage::kConstant, Source{{12, 34}});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -786,8 +787,8 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchTypeInitializerImplicit) {
-    auto* i32 = create<type::I32>();
-    auto* f32 = create<type::F32>();
+    auto* i32 = create<core::type::I32>();
+    auto* f32 = create<core::type::F32>();
     auto result = table->Lookup(CtorConv::kVec3, nullptr, Vector{i32, f32, i32},
                                 EvaluationStage::kConstant, Source{{12, 34}});
     ASSERT_FALSE(result);
@@ -813,8 +814,8 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchTypeInitializerExplicit) {
-    auto* i32 = create<type::I32>();
-    auto* f32 = create<type::F32>();
+    auto* i32 = create<core::type::I32>();
+    auto* f32 = create<core::type::F32>();
     auto result = table->Lookup(CtorConv::kVec3, i32, Vector{i32, f32, i32},
                                 EvaluationStage::kConstant, Source{{12, 34}});
     ASSERT_FALSE(result);
@@ -840,8 +841,8 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchTypeInitializerImplicitVecFromVecAbstract) {
-    auto* ai = create<type::AbstractInt>();
-    auto* vec3_ai = create<type::Vector>(ai, 3u);
+    auto* ai = create<core::type::AbstractInt>();
+    auto* vec3_ai = create<core::type::Vector>(ai, 3u);
     auto result = table->Lookup(CtorConv::kVec3, nullptr, Vector{vec3_ai},
                                 EvaluationStage::kConstant, Source{{12, 34}});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -853,10 +854,10 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchTypeInitializerImplicitMatFromVec) {
-    auto* af = create<type::AbstractFloat>();
-    auto* vec2_ai = create<type::Vector>(create<type::AbstractInt>(), 2u);
-    auto* vec2_af = create<type::Vector>(af, 2u);
-    auto* mat2x2_af = create<type::Matrix>(vec2_af, 2u);
+    auto* af = create<core::type::AbstractFloat>();
+    auto* vec2_ai = create<core::type::Vector>(create<core::type::AbstractInt>(), 2u);
+    auto* vec2_af = create<core::type::Vector>(af, 2u);
+    auto* mat2x2_af = create<core::type::Matrix>(vec2_af, 2u);
     auto result = table->Lookup(CtorConv::kMat2x2, nullptr, Vector{vec2_ai, vec2_ai},
                                 EvaluationStage::kConstant, Source{{12, 34}});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -869,8 +870,8 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchTypeInitializer_ConstantEval) {
-    auto* ai = create<type::AbstractInt>();
-    auto* vec3_ai = create<type::Vector>(ai, 3u);
+    auto* ai = create<core::type::AbstractInt>();
+    auto* vec3_ai = create<core::type::Vector>(ai, 3u);
     auto result = table->Lookup(CtorConv::kVec3, nullptr, Vector{ai, ai, ai},
                                 EvaluationStage::kConstant, Source{{12, 34}});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -885,7 +886,7 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchTypeInitializer_RuntimeEval) {
-    auto* ai = create<type::AbstractInt>();
+    auto* ai = create<core::type::AbstractInt>();
     auto result = table->Lookup(CtorConv::kVec3, nullptr, Vector{ai, ai, ai},
                                 EvaluationStage::kRuntime, Source{{12, 34}});
     auto* i32 = create<type::I32>();
@@ -902,10 +903,10 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchTypeConversion) {
-    auto* i32 = create<type::I32>();
-    auto* vec3_i32 = create<type::Vector>(i32, 3u);
-    auto* f32 = create<type::F32>();
-    auto* vec3_f32 = create<type::Vector>(f32, 3u);
+    auto* i32 = create<core::type::I32>();
+    auto* vec3_i32 = create<core::type::Vector>(i32, 3u);
+    auto* f32 = create<core::type::F32>();
+    auto* vec3_f32 = create<core::type::Vector>(f32, 3u);
     auto result = table->Lookup(CtorConv::kVec3, i32, Vector{vec3_f32}, EvaluationStage::kConstant,
                                 Source{{12, 34}});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -916,9 +917,9 @@
 }
 
 TEST_F(IntrinsicTableTest, MismatchTypeConversion) {
-    auto* arr =
-        create<type::Array>(create<type::U32>(), create<type::RuntimeArrayCount>(), 4u, 4u, 4u, 4u);
-    auto* f32 = create<type::F32>();
+    auto* arr = create<core::type::Array>(create<core::type::U32>(),
+                                          create<core::type::RuntimeArrayCount>(), 4u, 4u, 4u, 4u);
+    auto* f32 = create<core::type::F32>();
     auto result = table->Lookup(CtorConv::kVec3, f32, Vector{arr}, EvaluationStage::kConstant,
                                 Source{{12, 34}});
     ASSERT_FALSE(result);
@@ -944,11 +945,11 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchTypeConversion_ConstantEval) {
-    auto* ai = create<type::AbstractInt>();
-    auto* af = create<type::AbstractFloat>();
-    auto* vec3_ai = create<type::Vector>(ai, 3u);
-    auto* f32 = create<type::F32>();
-    auto* vec3_f32 = create<type::Vector>(f32, 3u);
+    auto* ai = create<core::type::AbstractInt>();
+    auto* af = create<core::type::AbstractFloat>();
+    auto* vec3_ai = create<core::type::Vector>(ai, 3u);
+    auto* f32 = create<core::type::F32>();
+    auto* vec3_f32 = create<core::type::Vector>(f32, 3u);
     auto result = table->Lookup(CtorConv::kVec3, af, Vector{vec3_ai}, EvaluationStage::kConstant,
                                 Source{{12, 34}});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -961,11 +962,11 @@
 }
 
 TEST_F(IntrinsicTableTest, MatchTypeConversion_RuntimeEval) {
-    auto* ai = create<type::AbstractInt>();
-    auto* af = create<type::AbstractFloat>();
-    auto* vec3_ai = create<type::Vector>(ai, 3u);
-    auto* vec3_f32 = create<type::Vector>(create<type::F32>(), 3u);
-    auto* vec3_i32 = create<type::Vector>(create<type::I32>(), 3u);
+    auto* ai = create<core::type::AbstractInt>();
+    auto* af = create<core::type::AbstractFloat>();
+    auto* vec3_ai = create<core::type::Vector>(ai, 3u);
+    auto* vec3_f32 = create<core::type::Vector>(create<core::type::F32>(), 3u);
+    auto* vec3_i32 = create<core::type::Vector>(create<core::type::I32>(), 3u);
     auto result = table->Lookup(CtorConv::kVec3, af, Vector{vec3_ai}, EvaluationStage::kRuntime,
                                 Source{{12, 34}});
     ASSERT_TRUE(result) << Diagnostics().str();
@@ -977,8 +978,8 @@
 }
 
 TEST_F(IntrinsicTableTest, Err257Arguments) {  // crbug.com/1323605
-    auto* f32 = create<type::F32>();
-    Vector<const type::Type*, 0> arg_tys;
+    auto* f32 = create<core::type::F32>();
+    Vector<const core::type::Type*, 0> arg_tys;
     arg_tys.Resize(257, f32);
     auto result = table->Lookup(core::Function::kAbs, std::move(arg_tys),
                                 EvaluationStage::kConstant, Source{});
@@ -991,8 +992,8 @@
     //    ctor i32(i32) -> i32
     //    conv i32<T: scalar_no_i32>(T) -> i32
     // The first should win overload resolution.
-    auto* ai = create<type::AbstractInt>();
-    auto* i32 = create<type::I32>();
+    auto* ai = create<core::type::AbstractInt>();
+    auto* i32 = create<core::type::I32>();
     auto result =
         table->Lookup(CtorConv::kI32, nullptr, Vector{ai}, EvaluationStage::kConstant, Source{});
     ASSERT_TRUE(result) << Diagnostics().str();
diff --git a/src/tint/lang/core/intrinsic_data.cc b/src/tint/lang/core/intrinsic_data.cc
index 7329072..40a1655 100644
--- a/src/tint/lang/core/intrinsic_data.cc
+++ b/src/tint/lang/core/intrinsic_data.cc
@@ -48,7 +48,7 @@
 using TemplateNumberInfo = tint::core::intrinsic::TemplateNumberInfo;
 using TemplateTypeIndex = tint::core::intrinsic::TemplateTypeIndex;
 using TemplateTypeInfo = tint::core::intrinsic::TemplateTypeInfo;
-using Type = tint::type::Type;
+using Type = tint::core::type::Type;
 using TypeMatcher = tint::core::intrinsic::TypeMatcher;
 using TypeMatcherIndex = tint::core::intrinsic::TypeMatcherIndex;
 using TypeMatcherIndicesIndex = tint::core::intrinsic::TypeMatcherIndicesIndex;
diff --git a/src/tint/lang/core/intrinsic_type_matchers.h b/src/tint/lang/core/intrinsic_type_matchers.h
index 97d9904..2175958 100644
--- a/src/tint/lang/core/intrinsic_type_matchers.h
+++ b/src/tint/lang/core/intrinsic_type_matchers.h
@@ -42,75 +42,75 @@
 
 namespace tint::core {
 
-inline bool match_bool(intrinsic::MatchState&, const type::Type* ty) {
-    return ty->IsAnyOf<intrinsic::Any, type::Bool>();
+inline bool match_bool(intrinsic::MatchState&, const core::type::Type* ty) {
+    return ty->IsAnyOf<intrinsic::Any, core::type::Bool>();
 }
 
-inline const type::AbstractFloat* build_fa(intrinsic::MatchState& state) {
+inline const core::type::AbstractFloat* build_fa(intrinsic::MatchState& state) {
     return state.types.AFloat();
 }
 
-inline bool match_fa(intrinsic::MatchState& state, const type::Type* ty) {
+inline bool match_fa(intrinsic::MatchState& state, const core::type::Type* ty) {
     return (state.earliest_eval_stage <= EvaluationStage::kConstant) &&
-           ty->IsAnyOf<intrinsic::Any, type::AbstractNumeric>();
+           ty->IsAnyOf<intrinsic::Any, core::type::AbstractNumeric>();
 }
 
-inline const type::AbstractInt* build_ia(intrinsic::MatchState& state) {
+inline const core::type::AbstractInt* build_ia(intrinsic::MatchState& state) {
     return state.types.AInt();
 }
 
-inline bool match_ia(intrinsic::MatchState& state, const type::Type* ty) {
+inline bool match_ia(intrinsic::MatchState& state, const core::type::Type* ty) {
     return (state.earliest_eval_stage <= EvaluationStage::kConstant) &&
-           ty->IsAnyOf<intrinsic::Any, type::AbstractInt>();
+           ty->IsAnyOf<intrinsic::Any, core::type::AbstractInt>();
 }
 
-inline const type::Bool* build_bool(intrinsic::MatchState& state) {
+inline const core::type::Bool* build_bool(intrinsic::MatchState& state) {
     return state.types.bool_();
 }
 
-inline const type::F16* build_f16(intrinsic::MatchState& state) {
+inline const core::type::F16* build_f16(intrinsic::MatchState& state) {
     return state.types.f16();
 }
 
-inline bool match_f16(intrinsic::MatchState&, const type::Type* ty) {
-    return ty->IsAnyOf<intrinsic::Any, type::F16, type::AbstractNumeric>();
+inline bool match_f16(intrinsic::MatchState&, const core::type::Type* ty) {
+    return ty->IsAnyOf<intrinsic::Any, core::type::F16, core::type::AbstractNumeric>();
 }
 
-inline const type::F32* build_f32(intrinsic::MatchState& state) {
+inline const core::type::F32* build_f32(intrinsic::MatchState& state) {
     return state.types.f32();
 }
 
-inline bool match_f32(intrinsic::MatchState&, const type::Type* ty) {
-    return ty->IsAnyOf<intrinsic::Any, type::F32, type::AbstractNumeric>();
+inline bool match_f32(intrinsic::MatchState&, const core::type::Type* ty) {
+    return ty->IsAnyOf<intrinsic::Any, core::type::F32, core::type::AbstractNumeric>();
 }
 
-inline const type::I32* build_i32(intrinsic::MatchState& state) {
+inline const core::type::I32* build_i32(intrinsic::MatchState& state) {
     return state.types.i32();
 }
 
-inline bool match_i32(intrinsic::MatchState&, const type::Type* ty) {
-    return ty->IsAnyOf<intrinsic::Any, type::I32, type::AbstractInt>();
+inline bool match_i32(intrinsic::MatchState&, const core::type::Type* ty) {
+    return ty->IsAnyOf<intrinsic::Any, core::type::I32, core::type::AbstractInt>();
 }
 
-inline const type::U32* build_u32(intrinsic::MatchState& state) {
+inline const core::type::U32* build_u32(intrinsic::MatchState& state) {
     return state.types.u32();
 }
 
-inline bool match_u32(intrinsic::MatchState&, const type::Type* ty) {
-    return ty->IsAnyOf<intrinsic::Any, type::U32, type::AbstractInt>();
+inline bool match_u32(intrinsic::MatchState&, const core::type::Type* ty) {
+    return ty->IsAnyOf<intrinsic::Any, core::type::U32, core::type::AbstractInt>();
 }
 
 inline bool match_vec(intrinsic::MatchState&,
-                      const type::Type* ty,
+                      const core::type::Type* ty,
                       intrinsic::Number& N,
-                      const type::Type*& T) {
+                      const core::type::Type*& T) {
     if (ty->Is<intrinsic::Any>()) {
         N = intrinsic::Number::any;
         T = ty;
         return true;
     }
 
-    if (auto* v = ty->As<type::Vector>()) {
+    if (auto* v = ty->As<core::type::Vector>()) {
         N = v->Width();
         T = v->type();
         return true;
@@ -119,13 +119,15 @@
 }
 
 template <uint32_t N>
-inline bool match_vec(intrinsic::MatchState&, const type::Type* ty, const type::Type*& T) {
+inline bool match_vec(intrinsic::MatchState&,
+                      const core::type::Type* ty,
+                      const core::type::Type*& T) {
     if (ty->Is<intrinsic::Any>()) {
         T = ty;
         return true;
     }
 
-    if (auto* v = ty->As<type::Vector>()) {
+    if (auto* v = ty->As<core::type::Vector>()) {
         if (v->Width() == N) {
             T = v->type();
             return true;
@@ -134,14 +136,15 @@
     return false;
 }
 
-inline const type::Vector* build_vec(intrinsic::MatchState& state,
-                                     intrinsic::Number N,
-                                     const type::Type* el) {
+inline const core::type::Vector* build_vec(intrinsic::MatchState& state,
+                                           intrinsic::Number N,
+                                           const core::type::Type* el) {
     return state.types.vec(el, N.Value());
 }
 
 template <uint32_t N>
-inline const type::Vector* build_vec(intrinsic::MatchState& state, const type::Type* el) {
+inline const core::type::Vector* build_vec(intrinsic::MatchState& state,
+                                           const core::type::Type* el) {
     return state.types.vec(el, N);
 }
 
@@ -153,13 +156,15 @@
 constexpr auto build_vec3 = build_vec<3>;
 constexpr auto build_vec4 = build_vec<4>;
 
-inline bool match_packedVec3(intrinsic::MatchState&, const type::Type* ty, const type::Type*& T) {
+inline bool match_packedVec3(intrinsic::MatchState&,
+                             const core::type::Type* ty,
+                             const core::type::Type*& T) {
     if (ty->Is<intrinsic::Any>()) {
         T = ty;
         return true;
     }
 
-    if (auto* v = ty->As<type::Vector>()) {
+    if (auto* v = ty->As<core::type::Vector>()) {
         if (v->Packed()) {
             T = v->type();
             return true;
@@ -168,22 +173,23 @@
     return false;
 }
 
-inline const type::Vector* build_packedVec3(intrinsic::MatchState& state, const type::Type* el) {
-    return state.types.Get<type::Vector>(el, 3u, /* packed */ true);
+inline const core::type::Vector* build_packedVec3(intrinsic::MatchState& state,
+                                                  const core::type::Type* el) {
+    return state.types.Get<core::type::Vector>(el, 3u, /* packed */ true);
 }
 
 inline bool match_mat(intrinsic::MatchState&,
-                      const type::Type* ty,
+                      const core::type::Type* ty,
                       intrinsic::Number& M,
                       intrinsic::Number& N,
-                      const type::Type*& T) {
+                      const core::type::Type*& T) {
     if (ty->Is<intrinsic::Any>()) {
         M = intrinsic::Number::any;
         N = intrinsic::Number::any;
         T = ty;
         return true;
     }
-    if (auto* m = ty->As<type::Matrix>()) {
+    if (auto* m = ty->As<core::type::Matrix>()) {
         M = m->columns();
         N = m->ColumnType()->Width();
         T = m->type();
@@ -193,12 +199,14 @@
 }
 
 template <uint32_t C, uint32_t R>
-inline bool match_mat(intrinsic::MatchState&, const type::Type* ty, const type::Type*& T) {
+inline bool match_mat(intrinsic::MatchState&,
+                      const core::type::Type* ty,
+                      const core::type::Type*& T) {
     if (ty->Is<intrinsic::Any>()) {
         T = ty;
         return true;
     }
-    if (auto* m = ty->As<type::Matrix>()) {
+    if (auto* m = ty->As<core::type::Matrix>()) {
         if (m->columns() == C && m->rows() == R) {
             T = m->type();
             return true;
@@ -207,16 +215,17 @@
     return false;
 }
 
-inline const type::Matrix* build_mat(intrinsic::MatchState& state,
-                                     intrinsic::Number C,
-                                     intrinsic::Number R,
-                                     const type::Type* T) {
+inline const core::type::Matrix* build_mat(intrinsic::MatchState& state,
+                                           intrinsic::Number C,
+                                           intrinsic::Number R,
+                                           const core::type::Type* T) {
     auto* column_type = state.types.vec(T, R.Value());
     return state.types.mat(column_type, C.Value());
 }
 
 template <uint32_t C, uint32_t R>
-inline const type::Matrix* build_mat(intrinsic::MatchState& state, const type::Type* T) {
+inline const core::type::Matrix* build_mat(intrinsic::MatchState& state,
+                                           const core::type::Type* T) {
     auto* column_type = state.types.vec(T, R);
     return state.types.mat(column_type, C);
 }
@@ -241,14 +250,16 @@
 constexpr auto match_mat4x3 = match_mat<4, 3>;
 constexpr auto match_mat4x4 = match_mat<4, 4>;
 
-inline bool match_array(intrinsic::MatchState&, const type::Type* ty, const type::Type*& T) {
+inline bool match_array(intrinsic::MatchState&,
+                        const core::type::Type* ty,
+                        const core::type::Type*& T) {
     if (ty->Is<intrinsic::Any>()) {
         T = ty;
         return true;
     }
 
-    if (auto* a = ty->As<type::Array>()) {
-        if (a->Count()->Is<type::RuntimeArrayCount>()) {
+    if (auto* a = ty->As<core::type::Array>()) {
+        if (a->Count()->Is<core::type::RuntimeArrayCount>()) {
             T = a->ElemType();
             return true;
         }
@@ -256,19 +267,21 @@
     return false;
 }
 
-inline const type::Array* build_array(intrinsic::MatchState& state, const type::Type* el) {
-    return state.types.Get<type::Array>(el,
-                                        /* count */ state.types.Get<type::RuntimeArrayCount>(),
-                                        /* align */ 0u,
-                                        /* size */ 0u,
-                                        /* stride */ 0u,
-                                        /* stride_implicit */ 0u);
+inline const core::type::Array* build_array(intrinsic::MatchState& state,
+                                            const core::type::Type* el) {
+    return state.types.Get<core::type::Array>(
+        el,
+        /* count */ state.types.Get<core::type::RuntimeArrayCount>(),
+        /* align */ 0u,
+        /* size */ 0u,
+        /* stride */ 0u,
+        /* stride_implicit */ 0u);
 }
 
 inline bool match_ptr(intrinsic::MatchState&,
-                      const type::Type* ty,
+                      const core::type::Type* ty,
                       intrinsic::Number& S,
-                      const type::Type*& T,
+                      const core::type::Type*& T,
                       intrinsic::Number& A) {
     if (ty->Is<intrinsic::Any>()) {
         S = intrinsic::Number::any;
@@ -277,7 +290,7 @@
         return true;
     }
 
-    if (auto* p = ty->As<type::Pointer>()) {
+    if (auto* p = ty->As<core::type::Pointer>()) {
         S = intrinsic::Number(static_cast<uint32_t>(p->AddressSpace()));
         T = p->StoreType();
         A = intrinsic::Number(static_cast<uint32_t>(p->Access()));
@@ -286,63 +299,69 @@
     return false;
 }
 
-inline const type::Pointer* build_ptr(intrinsic::MatchState& state,
-                                      intrinsic::Number S,
-                                      const type::Type* T,
-                                      intrinsic::Number& A) {
+inline const core::type::Pointer* build_ptr(intrinsic::MatchState& state,
+                                            intrinsic::Number S,
+                                            const core::type::Type* T,
+                                            intrinsic::Number& A) {
     return state.types.ptr(static_cast<core::AddressSpace>(S.Value()), T,
                            static_cast<core::Access>(A.Value()));
 }
 
-inline bool match_atomic(intrinsic::MatchState&, const type::Type* ty, const type::Type*& T) {
+inline bool match_atomic(intrinsic::MatchState&,
+                         const core::type::Type* ty,
+                         const core::type::Type*& T) {
     if (ty->Is<intrinsic::Any>()) {
         T = ty;
         return true;
     }
 
-    if (auto* a = ty->As<type::Atomic>()) {
+    if (auto* a = ty->As<core::type::Atomic>()) {
         T = a->Type();
         return true;
     }
     return false;
 }
 
-inline const type::Atomic* build_atomic(intrinsic::MatchState& state, const type::Type* T) {
+inline const core::type::Atomic* build_atomic(intrinsic::MatchState& state,
+                                              const core::type::Type* T) {
     return state.types.atomic(T);
 }
 
-inline bool match_sampler(intrinsic::MatchState&, const type::Type* ty) {
+inline bool match_sampler(intrinsic::MatchState&, const core::type::Type* ty) {
     if (ty->Is<intrinsic::Any>()) {
         return true;
     }
-    return ty->Is([](const type::Sampler* s) { return s->kind() == type::SamplerKind::kSampler; });
+    return ty->Is([](const core::type::Sampler* s) {
+        return s->kind() == core::type::SamplerKind::kSampler;
+    });
 }
 
-inline const type::Sampler* build_sampler(intrinsic::MatchState& state) {
+inline const core::type::Sampler* build_sampler(intrinsic::MatchState& state) {
     return state.types.sampler();
 }
 
-inline bool match_sampler_comparison(intrinsic::MatchState&, const type::Type* ty) {
+inline bool match_sampler_comparison(intrinsic::MatchState&, const core::type::Type* ty) {
     if (ty->Is<intrinsic::Any>()) {
         return true;
     }
-    return ty->Is(
-        [](const type::Sampler* s) { return s->kind() == type::SamplerKind::kComparisonSampler; });
+    return ty->Is([](const core::type::Sampler* s) {
+        return s->kind() == core::type::SamplerKind::kComparisonSampler;
+    });
 }
 
-inline const type::Sampler* build_sampler_comparison(intrinsic::MatchState& state) {
+inline const core::type::Sampler* build_sampler_comparison(intrinsic::MatchState& state) {
     return state.types.comparison_sampler();
 }
 
 inline bool match_texture(intrinsic::MatchState&,
-                          const type::Type* ty,
-                          type::TextureDimension dim,
-                          const type::Type*& T) {
+                          const core::type::Type* ty,
+                          core::type::TextureDimension dim,
+                          const core::type::Type*& T) {
     if (ty->Is<intrinsic::Any>()) {
         T = ty;
         return true;
     }
-    if (auto* v = ty->As<type::SampledTexture>()) {
+    if (auto* v = ty->As<core::type::SampledTexture>()) {
         if (v->dim() == dim) {
             T = v->type();
             return true;
@@ -353,33 +372,33 @@
 
 #define JOIN(a, b) a##b
 
-#define DECLARE_SAMPLED_TEXTURE(suffix, dim)                                                       \
-    inline bool JOIN(match_texture_, suffix)(intrinsic::MatchState & state, const type::Type* ty,  \
-                                             const type::Type*& T) {                               \
-        return match_texture(state, ty, dim, T);                                                   \
-    }                                                                                              \
-    inline const type::SampledTexture* JOIN(build_texture_, suffix)(intrinsic::MatchState & state, \
-                                                                    const type::Type* T) {         \
-        return state.types.Get<type::SampledTexture>(dim, T);                                      \
+#define DECLARE_SAMPLED_TEXTURE(suffix, dim)                                                     \
+    inline bool JOIN(match_texture_, suffix)(                                                    \
+        intrinsic::MatchState & state, const core::type::Type* ty, const core::type::Type*& T) { \
+        return match_texture(state, ty, dim, T);                                                 \
+    }                                                                                            \
+    inline const core::type::SampledTexture* JOIN(build_texture_, suffix)(                       \
+        intrinsic::MatchState & state, const core::type::Type* T) {                              \
+        return state.types.Get<core::type::SampledTexture>(dim, T);                              \
     }
 
-DECLARE_SAMPLED_TEXTURE(1d, type::TextureDimension::k1d)
-DECLARE_SAMPLED_TEXTURE(2d, type::TextureDimension::k2d)
-DECLARE_SAMPLED_TEXTURE(2d_array, type::TextureDimension::k2dArray)
-DECLARE_SAMPLED_TEXTURE(3d, type::TextureDimension::k3d)
-DECLARE_SAMPLED_TEXTURE(cube, type::TextureDimension::kCube)
-DECLARE_SAMPLED_TEXTURE(cube_array, type::TextureDimension::kCubeArray)
+DECLARE_SAMPLED_TEXTURE(1d, core::type::TextureDimension::k1d)
+DECLARE_SAMPLED_TEXTURE(2d, core::type::TextureDimension::k2d)
+DECLARE_SAMPLED_TEXTURE(2d_array, core::type::TextureDimension::k2dArray)
+DECLARE_SAMPLED_TEXTURE(3d, core::type::TextureDimension::k3d)
+DECLARE_SAMPLED_TEXTURE(cube, core::type::TextureDimension::kCube)
+DECLARE_SAMPLED_TEXTURE(cube_array, core::type::TextureDimension::kCubeArray)
 #undef DECLARE_SAMPLED_TEXTURE
 
 inline bool match_texture_multisampled(intrinsic::MatchState&,
-                                       const type::Type* ty,
-                                       type::TextureDimension dim,
-                                       const type::Type*& T) {
+                                       const core::type::Type* ty,
+                                       core::type::TextureDimension dim,
+                                       const core::type::Type*& T) {
     if (ty->Is<intrinsic::Any>()) {
         T = ty;
         return true;
     }
-    if (auto* v = ty->As<type::MultisampledTexture>()) {
+    if (auto* v = ty->As<core::type::MultisampledTexture>()) {
         if (v->dim() == dim) {
             T = v->type();
             return true;
@@ -388,61 +407,62 @@
     return false;
 }
 
-#define DECLARE_MULTISAMPLED_TEXTURE(suffix, dim)                                      \
-    inline bool JOIN(match_texture_multisampled_, suffix)(                             \
-        intrinsic::MatchState & state, const type::Type* ty, const type::Type*& T) {   \
-        return match_texture_multisampled(state, ty, dim, T);                          \
-    }                                                                                  \
-    inline const type::MultisampledTexture* JOIN(build_texture_multisampled_, suffix)( \
-        intrinsic::MatchState & state, const type::Type* T) {                          \
-        return state.types.Get<type::MultisampledTexture>(dim, T);                     \
+#define DECLARE_MULTISAMPLED_TEXTURE(suffix, dim)                                                \
+    inline bool JOIN(match_texture_multisampled_, suffix)(                                       \
+        intrinsic::MatchState & state, const core::type::Type* ty, const core::type::Type*& T) { \
+        return match_texture_multisampled(state, ty, dim, T);                                    \
+    }                                                                                            \
+    inline const core::type::MultisampledTexture* JOIN(build_texture_multisampled_, suffix)(     \
+        intrinsic::MatchState & state, const core::type::Type* T) {                              \
+        return state.types.Get<core::type::MultisampledTexture>(dim, T);                         \
     }
 
-DECLARE_MULTISAMPLED_TEXTURE(2d, type::TextureDimension::k2d)
+DECLARE_MULTISAMPLED_TEXTURE(2d, core::type::TextureDimension::k2d)
 #undef DECLARE_MULTISAMPLED_TEXTURE
 
 inline bool match_texture_depth(intrinsic::MatchState&,
-                                const type::Type* ty,
-                                type::TextureDimension dim) {
+                                const core::type::Type* ty,
+                                core::type::TextureDimension dim) {
     if (ty->Is<intrinsic::Any>()) {
         return true;
     }
-    return ty->Is([&](const type::DepthTexture* t) { return t->dim() == dim; });
+    return ty->Is([&](const core::type::DepthTexture* t) { return t->dim() == dim; });
 }
 
-#define DECLARE_DEPTH_TEXTURE(suffix, dim)                                         \
-    inline bool JOIN(match_texture_depth_, suffix)(intrinsic::MatchState & state,  \
-                                                   const type::Type* ty) {         \
-        return match_texture_depth(state, ty, dim);                                \
-    }                                                                              \
-    inline const type::DepthTexture* JOIN(build_texture_depth_,                    \
-                                          suffix)(intrinsic::MatchState & state) { \
-        return state.types.Get<type::DepthTexture>(dim);                           \
+#define DECLARE_DEPTH_TEXTURE(suffix, dim)                                               \
+    inline bool JOIN(match_texture_depth_, suffix)(intrinsic::MatchState & state,        \
+                                                   const core::type::Type* ty) {         \
+        return match_texture_depth(state, ty, dim);                                      \
+    }                                                                                    \
+    inline const core::type::DepthTexture* JOIN(build_texture_depth_,                    \
+                                                suffix)(intrinsic::MatchState & state) { \
+        return state.types.Get<core::type::DepthTexture>(dim);                           \
     }
 
-DECLARE_DEPTH_TEXTURE(2d, type::TextureDimension::k2d)
-DECLARE_DEPTH_TEXTURE(2d_array, type::TextureDimension::k2dArray)
-DECLARE_DEPTH_TEXTURE(cube, type::TextureDimension::kCube)
-DECLARE_DEPTH_TEXTURE(cube_array, type::TextureDimension::kCubeArray)
+DECLARE_DEPTH_TEXTURE(2d, core::type::TextureDimension::k2d)
+DECLARE_DEPTH_TEXTURE(2d_array, core::type::TextureDimension::k2dArray)
+DECLARE_DEPTH_TEXTURE(cube, core::type::TextureDimension::kCube)
+DECLARE_DEPTH_TEXTURE(cube_array, core::type::TextureDimension::kCubeArray)
 #undef DECLARE_DEPTH_TEXTURE
 
-inline bool match_texture_depth_multisampled_2d(intrinsic::MatchState&, const type::Type* ty) {
+inline bool match_texture_depth_multisampled_2d(intrinsic::MatchState&,
+                                                const core::type::Type* ty) {
     if (ty->Is<intrinsic::Any>()) {
         return true;
     }
-    return ty->Is([&](const type::DepthMultisampledTexture* t) {
-        return t->dim() == type::TextureDimension::k2d;
+    return ty->Is([&](const core::type::DepthMultisampledTexture* t) {
+        return t->dim() == core::type::TextureDimension::k2d;
     });
 }
 
-inline type::DepthMultisampledTexture* build_texture_depth_multisampled_2d(
+inline core::type::DepthMultisampledTexture* build_texture_depth_multisampled_2d(
     intrinsic::MatchState& state) {
-    return state.types.Get<type::DepthMultisampledTexture>(type::TextureDimension::k2d);
+    return state.types.Get<core::type::DepthMultisampledTexture>(core::type::TextureDimension::k2d);
 }
 
 inline bool match_texture_storage(intrinsic::MatchState&,
-                                  const type::Type* ty,
-                                  type::TextureDimension dim,
+                                  const core::type::Type* ty,
+                                  core::type::TextureDimension dim,
                                   intrinsic::Number& F,
                                   intrinsic::Number& A) {
     if (ty->Is<intrinsic::Any>()) {
@@ -450,7 +470,7 @@
         A = intrinsic::Number::any;
         return true;
     }
-    if (auto* v = ty->As<type::StorageTexture>()) {
+    if (auto* v = ty->As<core::type::StorageTexture>()) {
         if (v->dim() == dim) {
             F = intrinsic::Number(static_cast<uint32_t>(v->texel_format()));
             A = intrinsic::Number(static_cast<uint32_t>(v->access()));
@@ -460,38 +480,40 @@
     return false;
 }
 
-#define DECLARE_STORAGE_TEXTURE(suffix, dim)                                                     \
-    inline bool JOIN(match_texture_storage_, suffix)(intrinsic::MatchState & state,              \
-                                                     const type::Type* ty, intrinsic::Number& F, \
-                                                     intrinsic::Number& A) {                     \
-        return match_texture_storage(state, ty, dim, F, A);                                      \
-    }                                                                                            \
-    inline const type::StorageTexture* JOIN(build_texture_storage_, suffix)(                     \
-        intrinsic::MatchState & state, intrinsic::Number F, intrinsic::Number A) {               \
-        auto format = static_cast<TexelFormat>(F.Value());                                       \
-        auto access = static_cast<Access>(A.Value());                                            \
-        auto* T = type::StorageTexture::SubtypeFor(format, state.types);                         \
-        return state.types.Get<type::StorageTexture>(dim, format, access, T);                    \
+#define DECLARE_STORAGE_TEXTURE(suffix, dim)                                                       \
+    inline bool JOIN(match_texture_storage_, suffix)(intrinsic::MatchState & state,                \
+                                                     const core::type::Type* ty,                   \
+                                                     intrinsic::Number& F, intrinsic::Number& A) { \
+        return match_texture_storage(state, ty, dim, F, A);                                        \
+    }                                                                                              \
+    inline const core::type::StorageTexture* JOIN(build_texture_storage_, suffix)(                 \
+        intrinsic::MatchState & state, intrinsic::Number F, intrinsic::Number A) {                 \
+        auto format = static_cast<TexelFormat>(F.Value());                                         \
+        auto access = static_cast<Access>(A.Value());                                              \
+        auto* T = core::type::StorageTexture::SubtypeFor(format, state.types);                     \
+        return state.types.Get<core::type::StorageTexture>(dim, format, access, T);                \
     }
 
-DECLARE_STORAGE_TEXTURE(1d, type::TextureDimension::k1d)
-DECLARE_STORAGE_TEXTURE(2d, type::TextureDimension::k2d)
-DECLARE_STORAGE_TEXTURE(2d_array, type::TextureDimension::k2dArray)
-DECLARE_STORAGE_TEXTURE(3d, type::TextureDimension::k3d)
+DECLARE_STORAGE_TEXTURE(1d, core::type::TextureDimension::k1d)
+DECLARE_STORAGE_TEXTURE(2d, core::type::TextureDimension::k2d)
+DECLARE_STORAGE_TEXTURE(2d_array, core::type::TextureDimension::k2dArray)
+DECLARE_STORAGE_TEXTURE(3d, core::type::TextureDimension::k3d)
 #undef DECLARE_STORAGE_TEXTURE
 
-inline bool match_texture_external(intrinsic::MatchState&, const type::Type* ty) {
-    return ty->IsAnyOf<intrinsic::Any, type::ExternalTexture>();
+inline bool match_texture_external(intrinsic::MatchState&, const core::type::Type* ty) {
+    return ty->IsAnyOf<intrinsic::Any, core::type::ExternalTexture>();
 }
 
-inline const type::ExternalTexture* build_texture_external(intrinsic::MatchState& state) {
-    return state.types.Get<type::ExternalTexture>();
+inline const core::type::ExternalTexture* build_texture_external(intrinsic::MatchState& state) {
+    return state.types.Get<core::type::ExternalTexture>();
 }
 
 // Builtin types starting with a _ prefix cannot be declared in WGSL, so they
 // can only be used as return types. Because of this, they must only match Any,
 // which is used as the return type matcher.
-inline bool match_modf_result(intrinsic::MatchState&, const type::Type* ty, const type::Type*& T) {
+inline bool match_modf_result(intrinsic::MatchState&,
+                              const core::type::Type* ty,
+                              const core::type::Type*& T) {
     if (!ty->Is<intrinsic::Any>()) {
         return false;
     }
@@ -499,9 +521,9 @@
     return true;
 }
 inline bool match_modf_result_vec(intrinsic::MatchState&,
-                                  const type::Type* ty,
+                                  const core::type::Type* ty,
                                   intrinsic::Number& N,
-                                  const type::Type*& T) {
+                                  const core::type::Type*& T) {
     if (!ty->Is<intrinsic::Any>()) {
         return false;
     }
@@ -509,7 +531,9 @@
     T = ty;
     return true;
 }
-inline bool match_frexp_result(intrinsic::MatchState&, const type::Type* ty, const type::Type*& T) {
+inline bool match_frexp_result(intrinsic::MatchState&,
+                               const core::type::Type* ty,
+                               const core::type::Type*& T) {
     if (!ty->Is<intrinsic::Any>()) {
         return false;
     }
@@ -517,9 +541,9 @@
     return true;
 }
 inline bool match_frexp_result_vec(intrinsic::MatchState&,
-                                   const type::Type* ty,
+                                   const core::type::Type* ty,
                                    intrinsic::Number& N,
-                                   const type::Type*& T) {
+                                   const core::type::Type*& T) {
     if (!ty->Is<intrinsic::Any>()) {
         return false;
     }
@@ -529,8 +553,8 @@
 }
 
 inline bool match_atomic_compare_exchange_result(intrinsic::MatchState&,
-                                                 const type::Type* ty,
-                                                 const type::Type*& T) {
+                                                 const core::type::Type* ty,
+                                                 const core::type::Type*& T) {
     if (ty->Is<intrinsic::Any>()) {
         T = ty;
         return true;
@@ -538,31 +562,33 @@
     return false;
 }
 
-inline const type::Struct* build_modf_result(intrinsic::MatchState& state, const type::Type* el) {
-    return type::CreateModfResult(state.types, state.symbols, el);
+inline const core::type::Struct* build_modf_result(intrinsic::MatchState& state,
+                                                   const core::type::Type* el) {
+    return core::type::CreateModfResult(state.types, state.symbols, el);
 }
 
-inline const type::Struct* build_modf_result_vec(intrinsic::MatchState& state,
-                                                 intrinsic::Number& n,
-                                                 const type::Type* el) {
+inline const core::type::Struct* build_modf_result_vec(intrinsic::MatchState& state,
+                                                       intrinsic::Number& n,
+                                                       const core::type::Type* el) {
     auto* vec = state.types.vec(el, n.Value());
-    return type::CreateModfResult(state.types, state.symbols, vec);
+    return core::type::CreateModfResult(state.types, state.symbols, vec);
 }
 
-inline const type::Struct* build_frexp_result(intrinsic::MatchState& state, const type::Type* el) {
-    return type::CreateFrexpResult(state.types, state.symbols, el);
+inline const core::type::Struct* build_frexp_result(intrinsic::MatchState& state,
+                                                    const core::type::Type* el) {
+    return core::type::CreateFrexpResult(state.types, state.symbols, el);
 }
 
-inline const type::Struct* build_frexp_result_vec(intrinsic::MatchState& state,
-                                                  intrinsic::Number& n,
-                                                  const type::Type* el) {
+inline const core::type::Struct* build_frexp_result_vec(intrinsic::MatchState& state,
+                                                        intrinsic::Number& n,
+                                                        const core::type::Type* el) {
     auto* vec = state.types.vec(el, n.Value());
-    return type::CreateFrexpResult(state.types, state.symbols, vec);
+    return core::type::CreateFrexpResult(state.types, state.symbols, vec);
 }
 
-inline const type::Struct* build_atomic_compare_exchange_result(intrinsic::MatchState& state,
-                                                                const type::Type* ty) {
-    return type::CreateAtomicCompareExchangeResult(state.types, state.symbols, ty);
+inline const core::type::Struct* build_atomic_compare_exchange_result(intrinsic::MatchState& state,
+                                                                      const core::type::Type* ty) {
+    return core::type::CreateAtomicCompareExchangeResult(state.types, state.symbols, ty);
 }
 
 }  // namespace tint::core
diff --git a/src/tint/lang/core/ir/block_param.cc b/src/tint/lang/core/ir/block_param.cc
index 46a4070..4f031c4 100644
--- a/src/tint/lang/core/ir/block_param.cc
+++ b/src/tint/lang/core/ir/block_param.cc
@@ -19,7 +19,7 @@
 
 namespace tint::ir {
 
-BlockParam::BlockParam(const type::Type* ty) : type_(ty) {
+BlockParam::BlockParam(const core::type::Type* ty) : type_(ty) {
     TINT_ASSERT(type_ != nullptr);
 }
 
diff --git a/src/tint/lang/core/ir/block_param.h b/src/tint/lang/core/ir/block_param.h
index e694540..73e7853 100644
--- a/src/tint/lang/core/ir/block_param.h
+++ b/src/tint/lang/core/ir/block_param.h
@@ -25,15 +25,15 @@
   public:
     /// Constructor
     /// @param type the type of the var
-    explicit BlockParam(const type::Type* type);
+    explicit BlockParam(const core::type::Type* type);
     ~BlockParam() override;
 
     /// @returns the type of the var
-    const type::Type* Type() override { return type_; }
+    const core::type::Type* Type() override { return type_; }
 
   private:
     /// the result type of the instruction
-    const type::Type* type_ = nullptr;
+    const core::type::Type* type_ = nullptr;
 };
 
 }  // namespace tint::ir
diff --git a/src/tint/lang/core/ir/builder.cc b/src/tint/lang/core/ir/builder.cc
index 6a4dc8d..0cfc9d1 100644
--- a/src/tint/lang/core/ir/builder.cc
+++ b/src/tint/lang/core/ir/builder.cc
@@ -45,7 +45,7 @@
 }
 
 Function* Builder::Function(std::string_view name,
-                            const type::Type* return_type,
+                            const core::type::Type* return_type,
                             Function::PipelineStage stage,
                             std::optional<std::array<uint32_t, 3>> wg_size) {
     auto* ir_func = ir.values.Create<ir::Function>(return_type, stage, wg_size);
@@ -74,31 +74,31 @@
     return Append(ir.instructions.Create<ir::Discard>());
 }
 
-ir::Var* Builder::Var(const type::Pointer* type) {
+ir::Var* Builder::Var(const core::type::Pointer* type) {
     return Append(ir.instructions.Create<ir::Var>(InstructionResult(type)));
 }
 
-ir::Var* Builder::Var(std::string_view name, const type::Pointer* type) {
+ir::Var* Builder::Var(std::string_view name, const core::type::Pointer* type) {
     auto* var = Var(type);
     ir.SetName(var, name);
     return var;
 }
 
-ir::BlockParam* Builder::BlockParam(const type::Type* type) {
+ir::BlockParam* Builder::BlockParam(const core::type::Type* type) {
     return ir.values.Create<ir::BlockParam>(type);
 }
 
-ir::BlockParam* Builder::BlockParam(std::string_view name, const type::Type* type) {
+ir::BlockParam* Builder::BlockParam(std::string_view name, const core::type::Type* type) {
     auto* param = ir.values.Create<ir::BlockParam>(type);
     ir.SetName(param, name);
     return param;
 }
 
-ir::FunctionParam* Builder::FunctionParam(const type::Type* type) {
+ir::FunctionParam* Builder::FunctionParam(const core::type::Type* type) {
     return ir.values.Create<ir::FunctionParam>(type);
 }
 
-ir::FunctionParam* Builder::FunctionParam(std::string_view name, const type::Type* type) {
+ir::FunctionParam* Builder::FunctionParam(std::string_view name, const core::type::Type* type) {
     auto* param = ir.values.Create<ir::FunctionParam>(type);
     ir.SetName(param, name);
     return param;
@@ -112,11 +112,11 @@
     return Append(ir.instructions.Create<ir::Unreachable>());
 }
 
-const type::Type* Builder::VectorPtrElementType(const type::Type* type) {
-    auto* vec_ptr_ty = type->As<type::Pointer>();
+const core::type::Type* Builder::VectorPtrElementType(const core::type::Type* type) {
+    auto* vec_ptr_ty = type->As<core::type::Pointer>();
     TINT_ASSERT(vec_ptr_ty);
     if (TINT_LIKELY(vec_ptr_ty)) {
-        auto* vec_ty = vec_ptr_ty->StoreType()->As<type::Vector>();
+        auto* vec_ty = vec_ptr_ty->StoreType()->As<core::type::Vector>();
         TINT_ASSERT(vec_ty);
         if (TINT_LIKELY(vec_ty)) {
             return vec_ty->type();
diff --git a/src/tint/lang/core/ir/builder.h b/src/tint/lang/core/ir/builder.h
index 3510eec..b67303e 100644
--- a/src/tint/lang/core/ir/builder.h
+++ b/src/tint/lang/core/ir/builder.h
@@ -173,7 +173,7 @@
     /// @param wg_size the workgroup_size
     /// @returns the instruction
     ir::Function* Function(std::string_view name,
-                           const type::Type* return_type,
+                           const core::type::Type* return_type,
                            Function::PipelineStage stage = Function::PipelineStage::kUndefined,
                            std::optional<std::array<uint32_t, 3>> wg_size = {});
 
@@ -285,7 +285,7 @@
     /// @param size the number of items
     /// @returns the new constant
     template <typename ARG>
-    ir::Constant* Splat(const type::Type* ty, ARG&& value, size_t size) {
+    ir::Constant* Splat(const core::type::Type* ty, ARG&& value, size_t size) {
         return Constant(
             ir.constant_values.Splat(ty, ConstantValue(std::forward<ARG>(value)), size));
     }
@@ -295,7 +295,7 @@
     /// @param values the composite values
     /// @returns the new constant
     template <typename... ARGS, typename = DisableIfVectorLike<ARGS...>>
-    ir::Constant* Composite(const type::Type* ty, ARGS&&... values) {
+    ir::Constant* Composite(const core::type::Type* ty, ARGS&&... values) {
         return Constant(
             ir.constant_values.Composite(ty, Vector{ConstantValue(std::forward<ARGS>(values))...}));
     }
@@ -362,7 +362,7 @@
     /// @param rhs the right-hand-side of the operation
     /// @returns the operation
     template <typename LHS, typename RHS>
-    ir::Binary* Binary(enum Binary::Kind kind, const type::Type* type, LHS&& lhs, RHS&& rhs) {
+    ir::Binary* Binary(enum Binary::Kind kind, const core::type::Type* type, LHS&& lhs, RHS&& rhs) {
         CheckForNonDeterministicEvaluation<LHS, RHS>();
         auto* lhs_val = Value(std::forward<LHS>(lhs));
         auto* rhs_val = Value(std::forward<RHS>(rhs));
@@ -376,7 +376,7 @@
     /// @param rhs the rhs of the add
     /// @returns the operation
     template <typename LHS, typename RHS>
-    ir::Binary* And(const type::Type* type, LHS&& lhs, RHS&& rhs) {
+    ir::Binary* And(const core::type::Type* type, LHS&& lhs, RHS&& rhs) {
         return Binary(ir::Binary::Kind::kAnd, type, std::forward<LHS>(lhs), std::forward<RHS>(rhs));
     }
 
@@ -386,7 +386,7 @@
     /// @param rhs the rhs of the add
     /// @returns the operation
     template <typename LHS, typename RHS>
-    ir::Binary* Or(const type::Type* type, LHS&& lhs, RHS&& rhs) {
+    ir::Binary* Or(const core::type::Type* type, LHS&& lhs, RHS&& rhs) {
         return Binary(ir::Binary::Kind::kOr, type, std::forward<LHS>(lhs), std::forward<RHS>(rhs));
     }
 
@@ -396,7 +396,7 @@
     /// @param rhs the rhs of the add
     /// @returns the operation
     template <typename LHS, typename RHS>
-    ir::Binary* Xor(const type::Type* type, LHS&& lhs, RHS&& rhs) {
+    ir::Binary* Xor(const core::type::Type* type, LHS&& lhs, RHS&& rhs) {
         return Binary(ir::Binary::Kind::kXor, type, std::forward<LHS>(lhs), std::forward<RHS>(rhs));
     }
 
@@ -406,7 +406,7 @@
     /// @param rhs the rhs of the add
     /// @returns the operation
     template <typename LHS, typename RHS>
-    ir::Binary* Equal(const type::Type* type, LHS&& lhs, RHS&& rhs) {
+    ir::Binary* Equal(const core::type::Type* type, LHS&& lhs, RHS&& rhs) {
         return Binary(ir::Binary::Kind::kEqual, type, std::forward<LHS>(lhs),
                       std::forward<RHS>(rhs));
     }
@@ -417,7 +417,7 @@
     /// @param rhs the rhs of the add
     /// @returns the operation
     template <typename LHS, typename RHS>
-    ir::Binary* NotEqual(const type::Type* type, LHS&& lhs, RHS&& rhs) {
+    ir::Binary* NotEqual(const core::type::Type* type, LHS&& lhs, RHS&& rhs) {
         return Binary(ir::Binary::Kind::kNotEqual, type, std::forward<LHS>(lhs),
                       std::forward<RHS>(rhs));
     }
@@ -428,7 +428,7 @@
     /// @param rhs the rhs of the add
     /// @returns the operation
     template <typename LHS, typename RHS>
-    ir::Binary* LessThan(const type::Type* type, LHS&& lhs, RHS&& rhs) {
+    ir::Binary* LessThan(const core::type::Type* type, LHS&& lhs, RHS&& rhs) {
         return Binary(ir::Binary::Kind::kLessThan, type, std::forward<LHS>(lhs),
                       std::forward<RHS>(rhs));
     }
@@ -439,7 +439,7 @@
     /// @param rhs the rhs of the add
     /// @returns the operation
     template <typename LHS, typename RHS>
-    ir::Binary* GreaterThan(const type::Type* type, LHS&& lhs, RHS&& rhs) {
+    ir::Binary* GreaterThan(const core::type::Type* type, LHS&& lhs, RHS&& rhs) {
         return Binary(ir::Binary::Kind::kGreaterThan, type, std::forward<LHS>(lhs),
                       std::forward<RHS>(rhs));
     }
@@ -450,7 +450,7 @@
     /// @param rhs the rhs of the add
     /// @returns the operation
     template <typename LHS, typename RHS>
-    ir::Binary* LessThanEqual(const type::Type* type, LHS&& lhs, RHS&& rhs) {
+    ir::Binary* LessThanEqual(const core::type::Type* type, LHS&& lhs, RHS&& rhs) {
         return Binary(ir::Binary::Kind::kLessThanEqual, type, std::forward<LHS>(lhs),
                       std::forward<RHS>(rhs));
     }
@@ -461,7 +461,7 @@
     /// @param rhs the rhs of the add
     /// @returns the operation
     template <typename LHS, typename RHS>
-    ir::Binary* GreaterThanEqual(const type::Type* type, LHS&& lhs, RHS&& rhs) {
+    ir::Binary* GreaterThanEqual(const core::type::Type* type, LHS&& lhs, RHS&& rhs) {
         return Binary(ir::Binary::Kind::kGreaterThanEqual, type, std::forward<LHS>(lhs),
                       std::forward<RHS>(rhs));
     }
@@ -472,7 +472,7 @@
     /// @param rhs the rhs of the add
     /// @returns the operation
     template <typename LHS, typename RHS>
-    ir::Binary* ShiftLeft(const type::Type* type, LHS&& lhs, RHS&& rhs) {
+    ir::Binary* ShiftLeft(const core::type::Type* type, LHS&& lhs, RHS&& rhs) {
         return Binary(ir::Binary::Kind::kShiftLeft, type, std::forward<LHS>(lhs),
                       std::forward<RHS>(rhs));
     }
@@ -483,7 +483,7 @@
     /// @param rhs the rhs of the add
     /// @returns the operation
     template <typename LHS, typename RHS>
-    ir::Binary* ShiftRight(const type::Type* type, LHS&& lhs, RHS&& rhs) {
+    ir::Binary* ShiftRight(const core::type::Type* type, LHS&& lhs, RHS&& rhs) {
         return Binary(ir::Binary::Kind::kShiftRight, type, std::forward<LHS>(lhs),
                       std::forward<RHS>(rhs));
     }
@@ -494,7 +494,7 @@
     /// @param rhs the rhs of the add
     /// @returns the operation
     template <typename LHS, typename RHS>
-    ir::Binary* Add(const type::Type* type, LHS&& lhs, RHS&& rhs) {
+    ir::Binary* Add(const core::type::Type* type, LHS&& lhs, RHS&& rhs) {
         return Binary(ir::Binary::Kind::kAdd, type, std::forward<LHS>(lhs), std::forward<RHS>(rhs));
     }
 
@@ -504,7 +504,7 @@
     /// @param rhs the rhs of the add
     /// @returns the operation
     template <typename LHS, typename RHS>
-    ir::Binary* Subtract(const type::Type* type, LHS&& lhs, RHS&& rhs) {
+    ir::Binary* Subtract(const core::type::Type* type, LHS&& lhs, RHS&& rhs) {
         return Binary(ir::Binary::Kind::kSubtract, type, std::forward<LHS>(lhs),
                       std::forward<RHS>(rhs));
     }
@@ -515,7 +515,7 @@
     /// @param rhs the rhs of the add
     /// @returns the operation
     template <typename LHS, typename RHS>
-    ir::Binary* Multiply(const type::Type* type, LHS&& lhs, RHS&& rhs) {
+    ir::Binary* Multiply(const core::type::Type* type, LHS&& lhs, RHS&& rhs) {
         return Binary(ir::Binary::Kind::kMultiply, type, std::forward<LHS>(lhs),
                       std::forward<RHS>(rhs));
     }
@@ -526,7 +526,7 @@
     /// @param rhs the rhs of the add
     /// @returns the operation
     template <typename LHS, typename RHS>
-    ir::Binary* Divide(const type::Type* type, LHS&& lhs, RHS&& rhs) {
+    ir::Binary* Divide(const core::type::Type* type, LHS&& lhs, RHS&& rhs) {
         return Binary(ir::Binary::Kind::kDivide, type, std::forward<LHS>(lhs),
                       std::forward<RHS>(rhs));
     }
@@ -537,7 +537,7 @@
     /// @param rhs the rhs of the add
     /// @returns the operation
     template <typename LHS, typename RHS>
-    ir::Binary* Modulo(const type::Type* type, LHS&& lhs, RHS&& rhs) {
+    ir::Binary* Modulo(const core::type::Type* type, LHS&& lhs, RHS&& rhs) {
         return Binary(ir::Binary::Kind::kModulo, type, std::forward<LHS>(lhs),
                       std::forward<RHS>(rhs));
     }
@@ -548,7 +548,7 @@
     /// @param val the value of the operation
     /// @returns the operation
     template <typename VAL>
-    ir::Unary* Unary(enum Unary::Kind kind, const type::Type* type, VAL&& val) {
+    ir::Unary* Unary(enum Unary::Kind kind, const core::type::Type* type, VAL&& val) {
         auto* value = Value(std::forward<VAL>(val));
         return Append(ir.instructions.Create<ir::Unary>(InstructionResult(type), kind, value));
     }
@@ -558,7 +558,7 @@
     /// @param val the value
     /// @returns the operation
     template <typename VAL>
-    ir::Unary* Complement(const type::Type* type, VAL&& val) {
+    ir::Unary* Complement(const core::type::Type* type, VAL&& val) {
         return Unary(ir::Unary::Kind::kComplement, type, std::forward<VAL>(val));
     }
 
@@ -567,7 +567,7 @@
     /// @param val the value
     /// @returns the operation
     template <typename VAL>
-    ir::Unary* Negation(const type::Type* type, VAL&& val) {
+    ir::Unary* Negation(const core::type::Type* type, VAL&& val) {
         return Unary(ir::Unary::Kind::kNegation, type, std::forward<VAL>(val));
     }
 
@@ -576,8 +576,8 @@
     /// @param val the value
     /// @returns the operation
     template <typename VAL>
-    ir::Binary* Not(const type::Type* type, VAL&& val) {
-        if (auto* vec = type->As<type::Vector>()) {
+    ir::Binary* Not(const core::type::Type* type, VAL&& val) {
+        if (auto* vec = type->As<core::type::Vector>()) {
             return Equal(type, std::forward<VAL>(val), Splat(vec, false, vec->Width()));
         } else {
             return Equal(type, std::forward<VAL>(val), Constant(false));
@@ -589,7 +589,7 @@
     /// @param val the value being bitcast
     /// @returns the instruction
     template <typename VAL>
-    ir::Bitcast* Bitcast(const type::Type* type, VAL&& val) {
+    ir::Bitcast* Bitcast(const core::type::Type* type, VAL&& val) {
         auto* value = Value(std::forward<VAL>(val));
         return Append(ir.instructions.Create<ir::Bitcast>(InstructionResult(type), value));
     }
@@ -604,7 +604,7 @@
     /// @param args the call arguments
     /// @returns the instruction
     template <typename... ARGS>
-    ir::UserCall* Call(const type::Type* type, ir::Function* func, ARGS&&... args) {
+    ir::UserCall* Call(const core::type::Type* type, ir::Function* func, ARGS&&... args) {
         return Append(ir.instructions.Create<ir::UserCall>(InstructionResult(type), func,
                                                            Values(std::forward<ARGS>(args)...)));
     }
@@ -615,7 +615,7 @@
     /// @param args the call arguments
     /// @returns the instruction
     template <typename... ARGS>
-    ir::CoreBuiltinCall* Call(const type::Type* type, core::Function func, ARGS&&... args) {
+    ir::CoreBuiltinCall* Call(const core::type::Type* type, core::Function func, ARGS&&... args) {
         return Append(ir.instructions.Create<ir::CoreBuiltinCall>(
             InstructionResult(type), func, Values(std::forward<ARGS>(args)...)));
     }
@@ -626,7 +626,9 @@
     /// @param args the call arguments
     /// @returns the intrinsic call instruction
     template <typename... ARGS>
-    ir::IntrinsicCall* Call(const type::Type* type, enum IntrinsicCall::Kind kind, ARGS&&... args) {
+    ir::IntrinsicCall* Call(const core::type::Type* type,
+                            enum IntrinsicCall::Kind kind,
+                            ARGS&&... args) {
         return Append(ir.instructions.Create<ir::IntrinsicCall>(
             InstructionResult(type), kind, Values(std::forward<ARGS>(args)...)));
     }
@@ -636,7 +638,7 @@
     /// @param val the value to be converted
     /// @returns the instruction
     template <typename VAL>
-    ir::Convert* Convert(const type::Type* to, VAL&& val) {
+    ir::Convert* Convert(const core::type::Type* to, VAL&& val) {
         return Append(ir.instructions.Create<ir::Convert>(InstructionResult(to),
                                                           Value(std::forward<VAL>(val))));
     }
@@ -646,7 +648,7 @@
     /// @param args the arguments to the constructor
     /// @returns the instruction
     template <typename... ARGS>
-    ir::Construct* Construct(const type::Type* type, ARGS&&... args) {
+    ir::Construct* Construct(const core::type::Type* type, ARGS&&... args) {
         return Append(ir.instructions.Create<ir::Construct>(InstructionResult(type),
                                                             Values(std::forward<ARGS>(args)...)));
     }
@@ -703,13 +705,13 @@
     /// Creates a new `var` declaration
     /// @param type the var type
     /// @returns the instruction
-    ir::Var* Var(const type::Pointer* type);
+    ir::Var* Var(const core::type::Pointer* type);
 
     /// Creates a new `var` declaration with a name
     /// @param name the var name
     /// @param type the var type
     /// @returns the instruction
-    ir::Var* Var(std::string_view name, const type::Pointer* type);
+    ir::Var* Var(std::string_view name, const core::type::Pointer* type);
 
     /// Creates a new `let` declaration
     /// @param name the let name
@@ -828,24 +830,24 @@
     /// Creates a new `BlockParam`
     /// @param type the parameter type
     /// @returns the value
-    ir::BlockParam* BlockParam(const type::Type* type);
+    ir::BlockParam* BlockParam(const core::type::Type* type);
 
     /// Creates a new `BlockParam` with a name.
     /// @param name the parameter name
     /// @param type the parameter type
     /// @returns the value
-    ir::BlockParam* BlockParam(std::string_view name, const type::Type* type);
+    ir::BlockParam* BlockParam(std::string_view name, const core::type::Type* type);
 
     /// Creates a new `FunctionParam`
     /// @param type the parameter type
     /// @returns the value
-    ir::FunctionParam* FunctionParam(const type::Type* type);
+    ir::FunctionParam* FunctionParam(const core::type::Type* type);
 
     /// Creates a new `FunctionParam` with a name.
     /// @param name the parameter name
     /// @param type the parameter type
     /// @returns the value
-    ir::FunctionParam* FunctionParam(std::string_view name, const type::Type* type);
+    ir::FunctionParam* FunctionParam(std::string_view name, const core::type::Type* type);
 
     /// Creates a new `Access`
     /// @param type the return type
@@ -853,7 +855,7 @@
     /// @param indices the access indices
     /// @returns the instruction
     template <typename OBJ, typename... ARGS>
-    ir::Access* Access(const type::Type* type, OBJ&& object, ARGS&&... indices) {
+    ir::Access* Access(const core::type::Type* type, OBJ&& object, ARGS&&... indices) {
         CheckForNonDeterministicEvaluation<OBJ, ARGS...>();
         auto* obj_val = Value(std::forward<OBJ>(object));
         return Append(ir.instructions.Create<ir::Access>(InstructionResult(type), obj_val,
@@ -866,7 +868,7 @@
     /// @param indices the swizzle indices
     /// @returns the instruction
     template <typename OBJ>
-    ir::Swizzle* Swizzle(const type::Type* type, OBJ&& object, VectorRef<uint32_t> indices) {
+    ir::Swizzle* Swizzle(const core::type::Type* type, OBJ&& object, VectorRef<uint32_t> indices) {
         auto* obj_val = Value(std::forward<OBJ>(object));
         return Append(ir.instructions.Create<ir::Swizzle>(InstructionResult(type), obj_val,
                                                           std::move(indices)));
@@ -878,7 +880,7 @@
     /// @param indices the swizzle indices
     /// @returns the instruction
     template <typename OBJ>
-    ir::Swizzle* Swizzle(const type::Type* type,
+    ir::Swizzle* Swizzle(const core::type::Type* type,
                          OBJ&& object,
                          std::initializer_list<uint32_t> indices) {
         auto* obj_val = Value(std::forward<OBJ>(object));
@@ -901,7 +903,7 @@
     /// Creates a new runtime value
     /// @param type the return type
     /// @returns the value
-    ir::InstructionResult* InstructionResult(const type::Type* type) {
+    ir::InstructionResult* InstructionResult(const core::type::Type* type) {
         return ir.values.Create<ir::InstructionResult>(type);
     }
 
@@ -912,7 +914,7 @@
     /// @param step the loop index step amount
     /// @param cb the callback to call for the loop body
     template <typename START, typename END, typename STEP, typename FUNCTION>
-    void LoopRange(type::Manager& ty, START&& start, END&& end, STEP&& step, FUNCTION&& cb) {
+    void LoopRange(core::type::Manager& ty, START&& start, END&& end, STEP&& step, FUNCTION&& cb) {
         auto* start_value = Value(std::forward<START>(start));
         auto* end_value = Value(std::forward<END>(end));
         auto* step_value = Value(std::forward<STEP>(step));
@@ -948,7 +950,7 @@
   private:
     /// @returns the element type of the vector-pointer type
     /// Asserts and return i32 if @p type is not a pointer to a vector
-    const type::Type* VectorPtrElementType(const type::Type* type);
+    const core::type::Type* VectorPtrElementType(const core::type::Type* type);
 };
 
 }  // namespace tint::ir
diff --git a/src/tint/lang/core/ir/constant.h b/src/tint/lang/core/ir/constant.h
index 3dde430..6a75e91 100644
--- a/src/tint/lang/core/ir/constant.h
+++ b/src/tint/lang/core/ir/constant.h
@@ -32,7 +32,7 @@
     const core::constant::Value* Value() { return value_; }
 
     /// @returns the type of the constant
-    const type::Type* Type() override { return value_->Type(); }
+    const core::type::Type* Type() override { return value_->Type(); }
 
   private:
     const core::constant::Value* const value_ = nullptr;
diff --git a/src/tint/lang/core/ir/disassembler.cc b/src/tint/lang/core/ir/disassembler.cc
index c5a339d..71bd370 100644
--- a/src/tint/lang/core/ir/disassembler.cc
+++ b/src/tint/lang/core/ir/disassembler.cc
@@ -145,7 +145,7 @@
 
 std::string Disassembler::Disassemble() {
     for (auto* ty : mod_.Types()) {
-        if (auto* str = ty->As<type::Struct>()) {
+        if (auto* str = ty->As<core::type::Struct>()) {
             EmitStructDecl(str);
         }
     }
@@ -894,9 +894,9 @@
     sm.Store(u);
 }
 
-void Disassembler::EmitStructDecl(const type::Struct* str) {
+void Disassembler::EmitStructDecl(const core::type::Struct* str) {
     out_ << str->Name().Name() << " = struct @align(" << str->Align() << ")";
-    if (str->StructFlags().Contains(type::StructFlag::kBlock)) {
+    if (str->StructFlags().Contains(core::type::StructFlag::kBlock)) {
         out_ << ", @block";
     }
     out_ << " {";
diff --git a/src/tint/lang/core/ir/disassembler.h b/src/tint/lang/core/ir/disassembler.h
index 27c8518..39ca61d 100644
--- a/src/tint/lang/core/ir/disassembler.h
+++ b/src/tint/lang/core/ir/disassembler.h
@@ -30,7 +30,7 @@
 #include "src/tint/utils/text/string_stream.h"
 
 // Forward declarations.
-namespace tint::type {
+namespace tint::core::type {
 class Struct;
 }
 
@@ -140,7 +140,7 @@
     void EmitSwitch(Switch* s);
     void EmitLoop(Loop* l);
     void EmitIf(If* i);
-    void EmitStructDecl(const type::Struct* str);
+    void EmitStructDecl(const core::type::Struct* str);
     void EmitLine();
     void EmitOperand(Instruction* inst, size_t index);
     void EmitOperandList(Instruction* inst, size_t start_index = 0);
diff --git a/src/tint/lang/core/ir/function.cc b/src/tint/lang/core/ir/function.cc
index dbee758..b5bf71b 100644
--- a/src/tint/lang/core/ir/function.cc
+++ b/src/tint/lang/core/ir/function.cc
@@ -21,7 +21,7 @@
 
 namespace tint::ir {
 
-Function::Function(const type::Type* rt,
+Function::Function(const core::type::Type* rt,
                    PipelineStage stage,
                    std::optional<std::array<uint32_t, 3>> wg_size)
     : pipeline_stage_(stage), workgroup_size_(wg_size) {
diff --git a/src/tint/lang/core/ir/function.h b/src/tint/lang/core/ir/function.h
index 624e763..135abea 100644
--- a/src/tint/lang/core/ir/function.h
+++ b/src/tint/lang/core/ir/function.h
@@ -62,7 +62,7 @@
     /// @param rt the function return type
     /// @param stage the function stage
     /// @param wg_size the workgroup_size
-    Function(const type::Type* rt,
+    Function(const core::type::Type* rt,
              PipelineStage stage = PipelineStage::kUndefined,
              std::optional<std::array<uint32_t, 3>> wg_size = {});
     ~Function() override;
@@ -87,7 +87,7 @@
     std::optional<std::array<uint32_t, 3>> WorkgroupSize() { return workgroup_size_; }
 
     /// @returns the return type for the function
-    const type::Type* ReturnType() { return return_.type; }
+    const core::type::Type* ReturnType() { return return_.type; }
 
     /// Sets the return attributes
     /// @param builtin the builtin to set
@@ -142,7 +142,7 @@
     std::optional<std::array<uint32_t, 3>> workgroup_size_;
 
     struct {
-        const type::Type* type = nullptr;
+        const core::type::Type* type = nullptr;
         std::optional<enum ReturnBuiltin> builtin;
         std::optional<Location> location;
         bool invariant = false;
diff --git a/src/tint/lang/core/ir/function_param.cc b/src/tint/lang/core/ir/function_param.cc
index 5d9dbbe..a016342 100644
--- a/src/tint/lang/core/ir/function_param.cc
+++ b/src/tint/lang/core/ir/function_param.cc
@@ -20,7 +20,7 @@
 
 namespace tint::ir {
 
-FunctionParam::FunctionParam(const type::Type* ty) : type_(ty) {
+FunctionParam::FunctionParam(const core::type::Type* ty) : type_(ty) {
     TINT_ASSERT(ty != nullptr);
 }
 
diff --git a/src/tint/lang/core/ir/function_param.h b/src/tint/lang/core/ir/function_param.h
index 8a4e589..0484dca 100644
--- a/src/tint/lang/core/ir/function_param.h
+++ b/src/tint/lang/core/ir/function_param.h
@@ -57,11 +57,11 @@
 
     /// Constructor
     /// @param type the type of the var
-    explicit FunctionParam(const type::Type* type);
+    explicit FunctionParam(const core::type::Type* type);
     ~FunctionParam() override;
 
     /// @returns the type of the var
-    const type::Type* Type() override { return type_; }
+    const core::type::Type* Type() override { return type_; }
 
     /// Sets the builtin information. Note, it is currently an error if the builtin is already set.
     /// @param val the builtin to set
@@ -99,7 +99,7 @@
     std::optional<struct BindingPoint>& BindingPoint() { return binding_point_; }
 
   private:
-    const type::Type* type_ = nullptr;
+    const core::type::Type* type_ = nullptr;
     std::optional<enum FunctionParam::Builtin> builtin_;
     std::optional<struct Location> location_;
     std::optional<struct BindingPoint> binding_point_;
diff --git a/src/tint/lang/core/ir/instruction_result.cc b/src/tint/lang/core/ir/instruction_result.cc
index 300eca3..531f716 100644
--- a/src/tint/lang/core/ir/instruction_result.cc
+++ b/src/tint/lang/core/ir/instruction_result.cc
@@ -22,7 +22,7 @@
 
 namespace tint::ir {
 
-InstructionResult::InstructionResult(const type::Type* type) : type_(type) {
+InstructionResult::InstructionResult(const core::type::Type* type) : type_(type) {
     TINT_ASSERT(type_ != nullptr);
 }
 
diff --git a/src/tint/lang/core/ir/instruction_result.h b/src/tint/lang/core/ir/instruction_result.h
index f2bdd9c..1b7d21a 100644
--- a/src/tint/lang/core/ir/instruction_result.h
+++ b/src/tint/lang/core/ir/instruction_result.h
@@ -25,7 +25,7 @@
   public:
     /// Constructor
     /// @param type the type of the value
-    explicit InstructionResult(const type::Type* type);
+    explicit InstructionResult(const core::type::Type* type);
 
     /// Destructor
     ~InstructionResult() override;
@@ -34,11 +34,11 @@
     void Destroy() override;
 
     /// @returns the type of the value
-    const type::Type* Type() override { return type_; }
+    const core::type::Type* Type() override { return type_; }
 
     /// Sets the type of the value to @p type
     /// @param type the new type of the value
-    void SetType(const type::Type* type) { type_ = type; }
+    void SetType(const core::type::Type* type) { type_ = type; }
 
     /// Sets the source instruction for this value
     /// @param inst the instruction to set
@@ -49,7 +49,7 @@
 
   private:
     Instruction* source_ = nullptr;
-    const type::Type* type_ = nullptr;
+    const core::type::Type* type_ = nullptr;
 };
 
 }  // namespace tint::ir
diff --git a/src/tint/lang/core/ir/ir_helper_test.h b/src/tint/lang/core/ir/ir_helper_test.h
index bb62518..bdb2b6c 100644
--- a/src/tint/lang/core/ir/ir_helper_test.h
+++ b/src/tint/lang/core/ir/ir_helper_test.h
@@ -33,7 +33,7 @@
     /// The IR builder
     Builder b{mod};
     /// The type manager
-    type::Manager& ty{mod.Types()};
+    core::type::Manager& ty{mod.Types()};
 };
 
 using IRTestHelper = IRTestHelperBase<testing::Test>;
diff --git a/src/tint/lang/core/ir/load.cc b/src/tint/lang/core/ir/load.cc
index 3ed33f1..b4cbd78 100644
--- a/src/tint/lang/core/ir/load.cc
+++ b/src/tint/lang/core/ir/load.cc
@@ -24,7 +24,7 @@
 Load::Load(InstructionResult* result, Value* from) {
     flags_.Add(Flag::kSequenced);
 
-    TINT_ASSERT(from->Type()->Is<type::Pointer>());
+    TINT_ASSERT(from->Type()->Is<core::type::Pointer>());
     TINT_ASSERT(from && from->Type()->UnwrapPtr() == result->Type());
 
     AddOperand(Load::kFromOperandOffset, from);
diff --git a/src/tint/lang/core/ir/module.h b/src/tint/lang/core/ir/module.h
index 8466f24..f5b638d 100644
--- a/src/tint/lang/core/ir/module.h
+++ b/src/tint/lang/core/ir/module.h
@@ -79,7 +79,7 @@
     void SetName(Value* value, Symbol name);
 
     /// @return the type manager for the module
-    type::Manager& Types() { return constant_values.types; }
+    core::type::Manager& Types() { return constant_values.types; }
 
     /// The block allocator
     BlockAllocator<Block> blocks;
diff --git a/src/tint/lang/core/ir/transform/bgra8unorm_polyfill.cc b/src/tint/lang/core/ir/transform/bgra8unorm_polyfill.cc
index 2652c80..96c6ed5 100644
--- a/src/tint/lang/core/ir/transform/bgra8unorm_polyfill.cc
+++ b/src/tint/lang/core/ir/transform/bgra8unorm_polyfill.cc
@@ -38,7 +38,7 @@
     Builder b{*ir};
 
     /// The type manager.
-    type::Manager& ty{ir->Types()};
+    core::type::Manager& ty{ir->Types()};
 
     /// Process the module.
     void Process() {
@@ -50,11 +50,11 @@
                 if (!var) {
                     continue;
                 }
-                auto* ptr = var->Result()->Type()->As<type::Pointer>();
+                auto* ptr = var->Result()->Type()->As<core::type::Pointer>();
                 if (!ptr) {
                     continue;
                 }
-                auto* storage_texture = ptr->StoreType()->As<type::StorageTexture>();
+                auto* storage_texture = ptr->StoreType()->As<core::type::StorageTexture>();
                 if (storage_texture &&
                     storage_texture->texel_format() == core::TexelFormat::kBgra8Unorm) {
                     ReplaceVar(var, storage_texture);
@@ -70,7 +70,7 @@
         for (auto* func : ir->functions) {
             for (uint32_t index = 0; index < func->Params().Length(); index++) {
                 auto* param = func->Params()[index];
-                auto* storage_texture = param->Type()->As<type::StorageTexture>();
+                auto* storage_texture = param->Type()->As<core::type::StorageTexture>();
                 if (storage_texture &&
                     storage_texture->texel_format() == core::TexelFormat::kBgra8Unorm) {
                     ReplaceParameter(func, param, index, storage_texture);
@@ -82,10 +82,10 @@
     /// Replace a variable declaration with one that uses rgba8unorm instead of bgra8unorm.
     /// @param old_var the variable declaration to replace
     /// @param bgra8 the bgra8unorm texture type
-    void ReplaceVar(Var* old_var, const type::StorageTexture* bgra8) {
+    void ReplaceVar(Var* old_var, const core::type::StorageTexture* bgra8) {
         // Redeclare the variable with a rgba8unorm texel format.
-        auto* rgba8 = ty.Get<type::StorageTexture>(bgra8->dim(), core::TexelFormat::kRgba8Unorm,
-                                                   bgra8->access(), bgra8->type());
+        auto* rgba8 = ty.Get<core::type::StorageTexture>(
+            bgra8->dim(), core::TexelFormat::kRgba8Unorm, bgra8->access(), bgra8->type());
         auto* new_var = b.Var(ty.ptr(handle, rgba8));
         auto bp = old_var->BindingPoint();
         new_var->SetBindingPoint(bp->group, bp->binding);
@@ -106,10 +106,10 @@
     void ReplaceParameter(Function* func,
                           FunctionParam* old_param,
                           uint32_t index,
-                          const type::StorageTexture* bgra8) {
+                          const core::type::StorageTexture* bgra8) {
         // Redeclare the parameter with a rgba8unorm texel format.
-        auto* rgba8 = ty.Get<type::StorageTexture>(bgra8->dim(), core::TexelFormat::kRgba8Unorm,
-                                                   bgra8->access(), bgra8->type());
+        auto* rgba8 = ty.Get<core::type::StorageTexture>(
+            bgra8->dim(), core::TexelFormat::kRgba8Unorm, bgra8->access(), bgra8->type());
         auto* new_param = b.FunctionParam(rgba8);
         if (auto name = ir->NameOf(old_param)) {
             ir->SetName(new_param, name.NameView());
@@ -142,8 +142,8 @@
                     call->SetOperand(use.operand_index, new_value);
                     if (call->Func() == core::Function::kTextureStore) {
                         // Swizzle the value argument of a `textureStore()` builtin.
-                        auto* tex = old_value->Type()->As<type::StorageTexture>();
-                        auto index = type::IsTextureArray(tex->dim()) ? 3u : 2u;
+                        auto* tex = old_value->Type()->As<core::type::StorageTexture>();
+                        auto index = core::type::IsTextureArray(tex->dim()) ? 3u : 2u;
                         auto* value = call->Args()[index];
                         auto* swizzle = b.Swizzle(value->Type(), value, Vector{2u, 1u, 0u, 3u});
                         swizzle->InsertBefore(call);
diff --git a/src/tint/lang/core/ir/transform/bgra8unorm_polyfill_test.cc b/src/tint/lang/core/ir/transform/bgra8unorm_polyfill_test.cc
index 2c229f4..4cf15d0 100644
--- a/src/tint/lang/core/ir/transform/bgra8unorm_polyfill_test.cc
+++ b/src/tint/lang/core/ir/transform/bgra8unorm_polyfill_test.cc
@@ -46,8 +46,9 @@
 
 TEST_F(IR_Bgra8UnormPolyfillTest, NoModify_ModuleScopeVariable_Rgba) {
     auto format = core::TexelFormat::kRgba8Unorm;
-    auto* texture_ty = ty.Get<type::StorageTexture>(type::TextureDimension::k2d, format, write,
-                                                    type::StorageTexture::SubtypeFor(format, ty));
+    auto* texture_ty =
+        ty.Get<core::type::StorageTexture>(core::type::TextureDimension::k2d, format, write,
+                                           core::type::StorageTexture::SubtypeFor(format, ty));
 
     auto* var = b.Var("texture", ty.ptr(handle, texture_ty));
     var->SetBindingPoint(1, 2);
@@ -86,8 +87,9 @@
 
 TEST_F(IR_Bgra8UnormPolyfillTest, NoModify_UserFunctionParameter_Rgba) {
     auto format = core::TexelFormat::kRgba8Unorm;
-    auto* texture_ty = ty.Get<type::StorageTexture>(type::TextureDimension::k2d, format, write,
-                                                    type::StorageTexture::SubtypeFor(format, ty));
+    auto* texture_ty =
+        ty.Get<core::type::StorageTexture>(core::type::TextureDimension::k2d, format, write,
+                                           core::type::StorageTexture::SubtypeFor(format, ty));
 
     auto* func = b.Function("foo", ty.void_());
     auto* texture = b.FunctionParam("texture", texture_ty);
@@ -117,8 +119,9 @@
 
 TEST_F(IR_Bgra8UnormPolyfillTest, ModuleScopeVariable) {
     auto format = core::TexelFormat::kBgra8Unorm;
-    auto* texture_ty = ty.Get<type::StorageTexture>(type::TextureDimension::k2d, format, write,
-                                                    type::StorageTexture::SubtypeFor(format, ty));
+    auto* texture_ty =
+        ty.Get<core::type::StorageTexture>(core::type::TextureDimension::k2d, format, write,
+                                           core::type::StorageTexture::SubtypeFor(format, ty));
 
     auto* var = b.Var("texture", ty.ptr(handle, texture_ty));
     var->SetBindingPoint(1, 2);
@@ -170,8 +173,9 @@
 
 TEST_F(IR_Bgra8UnormPolyfillTest, UserFunctionParameter) {
     auto format = core::TexelFormat::kBgra8Unorm;
-    auto* texture_ty = ty.Get<type::StorageTexture>(type::TextureDimension::k2d, format, write,
-                                                    type::StorageTexture::SubtypeFor(format, ty));
+    auto* texture_ty =
+        ty.Get<core::type::StorageTexture>(core::type::TextureDimension::k2d, format, write,
+                                           core::type::StorageTexture::SubtypeFor(format, ty));
 
     auto* func = b.Function("foo", ty.void_());
     auto* texture = b.FunctionParam("texture", texture_ty);
@@ -209,8 +213,9 @@
 
 TEST_F(IR_Bgra8UnormPolyfillTest, ModuleScopePassedToUserFunction) {
     auto format = core::TexelFormat::kBgra8Unorm;
-    auto* texture_ty = ty.Get<type::StorageTexture>(type::TextureDimension::k2d, format, write,
-                                                    type::StorageTexture::SubtypeFor(format, ty));
+    auto* texture_ty =
+        ty.Get<core::type::StorageTexture>(core::type::TextureDimension::k2d, format, write,
+                                           core::type::StorageTexture::SubtypeFor(format, ty));
 
     auto* var = b.Var("texture", ty.ptr(handle, texture_ty));
     var->SetBindingPoint(1, 2);
@@ -288,8 +293,9 @@
 
 TEST_F(IR_Bgra8UnormPolyfillTest, ModuleScopePassedToUserFunction_MultipleTextures) {
     auto format = core::TexelFormat::kBgra8Unorm;
-    auto* texture_ty = ty.Get<type::StorageTexture>(type::TextureDimension::k2d, format, write,
-                                                    type::StorageTexture::SubtypeFor(format, ty));
+    auto* texture_ty =
+        ty.Get<core::type::StorageTexture>(core::type::TextureDimension::k2d, format, write,
+                                           core::type::StorageTexture::SubtypeFor(format, ty));
 
     auto* var_a = b.Var("texture_a", ty.ptr(handle, texture_ty));
     auto* var_b = b.Var("texture_b", ty.ptr(handle, texture_ty));
@@ -393,8 +399,9 @@
 
 TEST_F(IR_Bgra8UnormPolyfillTest, MutipleUsesOfOneTexture) {
     auto format = core::TexelFormat::kBgra8Unorm;
-    auto* texture_ty = ty.Get<type::StorageTexture>(type::TextureDimension::k2d, format, write,
-                                                    type::StorageTexture::SubtypeFor(format, ty));
+    auto* texture_ty =
+        ty.Get<core::type::StorageTexture>(core::type::TextureDimension::k2d, format, write,
+                                           core::type::StorageTexture::SubtypeFor(format, ty));
 
     auto* var_a = b.Var("texture", ty.ptr(handle, texture_ty));
     var_a->SetBindingPoint(1, 2);
@@ -493,8 +500,9 @@
 
 TEST_F(IR_Bgra8UnormPolyfillTest, ArrayedImage) {
     auto format = core::TexelFormat::kBgra8Unorm;
-    auto* texture_ty = ty.Get<type::StorageTexture>(type::TextureDimension::k2dArray, format, write,
-                                                    type::StorageTexture::SubtypeFor(format, ty));
+    auto* texture_ty =
+        ty.Get<core::type::StorageTexture>(core::type::TextureDimension::k2dArray, format, write,
+                                           core::type::StorageTexture::SubtypeFor(format, ty));
 
     auto* var = b.Var("texture", ty.ptr(handle, texture_ty));
     var->SetBindingPoint(1, 2);
@@ -547,8 +555,9 @@
 
 TEST_F(IR_Bgra8UnormPolyfillTest, TextureDimensions) {
     auto format = core::TexelFormat::kBgra8Unorm;
-    auto* texture_ty = ty.Get<type::StorageTexture>(type::TextureDimension::k2d, format, write,
-                                                    type::StorageTexture::SubtypeFor(format, ty));
+    auto* texture_ty =
+        ty.Get<core::type::StorageTexture>(core::type::TextureDimension::k2d, format, write,
+                                           core::type::StorageTexture::SubtypeFor(format, ty));
 
     auto* var = b.Var("texture", ty.ptr(handle, texture_ty));
     var->SetBindingPoint(1, 2);
diff --git a/src/tint/lang/core/ir/transform/block_decorated_structs.cc b/src/tint/lang/core/ir/transform/block_decorated_structs.cc
index 72a232a..befbbde 100644
--- a/src/tint/lang/core/ir/transform/block_decorated_structs.cc
+++ b/src/tint/lang/core/ir/transform/block_decorated_structs.cc
@@ -42,7 +42,7 @@
         if (!var) {
             continue;
         }
-        auto* ptr = var->Result()->Type()->As<type::Pointer>();
+        auto* ptr = var->Result()->Type()->As<core::type::Pointer>();
         if (!ptr || !core::IsHostShareable(ptr->AddressSpace())) {
             continue;
         }
@@ -51,14 +51,14 @@
 
     // Now process the buffer variables.
     for (auto* var : buffer_variables) {
-        auto* ptr = var->Result()->Type()->As<type::Pointer>();
+        auto* ptr = var->Result()->Type()->As<core::type::Pointer>();
         auto* store_ty = ptr->StoreType();
 
         bool wrapped = false;
-        Vector<const type::StructMember*, 4> members;
+        Vector<const core::type::StructMember*, 4> members;
 
         // Build the member list for the block-decorated structure.
-        if (auto* str = store_ty->As<type::Struct>(); str && !str->HasFixedFootprint()) {
+        if (auto* str = store_ty->As<core::type::Struct>(); str && !str->HasFixedFootprint()) {
             // We know the original struct will only ever be used as the store type of a buffer, so
             // just redeclare it as a block-decorated struct.
             for (auto* member : str->Members()) {
@@ -67,25 +67,25 @@
         } else {
             // The original struct might be used in other places, so create a new block-decorated
             // struct that wraps the original struct.
-            members.Push(ir->Types().Get<type::StructMember>(
+            members.Push(ir->Types().Get<core::type::StructMember>(
                 /* name */ ir->symbols.New(),
                 /* type */ store_ty,
                 /* index */ 0u,
                 /* offset */ 0u,
                 /* align */ store_ty->Align(),
                 /* size */ store_ty->Size(),
-                /* attributes */ type::StructMemberAttributes{}));
+                /* attributes */ core::type::StructMemberAttributes{}));
             wrapped = true;
         }
 
         // Create the block-decorated struct.
-        auto* block_struct = ir->Types().Get<type::Struct>(
+        auto* block_struct = ir->Types().Get<core::type::Struct>(
             /* name */ ir->symbols.New(),
             /* members */ members,
             /* align */ store_ty->Align(),
             /* size */ tint::RoundUp(store_ty->Align(), store_ty->Size()),
             /* size_no_padding */ store_ty->Size());
-        block_struct->SetStructFlag(type::StructFlag::kBlock);
+        block_struct->SetStructFlag(core::type::StructFlag::kBlock);
 
         // Replace the old variable declaration with one that uses the block-decorated struct type.
         auto* new_var =
diff --git a/src/tint/lang/core/ir/transform/builtin_polyfill.cc b/src/tint/lang/core/ir/transform/builtin_polyfill.cc
index f20cf06..57e94e6 100644
--- a/src/tint/lang/core/ir/transform/builtin_polyfill.cc
+++ b/src/tint/lang/core/ir/transform/builtin_polyfill.cc
@@ -40,7 +40,7 @@
     Builder b{*ir};
 
     /// The type manager.
-    type::Manager& ty{ir->Types()};
+    core::type::Manager& ty{ir->Types()};
 
     /// The symbol table.
     SymbolTable& sym{ir->symbols};
@@ -82,9 +82,10 @@
                         break;
                     case core::Function::kTextureSampleBaseClampToEdge:
                         if (config.texture_sample_base_clamp_to_edge_2d_f32) {
-                            auto* tex = builtin->Args()[0]->Type()->As<type::SampledTexture>();
-                            if (tex && tex->dim() == type::TextureDimension::k2d &&
-                                tex->type()->Is<type::F32>()) {
+                            auto* tex =
+                                builtin->Args()[0]->Type()->As<core::type::SampledTexture>();
+                            if (tex && tex->dim() == core::type::TextureDimension::k2d &&
+                                tex->type()->Is<core::type::F32>()) {
                                 worklist.Push(builtin);
                             }
                         }
@@ -136,8 +137,9 @@
     /// @param el_ty the type to extend
     /// @param match the type to match the component count of
     /// @returns a type with the same number of vector components as @p match
-    const type::Type* MatchWidth(const type::Type* el_ty, const type::Type* match) {
-        if (auto* vec = match->As<type::Vector>()) {
+    const core::type::Type* MatchWidth(const core::type::Type* el_ty,
+                                       const core::type::Type* match) {
+        if (auto* vec = match->As<core::type::Vector>()) {
             return ty.vec(el_ty, vec->Width());
         }
         return el_ty;
@@ -148,8 +150,8 @@
     /// @param element the value to extend
     /// @param match the type to match the component count of
     /// @returns a value with the same number of vector components as @p match
-    ir::Constant* MatchWidth(ir::Constant* element, const type::Type* match) {
-        if (auto* vec = match->As<type::Vector>()) {
+    ir::Constant* MatchWidth(ir::Constant* element, const core::type::Type* match) {
+        if (auto* vec = match->As<core::type::Vector>()) {
             return b.Splat(MatchWidth(element->Type(), match), element, vec->Width());
         }
         return element;
@@ -412,10 +414,10 @@
         auto* type = call->Result()->Type();
         ir::Constant* zero = nullptr;
         ir::Constant* one = nullptr;
-        if (type->DeepestElement()->Is<type::F32>()) {
+        if (type->DeepestElement()->Is<core::type::F32>()) {
             zero = MatchWidth(b.Constant(0_f), type);
             one = MatchWidth(b.Constant(1_f), type);
-        } else if (type->DeepestElement()->Is<type::F16>()) {
+        } else if (type->DeepestElement()->Is<core::type::F16>()) {
             zero = MatchWidth(b.Constant(0_h), type);
             one = MatchWidth(b.Constant(1_h), type);
         }
diff --git a/src/tint/lang/core/ir/transform/builtin_polyfill_test.cc b/src/tint/lang/core/ir/transform/builtin_polyfill_test.cc
index eb23968..3c57235 100644
--- a/src/tint/lang/core/ir/transform/builtin_polyfill_test.cc
+++ b/src/tint/lang/core/ir/transform/builtin_polyfill_test.cc
@@ -32,8 +32,8 @@
     /// @param result_ty the result type of the builtin call
     /// @param arg_types the arguments types for the builtin call
     void Build(core::Function builtin,
-               const type::Type* result_ty,
-               VectorRef<const type::Type*> arg_types) {
+               const core::type::Type* result_ty,
+               VectorRef<const core::type::Type*> arg_types) {
         Vector<FunctionParam*, 4> args;
         for (auto* arg_ty : arg_types) {
             args.Push(b.FunctionParam("arg", arg_ty));
@@ -1059,7 +1059,8 @@
 }
 
 TEST_F(IR_BuiltinPolyfillTest, TextureSampleBaseClampToEdge_2d_f32_NoPolyfill) {
-    auto* texture_ty = ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32());
+    auto* texture_ty =
+        ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32());
     Build(core::Function::kTextureSampleBaseClampToEdge, ty.vec4<f32>(),
           Vector{texture_ty, ty.sampler(), ty.vec2<f32>()});
     auto* src = R"(
@@ -1081,7 +1082,8 @@
 }
 
 TEST_F(IR_BuiltinPolyfillTest, TextureSampleBaseClampToEdge_2d_f32) {
-    auto* texture_ty = ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32());
+    auto* texture_ty =
+        ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32());
     Build(core::Function::kTextureSampleBaseClampToEdge, ty.vec4<f32>(),
           Vector{texture_ty, ty.sampler(), ty.vec2<f32>()});
     auto* src = R"(
diff --git a/src/tint/lang/core/ir/transform/demote_to_helper.cc b/src/tint/lang/core/ir/transform/demote_to_helper.cc
index e60b3a6..d07ee4a 100644
--- a/src/tint/lang/core/ir/transform/demote_to_helper.cc
+++ b/src/tint/lang/core/ir/transform/demote_to_helper.cc
@@ -37,7 +37,7 @@
     Builder b{*ir};
 
     /// The type manager.
-    type::Manager& ty{ir->Types()};
+    core::type::Manager& ty{ir->Types()};
 
     /// The global "has not discarded" flag.
     Var* continue_execution = nullptr;
@@ -139,7 +139,7 @@
             auto* result = ifelse->True()->Append(inst);
 
             TINT_ASSERT(!inst->HasMultiResults());
-            if (inst->HasResults() && !inst->Result()->Type()->Is<type::Void>()) {
+            if (inst->HasResults() && !inst->Result()->Type()->Is<core::type::Void>()) {
                 // The original instruction had a result, so return it from the if instruction.
                 ifelse->SetResults(Vector{b.InstructionResult(inst->Result()->Type())});
                 inst->Result()->ReplaceAllUsesWith(ifelse->Result());
@@ -169,7 +169,7 @@
                 },
                 [&](Store* store) {
                     // Conditionalize stores to host-visible address spaces.
-                    auto* ptr = store->To()->Type()->As<type::Pointer>();
+                    auto* ptr = store->To()->Type()->As<core::type::Pointer>();
                     if (ptr && ptr->AddressSpace() == core::AddressSpace::kStorage) {
                         conditionalize(store);
                     }
diff --git a/src/tint/lang/core/ir/transform/demote_to_helper_test.cc b/src/tint/lang/core/ir/transform/demote_to_helper_test.cc
index 4b56bd7..721a983 100644
--- a/src/tint/lang/core/ir/transform/demote_to_helper_test.cc
+++ b/src/tint/lang/core/ir/transform/demote_to_helper_test.cc
@@ -517,9 +517,9 @@
     auto format = core::TexelFormat::kR32Float;
     auto* texture =
         b.Var("texture", ty.ptr(core::AddressSpace::kHandle,
-                                ty.Get<type::StorageTexture>(
-                                    type::TextureDimension::k2d, format, core::Access::kWrite,
-                                    type::StorageTexture::SubtypeFor(format, ty))));
+                                ty.Get<core::type::StorageTexture>(
+                                    core::type::TextureDimension::k2d, format, core::Access::kWrite,
+                                    core::type::StorageTexture::SubtypeFor(format, ty))));
     texture->SetBindingPoint(0, 0);
     b.RootBlock()->Append(texture);
 
@@ -777,8 +777,9 @@
             b.Discard();
             b.ExitIf(ifelse);
         });
-        auto* result = b.Call(type::CreateAtomicCompareExchangeResult(ty, mod.symbols, ty.i32()),
-                              core::Function::kAtomicCompareExchangeWeak, buffer, 0_i, 42_i);
+        auto* result =
+            b.Call(core::type::CreateAtomicCompareExchangeResult(ty, mod.symbols, ty.i32()),
+                   core::Function::kAtomicCompareExchangeWeak, buffer, 0_i, 42_i);
         b.Add(ty.i32(), b.Access(ty.i32(), result, 0_i), 1_i);
         b.Return(ep, 0.5_f);
     });
diff --git a/src/tint/lang/core/ir/transform/helper_test.h b/src/tint/lang/core/ir/transform/helper_test.h
index 32d2919..10552c5 100644
--- a/src/tint/lang/core/ir/transform/helper_test.h
+++ b/src/tint/lang/core/ir/transform/helper_test.h
@@ -60,7 +60,7 @@
     /// The test IR builder.
     ir::Builder b{mod};
     /// The type manager.
-    type::Manager& ty{mod.Types()};
+    core::type::Manager& ty{mod.Types()};
 };
 
 using TransformTest = TransformTestBase<testing::Test>;
diff --git a/src/tint/lang/core/ir/transform/shader_io.cc b/src/tint/lang/core/ir/transform/shader_io.cc
index 51e8e615..1858a39 100644
--- a/src/tint/lang/core/ir/transform/shader_io.cc
+++ b/src/tint/lang/core/ir/transform/shader_io.cc
@@ -75,9 +75,9 @@
     /// The IR builder.
     Builder b{*ir};
     /// The type manager.
-    type::Manager& ty{ir->Types()};
+    core::type::Manager& ty{ir->Types()};
     /// The set of struct members that need to have their IO attributes stripped.
-    Hashset<const type::StructMember*, 8> members_to_strip;
+    Hashset<const core::type::StructMember*, 8> members_to_strip;
 
     /// The entry point currently being processed.
     Function* func = nullptr;
@@ -132,7 +132,7 @@
     /// Gather the shader inputs.
     void GatherInputs() {
         for (auto* param : func->Params()) {
-            if (auto* str = param->Type()->As<type::Struct>()) {
+            if (auto* str = param->Type()->As<core::type::Struct>()) {
                 for (auto* member : str->Members()) {
                     auto name = str->Name().Name() + "_" + member->Name().Name();
                     backend->AddInput(ir->symbols.Register(name), member->Type(),
@@ -141,7 +141,7 @@
                 }
             } else {
                 // Pull out the IO attributes and remove them from the parameter.
-                type::StructMemberAttributes attributes;
+                core::type::StructMemberAttributes attributes;
                 if (auto loc = param->Location()) {
                     attributes.location = loc->value;
                     if (loc->interpolation) {
@@ -163,11 +163,11 @@
 
     /// Gather the shader outputs.
     void GatherOutput() {
-        if (func->ReturnType()->Is<type::Void>()) {
+        if (func->ReturnType()->Is<core::type::Void>()) {
             return;
         }
 
-        if (auto* str = func->ReturnType()->As<type::Struct>()) {
+        if (auto* str = func->ReturnType()->As<core::type::Struct>()) {
             for (auto* member : str->Members()) {
                 auto name = str->Name().Name() + "_" + member->Name().Name();
                 backend->AddOutput(ir->symbols.Register(name), member->Type(),
@@ -176,7 +176,7 @@
             }
         } else {
             // Pull out the IO attributes and remove them from the original function.
-            type::StructMemberAttributes attributes;
+            core::type::StructMemberAttributes attributes;
             if (auto loc = func->ReturnLocation()) {
                 attributes.location = loc->value;
                 func->ClearReturnLocation();
@@ -198,7 +198,7 @@
         uint32_t input_idx = 0;
         Vector<Value*, 4> args;
         for (auto* param : func->Params()) {
-            if (auto* str = param->Type()->As<type::Struct>()) {
+            if (auto* str = param->Type()->As<core::type::Struct>()) {
                 Vector<Value*, 4> construct_args;
                 for (uint32_t i = 0; i < str->Members().Length(); i++) {
                     construct_args.Push(backend->GetInput(builder, input_idx++));
@@ -216,13 +216,13 @@
     /// @param builder the IR builder for new instructions
     /// @param inner_result the return value from calling the original entry point function
     void SetOutputs(Builder& builder, Value* inner_result) {
-        if (auto* str = inner_result->Type()->As<type::Struct>()) {
+        if (auto* str = inner_result->Type()->As<core::type::Struct>()) {
             for (auto* member : str->Members()) {
                 Value* from =
                     builder.Access(member->Type(), inner_result, u32(member->Index()))->Result();
                 backend->SetOutput(builder, member->Index(), from);
             }
-        } else if (!inner_result->Type()->Is<type::Void>()) {
+        } else if (!inner_result->Type()->Is<core::type::Void>()) {
             backend->SetOutput(builder, 0u, inner_result);
         }
     }
@@ -232,7 +232,7 @@
         // Remove IO attributes from all structure members that had them prior to this transform.
         for (auto* member : members_to_strip) {
             // TODO(crbug.com/tint/745): Remove the const_cast.
-            const_cast<type::StructMember*>(member)->SetAttributes({});
+            const_cast<core::type::StructMember*>(member)->SetAttributes({});
         }
     }
 };
@@ -248,7 +248,7 @@
         }
 
         // Skip entry points with no inputs or outputs.
-        if (func->Params().IsEmpty() && func->ReturnType()->Is<type::Void>()) {
+        if (func->Params().IsEmpty() && func->ReturnType()->Is<core::type::Void>()) {
             continue;
         }
 
diff --git a/src/tint/lang/core/ir/transform/shader_io.h b/src/tint/lang/core/ir/transform/shader_io.h
index e5b865f..23c20b5 100644
--- a/src/tint/lang/core/ir/transform/shader_io.h
+++ b/src/tint/lang/core/ir/transform/shader_io.h
@@ -38,8 +38,8 @@
     /// @param type the type of the input
     /// @param attributes the IO attributes
     virtual void AddInput(Symbol name,
-                          const type::Type* type,
-                          type::StructMemberAttributes attributes) {
+                          const core::type::Type* type,
+                          core::type::StructMemberAttributes attributes) {
         inputs.Push({name, type, std::move(attributes)});
     }
 
@@ -48,8 +48,8 @@
     /// @param type the type of the output
     /// @param attributes the IO attributes
     virtual void AddOutput(Symbol name,
-                           const type::Type* type,
-                           type::StructMemberAttributes attributes) {
+                           const core::type::Type* type,
+                           core::type::StructMemberAttributes attributes) {
         outputs.Push({name, type, std::move(attributes)});
     }
 
@@ -81,16 +81,16 @@
     Builder b{*ir};
 
     /// The type manager.
-    type::Manager& ty{ir->Types()};
+    core::type::Manager& ty{ir->Types()};
 
     /// The original entry point function.
     Function* func = nullptr;
 
     /// The list of shader inputs.
-    Vector<type::Manager::StructMemberDesc, 4> inputs;
+    Vector<core::type::Manager::StructMemberDesc, 4> inputs;
 
     /// The list of shader outputs.
-    Vector<type::Manager::StructMemberDesc, 4> outputs;
+    Vector<core::type::Manager::StructMemberDesc, 4> outputs;
 };
 
 /// The signature for a function that creates a backend state object.
diff --git a/src/tint/lang/core/ir/transform/std140.cc b/src/tint/lang/core/ir/transform/std140.cc
index 47c1562..3a1430b 100644
--- a/src/tint/lang/core/ir/transform/std140.cc
+++ b/src/tint/lang/core/ir/transform/std140.cc
@@ -39,19 +39,19 @@
     Builder b{*ir};
 
     /// The type manager.
-    type::Manager& ty{ir->Types()};
+    core::type::Manager& ty{ir->Types()};
 
     /// The symbol table.
     SymbolTable& sym{ir->symbols};
 
     /// Map from original type to a new type with decomposed matrices.
-    Hashmap<const type::Type*, const type::Type*, 4> rewritten_types{};
+    Hashmap<const core::type::Type*, const core::type::Type*, 4> rewritten_types{};
 
     /// Map from struct member to its new index.
-    Hashmap<const type::StructMember*, uint32_t, 4> member_index_map{};
+    Hashmap<const core::type::StructMember*, uint32_t, 4> member_index_map{};
 
     /// Map from a type to a helper function that will convert its rewritten form back to it.
-    Hashmap<const type::Struct*, Function*, 4> convert_helpers{};
+    Hashmap<const core::type::Struct*, Function*, 4> convert_helpers{};
 
     /// Process the module.
     void Process() {
@@ -66,7 +66,7 @@
             if (!var || !var->Alive()) {
                 continue;
             }
-            auto* ptr = var->Result()->Type()->As<type::Pointer>();
+            auto* ptr = var->Result()->Type()->As<core::type::Pointer>();
             if (!ptr || ptr->AddressSpace() != core::AddressSpace::kUniform) {
                 continue;
             }
@@ -80,7 +80,7 @@
         for (auto* var : buffer_variables) {
             // Create a new variable with the modified store type.
             const auto& bp = var->BindingPoint();
-            auto* store_type = var->Result()->Type()->As<type::Pointer>()->StoreType();
+            auto* store_type = var->Result()->Type()->As<core::type::Pointer>()->StoreType();
             auto* new_var = b.Var(ty.ptr(uniform, RewriteType(store_type)));
             new_var->SetBindingPoint(bp->group, bp->binding);
             if (auto name = ir->NameOf(var)) {
@@ -99,25 +99,25 @@
 
     /// @param mat the matrix type to check
     /// @returns true if @p mat needs to be decomposed
-    static bool NeedsDecomposing(const type::Matrix* mat) { return mat->ColumnStride() & 15; }
+    static bool NeedsDecomposing(const core::type::Matrix* mat) { return mat->ColumnStride() & 15; }
 
     /// Rewrite a type if necessary, decomposing contained matrices.
     /// @param type the type to rewrite
     /// @returns the new type
-    const type::Type* RewriteType(const type::Type* type) {
-        return rewritten_types.GetOrCreate(type, [&]() -> const type::Type* {
+    const core::type::Type* RewriteType(const core::type::Type* type) {
+        return rewritten_types.GetOrCreate(type, [&]() -> const core::type::Type* {
             return tint::Switch(
                 type,
-                [&](const type::Array* arr) -> const type::Type* {
+                [&](const core::type::Array* arr) -> const core::type::Type* {
                     // Create a new array with element type potentially rewritten.
                     return ty.array(RewriteType(arr->ElemType()), arr->ConstantCount().value());
                 },
-                [&](const type::Struct* str) -> const type::Type* {
+                [&](const core::type::Struct* str) -> const core::type::Type* {
                     bool needs_rewrite = false;
                     uint32_t member_index = 0;
-                    Vector<const type::StructMember*, 4> new_members;
+                    Vector<const core::type::StructMember*, 4> new_members;
                     for (auto* member : str->Members()) {
-                        auto* mat = member->Type()->As<type::Matrix>();
+                        auto* mat = member->Type()->As<core::type::Matrix>();
                         if (mat && NeedsDecomposing(mat)) {
                             // Decompose these matrices into a separate member for each column.
                             member_index_map.Add(member, member_index);
@@ -126,9 +126,9 @@
                             for (uint32_t i = 0; i < mat->columns(); i++) {
                                 StringStream ss;
                                 ss << member->Name().Name() << "_col" << std::to_string(i);
-                                new_members.Push(ty.Get<type::StructMember>(
+                                new_members.Push(ty.Get<core::type::StructMember>(
                                     sym.New(ss.str()), col, member_index, offset, col->Align(),
-                                    col->Size(), type::StructMemberAttributes{}));
+                                    col->Size(), core::type::StructMemberAttributes{}));
                                 offset += col->Align();
                                 member_index++;
                             }
@@ -136,9 +136,10 @@
                         } else {
                             // For all other types, recursively rewrite them as necessary.
                             auto* new_member_ty = RewriteType(member->Type());
-                            new_members.Push(ty.Get<type::StructMember>(
+                            new_members.Push(ty.Get<core::type::StructMember>(
                                 member->Name(), new_member_ty, member_index, member->Offset(),
-                                member->Align(), member->Size(), type::StructMemberAttributes{}));
+                                member->Align(), member->Size(),
+                                core::type::StructMemberAttributes{}));
                             member_index_map.Add(member, member_index);
                             member_index++;
                             if (new_member_ty != member->Type()) {
@@ -153,9 +154,9 @@
                     }
 
                     // Create a new struct with the rewritten members.
-                    auto* new_str = ty.Get<type::Struct>(sym.New(str->Name().Name() + "_std140"),
-                                                         std::move(new_members), str->Align(),
-                                                         str->Size(), str->SizeNoPadding());
+                    auto* new_str = ty.Get<core::type::Struct>(
+                        sym.New(str->Name().Name() + "_std140"), std::move(new_members),
+                        str->Align(), str->Size(), str->SizeNoPadding());
                     for (auto flag : str->StructFlags()) {
                         new_str->SetStructFlag(flag);
                     }
@@ -173,7 +174,7 @@
     /// @param root the root value being accessed into
     /// @param indices the access indices that get to the first column of the decomposed matrix
     /// @returns the loaded matrix
-    Value* LoadMatrix(const type::Matrix* mat, Value* root, Vector<Value*, 4> indices) {
+    Value* LoadMatrix(const core::type::Matrix* mat, Value* root, Vector<Value*, 4> indices) {
         // Load each column vector from the struct and reconstruct the original matrix type.
         Vector<Value*, 4> args;
         auto first_column = indices.Back()->As<Constant>()->Value()->ValueAs<uint32_t>();
@@ -189,17 +190,17 @@
     /// @param source the value to convert
     /// @param orig_ty the original type to convert type
     /// @returns the converted value
-    Value* Convert(Value* source, const type::Type* orig_ty) {
+    Value* Convert(Value* source, const core::type::Type* orig_ty) {
         if (source->Type() == orig_ty) {
             // The type was not rewritten, so just return the source value.
             return source;
         }
         return tint::Switch(
             orig_ty,  //
-            [&](const type::Struct* str) -> Value* {
+            [&](const core::type::Struct* str) -> Value* {
                 // Create a helper function that converts the struct to the original type.
                 auto* helper = convert_helpers.GetOrCreate(str, [&] {
-                    auto* input_str = source->Type()->As<type::Struct>();
+                    auto* input_str = source->Type()->As<core::type::Struct>();
                     auto* func = b.Function("convert_" + str->FriendlyName(), str);
                     auto* input = b.FunctionParam("input", input_str);
                     func->SetParams({input});
@@ -207,7 +208,7 @@
                         uint32_t index = 0;
                         Vector<Value*, 4> args;
                         for (auto* member : str->Members()) {
-                            if (auto* mat = member->Type()->As<type::Matrix>();
+                            if (auto* mat = member->Type()->As<core::type::Matrix>();
                                 mat && NeedsDecomposing(mat)) {
                                 // Extract each decomposed column and reconstruct the matrix.
                                 Vector<Value*, 4> columns;
@@ -235,7 +236,7 @@
                 // Call the helper function to convert the struct.
                 return b.Call(str, helper, source)->Result();
             },
-            [&](const type::Array* arr) -> Value* {
+            [&](const core::type::Array* arr) -> Value* {
                 // Create a loop that copies and converts each element of the array.
                 auto* el_ty = source->Type()->Elements().type;
                 auto* new_arr = b.Var(ty.ptr(function, arr));
@@ -262,7 +263,7 @@
                     auto* current_type = access->Object()->Type()->UnwrapPtr();
                     Vector<Value*, 4> indices;
                     for (auto idx : access->Indices()) {
-                        if (auto* str = current_type->As<type::Struct>()) {
+                        if (auto* str = current_type->As<core::type::Struct>()) {
                             uint32_t old_index = idx->As<Constant>()->Value()->ValueAs<uint32_t>();
                             uint32_t new_index = *member_index_map.Get(str->Members()[old_index]);
                             indices.Push(b.Constant(u32(new_index)));
@@ -275,7 +276,7 @@
                         // If we've hit a matrix that was decomposed, load the whole matrix.
                         // Any additional accesses will extract columns instead of producing
                         // pointers.
-                        if (auto* mat = current_type->As<type::Matrix>();
+                        if (auto* mat = current_type->As<core::type::Matrix>();
                             mat && NeedsDecomposing(mat)) {
                             replacement = LoadMatrix(mat, replacement, std::move(indices));
                             indices.Clear();
@@ -284,7 +285,7 @@
 
                     if (!indices.IsEmpty()) {
                         // Emit the access with the modified indices.
-                        if (replacement->Type()->Is<type::Pointer>()) {
+                        if (replacement->Type()->Is<core::type::Pointer>()) {
                             current_type = ty.ptr(uniform, RewriteType(current_type));
                         }
                         auto* new_access = b.Access(current_type, replacement, std::move(indices));
@@ -297,7 +298,7 @@
                     access->Destroy();
                 },
                 [&](Load* load) {
-                    if (!replacement->Type()->Is<type::Pointer>()) {
+                    if (!replacement->Type()->Is<core::type::Pointer>()) {
                         // We have already loaded to a value type, so this load just folds away.
                         load->Result()->ReplaceAllUsesWith(replacement);
                     } else {
@@ -311,7 +312,7 @@
                 [&](LoadVectorElement* load) {
                     // We should have loaded the decomposed matrix, reconstructed it, so this is now
                     // extracting from a value type.
-                    TINT_ASSERT(!replacement->Type()->Is<type::Pointer>());
+                    TINT_ASSERT(!replacement->Type()->Is<core::type::Pointer>());
                     auto* access = b.Access(load->Result()->Type(), replacement, load->Index());
                     load->Result()->ReplaceAllUsesWith(access->Result());
                     load->Destroy();
diff --git a/src/tint/lang/core/ir/transform/std140_test.cc b/src/tint/lang/core/ir/transform/std140_test.cc
index 58cc286..c5510f1 100644
--- a/src/tint/lang/core/ir/transform/std140_test.cc
+++ b/src/tint/lang/core/ir/transform/std140_test.cc
@@ -52,7 +52,7 @@
     auto* structure = ty.Struct(mod.symbols.New("MyStruct"), {
                                                                  {mod.symbols.New("a"), mat},
                                                              });
-    structure->SetStructFlag(type::kBlock);
+    structure->SetStructFlag(core::type::kBlock);
 
     auto* buffer = b.Var("buffer", ty.ptr(uniform, structure));
     buffer->SetBindingPoint(0, 0);
@@ -96,7 +96,7 @@
     auto* structure = ty.Struct(mod.symbols.New("MyStruct"), {
                                                                  {mod.symbols.New("a"), mat},
                                                              });
-    structure->SetStructFlag(type::kBlock);
+    structure->SetStructFlag(core::type::kBlock);
 
     auto* buffer = b.Var("buffer", ty.ptr(uniform, structure));
     buffer->SetBindingPoint(0, 0);
@@ -140,7 +140,7 @@
     auto* structure = ty.Struct(mod.symbols.New("MyStruct"), {
                                                                  {mod.symbols.New("a"), mat},
                                                              });
-    structure->SetStructFlag(type::kBlock);
+    structure->SetStructFlag(core::type::kBlock);
 
     auto* buffer = b.Var("buffer", ty.ptr(storage, structure));
     buffer->SetBindingPoint(0, 0);
@@ -186,7 +186,7 @@
         ty.Struct(mod.symbols.New("MyStruct"), {
                                                    {mod.symbols.New("arr"), ty.array(mat, 4u)},
                                                });
-    structure->SetStructFlag(type::kBlock);
+    structure->SetStructFlag(core::type::kBlock);
 
     auto* buffer = b.Var("buffer", ty.ptr(uniform, structure));
     buffer->SetBindingPoint(0, 0);
@@ -229,7 +229,7 @@
     auto* structure = ty.Struct(mod.symbols.New("MyStruct"), {
                                                                  {mod.symbols.New("a"), mat},
                                                              });
-    structure->SetStructFlag(type::kBlock);
+    structure->SetStructFlag(core::type::kBlock);
 
     auto* buffer = b.Var("buffer", ty.ptr(uniform, structure));
     buffer->SetBindingPoint(0, 0);
@@ -300,7 +300,7 @@
     auto* structure = ty.Struct(mod.symbols.New("MyStruct"), {
                                                                  {mod.symbols.New("a"), mat},
                                                              });
-    structure->SetStructFlag(type::kBlock);
+    structure->SetStructFlag(core::type::kBlock);
 
     auto* buffer = b.Var("buffer", ty.ptr(uniform, structure));
     buffer->SetBindingPoint(0, 0);
@@ -372,7 +372,7 @@
     auto* structure = ty.Struct(mod.symbols.New("MyStruct"), {
                                                                  {mod.symbols.New("a"), mat},
                                                              });
-    structure->SetStructFlag(type::kBlock);
+    structure->SetStructFlag(core::type::kBlock);
 
     auto* buffer = b.Var("buffer", ty.ptr(uniform, structure));
     buffer->SetBindingPoint(0, 0);
@@ -445,7 +445,7 @@
     auto* structure = ty.Struct(mod.symbols.New("MyStruct"), {
                                                                  {mod.symbols.New("a"), mat},
                                                              });
-    structure->SetStructFlag(type::kBlock);
+    structure->SetStructFlag(core::type::kBlock);
 
     auto* buffer = b.Var("buffer", ty.ptr(uniform, structure));
     buffer->SetBindingPoint(0, 0);
@@ -523,7 +523,7 @@
         ty.Struct(mod.symbols.New("Outer"), {
                                                 {mod.symbols.New("arr"), ty.array(inner, 4u)},
                                             });
-    outer->SetStructFlag(type::kBlock);
+    outer->SetStructFlag(core::type::kBlock);
 
     auto* buffer = b.Var("buffer", ty.ptr(uniform, outer));
     buffer->SetBindingPoint(0, 0);
@@ -643,7 +643,7 @@
     auto* outer = ty.Struct(mod.symbols.New("Outer"), {
                                                           {mod.symbols.New("inner"), inner},
                                                       });
-    outer->SetStructFlag(type::kBlock);
+    outer->SetStructFlag(core::type::kBlock);
 
     auto* buffer = b.Var("buffer", ty.ptr(uniform, outer));
     buffer->SetBindingPoint(0, 0);
@@ -734,7 +734,7 @@
                                                           {mod.symbols.New("m"), ty.mat3x2<f32>()},
                                                           {mod.symbols.New("inner"), inner},
                                                       });
-    outer->SetStructFlag(type::kBlock);
+    outer->SetStructFlag(core::type::kBlock);
 
     auto* buffer = b.Var("buffer", ty.ptr(uniform, outer));
     buffer->SetBindingPoint(0, 0);
@@ -828,7 +828,7 @@
                                                           {mod.symbols.New("arr"), arr},
                                                           {mod.symbols.New("d"), ty.i32()},
                                                       });
-    outer->SetStructFlag(type::kBlock);
+    outer->SetStructFlag(core::type::kBlock);
 
     auto* buffer = b.Var("buffer", ty.ptr(uniform, outer));
     buffer->SetBindingPoint(0, 0);
@@ -998,7 +998,7 @@
                                                           {mod.symbols.New("arr"), arr},
                                                           {mod.symbols.New("d"), ty.i32()},
                                                       });
-    outer->SetStructFlag(type::kBlock);
+    outer->SetStructFlag(core::type::kBlock);
 
     auto* buffer = b.Var("buffer", ty.ptr(uniform, outer));
     buffer->SetBindingPoint(0, 0);
@@ -1173,7 +1173,7 @@
                                                           {mod.symbols.New("arr"), arr},
                                                           {mod.symbols.New("d"), ty.i32()},
                                                       });
-    outer->SetStructFlag(type::kBlock);
+    outer->SetStructFlag(core::type::kBlock);
 
     auto* buffer = b.Var("buffer", ty.ptr(uniform, outer));
     buffer->SetBindingPoint(0, 0);
@@ -1336,18 +1336,18 @@
 
 TEST_F(IR_Std140Test, NonDefaultAlignAndSize) {
     auto* mat = ty.mat4x2<f32>();
-    auto* structure = ty.Get<type::Struct>(
+    auto* structure = ty.Get<core::type::Struct>(
         mod.symbols.New("MyStruct"),
         Vector{
-            ty.Get<type::StructMember>(mod.symbols.New("a"), ty.i32(), 0u, 0u, 0u, 16u,
-                                       type::StructMemberAttributes{}),
-            ty.Get<type::StructMember>(mod.symbols.New("m"), mat, 1u, 64u, 32u, 64u,
-                                       type::StructMemberAttributes{}),
-            ty.Get<type::StructMember>(mod.symbols.New("b"), ty.i32(), 2u, 128u, 8u, 32u,
-                                       type::StructMemberAttributes{}),
+            ty.Get<core::type::StructMember>(mod.symbols.New("a"), ty.i32(), 0u, 0u, 0u, 16u,
+                                             core::type::StructMemberAttributes{}),
+            ty.Get<core::type::StructMember>(mod.symbols.New("m"), mat, 1u, 64u, 32u, 64u,
+                                             core::type::StructMemberAttributes{}),
+            ty.Get<core::type::StructMember>(mod.symbols.New("b"), ty.i32(), 2u, 128u, 8u, 32u,
+                                             core::type::StructMemberAttributes{}),
         },
         128u, 256u, 160u);
-    structure->SetStructFlag(type::kBlock);
+    structure->SetStructFlag(core::type::kBlock);
 
     auto* buffer = b.Var("buffer", ty.ptr(uniform, structure));
     buffer->SetBindingPoint(0, 0);
@@ -1448,7 +1448,7 @@
                                                    {mod.symbols.New("c"), ty.mat4x3<f16>()},
                                                    {mod.symbols.New("d"), ty.mat4x4<f16>()},
                                                });
-    structure->SetStructFlag(type::kBlock);
+    structure->SetStructFlag(core::type::kBlock);
 
     auto* buffer = b.Var("buffer", ty.ptr(uniform, structure));
     buffer->SetBindingPoint(0, 0);
diff --git a/src/tint/lang/core/ir/validator.cc b/src/tint/lang/core/ir/validator.cc
index ca5eb5a..d9f17fa 100644
--- a/src/tint/lang/core/ir/validator.cc
+++ b/src/tint/lang/core/ir/validator.cc
@@ -321,7 +321,7 @@
 }
 
 void Validator::CheckAccess(ir::Access* a) {
-    bool is_ptr = a->Object()->Type()->Is<type::Pointer>();
+    bool is_ptr = a->Object()->Type()->Is<core::type::Pointer>();
     auto* ty = a->Object()->Type()->UnwrapPtr();
 
     auto current = [&] { return is_ptr ? "ptr<" + ty->FriendlyName() + ">" : ty->FriendlyName(); };
@@ -338,7 +338,7 @@
             return;
         }
 
-        if (is_ptr && ty->Is<type::Vector>()) {
+        if (is_ptr && ty->Is<core::type::Vector>()) {
             err("cannot obtain address of vector element");
             return;
         }
@@ -379,7 +379,7 @@
     }
 
     auto* want_ty = a->Result()->Type()->UnwrapPtr();
-    bool want_ptr = a->Result()->Type()->Is<type::Pointer>();
+    bool want_ptr = a->Result()->Type()->Is<core::type::Pointer>();
     if (TINT_UNLIKELY(ty != want_ty || is_ptr != want_ptr)) {
         std::string want =
             want_ptr ? "ptr<" + want_ty->FriendlyName() + ">" : want_ty->FriendlyName();
@@ -406,7 +406,7 @@
 void Validator::CheckIf(If* if_) {
     CheckOperandNotNull(if_, if_->Condition(), If::kConditionOperandOffset);
 
-    if (if_->Condition() && !if_->Condition()->Type()->Is<type::Bool>()) {
+    if (if_->Condition() && !if_->Condition()->Type()->Is<core::type::Bool>()) {
         AddError(if_, If::kConditionOperandOffset,
                  InstError(if_, "condition must be a `bool` type"));
     }
@@ -512,7 +512,7 @@
         AddError(ret, InstError(ret, "undefined function"));
         return;
     }
-    if (func->ReturnType()->Is<type::Void>()) {
+    if (func->ReturnType()->Is<core::type::Void>()) {
         if (ret->Value()) {
             AddError(ret, InstError(ret, "unexpected return value"));
         }
@@ -604,7 +604,7 @@
     }
 }
 
-const type::Type* Validator::GetVectorPtrElementType(Instruction* inst, size_t idx) {
+const core::type::Type* Validator::GetVectorPtrElementType(Instruction* inst, size_t idx) {
     auto* operand = inst->Operands()[idx];
     if (TINT_UNLIKELY(!operand)) {
         return nullptr;
@@ -615,9 +615,9 @@
         return nullptr;
     }
 
-    auto* vec_ptr_ty = type->As<type::Pointer>();
+    auto* vec_ptr_ty = type->As<core::type::Pointer>();
     if (TINT_LIKELY(vec_ptr_ty)) {
-        auto* vec_ty = vec_ptr_ty->StoreType()->As<type::Vector>();
+        auto* vec_ty = vec_ptr_ty->StoreType()->As<core::type::Vector>();
         if (TINT_LIKELY(vec_ty)) {
             return vec_ty->type();
         }
diff --git a/src/tint/lang/core/ir/validator.h b/src/tint/lang/core/ir/validator.h
index c409985..9448c7b 100644
--- a/src/tint/lang/core/ir/validator.h
+++ b/src/tint/lang/core/ir/validator.h
@@ -228,7 +228,7 @@
     /// @param inst the instruction
     /// @param idx the operand index
     /// @returns the vector pointer type for the given instruction operand
-    const type::Type* GetVectorPtrElementType(Instruction* inst, size_t idx);
+    const core::type::Type* GetVectorPtrElementType(Instruction* inst, size_t idx);
 
   private:
     Module& mod_;
diff --git a/src/tint/lang/core/ir/value.h b/src/tint/lang/core/ir/value.h
index 5871271..556f695 100644
--- a/src/tint/lang/core/ir/value.h
+++ b/src/tint/lang/core/ir/value.h
@@ -57,7 +57,7 @@
     ~Value() override;
 
     /// @returns the type of the value
-    virtual const type::Type* Type() { return nullptr; }
+    virtual const core::type::Type* Type() { return nullptr; }
 
     /// Destroys the Value. Once called, the Value must not be used again.
     /// The Value must not be in use by any instruction.
diff --git a/src/tint/lang/core/ir/var.cc b/src/tint/lang/core/ir/var.cc
index 3bf295c..cacf610 100644
--- a/src/tint/lang/core/ir/var.cc
+++ b/src/tint/lang/core/ir/var.cc
@@ -23,7 +23,7 @@
 
 Var::Var(InstructionResult* result) {
     if (result && result->Type()) {
-        TINT_ASSERT(result->Type()->Is<type::Pointer>());
+        TINT_ASSERT(result->Type()->Is<core::type::Pointer>());
     }
 
     // Default to no initializer.
diff --git a/src/tint/lang/core/type/abstract_float.cc b/src/tint/lang/core/type/abstract_float.cc
index 89791c4..e133e94 100644
--- a/src/tint/lang/core/type/abstract_float.cc
+++ b/src/tint/lang/core/type/abstract_float.cc
@@ -17,9 +17,9 @@
 #include "src/tint/lang/core/type/manager.h"
 #include "src/tint/utils/math/hash.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::AbstractFloat);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::AbstractFloat);
 
-namespace tint::type {
+namespace tint::core::type {
 
 AbstractFloat::AbstractFloat() : Base(Hash(tint::TypeInfo::Of<AbstractFloat>().full_hashcode)) {}
 
@@ -33,4 +33,4 @@
     return ctx.dst.mgr->Get<AbstractFloat>();
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/abstract_float.h b/src/tint/lang/core/type/abstract_float.h
index 857cf5e..59da480 100644
--- a/src/tint/lang/core/type/abstract_float.h
+++ b/src/tint/lang/core/type/abstract_float.h
@@ -19,7 +19,7 @@
 
 #include "src/tint/lang/core/type/abstract_numeric.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// An abstract-float type.
 /// @see https://www.w3.org/TR/WGSL/#abstractFloat
@@ -39,6 +39,6 @@
     AbstractFloat* Clone(CloneContext& ctx) const override;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_ABSTRACT_FLOAT_H_
diff --git a/src/tint/lang/core/type/abstract_int.cc b/src/tint/lang/core/type/abstract_int.cc
index ed2abe1..837d4cb 100644
--- a/src/tint/lang/core/type/abstract_int.cc
+++ b/src/tint/lang/core/type/abstract_int.cc
@@ -17,9 +17,9 @@
 #include "src/tint/lang/core/type/manager.h"
 #include "src/tint/utils/math/hash.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::AbstractInt);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::AbstractInt);
 
-namespace tint::type {
+namespace tint::core::type {
 
 AbstractInt::AbstractInt() : Base(Hash(tint::TypeInfo::Of<AbstractInt>().full_hashcode)) {}
 
@@ -33,4 +33,4 @@
     return ctx.dst.mgr->Get<AbstractInt>();
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/abstract_int.h b/src/tint/lang/core/type/abstract_int.h
index 71da42c..69d5aa0 100644
--- a/src/tint/lang/core/type/abstract_int.h
+++ b/src/tint/lang/core/type/abstract_int.h
@@ -19,7 +19,7 @@
 
 #include "src/tint/lang/core/type/abstract_numeric.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// An abstract-int type.
 /// @see https://www.w3.org/TR/WGSL/#abstractint
@@ -39,6 +39,6 @@
     AbstractInt* Clone(CloneContext& ctx) const override;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_ABSTRACT_INT_H_
diff --git a/src/tint/lang/core/type/abstract_numeric.cc b/src/tint/lang/core/type/abstract_numeric.cc
index 14bf9a9..e6ef24b 100644
--- a/src/tint/lang/core/type/abstract_numeric.cc
+++ b/src/tint/lang/core/type/abstract_numeric.cc
@@ -14,13 +14,13 @@
 
 #include "src/tint/lang/core/type/abstract_numeric.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::AbstractNumeric);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::AbstractNumeric);
 
-namespace tint::type {
+namespace tint::core::type {
 
 AbstractNumeric::AbstractNumeric(size_t hash)
     : Base(hash,
-           type::Flags{
+           core::type::Flags{
                Flag::kConstructable,
                Flag::kCreationFixedFootprint,
                Flag::kFixedFootprint,
@@ -35,4 +35,4 @@
     return 0;
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/abstract_numeric.h b/src/tint/lang/core/type/abstract_numeric.h
index 7a7670a..b76e7a7 100644
--- a/src/tint/lang/core/type/abstract_numeric.h
+++ b/src/tint/lang/core/type/abstract_numeric.h
@@ -19,7 +19,7 @@
 
 #include "src/tint/lang/core/type/numeric_scalar.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// The base class for abstract-int and abstract-float types.
 /// @see https://www.w3.org/TR/WGSL/#types-for-creation-time-constants
@@ -39,6 +39,6 @@
     uint32_t Align() const override;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_ABSTRACT_NUMERIC_H_
diff --git a/src/tint/lang/core/type/array.cc b/src/tint/lang/core/type/array.cc
index 59747ae..c76ba42 100644
--- a/src/tint/lang/core/type/array.cc
+++ b/src/tint/lang/core/type/array.cc
@@ -23,14 +23,14 @@
 #include "src/tint/utils/symbol/symbol_table.h"
 #include "src/tint/utils/text/string_stream.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::Array);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::Array);
 
-namespace tint::type {
+namespace tint::core::type {
 
 namespace {
 
-type::Flags FlagsFrom(const Type* element, const ArrayCount* count) {
-    type::Flags flags;
+core::type::Flags FlagsFrom(const Type* element, const ArrayCount* count) {
+    core::type::Flags flags;
     // Only constant-expression sized arrays are constructible
     if (count->Is<ConstantArrayCount>()) {
         if (element->IsConstructible()) {
@@ -128,4 +128,4 @@
     return ctx.dst.mgr->Get<Array>(elem_ty, count, align_, size_, stride_, implicit_stride_);
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/array.h b/src/tint/lang/core/type/array.h
index 1eb09c9..0f97911 100644
--- a/src/tint/lang/core/type/array.h
+++ b/src/tint/lang/core/type/array.h
@@ -25,7 +25,7 @@
 #include "src/tint/utils/containers/unique_vector.h"
 #include "src/tint/utils/macros/compiler.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// Array holds the type information for Array nodes.
 class Array final : public Castable<Array, Type> {
@@ -117,6 +117,6 @@
     const uint32_t implicit_stride_;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_ARRAY_H_
diff --git a/src/tint/lang/core/type/array_count.cc b/src/tint/lang/core/type/array_count.cc
index 3d6dc76..6b3f52f 100644
--- a/src/tint/lang/core/type/array_count.cc
+++ b/src/tint/lang/core/type/array_count.cc
@@ -16,11 +16,11 @@
 
 #include "src/tint/lang/core/type/manager.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::ArrayCount);
-TINT_INSTANTIATE_TYPEINFO(tint::type::ConstantArrayCount);
-TINT_INSTANTIATE_TYPEINFO(tint::type::RuntimeArrayCount);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::ArrayCount);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::ConstantArrayCount);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::RuntimeArrayCount);
 
-namespace tint::type {
+namespace tint::core::type {
 
 ArrayCount::ArrayCount(size_t hash) : Base(hash) {}
 ArrayCount::~ArrayCount() = default;
@@ -61,4 +61,4 @@
     return ctx.dst.mgr->Get<RuntimeArrayCount>();
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/array_count.h b/src/tint/lang/core/type/array_count.h
index 7ab196f..d3869c5 100644
--- a/src/tint/lang/core/type/array_count.h
+++ b/src/tint/lang/core/type/array_count.h
@@ -22,7 +22,7 @@
 #include "src/tint/lang/core/type/unique_node.h"
 #include "src/tint/utils/symbol/symbol_table.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// An array count
 class ArrayCount : public Castable<ArrayCount, UniqueNode> {
@@ -93,6 +93,6 @@
     RuntimeArrayCount* Clone(CloneContext& ctx) const override;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_ARRAY_COUNT_H_
diff --git a/src/tint/lang/core/type/array_test.cc b/src/tint/lang/core/type/array_test.cc
index d07d719..e82bebd 100644
--- a/src/tint/lang/core/type/array_test.cc
+++ b/src/tint/lang/core/type/array_test.cc
@@ -16,7 +16,7 @@
 #include "src/tint/lang/core/type/texture.h"
 #include "src/tint/lang/wgsl/sem/array_count.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using ArrayTest = TestHelper;
@@ -167,8 +167,8 @@
 TEST_F(ArrayTest, CloneSizedArray) {
     auto* ary = create<Array>(create<U32>(), create<ConstantArrayCount>(2u), 4u, 8u, 32u, 16u);
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* val = ary->Clone(ctx);
 
@@ -186,8 +186,8 @@
 TEST_F(ArrayTest, CloneRuntimeArray) {
     auto* ary = create<Array>(create<U32>(), create<RuntimeArrayCount>(), 4u, 8u, 32u, 32u);
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* val = ary->Clone(ctx);
     ASSERT_NE(val, nullptr);
@@ -201,4 +201,4 @@
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/atomic.cc b/src/tint/lang/core/type/atomic.cc
index 4ff5607..20809f1 100644
--- a/src/tint/lang/core/type/atomic.cc
+++ b/src/tint/lang/core/type/atomic.cc
@@ -21,13 +21,13 @@
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::Atomic);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::Atomic);
 
-namespace tint::type {
+namespace tint::core::type {
 
-Atomic::Atomic(const type::Type* subtype)
+Atomic::Atomic(const core::type::Type* subtype)
     : Base(Hash(tint::TypeInfo::Of<Atomic>().full_hashcode, subtype),
-           type::Flags{
+           core::type::Flags{
                Flag::kCreationFixedFootprint,
                Flag::kFixedFootprint,
            }),
@@ -35,7 +35,7 @@
     TINT_ASSERT(!subtype->Is<Reference>());
 }
 
-bool Atomic::Equals(const type::UniqueNode& other) const {
+bool Atomic::Equals(const core::type::UniqueNode& other) const {
     if (auto* o = other.As<Atomic>()) {
         return o->subtype_ == subtype_;
     }
@@ -63,4 +63,4 @@
     return ctx.dst.mgr->Get<Atomic>(ty);
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/atomic.h b/src/tint/lang/core/type/atomic.h
index 4680b45..6ca1938 100644
--- a/src/tint/lang/core/type/atomic.h
+++ b/src/tint/lang/core/type/atomic.h
@@ -19,24 +19,24 @@
 
 #include "src/tint/lang/core/type/type.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A atomic type.
 class Atomic final : public Castable<Atomic, Type> {
   public:
     /// Constructor
     /// @param subtype the atomic type
-    explicit Atomic(const type::Type* subtype);
+    explicit Atomic(const core::type::Type* subtype);
 
     /// Destructor
     ~Atomic() override;
 
     /// @param other the other node to compare against
     /// @returns true if the this type is equal to @p other
-    bool Equals(const type::UniqueNode& other) const override;
+    bool Equals(const core::type::UniqueNode& other) const override;
 
     /// @returns the atomic type
-    const type::Type* Type() const { return subtype_; }
+    const core::type::Type* Type() const { return subtype_; }
 
     /// @returns the name for this type that closely resembles how it would be
     /// declared in WGSL.
@@ -53,9 +53,9 @@
     Atomic* Clone(CloneContext& ctx) const override;
 
   private:
-    type::Type const* const subtype_;
+    core::type::Type const* const subtype_;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_ATOMIC_H_
diff --git a/src/tint/lang/core/type/atomic_test.cc b/src/tint/lang/core/type/atomic_test.cc
index 8ff9232..e3f8b9f 100644
--- a/src/tint/lang/core/type/atomic_test.cc
+++ b/src/tint/lang/core/type/atomic_test.cc
@@ -16,7 +16,7 @@
 
 #include "src/tint/lang/core/type/helper_test.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using AtomicTest = TestHelper;
@@ -53,12 +53,12 @@
 TEST_F(AtomicTest, Clone) {
     auto* atomic = create<Atomic>(create<I32>());
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* val = atomic->Clone(ctx);
     EXPECT_TRUE(val->Type()->Is<I32>());
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/bool.cc b/src/tint/lang/core/type/bool.cc
index 0c937a4..512aa00 100644
--- a/src/tint/lang/core/type/bool.cc
+++ b/src/tint/lang/core/type/bool.cc
@@ -16,13 +16,13 @@
 
 #include "src/tint/lang/core/type/manager.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::Bool);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::Bool);
 
-namespace tint::type {
+namespace tint::core::type {
 
 Bool::Bool()
     : Base(static_cast<size_t>(tint::TypeInfo::Of<Bool>().full_hashcode),
-           type::Flags{
+           core::type::Flags{
                Flag::kConstructable,
                Flag::kCreationFixedFootprint,
                Flag::kFixedFootprint,
@@ -46,4 +46,4 @@
     return ctx.dst.mgr->Get<Bool>();
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/bool.h b/src/tint/lang/core/type/bool.h
index 2a96db1..a0938e6 100644
--- a/src/tint/lang/core/type/bool.h
+++ b/src/tint/lang/core/type/bool.h
@@ -25,7 +25,7 @@
 #undef Bool
 #endif
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A boolean type
 class Bool final : public Castable<Bool, Scalar> {
@@ -55,6 +55,6 @@
     Bool* Clone(CloneContext& ctx) const override;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_BOOL_H_
diff --git a/src/tint/lang/core/type/bool_test.cc b/src/tint/lang/core/type/bool_test.cc
index 39d08a4..e3a6347 100644
--- a/src/tint/lang/core/type/bool_test.cc
+++ b/src/tint/lang/core/type/bool_test.cc
@@ -15,7 +15,7 @@
 #include "src/tint/lang/core/type/helper_test.h"
 #include "src/tint/lang/core/type/texture.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using BoolTest = TestHelper;
@@ -46,12 +46,12 @@
 
 TEST_F(BoolTest, Clone) {
     auto* a = create<Bool>();
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* b = a->Clone(ctx);
     ASSERT_TRUE(b->Is<Bool>());
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/builtin_structs.cc b/src/tint/lang/core/type/builtin_structs.cc
index fddf2b4..3d97986 100644
--- a/src/tint/lang/core/type/builtin_structs.cc
+++ b/src/tint/lang/core/type/builtin_structs.cc
@@ -32,7 +32,7 @@
 #include "src/tint/utils/symbol/symbol_table.h"
 #include "src/tint/utils/text/string.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// An array of `modf()` return type names for an argument of `vecN<f32>`.
 constexpr std::array kModfVecF32Names{
@@ -187,4 +187,4 @@
         });
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/builtin_structs.h b/src/tint/lang/core/type/builtin_structs.h
index c040af4..bd7fb8a 100644
--- a/src/tint/lang/core/type/builtin_structs.h
+++ b/src/tint/lang/core/type/builtin_structs.h
@@ -19,13 +19,13 @@
 namespace tint {
 class SymbolTable;
 }  // namespace tint
-namespace tint::type {
+namespace tint::core::type {
 class Manager;
 class Struct;
 class Type;
-}  // namespace tint::type
+}  // namespace tint::core::type
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// @param types the type manager
 /// @param symbols the symbol table
@@ -45,6 +45,6 @@
 /// @returns the builtin struct type for a atomic_compare_exchange() builtin call.
 Struct* CreateAtomicCompareExchangeResult(Manager& types, SymbolTable& symbols, const Type* ty);
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_BUILTIN_STRUCTS_H_
diff --git a/src/tint/lang/core/type/builtin_structs_test.cc b/src/tint/lang/core/type/builtin_structs_test.cc
index 478453b..a981b0e 100644
--- a/src/tint/lang/core/type/builtin_structs_test.cc
+++ b/src/tint/lang/core/type/builtin_structs_test.cc
@@ -29,7 +29,7 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 enum ElementType {
@@ -161,4 +161,4 @@
                          testing::Values(kI32, kU32));
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/clone_context.h b/src/tint/lang/core/type/clone_context.h
index c8d0ea3..8837e63 100644
--- a/src/tint/lang/core/type/clone_context.h
+++ b/src/tint/lang/core/type/clone_context.h
@@ -19,11 +19,11 @@
 namespace tint {
 class SymbolTable;
 }  // namespace tint
-namespace tint::type {
+namespace tint::core::type {
 class Manager;
-}  // namespace tint::type
+}  // namespace tint::core::type
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// Context information for cloning of types
 struct CloneContext {
@@ -42,6 +42,6 @@
     } dst;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_CLONE_CONTEXT_H_
diff --git a/src/tint/lang/core/type/depth_multisampled_texture.cc b/src/tint/lang/core/type/depth_multisampled_texture.cc
index 71983b9..3d30d83 100644
--- a/src/tint/lang/core/type/depth_multisampled_texture.cc
+++ b/src/tint/lang/core/type/depth_multisampled_texture.cc
@@ -21,9 +21,9 @@
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::DepthMultisampledTexture);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::DepthMultisampledTexture);
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 bool IsValidDepthDimension(TextureDimension dim) {
@@ -56,4 +56,4 @@
     return ctx.dst.mgr->Get<DepthMultisampledTexture>(dim());
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/depth_multisampled_texture.h b/src/tint/lang/core/type/depth_multisampled_texture.h
index f5e1e35..c724775 100644
--- a/src/tint/lang/core/type/depth_multisampled_texture.h
+++ b/src/tint/lang/core/type/depth_multisampled_texture.h
@@ -20,7 +20,7 @@
 #include "src/tint/lang/core/type/texture.h"
 #include "src/tint/lang/core/type/texture_dimension.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A multisampled depth texture type.
 class DepthMultisampledTexture final : public Castable<DepthMultisampledTexture, Texture> {
@@ -45,6 +45,6 @@
     DepthMultisampledTexture* Clone(CloneContext& ctx) const override;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_DEPTH_MULTISAMPLED_TEXTURE_H_
diff --git a/src/tint/lang/core/type/depth_multisampled_texture_test.cc b/src/tint/lang/core/type/depth_multisampled_texture_test.cc
index 04f6a1e..007e04d 100644
--- a/src/tint/lang/core/type/depth_multisampled_texture_test.cc
+++ b/src/tint/lang/core/type/depth_multisampled_texture_test.cc
@@ -20,7 +20,7 @@
 #include "src/tint/lang/core/type/storage_texture.h"
 #include "src/tint/lang/core/type/texture_dimension.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using DepthMultisampledTextureTest = TestHelper;
@@ -61,12 +61,12 @@
 TEST_F(DepthMultisampledTextureTest, Clone) {
     auto* a = create<DepthMultisampledTexture>(TextureDimension::k2d);
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* dt = a->Clone(ctx);
     EXPECT_EQ(dt->dim(), TextureDimension::k2d);
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/depth_texture.cc b/src/tint/lang/core/type/depth_texture.cc
index 973bb56..d1ca5f5 100644
--- a/src/tint/lang/core/type/depth_texture.cc
+++ b/src/tint/lang/core/type/depth_texture.cc
@@ -21,9 +21,9 @@
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::DepthTexture);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::DepthTexture);
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 bool IsValidDepthDimension(TextureDimension dim) {
@@ -57,4 +57,4 @@
     return ctx.dst.mgr->Get<DepthTexture>(dim());
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/depth_texture.h b/src/tint/lang/core/type/depth_texture.h
index 92692ed..4536fa6 100644
--- a/src/tint/lang/core/type/depth_texture.h
+++ b/src/tint/lang/core/type/depth_texture.h
@@ -20,7 +20,7 @@
 #include "src/tint/lang/core/type/texture.h"
 #include "src/tint/lang/core/type/texture_dimension.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A depth texture type.
 class DepthTexture final : public Castable<DepthTexture, Texture> {
@@ -45,6 +45,6 @@
     DepthTexture* Clone(CloneContext& ctx) const override;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_DEPTH_TEXTURE_H_
diff --git a/src/tint/lang/core/type/depth_texture_test.cc b/src/tint/lang/core/type/depth_texture_test.cc
index b82ec7b..a0392369 100644
--- a/src/tint/lang/core/type/depth_texture_test.cc
+++ b/src/tint/lang/core/type/depth_texture_test.cc
@@ -20,7 +20,7 @@
 #include "src/tint/lang/core/type/storage_texture.h"
 #include "src/tint/lang/core/type/texture_dimension.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using DepthTextureTest = TestHelper;
@@ -73,12 +73,12 @@
 TEST_F(DepthTextureTest, Clone) {
     auto* a = create<DepthTexture>(TextureDimension::k2d);
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* dt = a->Clone(ctx);
     EXPECT_EQ(dt->dim(), TextureDimension::k2d);
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/external_texture.cc b/src/tint/lang/core/type/external_texture.cc
index 13e5d44..24962ca 100644
--- a/src/tint/lang/core/type/external_texture.cc
+++ b/src/tint/lang/core/type/external_texture.cc
@@ -17,9 +17,9 @@
 #include "src/tint/lang/core/type/manager.h"
 #include "src/tint/lang/core/type/texture_dimension.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::ExternalTexture);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::ExternalTexture);
 
-namespace tint::type {
+namespace tint::core::type {
 
 ExternalTexture::ExternalTexture()
     : Base(static_cast<size_t>(tint::TypeInfo::Of<ExternalTexture>().full_hashcode),
@@ -39,4 +39,4 @@
     return ctx.dst.mgr->Get<ExternalTexture>();
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/external_texture.h b/src/tint/lang/core/type/external_texture.h
index 7f35697..d5ef929 100644
--- a/src/tint/lang/core/type/external_texture.h
+++ b/src/tint/lang/core/type/external_texture.h
@@ -19,7 +19,7 @@
 
 #include "src/tint/lang/core/type/texture.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// An external texture type
 class ExternalTexture final : public Castable<ExternalTexture, Texture> {
@@ -43,6 +43,6 @@
     ExternalTexture* Clone(CloneContext& ctx) const override;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_EXTERNAL_TEXTURE_H_
diff --git a/src/tint/lang/core/type/external_texture_test.cc b/src/tint/lang/core/type/external_texture_test.cc
index c850e9b..9ca5eb7 100644
--- a/src/tint/lang/core/type/external_texture_test.cc
+++ b/src/tint/lang/core/type/external_texture_test.cc
@@ -21,7 +21,7 @@
 #include "src/tint/lang/core/type/storage_texture.h"
 #include "src/tint/lang/core/type/texture_dimension.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using ExternalTextureTest = TestHelper;
@@ -70,12 +70,12 @@
 TEST_F(ExternalTextureTest, Clone) {
     auto* a = create<ExternalTexture>();
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* b = a->Clone(ctx);
     ASSERT_TRUE(b->Is<ExternalTexture>());
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/f16.cc b/src/tint/lang/core/type/f16.cc
index f14db5a..8ff15cb 100644
--- a/src/tint/lang/core/type/f16.cc
+++ b/src/tint/lang/core/type/f16.cc
@@ -16,13 +16,13 @@
 
 #include "src/tint/lang/core/type/manager.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::F16);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::F16);
 
-namespace tint::type {
+namespace tint::core::type {
 
 F16::F16()
     : Base(static_cast<size_t>(tint::TypeInfo::Of<F16>().full_hashcode),
-           type::Flags{
+           core::type::Flags{
                Flag::kConstructable,
                Flag::kCreationFixedFootprint,
                Flag::kFixedFootprint,
@@ -46,4 +46,4 @@
     return ctx.dst.mgr->Get<F16>();
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/f16.h b/src/tint/lang/core/type/f16.h
index 4d310d8..bef6ead 100644
--- a/src/tint/lang/core/type/f16.h
+++ b/src/tint/lang/core/type/f16.h
@@ -19,7 +19,7 @@
 
 #include "src/tint/lang/core/type/numeric_scalar.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A float 16 type
 class F16 final : public Castable<F16, NumericScalar> {
@@ -45,6 +45,6 @@
     F16* Clone(CloneContext& ctx) const override;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_F16_H_
diff --git a/src/tint/lang/core/type/f16_test.cc b/src/tint/lang/core/type/f16_test.cc
index f1b083e..61fa0dc 100644
--- a/src/tint/lang/core/type/f16_test.cc
+++ b/src/tint/lang/core/type/f16_test.cc
@@ -15,7 +15,7 @@
 #include "src/tint/lang/core/type/helper_test.h"
 #include "src/tint/lang/core/type/texture.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using F16Test = TestHelper;
@@ -47,12 +47,12 @@
 TEST_F(F16Test, Clone) {
     auto* a = create<F16>();
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* b = a->Clone(ctx);
     ASSERT_TRUE(b->Is<F16>());
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/f32.cc b/src/tint/lang/core/type/f32.cc
index 2fb2693..1e5a676 100644
--- a/src/tint/lang/core/type/f32.cc
+++ b/src/tint/lang/core/type/f32.cc
@@ -16,13 +16,13 @@
 
 #include "src/tint/lang/core/type/manager.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::F32);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::F32);
 
-namespace tint::type {
+namespace tint::core::type {
 
 F32::F32()
     : Base(static_cast<size_t>(tint::TypeInfo::Of<F32>().full_hashcode),
-           type::Flags{
+           core::type::Flags{
                Flag::kConstructable,
                Flag::kCreationFixedFootprint,
                Flag::kFixedFootprint,
@@ -46,4 +46,4 @@
     return ctx.dst.mgr->Get<F32>();
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/f32.h b/src/tint/lang/core/type/f32.h
index 3c7f730..fe5af50 100644
--- a/src/tint/lang/core/type/f32.h
+++ b/src/tint/lang/core/type/f32.h
@@ -19,7 +19,7 @@
 
 #include "src/tint/lang/core/type/numeric_scalar.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A float 32 type
 class F32 final : public Castable<F32, NumericScalar> {
@@ -45,6 +45,6 @@
     F32* Clone(CloneContext& ctx) const override;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_F32_H_
diff --git a/src/tint/lang/core/type/f32_test.cc b/src/tint/lang/core/type/f32_test.cc
index 5acab85..05b1546 100644
--- a/src/tint/lang/core/type/f32_test.cc
+++ b/src/tint/lang/core/type/f32_test.cc
@@ -15,7 +15,7 @@
 #include "src/tint/lang/core/type/helper_test.h"
 #include "src/tint/lang/core/type/texture.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using F32Test = TestHelper;
@@ -47,12 +47,12 @@
 TEST_F(F32Test, Clone) {
     auto* a = create<F32>();
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* b = a->Clone(ctx);
     ASSERT_TRUE(b->Is<F32>());
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/helper_test.h b/src/tint/lang/core/type/helper_test.h
index 34b029d..7cb71bc 100644
--- a/src/tint/lang/core/type/helper_test.h
+++ b/src/tint/lang/core/type/helper_test.h
@@ -21,7 +21,7 @@
 #include "src/tint/lang/wgsl/program/program_builder.h"
 #include "src/tint/lang/wgsl/resolver/resolve.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// Helper class for testing
 template <typename BASE>
@@ -44,13 +44,13 @@
 template <typename T>
 using TestParamHelper = TestHelperBase<testing::TestWithParam<T>>;
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 /// Helper macro for testing that a type was as expected
 #define EXPECT_TYPE(GOT, EXPECT)                                                                \
     do {                                                                                        \
-        const type::Type* got = GOT;                                                            \
-        const type::Type* expect = EXPECT;                                                      \
+        const core::type::Type* got = GOT;                                                      \
+        const core::type::Type* expect = EXPECT;                                                \
         if (got != expect) {                                                                    \
             ADD_FAILURE() << #GOT " != " #EXPECT "\n"                                           \
                           << "  " #GOT ": " << (got ? got->FriendlyName() : "<null>") << "\n"   \
diff --git a/src/tint/lang/core/type/i32.cc b/src/tint/lang/core/type/i32.cc
index ceb53de..a2e7c9c 100644
--- a/src/tint/lang/core/type/i32.cc
+++ b/src/tint/lang/core/type/i32.cc
@@ -16,13 +16,13 @@
 
 #include "src/tint/lang/core/type/manager.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::I32);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::I32);
 
-namespace tint::type {
+namespace tint::core::type {
 
 I32::I32()
     : Base(static_cast<size_t>(tint::TypeInfo::Of<I32>().full_hashcode),
-           type::Flags{
+           core::type::Flags{
                Flag::kConstructable,
                Flag::kCreationFixedFootprint,
                Flag::kFixedFootprint,
@@ -46,4 +46,4 @@
     return ctx.dst.mgr->Get<I32>();
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/i32.h b/src/tint/lang/core/type/i32.h
index fae89d5..addcafa 100644
--- a/src/tint/lang/core/type/i32.h
+++ b/src/tint/lang/core/type/i32.h
@@ -19,7 +19,7 @@
 
 #include "src/tint/lang/core/type/numeric_scalar.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A signed int 32 type.
 class I32 final : public Castable<I32, NumericScalar> {
@@ -45,6 +45,6 @@
     I32* Clone(CloneContext& ctx) const override;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_I32_H_
diff --git a/src/tint/lang/core/type/i32_test.cc b/src/tint/lang/core/type/i32_test.cc
index 5b9786c..8119a42 100644
--- a/src/tint/lang/core/type/i32_test.cc
+++ b/src/tint/lang/core/type/i32_test.cc
@@ -15,7 +15,7 @@
 #include "src/tint/lang/core/type/helper_test.h"
 #include "src/tint/lang/core/type/texture.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using I32Test = TestHelper;
@@ -47,12 +47,12 @@
 TEST_F(I32Test, Clone) {
     auto* a = create<I32>();
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* b = a->Clone(ctx);
     ASSERT_TRUE(b->Is<I32>());
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/manager.cc b/src/tint/lang/core/type/manager.cc
index a1178f2..2a3436e 100644
--- a/src/tint/lang/core/type/manager.cc
+++ b/src/tint/lang/core/type/manager.cc
@@ -30,7 +30,7 @@
 #include "src/tint/lang/core/type/vector.h"
 #include "src/tint/lang/core/type/void.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 Manager::Manager() = default;
 
@@ -40,128 +40,131 @@
 
 Manager::~Manager() = default;
 
-const type::Void* Manager::void_() {
-    return Get<type::Void>();
+const core::type::Void* Manager::void_() {
+    return Get<core::type::Void>();
 }
 
-const type::Bool* Manager::bool_() {
-    return Get<type::Bool>();
+const core::type::Bool* Manager::bool_() {
+    return Get<core::type::Bool>();
 }
 
-const type::I32* Manager::i32() {
-    return Get<type::I32>();
+const core::type::I32* Manager::i32() {
+    return Get<core::type::I32>();
 }
 
-const type::U32* Manager::u32() {
-    return Get<type::U32>();
+const core::type::U32* Manager::u32() {
+    return Get<core::type::U32>();
 }
 
-const type::F32* Manager::f32() {
-    return Get<type::F32>();
+const core::type::F32* Manager::f32() {
+    return Get<core::type::F32>();
 }
 
-const type::F16* Manager::f16() {
-    return Get<type::F16>();
+const core::type::F16* Manager::f16() {
+    return Get<core::type::F16>();
 }
 
-const type::AbstractFloat* Manager::AFloat() {
-    return Get<type::AbstractFloat>();
+const core::type::AbstractFloat* Manager::AFloat() {
+    return Get<core::type::AbstractFloat>();
 }
 
-const type::AbstractInt* Manager::AInt() {
-    return Get<type::AbstractInt>();
+const core::type::AbstractInt* Manager::AInt() {
+    return Get<core::type::AbstractInt>();
 }
 
-const type::Atomic* Manager::atomic(const type::Type* inner) {
-    return Get<type::Atomic>(inner);
+const core::type::Atomic* Manager::atomic(const core::type::Type* inner) {
+    return Get<core::type::Atomic>(inner);
 }
 
-const type::Vector* Manager::packed_vec(const type::Type* inner, uint32_t size) {
-    return Get<type::Vector>(inner, size, true);
+const core::type::Vector* Manager::packed_vec(const core::type::Type* inner, uint32_t size) {
+    return Get<core::type::Vector>(inner, size, true);
 }
 
-const type::Vector* Manager::vec(const type::Type* inner, uint32_t size) {
-    return Get<type::Vector>(inner, size);
+const core::type::Vector* Manager::vec(const core::type::Type* inner, uint32_t size) {
+    return Get<core::type::Vector>(inner, size);
 }
 
-const type::Vector* Manager::vec2(const type::Type* inner) {
+const core::type::Vector* Manager::vec2(const core::type::Type* inner) {
     return vec(inner, 2);
 }
 
-const type::Vector* Manager::vec3(const type::Type* inner) {
+const core::type::Vector* Manager::vec3(const core::type::Type* inner) {
     return vec(inner, 3);
 }
 
-const type::Vector* Manager::vec4(const type::Type* inner) {
+const core::type::Vector* Manager::vec4(const core::type::Type* inner) {
     return vec(inner, 4);
 }
 
-const type::Matrix* Manager::mat(const type::Type* inner, uint32_t cols, uint32_t rows) {
-    return Get<type::Matrix>(vec(inner, rows), cols);
+const core::type::Matrix* Manager::mat(const core::type::Type* inner,
+                                       uint32_t cols,
+                                       uint32_t rows) {
+    return Get<core::type::Matrix>(vec(inner, rows), cols);
 }
 
-const type::Matrix* Manager::mat(const type::Vector* column_type, uint32_t cols) {
-    return Get<type::Matrix>(column_type, cols);
+const core::type::Matrix* Manager::mat(const core::type::Vector* column_type, uint32_t cols) {
+    return Get<core::type::Matrix>(column_type, cols);
 }
 
-const type::Matrix* Manager::mat2x2(const type::Type* inner) {
+const core::type::Matrix* Manager::mat2x2(const core::type::Type* inner) {
     return mat(inner, 2, 2);
 }
 
-const type::Matrix* Manager::mat2x3(const type::Type* inner) {
+const core::type::Matrix* Manager::mat2x3(const core::type::Type* inner) {
     return mat(inner, 2, 3);
 }
 
-const type::Matrix* Manager::mat2x4(const type::Type* inner) {
+const core::type::Matrix* Manager::mat2x4(const core::type::Type* inner) {
     return mat(inner, 2, 4);
 }
 
-const type::Matrix* Manager::mat3x2(const type::Type* inner) {
+const core::type::Matrix* Manager::mat3x2(const core::type::Type* inner) {
     return mat(inner, 3, 2);
 }
 
-const type::Matrix* Manager::mat3x3(const type::Type* inner) {
+const core::type::Matrix* Manager::mat3x3(const core::type::Type* inner) {
     return mat(inner, 3, 3);
 }
 
-const type::Matrix* Manager::mat3x4(const type::Type* inner) {
+const core::type::Matrix* Manager::mat3x4(const core::type::Type* inner) {
     return mat(inner, 3, 4);
 }
 
-const type::Matrix* Manager::mat4x2(const type::Type* inner) {
+const core::type::Matrix* Manager::mat4x2(const core::type::Type* inner) {
     return mat(inner, 4, 2);
 }
 
-const type::Matrix* Manager::mat4x3(const type::Type* inner) {
+const core::type::Matrix* Manager::mat4x3(const core::type::Type* inner) {
     return mat(inner, 4, 3);
 }
 
-const type::Matrix* Manager::mat4x4(const type::Type* inner) {
+const core::type::Matrix* Manager::mat4x4(const core::type::Type* inner) {
     return mat(inner, 4, 4);
 }
 
-const type::Array* Manager::array(const type::Type* elem_ty,
-                                  uint32_t count,
-                                  uint32_t stride /* = 0*/) {
+const core::type::Array* Manager::array(const core::type::Type* elem_ty,
+                                        uint32_t count,
+                                        uint32_t stride /* = 0*/) {
     uint32_t implicit_stride = tint::RoundUp(elem_ty->Align(), elem_ty->Size());
     if (stride == 0) {
         stride = implicit_stride;
     }
     TINT_ASSERT(stride >= implicit_stride);
 
-    return Get<type::Array>(/* element type */ elem_ty,
-                            /* element count */ Get<ConstantArrayCount>(count),
-                            /* array alignment */ elem_ty->Align(),
-                            /* array size */ count * stride,
-                            /* element stride */ stride,
-                            /* implicit stride */ implicit_stride);
+    return Get<core::type::Array>(/* element type */ elem_ty,
+                                  /* element count */ Get<ConstantArrayCount>(count),
+                                  /* array alignment */ elem_ty->Align(),
+                                  /* array size */ count * stride,
+                                  /* element stride */ stride,
+                                  /* implicit stride */ implicit_stride);
 }
 
-const type::Array* Manager::runtime_array(const type::Type* elem_ty, uint32_t stride /* = 0 */) {
+const core::type::Array* Manager::runtime_array(const core::type::Type* elem_ty,
+                                                uint32_t stride /* = 0 */) {
     if (stride == 0) {
         stride = elem_ty->Align();
     }
-    return Get<type::Array>(
+    return Get<core::type::Array>(
         /* element type */ elem_ty,
         /* element count */ Get<RuntimeArrayCount>(),
         /* array alignment */ elem_ty->Align(),
@@ -170,27 +173,27 @@
         /* implicit stride */ elem_ty->Align());
 }
 
-const type::Pointer* Manager::ptr(core::AddressSpace address_space,
-                                  const type::Type* subtype,
-                                  core::Access access /* = core::Access::kReadWrite */) {
-    return Get<type::Pointer>(address_space, subtype, access);
+const core::type::Pointer* Manager::ptr(core::AddressSpace address_space,
+                                        const core::type::Type* subtype,
+                                        core::Access access /* = core::Access::kReadWrite */) {
+    return Get<core::type::Pointer>(address_space, subtype, access);
 }
 
-type::Struct* Manager::Struct(Symbol name, VectorRef<StructMemberDesc> md) {
-    tint::Vector<const type::StructMember*, 4> members;
+core::type::Struct* Manager::Struct(Symbol name, VectorRef<StructMemberDesc> md) {
+    tint::Vector<const core::type::StructMember*, 4> members;
     uint32_t current_size = 0u;
     uint32_t max_align = 0u;
     for (const auto& m : md) {
         uint32_t index = static_cast<uint32_t>(members.Length());
         uint32_t align = std::max<uint32_t>(m.type->Align(), 1u);
         uint32_t offset = tint::RoundUp(align, current_size);
-        members.Push(Get<type::StructMember>(m.name, m.type, index, offset, align, m.type->Size(),
-                                             std::move(m.attributes)));
+        members.Push(Get<core::type::StructMember>(m.name, m.type, index, offset, align,
+                                                   m.type->Size(), std::move(m.attributes)));
         current_size = offset + m.type->Size();
         max_align = std::max(max_align, align);
     }
-    return Get<type::Struct>(name, members, max_align, tint::RoundUp(max_align, current_size),
-                             current_size);
+    return Get<core::type::Struct>(name, members, max_align, tint::RoundUp(max_align, current_size),
+                                   current_size);
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/manager.h b/src/tint/lang/core/type/manager.h
index 55def97..b3597d0 100644
--- a/src/tint/lang/core/type/manager.h
+++ b/src/tint/lang/core/type/manager.h
@@ -31,7 +31,7 @@
 #include "src/tint/utils/symbol/symbol.h"
 
 // Forward declarations
-namespace tint::type {
+namespace tint::core::type {
 class AbstractFloat;
 class AbstractInt;
 class Array;
@@ -44,9 +44,9 @@
 class U32;
 class Vector;
 class Void;
-}  // namespace tint::type
+}  // namespace tint::core::type
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// The type manager holds all the pointers to the known types.
 class Manager final {
@@ -86,28 +86,28 @@
 
     /// Constructs or returns an existing type, unique node or node
     /// @param args the arguments used to construct the type, unique node or node.
-    /// @tparam T a class deriving from type::Node, or a C-like type that's automatically translated
-    /// to the equivalent type node type. For example `Get<i32>()` is equivalent to
-    /// `Get<type::I32>()`
+    /// @tparam T a class deriving from core::type::Node, or a C-like type that's automatically
+    /// translated to the equivalent type node type. For example `Get<i32>()` is equivalent to
+    /// `Get<core::type::I32>()`
     /// @return a pointer to an instance of `T` with the provided arguments.
     /// If `T` derives from UniqueNode and an existing instance of `T` has been constructed, then
     /// the same pointer is returned.
     template <typename T, typename... ARGS>
     auto* Get(ARGS&&... args) {
         if constexpr (std::is_same_v<T, tint::AInt>) {
-            return Get<type::AbstractInt>(std::forward<ARGS>(args)...);
+            return Get<core::type::AbstractInt>(std::forward<ARGS>(args)...);
         } else if constexpr (std::is_same_v<T, tint::AFloat>) {
-            return Get<type::AbstractFloat>(std::forward<ARGS>(args)...);
+            return Get<core::type::AbstractFloat>(std::forward<ARGS>(args)...);
         } else if constexpr (std::is_same_v<T, tint::i32>) {
-            return Get<type::I32>(std::forward<ARGS>(args)...);
+            return Get<core::type::I32>(std::forward<ARGS>(args)...);
         } else if constexpr (std::is_same_v<T, tint::u32>) {
-            return Get<type::U32>(std::forward<ARGS>(args)...);
+            return Get<core::type::U32>(std::forward<ARGS>(args)...);
         } else if constexpr (std::is_same_v<T, tint::f32>) {
-            return Get<type::F32>(std::forward<ARGS>(args)...);
+            return Get<core::type::F32>(std::forward<ARGS>(args)...);
         } else if constexpr (std::is_same_v<T, tint::f16>) {
-            return Get<type::F16>(std::forward<ARGS>(args)...);
+            return Get<core::type::F16>(std::forward<ARGS>(args)...);
         } else if constexpr (std::is_same_v<T, bool>) {
-            return Get<type::Bool>(std::forward<ARGS>(args)...);
+            return Get<core::type::Bool>(std::forward<ARGS>(args)...);
         } else if constexpr (core::fluent_types::IsVector<T>) {
             return vec<typename T::type, T::width>(std::forward<ARGS>(args)...);
         } else if constexpr (core::fluent_types::IsMatrix<T>) {
@@ -136,67 +136,67 @@
     }
 
     /// @returns a void type
-    const type::Void* void_();
+    const core::type::Void* void_();
 
     /// @returns a bool type
-    const type::Bool* bool_();
+    const core::type::Bool* bool_();
 
     /// @returns an i32 type
-    const type::I32* i32();
+    const core::type::I32* i32();
 
     /// @returns a u32 type
-    const type::U32* u32();
+    const core::type::U32* u32();
 
     /// @returns an f32 type
-    const type::F32* f32();
+    const core::type::F32* f32();
 
     /// @returns an f16 type
-    const type::F16* f16();
+    const core::type::F16* f16();
 
     /// @returns a abstract-float type
-    const type::AbstractFloat* AFloat();
+    const core::type::AbstractFloat* AFloat();
 
     /// @returns a abstract-int type
-    const type::AbstractInt* AInt();
+    const core::type::AbstractInt* AInt();
 
     /// @param inner the inner type
     /// @returns an atomic type with the element type @p inner
-    const type::Atomic* atomic(const type::Type* inner);
+    const core::type::Atomic* atomic(const core::type::Type* inner);
 
     /// @tparam T the element type
     /// @returns the atomic type
     template <typename T>
-    const type::Atomic* atomic() {
+    const core::type::Atomic* atomic() {
         return atomic(Get<T>());
     }
 
     /// @param inner the inner type
     /// @param size the vector size
     /// @returns the vector type
-    const type::Vector* packed_vec(const type::Type* inner, uint32_t size);
+    const core::type::Vector* packed_vec(const core::type::Type* inner, uint32_t size);
 
     /// @param inner the inner type
     /// @param size the vector size
     /// @returns the vector type
-    const type::Vector* vec(const type::Type* inner, uint32_t size);
+    const core::type::Vector* vec(const core::type::Type* inner, uint32_t size);
 
     /// @param inner the inner type
     /// @returns a vec2 type with the element type @p inner
-    const type::Vector* vec2(const type::Type* inner);
+    const core::type::Vector* vec2(const core::type::Type* inner);
 
     /// @param inner the inner type
     /// @returns a vec3 type with the element type @p inner
-    const type::Vector* vec3(const type::Type* inner);
+    const core::type::Vector* vec3(const core::type::Type* inner);
 
     /// @param inner the inner type
     /// @returns a vec4 type with the element type @p inner
-    const type::Vector* vec4(const type::Type* inner);
+    const core::type::Vector* vec4(const core::type::Type* inner);
 
     /// @tparam T the element type
     /// @tparam N the vector width
     /// @returns the vector type
     template <typename T, size_t N>
-    const type::Vector* vec() {
+    const core::type::Vector* vec() {
         TINT_BEGIN_DISABLE_WARNING(UNREACHABLE_CODE);
         static_assert(N >= 2 && N <= 4);
         switch (N) {
@@ -214,21 +214,21 @@
     /// @tparam T the element type
     /// @returns a vec2 with the element type `T`
     template <typename T>
-    const type::Vector* vec2() {
+    const core::type::Vector* vec2() {
         return vec2(Get<T>());
     }
 
     /// @tparam T the element type
     /// @returns a vec2 with the element type `T`
     template <typename T>
-    const type::Vector* vec3() {
+    const core::type::Vector* vec3() {
         return vec3(Get<T>());
     }
 
     /// @tparam T the element type
     /// @returns a vec2 with the element type `T`
     template <typename T>
-    const type::Vector* vec4() {
+    const core::type::Vector* vec4() {
         return vec4(Get<T>());
     }
 
@@ -236,109 +236,109 @@
     /// @param cols the number of columns
     /// @param rows the number of rows
     /// @returns the matrix type
-    const type::Matrix* mat(const type::Type* inner, uint32_t cols, uint32_t rows);
+    const core::type::Matrix* mat(const core::type::Type* inner, uint32_t cols, uint32_t rows);
 
     /// @param column_type the column vector type
     /// @param cols the number of columns
     /// @returns the matrix type
-    const type::Matrix* mat(const type::Vector* column_type, uint32_t cols);
+    const core::type::Matrix* mat(const core::type::Vector* column_type, uint32_t cols);
 
     /// @param inner the inner type
     /// @returns a mat2x2 with the element @p inner
-    const type::Matrix* mat2x2(const type::Type* inner);
+    const core::type::Matrix* mat2x2(const core::type::Type* inner);
 
     /// @tparam T the element type
     /// @returns a mat2x2 with the element type `T`
     template <typename T>
-    const type::Matrix* mat2x2() {
+    const core::type::Matrix* mat2x2() {
         return mat2x2(Get<T>());
     }
 
     /// @param inner the inner type
     /// @returns a mat2x3 with the element @p inner
-    const type::Matrix* mat2x3(const type::Type* inner);
+    const core::type::Matrix* mat2x3(const core::type::Type* inner);
 
     /// @tparam T the element type
     /// @returns a mat2x3 with the element type `T`
     template <typename T>
-    const type::Matrix* mat2x3() {
+    const core::type::Matrix* mat2x3() {
         return mat2x3(Get<T>());
     }
 
     /// @param inner the inner type
     /// @returns a mat2x4 with the element @p inner
-    const type::Matrix* mat2x4(const type::Type* inner);
+    const core::type::Matrix* mat2x4(const core::type::Type* inner);
 
     /// @tparam T the element type
     /// @returns a mat2x4 with the element type `T`
     template <typename T>
-    const type::Matrix* mat2x4() {
+    const core::type::Matrix* mat2x4() {
         return mat2x4(Get<T>());
     }
 
     /// @param inner the inner type
     /// @returns a mat3x2 with the element @p inner
-    const type::Matrix* mat3x2(const type::Type* inner);
+    const core::type::Matrix* mat3x2(const core::type::Type* inner);
 
     /// @tparam T the element type
     /// @returns a mat3x2 with the element type `T`
     template <typename T>
-    const type::Matrix* mat3x2() {
+    const core::type::Matrix* mat3x2() {
         return mat3x2(Get<T>());
     }
 
     /// @param inner the inner type
     /// @returns a mat3x3 with the element @p inner
-    const type::Matrix* mat3x3(const type::Type* inner);
+    const core::type::Matrix* mat3x3(const core::type::Type* inner);
 
     /// @tparam T the element type
     /// @returns a mat3x3 with the element type `T`
     template <typename T>
-    const type::Matrix* mat3x3() {
+    const core::type::Matrix* mat3x3() {
         return mat3x3(Get<T>());
     }
 
     /// @param inner the inner type
     /// @returns a mat3x4 with the element @p inner
-    const type::Matrix* mat3x4(const type::Type* inner);
+    const core::type::Matrix* mat3x4(const core::type::Type* inner);
 
     /// @tparam T the element type
     /// @returns a mat3x4 with the element type `T`
     template <typename T>
-    const type::Matrix* mat3x4() {
+    const core::type::Matrix* mat3x4() {
         return mat3x4(Get<T>());
     }
 
     /// @param inner the inner type
     /// @returns a mat4x2 with the element @p inner
-    const type::Matrix* mat4x2(const type::Type* inner);
+    const core::type::Matrix* mat4x2(const core::type::Type* inner);
 
     /// @tparam T the element type
     /// @returns a mat4x2 with the element type `T`
     template <typename T>
-    const type::Matrix* mat4x2() {
+    const core::type::Matrix* mat4x2() {
         return mat4x2(Get<T>());
     }
 
     /// @param inner the inner type
     /// @returns a mat4x3 with the element @p inner
-    const type::Matrix* mat4x3(const type::Type* inner);
+    const core::type::Matrix* mat4x3(const core::type::Type* inner);
 
     /// @tparam T the element type
     /// @returns a mat4x3 with the element type `T`
     template <typename T>
-    const type::Matrix* mat4x3() {
+    const core::type::Matrix* mat4x3() {
         return mat4x3(Get<T>());
     }
 
     /// @param inner the inner type
     /// @returns a mat4x4 with the element @p inner
-    const type::Matrix* mat4x4(const type::Type* inner);
+    const core::type::Matrix* mat4x4(const core::type::Type* inner);
 
     /// @tparam T the element type
     /// @returns a mat4x4 with the element type `T`
     template <typename T>
-    const type::Matrix* mat4x4() {
+    const core::type::Matrix* mat4x4() {
         return mat4x4(Get<T>());
     }
 
@@ -347,7 +347,7 @@
     /// @tparam T the element type
     /// @returns a matrix with the given number of columns and rows
     template <typename T>
-    const type::Matrix* mat(uint32_t columns, uint32_t rows) {
+    const core::type::Matrix* mat(uint32_t columns, uint32_t rows) {
         return mat(Get<T>(), columns, rows);
     }
 
@@ -356,7 +356,7 @@
     /// @tparam T the element type
     /// @returns a matrix with the given number of columns and rows
     template <uint32_t C, uint32_t R, typename T>
-    const type::Matrix* mat() {
+    const core::type::Matrix* mat() {
         return mat(Get<T>(), C, R);
     }
 
@@ -364,19 +364,21 @@
     /// @param count the array element count
     /// @param stride the optional array element stride
     /// @returns the array type
-    const type::Array* array(const type::Type* elem_ty, uint32_t count, uint32_t stride = 0);
+    const core::type::Array* array(const core::type::Type* elem_ty,
+                                   uint32_t count,
+                                   uint32_t stride = 0);
 
     /// @param elem_ty the array element type
     /// @param stride the optional array element stride
     /// @returns the runtime array type
-    const type::Array* runtime_array(const type::Type* elem_ty, uint32_t stride = 0);
+    const core::type::Array* runtime_array(const core::type::Type* elem_ty, uint32_t stride = 0);
 
     /// @returns an array type with the element type `T` and size `N`.
     /// @tparam T the element type
     /// @tparam N the array length. If zero, then constructs a runtime-sized array.
     /// @param stride the optional array element stride
     template <typename T, size_t N = 0>
-    const type::Array* array(uint32_t stride = 0) {
+    const core::type::Array* array(uint32_t stride = 0) {
         if constexpr (N == 0) {
             return runtime_array(Get<T>(), stride);
         } else {
@@ -388,16 +390,16 @@
     /// @param subtype the pointer subtype
     /// @param access the access settings
     /// @returns the pointer type
-    const type::Pointer* ptr(core::AddressSpace address_space,
-                             const type::Type* subtype,
-                             core::Access access = core::Access::kReadWrite);
+    const core::type::Pointer* ptr(core::AddressSpace address_space,
+                                   const core::type::Type* subtype,
+                                   core::Access access = core::Access::kReadWrite);
 
     /// @tparam SPACE the address space
     /// @tparam T the storage type
     /// @tparam ACCESS the access mode
     /// @returns the pointer type with the templated address space, storage type and access.
     template <core::AddressSpace SPACE, typename T, core::Access ACCESS = core::Access::kReadWrite>
-    const type::Pointer* ptr() {
+    const core::type::Pointer* ptr() {
         return ptr(SPACE, Get<T>(), ACCESS);
     }
 
@@ -406,16 +408,18 @@
     /// @tparam ACCESS the access mode
     /// @returns the pointer type with the templated address space, storage type and access.
     template <core::AddressSpace SPACE, core::Access ACCESS = core::Access::kReadWrite>
-    const type::Pointer* ptr(const type::Type* subtype) {
+    const core::type::Pointer* ptr(const core::type::Type* subtype) {
         return ptr(SPACE, subtype, ACCESS);
     }
 
     /// @returns the sampler type
-    const type::Sampler* sampler() { return Get<type::Sampler>(type::SamplerKind::kSampler); }
+    const core::type::Sampler* sampler() {
+        return Get<core::type::Sampler>(core::type::SamplerKind::kSampler);
+    }
 
     /// @returns the comparison sampler type
-    const type::Sampler* comparison_sampler() {
-        return Get<type::Sampler>(type::SamplerKind::kComparisonSampler);
+    const core::type::Sampler* comparison_sampler() {
+        return Get<core::type::Sampler>(core::type::SamplerKind::kComparisonSampler);
     }
 
     /// A structure member descriptor.
@@ -423,22 +427,22 @@
         /// The name of the struct member.
         Symbol name;
         /// The type of the struct member.
-        const type::Type* type = nullptr;
+        const core::type::Type* type = nullptr;
         /// The optional struct member attributes.
-        type::StructMemberAttributes attributes = {};
+        core::type::StructMemberAttributes attributes = {};
     };
 
     /// Create a new structure declaration.
     /// @param name the name of the structure
     /// @param members the list of structure member descriptors
     /// @returns the structure type
-    type::Struct* Struct(Symbol name, VectorRef<StructMemberDesc> members);
+    core::type::Struct* Struct(Symbol name, VectorRef<StructMemberDesc> members);
 
     /// Create a new structure declaration.
     /// @param name the name of the structure
     /// @param members the list of structure member descriptors
     /// @returns the structure type
-    type::Struct* Struct(Symbol name, std::initializer_list<StructMemberDesc> members) {
+    core::type::Struct* Struct(Symbol name, std::initializer_list<StructMemberDesc> members) {
         return Struct(name, tint::Vector<StructMemberDesc, 4>(members));
     }
 
@@ -449,7 +453,7 @@
 
   private:
     /// ToType<T> is specialized for various `T` types and each specialization contains a single
-    /// `type` alias to the corresponding type deriving from `type::Type`.
+    /// `type` alias to the corresponding type deriving from `core::type::Type`.
     template <typename T>
     struct ToTypeImpl {
         using type = T;
@@ -466,6 +470,6 @@
     BlockAllocator<Node> nodes_;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_MANAGER_H_
diff --git a/src/tint/lang/core/type/manager_test.cc b/src/tint/lang/core/type/manager_test.cc
index 23f58f5..d22b6bc 100644
--- a/src/tint/lang/core/type/manager_test.cc
+++ b/src/tint/lang/core/type/manager_test.cc
@@ -21,7 +21,7 @@
 #include "src/tint/lang/core/type/i32.h"
 #include "src/tint/lang/core/type/u32.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 template <typename T>
@@ -112,4 +112,4 @@
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/matrix.cc b/src/tint/lang/core/type/matrix.cc
index 59e006a..6137170 100644
--- a/src/tint/lang/core/type/matrix.cc
+++ b/src/tint/lang/core/type/matrix.cc
@@ -21,13 +21,13 @@
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::Matrix);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::Matrix);
 
-namespace tint::type {
+namespace tint::core::type {
 
 Matrix::Matrix(const Vector* column_type, uint32_t columns)
     : Base(Hash(tint::TypeInfo::Of<Vector>().full_hashcode, columns, column_type),
-           type::Flags{
+           core::type::Flags{
                Flag::kConstructable,
                Flag::kCreationFixedFootprint,
                Flag::kFixedFootprint,
@@ -83,4 +83,4 @@
     return ctx.dst.mgr->Get<Matrix>(col_ty, columns_);
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/matrix.h b/src/tint/lang/core/type/matrix.h
index 2a9cda5..080a2f3 100644
--- a/src/tint/lang/core/type/matrix.h
+++ b/src/tint/lang/core/type/matrix.h
@@ -20,11 +20,11 @@
 #include "src/tint/lang/core/type/vector.h"
 
 // Forward declarations
-namespace tint::type {
+namespace tint::core::type {
 class Vector;
-}  // namespace tint::type
+}  // namespace tint::core::type
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A matrix type
 class Matrix final : public Castable<Matrix, Type> {
@@ -83,6 +83,6 @@
     const uint32_t columns_;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_MATRIX_H_
diff --git a/src/tint/lang/core/type/matrix_test.cc b/src/tint/lang/core/type/matrix_test.cc
index 914ade6..079b0e3 100644
--- a/src/tint/lang/core/type/matrix_test.cc
+++ b/src/tint/lang/core/type/matrix_test.cc
@@ -15,7 +15,7 @@
 #include "src/tint/lang/core/type/helper_test.h"
 #include "src/tint/lang/core/type/texture.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using MatrixTest = TestHelper;
@@ -68,8 +68,8 @@
 TEST_F(MatrixTest, Clone) {
     auto* a = create<Matrix>(create<Vector>(create<I32>(), 3u), 4u);
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* mat = a->Clone(ctx);
     EXPECT_TRUE(mat->type()->Is<I32>());
@@ -78,4 +78,4 @@
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/multisampled_texture.cc b/src/tint/lang/core/type/multisampled_texture.cc
index 20b9da3..8a93f86 100644
--- a/src/tint/lang/core/type/multisampled_texture.cc
+++ b/src/tint/lang/core/type/multisampled_texture.cc
@@ -21,9 +21,9 @@
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::MultisampledTexture);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::MultisampledTexture);
 
-namespace tint::type {
+namespace tint::core::type {
 
 MultisampledTexture::MultisampledTexture(TextureDimension dim, const Type* type)
     : Base(Hash(tint::TypeInfo::Of<MultisampledTexture>().full_hashcode, dim, type), dim),
@@ -51,4 +51,4 @@
     return ctx.dst.mgr->Get<MultisampledTexture>(dim(), ty);
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/multisampled_texture.h b/src/tint/lang/core/type/multisampled_texture.h
index 0a37556..017ad69 100644
--- a/src/tint/lang/core/type/multisampled_texture.h
+++ b/src/tint/lang/core/type/multisampled_texture.h
@@ -20,7 +20,7 @@
 #include "src/tint/lang/core/type/texture.h"
 #include "src/tint/lang/core/type/texture_dimension.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A multisampled texture type.
 class MultisampledTexture final : public Castable<MultisampledTexture, Texture> {
@@ -52,6 +52,6 @@
     const Type* const type_;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_MULTISAMPLED_TEXTURE_H_
diff --git a/src/tint/lang/core/type/multisampled_texture_test.cc b/src/tint/lang/core/type/multisampled_texture_test.cc
index fcbd1d3..4a893b3 100644
--- a/src/tint/lang/core/type/multisampled_texture_test.cc
+++ b/src/tint/lang/core/type/multisampled_texture_test.cc
@@ -21,7 +21,7 @@
 #include "src/tint/lang/core/type/storage_texture.h"
 #include "src/tint/lang/core/type/texture_dimension.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using MultisampledTextureTest = TestHelper;
@@ -85,8 +85,8 @@
 TEST_F(MultisampledTextureTest, Clone) {
     auto* a = create<MultisampledTexture>(TextureDimension::k2d, create<F32>());
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* mt = a->Clone(ctx);
     EXPECT_EQ(mt->dim(), TextureDimension::k2d);
@@ -94,4 +94,4 @@
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/node.cc b/src/tint/lang/core/type/node.cc
index 7b04892..5735efd 100644
--- a/src/tint/lang/core/type/node.cc
+++ b/src/tint/lang/core/type/node.cc
@@ -14,9 +14,9 @@
 
 #include "src/tint/lang/core/type/node.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::Node);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::Node);
 
-namespace tint::type {
+namespace tint::core::type {
 
 Node::Node() = default;
 
@@ -24,4 +24,4 @@
 
 Node::~Node() = default;
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/node.h b/src/tint/lang/core/type/node.h
index d4addf4..2cb4bdc 100644
--- a/src/tint/lang/core/type/node.h
+++ b/src/tint/lang/core/type/node.h
@@ -17,7 +17,7 @@
 
 #include "src/tint/utils/rtti/castable.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// Node is the base class for all type nodes
 class Node : public Castable<Node> {
@@ -32,6 +32,6 @@
     ~Node() override;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_NODE_H_
diff --git a/src/tint/lang/core/type/numeric_scalar.cc b/src/tint/lang/core/type/numeric_scalar.cc
index bce6b92..9813f4c 100644
--- a/src/tint/lang/core/type/numeric_scalar.cc
+++ b/src/tint/lang/core/type/numeric_scalar.cc
@@ -14,12 +14,12 @@
 
 #include "src/tint/lang/core/type/numeric_scalar.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::NumericScalar);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::NumericScalar);
 
-namespace tint::type {
+namespace tint::core::type {
 
-NumericScalar::NumericScalar(size_t hash, type::Flags flags) : Base(hash, flags) {}
+NumericScalar::NumericScalar(size_t hash, core::type::Flags flags) : Base(hash, flags) {}
 
 NumericScalar::~NumericScalar() = default;
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/numeric_scalar.h b/src/tint/lang/core/type/numeric_scalar.h
index 987921a..cdcd3fc 100644
--- a/src/tint/lang/core/type/numeric_scalar.h
+++ b/src/tint/lang/core/type/numeric_scalar.h
@@ -17,7 +17,7 @@
 
 #include "src/tint/lang/core/type/scalar.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// Base class for all numeric-scalar types
 /// @see https://www.w3.org/TR/WGSL/#scalar-types
@@ -30,9 +30,9 @@
     /// Constructor
     /// @param hash the immutable hash for the node
     /// @param flags the flags of this type
-    NumericScalar(size_t hash, type::Flags flags);
+    NumericScalar(size_t hash, core::type::Flags flags);
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_NUMERIC_SCALAR_H_
diff --git a/src/tint/lang/core/type/pointer.cc b/src/tint/lang/core/type/pointer.cc
index c89f25c..c73c0fa 100644
--- a/src/tint/lang/core/type/pointer.cc
+++ b/src/tint/lang/core/type/pointer.cc
@@ -21,13 +21,13 @@
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::Pointer);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::Pointer);
 
-namespace tint::type {
+namespace tint::core::type {
 
 Pointer::Pointer(core::AddressSpace address_space, const Type* subtype, core::Access access)
     : Base(Hash(tint::TypeInfo::Of<Pointer>().full_hashcode, address_space, subtype, access),
-           type::Flags{}),
+           core::type::Flags{}),
       subtype_(subtype),
       address_space_(address_space),
       access_(access) {
@@ -61,4 +61,4 @@
     return ctx.dst.mgr->Get<Pointer>(address_space_, ty, access_);
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/pointer.h b/src/tint/lang/core/type/pointer.h
index ec3b673..69e5b80 100644
--- a/src/tint/lang/core/type/pointer.h
+++ b/src/tint/lang/core/type/pointer.h
@@ -21,7 +21,7 @@
 #include "src/tint/lang/core/address_space.h"
 #include "src/tint/lang/core/type/type.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A pointer type.
 class Pointer final : public Castable<Pointer, Type> {
@@ -62,6 +62,6 @@
     core::Access const access_;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_POINTER_H_
diff --git a/src/tint/lang/core/type/pointer_test.cc b/src/tint/lang/core/type/pointer_test.cc
index 1649f5c..b937f77 100644
--- a/src/tint/lang/core/type/pointer_test.cc
+++ b/src/tint/lang/core/type/pointer_test.cc
@@ -16,7 +16,7 @@
 #include "src/tint/lang/core/type/helper_test.h"
 #include "src/tint/lang/core/type/texture.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using PointerTest = TestHelper;
@@ -83,8 +83,8 @@
     auto* a =
         create<Pointer>(core::AddressSpace::kStorage, create<I32>(), core::Access::kReadWrite);
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* ptr = a->Clone(ctx);
     EXPECT_TRUE(ptr->StoreType()->Is<I32>());
@@ -93,4 +93,4 @@
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/reference.cc b/src/tint/lang/core/type/reference.cc
index 69e0a26..572a53a 100644
--- a/src/tint/lang/core/type/reference.cc
+++ b/src/tint/lang/core/type/reference.cc
@@ -20,13 +20,13 @@
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::Reference);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::Reference);
 
-namespace tint::type {
+namespace tint::core::type {
 
 Reference::Reference(core::AddressSpace address_space, const Type* subtype, core::Access access)
     : Base(Hash(tint::TypeInfo::Of<Reference>().full_hashcode, address_space, subtype, access),
-           type::Flags{}),
+           core::type::Flags{}),
       subtype_(subtype),
       address_space_(address_space),
       access_(access) {
@@ -60,4 +60,4 @@
     return ctx.dst.mgr->Get<Reference>(address_space_, ty, access_);
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/reference.h b/src/tint/lang/core/type/reference.h
index 237db67..f1f2420 100644
--- a/src/tint/lang/core/type/reference.h
+++ b/src/tint/lang/core/type/reference.h
@@ -21,7 +21,7 @@
 #include "src/tint/lang/core/address_space.h"
 #include "src/tint/lang/core/type/type.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A reference type.
 class Reference final : public Castable<Reference, Type> {
@@ -62,6 +62,6 @@
     core::Access const access_;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_REFERENCE_H_
diff --git a/src/tint/lang/core/type/reference_test.cc b/src/tint/lang/core/type/reference_test.cc
index a5427fe..7aa1aab 100644
--- a/src/tint/lang/core/type/reference_test.cc
+++ b/src/tint/lang/core/type/reference_test.cc
@@ -16,7 +16,7 @@
 #include "src/tint/lang/core/address_space.h"
 #include "src/tint/lang/core/type/helper_test.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using ReferenceTest = TestHelper;
@@ -83,8 +83,8 @@
     auto* a =
         create<Reference>(core::AddressSpace::kStorage, create<I32>(), core::Access::kReadWrite);
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* ref = a->Clone(ctx);
     EXPECT_TRUE(ref->StoreType()->Is<I32>());
@@ -93,4 +93,4 @@
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/sampled_texture.cc b/src/tint/lang/core/type/sampled_texture.cc
index 297287b..8865ec8 100644
--- a/src/tint/lang/core/type/sampled_texture.cc
+++ b/src/tint/lang/core/type/sampled_texture.cc
@@ -21,9 +21,9 @@
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::SampledTexture);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::SampledTexture);
 
-namespace tint::type {
+namespace tint::core::type {
 
 SampledTexture::SampledTexture(TextureDimension dim, const Type* type)
     : Base(Hash(TypeInfo::Of<SampledTexture>().full_hashcode, dim, type), dim), type_(type) {
@@ -50,4 +50,4 @@
     return ctx.dst.mgr->Get<SampledTexture>(dim(), ty);
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/sampled_texture.h b/src/tint/lang/core/type/sampled_texture.h
index d22c81f..42191b5 100644
--- a/src/tint/lang/core/type/sampled_texture.h
+++ b/src/tint/lang/core/type/sampled_texture.h
@@ -20,7 +20,7 @@
 #include "src/tint/lang/core/type/texture.h"
 #include "src/tint/lang/core/type/texture_dimension.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A sampled texture type.
 class SampledTexture final : public Castable<SampledTexture, Texture> {
@@ -52,6 +52,6 @@
     const Type* const type_;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_SAMPLED_TEXTURE_H_
diff --git a/src/tint/lang/core/type/sampled_texture_test.cc b/src/tint/lang/core/type/sampled_texture_test.cc
index 375e423..0a65228 100644
--- a/src/tint/lang/core/type/sampled_texture_test.cc
+++ b/src/tint/lang/core/type/sampled_texture_test.cc
@@ -20,7 +20,7 @@
 #include "src/tint/lang/core/type/storage_texture.h"
 #include "src/tint/lang/core/type/texture_dimension.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using SampledTextureTest = TestHelper;
@@ -89,8 +89,8 @@
 TEST_F(SampledTextureTest, Clone) {
     auto* a = create<SampledTexture>(TextureDimension::kCube, create<F32>());
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* mt = a->Clone(ctx);
     EXPECT_EQ(mt->dim(), TextureDimension::kCube);
@@ -98,4 +98,4 @@
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/sampler.cc b/src/tint/lang/core/type/sampler.cc
index ffdaaa2..0ceaeed 100644
--- a/src/tint/lang/core/type/sampler.cc
+++ b/src/tint/lang/core/type/sampler.cc
@@ -17,12 +17,13 @@
 #include "src/tint/lang/core/type/manager.h"
 #include "src/tint/utils/math/hash.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::Sampler);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::Sampler);
 
-namespace tint::type {
+namespace tint::core::type {
 
 Sampler::Sampler(SamplerKind kind)
-    : Base(Hash(tint::TypeInfo::Of<Sampler>().full_hashcode, kind), type::Flags{}), kind_(kind) {}
+    : Base(Hash(tint::TypeInfo::Of<Sampler>().full_hashcode, kind), core::type::Flags{}),
+      kind_(kind) {}
 
 Sampler::~Sampler() = default;
 
@@ -41,4 +42,4 @@
     return ctx.dst.mgr->Get<Sampler>(kind_);
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/sampler.h b/src/tint/lang/core/type/sampler.h
index 9946731..9487152 100644
--- a/src/tint/lang/core/type/sampler.h
+++ b/src/tint/lang/core/type/sampler.h
@@ -20,7 +20,7 @@
 #include "src/tint/lang/core/type/sampler_kind.h"
 #include "src/tint/lang/core/type/type.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A sampler type.
 class Sampler final : public Castable<Sampler, Type> {
@@ -54,6 +54,6 @@
     SamplerKind const kind_;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_SAMPLER_H_
diff --git a/src/tint/lang/core/type/sampler_kind.cc b/src/tint/lang/core/type/sampler_kind.cc
index 17e950c..5019ba9 100644
--- a/src/tint/lang/core/type/sampler_kind.cc
+++ b/src/tint/lang/core/type/sampler_kind.cc
@@ -14,7 +14,7 @@
 
 #include "src/tint/lang/core/type/sampler_kind.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 std::string_view ToString(SamplerKind kind) {
     switch (kind) {
@@ -26,4 +26,4 @@
     return "<unknown>";
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/sampler_kind.h b/src/tint/lang/core/type/sampler_kind.h
index fed81c2..5b58e13 100644
--- a/src/tint/lang/core/type/sampler_kind.h
+++ b/src/tint/lang/core/type/sampler_kind.h
@@ -18,7 +18,7 @@
 #include "src/tint/utils/text/string_stream.h"
 #include "src/tint/utils/traits/traits.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// The different kinds of samplers
 enum class SamplerKind {
@@ -40,6 +40,6 @@
     return out << ToString(kind);
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_SAMPLER_KIND_H_
diff --git a/src/tint/lang/core/type/sampler_test.cc b/src/tint/lang/core/type/sampler_test.cc
index 7b9657f..fb51867 100644
--- a/src/tint/lang/core/type/sampler_test.cc
+++ b/src/tint/lang/core/type/sampler_test.cc
@@ -16,7 +16,7 @@
 #include "src/tint/lang/core/type/helper_test.h"
 #include "src/tint/lang/core/type/texture.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using SamplerTest = TestHelper;
@@ -66,12 +66,12 @@
 TEST_F(SamplerTest, Clone) {
     auto* a = create<Sampler>(SamplerKind::kSampler);
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* mt = a->Clone(ctx);
     EXPECT_EQ(mt->kind(), SamplerKind::kSampler);
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/scalar.cc b/src/tint/lang/core/type/scalar.cc
index b6b9650..1536e21 100644
--- a/src/tint/lang/core/type/scalar.cc
+++ b/src/tint/lang/core/type/scalar.cc
@@ -14,11 +14,11 @@
 
 #include "src/tint/lang/core/type/scalar.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::Scalar);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::Scalar);
 
-namespace tint::type {
+namespace tint::core::type {
 
-Scalar::Scalar(size_t hash, type::Flags flags) : Base(hash, flags) {}
+Scalar::Scalar(size_t hash, core::type::Flags flags) : Base(hash, flags) {}
 
 Scalar::~Scalar() = default;
 
@@ -26,4 +26,4 @@
     return &other.TypeInfo() == &TypeInfo();
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/scalar.h b/src/tint/lang/core/type/scalar.h
index bbcd046..ac6d81b 100644
--- a/src/tint/lang/core/type/scalar.h
+++ b/src/tint/lang/core/type/scalar.h
@@ -17,7 +17,7 @@
 
 #include "src/tint/lang/core/type/type.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// Base class for all scalar types
 /// @see https://www.w3.org/TR/WGSL/#scalar-types
@@ -34,9 +34,9 @@
     /// Constructor
     /// @param hash the immutable hash for the node
     /// @param flags the flags of this type
-    Scalar(size_t hash, type::Flags flags);
+    Scalar(size_t hash, core::type::Flags flags);
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_SCALAR_H_
diff --git a/src/tint/lang/core/type/storage_texture.cc b/src/tint/lang/core/type/storage_texture.cc
index 0e766c5..f1d7204 100644
--- a/src/tint/lang/core/type/storage_texture.cc
+++ b/src/tint/lang/core/type/storage_texture.cc
@@ -21,9 +21,9 @@
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::StorageTexture);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::StorageTexture);
 
-namespace tint::type {
+namespace tint::core::type {
 
 StorageTexture::StorageTexture(TextureDimension dim,
                                core::TexelFormat format,
@@ -89,4 +89,4 @@
     return ctx.dst.mgr->Get<StorageTexture>(dim(), texel_format_, access_, ty);
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/storage_texture.h b/src/tint/lang/core/type/storage_texture.h
index 550973d..491e7fa 100644
--- a/src/tint/lang/core/type/storage_texture.h
+++ b/src/tint/lang/core/type/storage_texture.h
@@ -23,11 +23,11 @@
 #include "src/tint/lang/core/type/texture_dimension.h"
 
 // Forward declarations
-namespace tint::type {
+namespace tint::core::type {
 class Manager;
-}  // namespace tint::type
+}  // namespace tint::core::type
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A storage texture type.
 class StorageTexture final : public Castable<StorageTexture, Texture> {
@@ -77,6 +77,6 @@
     Type* const subtype_;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_STORAGE_TEXTURE_H_
diff --git a/src/tint/lang/core/type/storage_texture_test.cc b/src/tint/lang/core/type/storage_texture_test.cc
index 35a3b12..45f7776 100644
--- a/src/tint/lang/core/type/storage_texture_test.cc
+++ b/src/tint/lang/core/type/storage_texture_test.cc
@@ -20,7 +20,7 @@
 #include "src/tint/lang/core/type/sampled_texture.h"
 #include "src/tint/lang/core/type/texture_dimension.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 struct StorageTextureTest : public TestHelper {
@@ -137,8 +137,8 @@
     auto* a =
         Create(TextureDimension::kCube, core::TexelFormat::kRgba32Float, core::Access::kReadWrite);
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* mt = a->Clone(ctx);
     EXPECT_EQ(mt->dim(), TextureDimension::kCube);
@@ -147,4 +147,4 @@
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/struct.cc b/src/tint/lang/core/type/struct.cc
index 7792923..142196e 100644
--- a/src/tint/lang/core/type/struct.cc
+++ b/src/tint/lang/core/type/struct.cc
@@ -24,14 +24,14 @@
 #include "src/tint/utils/symbol/symbol_table.h"
 #include "src/tint/utils/text/string_stream.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::Struct);
-TINT_INSTANTIATE_TYPEINFO(tint::type::StructMember);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::Struct);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::StructMember);
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
-type::Flags FlagsFrom(VectorRef<const StructMember*> members) {
-    type::Flags flags{
+core::type::Flags FlagsFrom(VectorRef<const StructMember*> members) {
+    core::type::Flags flags{
         Flag::kConstructable,
         Flag::kCreationFixedFootprint,
         Flag::kFixedFootprint,
@@ -180,7 +180,7 @@
 }
 
 StructMember::StructMember(Symbol name,
-                           const type::Type* type,
+                           const core::type::Type* type,
                            uint32_t index,
                            uint32_t offset,
                            uint32_t align,
@@ -202,4 +202,4 @@
     return ctx.dst.mgr->Get<StructMember>(sym, ty, index_, offset_, align_, size_, attributes_);
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/struct.h b/src/tint/lang/core/type/struct.h
index 4bff0da..e19693f 100644
--- a/src/tint/lang/core/type/struct.h
+++ b/src/tint/lang/core/type/struct.h
@@ -30,11 +30,11 @@
 #include "src/tint/utils/symbol/symbol.h"
 
 // Forward declarations
-namespace tint::type {
+namespace tint::core::type {
 class StructMember;
-}  // namespace tint::type
+}  // namespace tint::core::type
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// Metadata to capture how a structure is used in a shader module.
 enum class PipelineStageUsage {
@@ -109,7 +109,7 @@
     uint32_t SizeNoPadding() const { return size_no_padding_; }
 
     /// @returns the structure flags
-    type::StructFlags StructFlags() const { return struct_flags_; }
+    core::type::StructFlags StructFlags() const { return struct_flags_; }
 
     /// Set a structure flag.
     /// @param flag the flag to set
@@ -181,7 +181,7 @@
     const uint32_t align_;
     const uint32_t size_;
     const uint32_t size_no_padding_;
-    type::StructFlags struct_flags_;
+    core::type::StructFlags struct_flags_;
     std::unordered_set<core::AddressSpace> address_space_usage_;
     std::unordered_set<PipelineStageUsage> pipeline_stage_uses_;
     tint::Vector<const Struct*, 2> concrete_types_;
@@ -213,7 +213,7 @@
     /// @param size the byte size of the member
     /// @param attributes the optional attributes
     StructMember(Symbol name,
-                 const type::Type* type,
+                 const core::type::Type* type,
                  uint32_t index,
                  uint32_t offset,
                  uint32_t align,
@@ -231,10 +231,10 @@
     void SetStruct(const Struct* s) { struct_ = s; }
 
     /// @returns the structure that owns this member
-    const type::Struct* Struct() const { return struct_; }
+    const core::type::Struct* Struct() const { return struct_; }
 
     /// @returns the type of the member
-    const type::Type* Type() const { return type_; }
+    const core::type::Type* Type() const { return type_; }
 
     /// @returns the member index
     uint32_t Index() const { return index_; }
@@ -261,8 +261,8 @@
 
   private:
     const Symbol name_;
-    const type::Struct* struct_;
-    const type::Type* type_;
+    const core::type::Struct* struct_;
+    const core::type::Type* type_;
     const uint32_t index_;
     const uint32_t offset_;
     const uint32_t align_;
@@ -270,6 +270,6 @@
     StructMemberAttributes attributes_;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_STRUCT_H_
diff --git a/src/tint/lang/core/type/struct_test.cc b/src/tint/lang/core/type/struct_test.cc
index 7a743fd..b6059a1 100644
--- a/src/tint/lang/core/type/struct_test.cc
+++ b/src/tint/lang/core/type/struct_test.cc
@@ -16,7 +16,7 @@
 #include "src/tint/lang/core/type/helper_test.h"
 #include "src/tint/lang/core/type/texture.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using namespace tint::number_suffixes;  // NOLINT
@@ -205,7 +205,7 @@
 }
 
 TEST_F(TypeStructTest, Clone) {
-    type::StructMemberAttributes attrs_location_2;
+    core::type::StructMemberAttributes attrs_location_2;
     attrs_location_2.location = 2;
 
     auto* s = create<Struct>(
@@ -213,14 +213,14 @@
         tint::Vector{create<StructMember>(Sym("b"), create<Vector>(create<F32>(), 3u), 0u, 0u, 16u,
                                           12u, attrs_location_2),
                      create<StructMember>(Sym("a"), create<I32>(), 1u, 16u, 4u, 4u,
-                                          type::StructMemberAttributes{})},
+                                          core::type::StructMemberAttributes{})},
         4u /* align */, 8u /* size */, 16u /* size_no_padding */);
 
     GenerationID id;
     SymbolTable new_st{id};
 
-    type::Manager mgr;
-    type::CloneContext ctx{{&Symbols()}, {&new_st, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{&Symbols()}, {&new_st, &mgr}};
 
     auto* st = s->Clone(ctx);
 
@@ -250,4 +250,4 @@
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/texture.cc b/src/tint/lang/core/type/texture.cc
index e6d711b..7240bd6 100644
--- a/src/tint/lang/core/type/texture.cc
+++ b/src/tint/lang/core/type/texture.cc
@@ -14,44 +14,44 @@
 
 #include "src/tint/lang/core/type/texture.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::Texture);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::Texture);
 
-namespace tint::type {
+namespace tint::core::type {
 
-Texture::Texture(size_t hash, TextureDimension dim) : Base(hash, type::Flags{}), dim_(dim) {}
+Texture::Texture(size_t hash, TextureDimension dim) : Base(hash, core::type::Flags{}), dim_(dim) {}
 
 Texture::~Texture() = default;
 
-bool IsTextureArray(type::TextureDimension dim) {
+bool IsTextureArray(core::type::TextureDimension dim) {
     switch (dim) {
-        case type::TextureDimension::k2dArray:
-        case type::TextureDimension::kCubeArray:
+        case core::type::TextureDimension::k2dArray:
+        case core::type::TextureDimension::kCubeArray:
             return true;
-        case type::TextureDimension::k2d:
-        case type::TextureDimension::kNone:
-        case type::TextureDimension::k1d:
-        case type::TextureDimension::k3d:
-        case type::TextureDimension::kCube:
+        case core::type::TextureDimension::k2d:
+        case core::type::TextureDimension::kNone:
+        case core::type::TextureDimension::k1d:
+        case core::type::TextureDimension::k3d:
+        case core::type::TextureDimension::kCube:
             return false;
     }
     return false;
 }
 
-int NumCoordinateAxes(type::TextureDimension dim) {
+int NumCoordinateAxes(core::type::TextureDimension dim) {
     switch (dim) {
-        case type::TextureDimension::kNone:
+        case core::type::TextureDimension::kNone:
             return 0;
-        case type::TextureDimension::k1d:
+        case core::type::TextureDimension::k1d:
             return 1;
-        case type::TextureDimension::k2d:
-        case type::TextureDimension::k2dArray:
+        case core::type::TextureDimension::k2d:
+        case core::type::TextureDimension::k2dArray:
             return 2;
-        case type::TextureDimension::k3d:
-        case type::TextureDimension::kCube:
-        case type::TextureDimension::kCubeArray:
+        case core::type::TextureDimension::k3d:
+        case core::type::TextureDimension::kCube:
+        case core::type::TextureDimension::kCubeArray:
             return 3;
     }
     return 0;
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/texture.h b/src/tint/lang/core/type/texture.h
index 792f9be..e94ef81 100644
--- a/src/tint/lang/core/type/texture.h
+++ b/src/tint/lang/core/type/texture.h
@@ -18,7 +18,7 @@
 #include "src/tint/lang/core/type/texture_dimension.h"
 #include "src/tint/lang/core/type/type.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A texture type.
 class Texture : public Castable<Texture, Type> {
@@ -39,7 +39,7 @@
 
 /// @param dim the type::TextureDimension to query
 /// @return true if the given type::TextureDimension is an array texture
-bool IsTextureArray(type::TextureDimension dim);
+bool IsTextureArray(core::type::TextureDimension dim);
 
 /// Returns the number of axes in the coordinate used for accessing
 /// the texture, where an access is one of: sampling, fetching, load,
@@ -53,8 +53,8 @@
 /// size, representing the (x,y) size of each cube face, in texels.
 /// @param dim the type::TextureDimension to query
 /// @return number of dimensions in a coordinate for the dimensionality
-int NumCoordinateAxes(type::TextureDimension dim);
+int NumCoordinateAxes(core::type::TextureDimension dim);
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_TEXTURE_H_
diff --git a/src/tint/lang/core/type/texture_dimension.cc b/src/tint/lang/core/type/texture_dimension.cc
index dc2ce79..a322ec7 100644
--- a/src/tint/lang/core/type/texture_dimension.cc
+++ b/src/tint/lang/core/type/texture_dimension.cc
@@ -14,26 +14,26 @@
 
 #include "src/tint/lang/core/type/texture_dimension.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
-std::string_view ToString(type::TextureDimension dim) {
+std::string_view ToString(core::type::TextureDimension dim) {
     switch (dim) {
-        case type::TextureDimension::kNone:
+        case core::type::TextureDimension::kNone:
             return "None";
-        case type::TextureDimension::k1d:
+        case core::type::TextureDimension::k1d:
             return "1d";
-        case type::TextureDimension::k2d:
+        case core::type::TextureDimension::k2d:
             return "2d";
-        case type::TextureDimension::k2dArray:
+        case core::type::TextureDimension::k2dArray:
             return "2d_array";
-        case type::TextureDimension::k3d:
+        case core::type::TextureDimension::k3d:
             return "3d";
-        case type::TextureDimension::kCube:
+        case core::type::TextureDimension::kCube:
             return "cube";
-        case type::TextureDimension::kCubeArray:
+        case core::type::TextureDimension::kCubeArray:
             return "cube_array";
     }
     return "<unknown>";
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/texture_dimension.h b/src/tint/lang/core/type/texture_dimension.h
index 1d5fd44..f77c796 100644
--- a/src/tint/lang/core/type/texture_dimension.h
+++ b/src/tint/lang/core/type/texture_dimension.h
@@ -18,7 +18,7 @@
 #include "src/tint/utils/text/string_stream.h"
 #include "src/tint/utils/traits/traits.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// The dimensionality of the texture
 enum class TextureDimension {
@@ -46,10 +46,10 @@
 /// @param dim the type::TextureDimension
 /// @return the stream so calls can be chained
 template <typename STREAM, typename = traits::EnableIfIsOStream<STREAM>>
-auto& operator<<(STREAM& out, type::TextureDimension dim) {
+auto& operator<<(STREAM& out, core::type::TextureDimension dim) {
     return out << ToString(dim);
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_TEXTURE_DIMENSION_H_
diff --git a/src/tint/lang/core/type/texture_test.cc b/src/tint/lang/core/type/texture_test.cc
index 55aa370..70f5ccf 100644
--- a/src/tint/lang/core/type/texture_test.cc
+++ b/src/tint/lang/core/type/texture_test.cc
@@ -17,7 +17,7 @@
 #include "src/tint/lang/core/type/helper_test.h"
 #include "src/tint/lang/core/type/sampled_texture.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using TextureTypeDimTest = TestParamHelper<TextureDimension>;
@@ -41,4 +41,4 @@
                                            TextureDimension::kCubeArray));
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/type.cc b/src/tint/lang/core/type/type.cc
index 3c5185f..9b99c5ad 100644
--- a/src/tint/lang/core/type/type.cc
+++ b/src/tint/lang/core/type/type.cc
@@ -31,11 +31,11 @@
 #include "src/tint/lang/core/type/vector.h"
 #include "src/tint/utils/rtti/switch.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::Type);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::Type);
 
-namespace tint::type {
+namespace tint::core::type {
 
-Type::Type(size_t hash, type::Flags flags) : Base(hash), flags_(flags) {
+Type::Type(size_t hash, core::type::Flags flags) : Base(hash), flags_(flags) {
     if (IsConstructible()) {
         TINT_ASSERT(HasCreationFixedFootprint());
     }
@@ -149,15 +149,15 @@
 }
 
 bool Type::is_numeric_vector() const {
-    return Is([](const Vector* v) { return v->type()->Is<type::NumericScalar>(); });
+    return Is([](const Vector* v) { return v->type()->Is<core::type::NumericScalar>(); });
 }
 
 bool Type::is_scalar_vector() const {
-    return Is([](const Vector* v) { return v->type()->Is<type::Scalar>(); });
+    return Is([](const Vector* v) { return v->type()->Is<core::type::Scalar>(); });
 }
 
 bool Type::is_numeric_scalar_or_vector() const {
-    return Is<type::NumericScalar>() || is_numeric_vector();
+    return Is<core::type::NumericScalar>() || is_numeric_vector();
 }
 
 bool Type::is_handle() const {
@@ -284,4 +284,4 @@
     return common;
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/type.h b/src/tint/lang/core/type/type.h
index 2c9acd8..bfeb9b6 100644
--- a/src/tint/lang/core/type/type.h
+++ b/src/tint/lang/core/type/type.h
@@ -28,11 +28,11 @@
 class ProgramBuilder;
 class SymbolTable;
 }  // namespace tint
-namespace tint::type {
+namespace tint::core::type {
 class Type;
-}  // namespace tint::type
+}  // namespace tint::core::type
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// Flag is an enumerator of type flag bits, used by Flags.
 enum Flag {
@@ -97,7 +97,7 @@
     virtual Type* Clone(CloneContext& ctx) const = 0;
 
     /// @returns the flags on the type
-    type::Flags Flags() { return flags_; }
+    core::type::Flags Flags() { return flags_; }
 
     /// @returns true if type is constructable
     /// https://gpuweb.github.io/gpuweb/wgsl/#constructible-types
@@ -228,31 +228,31 @@
     /// Constructor
     /// @param hash the immutable hash for the node
     /// @param flags the flags of this type
-    Type(size_t hash, type::Flags flags);
+    Type(size_t hash, core::type::Flags flags);
 
     /// The flags of this type.
-    const type::Flags flags_;
+    const core::type::Flags flags_;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 namespace std {
 
-/// std::hash specialization for tint::type::Type
+/// std::hash specialization for tint::core::type::Type
 template <>
-struct hash<tint::type::Type> {
+struct hash<tint::core::type::Type> {
     /// @param type the type to obtain a hash from
     /// @returns the hash of the type
-    size_t operator()(const tint::type::Type& type) const { return type.unique_hash; }
+    size_t operator()(const tint::core::type::Type& type) const { return type.unique_hash; }
 };
 
-/// std::equal_to specialization for tint::type::Type
+/// std::equal_to specialization for tint::core::type::Type
 template <>
-struct equal_to<tint::type::Type> {
+struct equal_to<tint::core::type::Type> {
     /// @param a the first type to compare
     /// @param b the second type to compare
     /// @returns true if the two types are equal
-    bool operator()(const tint::type::Type& a, const tint::type::Type& b) const {
+    bool operator()(const tint::core::type::Type& a, const tint::core::type::Type& b) const {
         return a.Equals(b);
     }
 };
diff --git a/src/tint/lang/core/type/type_test.cc b/src/tint/lang/core/type/type_test.cc
index 900fddd..25c0403 100644
--- a/src/tint/lang/core/type/type_test.cc
+++ b/src/tint/lang/core/type/type_test.cc
@@ -19,7 +19,7 @@
 #include "src/tint/lang/core/type/helper_test.h"
 #include "src/tint/lang/core/type/reference.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 struct TypeTest : public TestHelper {
@@ -45,34 +45,36 @@
     const Matrix* mat4x3_af = create<Matrix>(vec3_af, 4u);
     const Reference* ref_u32 =
         create<Reference>(core::AddressSpace::kPrivate, u32, core::Access::kReadWrite);
-    const Struct* str_f32 = create<Struct>(Sym("str_f32"),
-                                           tint::Vector{
-                                               create<StructMember>(
-                                                   /* name */ Sym("x"),
-                                                   /* type */ f32,
-                                                   /* index */ 0u,
-                                                   /* offset */ 0u,
-                                                   /* align */ 4u,
-                                                   /* size */ 4u,
-                                                   /* attributes */ type::StructMemberAttributes{}),
-                                           },
-                                           /* align*/ 4u,
-                                           /* size*/ 4u,
-                                           /* size_no_padding*/ 4u);
-    const Struct* str_f16 = create<Struct>(Sym("str_f16"),
-                                           tint::Vector{
-                                               create<StructMember>(
-                                                   /* name */ Sym("x"),
-                                                   /* type */ f16,
-                                                   /* index */ 0u,
-                                                   /* offset */ 0u,
-                                                   /* align */ 4u,
-                                                   /* size */ 4u,
-                                                   /* attributes */ type::StructMemberAttributes{}),
-                                           },
-                                           /* align*/ 4u,
-                                           /* size*/ 4u,
-                                           /* size_no_padding*/ 4u);
+    const Struct* str_f32 =
+        create<Struct>(Sym("str_f32"),
+                       tint::Vector{
+                           create<StructMember>(
+                               /* name */ Sym("x"),
+                               /* type */ f32,
+                               /* index */ 0u,
+                               /* offset */ 0u,
+                               /* align */ 4u,
+                               /* size */ 4u,
+                               /* attributes */ core::type::StructMemberAttributes{}),
+                       },
+                       /* align*/ 4u,
+                       /* size*/ 4u,
+                       /* size_no_padding*/ 4u);
+    const Struct* str_f16 =
+        create<Struct>(Sym("str_f16"),
+                       tint::Vector{
+                           create<StructMember>(
+                               /* name */ Sym("x"),
+                               /* type */ f16,
+                               /* index */ 0u,
+                               /* offset */ 0u,
+                               /* align */ 4u,
+                               /* size */ 4u,
+                               /* attributes */ core::type::StructMemberAttributes{}),
+                       },
+                       /* align*/ 4u,
+                       /* size*/ 4u,
+                       /* size_no_padding*/ 4u);
     Struct* str_af = create<Struct>(Sym("str_af"),
                                     tint::Vector{
                                         create<StructMember>(
@@ -82,7 +84,7 @@
                                             /* offset */ 0u,
                                             /* align */ 4u,
                                             /* size */ 4u,
-                                            /* attributes */ type::StructMemberAttributes{}),
+                                            /* attributes */ core::type::StructMemberAttributes{}),
                                     },
                                     /* align*/ 4u,
                                     /* size*/ 4u,
@@ -546,4 +548,4 @@
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/u32.cc b/src/tint/lang/core/type/u32.cc
index 37cf91d..c548222 100644
--- a/src/tint/lang/core/type/u32.cc
+++ b/src/tint/lang/core/type/u32.cc
@@ -16,13 +16,13 @@
 
 #include "src/tint/lang/core/type/manager.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::U32);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::U32);
 
-namespace tint::type {
+namespace tint::core::type {
 
 U32::U32()
     : Base(static_cast<size_t>(tint::TypeInfo::Of<U32>().full_hashcode),
-           type::Flags{
+           core::type::Flags{
                Flag::kConstructable,
                Flag::kCreationFixedFootprint,
                Flag::kFixedFootprint,
@@ -46,4 +46,4 @@
     return ctx.dst.mgr->Get<U32>();
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/u32.h b/src/tint/lang/core/type/u32.h
index 5498228..4013fed 100644
--- a/src/tint/lang/core/type/u32.h
+++ b/src/tint/lang/core/type/u32.h
@@ -19,7 +19,7 @@
 
 #include "src/tint/lang/core/type/numeric_scalar.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A unsigned int 32 type.
 class U32 final : public Castable<U32, NumericScalar> {
@@ -45,6 +45,6 @@
     U32* Clone(CloneContext& ctx) const override;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_U32_H_
diff --git a/src/tint/lang/core/type/u32_test.cc b/src/tint/lang/core/type/u32_test.cc
index 54e9898..af58452 100644
--- a/src/tint/lang/core/type/u32_test.cc
+++ b/src/tint/lang/core/type/u32_test.cc
@@ -15,7 +15,7 @@
 #include "src/tint/lang/core/type/helper_test.h"
 #include "src/tint/lang/core/type/texture.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using U32Test = TestHelper;
@@ -47,12 +47,12 @@
 TEST_F(U32Test, Clone) {
     auto* a = create<U32>();
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* b = a->Clone(ctx);
     ASSERT_TRUE(b->Is<U32>());
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/unique_node.cc b/src/tint/lang/core/type/unique_node.cc
index 1de2ec9..7a4aef2 100644
--- a/src/tint/lang/core/type/unique_node.cc
+++ b/src/tint/lang/core/type/unique_node.cc
@@ -14,10 +14,10 @@
 
 #include "src/tint/lang/core/type/unique_node.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::UniqueNode);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::UniqueNode);
 
-namespace tint::type {
+namespace tint::core::type {
 
 UniqueNode::~UniqueNode() = default;
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/unique_node.h b/src/tint/lang/core/type/unique_node.h
index c0042a5..bcf136b 100644
--- a/src/tint/lang/core/type/unique_node.h
+++ b/src/tint/lang/core/type/unique_node.h
@@ -19,7 +19,7 @@
 
 #include "src/tint/lang/core/type/node.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// UniqueNode is the base class for objects that are de-duplicated by the Manager.
 /// Deduplication is achieved by comparing a temporary object to the set of existing objects, using
@@ -42,25 +42,26 @@
     const size_t unique_hash;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 namespace std {
 
-/// std::hash specialization for tint::type::UniqueNode
+/// std::hash specialization for tint::core::type::UniqueNode
 template <>
-struct hash<tint::type::UniqueNode> {
+struct hash<tint::core::type::UniqueNode> {
     /// @param node the unique node to obtain a hash from
     /// @returns the hash of the node
-    size_t operator()(const tint::type::UniqueNode& node) const { return node.unique_hash; }
+    size_t operator()(const tint::core::type::UniqueNode& node) const { return node.unique_hash; }
 };
 
-/// std::equal_to specialization for tint::type::UniqueNode
+/// std::equal_to specialization for tint::core::type::UniqueNode
 template <>
-struct equal_to<tint::type::UniqueNode> {
+struct equal_to<tint::core::type::UniqueNode> {
     /// @param a the first unique node to compare
     /// @param b the second unique node to compare
     /// @returns true if the two nodes are equal
-    bool operator()(const tint::type::UniqueNode& a, const tint::type::UniqueNode& b) const {
+    bool operator()(const tint::core::type::UniqueNode& a,
+                    const tint::core::type::UniqueNode& b) const {
         return &a == &b || a.Equals(b);
     }
 };
diff --git a/src/tint/lang/core/type/vector.cc b/src/tint/lang/core/type/vector.cc
index 5e7d865..1bde999 100644
--- a/src/tint/lang/core/type/vector.cc
+++ b/src/tint/lang/core/type/vector.cc
@@ -20,13 +20,13 @@
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/text/string_stream.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::Vector);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::Vector);
 
-namespace tint::type {
+namespace tint::core::type {
 
 Vector::Vector(Type const* subtype, uint32_t width, bool packed /* = false */)
     : Base(Hash(tint::TypeInfo::Of<Vector>().full_hashcode, width, subtype, packed),
-           type::Flags{
+           core::type::Flags{
                Flag::kConstructable,
                Flag::kCreationFixedFootprint,
                Flag::kFixedFootprint,
@@ -86,4 +86,4 @@
     return index < width_ ? subtype_ : nullptr;
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/vector.h b/src/tint/lang/core/type/vector.h
index ce92cef..2be8499 100644
--- a/src/tint/lang/core/type/vector.h
+++ b/src/tint/lang/core/type/vector.h
@@ -19,7 +19,7 @@
 
 #include "src/tint/lang/core/type/type.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A vector type.
 class Vector : public Castable<Vector, Type> {
@@ -81,6 +81,6 @@
     const bool packed_;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_VECTOR_H_
diff --git a/src/tint/lang/core/type/vector_test.cc b/src/tint/lang/core/type/vector_test.cc
index 85e28d1..3f73cec 100644
--- a/src/tint/lang/core/type/vector_test.cc
+++ b/src/tint/lang/core/type/vector_test.cc
@@ -15,7 +15,7 @@
 #include "src/tint/lang/core/type/helper_test.h"
 #include "src/tint/lang/core/type/texture.h"
 
-namespace tint::type {
+namespace tint::core::type {
 namespace {
 
 using VectorTest = TestHelper;
@@ -83,8 +83,8 @@
 TEST_F(VectorTest, Clone) {
     auto* a = create<Vector>(create<I32>(), 2u);
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* vec = a->Clone(ctx);
     EXPECT_TRUE(vec->type()->Is<I32>());
@@ -95,8 +95,8 @@
 TEST_F(VectorTest, Clone_Packed) {
     auto* a = create<Vector>(create<I32>(), 3u, true);
 
-    type::Manager mgr;
-    type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
+    core::type::Manager mgr;
+    core::type::CloneContext ctx{{nullptr}, {nullptr, &mgr}};
 
     auto* vec = a->Clone(ctx);
     EXPECT_TRUE(vec->type()->Is<I32>());
@@ -105,4 +105,4 @@
 }
 
 }  // namespace
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/void.cc b/src/tint/lang/core/type/void.cc
index 69c9a44..a829c17 100644
--- a/src/tint/lang/core/type/void.cc
+++ b/src/tint/lang/core/type/void.cc
@@ -16,11 +16,12 @@
 
 #include "src/tint/lang/core/type/manager.h"
 
-TINT_INSTANTIATE_TYPEINFO(tint::type::Void);
+TINT_INSTANTIATE_TYPEINFO(tint::core::type::Void);
 
-namespace tint::type {
+namespace tint::core::type {
 
-Void::Void() : Base(static_cast<size_t>(tint::TypeInfo::Of<Void>().full_hashcode), type::Flags{}) {}
+Void::Void()
+    : Base(static_cast<size_t>(tint::TypeInfo::Of<Void>().full_hashcode), core::type::Flags{}) {}
 
 Void::~Void() = default;
 
@@ -36,4 +37,4 @@
     return ctx.dst.mgr->Get<Void>();
 }
 
-}  // namespace tint::type
+}  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/void.h b/src/tint/lang/core/type/void.h
index 5ee7146..05cb495 100644
--- a/src/tint/lang/core/type/void.h
+++ b/src/tint/lang/core/type/void.h
@@ -19,7 +19,7 @@
 
 #include "src/tint/lang/core/type/type.h"
 
-namespace tint::type {
+namespace tint::core::type {
 
 /// A void type
 class Void final : public Castable<Void, Type> {
@@ -43,6 +43,6 @@
     Void* Clone(CloneContext& ctx) const override;
 };
 
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 #endif  // SRC_TINT_LANG_CORE_TYPE_VOID_H_
diff --git a/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc b/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc
index 50778e3..268ea33 100644
--- a/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc
+++ b/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc
@@ -285,8 +285,8 @@
             [&](const ast::Struct* str) {
                 auto* sem = builder_.Sem().Get(str);
                 bool has_rt_arr = false;
-                if (auto* arr = sem->Members().Back()->Type()->As<type::Array>()) {
-                    has_rt_arr = arr->Count()->Is<type::RuntimeArrayCount>();
+                if (auto* arr = sem->Members().Back()->Type()->As<core::type::Array>()) {
+                    has_rt_arr = arr->Count()->Is<core::type::RuntimeArrayCount>();
                 }
                 bool is_block =
                     ast::HasAttribute<ast::transform::AddBlockAttribute::BlockAttribute>(
@@ -372,10 +372,10 @@
     }
 
     // Use packFloat2x16 and unpackFloat2x16 for f16 types.
-    if (src_type->DeepestElement()->Is<type::F16>()) {
+    if (src_type->DeepestElement()->Is<core::type::F16>()) {
         // Source type must be vec2<f16> or vec4<f16>, since type f16 and vec3<f16> can only have
         // identity bitcast.
-        auto* src_vec = src_type->As<type::Vector>();
+        auto* src_vec = src_type->As<core::type::Vector>();
         TINT_ASSERT(src_vec);
         TINT_ASSERT(((src_vec->Width() == 2u) || (src_vec->Width() == 4u)));
         std::string fn = GetOrCreate(
@@ -427,9 +427,9 @@
             ScopedParen sp(out);
             EmitExpression(out, expr->expr);
         }
-    } else if (dst_type->DeepestElement()->Is<type::F16>()) {
+    } else if (dst_type->DeepestElement()->Is<core::type::F16>()) {
         // Destination type must be vec2<f16> or vec4<f16>.
-        auto* dst_vec = dst_type->As<type::Vector>();
+        auto* dst_vec = dst_type->As<core::type::Vector>();
         TINT_ASSERT(dst_vec);
         TINT_ASSERT(((dst_vec->Width() == 2u) || (dst_vec->Width() == 4u)));
         std::string fn = GetOrCreate(
@@ -451,10 +451,11 @@
                 }
                 {
                     ScopedIndent si(&b);
-                    if (auto src_vec = src_type->As<type::Vector>()) {
+                    if (auto src_vec = src_type->As<core::type::Vector>()) {
                         // Source vector type must be vec2<f32/i32/u32>, destination type vec4<f16>.
-                        TINT_ASSERT((
-                            src_vec->DeepestElement()->IsAnyOf<type::I32, type::U32, type::F32>()));
+                        TINT_ASSERT(
+                            (src_vec->DeepestElement()
+                                 ->IsAnyOf<core::type::I32, core::type::U32, core::type::F32>()));
                         TINT_ASSERT((src_vec->Width() == 2u));
                         {
                             auto s = Line(&b);
@@ -471,7 +472,9 @@
                         Line(&b) << "return f16vec4(v_xy.x, v_xy.y, v_zw.x, v_zw.y);";
                     } else {
                         // Source scalar type must be f32/i32/u32, destination type vec2<f16>.
-                        TINT_ASSERT((src_type->IsAnyOf<type::I32, type::U32, type::F32>()));
+                        TINT_ASSERT(
+                            (src_type
+                                 ->IsAnyOf<core::type::I32, core::type::U32, core::type::F32>()));
                         {
                             auto s = Line(&b);
                             s << "uint r = ";
@@ -633,7 +636,7 @@
 }
 
 void ASTPrinter::EmitBinary(StringStream& out, const ast::BinaryExpression* expr) {
-    if (IsRelational(expr->op) && !TypeOf(expr->lhs)->UnwrapRef()->Is<type::Scalar>()) {
+    if (IsRelational(expr->op) && !TypeOf(expr->lhs)->UnwrapRef()->Is<core::type::Scalar>()) {
         EmitVectorRelational(out, expr);
         return;
     }
@@ -843,7 +846,7 @@
         EmitExpression(out, expr->args[0]);
     } else if ((builtin->Type() == core::Function::kAny ||
                 builtin->Type() == core::Function::kAll) &&
-               TypeOf(expr->args[0])->UnwrapRef()->Is<type::Scalar>()) {
+               TypeOf(expr->args[0])->UnwrapRef()->Is<core::type::Scalar>()) {
         // GLSL does not support any() or all() on scalar arguments. It's a no-op.
         EmitExpression(out, expr->args[0]);
     } else if (builtin->IsBarrier()) {
@@ -932,14 +935,14 @@
                 ScopedParen sp(out);
                 EmitExpression(out, expr->args[0]);
                 out << ", 0";
-                if (builtin->ReturnType()->Is<type::U32>()) {
+                if (builtin->ReturnType()->Is<core::type::U32>()) {
                     out << "u";
                 }
             }
             return;
         }
         case core::Function::kAtomicCompareExchangeWeak: {
-            EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>());
+            EmitStructType(&helpers_, builtin->ReturnType()->As<core::type::Struct>());
 
             auto* dest = expr->args[0];
             auto* compare_value = expr->args[1];
@@ -1069,7 +1072,7 @@
                                 const sem::Builtin* builtin) {
     // GLSL does not support ternary expressions with a bool vector conditional,
     // so polyfill with a helper.
-    if (auto* vec = builtin->Parameters()[2]->Type()->As<type::Vector>()) {
+    if (auto* vec = builtin->Parameters()[2]->Type()->As<core::type::Vector>()) {
         CallBuiltinHelper(out, expr, builtin,
                           [&](TextBuffer* b, const std::vector<std::string>& params) {
                               auto l = Line(b);
@@ -1107,7 +1110,7 @@
 void ASTPrinter::EmitDotCall(StringStream& out,
                              const ast::CallExpression* expr,
                              const sem::Builtin* builtin) {
-    auto* vec_ty = builtin->Parameters()[0]->Type()->As<type::Vector>();
+    auto* vec_ty = builtin->Parameters()[0]->Type()->As<core::type::Vector>();
     std::string fn = "dot";
     if (vec_ty->type()->is_integer_scalar()) {
         // GLSL does not have a builtin for dot() with integer vector types.
@@ -1163,49 +1166,49 @@
                               const ast::CallExpression* expr,
                               const sem::Builtin* builtin) {
     TINT_ASSERT(expr->args.Length() == 1);
-    CallBuiltinHelper(out, expr, builtin,
-                      [&](TextBuffer* b, const std::vector<std::string>& params) {
-                          // Emit the builtin return type unique to this overload. This does not
-                          // exist in the AST, so it will not be generated in Generate().
-                          EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>());
+    CallBuiltinHelper(
+        out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
+            // Emit the builtin return type unique to this overload. This does not
+            // exist in the AST, so it will not be generated in Generate().
+            EmitStructType(&helpers_, builtin->ReturnType()->As<core::type::Struct>());
 
-                          {
-                              auto l = Line(b);
-                              EmitType(l, builtin->ReturnType(), core::AddressSpace::kUndefined,
-                                       core::Access::kUndefined, "");
-                              l << " result;";
-                          }
-                          Line(b) << "result.fract = modf(" << params[0] << ", result.whole);";
-                          Line(b) << "return result;";
-                      });
+            {
+                auto l = Line(b);
+                EmitType(l, builtin->ReturnType(), core::AddressSpace::kUndefined,
+                         core::Access::kUndefined, "");
+                l << " result;";
+            }
+            Line(b) << "result.fract = modf(" << params[0] << ", result.whole);";
+            Line(b) << "return result;";
+        });
 }
 
 void ASTPrinter::EmitFrexpCall(StringStream& out,
                                const ast::CallExpression* expr,
                                const sem::Builtin* builtin) {
     TINT_ASSERT(expr->args.Length() == 1);
-    CallBuiltinHelper(out, expr, builtin,
-                      [&](TextBuffer* b, const std::vector<std::string>& params) {
-                          // Emit the builtin return type unique to this overload. This does not
-                          // exist in the AST, so it will not be generated in Generate().
-                          EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>());
+    CallBuiltinHelper(
+        out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
+            // Emit the builtin return type unique to this overload. This does not
+            // exist in the AST, so it will not be generated in Generate().
+            EmitStructType(&helpers_, builtin->ReturnType()->As<core::type::Struct>());
 
-                          {
-                              auto l = Line(b);
-                              EmitType(l, builtin->ReturnType(), core::AddressSpace::kUndefined,
-                                       core::Access::kUndefined, "");
-                              l << " result;";
-                          }
-                          Line(b) << "result.fract = frexp(" << params[0] << ", result.exp);";
-                          Line(b) << "return result;";
-                      });
+            {
+                auto l = Line(b);
+                EmitType(l, builtin->ReturnType(), core::AddressSpace::kUndefined,
+                         core::Access::kUndefined, "");
+                l << " result;";
+            }
+            Line(b) << "result.fract = frexp(" << params[0] << ", result.exp);";
+            Line(b) << "return result;";
+        });
 }
 
 void ASTPrinter::EmitDegreesCall(StringStream& out,
                                  const ast::CallExpression* expr,
                                  const sem::Builtin* builtin) {
     auto* return_elem_type = builtin->ReturnType()->DeepestElement();
-    const std::string suffix = Is<type::F16>(return_elem_type) ? "hf" : "f";
+    const std::string suffix = Is<core::type::F16>(return_elem_type) ? "hf" : "f";
     CallBuiltinHelper(out, expr, builtin,
                       [&](TextBuffer* b, const std::vector<std::string>& params) {
                           Line(b) << "return " << params[0] << " * " << std::setprecision(20)
@@ -1217,7 +1220,7 @@
                                  const ast::CallExpression* expr,
                                  const sem::Builtin* builtin) {
     auto* return_elem_type = builtin->ReturnType()->DeepestElement();
-    const std::string suffix = Is<type::F16>(return_elem_type) ? "hf" : "f";
+    const std::string suffix = Is<core::type::F16>(return_elem_type) ? "hf" : "f";
     CallBuiltinHelper(out, expr, builtin,
                       [&](TextBuffer* b, const std::vector<std::string>& params) {
                           Line(b) << "return " << params[0] << " * " << std::setprecision(20)
@@ -1232,7 +1235,7 @@
     CallBuiltinHelper(
         out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
             const auto v = params[0];
-            if (auto* vec = builtin->ReturnType()->As<type::Vector>()) {
+            if (auto* vec = builtin->ReturnType()->As<core::type::Vector>()) {
                 switch (vec->Width()) {
                     case 2: {
                         Line(b) << "return unpackHalf2x16(packHalf2x16(" << v << "));";
@@ -1270,7 +1273,7 @@
 
 const ast::Expression* ASTPrinter::CreateF32Zero(const sem::Statement* stmt) {
     auto* zero = builder_.Expr(0_f);
-    auto* f32 = builder_.create<type::F32>();
+    auto* f32 = builder_.create<core::type::F32>();
     auto* sem_zero = builder_.create<sem::ValueExpression>(
         zero, f32, core::EvaluationStage::kRuntime, stmt, /* constant_value */ nullptr,
         /* has_side_effects */ false);
@@ -1299,9 +1302,9 @@
         return;
     }
 
-    auto* texture_type = TypeOf(texture)->UnwrapRef()->As<type::Texture>();
+    auto* texture_type = TypeOf(texture)->UnwrapRef()->As<core::type::Texture>();
 
-    auto emit_signed_int_type = [&](const type::Type* ty) {
+    auto emit_signed_int_type = [&](const core::type::Type* ty) {
         uint32_t width = ty->Elements().count;
         if (width > 1) {
             out << "ivec" << width;
@@ -1310,7 +1313,7 @@
         }
     };
 
-    auto emit_unsigned_int_type = [&](const type::Type* ty) {
+    auto emit_unsigned_int_type = [&](const core::type::Type* ty) {
         uint32_t width = ty->Elements().count;
         if (width > 1) {
             out << "uvec" << width;
@@ -1339,7 +1342,7 @@
             emit_unsigned_int_type(call->Type());
             ScopedParen sp(out);
 
-            if (texture_type->Is<type::StorageTexture>()) {
+            if (texture_type->Is<core::type::StorageTexture>()) {
                 out << "imageSize(";
             } else {
                 out << "textureSize(";
@@ -1348,9 +1351,9 @@
 
             // The LOD parameter is mandatory on textureSize() for non-multisampled
             // textures.
-            if (!texture_type->Is<type::StorageTexture>() &&
-                !texture_type->Is<type::MultisampledTexture>() &&
-                !texture_type->Is<type::DepthMultisampledTexture>()) {
+            if (!texture_type->Is<core::type::StorageTexture>() &&
+                !texture_type->Is<core::type::MultisampledTexture>() &&
+                !texture_type->Is<core::type::DepthMultisampledTexture>()) {
                 out << ", ";
                 if (auto* level_arg = arg(Usage::kLevel)) {
                     emit_expr_as_signed(level_arg);
@@ -1361,8 +1364,8 @@
             out << ")";
             // textureSize() on array samplers returns the array size in the
             // final component, so strip it out.
-            if (texture_type->dim() == type::TextureDimension::k2dArray ||
-                texture_type->dim() == type::TextureDimension::kCubeArray) {
+            if (texture_type->dim() == core::type::TextureDimension::k2dArray ||
+                texture_type->dim() == core::type::TextureDimension::kCubeArray) {
                 out << ".xy";
             }
             return;
@@ -1374,7 +1377,7 @@
             out << "uint";
             ScopedParen sp(out);
 
-            if (texture_type->Is<type::StorageTexture>()) {
+            if (texture_type->Is<core::type::StorageTexture>()) {
                 out << "imageSize(";
             } else {
                 out << "textureSize(";
@@ -1385,9 +1388,9 @@
 
             // The LOD parameter is mandatory on textureSize() for non-multisampled
             // textures.
-            if (!texture_type->Is<type::StorageTexture>() &&
-                !texture_type->Is<type::MultisampledTexture>() &&
-                !texture_type->Is<type::DepthMultisampledTexture>()) {
+            if (!texture_type->Is<core::type::StorageTexture>() &&
+                !texture_type->Is<core::type::MultisampledTexture>() &&
+                !texture_type->Is<core::type::DepthMultisampledTexture>()) {
                 out << ", ";
                 if (auto* level_arg = arg(Usage::kLevel)) {
                     emit_expr_as_signed(level_arg);
@@ -1428,7 +1431,7 @@
 
     uint32_t glsl_ret_width = 4u;
     bool append_depth_ref_to_coords = true;
-    bool is_depth = texture_type->Is<type::DepthTexture>();
+    bool is_depth = texture_type->Is<core::type::DepthTexture>();
 
     switch (builtin->Type()) {
         case core::Function::kTextureSample:
@@ -1493,7 +1496,7 @@
     // GLSL requires Dref to be appended to the coordinates, *unless* it's
     // samplerCubeArrayShadow, in which case it will be handled as a separate
     // parameter.
-    if (texture_type->dim() == type::TextureDimension::kCubeArray) {
+    if (texture_type->dim() == core::type::TextureDimension::kCubeArray) {
         append_depth_ref_to_coords = false;
     }
 
@@ -1554,14 +1557,14 @@
 
     out << ")";
 
-    if (builtin->ReturnType()->Is<type::Void>()) {
+    if (builtin->ReturnType()->Is<core::type::Void>()) {
         return;
     }
     // If the builtin return type does not match the number of elements of the
     // GLSL builtin, we need to swizzle the expression to generate the correct
     // number of components.
     uint32_t wgsl_ret_width = 1;
-    if (auto* vec = builtin->ReturnType()->As<type::Vector>()) {
+    if (auto* vec = builtin->ReturnType()->As<core::type::Vector>()) {
         wgsl_ret_width = vec->Width();
     }
     if (wgsl_ret_width < glsl_ret_width) {
@@ -1809,7 +1812,7 @@
 
             auto const* type = v->Type();
 
-            if (auto* ptr = type->As<type::Pointer>()) {
+            if (auto* ptr = type->As<core::type::Pointer>()) {
                 // Transform pointer parameters in to `inout` parameters.
                 // The WGSL spec is highly restrictive in what can be passed in pointer
                 // parameters, which allows for this transformation. See:
@@ -1889,7 +1892,7 @@
 
 void ASTPrinter::EmitUniformVariable(const ast::Var* var, const sem::Variable* sem) {
     auto* type = sem->Type()->UnwrapRef();
-    auto* str = type->As<type::Struct>();
+    auto* str = type->As<core::type::Struct>();
     if (TINT_UNLIKELY(!str)) {
         TINT_ICE() << "storage variable must be of struct type";
         return;
@@ -1908,7 +1911,7 @@
 
 void ASTPrinter::EmitStorageVariable(const ast::Var* var, const sem::Variable* sem) {
     auto* type = sem->Type()->UnwrapRef();
-    auto* str = type->As<type::Struct>();
+    auto* str = type->As<core::type::Struct>();
     if (TINT_UNLIKELY(!str)) {
         TINT_ICE() << "storage variable must be of struct type";
         return;
@@ -1927,12 +1930,12 @@
 
     auto name = var->name->symbol.Name();
     auto* type = sem->Type()->UnwrapRef();
-    if (type->Is<type::Sampler>()) {
+    if (type->Is<core::type::Sampler>()) {
         // GLSL ignores Sampler variables.
         return;
     }
 
-    if (auto* storage = type->As<type::StorageTexture>()) {
+    if (auto* storage = type->As<core::type::StorageTexture>()) {
         out << "layout(";
         switch (storage->texel_format()) {
             case core::TexelFormat::kBgra8Unorm:
@@ -2161,7 +2164,7 @@
         for (auto* var : func->params) {
             auto* sem = builder_.Sem().Get(var);
             auto* type = sem->Type();
-            if (TINT_UNLIKELY(!type->Is<type::Struct>())) {
+            if (TINT_UNLIKELY(!type->Is<core::type::Struct>())) {
                 // ICE likely indicates that the CanonicalizeEntryPointIO transform was
                 // not run, or a builtin parameter was added after it was run.
                 TINT_ICE() << "Unsupported non-struct entry point parameter";
@@ -2200,12 +2203,12 @@
 void ASTPrinter::EmitConstant(StringStream& out, const core::constant::Value* constant) {
     Switch(
         constant->Type(),  //
-        [&](const type::Bool*) { out << (constant->ValueAs<AInt>() ? "true" : "false"); },
-        [&](const type::F32*) { PrintF32(out, constant->ValueAs<f32>()); },
-        [&](const type::F16*) { PrintF16(out, constant->ValueAs<f16>()); },
-        [&](const type::I32*) { PrintI32(out, constant->ValueAs<i32>()); },
-        [&](const type::U32*) { out << constant->ValueAs<AInt>() << "u"; },
-        [&](const type::Vector* v) {
+        [&](const core::type::Bool*) { out << (constant->ValueAs<AInt>() ? "true" : "false"); },
+        [&](const core::type::F32*) { PrintF32(out, constant->ValueAs<f32>()); },
+        [&](const core::type::F16*) { PrintF16(out, constant->ValueAs<f16>()); },
+        [&](const core::type::I32*) { PrintI32(out, constant->ValueAs<i32>()); },
+        [&](const core::type::U32*) { out << constant->ValueAs<AInt>() << "u"; },
+        [&](const core::type::Vector* v) {
             EmitType(out, v, core::AddressSpace::kUndefined, core::Access::kUndefined, "");
 
             ScopedParen sp(out);
@@ -2222,7 +2225,7 @@
                 EmitConstant(out, constant->Index(i));
             }
         },
-        [&](const type::Matrix* m) {
+        [&](const core::type::Matrix* m) {
             EmitType(out, m, core::AddressSpace::kUndefined, core::Access::kUndefined, "");
 
             ScopedParen sp(out);
@@ -2234,7 +2237,7 @@
                 EmitConstant(out, constant->Index(column_idx));
             }
         },
-        [&](const type::Array* a) {
+        [&](const core::type::Array* a) {
             EmitType(out, a, core::AddressSpace::kUndefined, core::Access::kUndefined, "");
 
             ScopedParen sp(out);
@@ -2242,7 +2245,7 @@
             auto count = a->ConstantCount();
             if (!count) {
                 diagnostics_.add_error(diag::System::Writer,
-                                       type::Array::kErrExpectedConstantCount);
+                                       core::type::Array::kErrExpectedConstantCount);
                 return;
             }
 
@@ -2253,7 +2256,7 @@
                 EmitConstant(out, constant->Index(i));
             }
         },
-        [&](const type::Struct* s) {
+        [&](const core::type::Struct* s) {
             EmitStructType(&helpers_, s);
 
             out << StructName(s);
@@ -2301,18 +2304,18 @@
         [&](Default) { diagnostics_.add_error(diag::System::Writer, "unknown literal type"); });
 }
 
-void ASTPrinter::EmitZeroValue(StringStream& out, const type::Type* type) {
-    if (type->Is<type::Bool>()) {
+void ASTPrinter::EmitZeroValue(StringStream& out, const core::type::Type* type) {
+    if (type->Is<core::type::Bool>()) {
         out << "false";
-    } else if (type->Is<type::F32>()) {
+    } else if (type->Is<core::type::F32>()) {
         out << "0.0f";
-    } else if (type->Is<type::F16>()) {
+    } else if (type->Is<core::type::F16>()) {
         out << "0.0hf";
-    } else if (type->Is<type::I32>()) {
+    } else if (type->Is<core::type::I32>()) {
         out << "0";
-    } else if (type->Is<type::U32>()) {
+    } else if (type->Is<core::type::U32>()) {
         out << "0u";
-    } else if (auto* vec = type->As<type::Vector>()) {
+    } else if (auto* vec = type->As<core::type::Vector>()) {
         EmitType(out, type, core::AddressSpace::kUndefined, core::Access::kReadWrite, "");
         ScopedParen sp(out);
         for (uint32_t i = 0; i < vec->Width(); i++) {
@@ -2321,7 +2324,7 @@
             }
             EmitZeroValue(out, vec->type());
         }
-    } else if (auto* mat = type->As<type::Matrix>()) {
+    } else if (auto* mat = type->As<core::type::Matrix>()) {
         EmitType(out, type, core::AddressSpace::kUndefined, core::Access::kReadWrite, "");
         ScopedParen sp(out);
         for (uint32_t i = 0; i < (mat->rows() * mat->columns()); i++) {
@@ -2330,7 +2333,7 @@
             }
             EmitZeroValue(out, mat->type());
         }
-    } else if (auto* str = type->As<type::Struct>()) {
+    } else if (auto* str = type->As<core::type::Struct>()) {
         EmitType(out, type, core::AddressSpace::kUndefined, core::Access::kUndefined, "");
         bool first = true;
         ScopedParen sp(out);
@@ -2342,13 +2345,14 @@
             }
             EmitZeroValue(out, member->Type());
         }
-    } else if (auto* arr = type->As<type::Array>()) {
+    } else if (auto* arr = type->As<core::type::Array>()) {
         EmitType(out, type, core::AddressSpace::kUndefined, core::Access::kUndefined, "");
         ScopedParen sp(out);
 
         auto count = arr->ConstantCount();
         if (!count) {
-            diagnostics_.add_error(diag::System::Writer, type::Array::kErrExpectedConstantCount);
+            diagnostics_.add_error(diag::System::Writer,
+                                   core::type::Array::kErrExpectedConstantCount);
             return;
         }
 
@@ -2604,7 +2608,7 @@
 }
 
 void ASTPrinter::EmitType(StringStream& out,
-                          const type::Type* type,
+                          const core::type::Type* type,
                           core::AddressSpace address_space,
                           core::Access access,
                           const std::string& name,
@@ -2630,17 +2634,17 @@
             break;
     }
 
-    if (auto* ary = type->As<type::Array>()) {
-        const type::Type* base_type = ary;
+    if (auto* ary = type->As<core::type::Array>()) {
+        const core::type::Type* base_type = ary;
         std::vector<uint32_t> sizes;
-        while (auto* arr = base_type->As<type::Array>()) {
-            if (arr->Count()->Is<type::RuntimeArrayCount>()) {
+        while (auto* arr = base_type->As<core::type::Array>()) {
+            if (arr->Count()->Is<core::type::RuntimeArrayCount>()) {
                 sizes.push_back(0);
             } else {
                 auto count = arr->ConstantCount();
                 if (!count) {
                     diagnostics_.add_error(diag::System::Writer,
-                                           type::Array::kErrExpectedConstantCount);
+                                           core::type::Array::kErrExpectedConstantCount);
                     return;
                 }
                 sizes.push_back(count.value());
@@ -2662,39 +2666,39 @@
                 out << "[]";
             }
         }
-    } else if (type->Is<type::Bool>()) {
+    } else if (type->Is<core::type::Bool>()) {
         out << "bool";
-    } else if (type->Is<type::F32>()) {
+    } else if (type->Is<core::type::F32>()) {
         out << "float";
-    } else if (type->Is<type::F16>()) {
+    } else if (type->Is<core::type::F16>()) {
         out << "float16_t";
-    } else if (type->Is<type::I32>()) {
+    } else if (type->Is<core::type::I32>()) {
         out << "int";
-    } else if (auto* mat = type->As<type::Matrix>()) {
-        TINT_ASSERT((mat->type()->IsAnyOf<type::F32, type::F16>()));
-        if (mat->type()->Is<type::F16>()) {
+    } else if (auto* mat = type->As<core::type::Matrix>()) {
+        TINT_ASSERT((mat->type()->IsAnyOf<core::type::F32, core::type::F16>()));
+        if (mat->type()->Is<core::type::F16>()) {
             out << "f16";
         }
         out << "mat" << mat->columns();
         if (mat->rows() != mat->columns()) {
             out << "x" << mat->rows();
         }
-    } else if (TINT_UNLIKELY(type->Is<type::Pointer>())) {
+    } else if (TINT_UNLIKELY(type->Is<core::type::Pointer>())) {
         TINT_ICE() << "Attempting to emit pointer type. These should have been removed with the "
                       "SimplifyPointers transform";
-    } else if (type->Is<type::Sampler>()) {
-    } else if (auto* str = type->As<type::Struct>()) {
+    } else if (type->Is<core::type::Sampler>()) {
+    } else if (auto* str = type->As<core::type::Struct>()) {
         out << StructName(str);
-    } else if (auto* tex = type->As<type::Texture>()) {
-        if (TINT_UNLIKELY(tex->Is<type::ExternalTexture>())) {
+    } else if (auto* tex = type->As<core::type::Texture>()) {
+        if (TINT_UNLIKELY(tex->Is<core::type::ExternalTexture>())) {
             TINT_ICE() << "Multiplanar external texture transform was not run.";
             return;
         }
 
-        auto* storage = tex->As<type::StorageTexture>();
-        auto* ms = tex->As<type::MultisampledTexture>();
-        auto* depth_ms = tex->As<type::DepthMultisampledTexture>();
-        auto* sampled = tex->As<type::SampledTexture>();
+        auto* storage = tex->As<core::type::StorageTexture>();
+        auto* ms = tex->As<core::type::MultisampledTexture>();
+        auto* depth_ms = tex->As<core::type::DepthMultisampledTexture>();
+        auto* sampled = tex->As<core::type::SampledTexture>();
 
         out << "highp ";
 
@@ -2705,10 +2709,10 @@
                         : storage ? storage->type()
                         : ms      ? ms->type()
                                   : nullptr;
-        if (!subtype || subtype->Is<type::F32>()) {
-        } else if (subtype->Is<type::I32>()) {
+        if (!subtype || subtype->Is<core::type::F32>()) {
+        } else if (subtype->Is<core::type::I32>()) {
             out << "i";
-        } else if (TINT_LIKELY(subtype->Is<type::U32>())) {
+        } else if (TINT_LIKELY(subtype->Is<core::type::U32>())) {
             out << "u";
         } else {
             TINT_ICE() << "Unsupported texture type";
@@ -2718,53 +2722,53 @@
         out << (storage ? "image" : "sampler");
 
         switch (tex->dim()) {
-            case type::TextureDimension::k1d:
+            case core::type::TextureDimension::k1d:
                 out << "1D";
                 break;
-            case type::TextureDimension::k2d:
+            case core::type::TextureDimension::k2d:
                 out << ((ms || depth_ms) ? "2DMS" : "2D");
                 break;
-            case type::TextureDimension::k2dArray:
+            case core::type::TextureDimension::k2dArray:
                 out << ((ms || depth_ms) ? "2DMSArray" : "2DArray");
                 break;
-            case type::TextureDimension::k3d:
+            case core::type::TextureDimension::k3d:
                 out << "3D";
                 break;
-            case type::TextureDimension::kCube:
+            case core::type::TextureDimension::kCube:
                 out << "Cube";
                 break;
-            case type::TextureDimension::kCubeArray:
+            case core::type::TextureDimension::kCubeArray:
                 out << "CubeArray";
                 break;
             default:
                 TINT_UNREACHABLE() << "unexpected TextureDimension " << tex->dim();
                 return;
         }
-        if (tex->Is<type::DepthTexture>()) {
+        if (tex->Is<core::type::DepthTexture>()) {
             out << "Shadow";
         }
-    } else if (type->Is<type::U32>()) {
+    } else if (type->Is<core::type::U32>()) {
         out << "uint";
-    } else if (auto* vec = type->As<type::Vector>()) {
+    } else if (auto* vec = type->As<core::type::Vector>()) {
         auto width = vec->Width();
-        if (vec->type()->Is<type::F32>() && width >= 1 && width <= 4) {
+        if (vec->type()->Is<core::type::F32>() && width >= 1 && width <= 4) {
             out << "vec" << width;
-        } else if (vec->type()->Is<type::F16>() && width >= 1 && width <= 4) {
+        } else if (vec->type()->Is<core::type::F16>() && width >= 1 && width <= 4) {
             out << "f16vec" << width;
-        } else if (vec->type()->Is<type::I32>() && width >= 1 && width <= 4) {
+        } else if (vec->type()->Is<core::type::I32>() && width >= 1 && width <= 4) {
             out << "ivec" << width;
-        } else if (vec->type()->Is<type::U32>() && width >= 1 && width <= 4) {
+        } else if (vec->type()->Is<core::type::U32>() && width >= 1 && width <= 4) {
             out << "uvec" << width;
-        } else if (vec->type()->Is<type::Bool>() && width >= 1 && width <= 4) {
+        } else if (vec->type()->Is<core::type::Bool>() && width >= 1 && width <= 4) {
             out << "bvec" << width;
         } else {
             out << "vector<";
             EmitType(out, vec->type(), address_space, access, "");
             out << ", " << width << ">";
         }
-    } else if (auto* atomic = type->As<type::Atomic>()) {
+    } else if (auto* atomic = type->As<core::type::Atomic>()) {
         EmitType(out, atomic->Type(), address_space, access, name);
-    } else if (type->Is<type::Void>()) {
+    } else if (type->Is<core::type::Void>()) {
         out << "void";
     } else {
         diagnostics_.add_error(diag::System::Writer, "unknown type in EmitType");
@@ -2772,7 +2776,7 @@
 }
 
 void ASTPrinter::EmitTypeAndName(StringStream& out,
-                                 const type::Type* type,
+                                 const core::type::Type* type,
                                  core::AddressSpace address_space,
                                  core::Access access,
                                  const std::string& name) {
@@ -2783,7 +2787,7 @@
     }
 }
 
-void ASTPrinter::EmitStructType(TextBuffer* b, const type::Struct* str) {
+void ASTPrinter::EmitStructType(TextBuffer* b, const core::type::Struct* str) {
     auto it = emitted_structs_.emplace(str);
     if (!it.second) {
         return;
@@ -2796,7 +2800,7 @@
     Line(b);
 }
 
-void ASTPrinter::EmitStructMembers(TextBuffer* b, const type::Struct* str) {
+void ASTPrinter::EmitStructMembers(TextBuffer* b, const core::type::Struct* str) {
     ScopedIndent si(b);
     for (auto* mem : str->Members()) {
         auto name = mem->Name().Name();
@@ -2818,7 +2822,7 @@
             out << "~";
             break;
         case core::UnaryOp::kNot:
-            if (TypeOf(expr)->UnwrapRef()->Is<type::Scalar>()) {
+            if (TypeOf(expr)->UnwrapRef()->Is<core::type::Scalar>()) {
                 out << "!";
             } else {
                 out << "not";
@@ -2901,7 +2905,7 @@
                     }
                     auto param_name = "param_" + std::to_string(parameter_names.size());
                     const auto* ty = param->Type();
-                    if (auto* ptr = ty->As<type::Pointer>()) {
+                    if (auto* ptr = ty->As<core::type::Pointer>()) {
                         decl << "inout ";
                         ty = ptr->StoreType();
                     }
@@ -2936,18 +2940,18 @@
     }
 }
 
-type::Type* ASTPrinter::BoolTypeToUint(const type::Type* type) {
-    auto* u32 = builder_.create<type::U32>();
-    if (type->Is<type::Bool>()) {
+core::type::Type* ASTPrinter::BoolTypeToUint(const core::type::Type* type) {
+    auto* u32 = builder_.create<core::type::U32>();
+    if (type->Is<core::type::Bool>()) {
         return u32;
-    } else if (auto* vec = type->As<type::Vector>()) {
-        return builder_.create<type::Vector>(u32, vec->Width());
+    } else if (auto* vec = type->As<core::type::Vector>()) {
+        return builder_.create<core::type::Vector>(u32, vec->Width());
     } else {
         return nullptr;
     }
 }
 
-std::string ASTPrinter::StructName(const type::Struct* s) {
+std::string ASTPrinter::StructName(const core::type::Struct* s) {
     auto name = s->Name().Name();
     if (HasPrefix(name, "__")) {
         name = tint::GetOrCreate(builtin_struct_names_, s,
diff --git a/src/tint/lang/glsl/writer/ast_printer/ast_printer.h b/src/tint/lang/glsl/writer/ast_printer/ast_printer.h
index 15d6fa9..dd927dc 100644
--- a/src/tint/lang/glsl/writer/ast_printer/ast_printer.h
+++ b/src/tint/lang/glsl/writer/ast_printer/ast_printer.h
@@ -349,7 +349,7 @@
     /// @param name_printed (optional) if not nullptr and an array was printed
     /// then the boolean is set to true.
     void EmitType(StringStream& out,
-                  const type::Type* type,
+                  const core::type::Type* type,
                   core::AddressSpace address_space,
                   core::Access access,
                   const std::string& name,
@@ -361,7 +361,7 @@
     /// @param access the access control type of the variable
     /// @param name the name to emit
     void EmitTypeAndName(StringStream& out,
-                         const type::Type* type,
+                         const core::type::Type* type,
                          core::AddressSpace address_space,
                          core::Access access,
                          const std::string& name);
@@ -369,11 +369,11 @@
     /// this function will simply return `true` without emitting anything.
     /// @param buffer the text buffer that the type declaration will be written to
     /// @param ty the struct to generate
-    void EmitStructType(TextBuffer* buffer, const type::Struct* ty);
+    void EmitStructType(TextBuffer* buffer, const core::type::Struct* ty);
     /// Handles generating the members of a structure
     /// @param buffer the text buffer that the struct members will be written to
     /// @param ty the struct to generate
-    void EmitStructMembers(TextBuffer* buffer, const type::Struct* ty);
+    void EmitStructMembers(TextBuffer* buffer, const core::type::Struct* ty);
     /// Handles a unary op expression
     /// @param out the output of the expression stream
     /// @param expr the expression to emit
@@ -381,7 +381,7 @@
     /// Emits the zero value for the given type
     /// @param out the output stream
     /// @param type the type to emit the value for
-    void EmitZeroValue(StringStream& out, const type::Type* type);
+    void EmitZeroValue(StringStream& out, const core::type::Type* type);
     /// Handles generating a 'var' declaration
     /// @param var the variable to generate
     void EmitVar(const ast::Var* var);
@@ -400,10 +400,10 @@
     /// @param stage pipeline stage in which this builtin is used
     /// @returns the string name of the builtin or blank on error
     const char* builtin_to_string(core::BuiltinValue builtin, ast::PipelineStage stage);
-    /// Converts a builtin to a type::Type appropriate for GLSL.
+    /// Converts a builtin to a core::type::Type appropriate for GLSL.
     /// @param builtin the builtin to convert
     /// @returns the appropriate semantic type or null on error.
-    type::Type* builtin_type(core::BuiltinValue builtin);
+    core::type::Type* builtin_type(core::BuiltinValue builtin);
 
   private:
     enum class VarType { kIn, kOut };
@@ -415,7 +415,7 @@
 
     /// The map key for two semantic types.
     using BinaryOperandType =
-        tint::UnorderedKeyWrapper<std::tuple<const type::Type*, const type::Type*>>;
+        tint::UnorderedKeyWrapper<std::tuple<const core::type::Type*, const core::type::Type*>>;
 
     /// CallBuiltinHelper will call the builtin helper function, creating it
     /// if it hasn't been built already. If the builtin needs to be built then
@@ -438,13 +438,13 @@
     /// Create a uint type corresponding to the given bool or bool vector type.
     /// @param type the bool or bool vector type to convert
     /// @returns the corresponding uint type
-    type::Type* BoolTypeToUint(const type::Type* type);
+    core::type::Type* BoolTypeToUint(const core::type::Type* type);
 
     /// @param s the structure
     /// @returns the name of the structure, taking special care of builtin structures that start
     /// with double underscores. If the structure is a builtin, then the returned name will be a
     /// unique name without the leading underscores.
-    std::string StructName(const type::Struct* s);
+    std::string StructName(const core::type::Struct* s);
 
     /// @return a new, unique identifier with the given prefix.
     /// @param prefix optional prefix to apply to the generated identifier. If empty "tint_symbol"
@@ -463,16 +463,16 @@
     TextBuffer helpers_;
 
     /// Map of builtin structure to unique generated name
-    std::unordered_map<const type::Struct*, std::string> builtin_struct_names_;
+    std::unordered_map<const core::type::Struct*, std::string> builtin_struct_names_;
     std::function<void()> emit_continuing_;
     std::unordered_map<const sem::Builtin*, std::string> builtins_;
-    std::unordered_map<const type::Vector*, std::string> dynamic_vector_write_;
-    std::unordered_map<const type::Vector*, std::string> int_dot_funcs_;
+    std::unordered_map<const core::type::Vector*, std::string> dynamic_vector_write_;
+    std::unordered_map<const core::type::Vector*, std::string> int_dot_funcs_;
     std::unordered_map<BinaryOperandType, std::string> float_modulo_funcs_;
     // Polyfill functions for bitcast expression, BinaryOperandType indicates the source type and
     // the destination type
     std::unordered_map<BinaryOperandType, std::string> bitcast_funcs_;
-    std::unordered_set<const type::Struct*> emitted_structs_;
+    std::unordered_set<const core::type::Struct*> emitted_structs_;
     bool requires_oes_sample_variables_ = false;
     bool requires_default_precision_qualifier_ = false;
     bool requires_f16_extension_ = false;
diff --git a/src/tint/lang/glsl/writer/ast_printer/type_test.cc b/src/tint/lang/glsl/writer/ast_printer/type_test.cc
index c788356..57163cd 100644
--- a/src/tint/lang/glsl/writer/ast_printer/type_test.cc
+++ b/src/tint/lang/glsl/writer/ast_printer/type_test.cc
@@ -87,7 +87,7 @@
 }
 
 TEST_F(GlslASTPrinterTest_Type, EmitType_Bool) {
-    auto* bool_ = create<type::Bool>();
+    auto* bool_ = create<core::type::Bool>();
 
     ASTPrinter& gen = Build();
 
@@ -98,7 +98,7 @@
 }
 
 TEST_F(GlslASTPrinterTest_Type, EmitType_F32) {
-    auto* f32 = create<type::F32>();
+    auto* f32 = create<core::type::F32>();
 
     ASTPrinter& gen = Build();
 
@@ -111,7 +111,7 @@
 TEST_F(GlslASTPrinterTest_Type, EmitType_F16) {
     Enable(core::Extension::kF16);
 
-    auto* f16 = create<type::F16>();
+    auto* f16 = create<core::type::F16>();
 
     ASTPrinter& gen = Build();
 
@@ -122,7 +122,7 @@
 }
 
 TEST_F(GlslASTPrinterTest_Type, EmitType_I32) {
-    auto* i32 = create<type::I32>();
+    auto* i32 = create<core::type::I32>();
 
     ASTPrinter& gen = Build();
 
@@ -133,9 +133,9 @@
 }
 
 TEST_F(GlslASTPrinterTest_Type, EmitType_Matrix_F32) {
-    auto* f32 = create<type::F32>();
-    auto* vec3 = create<type::Vector>(f32, 3u);
-    auto* mat2x3 = create<type::Matrix>(vec3, 2u);
+    auto* f32 = create<core::type::F32>();
+    auto* vec3 = create<core::type::Vector>(f32, 3u);
+    auto* mat2x3 = create<core::type::Matrix>(vec3, 2u);
 
     ASTPrinter& gen = Build();
 
@@ -148,9 +148,9 @@
 TEST_F(GlslASTPrinterTest_Type, EmitType_Matrix_F16) {
     Enable(core::Extension::kF16);
 
-    auto* f16 = create<type::F16>();
-    auto* vec3 = create<type::Vector>(f16, 3u);
-    auto* mat2x3 = create<type::Matrix>(vec3, 2u);
+    auto* f16 = create<core::type::F16>();
+    auto* vec3 = create<core::type::Vector>(f16, 3u);
+    auto* mat2x3 = create<core::type::Matrix>(vec3, 2u);
 
     ASTPrinter& gen = Build();
 
@@ -170,7 +170,7 @@
     ASTPrinter& gen = Build();
 
     tint::TextGenerator::TextBuffer buf;
-    auto* str = program->TypeOf(s)->As<type::Struct>();
+    auto* str = program->TypeOf(s)->As<core::type::Struct>();
     gen.EmitStructType(&buf, str);
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
     EXPECT_EQ(buf.String(), R"(struct S {
@@ -190,7 +190,7 @@
 
     ASTPrinter& gen = Build();
 
-    auto* str = program->TypeOf(s)->As<type::Struct>();
+    auto* str = program->TypeOf(s)->As<core::type::Struct>();
     StringStream out;
     gen.EmitType(out, str, core::AddressSpace::kUndefined, core::Access::kReadWrite, "");
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
@@ -224,7 +224,7 @@
     ASTPrinter& gen = Build();
 
     tint::TextGenerator::TextBuffer buf;
-    auto* str = program->TypeOf(s)->As<type::Struct>();
+    auto* str = program->TypeOf(s)->As<core::type::Struct>();
     gen.EmitStructType(&buf, str);
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
     EXPECT_EQ(buf.String(), R"(struct S {
@@ -236,7 +236,7 @@
 }
 
 TEST_F(GlslASTPrinterTest_Type, EmitType_U32) {
-    auto* u32 = create<type::U32>();
+    auto* u32 = create<core::type::U32>();
 
     ASTPrinter& gen = Build();
 
@@ -247,8 +247,8 @@
 }
 
 TEST_F(GlslASTPrinterTest_Type, EmitType_Vector_F32) {
-    auto* f32 = create<type::F32>();
-    auto* vec3 = create<type::Vector>(f32, 3u);
+    auto* f32 = create<core::type::F32>();
+    auto* vec3 = create<core::type::Vector>(f32, 3u);
 
     ASTPrinter& gen = Build();
 
@@ -261,8 +261,8 @@
 TEST_F(GlslASTPrinterTest_Type, EmitType_Vector_F16) {
     Enable(core::Extension::kF16);
 
-    auto* f16 = create<type::F16>();
-    auto* vec3 = create<type::Vector>(f16, 3u);
+    auto* f16 = create<core::type::F16>();
+    auto* vec3 = create<core::type::Vector>(f16, 3u);
 
     ASTPrinter& gen = Build();
 
@@ -273,7 +273,7 @@
 }
 
 TEST_F(GlslASTPrinterTest_Type, EmitType_Void) {
-    auto* void_ = create<type::Void>();
+    auto* void_ = create<core::type::Void>();
 
     ASTPrinter& gen = Build();
 
@@ -284,7 +284,7 @@
 }
 
 TEST_F(GlslASTPrinterTest_Type, EmitSampler) {
-    auto* sampler = create<type::Sampler>(type::SamplerKind::kSampler);
+    auto* sampler = create<core::type::Sampler>(core::type::SamplerKind::kSampler);
 
     ASTPrinter& gen = Build();
 
@@ -294,7 +294,7 @@
 }
 
 TEST_F(GlslASTPrinterTest_Type, EmitSamplerComparison) {
-    auto* sampler = create<type::Sampler>(type::SamplerKind::kComparisonSampler);
+    auto* sampler = create<core::type::Sampler>(core::type::SamplerKind::kComparisonSampler);
 
     ASTPrinter& gen = Build();
 
@@ -304,7 +304,7 @@
 }
 
 struct GlslDepthTextureData {
-    type::TextureDimension dim;
+    core::type::TextureDimension dim;
     std::string result;
 };
 inline std::ostream& operator<<(std::ostream& out, GlslDepthTextureData data) {
@@ -339,14 +339,15 @@
     GlslASTPrinterTest_Type,
     GlslDepthTexturesTest,
     testing::Values(
-        GlslDepthTextureData{type::TextureDimension::k2d, "sampler2DShadow tex;"},
-        GlslDepthTextureData{type::TextureDimension::k2dArray, "sampler2DArrayShadow tex;"},
-        GlslDepthTextureData{type::TextureDimension::kCube, "samplerCubeShadow tex;"},
-        GlslDepthTextureData{type::TextureDimension::kCubeArray, "samplerCubeArrayShadow tex;"}));
+        GlslDepthTextureData{core::type::TextureDimension::k2d, "sampler2DShadow tex;"},
+        GlslDepthTextureData{core::type::TextureDimension::k2dArray, "sampler2DArrayShadow tex;"},
+        GlslDepthTextureData{core::type::TextureDimension::kCube, "samplerCubeShadow tex;"},
+        GlslDepthTextureData{core::type::TextureDimension::kCubeArray,
+                             "samplerCubeArrayShadow tex;"}));
 
 using GlslDepthMultisampledTexturesTest = TestHelper;
 TEST_F(GlslDepthMultisampledTexturesTest, Emit) {
-    auto t = ty.depth_multisampled_texture(type::TextureDimension::k2d);
+    auto t = ty.depth_multisampled_texture(core::type::TextureDimension::k2d);
 
     GlobalVar("tex", t, Binding(1_a), Group(2_a));
 
@@ -366,7 +367,7 @@
 
 enum class TextureDataType { F32, U32, I32 };
 struct GlslSampledTextureData {
-    type::TextureDimension dim;
+    core::type::TextureDimension dim;
     TextureDataType datatype;
     std::string result;
 };
@@ -413,99 +414,99 @@
                          GlslSampledTexturesTest,
                          testing::Values(
                              GlslSampledTextureData{
-                                 type::TextureDimension::k1d,
+                                 core::type::TextureDimension::k1d,
                                  TextureDataType::F32,
                                  "sampler1D tex;",
                              },
                              GlslSampledTextureData{
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  TextureDataType::F32,
                                  "sampler2D tex;",
                              },
                              GlslSampledTextureData{
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  TextureDataType::F32,
                                  "sampler2DArray tex;",
                              },
                              GlslSampledTextureData{
-                                 type::TextureDimension::k3d,
+                                 core::type::TextureDimension::k3d,
                                  TextureDataType::F32,
                                  "sampler3D tex;",
                              },
                              GlslSampledTextureData{
-                                 type::TextureDimension::kCube,
+                                 core::type::TextureDimension::kCube,
                                  TextureDataType::F32,
                                  "samplerCube tex;",
                              },
                              GlslSampledTextureData{
-                                 type::TextureDimension::kCubeArray,
+                                 core::type::TextureDimension::kCubeArray,
                                  TextureDataType::F32,
                                  "samplerCubeArray tex;",
                              },
                              GlslSampledTextureData{
-                                 type::TextureDimension::k1d,
+                                 core::type::TextureDimension::k1d,
                                  TextureDataType::U32,
                                  "usampler1D tex;",
                              },
                              GlslSampledTextureData{
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  TextureDataType::U32,
                                  "usampler2D tex;",
                              },
                              GlslSampledTextureData{
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  TextureDataType::U32,
                                  "usampler2DArray tex;",
                              },
                              GlslSampledTextureData{
-                                 type::TextureDimension::k3d,
+                                 core::type::TextureDimension::k3d,
                                  TextureDataType::U32,
                                  "usampler3D tex;",
                              },
                              GlslSampledTextureData{
-                                 type::TextureDimension::kCube,
+                                 core::type::TextureDimension::kCube,
                                  TextureDataType::U32,
                                  "usamplerCube tex;",
                              },
                              GlslSampledTextureData{
-                                 type::TextureDimension::kCubeArray,
+                                 core::type::TextureDimension::kCubeArray,
                                  TextureDataType::U32,
                                  "usamplerCubeArray tex;",
                              },
                              GlslSampledTextureData{
-                                 type::TextureDimension::k1d,
+                                 core::type::TextureDimension::k1d,
                                  TextureDataType::I32,
                                  "isampler1D tex;",
                              },
                              GlslSampledTextureData{
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  TextureDataType::I32,
                                  "isampler2D tex;",
                              },
                              GlslSampledTextureData{
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  TextureDataType::I32,
                                  "isampler2DArray tex;",
                              },
                              GlslSampledTextureData{
-                                 type::TextureDimension::k3d,
+                                 core::type::TextureDimension::k3d,
                                  TextureDataType::I32,
                                  "isampler3D tex;",
                              },
                              GlslSampledTextureData{
-                                 type::TextureDimension::kCube,
+                                 core::type::TextureDimension::kCube,
                                  TextureDataType::I32,
                                  "isamplerCube tex;",
                              },
                              GlslSampledTextureData{
-                                 type::TextureDimension::kCubeArray,
+                                 core::type::TextureDimension::kCubeArray,
                                  TextureDataType::I32,
                                  "isamplerCubeArray tex;",
                              }));
 
 TEST_F(GlslASTPrinterTest_Type, EmitMultisampledTexture) {
-    auto* f32 = create<type::F32>();
-    auto* s = create<type::MultisampledTexture>(type::TextureDimension::k2d, f32);
+    auto* f32 = create<core::type::F32>();
+    auto* s = create<core::type::MultisampledTexture>(core::type::TextureDimension::k2d, f32);
 
     ASTPrinter& gen = Build();
 
@@ -516,7 +517,7 @@
 }
 
 struct GlslStorageTextureData {
-    type::TextureDimension dim;
+    core::type::TextureDimension dim;
     core::TexelFormat imgfmt;
     std::string result;
 };
@@ -549,31 +550,31 @@
 INSTANTIATE_TEST_SUITE_P(
     GlslASTPrinterTest_Type,
     GlslStorageTexturesTest,
-    testing::Values(GlslStorageTextureData{type::TextureDimension::k1d,
+    testing::Values(GlslStorageTextureData{core::type::TextureDimension::k1d,
                                            core::TexelFormat::kRgba8Unorm, "image1D tex;"},
-                    GlslStorageTextureData{type::TextureDimension::k2d,
+                    GlslStorageTextureData{core::type::TextureDimension::k2d,
                                            core::TexelFormat::kRgba16Float, "image2D tex;"},
-                    GlslStorageTextureData{type::TextureDimension::k2dArray,
+                    GlslStorageTextureData{core::type::TextureDimension::k2dArray,
                                            core::TexelFormat::kR32Float, "image2DArray tex;"},
-                    GlslStorageTextureData{type::TextureDimension::k3d,
+                    GlslStorageTextureData{core::type::TextureDimension::k3d,
                                            core::TexelFormat::kRg32Float, "image3D tex;"},
-                    GlslStorageTextureData{type::TextureDimension::k1d,
+                    GlslStorageTextureData{core::type::TextureDimension::k1d,
                                            core::TexelFormat::kRgba32Float, "image1D tex;"},
-                    GlslStorageTextureData{type::TextureDimension::k2d,
+                    GlslStorageTextureData{core::type::TextureDimension::k2d,
                                            core::TexelFormat::kRgba16Uint, "image2D tex;"},
-                    GlslStorageTextureData{type::TextureDimension::k2dArray,
+                    GlslStorageTextureData{core::type::TextureDimension::k2dArray,
                                            core::TexelFormat::kR32Uint, "image2DArray tex;"},
-                    GlslStorageTextureData{type::TextureDimension::k3d,
+                    GlslStorageTextureData{core::type::TextureDimension::k3d,
                                            core::TexelFormat::kRg32Uint, "image3D tex;"},
-                    GlslStorageTextureData{type::TextureDimension::k1d,
+                    GlslStorageTextureData{core::type::TextureDimension::k1d,
                                            core::TexelFormat::kRgba32Uint, "image1D tex;"},
-                    GlslStorageTextureData{type::TextureDimension::k2d,
+                    GlslStorageTextureData{core::type::TextureDimension::k2d,
                                            core::TexelFormat::kRgba16Sint, "image2D tex;"},
-                    GlslStorageTextureData{type::TextureDimension::k2dArray,
+                    GlslStorageTextureData{core::type::TextureDimension::k2dArray,
                                            core::TexelFormat::kR32Sint, "image2DArray tex;"},
-                    GlslStorageTextureData{type::TextureDimension::k3d,
+                    GlslStorageTextureData{core::type::TextureDimension::k3d,
                                            core::TexelFormat::kRg32Sint, "image3D tex;"},
-                    GlslStorageTextureData{type::TextureDimension::k1d,
+                    GlslStorageTextureData{core::type::TextureDimension::k1d,
                                            core::TexelFormat::kRgba32Sint, "image1D tex;"}));
 
 }  // namespace
diff --git a/src/tint/lang/hlsl/writer/ast_printer/ast_printer.cc b/src/tint/lang/hlsl/writer/ast_printer/ast_printer.cc
index 40fc56a..d9de220 100644
--- a/src/tint/lang/hlsl/writer/ast_printer/ast_printer.cc
+++ b/src/tint/lang/hlsl/writer/ast_printer/ast_printer.cc
@@ -412,7 +412,7 @@
 }
 
 bool ASTPrinter::EmitDynamicVectorAssignment(const ast::AssignmentStatement* stmt,
-                                             const type::Vector* vec) {
+                                             const core::type::Vector* vec) {
     auto name = tint::GetOrCreate(dynamic_vector_write_, vec, [&]() -> std::string {
         std::string fn;
         {
@@ -485,7 +485,7 @@
 }
 
 bool ASTPrinter::EmitDynamicMatrixVectorAssignment(const ast::AssignmentStatement* stmt,
-                                                   const type::Matrix* mat) {
+                                                   const core::type::Matrix* mat) {
     auto name = tint::GetOrCreate(dynamic_matrix_vector_write_, mat, [&]() -> std::string {
         std::string fn;
         {
@@ -551,7 +551,7 @@
 }
 
 bool ASTPrinter::EmitDynamicMatrixScalarAssignment(const ast::AssignmentStatement* stmt,
-                                                   const type::Matrix* mat) {
+                                                   const core::type::Matrix* mat) {
     auto* lhs_row_access = stmt->lhs->As<ast::IndexAccessorExpression>();
     auto* lhs_col_access = lhs_row_access->object->As<ast::IndexAccessorExpression>();
 
@@ -610,7 +610,7 @@
                                 default: {
                                     auto* vec = TypeOf(lhs_row_access->object)
                                                     ->UnwrapRef()
-                                                    ->As<type::Vector>();
+                                                    ->As<core::type::Vector>();
                                     TINT_UNREACHABLE() << "invalid vector size " << vec->Width();
                                     break;
                                 }
@@ -686,12 +686,12 @@
     }
 
     // Handle the f16 types using polyfill functions
-    if (src_el_type->Is<type::F16>() || dst_el_type->Is<type::F16>()) {
+    if (src_el_type->Is<core::type::F16>() || dst_el_type->Is<core::type::F16>()) {
         auto f16_bitcast_polyfill = [&]() {
-            if (src_el_type->Is<type::F16>()) {
+            if (src_el_type->Is<core::type::F16>()) {
                 // Source type must be vec2<f16> or vec4<f16>, since type f16 and vec3<f16> can only
                 // have identity bitcast.
-                auto* src_vec = src_type->As<type::Vector>();
+                auto* src_vec = src_type->As<core::type::Vector>();
                 TINT_ASSERT(src_vec);
                 TINT_ASSERT(((src_vec->Width() == 2u) || (src_vec->Width() == 4u)));
 
@@ -755,14 +755,15 @@
                     });
             } else {
                 // Destination type must be vec2<f16> or vec4<f16>.
-                auto* dst_vec = dst_type->As<type::Vector>();
+                auto* dst_vec = dst_type->As<core::type::Vector>();
                 TINT_ASSERT((dst_vec && ((dst_vec->Width() == 2u) || (dst_vec->Width() == 4u)) &&
-                             dst_el_type->Is<type::F16>()));
+                             dst_el_type->Is<core::type::F16>()));
                 // Source type must be f32/i32/u32 or vec2<f32/i32/u32>.
-                auto* src_vec = src_type->As<type::Vector>();
-                TINT_ASSERT((src_type->IsAnyOf<type::I32, type::U32, type::F32>() ||
-                             (src_vec && src_vec->Width() == 2u &&
-                              src_el_type->IsAnyOf<type::I32, type::U32, type::F32>())));
+                auto* src_vec = src_type->As<core::type::Vector>();
+                TINT_ASSERT(
+                    (src_type->IsAnyOf<core::type::I32, core::type::U32, core::type::F32>() ||
+                     (src_vec && src_vec->Width() == 2u &&
+                      src_el_type->IsAnyOf<core::type::I32, core::type::U32, core::type::F32>())));
                 std::string src_type_suffix = (src_vec ? "2" : "");
 
                 // Bitcast other types to f16 types by reinterpreting their bits as f16 using
@@ -849,7 +850,7 @@
     }
 
     // Otherwise, bitcasting between non-f16 types.
-    TINT_ASSERT((!src_el_type->Is<type::F16>() && !dst_el_type->Is<type::F16>()));
+    TINT_ASSERT((!src_el_type->Is<core::type::F16>() && !dst_el_type->Is<core::type::F16>()));
     out << "as";
     if (!EmitType(out, dst_el_type, core::AddressSpace::kUndefined, core::Access::kReadWrite, "")) {
         return false;
@@ -867,7 +868,7 @@
         // BUG(crbug.com/tint/1333): work around assignment of scalar to matrices
         // with at least one dynamic index
         if (auto* lhs_sub_access = lhs_access->object->As<ast::IndexAccessorExpression>()) {
-            if (auto* mat = TypeOf(lhs_sub_access->object)->UnwrapRef()->As<type::Matrix>()) {
+            if (auto* mat = TypeOf(lhs_sub_access->object)->UnwrapRef()->As<core::type::Matrix>()) {
                 auto* rhs_row_idx_sem = builder_.Sem().GetVal(lhs_access->index);
                 auto* rhs_col_idx_sem = builder_.Sem().GetVal(lhs_sub_access->index);
                 if (!rhs_row_idx_sem->ConstantValue() || !rhs_col_idx_sem->ConstantValue()) {
@@ -878,7 +879,7 @@
         // BUG(crbug.com/tint/1333): work around assignment of vector to matrices
         // with dynamic indices
         const auto* lhs_access_type = TypeOf(lhs_access->object)->UnwrapRef();
-        if (auto* mat = lhs_access_type->As<type::Matrix>()) {
+        if (auto* mat = lhs_access_type->As<core::type::Matrix>()) {
             auto* lhs_index_sem = builder_.Sem().GetVal(lhs_access->index);
             if (!lhs_index_sem->ConstantValue()) {
                 return EmitDynamicMatrixVectorAssignment(stmt, mat);
@@ -886,7 +887,7 @@
         }
         // BUG(crbug.com/tint/534): work around assignment to vectors with dynamic
         // indices
-        if (auto* vec = lhs_access_type->As<type::Vector>()) {
+        if (auto* vec = lhs_access_type->As<core::type::Vector>()) {
             auto* rhs_sem = builder_.Sem().GetVal(lhs_access->index);
             if (!rhs_sem->ConstantValue()) {
                 return EmitDynamicVectorAssignment(stmt, vec);
@@ -946,9 +947,9 @@
     // Multiplying by a matrix requires the use of `mul` in order to get the
     // type of multiply we desire.
     if (expr->op == core::BinaryOp::kMultiply &&
-        ((lhs_type->Is<type::Vector>() && rhs_type->Is<type::Matrix>()) ||
-         (lhs_type->Is<type::Matrix>() && rhs_type->Is<type::Vector>()) ||
-         (lhs_type->Is<type::Matrix>() && rhs_type->Is<type::Matrix>()))) {
+        ((lhs_type->Is<core::type::Vector>() && rhs_type->Is<core::type::Matrix>()) ||
+         (lhs_type->Is<core::type::Matrix>() && rhs_type->Is<core::type::Vector>()) ||
+         (lhs_type->Is<core::type::Matrix>() && rhs_type->Is<core::type::Matrix>()))) {
         // Matrices are transposed, so swap LHS and RHS.
         out << "mul(";
         if (!EmitExpression(out, expr->rhs)) {
@@ -1282,7 +1283,7 @@
 
     // Single parameter matrix initializers must be identity initializer.
     // It could also be conversions between f16 and f32 matrix when f16 is properly supported.
-    if (type->Is<type::Matrix>() && call->Arguments().Length() == 1) {
+    if (type->Is<core::type::Matrix>() && call->Arguments().Length() == 1) {
         if (!ctor->Parameters()[0]->Type()->UnwrapRef()->is_float_matrix()) {
             TINT_UNREACHABLE()
                 << "found a single-parameter matrix initializer that is not identity initializer";
@@ -1290,13 +1291,13 @@
         }
     }
 
-    bool brackets = type->IsAnyOf<type::Array, type::Struct>();
+    bool brackets = type->IsAnyOf<core::type::Array, core::type::Struct>();
 
     // For single-value vector initializers, swizzle the scalar to the right
     // vector dimension using .x
-    const bool is_single_value_vector_init = type->is_scalar_vector() &&
-                                             call->Arguments().Length() == 1 &&
-                                             ctor->Parameters()[0]->Type()->Is<type::Scalar>();
+    const bool is_single_value_vector_init =
+        type->is_scalar_vector() && call->Arguments().Length() == 1 &&
+        ctor->Parameters()[0]->Type()->Is<core::type::Scalar>();
 
     if (brackets) {
         out << "{";
@@ -1324,7 +1325,7 @@
     }
 
     if (is_single_value_vector_init) {
-        out << ")." << std::string(type->As<type::Vector>()->Width(), 'x');
+        out << ")." << std::string(type->As<core::type::Vector>()->Width(), 'x');
     }
 
     out << (brackets ? "}" : ")");
@@ -1353,7 +1354,7 @@
     bool scalar_offset_constant = false;
 
     if (auto* val = builder_.Sem().GetVal(offset)->ConstantValue()) {
-        TINT_ASSERT(val->Type()->Is<type::U32>());
+        TINT_ASSERT(val->Type()->Is<core::type::U32>());
         scalar_offset_bytes = static_cast<uint32_t>(val->ValueAs<AInt>());
         scalar_offset_index = scalar_offset_bytes / 4;  // bytes -> scalar index
         scalar_offset_constant = true;
@@ -1923,7 +1924,7 @@
             return true;
         }
         case Op::kAtomicCompareExchangeWeak: {
-            if (!EmitStructType(&helpers_, result_ty->As<type::Struct>())) {
+            if (!EmitStructType(&helpers_, result_ty->As<core::type::Struct>())) {
                 return false;
             }
 
@@ -1990,7 +1991,7 @@
                                          const sem::Builtin* builtin) {
     std::string result = UniqueIdentifier("atomic_result");
 
-    if (!builtin->ReturnType()->Is<type::Void>()) {
+    if (!builtin->ReturnType()->Is<core::type::Void>()) {
         auto pre = Line();
         if (!EmitTypeAndName(pre, builtin->ReturnType(), core::AddressSpace::kUndefined,
                              core::Access::kUndefined, result)) {
@@ -2082,7 +2083,7 @@
             return true;
         }
         case core::Function::kAtomicCompareExchangeWeak: {
-            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>())) {
+            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<core::type::Struct>())) {
                 return false;
             }
 
@@ -2193,13 +2194,13 @@
             auto in = params[0];
 
             std::string width;
-            if (auto* vec = ty->As<type::Vector>()) {
+            if (auto* vec = ty->As<core::type::Vector>()) {
                 width = std::to_string(vec->Width());
             }
 
             // Emit the builtin return type unique to this overload. This does not
             // exist in the AST, so it will not be generated in Generate().
-            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>())) {
+            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<core::type::Struct>())) {
                 return false;
             }
 
@@ -2226,18 +2227,18 @@
             auto in = params[0];
 
             std::string width;
-            if (auto* vec = ty->As<type::Vector>()) {
+            if (auto* vec = ty->As<core::type::Vector>()) {
                 width = std::to_string(vec->Width());
             }
 
             // Emit the builtin return type unique to this overload. This does not
             // exist in the AST, so it will not be generated in Generate().
-            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>())) {
+            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<core::type::Struct>())) {
                 return false;
             }
 
             std::string member_type;
-            if (Is<type::F16>(ty->DeepestElement())) {
+            if (Is<core::type::F16>(ty->DeepestElement())) {
                 member_type = width.empty() ? "float16_t" : ("vector<float16_t, " + width + ">");
             } else {
                 member_type = "float" + width;
@@ -2301,7 +2302,7 @@
                                        const sem::Builtin* builtin) {
     // Cast to f16 and back
     std::string width;
-    if (auto* vec = builtin->ReturnType()->As<type::Vector>()) {
+    if (auto* vec = builtin->ReturnType()->As<core::type::Vector>()) {
         width = std::to_string(vec->Width());
     }
     out << "f16tof32(f32tof16"
@@ -2532,7 +2533,7 @@
         return false;
     }
 
-    auto* texture_type = TypeOf(texture)->UnwrapRef()->As<type::Texture>();
+    auto* texture_type = TypeOf(texture)->UnwrapRef()->As<core::type::Texture>();
 
     switch (builtin->Type()) {
         case core::Function::kTextureDimensions:
@@ -2540,35 +2541,35 @@
         case core::Function::kTextureNumLevels:
         case core::Function::kTextureNumSamples: {
             // All of these builtins use the GetDimensions() method on the texture
-            bool is_ms =
-                texture_type->IsAnyOf<type::MultisampledTexture, type::DepthMultisampledTexture>();
+            bool is_ms = texture_type->IsAnyOf<core::type::MultisampledTexture,
+                                               core::type::DepthMultisampledTexture>();
             int num_dimensions = 0;
             std::string swizzle;
 
             switch (builtin->Type()) {
                 case core::Function::kTextureDimensions:
                     switch (texture_type->dim()) {
-                        case type::TextureDimension::kNone:
+                        case core::type::TextureDimension::kNone:
                             TINT_ICE() << "texture dimension is kNone";
                             return false;
-                        case type::TextureDimension::k1d:
+                        case core::type::TextureDimension::k1d:
                             num_dimensions = 1;
                             break;
-                        case type::TextureDimension::k2d:
+                        case core::type::TextureDimension::k2d:
                             num_dimensions = is_ms ? 3 : 2;
                             swizzle = is_ms ? ".xy" : "";
                             break;
-                        case type::TextureDimension::k2dArray:
+                        case core::type::TextureDimension::k2dArray:
                             num_dimensions = is_ms ? 4 : 3;
                             swizzle = ".xy";
                             break;
-                        case type::TextureDimension::k3d:
+                        case core::type::TextureDimension::k3d:
                             num_dimensions = 3;
                             break;
-                        case type::TextureDimension::kCube:
+                        case core::type::TextureDimension::kCube:
                             num_dimensions = 2;
                             break;
-                        case type::TextureDimension::kCubeArray:
+                        case core::type::TextureDimension::kCubeArray:
                             num_dimensions = 3;
                             swizzle = ".xy";
                             break;
@@ -2579,11 +2580,11 @@
                         default:
                             TINT_ICE() << "texture dimension is not arrayed";
                             return false;
-                        case type::TextureDimension::k2dArray:
+                        case core::type::TextureDimension::k2dArray:
                             num_dimensions = is_ms ? 4 : 3;
                             swizzle = ".z";
                             break;
-                        case type::TextureDimension::kCubeArray:
+                        case core::type::TextureDimension::kCubeArray:
                             num_dimensions = 3;
                             swizzle = ".z";
                             break;
@@ -2594,18 +2595,18 @@
                         default:
                             TINT_ICE() << "texture dimension does not support mips";
                             return false;
-                        case type::TextureDimension::k1d:
+                        case core::type::TextureDimension::k1d:
                             num_dimensions = 2;
                             swizzle = ".y";
                             break;
-                        case type::TextureDimension::k2d:
-                        case type::TextureDimension::kCube:
+                        case core::type::TextureDimension::k2d:
+                        case core::type::TextureDimension::kCube:
                             num_dimensions = 3;
                             swizzle = ".z";
                             break;
-                        case type::TextureDimension::k2dArray:
-                        case type::TextureDimension::k3d:
-                        case type::TextureDimension::kCubeArray:
+                        case core::type::TextureDimension::k2dArray:
+                        case core::type::TextureDimension::k3d:
+                        case core::type::TextureDimension::kCubeArray:
                             num_dimensions = 4;
                             swizzle = ".w";
                             break;
@@ -2616,11 +2617,11 @@
                         default:
                             TINT_ICE() << "texture dimension does not support multisampling";
                             return false;
-                        case type::TextureDimension::k2d:
+                        case core::type::TextureDimension::k2d:
                             num_dimensions = 3;
                             swizzle = ".z";
                             break;
-                        case type::TextureDimension::k2dArray:
+                        case core::type::TextureDimension::k2dArray:
                             num_dimensions = 4;
                             swizzle = ".w";
                             break;
@@ -2743,7 +2744,7 @@
         case core::Function::kTextureLoad:
             out << ".Load(";
             // Multisampled textures do not support mip-levels.
-            if (!texture_type->Is<type::MultisampledTexture>()) {
+            if (!texture_type->Is<core::type::MultisampledTexture>()) {
                 pack_level_in_coords = true;
             }
             break;
@@ -2794,7 +2795,7 @@
     }
 
     auto emit_vector_appended_with_i32_zero = [&](const ast::Expression* vector) {
-        auto* i32 = builder_.create<type::I32>();
+        auto* i32 = builder_.create<core::type::I32>();
         auto* zero = builder_.Expr(0_i);
         auto* stmt = builder_.Sem().Get(vector)->Stmt();
         builder_.Sem().Add(zero, builder_.create<sem::ValueExpression>(
@@ -2862,7 +2863,7 @@
         // HLSL builtin, we need to swizzle the expression to generate the correct
         // number of components.
         uint32_t wgsl_ret_width = 1;
-        if (auto* vec = builtin->ReturnType()->As<type::Vector>()) {
+        if (auto* vec = builtin->ReturnType()->As<core::type::Vector>()) {
             wgsl_ret_width = vec->Width();
         }
         if (wgsl_ret_width < hlsl_ret_width) {
@@ -3105,7 +3106,7 @@
         auto name = func->name->symbol.Name();
         // If the function returns an array, then we need to declare a typedef for
         // this.
-        if (sem->ReturnType()->Is<type::Array>()) {
+        if (sem->ReturnType()->Is<core::type::Array>()) {
             auto typedef_name = UniqueIdentifier(name + "_ret");
             auto pre = Line();
             pre << "typedef ";
@@ -3136,7 +3137,7 @@
             auto address_space = core::AddressSpace::kUndefined;
             auto access = core::Access::kUndefined;
 
-            if (auto* ptr = type->As<type::Pointer>()) {
+            if (auto* ptr = type->As<core::type::Pointer>()) {
                 type = ptr->StoreType();
                 switch (ptr->AddressSpace()) {
                     case core::AddressSpace::kStorage:
@@ -3168,7 +3169,7 @@
         out << ") {";
     }
 
-    if (sem->DiscardStatement() && !sem->ReturnType()->Is<type::Void>()) {
+    if (sem->DiscardStatement() && !sem->ReturnType()->Is<core::type::Void>()) {
         // BUG(crbug.com/tint/1081): work around non-void functions with discard
         // failing compilation sometimes
         if (!EmitFunctionBodyWithDiscard(func)) {
@@ -3192,7 +3193,7 @@
     // there is always an (unused) return statement.
 
     auto* sem = builder_.Sem().Get(func);
-    TINT_ASSERT(sem->DiscardStatement() && !sem->ReturnType()->Is<type::Void>());
+    TINT_ASSERT(sem->DiscardStatement() && !sem->ReturnType()->Is<core::type::Void>());
 
     ScopedIndent si(this);
     Line() << "if (true) {";
@@ -3310,12 +3311,12 @@
 
     const char* register_space = nullptr;
 
-    if (unwrapped_type->Is<type::Texture>()) {
+    if (unwrapped_type->Is<core::type::Texture>()) {
         register_space = "t";
-        if (unwrapped_type->Is<type::StorageTexture>()) {
+        if (unwrapped_type->Is<core::type::StorageTexture>()) {
             register_space = "u";
         }
-    } else if (unwrapped_type->Is<type::Sampler>()) {
+    } else if (unwrapped_type->Is<core::type::Sampler>()) {
         register_space = "s";
     }
 
@@ -3483,7 +3484,7 @@
         for (auto* var : func->params) {
             auto* sem = builder_.Sem().Get(var);
             auto* type = sem->Type();
-            if (TINT_UNLIKELY(!type->Is<type::Struct>())) {
+            if (TINT_UNLIKELY(!type->Is<core::type::Struct>())) {
                 // ICE likely indicates that the CanonicalizeEntryPointIO transform was
                 // not run, or a builtin parameter was added after it was run.
                 TINT_ICE() << "Unsupported non-struct entry point parameter";
@@ -3528,30 +3529,30 @@
                               bool is_variable_initializer) {
     return Switch(
         constant->Type(),  //
-        [&](const type::Bool*) {
+        [&](const core::type::Bool*) {
             out << (constant->ValueAs<AInt>() ? "true" : "false");
             return true;
         },
-        [&](const type::F32*) {
+        [&](const core::type::F32*) {
             PrintF32(out, constant->ValueAs<f32>());
             return true;
         },
-        [&](const type::F16*) {
+        [&](const core::type::F16*) {
             // emit a f16 scalar with explicit float16_t type declaration.
             out << "float16_t(";
             PrintF16(out, constant->ValueAs<f16>());
             out << ")";
             return true;
         },
-        [&](const type::I32*) {
+        [&](const core::type::I32*) {
             out << constant->ValueAs<AInt>();
             return true;
         },
-        [&](const type::U32*) {
+        [&](const core::type::U32*) {
             out << constant->ValueAs<AInt>() << "u";
             return true;
         },
-        [&](const type::Vector* v) {
+        [&](const core::type::Vector* v) {
             if (auto* splat = constant->As<core::constant::Splat>()) {
                 {
                     ScopedParen sp(out);
@@ -3582,7 +3583,7 @@
             }
             return true;
         },
-        [&](const type::Matrix* m) {
+        [&](const core::type::Matrix* m) {
             if (!EmitType(out, m, core::AddressSpace::kUndefined, core::Access::kUndefined, "")) {
                 return false;
             }
@@ -3599,7 +3600,7 @@
             }
             return true;
         },
-        [&](const type::Array* a) {
+        [&](const core::type::Array* a) {
             if (constant->AllZero()) {
                 out << "(";
                 if (!EmitType(out, a, core::AddressSpace::kUndefined, core::Access::kUndefined,
@@ -3616,7 +3617,7 @@
             auto count = a->ConstantCount();
             if (!count) {
                 diagnostics_.add_error(diag::System::Writer,
-                                       type::Array::kErrExpectedConstantCount);
+                                       core::type::Array::kErrExpectedConstantCount);
                 return false;
             }
 
@@ -3631,7 +3632,7 @@
 
             return true;
         },
-        [&](const type::Struct* s) {
+        [&](const core::type::Struct* s) {
             if (!EmitStructType(&helpers_, s)) {
                 return false;
             }
@@ -3718,30 +3719,30 @@
         });
 }
 
-bool ASTPrinter::EmitValue(StringStream& out, const type::Type* type, int value) {
+bool ASTPrinter::EmitValue(StringStream& out, const core::type::Type* type, int value) {
     return Switch(
         type,
-        [&](const type::Bool*) {
+        [&](const core::type::Bool*) {
             out << (value == 0 ? "false" : "true");
             return true;
         },
-        [&](const type::F32*) {
+        [&](const core::type::F32*) {
             out << value << ".0f";
             return true;
         },
-        [&](const type::F16*) {
+        [&](const core::type::F16*) {
             out << "float16_t(" << value << ".0h)";
             return true;
         },
-        [&](const type::I32*) {
+        [&](const core::type::I32*) {
             out << value;
             return true;
         },
-        [&](const type::U32*) {
+        [&](const core::type::U32*) {
             out << value << "u";
             return true;
         },
-        [&](const type::Vector* vec) {
+        [&](const core::type::Vector* vec) {
             if (!EmitType(out, type, core::AddressSpace::kUndefined, core::Access::kReadWrite,
                           "")) {
                 return false;
@@ -3757,7 +3758,7 @@
             }
             return true;
         },
-        [&](const type::Matrix* mat) {
+        [&](const core::type::Matrix* mat) {
             if (!EmitType(out, type, core::AddressSpace::kUndefined, core::Access::kReadWrite,
                           "")) {
                 return false;
@@ -3773,13 +3774,13 @@
             }
             return true;
         },
-        [&](const type::Struct*) {
+        [&](const core::type::Struct*) {
             out << "(";
             TINT_DEFER(out << ")" << value);
             return EmitType(out, type, core::AddressSpace::kUndefined, core::Access::kUndefined,
                             "");
         },
-        [&](const type::Array*) {
+        [&](const core::type::Array*) {
             out << "(";
             TINT_DEFER(out << ")" << value);
             return EmitType(out, type, core::AddressSpace::kUndefined, core::Access::kUndefined,
@@ -3792,7 +3793,7 @@
         });
 }
 
-bool ASTPrinter::EmitZeroValue(StringStream& out, const type::Type* type) {
+bool ASTPrinter::EmitZeroValue(StringStream& out, const core::type::Type* type) {
     return EmitValue(out, type, 0);
 }
 
@@ -4152,7 +4153,7 @@
 }
 
 bool ASTPrinter::EmitType(StringStream& out,
-                          const type::Type* type,
+                          const core::type::Type* type,
                           core::AddressSpace address_space,
                           core::Access access,
                           const std::string& name,
@@ -4181,11 +4182,11 @@
 
     return Switch(
         type,
-        [&](const type::Array* ary) {
-            const type::Type* base_type = ary;
+        [&](const core::type::Array* ary) {
+            const core::type::Type* base_type = ary;
             std::vector<uint32_t> sizes;
-            while (auto* arr = base_type->As<type::Array>()) {
-                if (TINT_UNLIKELY(arr->Count()->Is<type::RuntimeArrayCount>())) {
+            while (auto* arr = base_type->As<core::type::Array>()) {
+                if (TINT_UNLIKELY(arr->Count()->Is<core::type::RuntimeArrayCount>())) {
                     TINT_ICE()
                         << "runtime arrays may only exist in storage buffers, which should have "
                            "been transformed into a ByteAddressBuffer";
@@ -4194,7 +4195,7 @@
                 const auto count = arr->ConstantCount();
                 if (!count) {
                     diagnostics_.add_error(diag::System::Writer,
-                                           type::Array::kErrExpectedConstantCount);
+                                           core::type::Array::kErrExpectedConstantCount);
                     return false;
                 }
 
@@ -4215,24 +4216,24 @@
             }
             return true;
         },
-        [&](const type::Bool*) {
+        [&](const core::type::Bool*) {
             out << "bool";
             return true;
         },
-        [&](const type::F32*) {
+        [&](const core::type::F32*) {
             out << "float";
             return true;
         },
-        [&](const type::F16*) {
+        [&](const core::type::F16*) {
             out << "float16_t";
             return true;
         },
-        [&](const type::I32*) {
+        [&](const core::type::I32*) {
             out << "int";
             return true;
         },
-        [&](const type::Matrix* mat) {
-            if (mat->type()->Is<type::F16>()) {
+        [&](const core::type::Matrix* mat) {
+            if (mat->type()->Is<core::type::F16>()) {
                 // Use matrix<type, N, M> for f16 matrix
                 out << "matrix<";
                 if (!EmitType(out, mat->type(), address_space, access, "")) {
@@ -4254,12 +4255,12 @@
             out << mat->columns() << "x" << mat->rows();
             return true;
         },
-        [&](const type::Pointer*) {
+        [&](const core::type::Pointer*) {
             TINT_ICE() << "Attempting to emit pointer type. These should have "
                           "been removed with the SimplifyPointers transform";
             return false;
         },
-        [&](const type::Sampler* sampler) {
+        [&](const core::type::Sampler* sampler) {
             out << "Sampler";
             if (sampler->IsComparison()) {
                 out << "Comparison";
@@ -4267,20 +4268,20 @@
             out << "State";
             return true;
         },
-        [&](const type::Struct* str) {
+        [&](const core::type::Struct* str) {
             out << StructName(str);
             return true;
         },
-        [&](const type::Texture* tex) {
-            if (TINT_UNLIKELY(tex->Is<type::ExternalTexture>())) {
+        [&](const core::type::Texture* tex) {
+            if (TINT_UNLIKELY(tex->Is<core::type::ExternalTexture>())) {
                 TINT_ICE() << "Multiplanar external texture transform was not run.";
                 return false;
             }
 
-            auto* storage = tex->As<type::StorageTexture>();
-            auto* ms = tex->As<type::MultisampledTexture>();
-            auto* depth_ms = tex->As<type::DepthMultisampledTexture>();
-            auto* sampled = tex->As<type::SampledTexture>();
+            auto* storage = tex->As<core::type::StorageTexture>();
+            auto* ms = tex->As<core::type::MultisampledTexture>();
+            auto* depth_ms = tex->As<core::type::DepthMultisampledTexture>();
+            auto* sampled = tex->As<core::type::SampledTexture>();
 
             if (storage && storage->access() != core::Access::kRead) {
                 out << "RW";
@@ -4288,22 +4289,22 @@
             out << "Texture";
 
             switch (tex->dim()) {
-                case type::TextureDimension::k1d:
+                case core::type::TextureDimension::k1d:
                     out << "1D";
                     break;
-                case type::TextureDimension::k2d:
+                case core::type::TextureDimension::k2d:
                     out << ((ms || depth_ms) ? "2DMS" : "2D");
                     break;
-                case type::TextureDimension::k2dArray:
+                case core::type::TextureDimension::k2dArray:
                     out << ((ms || depth_ms) ? "2DMSArray" : "2DArray");
                     break;
-                case type::TextureDimension::k3d:
+                case core::type::TextureDimension::k3d:
                     out << "3D";
                     break;
-                case type::TextureDimension::kCube:
+                case core::type::TextureDimension::kCube:
                     out << "Cube";
                     break;
-                case type::TextureDimension::kCubeArray:
+                case core::type::TextureDimension::kCubeArray:
                     out << "CubeArray";
                     break;
                 default:
@@ -4324,11 +4325,11 @@
             } else if (sampled || ms) {
                 auto* subtype = sampled ? sampled->type() : ms->type();
                 out << "<";
-                if (subtype->Is<type::F32>()) {
+                if (subtype->Is<core::type::F32>()) {
                     out << "float4";
-                } else if (subtype->Is<type::I32>()) {
+                } else if (subtype->Is<core::type::I32>()) {
                     out << "int4";
-                } else if (TINT_LIKELY(subtype->Is<type::U32>())) {
+                } else if (TINT_LIKELY(subtype->Is<core::type::U32>())) {
                     out << "uint4";
                 } else {
                     TINT_ICE() << "Unsupported multisampled texture type";
@@ -4338,19 +4339,19 @@
             }
             return true;
         },
-        [&](const type::U32*) {
+        [&](const core::type::U32*) {
             out << "uint";
             return true;
         },
-        [&](const type::Vector* vec) {
+        [&](const core::type::Vector* vec) {
             auto width = vec->Width();
-            if (vec->type()->Is<type::F32>() && width >= 1 && width <= 4) {
+            if (vec->type()->Is<core::type::F32>() && width >= 1 && width <= 4) {
                 out << "float" << width;
-            } else if (vec->type()->Is<type::I32>() && width >= 1 && width <= 4) {
+            } else if (vec->type()->Is<core::type::I32>() && width >= 1 && width <= 4) {
                 out << "int" << width;
-            } else if (vec->type()->Is<type::U32>() && width >= 1 && width <= 4) {
+            } else if (vec->type()->Is<core::type::U32>() && width >= 1 && width <= 4) {
                 out << "uint" << width;
-            } else if (vec->type()->Is<type::Bool>() && width >= 1 && width <= 4) {
+            } else if (vec->type()->Is<core::type::Bool>() && width >= 1 && width <= 4) {
                 out << "bool" << width;
             } else {
                 // For example, use "vector<float16_t, N>" for f16 vector.
@@ -4362,10 +4363,10 @@
             }
             return true;
         },
-        [&](const type::Atomic* atomic) {
+        [&](const core::type::Atomic* atomic) {
             return EmitType(out, atomic->Type(), address_space, access, name);
         },
-        [&](const type::Void*) {
+        [&](const core::type::Void*) {
             out << "void";
             return true;
         },
@@ -4376,7 +4377,7 @@
 }
 
 bool ASTPrinter::EmitTypeAndName(StringStream& out,
-                                 const type::Type* type,
+                                 const core::type::Type* type,
                                  core::AddressSpace address_space,
                                  core::Access access,
                                  const std::string& name) {
@@ -4390,7 +4391,7 @@
     return true;
 }
 
-bool ASTPrinter::EmitStructType(TextBuffer* b, const type::Struct* str) {
+bool ASTPrinter::EmitStructType(TextBuffer* b, const core::type::Struct* str) {
     auto it = emitted_structs_.emplace(str);
     if (!it.second) {
         return true;
@@ -4412,14 +4413,16 @@
                 if (TINT_UNLIKELY(pipeline_stage_uses.size() != 1)) {
                     TINT_ICE() << "invalid entry point IO struct uses";
                 }
-                if (pipeline_stage_uses.count(type::PipelineStageUsage::kVertexInput)) {
+                if (pipeline_stage_uses.count(core::type::PipelineStageUsage::kVertexInput)) {
                     post += " : TEXCOORD" + std::to_string(location.value());
-                } else if (pipeline_stage_uses.count(type::PipelineStageUsage::kVertexOutput)) {
+                } else if (pipeline_stage_uses.count(
+                               core::type::PipelineStageUsage::kVertexOutput)) {
                     post += " : TEXCOORD" + std::to_string(location.value());
-                } else if (pipeline_stage_uses.count(type::PipelineStageUsage::kFragmentInput)) {
+                } else if (pipeline_stage_uses.count(
+                               core::type::PipelineStageUsage::kFragmentInput)) {
                     post += " : TEXCOORD" + std::to_string(location.value());
                 } else if (TINT_LIKELY(pipeline_stage_uses.count(
-                               type::PipelineStageUsage::kFragmentOutput))) {
+                               core::type::PipelineStageUsage::kFragmentOutput))) {
                     if (auto index = attributes.index) {
                         post += " : SV_Target" + std::to_string(location.value() + index.value());
                     } else {
@@ -4562,7 +4565,7 @@
                     }
                     auto param_name = "param_" + std::to_string(parameter_names.size());
                     const auto* ty = param->Type();
-                    if (auto* ptr = ty->As<type::Pointer>()) {
+                    if (auto* ptr = ty->As<core::type::Pointer>()) {
                         decl << "inout ";
                         ty = ptr->StoreType();
                     }
@@ -4608,7 +4611,7 @@
     return true;
 }
 
-std::string ASTPrinter::StructName(const type::Struct* s) {
+std::string ASTPrinter::StructName(const core::type::Struct* s) {
     auto name = s->Name().Name();
     if (HasPrefix(name, "__")) {
         name = tint::GetOrCreate(builtin_struct_names_, s,
diff --git a/src/tint/lang/hlsl/writer/ast_printer/ast_printer.h b/src/tint/lang/hlsl/writer/ast_printer/ast_printer.h
index 0e029fe..ca4489c 100644
--- a/src/tint/lang/hlsl/writer/ast_printer/ast_printer.h
+++ b/src/tint/lang/hlsl/writer/ast_printer/ast_printer.h
@@ -420,7 +420,7 @@
     /// then the boolean is set to true.
     /// @returns true if the type is emitted
     bool EmitType(StringStream& out,
-                  const type::Type* type,
+                  const core::type::Type* type,
                   core::AddressSpace address_space,
                   core::Access access,
                   const std::string& name,
@@ -433,7 +433,7 @@
     /// @param name the name to emit
     /// @returns true if the type is emitted
     bool EmitTypeAndName(StringStream& out,
-                         const type::Type* type,
+                         const core::type::Type* type,
                          core::AddressSpace address_space,
                          core::Access access,
                          const std::string& name);
@@ -442,7 +442,7 @@
     /// @param buffer the text buffer that the type declaration will be written to
     /// @param ty the struct to generate
     /// @returns true if the struct is emitted
-    bool EmitStructType(TextBuffer* buffer, const type::Struct* ty);
+    bool EmitStructType(TextBuffer* buffer, const core::type::Struct* ty);
     /// Handles a unary op expression
     /// @param out the output of the expression stream
     /// @param expr the expression to emit
@@ -453,12 +453,12 @@
     /// @param type the type to emit the value for
     /// @param value the value to emit
     /// @returns true if the value was successfully emitted.
-    bool EmitValue(StringStream& out, const type::Type* type, int value);
+    bool EmitValue(StringStream& out, const core::type::Type* type, int value);
     /// Emits the zero value for the given type
     /// @param out the output stream
     /// @param type the type to emit the value for
     /// @returns true if the zero value was successfully emitted.
-    bool EmitZeroValue(StringStream& out, const type::Type* type);
+    bool EmitZeroValue(StringStream& out, const core::type::Type* type);
     /// Handles generating a 'var' declaration
     /// @param var the variable to generate
     /// @returns true if the variable was emitted
@@ -474,7 +474,8 @@
     /// via an accessor expression
     /// @param vec the vector type being assigned to
     /// @returns true on success
-    bool EmitDynamicVectorAssignment(const ast::AssignmentStatement* stmt, const type::Vector* vec);
+    bool EmitDynamicVectorAssignment(const ast::AssignmentStatement* stmt,
+                                     const core::type::Vector* vec);
     /// Emits call to a helper matrix assignment function for the input assignment
     /// statement and matrix type. This is used to work around FXC issues where
     /// assignment of a vector to a matrix with a dynamic index causes compilation
@@ -484,7 +485,7 @@
     /// @param mat the matrix type being assigned to
     /// @returns true on success
     bool EmitDynamicMatrixVectorAssignment(const ast::AssignmentStatement* stmt,
-                                           const type::Matrix* mat);
+                                           const core::type::Matrix* mat);
     /// Emits call to a helper matrix assignment function for the input assignment
     /// statement and matrix type. This is used to work around FXC issues where
     /// assignment of a scalar to a matrix with at least one dynamic index causes
@@ -494,7 +495,7 @@
     /// @param mat the matrix type being assigned to
     /// @returns true on success
     bool EmitDynamicMatrixScalarAssignment(const ast::AssignmentStatement* stmt,
-                                           const type::Matrix* mat);
+                                           const core::type::Matrix* mat);
 
     /// Handles generating a builtin method name
     /// @param builtin the semantic info for the builtin
@@ -535,7 +536,8 @@
     };
 
     /// The map key for two semantic types.
-    using BinaryType = tint::UnorderedKeyWrapper<std::tuple<const type::Type*, const type::Type*>>;
+    using BinaryType =
+        tint::UnorderedKeyWrapper<std::tuple<const core::type::Type*, const core::type::Type*>>;
 
     /// CallBuiltinHelper will call the builtin helper function, creating it
     /// if it hasn't been built already. If the builtin needs to be built then
@@ -560,7 +562,7 @@
     /// @returns the name of the structure, taking special care of builtin structures that start
     /// with double underscores. If the structure is a builtin, then the returned name will be a
     /// unique name without the leading underscores.
-    std::string StructName(const type::Struct* s);
+    std::string StructName(const core::type::Struct* s);
 
     /// @return a new, unique identifier with the given prefix.
     /// @param prefix optional prefix to apply to the generated identifier. If empty "tint_symbol"
@@ -579,18 +581,18 @@
     TextBuffer helpers_;
 
     /// Map of builtin structure to unique generated name
-    std::unordered_map<const type::Struct*, std::string> builtin_struct_names_;
+    std::unordered_map<const core::type::Struct*, std::string> builtin_struct_names_;
     std::function<bool()> emit_continuing_;
-    std::unordered_map<const type::Matrix*, std::string> matrix_scalar_inits_;
+    std::unordered_map<const core::type::Matrix*, std::string> matrix_scalar_inits_;
     std::unordered_map<const sem::Builtin*, std::string> builtins_;
     // Polyfill functions for bitcast expression, BinaryType indicates the source type and the
     // destination type.
     std::unordered_map<BinaryType, std::string> bitcast_funcs_;
-    std::unordered_map<const type::Vector*, std::string> dynamic_vector_write_;
-    std::unordered_map<const type::Matrix*, std::string> dynamic_matrix_vector_write_;
-    std::unordered_map<const type::Matrix*, std::string> dynamic_matrix_scalar_write_;
-    std::unordered_map<const type::Type*, std::string> value_or_one_if_zero_;
-    std::unordered_set<const type::Struct*> emitted_structs_;
+    std::unordered_map<const core::type::Vector*, std::string> dynamic_vector_write_;
+    std::unordered_map<const core::type::Matrix*, std::string> dynamic_matrix_vector_write_;
+    std::unordered_map<const core::type::Matrix*, std::string> dynamic_matrix_scalar_write_;
+    std::unordered_map<const core::type::Type*, std::string> value_or_one_if_zero_;
+    std::unordered_set<const core::type::Struct*> emitted_structs_;
 };
 
 }  // namespace tint::hlsl::writer
diff --git a/src/tint/lang/hlsl/writer/ast_printer/type_test.cc b/src/tint/lang/hlsl/writer/ast_printer/type_test.cc
index f7b2282..900670f 100644
--- a/src/tint/lang/hlsl/writer/ast_printer/type_test.cc
+++ b/src/tint/lang/hlsl/writer/ast_printer/type_test.cc
@@ -86,7 +86,7 @@
 }
 
 TEST_F(HlslASTPrinterTest_Type, EmitType_Bool) {
-    auto* bool_ = create<type::Bool>();
+    auto* bool_ = create<core::type::Bool>();
 
     ASTPrinter& gen = Build();
 
@@ -98,7 +98,7 @@
 }
 
 TEST_F(HlslASTPrinterTest_Type, EmitType_F16) {
-    auto* f16 = create<type::F16>();
+    auto* f16 = create<core::type::F16>();
 
     ASTPrinter& gen = Build();
 
@@ -110,7 +110,7 @@
 }
 
 TEST_F(HlslASTPrinterTest_Type, EmitType_F32) {
-    auto* f32 = create<type::F32>();
+    auto* f32 = create<core::type::F32>();
 
     ASTPrinter& gen = Build();
 
@@ -122,7 +122,7 @@
 }
 
 TEST_F(HlslASTPrinterTest_Type, EmitType_I32) {
-    auto* i32 = create<type::I32>();
+    auto* i32 = create<core::type::I32>();
 
     ASTPrinter& gen = Build();
 
@@ -134,9 +134,9 @@
 }
 
 TEST_F(HlslASTPrinterTest_Type, EmitType_Matrix_F16) {
-    auto* f16 = create<type::F16>();
-    auto* vec3 = create<type::Vector>(f16, 3u);
-    auto* mat2x3 = create<type::Matrix>(vec3, 2u);
+    auto* f16 = create<core::type::F16>();
+    auto* vec3 = create<core::type::Vector>(f16, 3u);
+    auto* mat2x3 = create<core::type::Matrix>(vec3, 2u);
 
     ASTPrinter& gen = Build();
 
@@ -148,9 +148,9 @@
 }
 
 TEST_F(HlslASTPrinterTest_Type, EmitType_Matrix_F32) {
-    auto* f32 = create<type::F32>();
-    auto* vec3 = create<type::Vector>(f32, 3u);
-    auto* mat2x3 = create<type::Matrix>(vec3, 2u);
+    auto* f32 = create<core::type::F32>();
+    auto* vec3 = create<core::type::Vector>(f32, 3u);
+    auto* mat2x3 = create<core::type::Matrix>(vec3, 2u);
 
     ASTPrinter& gen = Build();
 
@@ -171,7 +171,7 @@
     ASTPrinter& gen = Build();
 
     tint::TextGenerator::TextBuffer buf;
-    auto* str = program->TypeOf(s)->As<type::Struct>();
+    auto* str = program->TypeOf(s)->As<core::type::Struct>();
     ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
     EXPECT_EQ(buf.String(), R"(struct S {
   int a;
@@ -203,7 +203,7 @@
 
     ASTPrinter& gen = Build();
 
-    auto* str = program->TypeOf(s)->As<type::Struct>();
+    auto* str = program->TypeOf(s)->As<core::type::Struct>();
     StringStream out;
     ASSERT_TRUE(
         gen.EmitType(out, str, core::AddressSpace::kUndefined, core::Access::kReadWrite, ""))
@@ -238,7 +238,7 @@
     ASTPrinter& gen = Build();
 
     tint::TextGenerator::TextBuffer buf;
-    auto* str = program->TypeOf(s)->As<type::Struct>();
+    auto* str = program->TypeOf(s)->As<core::type::Struct>();
     ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
     EXPECT_EQ(buf.String(), R"(struct S {
   int a;
@@ -248,7 +248,7 @@
 }
 
 TEST_F(HlslASTPrinterTest_Type, EmitType_U32) {
-    auto* u32 = create<type::U32>();
+    auto* u32 = create<core::type::U32>();
 
     ASTPrinter& gen = Build();
 
@@ -260,8 +260,8 @@
 }
 
 TEST_F(HlslASTPrinterTest_Type, EmitType_Vector) {
-    auto* f32 = create<type::F32>();
-    auto* vec3 = create<type::Vector>(f32, 3u);
+    auto* f32 = create<core::type::F32>();
+    auto* vec3 = create<core::type::Vector>(f32, 3u);
 
     ASTPrinter& gen = Build();
 
@@ -273,7 +273,7 @@
 }
 
 TEST_F(HlslASTPrinterTest_Type, EmitType_Void) {
-    auto* void_ = create<type::Void>();
+    auto* void_ = create<core::type::Void>();
 
     ASTPrinter& gen = Build();
 
@@ -285,7 +285,7 @@
 }
 
 TEST_F(HlslASTPrinterTest_Type, EmitSampler) {
-    auto* sampler = create<type::Sampler>(type::SamplerKind::kSampler);
+    auto* sampler = create<core::type::Sampler>(core::type::SamplerKind::kSampler);
 
     ASTPrinter& gen = Build();
 
@@ -297,7 +297,7 @@
 }
 
 TEST_F(HlslASTPrinterTest_Type, EmitSamplerComparison) {
-    auto* sampler = create<type::Sampler>(type::SamplerKind::kComparisonSampler);
+    auto* sampler = create<core::type::Sampler>(core::type::SamplerKind::kComparisonSampler);
 
     ASTPrinter& gen = Build();
 
@@ -309,7 +309,7 @@
 }
 
 struct HlslDepthTextureData {
-    type::TextureDimension dim;
+    core::type::TextureDimension dim;
     std::string result;
 };
 inline std::ostream& operator<<(std::ostream& out, HlslDepthTextureData data) {
@@ -342,18 +342,18 @@
 INSTANTIATE_TEST_SUITE_P(
     HlslASTPrinterTest_Type,
     HlslDepthTexturesTest,
-    testing::Values(HlslDepthTextureData{type::TextureDimension::k2d,
+    testing::Values(HlslDepthTextureData{core::type::TextureDimension::k2d,
                                          "Texture2D tex : register(t1, space2);"},
-                    HlslDepthTextureData{type::TextureDimension::k2dArray,
+                    HlslDepthTextureData{core::type::TextureDimension::k2dArray,
                                          "Texture2DArray tex : register(t1, space2);"},
-                    HlslDepthTextureData{type::TextureDimension::kCube,
+                    HlslDepthTextureData{core::type::TextureDimension::kCube,
                                          "TextureCube tex : register(t1, space2);"},
-                    HlslDepthTextureData{type::TextureDimension::kCubeArray,
+                    HlslDepthTextureData{core::type::TextureDimension::kCubeArray,
                                          "TextureCubeArray tex : register(t1, space2);"}));
 
 using HlslDepthMultisampledTexturesTest = TestHelper;
 TEST_F(HlslDepthMultisampledTexturesTest, Emit) {
-    auto t = ty.depth_multisampled_texture(type::TextureDimension::k2d);
+    auto t = ty.depth_multisampled_texture(core::type::TextureDimension::k2d);
 
     GlobalVar("tex", t, Binding(1_a), Group(2_a));
 
@@ -373,7 +373,7 @@
 
 enum class TextureDataType { F32, U32, I32 };
 struct HlslSampledTextureData {
-    type::TextureDimension dim;
+    core::type::TextureDimension dim;
     TextureDataType datatype;
     std::string result;
 };
@@ -420,99 +420,99 @@
                          HlslSampledTexturesTest,
                          testing::Values(
                              HlslSampledTextureData{
-                                 type::TextureDimension::k1d,
+                                 core::type::TextureDimension::k1d,
                                  TextureDataType::F32,
                                  "Texture1D<float4> tex : register(t1, space2);",
                              },
                              HlslSampledTextureData{
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  TextureDataType::F32,
                                  "Texture2D<float4> tex : register(t1, space2);",
                              },
                              HlslSampledTextureData{
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  TextureDataType::F32,
                                  "Texture2DArray<float4> tex : register(t1, space2);",
                              },
                              HlslSampledTextureData{
-                                 type::TextureDimension::k3d,
+                                 core::type::TextureDimension::k3d,
                                  TextureDataType::F32,
                                  "Texture3D<float4> tex : register(t1, space2);",
                              },
                              HlslSampledTextureData{
-                                 type::TextureDimension::kCube,
+                                 core::type::TextureDimension::kCube,
                                  TextureDataType::F32,
                                  "TextureCube<float4> tex : register(t1, space2);",
                              },
                              HlslSampledTextureData{
-                                 type::TextureDimension::kCubeArray,
+                                 core::type::TextureDimension::kCubeArray,
                                  TextureDataType::F32,
                                  "TextureCubeArray<float4> tex : register(t1, space2);",
                              },
                              HlslSampledTextureData{
-                                 type::TextureDimension::k1d,
+                                 core::type::TextureDimension::k1d,
                                  TextureDataType::U32,
                                  "Texture1D<uint4> tex : register(t1, space2);",
                              },
                              HlslSampledTextureData{
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  TextureDataType::U32,
                                  "Texture2D<uint4> tex : register(t1, space2);",
                              },
                              HlslSampledTextureData{
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  TextureDataType::U32,
                                  "Texture2DArray<uint4> tex : register(t1, space2);",
                              },
                              HlslSampledTextureData{
-                                 type::TextureDimension::k3d,
+                                 core::type::TextureDimension::k3d,
                                  TextureDataType::U32,
                                  "Texture3D<uint4> tex : register(t1, space2);",
                              },
                              HlslSampledTextureData{
-                                 type::TextureDimension::kCube,
+                                 core::type::TextureDimension::kCube,
                                  TextureDataType::U32,
                                  "TextureCube<uint4> tex : register(t1, space2);",
                              },
                              HlslSampledTextureData{
-                                 type::TextureDimension::kCubeArray,
+                                 core::type::TextureDimension::kCubeArray,
                                  TextureDataType::U32,
                                  "TextureCubeArray<uint4> tex : register(t1, space2);",
                              },
                              HlslSampledTextureData{
-                                 type::TextureDimension::k1d,
+                                 core::type::TextureDimension::k1d,
                                  TextureDataType::I32,
                                  "Texture1D<int4> tex : register(t1, space2);",
                              },
                              HlslSampledTextureData{
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  TextureDataType::I32,
                                  "Texture2D<int4> tex : register(t1, space2);",
                              },
                              HlslSampledTextureData{
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  TextureDataType::I32,
                                  "Texture2DArray<int4> tex : register(t1, space2);",
                              },
                              HlslSampledTextureData{
-                                 type::TextureDimension::k3d,
+                                 core::type::TextureDimension::k3d,
                                  TextureDataType::I32,
                                  "Texture3D<int4> tex : register(t1, space2);",
                              },
                              HlslSampledTextureData{
-                                 type::TextureDimension::kCube,
+                                 core::type::TextureDimension::kCube,
                                  TextureDataType::I32,
                                  "TextureCube<int4> tex : register(t1, space2);",
                              },
                              HlslSampledTextureData{
-                                 type::TextureDimension::kCubeArray,
+                                 core::type::TextureDimension::kCubeArray,
                                  TextureDataType::I32,
                                  "TextureCubeArray<int4> tex : register(t1, space2);",
                              }));
 
 TEST_F(HlslASTPrinterTest_Type, EmitMultisampledTexture) {
-    auto* f32 = create<type::F32>();
-    auto* s = create<type::MultisampledTexture>(type::TextureDimension::k2d, f32);
+    auto* f32 = create<core::type::F32>();
+    auto* s = create<core::type::MultisampledTexture>(core::type::TextureDimension::k2d, f32);
 
     ASTPrinter& gen = Build();
 
@@ -523,7 +523,7 @@
 }
 
 struct HlslStorageTextureData {
-    type::TextureDimension dim;
+    core::type::TextureDimension dim;
     core::TexelFormat imgfmt;
     std::string result;
 };
@@ -562,31 +562,31 @@
     HlslASTPrinterTest_Type,
     HlslStorageTexturesTest,
     testing::Values(
-        HlslStorageTextureData{type::TextureDimension::k1d, core::TexelFormat::kRgba8Unorm,
+        HlslStorageTextureData{core::type::TextureDimension::k1d, core::TexelFormat::kRgba8Unorm,
                                "RWTexture1D<float4> tex : register(u1, space2);"},
-        HlslStorageTextureData{type::TextureDimension::k2d, core::TexelFormat::kRgba16Float,
+        HlslStorageTextureData{core::type::TextureDimension::k2d, core::TexelFormat::kRgba16Float,
                                "RWTexture2D<float4> tex : register(u1, space2);"},
-        HlslStorageTextureData{type::TextureDimension::k2dArray, core::TexelFormat::kR32Float,
+        HlslStorageTextureData{core::type::TextureDimension::k2dArray, core::TexelFormat::kR32Float,
                                "RWTexture2DArray<float4> tex : register(u1, space2);"},
-        HlslStorageTextureData{type::TextureDimension::k3d, core::TexelFormat::kRg32Float,
+        HlslStorageTextureData{core::type::TextureDimension::k3d, core::TexelFormat::kRg32Float,
                                "RWTexture3D<float4> tex : register(u1, space2);"},
-        HlslStorageTextureData{type::TextureDimension::k1d, core::TexelFormat::kRgba32Float,
+        HlslStorageTextureData{core::type::TextureDimension::k1d, core::TexelFormat::kRgba32Float,
                                "RWTexture1D<float4> tex : register(u1, space2);"},
-        HlslStorageTextureData{type::TextureDimension::k2d, core::TexelFormat::kRgba16Uint,
+        HlslStorageTextureData{core::type::TextureDimension::k2d, core::TexelFormat::kRgba16Uint,
                                "RWTexture2D<uint4> tex : register(u1, space2);"},
-        HlslStorageTextureData{type::TextureDimension::k2dArray, core::TexelFormat::kR32Uint,
+        HlslStorageTextureData{core::type::TextureDimension::k2dArray, core::TexelFormat::kR32Uint,
                                "RWTexture2DArray<uint4> tex : register(u1, space2);"},
-        HlslStorageTextureData{type::TextureDimension::k3d, core::TexelFormat::kRg32Uint,
+        HlslStorageTextureData{core::type::TextureDimension::k3d, core::TexelFormat::kRg32Uint,
                                "RWTexture3D<uint4> tex : register(u1, space2);"},
-        HlslStorageTextureData{type::TextureDimension::k1d, core::TexelFormat::kRgba32Uint,
+        HlslStorageTextureData{core::type::TextureDimension::k1d, core::TexelFormat::kRgba32Uint,
                                "RWTexture1D<uint4> tex : register(u1, space2);"},
-        HlslStorageTextureData{type::TextureDimension::k2d, core::TexelFormat::kRgba16Sint,
+        HlslStorageTextureData{core::type::TextureDimension::k2d, core::TexelFormat::kRgba16Sint,
                                "RWTexture2D<int4> tex : register(u1, space2);"},
-        HlslStorageTextureData{type::TextureDimension::k2dArray, core::TexelFormat::kR32Sint,
+        HlslStorageTextureData{core::type::TextureDimension::k2dArray, core::TexelFormat::kR32Sint,
                                "RWTexture2DArray<int4> tex : register(u1, space2);"},
-        HlslStorageTextureData{type::TextureDimension::k3d, core::TexelFormat::kRg32Sint,
+        HlslStorageTextureData{core::type::TextureDimension::k3d, core::TexelFormat::kRg32Sint,
                                "RWTexture3D<int4> tex : register(u1, space2);"},
-        HlslStorageTextureData{type::TextureDimension::k1d, core::TexelFormat::kRgba32Sint,
+        HlslStorageTextureData{core::type::TextureDimension::k1d, core::TexelFormat::kRgba32Sint,
                                "RWTexture1D<int4> tex : register(u1, space2);"}));
 
 }  // namespace
diff --git a/src/tint/lang/msl/writer/ast_printer/ast_printer.cc b/src/tint/lang/msl/writer/ast_printer/ast_printer.cc
index 1a017d8..b8a659d 100644
--- a/src/tint/lang/msl/writer/ast_printer/ast_printer.cc
+++ b/src/tint/lang/msl/writer/ast_printer/ast_printer.cc
@@ -98,14 +98,14 @@
   public:
     ScopedBitCast(ASTPrinter* generator,
                   StringStream& stream,
-                  const type::Type* curr_type,
-                  const type::Type* target_type)
+                  const core::type::Type* curr_type,
+                  const core::type::Type* target_type)
         : s(stream) {
-        auto* target_vec_type = target_type->As<type::Vector>();
+        auto* target_vec_type = target_type->As<core::type::Vector>();
 
         // If we need to promote from scalar to vector, bitcast the scalar to the
         // vector element type.
-        if (curr_type->Is<type::Scalar>() && target_vec_type) {
+        if (curr_type->Is<core::type::Scalar>() && target_vec_type) {
             target_type = target_vec_type->type();
         }
 
@@ -325,8 +325,8 @@
     return true;
 }
 
-bool ASTPrinter::EmitTypeDecl(const type::Type* ty) {
-    if (auto* str = ty->As<type::Struct>()) {
+bool ASTPrinter::EmitTypeDecl(const core::type::Type* ty) {
+    if (auto* str = ty->As<core::type::Struct>()) {
         if (!EmitStructType(current_buffer_, str)) {
             return false;
         }
@@ -465,20 +465,22 @@
         return true;
     };
 
-    auto signed_type_of = [&](const type::Type* ty) -> const type::Type* {
+    auto signed_type_of = [&](const core::type::Type* ty) -> const core::type::Type* {
         if (ty->is_integer_scalar()) {
-            return builder_.create<type::I32>();
-        } else if (auto* v = ty->As<type::Vector>()) {
-            return builder_.create<type::Vector>(builder_.create<type::I32>(), v->Width());
+            return builder_.create<core::type::I32>();
+        } else if (auto* v = ty->As<core::type::Vector>()) {
+            return builder_.create<core::type::Vector>(builder_.create<core::type::I32>(),
+                                                       v->Width());
         }
         return {};
     };
 
-    auto unsigned_type_of = [&](const type::Type* ty) -> const type::Type* {
+    auto unsigned_type_of = [&](const core::type::Type* ty) -> const core::type::Type* {
         if (ty->is_integer_scalar()) {
-            return builder_.create<type::U32>();
-        } else if (auto* v = ty->As<type::Vector>()) {
-            return builder_.create<type::Vector>(builder_.create<type::U32>(), v->Width());
+            return builder_.create<core::type::U32>();
+        } else if (auto* v = ty->As<core::type::Vector>()) {
+            return builder_.create<core::type::Vector>(builder_.create<core::type::U32>(),
+                                                       v->Width());
         }
         return {};
     };
@@ -506,9 +508,9 @@
         rhs_type->is_signed_integer_scalar_or_vector()) {
         // If lhs or rhs is a vector, use that type (support implicit scalar to
         // vector promotion)
-        auto* target_type = lhs_type->Is<type::Vector>()
+        auto* target_type = lhs_type->Is<core::type::Vector>()
                                 ? lhs_type
-                                : (rhs_type->Is<type::Vector>() ? rhs_type : lhs_type);
+                                : (rhs_type->Is<core::type::Vector>() ? rhs_type : lhs_type);
 
         // WGSL defines behaviour for signed overflow, MSL does not. For these
         // cases, bitcast operands to unsigned, then cast result to signed.
@@ -557,7 +559,7 @@
     }
 
     // Handle '&' and '|' of booleans.
-    if ((expr->IsAnd() || expr->IsOr()) && lhs_type->Is<type::Bool>()) {
+    if ((expr->IsAnd() || expr->IsOr()) && lhs_type->Is<core::type::Bool>()) {
         out << "bool";
         ScopedParen sp(out);
         if (!EmitExpression(out, expr->lhs)) {
@@ -677,7 +679,7 @@
         }
         case core::Function::kQuantizeToF16: {
             std::string width = "";
-            if (auto* vec = builtin->ReturnType()->As<type::Vector>()) {
+            if (auto* vec = builtin->ReturnType()->As<core::type::Vector>()) {
                 width = std::to_string(vec->Width());
             }
             out << "float" << width << "(half" << width << "(";
@@ -700,7 +702,7 @@
 
         case core::Function::kLength: {
             auto* sem = builder_.Sem().GetVal(expr->args[0]);
-            if (sem->Type()->UnwrapRef()->Is<type::Scalar>()) {
+            if (sem->Type()->UnwrapRef()->Is<core::type::Scalar>()) {
                 // Emulate scalar overload using fabs(x).
                 name = "fabs";
             }
@@ -709,7 +711,7 @@
 
         case core::Function::kDistance: {
             auto* sem = builder_.Sem().GetVal(expr->args[0]);
-            if (sem->Type()->UnwrapRef()->Is<type::Scalar>()) {
+            if (sem->Type()->UnwrapRef()->Is<core::type::Scalar>()) {
                 // Emulate scalar overload using fabs(x - y);
                 out << "fabs";
                 ScopedParen sp(out);
@@ -777,7 +779,7 @@
 
     bool ok = Switch(
         type,
-        [&](const type::Array*) {
+        [&](const core::type::Array*) {
             if (!EmitType(out, type)) {
                 return false;
             }
@@ -785,7 +787,7 @@
             terminator = "}";
             return true;
         },
-        [&](const type::Struct*) {
+        [&](const core::type::Struct*) {
             out << "{";
             terminator = "}";
             return true;
@@ -807,7 +809,7 @@
             out << ", ";
         }
 
-        if (auto* struct_ty = type->As<type::Struct>()) {
+        if (auto* struct_ty = type->As<core::type::Struct>()) {
             // Emit field designators for structures to account for padding members.
             auto name = struct_ty->Members()[i]->Name().Name();
             out << "." << name << "=";
@@ -878,13 +880,14 @@
             return call("atomic_exchange_explicit", true);
 
         case core::Function::kAtomicCompareExchangeWeak: {
-            auto* ptr_ty = TypeOf(expr->args[0])->UnwrapRef()->As<type::Pointer>();
+            auto* ptr_ty = TypeOf(expr->args[0])->UnwrapRef()->As<core::type::Pointer>();
             auto sc = ptr_ty->AddressSpace();
-            auto* str = builtin->ReturnType()->As<type::Struct>();
+            auto* str = builtin->ReturnType()->As<core::type::Struct>();
 
             auto func = tint::GetOrCreate(
                 atomicCompareExchangeWeak_, ACEWKeyType{{sc, str}}, [&]() -> std::string {
-                    if (!EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>())) {
+                    if (!EmitStructType(&helpers_,
+                                        builtin->ReturnType()->As<core::type::Struct>())) {
                         return "";
                     }
 
@@ -895,7 +898,7 @@
 
                     {
                         auto f = Line(&buf);
-                        auto str_name = StructName(builtin->ReturnType()->As<type::Struct>());
+                        auto str_name = StructName(builtin->ReturnType()->As<core::type::Struct>());
                         f << str_name << " " << name << "(";
                         if (!EmitTypeAndName(f, atomic_ty, "atomic")) {
                             return "";
@@ -968,7 +971,7 @@
         return false;
     }
 
-    auto* texture_type = TypeOf(texture)->UnwrapRef()->As<type::Texture>();
+    auto* texture_type = TypeOf(texture)->UnwrapRef()->As<core::type::Texture>();
 
     // Helper to emit the texture expression, wrapped in parentheses if the
     // expression includes an operator with lower precedence than the member
@@ -989,25 +992,25 @@
     };
 
     // MSL requires that `lod` is a constant 0 for 1D textures.
-    bool level_is_constant_zero = texture_type->dim() == type::TextureDimension::k1d;
+    bool level_is_constant_zero = texture_type->dim() == core::type::TextureDimension::k1d;
 
     switch (builtin->Type()) {
         case core::Function::kTextureDimensions: {
             std::vector<const char*> dims;
             switch (texture_type->dim()) {
-                case type::TextureDimension::kNone:
+                case core::type::TextureDimension::kNone:
                     diagnostics_.add_error(diag::System::Writer, "texture dimension is kNone");
                     return false;
-                case type::TextureDimension::k1d:
+                case core::type::TextureDimension::k1d:
                     dims = {"width"};
                     break;
-                case type::TextureDimension::k2d:
-                case type::TextureDimension::k2dArray:
-                case type::TextureDimension::kCube:
-                case type::TextureDimension::kCubeArray:
+                case core::type::TextureDimension::k2d:
+                case core::type::TextureDimension::k2dArray:
+                case core::type::TextureDimension::kCube:
+                case core::type::TextureDimension::kCubeArray:
                     dims = {"width", "height"};
                     break;
-                case type::TextureDimension::k3d:
+                case core::type::TextureDimension::k3d:
                     dims = {"width", "height", "depth"};
                     break;
             }
@@ -1123,14 +1126,14 @@
             if (usage == Usage::kCoords && e->Type()->UnwrapRef()->is_integer_scalar_or_vector()) {
                 casted = true;
                 switch (texture_type->dim()) {
-                    case type::TextureDimension::k1d:
+                    case core::type::TextureDimension::k1d:
                         out << "uint(";
                         break;
-                    case type::TextureDimension::k2d:
-                    case type::TextureDimension::k2dArray:
+                    case core::type::TextureDimension::k2d:
+                    case core::type::TextureDimension::k2dArray:
                         out << "uint2(";
                         break;
-                    case type::TextureDimension::k3d:
+                    case core::type::TextureDimension::k3d:
                         out << "uint3(";
                         break;
                     default:
@@ -1180,17 +1183,17 @@
     if (auto* ddx = arg(Usage::kDdx)) {
         auto dim = texture_type->dim();
         switch (dim) {
-            case type::TextureDimension::k2d:
-            case type::TextureDimension::k2dArray:
+            case core::type::TextureDimension::k2d:
+            case core::type::TextureDimension::k2dArray:
                 maybe_write_comma();
                 out << "gradient2d(";
                 break;
-            case type::TextureDimension::k3d:
+            case core::type::TextureDimension::k3d:
                 maybe_write_comma();
                 out << "gradient3d(";
                 break;
-            case type::TextureDimension::kCube:
-            case type::TextureDimension::kCubeArray:
+            case core::type::TextureDimension::kCube:
+            case core::type::TextureDimension::kCubeArray:
                 maybe_write_comma();
                 out << "gradientcube(";
                 break;
@@ -1225,8 +1228,8 @@
         if (!has_offset) {
             // offset argument may need to be provided if we have a component.
             switch (texture_type->dim()) {
-                case type::TextureDimension::k2d:
-                case type::TextureDimension::k2dArray:
+                case core::type::TextureDimension::k2d:
+                case core::type::TextureDimension::k2dArray:
                     out << "int2(0), ";
                     break;
                 default:
@@ -1261,7 +1264,7 @@
 bool ASTPrinter::EmitDotCall(StringStream& out,
                              const ast::CallExpression* expr,
                              const sem::Builtin* builtin) {
-    auto* vec_ty = builtin->Parameters()[0]->Type()->As<type::Vector>();
+    auto* vec_ty = builtin->Parameters()[0]->Type()->As<core::type::Vector>();
     std::string fn = "dot";
     if (vec_ty->type()->is_integer_scalar()) {
         // MSL does not have a builtin for dot() with integer vector types.
@@ -1312,17 +1315,17 @@
             auto in = params[0];
 
             std::string width;
-            if (auto* vec = ty->As<type::Vector>()) {
+            if (auto* vec = ty->As<core::type::Vector>()) {
                 width = std::to_string(vec->Width());
             }
 
             // Emit the builtin return type unique to this overload. This does not
             // exist in the AST, so it will not be generated in Generate().
-            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>())) {
+            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<core::type::Struct>())) {
                 return false;
             }
 
-            Line(b) << StructName(builtin->ReturnType()->As<type::Struct>()) << " result;";
+            Line(b) << StructName(builtin->ReturnType()->As<core::type::Struct>()) << " result;";
             Line(b) << "result.fract = modf(" << in << ", result.whole);";
             Line(b) << "return result;";
             return true;
@@ -1338,17 +1341,17 @@
             auto in = params[0];
 
             std::string width;
-            if (auto* vec = ty->As<type::Vector>()) {
+            if (auto* vec = ty->As<core::type::Vector>()) {
                 width = std::to_string(vec->Width());
             }
 
             // Emit the builtin return type unique to this overload. This does not
             // exist in the AST, so it will not be generated in Generate().
-            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<type::Struct>())) {
+            if (!EmitStructType(&helpers_, builtin->ReturnType()->As<core::type::Struct>())) {
                 return false;
             }
 
-            Line(b) << StructName(builtin->ReturnType()->As<type::Struct>()) << " result;";
+            Line(b) << StructName(builtin->ReturnType()->As<core::type::Struct>()) << " result;";
             Line(b) << "result.fract = frexp(" << in << ", result.exp);";
             Line(b) << "return result;";
             return true;
@@ -1578,44 +1581,44 @@
     return true;
 }
 
-bool ASTPrinter::EmitZeroValue(StringStream& out, const type::Type* type) {
+bool ASTPrinter::EmitZeroValue(StringStream& out, const core::type::Type* type) {
     return Switch(
         type,
-        [&](const type::Bool*) {
+        [&](const core::type::Bool*) {
             out << "false";
             return true;
         },
-        [&](const type::F16*) {
+        [&](const core::type::F16*) {
             out << "0.0h";
             return true;
         },
-        [&](const type::F32*) {
+        [&](const core::type::F32*) {
             out << "0.0f";
             return true;
         },
-        [&](const type::I32*) {
+        [&](const core::type::I32*) {
             out << "0";
             return true;
         },
-        [&](const type::U32*) {
+        [&](const core::type::U32*) {
             out << "0u";
             return true;
         },
-        [&](const type::Vector* vec) {  //
+        [&](const core::type::Vector* vec) {  //
             return EmitZeroValue(out, vec->type());
         },
-        [&](const type::Matrix* mat) {
+        [&](const core::type::Matrix* mat) {
             if (!EmitType(out, mat)) {
                 return false;
             }
             ScopedParen sp(out);
             return EmitZeroValue(out, mat->type());
         },
-        [&](const type::Array*) {
+        [&](const core::type::Array*) {
             out << "{}";
             return true;
         },
-        [&](const type::Struct*) {
+        [&](const core::type::Struct*) {
             out << "{}";
             return true;
         },
@@ -1629,27 +1632,27 @@
 bool ASTPrinter::EmitConstant(StringStream& out, const core::constant::Value* constant) {
     return Switch(
         constant->Type(),  //
-        [&](const type::Bool*) {
+        [&](const core::type::Bool*) {
             out << (constant->ValueAs<AInt>() ? "true" : "false");
             return true;
         },
-        [&](const type::F32*) {
+        [&](const core::type::F32*) {
             PrintF32(out, constant->ValueAs<f32>());
             return true;
         },
-        [&](const type::F16*) {
+        [&](const core::type::F16*) {
             PrintF16(out, constant->ValueAs<f16>());
             return true;
         },
-        [&](const type::I32*) {
+        [&](const core::type::I32*) {
             PrintI32(out, constant->ValueAs<i32>());
             return true;
         },
-        [&](const type::U32*) {
+        [&](const core::type::U32*) {
             out << constant->ValueAs<AInt>() << "u";
             return true;
         },
-        [&](const type::Vector* v) {
+        [&](const core::type::Vector* v) {
             if (!EmitType(out, v)) {
                 return false;
             }
@@ -1673,7 +1676,7 @@
             }
             return true;
         },
-        [&](const type::Matrix* m) {
+        [&](const core::type::Matrix* m) {
             if (!EmitType(out, m)) {
                 return false;
             }
@@ -1690,7 +1693,7 @@
             }
             return true;
         },
-        [&](const type::Array* a) {
+        [&](const core::type::Array* a) {
             if (!EmitType(out, a)) {
                 return false;
             }
@@ -1705,7 +1708,7 @@
             auto count = a->ConstantCount();
             if (!count) {
                 diagnostics_.add_error(diag::System::Writer,
-                                       type::Array::kErrExpectedConstantCount);
+                                       core::type::Array::kErrExpectedConstantCount);
                 return false;
             }
 
@@ -1720,7 +1723,7 @@
 
             return true;
         },
-        [&](const type::Struct* s) {
+        [&](const core::type::Struct* s) {
             if (!EmitStructType(&helpers_, s)) {
                 return false;
             }
@@ -1850,7 +1853,7 @@
             if (!EmitType(out, type)) {
                 return false;
             }
-            if (type->Is<type::Pointer>()) {
+            if (type->Is<core::type::Pointer>()) {
                 out << " const";
             }
             out << " " << v->name->symbol.Name();
@@ -1919,11 +1922,11 @@
 
             bool ok = Switch(
                 type,  //
-                [&](const type::Struct*) {
+                [&](const core::type::Struct*) {
                     out << " [[stage_in]]";
                     return true;
                 },
-                [&](const type::Texture*) {
+                [&](const core::type::Texture*) {
                     uint32_t binding = get_binding_index(param);
                     if (binding == kInvalidBindingIndex) {
                         return false;
@@ -1931,7 +1934,7 @@
                     out << " [[texture(" << binding << ")]]";
                     return true;
                 },
-                [&](const type::Sampler*) {
+                [&](const core::type::Sampler*) {
                     uint32_t binding = get_binding_index(param);
                     if (binding == kInvalidBindingIndex) {
                         return false;
@@ -1939,7 +1942,7 @@
                     out << " [[sampler(" << binding << ")]]";
                     return true;
                 },
-                [&](const type::Pointer* ptr) {
+                [&](const core::type::Pointer* ptr) {
                     switch (ptr->AddressSpace()) {
                         case core::AddressSpace::kWorkgroup: {
                             auto& allocations = workgroup_allocations_[func_name];
@@ -2427,34 +2430,34 @@
     return true;
 }
 
-bool ASTPrinter::EmitType(StringStream& out, const type::Type* type) {
+bool ASTPrinter::EmitType(StringStream& out, const core::type::Type* type) {
     return Switch(
         type,
-        [&](const type::Atomic* atomic) {
-            if (atomic->Type()->Is<type::I32>()) {
+        [&](const core::type::Atomic* atomic) {
+            if (atomic->Type()->Is<core::type::I32>()) {
                 out << "atomic_int";
                 return true;
             }
-            if (TINT_LIKELY(atomic->Type()->Is<type::U32>())) {
+            if (TINT_LIKELY(atomic->Type()->Is<core::type::U32>())) {
                 out << "atomic_uint";
                 return true;
             }
             TINT_ICE() << "unhandled atomic type " << atomic->Type()->FriendlyName();
             return false;
         },
-        [&](const type::Array* arr) {
+        [&](const core::type::Array* arr) {
             out << ArrayType() << "<";
             if (!EmitType(out, arr->ElemType())) {
                 return false;
             }
             out << ", ";
-            if (arr->Count()->Is<type::RuntimeArrayCount>()) {
+            if (arr->Count()->Is<core::type::RuntimeArrayCount>()) {
                 out << "1";
             } else {
                 auto count = arr->ConstantCount();
                 if (!count) {
                     diagnostics_.add_error(diag::System::Writer,
-                                           type::Array::kErrExpectedConstantCount);
+                                           core::type::Array::kErrExpectedConstantCount);
                     return false;
                 }
 
@@ -2463,30 +2466,30 @@
             out << ">";
             return true;
         },
-        [&](const type::Bool*) {
+        [&](const core::type::Bool*) {
             out << "bool";
             return true;
         },
-        [&](const type::F16*) {
+        [&](const core::type::F16*) {
             out << "half";
             return true;
         },
-        [&](const type::F32*) {
+        [&](const core::type::F32*) {
             out << "float";
             return true;
         },
-        [&](const type::I32*) {
+        [&](const core::type::I32*) {
             out << "int";
             return true;
         },
-        [&](const type::Matrix* mat) {
+        [&](const core::type::Matrix* mat) {
             if (!EmitType(out, mat->type())) {
                 return false;
             }
             out << mat->columns() << "x" << mat->rows();
             return true;
         },
-        [&](const type::Pointer* ptr) {
+        [&](const core::type::Pointer* ptr) {
             if (ptr->Access() == core::Access::kRead) {
                 out << "const ";
             }
@@ -2500,52 +2503,53 @@
             out << "*";
             return true;
         },
-        [&](const type::Sampler*) {
+        [&](const core::type::Sampler*) {
             out << "sampler";
             return true;
         },
-        [&](const type::Struct* str) {
+        [&](const core::type::Struct* str) {
             // The struct type emits as just the name. The declaration would be
             // emitted as part of emitting the declared types.
             out << StructName(str);
             return true;
         },
-        [&](const type::Texture* tex) {
-            if (TINT_UNLIKELY(tex->Is<type::ExternalTexture>())) {
+        [&](const core::type::Texture* tex) {
+            if (TINT_UNLIKELY(tex->Is<core::type::ExternalTexture>())) {
                 TINT_ICE() << "Multiplanar external texture transform was not run.";
                 return false;
             }
 
-            if (tex->IsAnyOf<type::DepthTexture, type::DepthMultisampledTexture>()) {
+            if (tex->IsAnyOf<core::type::DepthTexture, core::type::DepthMultisampledTexture>()) {
                 out << "depth";
             } else {
                 out << "texture";
             }
 
             switch (tex->dim()) {
-                case type::TextureDimension::k1d:
+                case core::type::TextureDimension::k1d:
                     out << "1d";
                     break;
-                case type::TextureDimension::k2d:
+                case core::type::TextureDimension::k2d:
                     out << "2d";
                     break;
-                case type::TextureDimension::k2dArray:
+                case core::type::TextureDimension::k2dArray:
                     out << "2d_array";
                     break;
-                case type::TextureDimension::k3d:
+                case core::type::TextureDimension::k3d:
                     out << "3d";
                     break;
-                case type::TextureDimension::kCube:
+                case core::type::TextureDimension::kCube:
                     out << "cube";
                     break;
-                case type::TextureDimension::kCubeArray:
+                case core::type::TextureDimension::kCubeArray:
                     out << "cube_array";
                     break;
                 default:
                     diagnostics_.add_error(diag::System::Writer, "Invalid texture dimensions");
                     return false;
             }
-            if (tex->IsAnyOf<type::MultisampledTexture, type::DepthMultisampledTexture>()) {
+            if (tex->IsAnyOf<core::type::MultisampledTexture,
+                             core::type::DepthMultisampledTexture>()) {
                 out << "_ms";
             }
             out << "<";
@@ -2553,15 +2557,15 @@
 
             return Switch(
                 tex,
-                [&](const type::DepthTexture*) {
+                [&](const core::type::DepthTexture*) {
                     out << "float, access::sample";
                     return true;
                 },
-                [&](const type::DepthMultisampledTexture*) {
+                [&](const core::type::DepthMultisampledTexture*) {
                     out << "float, access::read";
                     return true;
                 },
-                [&](const type::StorageTexture* storage) {
+                [&](const core::type::StorageTexture* storage) {
                     if (!EmitType(out, storage->type())) {
                         return false;
                     }
@@ -2578,14 +2582,14 @@
                     }
                     return true;
                 },
-                [&](const type::MultisampledTexture* ms) {
+                [&](const core::type::MultisampledTexture* ms) {
                     if (!EmitType(out, ms->type())) {
                         return false;
                     }
                     out << ", access::read";
                     return true;
                 },
-                [&](const type::SampledTexture* sampled) {
+                [&](const core::type::SampledTexture* sampled) {
                     if (!EmitType(out, sampled->type())) {
                         return false;
                     }
@@ -2597,11 +2601,11 @@
                     return false;
                 });
         },
-        [&](const type::U32*) {
+        [&](const core::type::U32*) {
             out << "uint";
             return true;
         },
-        [&](const type::Vector* vec) {
+        [&](const core::type::Vector* vec) {
             if (vec->Packed()) {
                 out << "packed_";
             }
@@ -2611,7 +2615,7 @@
             out << vec->Width();
             return true;
         },
-        [&](const type::Void*) {
+        [&](const core::type::Void*) {
             out << "void";
             return true;
         },
@@ -2623,7 +2627,7 @@
 }
 
 bool ASTPrinter::EmitTypeAndName(StringStream& out,
-                                 const type::Type* type,
+                                 const core::type::Type* type,
                                  const std::string& name) {
     if (!EmitType(out, type)) {
         return false;
@@ -2655,7 +2659,7 @@
     return false;
 }
 
-bool ASTPrinter::EmitStructType(TextBuffer* b, const type::Struct* str) {
+bool ASTPrinter::EmitStructType(TextBuffer* b, const core::type::Struct* str) {
     auto it = emitted_structs_.emplace(str);
     if (!it.second) {
         return true;
@@ -2734,14 +2738,14 @@
                 return false;
             }
 
-            if (pipeline_stage_uses.count(type::PipelineStageUsage::kVertexInput)) {
+            if (pipeline_stage_uses.count(core::type::PipelineStageUsage::kVertexInput)) {
                 out << " [[attribute(" + std::to_string(location.value()) + ")]]";
-            } else if (pipeline_stage_uses.count(type::PipelineStageUsage::kVertexOutput)) {
+            } else if (pipeline_stage_uses.count(core::type::PipelineStageUsage::kVertexOutput)) {
                 out << " [[user(locn" + std::to_string(location.value()) + ")]]";
-            } else if (pipeline_stage_uses.count(type::PipelineStageUsage::kFragmentInput)) {
+            } else if (pipeline_stage_uses.count(core::type::PipelineStageUsage::kFragmentInput)) {
                 out << " [[user(locn" + std::to_string(location.value()) + ")]]";
-            } else if (TINT_LIKELY(
-                           pipeline_stage_uses.count(type::PipelineStageUsage::kFragmentOutput))) {
+            } else if (TINT_LIKELY(pipeline_stage_uses.count(
+                           core::type::PipelineStageUsage::kFragmentOutput))) {
                 if (auto index = attributes.index) {
                     out << " [[color(" + std::to_string(location.value()) + ") index(" +
                                std::to_string(index.value()) + ")]]";
@@ -3031,7 +3035,7 @@
     return array_template_name_;
 }
 
-std::string ASTPrinter::StructName(const type::Struct* s) {
+std::string ASTPrinter::StructName(const core::type::Struct* s) {
     auto name = s->Name().Name();
     if (HasPrefix(name, "__")) {
         name = tint::GetOrCreate(builtin_struct_names_, s,
diff --git a/src/tint/lang/msl/writer/ast_printer/ast_printer.h b/src/tint/lang/msl/writer/ast_printer/ast_printer.h
index 6d98660..3194f84 100644
--- a/src/tint/lang/msl/writer/ast_printer/ast_printer.h
+++ b/src/tint/lang/msl/writer/ast_printer/ast_printer.h
@@ -102,7 +102,7 @@
     /// Handles generating a declared type
     /// @param ty the declared type to generate
     /// @returns true if the declared type was emitted
-    bool EmitTypeDecl(const type::Type* ty);
+    bool EmitTypeDecl(const core::type::Type* ty);
     /// Handles an index accessor expression
     /// @param out the output of the expression stream
     /// @param expr the expression to emit
@@ -312,13 +312,13 @@
     /// @param out the output of the type stream
     /// @param type the type to generate
     /// @returns true if the type is emitted
-    bool EmitType(StringStream& out, const type::Type* type);
+    bool EmitType(StringStream& out, const core::type::Type* type);
     /// Handles generating type and name
     /// @param out the output stream
     /// @param type the type to generate
     /// @param name the name to emit
     /// @returns true if the type is emitted
-    bool EmitTypeAndName(StringStream& out, const type::Type* type, const std::string& name);
+    bool EmitTypeAndName(StringStream& out, const core::type::Type* type, const std::string& name);
     /// Handles generating a address space
     /// @param out the output of the type stream
     /// @param sc the address space to generate
@@ -329,7 +329,7 @@
     /// @param buffer the text buffer that the type declaration will be written to
     /// @param str the struct to generate
     /// @returns true if the struct is emitted
-    bool EmitStructType(TextBuffer* buffer, const type::Struct* str);
+    bool EmitStructType(TextBuffer* buffer, const core::type::Struct* str);
     /// Handles a unary op expression
     /// @param out the output of the expression stream
     /// @param expr the expression to emit
@@ -347,7 +347,7 @@
     /// @param out the output of the expression stream
     /// @param type the type to emit the value for
     /// @returns true if the zero value was successfully emitted.
-    bool EmitZeroValue(StringStream& out, const type::Type* type);
+    bool EmitZeroValue(StringStream& out, const core::type::Type* type);
 
     /// Handles generating a builtin name
     /// @param builtin the semantic info for the builtin
@@ -382,7 +382,7 @@
     /// @returns the name of the structure, taking special care of builtin structures that start
     /// with double underscores. If the structure is a builtin, then the returned name will be a
     /// unique name without the leading underscores.
-    std::string StructName(const type::Struct* s);
+    std::string StructName(const core::type::Struct* s);
 
     /// @return a new, unique identifier with the given prefix.
     /// @param prefix optional prefix to apply to the generated identifier. If empty "tint_symbol"
@@ -400,14 +400,14 @@
     TextBuffer helpers_;  // Helper functions emitted at the top of the output
 
     /// Map of builtin structure to unique generated name
-    std::unordered_map<const type::Struct*, std::string> builtin_struct_names_;
+    std::unordered_map<const core::type::Struct*, std::string> builtin_struct_names_;
 
     std::function<bool()> emit_continuing_;
 
     /// Name of atomicCompareExchangeWeak() helper for the given pointer storage
     /// class and struct return type
     using ACEWKeyType =
-        tint::UnorderedKeyWrapper<std::tuple<core::AddressSpace, const type::Struct*>>;
+        tint::UnorderedKeyWrapper<std::tuple<core::AddressSpace, const core::type::Struct*>>;
     std::unordered_map<ACEWKeyType, std::string> atomicCompareExchangeWeak_;
 
     /// Unique name of the 'TINT_INVARIANT' preprocessor define.
@@ -427,9 +427,9 @@
     std::unordered_map<std::string, std::vector<uint32_t>> workgroup_allocations_;
 
     std::unordered_map<const sem::Builtin*, std::string> builtins_;
-    std::unordered_map<const type::Type*, std::string> unary_minus_funcs_;
+    std::unordered_map<const core::type::Type*, std::string> unary_minus_funcs_;
     std::unordered_map<uint32_t, std::string> int_dot_funcs_;
-    std::unordered_set<const type::Struct*> emitted_structs_;
+    std::unordered_set<const core::type::Struct*> emitted_structs_;
 };
 
 }  // namespace tint::msl::writer
diff --git a/src/tint/lang/msl/writer/ast_printer/ast_type_test.cc b/src/tint/lang/msl/writer/ast_printer/ast_type_test.cc
index 15ce7f4..13a64aa 100644
--- a/src/tint/lang/msl/writer/ast_printer/ast_type_test.cc
+++ b/src/tint/lang/msl/writer/ast_printer/ast_type_test.cc
@@ -148,7 +148,7 @@
 }
 
 TEST_F(MslASTPrinterTest, EmitType_Bool) {
-    auto* bool_ = create<type::Bool>();
+    auto* bool_ = create<core::type::Bool>();
 
     ASTPrinter& gen = Build();
 
@@ -158,7 +158,7 @@
 }
 
 TEST_F(MslASTPrinterTest, EmitType_F32) {
-    auto* f32 = create<type::F32>();
+    auto* f32 = create<core::type::F32>();
 
     ASTPrinter& gen = Build();
 
@@ -168,7 +168,7 @@
 }
 
 TEST_F(MslASTPrinterTest, EmitType_F16) {
-    auto* f16 = create<type::F16>();
+    auto* f16 = create<core::type::F16>();
 
     ASTPrinter& gen = Build();
 
@@ -178,7 +178,7 @@
 }
 
 TEST_F(MslASTPrinterTest, EmitType_I32) {
-    auto* i32 = create<type::I32>();
+    auto* i32 = create<core::type::I32>();
 
     ASTPrinter& gen = Build();
 
@@ -188,9 +188,9 @@
 }
 
 TEST_F(MslASTPrinterTest, EmitType_Matrix_F32) {
-    auto* f32 = create<type::F32>();
-    auto* vec3 = create<type::Vector>(f32, 3u);
-    auto* mat2x3 = create<type::Matrix>(vec3, 2u);
+    auto* f32 = create<core::type::F32>();
+    auto* vec3 = create<core::type::Vector>(f32, 3u);
+    auto* mat2x3 = create<core::type::Matrix>(vec3, 2u);
 
     ASTPrinter& gen = Build();
 
@@ -200,9 +200,9 @@
 }
 
 TEST_F(MslASTPrinterTest, EmitType_Matrix_F16) {
-    auto* f16 = create<type::F16>();
-    auto* vec3 = create<type::Vector>(f16, 3u);
-    auto* mat2x3 = create<type::Matrix>(vec3, 2u);
+    auto* f16 = create<core::type::F16>();
+    auto* vec3 = create<core::type::Vector>(f16, 3u);
+    auto* mat2x3 = create<core::type::Matrix>(vec3, 2u);
 
     ASTPrinter& gen = Build();
 
@@ -212,8 +212,9 @@
 }
 
 TEST_F(MslASTPrinterTest, EmitType_Pointer) {
-    auto* f32 = create<type::F32>();
-    auto* p = create<type::Pointer>(core::AddressSpace::kWorkgroup, f32, core::Access::kReadWrite);
+    auto* f32 = create<core::type::F32>();
+    auto* p =
+        create<core::type::Pointer>(core::AddressSpace::kWorkgroup, f32, core::Access::kReadWrite);
 
     ASTPrinter& gen = Build();
 
@@ -244,7 +245,7 @@
     ASTPrinter& gen = Build();
 
     tint::TextGenerator::TextBuffer buf;
-    auto* str = program->TypeOf(s)->As<type::Struct>();
+    auto* str = program->TypeOf(s)->As<core::type::Struct>();
     ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
     EXPECT_EQ(buf.String(), R"(struct S {
   int a;
@@ -291,7 +292,7 @@
     ASTPrinter& gen = Build();
 
     tint::TextGenerator::TextBuffer buf;
-    auto* str = program->TypeOf(type)->As<type::Struct>();
+    auto* str = program->TypeOf(type)->As<core::type::Struct>();
     ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
 
     // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, ARRAY_COUNT, NAME)
@@ -398,7 +399,7 @@
     ASTPrinter& gen = Build();
 
     tint::TextGenerator::TextBuffer buf;
-    auto* str = program->TypeOf(type)->As<type::Struct>();
+    auto* str = program->TypeOf(type)->As<core::type::Struct>();
     ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
 
     // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, ARRAY_COUNT, NAME)
@@ -490,7 +491,7 @@
     ASTPrinter& gen = Build();
 
     tint::TextGenerator::TextBuffer buf;
-    auto* str = program->TypeOf(type)->As<type::Struct>();
+    auto* str = program->TypeOf(type)->As<core::type::Struct>();
     ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
 
     // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, ARRAY_COUNT, NAME)
@@ -574,7 +575,7 @@
     ASTPrinter& gen = Build();
 
     tint::TextGenerator::TextBuffer buf;
-    auto* str = program->TypeOf(type)->As<type::Struct>();
+    auto* str = program->TypeOf(type)->As<core::type::Struct>();
     ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
 
     // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, ARRAY_COUNT, NAME)
@@ -636,7 +637,7 @@
     ASTPrinter& gen = Build();
 
     tint::TextGenerator::TextBuffer buf;
-    auto* str = program->TypeOf(type)->As<type::Struct>();
+    auto* str = program->TypeOf(type)->As<core::type::Struct>();
     ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
     EXPECT_EQ(buf.String(), R"(struct S {
   /* 0x0000 */ int tint_pad_2;
@@ -695,7 +696,7 @@
     ASTPrinter& gen = Build();
 
     tint::TextGenerator::TextBuffer buf;
-    auto* str = program->TypeOf(type)->As<type::Struct>();
+    auto* str = program->TypeOf(type)->As<core::type::Struct>();
     ASSERT_TRUE(gen.EmitStructType(&buf, str)) << gen.Diagnostics();
     EXPECT_EQ(buf.String(), R"(struct S {
   /* 0x0000 */ int a;
@@ -705,7 +706,7 @@
 }
 
 TEST_F(MslASTPrinterTest, EmitType_U32) {
-    auto* u32 = create<type::U32>();
+    auto* u32 = create<core::type::U32>();
 
     ASTPrinter& gen = Build();
 
@@ -715,8 +716,8 @@
 }
 
 TEST_F(MslASTPrinterTest, EmitType_Vector) {
-    auto* f32 = create<type::F32>();
-    auto* vec3 = create<type::Vector>(f32, 3u);
+    auto* f32 = create<core::type::F32>();
+    auto* vec3 = create<core::type::Vector>(f32, 3u);
 
     ASTPrinter& gen = Build();
 
@@ -726,7 +727,7 @@
 }
 
 TEST_F(MslASTPrinterTest, EmitType_Void) {
-    auto* void_ = create<type::Void>();
+    auto* void_ = create<core::type::Void>();
 
     ASTPrinter& gen = Build();
 
@@ -736,7 +737,7 @@
 }
 
 TEST_F(MslASTPrinterTest, EmitType_Sampler) {
-    auto* sampler = create<type::Sampler>(type::SamplerKind::kSampler);
+    auto* sampler = create<core::type::Sampler>(core::type::SamplerKind::kSampler);
 
     ASTPrinter& gen = Build();
 
@@ -746,7 +747,7 @@
 }
 
 TEST_F(MslASTPrinterTest, EmitType_SamplerComparison) {
-    auto* sampler = create<type::Sampler>(type::SamplerKind::kComparisonSampler);
+    auto* sampler = create<core::type::Sampler>(core::type::SamplerKind::kComparisonSampler);
 
     ASTPrinter& gen = Build();
 
@@ -756,7 +757,7 @@
 }
 
 struct MslDepthTextureData {
-    type::TextureDimension dim;
+    core::type::TextureDimension dim;
     std::string result;
 };
 inline std::ostream& operator<<(std::ostream& out, MslDepthTextureData data) {
@@ -769,7 +770,7 @@
 TEST_P(MslDepthTexturesTest, Emit) {
     auto params = GetParam();
 
-    type::DepthTexture s(params.dim);
+    core::type::DepthTexture s(params.dim);
 
     ASTPrinter& gen = Build();
 
@@ -780,17 +781,18 @@
 INSTANTIATE_TEST_SUITE_P(
     MslASTPrinterTest,
     MslDepthTexturesTest,
-    testing::Values(
-        MslDepthTextureData{type::TextureDimension::k2d, "depth2d<float, access::sample>"},
-        MslDepthTextureData{type::TextureDimension::k2dArray,
-                            "depth2d_array<float, access::sample>"},
-        MslDepthTextureData{type::TextureDimension::kCube, "depthcube<float, access::sample>"},
-        MslDepthTextureData{type::TextureDimension::kCubeArray,
-                            "depthcube_array<float, access::sample>"}));
+    testing::Values(MslDepthTextureData{core::type::TextureDimension::k2d,
+                                        "depth2d<float, access::sample>"},
+                    MslDepthTextureData{core::type::TextureDimension::k2dArray,
+                                        "depth2d_array<float, access::sample>"},
+                    MslDepthTextureData{core::type::TextureDimension::kCube,
+                                        "depthcube<float, access::sample>"},
+                    MslDepthTextureData{core::type::TextureDimension::kCubeArray,
+                                        "depthcube_array<float, access::sample>"}));
 
 using MslDepthMultisampledTexturesTest = TestHelper;
 TEST_F(MslDepthMultisampledTexturesTest, Emit) {
-    type::DepthMultisampledTexture s(type::TextureDimension::k2d);
+    core::type::DepthMultisampledTexture s(core::type::TextureDimension::k2d);
 
     ASTPrinter& gen = Build();
 
@@ -800,7 +802,7 @@
 }
 
 struct MslTextureData {
-    type::TextureDimension dim;
+    core::type::TextureDimension dim;
     std::string result;
 };
 inline std::ostream& operator<<(std::ostream& out, MslTextureData data) {
@@ -813,8 +815,8 @@
 TEST_P(MslSampledtexturesTest, Emit) {
     auto params = GetParam();
 
-    auto* f32 = create<type::F32>();
-    auto* s = create<type::SampledTexture>(params.dim, f32);
+    auto* f32 = create<core::type::F32>();
+    auto* s = create<core::type::SampledTexture>(params.dim, f32);
 
     ASTPrinter& gen = Build();
 
@@ -826,17 +828,18 @@
     MslASTPrinterTest,
     MslSampledtexturesTest,
     testing::Values(
-        MslTextureData{type::TextureDimension::k1d, "texture1d<float, access::sample>"},
-        MslTextureData{type::TextureDimension::k2d, "texture2d<float, access::sample>"},
-        MslTextureData{type::TextureDimension::k2dArray, "texture2d_array<float, access::sample>"},
-        MslTextureData{type::TextureDimension::k3d, "texture3d<float, access::sample>"},
-        MslTextureData{type::TextureDimension::kCube, "texturecube<float, access::sample>"},
-        MslTextureData{type::TextureDimension::kCubeArray,
+        MslTextureData{core::type::TextureDimension::k1d, "texture1d<float, access::sample>"},
+        MslTextureData{core::type::TextureDimension::k2d, "texture2d<float, access::sample>"},
+        MslTextureData{core::type::TextureDimension::k2dArray,
+                       "texture2d_array<float, access::sample>"},
+        MslTextureData{core::type::TextureDimension::k3d, "texture3d<float, access::sample>"},
+        MslTextureData{core::type::TextureDimension::kCube, "texturecube<float, access::sample>"},
+        MslTextureData{core::type::TextureDimension::kCubeArray,
                        "texturecube_array<float, access::sample>"}));
 
 TEST_F(MslASTPrinterTest, Emit_TypeMultisampledTexture) {
-    auto* u32 = create<type::U32>();
-    auto* ms = create<type::MultisampledTexture>(type::TextureDimension::k2d, u32);
+    auto* u32 = create<core::type::U32>();
+    auto* ms = create<core::type::MultisampledTexture>(core::type::TextureDimension::k2d, u32);
 
     ASTPrinter& gen = Build();
 
@@ -846,7 +849,7 @@
 }
 
 struct MslStorageTextureData {
-    type::TextureDimension dim;
+    core::type::TextureDimension dim;
     std::string result;
 };
 inline std::ostream& operator<<(std::ostream& out, MslStorageTextureData data) {
@@ -867,15 +870,17 @@
     ASSERT_TRUE(gen.EmitType(out, program->TypeOf(type))) << gen.Diagnostics();
     EXPECT_EQ(out.str(), params.result);
 }
-INSTANTIATE_TEST_SUITE_P(
-    MslASTPrinterTest,
-    MslStorageTexturesTest,
-    testing::Values(
-        MslStorageTextureData{type::TextureDimension::k1d, "texture1d<float, access::write>"},
-        MslStorageTextureData{type::TextureDimension::k2d, "texture2d<float, access::write>"},
-        MslStorageTextureData{type::TextureDimension::k2dArray,
-                              "texture2d_array<float, access::write>"},
-        MslStorageTextureData{type::TextureDimension::k3d, "texture3d<float, access::write>"}));
+INSTANTIATE_TEST_SUITE_P(MslASTPrinterTest,
+                         MslStorageTexturesTest,
+                         testing::Values(MslStorageTextureData{core::type::TextureDimension::k1d,
+                                                               "texture1d<float, access::write>"},
+                                         MslStorageTextureData{core::type::TextureDimension::k2d,
+                                                               "texture2d<float, access::write>"},
+                                         MslStorageTextureData{
+                                             core::type::TextureDimension::k2dArray,
+                                             "texture2d_array<float, access::write>"},
+                                         MslStorageTextureData{core::type::TextureDimension::k3d,
+                                                               "texture3d<float, access::write>"}));
 
 }  // namespace
 }  // namespace tint::msl::writer
diff --git a/src/tint/lang/msl/writer/common/printer_support.cc b/src/tint/lang/msl/writer/common/printer_support.cc
index c97543a4..3311449 100644
--- a/src/tint/lang/msl/writer/common/printer_support.cc
+++ b/src/tint/lang/msl/writer/common/printer_support.cc
@@ -98,30 +98,31 @@
     return attr;
 }
 
-SizeAndAlign MslPackedTypeSizeAndAlign(const type::Type* ty) {
+SizeAndAlign MslPackedTypeSizeAndAlign(const core::type::Type* ty) {
     return tint::Switch(
         ty,
 
         // https://developer.apple.com/metal/Metal-Shading-Language-Specification.pdf
         // 2.1 Scalar Data Types
-        [&](const type::U32*) {
+        [&](const core::type::U32*) {
             return SizeAndAlign{4, 4};
         },
-        [&](const type::I32*) {
+        [&](const core::type::I32*) {
             return SizeAndAlign{4, 4};
         },
-        [&](const type::F32*) {
+        [&](const core::type::F32*) {
             return SizeAndAlign{4, 4};
         },
-        [&](const type::F16*) {
+        [&](const core::type::F16*) {
             return SizeAndAlign{2, 2};
         },
 
-        [&](const type::Vector* vec) {
+        [&](const core::type::Vector* vec) {
             auto num_els = vec->Width();
             auto* el_ty = vec->type();
             SizeAndAlign el_size_align = MslPackedTypeSizeAndAlign(el_ty);
-            if (el_ty->IsAnyOf<type::U32, type::I32, type::F32, type::F16>()) {
+            if (el_ty->IsAnyOf<core::type::U32, core::type::I32, core::type::F32,
+                               core::type::F16>()) {
                 // Use a packed_vec type for 3-element vectors only.
                 if (num_els == 3) {
                     // https://developer.apple.com/metal/Metal-Shading-Language-Specification.pdf
@@ -138,14 +139,14 @@
             return SizeAndAlign{};
         },
 
-        [&](const type::Matrix* mat) {
+        [&](const core::type::Matrix* mat) {
             // https://developer.apple.com/metal/Metal-Shading-Language-Specification.pdf
             // 2.3 Matrix Data Types
             auto cols = mat->columns();
             auto rows = mat->rows();
             auto* el_ty = mat->type();
             // Metal only support half and float matrix.
-            if (el_ty->IsAnyOf<type::F32, type::F16>()) {
+            if (el_ty->IsAnyOf<core::type::F32, core::type::F16>()) {
                 static constexpr SizeAndAlign table_f32[] = {
                     /* float2x2 */ {16, 8},
                     /* float2x3 */ {32, 16},
@@ -169,7 +170,7 @@
                     /* half4x4 */ {32, 8},
                 };
                 if (cols >= 2 && cols <= 4 && rows >= 2 && rows <= 4) {
-                    if (el_ty->Is<type::F32>()) {
+                    if (el_ty->Is<core::type::F32>()) {
                         return table_f32[(3 * (cols - 2)) + (rows - 2)];
                     } else {
                         return table_f16[(3 * (cols - 2)) + (rows - 2)];
@@ -181,30 +182,30 @@
             return SizeAndAlign{};
         },
 
-        [&](const type::Array* arr) {
+        [&](const core::type::Array* arr) {
             if (TINT_UNLIKELY(!arr->IsStrideImplicit())) {
                 TINT_ICE()
                     << "arrays with explicit strides should not exist past the SPIR-V reader";
                 return SizeAndAlign{};
             }
-            if (arr->Count()->Is<type::RuntimeArrayCount>()) {
+            if (arr->Count()->Is<core::type::RuntimeArrayCount>()) {
                 return SizeAndAlign{arr->Stride(), arr->Align()};
             }
             if (auto count = arr->ConstantCount()) {
                 return SizeAndAlign{arr->Stride() * count.value(), arr->Align()};
             }
-            TINT_ICE() << type::Array::kErrExpectedConstantCount;
+            TINT_ICE() << core::type::Array::kErrExpectedConstantCount;
             return SizeAndAlign{};
         },
 
-        [&](const type::Struct* str) {
+        [&](const core::type::Struct* str) {
             // TODO(crbug.com/tint/650): There's an assumption here that MSL's
             // default structure size and alignment matches WGSL's. We need to
             // confirm this.
             return SizeAndAlign{str->Size(), str->Align()};
         },
 
-        [&](const type::Atomic* atomic) { return MslPackedTypeSizeAndAlign(atomic->Type()); },
+        [&](const core::type::Atomic* atomic) { return MslPackedTypeSizeAndAlign(atomic->Type()); },
 
         [&](Default) {
             TINT_UNREACHABLE() << "Unhandled type " << ty->TypeInfo().name;
diff --git a/src/tint/lang/msl/writer/common/printer_support.h b/src/tint/lang/msl/writer/common/printer_support.h
index ddec2ed..f8807ff 100644
--- a/src/tint/lang/msl/writer/common/printer_support.h
+++ b/src/tint/lang/msl/writer/common/printer_support.h
@@ -35,7 +35,7 @@
 
 /// @param ty the type to generate size and align for
 /// @returns the MSL packed type size and alignment in bytes for the given type.
-SizeAndAlign MslPackedTypeSizeAndAlign(const type::Type* ty);
+SizeAndAlign MslPackedTypeSizeAndAlign(const core::type::Type* ty);
 
 /// Converts a builtin to an attribute name
 /// @param builtin the builtin to convert
diff --git a/src/tint/lang/msl/writer/printer/helper_test.h b/src/tint/lang/msl/writer/printer/helper_test.h
index 84887d1..e4ca774 100644
--- a/src/tint/lang/msl/writer/printer/helper_test.h
+++ b/src/tint/lang/msl/writer/printer/helper_test.h
@@ -54,7 +54,7 @@
     /// The test builder.
     ir::Builder b{mod};
     /// The type manager.
-    type::Manager& ty{mod.Types()};
+    core::type::Manager& ty{mod.Types()};
 
   protected:
     /// The MSL writer.
diff --git a/src/tint/lang/msl/writer/printer/printer.cc b/src/tint/lang/msl/writer/printer/printer.cc
index 96059f6..15cdd31 100644
--- a/src/tint/lang/msl/writer/printer/printer.cc
+++ b/src/tint/lang/msl/writer/printer/printer.cc
@@ -179,7 +179,7 @@
 void Printer::EmitBinary(ir::Binary* b) {
     if (b->Kind() == ir::Binary::Kind::kEqual) {
         auto* rhs = b->RHS()->As<ir::Constant>();
-        if (rhs && rhs->Type()->Is<type::Bool>() && rhs->Value()->ValueAs<bool>() == false) {
+        if (rhs && rhs->Type()->Is<core::type::Bool>() && rhs->Value()->ValueAs<bool>() == false) {
             // expr == false
             Bind(b->Result(), "!(" + Expr(b->LHS()) + ")");
             return;
@@ -238,7 +238,7 @@
 void Printer::EmitVar(ir::Var* v) {
     auto out = Line();
 
-    auto* ptr = v->Result()->Type()->As<type::Pointer>();
+    auto* ptr = v->Result()->Type()->As<core::type::Pointer>();
     TINT_ASSERT_OR_RETURN(ptr);
 
     auto space = ptr->AddressSpace();
@@ -363,23 +363,23 @@
     }
 }
 
-void Printer::EmitType(StringStream& out, const type::Type* ty) {
+void Printer::EmitType(StringStream& out, const core::type::Type* ty) {
     tint::Switch(
-        ty,                                         //
-        [&](const type::Bool*) { out << "bool"; },  //
-        [&](const type::Void*) { out << "void"; },  //
-        [&](const type::F32*) { out << "float"; },  //
-        [&](const type::F16*) { out << "half"; },   //
-        [&](const type::I32*) { out << "int"; },    //
-        [&](const type::U32*) { out << "uint"; },   //
-        [&](const type::Array* arr) { EmitArrayType(out, arr); },
-        [&](const type::Vector* vec) { EmitVectorType(out, vec); },
-        [&](const type::Matrix* mat) { EmitMatrixType(out, mat); },
-        [&](const type::Atomic* atomic) { EmitAtomicType(out, atomic); },
-        [&](const type::Pointer* ptr) { EmitPointerType(out, ptr); },
-        [&](const type::Sampler*) { out << "sampler"; },  //
-        [&](const type::Texture* tex) { EmitTextureType(out, tex); },
-        [&](const type::Struct* str) {
+        ty,                                               //
+        [&](const core::type::Bool*) { out << "bool"; },  //
+        [&](const core::type::Void*) { out << "void"; },  //
+        [&](const core::type::F32*) { out << "float"; },  //
+        [&](const core::type::F16*) { out << "half"; },   //
+        [&](const core::type::I32*) { out << "int"; },    //
+        [&](const core::type::U32*) { out << "uint"; },   //
+        [&](const core::type::Array* arr) { EmitArrayType(out, arr); },
+        [&](const core::type::Vector* vec) { EmitVectorType(out, vec); },
+        [&](const core::type::Matrix* mat) { EmitMatrixType(out, mat); },
+        [&](const core::type::Atomic* atomic) { EmitAtomicType(out, atomic); },
+        [&](const core::type::Pointer* ptr) { EmitPointerType(out, ptr); },
+        [&](const core::type::Sampler*) { out << "sampler"; },  //
+        [&](const core::type::Texture* tex) { EmitTextureType(out, tex); },
+        [&](const core::type::Struct* str) {
             out << StructName(str);
 
             TINT_SCOPED_ASSIGNMENT(current_buffer_, &preamble_buffer_);
@@ -388,7 +388,7 @@
         [&](Default) { UNHANDLED_CASE(ty); });
 }
 
-void Printer::EmitPointerType(StringStream& out, const type::Pointer* ptr) {
+void Printer::EmitPointerType(StringStream& out, const core::type::Pointer* ptr) {
     if (ptr->Access() == core::Access::kRead) {
         out << "const ";
     }
@@ -398,28 +398,28 @@
     out << "*";
 }
 
-void Printer::EmitAtomicType(StringStream& out, const type::Atomic* atomic) {
-    if (atomic->Type()->Is<type::I32>()) {
+void Printer::EmitAtomicType(StringStream& out, const core::type::Atomic* atomic) {
+    if (atomic->Type()->Is<core::type::I32>()) {
         out << "atomic_int";
         return;
     }
-    if (TINT_LIKELY(atomic->Type()->Is<type::U32>())) {
+    if (TINT_LIKELY(atomic->Type()->Is<core::type::U32>())) {
         out << "atomic_uint";
         return;
     }
     TINT_ICE() << "unhandled atomic type " << atomic->Type()->FriendlyName();
 }
 
-void Printer::EmitArrayType(StringStream& out, const type::Array* arr) {
+void Printer::EmitArrayType(StringStream& out, const core::type::Array* arr) {
     out << ArrayTemplateName() << "<";
     EmitType(out, arr->ElemType());
     out << ", ";
-    if (arr->Count()->Is<type::RuntimeArrayCount>()) {
+    if (arr->Count()->Is<core::type::RuntimeArrayCount>()) {
         out << "1";
     } else {
         auto count = arr->ConstantCount();
         if (!count) {
-            TINT_ICE() << type::Array::kErrExpectedConstantCount;
+            TINT_ICE() << core::type::Array::kErrExpectedConstantCount;
             return;
         }
         out << count.value();
@@ -427,7 +427,7 @@
     out << ">";
 }
 
-void Printer::EmitVectorType(StringStream& out, const type::Vector* vec) {
+void Printer::EmitVectorType(StringStream& out, const core::type::Vector* vec) {
     if (vec->Packed()) {
         out << "packed_";
     }
@@ -435,47 +435,47 @@
     out << vec->Width();
 }
 
-void Printer::EmitMatrixType(StringStream& out, const type::Matrix* mat) {
+void Printer::EmitMatrixType(StringStream& out, const core::type::Matrix* mat) {
     EmitType(out, mat->type());
     out << mat->columns() << "x" << mat->rows();
 }
 
-void Printer::EmitTextureType(StringStream& out, const type::Texture* tex) {
-    if (TINT_UNLIKELY(tex->Is<type::ExternalTexture>())) {
+void Printer::EmitTextureType(StringStream& out, const core::type::Texture* tex) {
+    if (TINT_UNLIKELY(tex->Is<core::type::ExternalTexture>())) {
         TINT_ICE() << "Multiplanar external texture transform was not run.";
         return;
     }
 
-    if (tex->IsAnyOf<type::DepthTexture, type::DepthMultisampledTexture>()) {
+    if (tex->IsAnyOf<core::type::DepthTexture, core::type::DepthMultisampledTexture>()) {
         out << "depth";
     } else {
         out << "texture";
     }
 
     switch (tex->dim()) {
-        case type::TextureDimension::k1d:
+        case core::type::TextureDimension::k1d:
             out << "1d";
             break;
-        case type::TextureDimension::k2d:
+        case core::type::TextureDimension::k2d:
             out << "2d";
             break;
-        case type::TextureDimension::k2dArray:
+        case core::type::TextureDimension::k2dArray:
             out << "2d_array";
             break;
-        case type::TextureDimension::k3d:
+        case core::type::TextureDimension::k3d:
             out << "3d";
             break;
-        case type::TextureDimension::kCube:
+        case core::type::TextureDimension::kCube:
             out << "cube";
             break;
-        case type::TextureDimension::kCubeArray:
+        case core::type::TextureDimension::kCubeArray:
             out << "cube_array";
             break;
         default:
             TINT_ICE() << "invalid texture dimensions";
             return;
     }
-    if (tex->IsAnyOf<type::MultisampledTexture, type::DepthMultisampledTexture>()) {
+    if (tex->IsAnyOf<core::type::MultisampledTexture, core::type::DepthMultisampledTexture>()) {
         out << "_ms";
     }
     out << "<";
@@ -483,9 +483,9 @@
 
     tint::Switch(
         tex,  //
-        [&](const type::DepthTexture*) { out << "float, access::sample"; },
-        [&](const type::DepthMultisampledTexture*) { out << "float, access::read"; },
-        [&](const type::StorageTexture* storage) {
+        [&](const core::type::DepthTexture*) { out << "float, access::sample"; },
+        [&](const core::type::DepthMultisampledTexture*) { out << "float, access::read"; },
+        [&](const core::type::StorageTexture* storage) {
             EmitType(out, storage->type());
             out << ", ";
 
@@ -499,18 +499,18 @@
                 return;
             }
         },
-        [&](const type::MultisampledTexture* ms) {
+        [&](const core::type::MultisampledTexture* ms) {
             EmitType(out, ms->type());
             out << ", access::read";
         },
-        [&](const type::SampledTexture* sampled) {
+        [&](const core::type::SampledTexture* sampled) {
             EmitType(out, sampled->type());
             out << ", access::sample";
         },
         [&](Default) { TINT_ICE() << "invalid texture type"; });
 }
 
-void Printer::EmitStructType(const type::Struct* str) {
+void Printer::EmitStructType(const core::type::Struct* str) {
     auto it = emitted_structs_.emplace(str);
     if (!it.second) {
         return;
@@ -592,14 +592,14 @@
                 return;
             }
 
-            if (pipeline_stage_uses.count(type::PipelineStageUsage::kVertexInput)) {
+            if (pipeline_stage_uses.count(core::type::PipelineStageUsage::kVertexInput)) {
                 out << " [[attribute(" + std::to_string(location.value()) + ")]]";
-            } else if (pipeline_stage_uses.count(type::PipelineStageUsage::kVertexOutput)) {
+            } else if (pipeline_stage_uses.count(core::type::PipelineStageUsage::kVertexOutput)) {
                 out << " [[user(locn" + std::to_string(location.value()) + ")]]";
-            } else if (pipeline_stage_uses.count(type::PipelineStageUsage::kFragmentInput)) {
+            } else if (pipeline_stage_uses.count(core::type::PipelineStageUsage::kFragmentInput)) {
                 out << " [[user(locn" + std::to_string(location.value()) + ")]]";
-            } else if (TINT_LIKELY(
-                           pipeline_stage_uses.count(type::PipelineStageUsage::kFragmentOutput))) {
+            } else if (TINT_LIKELY(pipeline_stage_uses.count(
+                           core::type::PipelineStageUsage::kFragmentOutput))) {
                 out << " [[color(" + std::to_string(location.value()) + ")]]";
             } else {
                 TINT_ICE() << "invalid use of location decoration";
@@ -662,12 +662,12 @@
 
     tint::Switch(
         c->Type(),  //
-        [&](const type::Bool*) { out << (c->ValueAs<bool>() ? "true" : "false"); },
-        [&](const type::I32*) { PrintI32(out, c->ValueAs<i32>()); },
-        [&](const type::U32*) { out << c->ValueAs<u32>() << "u"; },
-        [&](const type::F32*) { PrintF32(out, c->ValueAs<f32>()); },
-        [&](const type::F16*) { PrintF16(out, c->ValueAs<f16>()); },
-        [&](const type::Vector* v) {
+        [&](const core::type::Bool*) { out << (c->ValueAs<bool>() ? "true" : "false"); },
+        [&](const core::type::I32*) { PrintI32(out, c->ValueAs<i32>()); },
+        [&](const core::type::U32*) { out << c->ValueAs<u32>() << "u"; },
+        [&](const core::type::F32*) { PrintF32(out, c->ValueAs<f32>()); },
+        [&](const core::type::F16*) { PrintF16(out, c->ValueAs<f16>()); },
+        [&](const core::type::Vector* v) {
             EmitType(out, v);
 
             ScopedParen sp(out);
@@ -677,12 +677,12 @@
             }
             emit_values(v->Width());
         },
-        [&](const type::Matrix* m) {
+        [&](const core::type::Matrix* m) {
             EmitType(out, m);
             ScopedParen sp(out);
             emit_values(m->columns());
         },
-        [&](const type::Array* a) {
+        [&](const core::type::Array* a) {
             EmitType(out, a);
             out << "{";
             TINT_DEFER(out << "}");
@@ -693,12 +693,12 @@
 
             auto count = a->ConstantCount();
             if (!count) {
-                TINT_ICE() << type::Array::kErrExpectedConstantCount;
+                TINT_ICE() << core::type::Array::kErrExpectedConstantCount;
                 return;
             }
             emit_values(*count);
         },
-        [&](const type::Struct* s) {
+        [&](const core::type::Struct* s) {
             EmitStructType(s);
             out << StructName(s) << "{";
             TINT_DEFER(out << "}");
@@ -719,26 +719,26 @@
         [&](Default) { UNHANDLED_CASE(c->Type()); });
 }
 
-void Printer::EmitZeroValue(StringStream& out, const type::Type* ty) {
+void Printer::EmitZeroValue(StringStream& out, const core::type::Type* ty) {
     Switch(
-        ty, [&](const type::Bool*) { out << "false"; },                     //
-        [&](const type::F16*) { out << "0.0h"; },                           //
-        [&](const type::F32*) { out << "0.0f"; },                           //
-        [&](const type::I32*) { out << "0"; },                              //
-        [&](const type::U32*) { out << "0u"; },                             //
-        [&](const type::Vector* vec) { EmitZeroValue(out, vec->type()); },  //
-        [&](const type::Matrix* mat) {
+        ty, [&](const core::type::Bool*) { out << "false"; },                     //
+        [&](const core::type::F16*) { out << "0.0h"; },                           //
+        [&](const core::type::F32*) { out << "0.0f"; },                           //
+        [&](const core::type::I32*) { out << "0"; },                              //
+        [&](const core::type::U32*) { out << "0u"; },                             //
+        [&](const core::type::Vector* vec) { EmitZeroValue(out, vec->type()); },  //
+        [&](const core::type::Matrix* mat) {
             EmitType(out, mat);
 
             ScopedParen sp(out);
             EmitZeroValue(out, mat->type());
         },
-        [&](const type::Array*) { out << "{}"; },   //
-        [&](const type::Struct*) { out << "{}"; },  //
+        [&](const core::type::Array*) { out << "{}"; },   //
+        [&](const core::type::Struct*) { out << "{}"; },  //
         [&](Default) { TINT_ICE() << "Invalid type for zero emission: " << ty->FriendlyName(); });
 }
 
-std::string Printer::StructName(const type::Struct* s) {
+std::string Printer::StructName(const core::type::Struct* s) {
     auto name = s->Name().Name();
     if (HasPrefix(name, "__")) {
         name = tint::GetOrCreate(builtin_struct_names_, s,
@@ -802,7 +802,7 @@
         return "<error>";
     }
 
-    if (value->Type()->Is<type::Pointer>()) {
+    if (value->Type()->Is<core::type::Pointer>()) {
         return ToPtrKind(expr, got_ptr_kind, want_ptr_kind);
     }
 
@@ -841,7 +841,7 @@
             auto out = Line();
             EmitType(out, value->Type());
             out << " const " << mod_name.Name() << " = ";
-            if (value->Type()->Is<type::Pointer>()) {
+            if (value->Type()->Is<core::type::Pointer>()) {
                 out << ToPtrKind(expr, ptr_kind, PtrKind::kPtr);
             } else {
                 out << expr;
diff --git a/src/tint/lang/msl/writer/printer/printer.h b/src/tint/lang/msl/writer/printer/printer.h
index 134ad28..9a49a84 100644
--- a/src/tint/lang/msl/writer/printer/printer.h
+++ b/src/tint/lang/msl/writer/printer/printer.h
@@ -95,36 +95,36 @@
     /// Emit a type
     /// @param out the stream to emit too
     /// @param ty the type to emit
-    void EmitType(StringStream& out, const type::Type* ty);
+    void EmitType(StringStream& out, const core::type::Type* ty);
 
     /// Handles generating an array declaration
     /// @param out the output stream
     /// @param arr the array to emit
-    void EmitArrayType(StringStream& out, const type::Array* arr);
+    void EmitArrayType(StringStream& out, const core::type::Array* arr);
     /// Handles generating an atomic declaration
     /// @param out the output stream
     /// @param atomic the atomic to emit
-    void EmitAtomicType(StringStream& out, const type::Atomic* atomic);
+    void EmitAtomicType(StringStream& out, const core::type::Atomic* atomic);
     /// Handles generating a pointer declaration
     /// @param out the output stream
     /// @param ptr the pointer to emit
-    void EmitPointerType(StringStream& out, const type::Pointer* ptr);
+    void EmitPointerType(StringStream& out, const core::type::Pointer* ptr);
     /// Handles generating a vector declaration
     /// @param out the output stream
     /// @param vec the vector to emit
-    void EmitVectorType(StringStream& out, const type::Vector* vec);
+    void EmitVectorType(StringStream& out, const core::type::Vector* vec);
     /// Handles generating a matrix declaration
     /// @param out the output stream
     /// @param mat the matrix to emit
-    void EmitMatrixType(StringStream& out, const type::Matrix* mat);
+    void EmitMatrixType(StringStream& out, const core::type::Matrix* mat);
     /// Handles generating a texture declaration
     /// @param out the output stream
     /// @param tex the texture to emit
-    void EmitTextureType(StringStream& out, const type::Texture* tex);
+    void EmitTextureType(StringStream& out, const core::type::Texture* tex);
     /// Handles generating a struct declaration. If the structure has already been emitted, then
     /// this function will simply return without emitting anything.
     /// @param str the struct to generate
-    void EmitStructType(const type::Struct* str);
+    void EmitStructType(const core::type::Struct* str);
 
     /// Handles generating a address space
     /// @param out the output of the type stream
@@ -143,7 +143,7 @@
     /// Emits the zero value for the given type
     /// @param out the stream to emit too
     /// @param ty the type
-    void EmitZeroValue(StringStream& out, const type::Type* ty);
+    void EmitZeroValue(StringStream& out, const core::type::Type* ty);
 
     /// @returns the name of the templated `tint_array` helper type, generating it if needed
     const std::string& ArrayTemplateName();
@@ -152,7 +152,7 @@
     /// @returns the name of the structure, taking special care of builtin structures that start
     /// with double underscores. If the structure is a builtin, then the returned name will be a
     /// unique name without the leading underscores.
-    std::string StructName(const type::Struct* s);
+    std::string StructName(const core::type::Struct* s);
 
     /// @return a new, unique identifier with the given prefix.
     /// @param prefix optional prefix to apply to the generated identifier. If empty "tint_symbol"
@@ -160,7 +160,7 @@
     std::string UniqueIdentifier(const std::string& prefix = "");
 
     /// Map of builtin structure to unique generated name
-    std::unordered_map<const type::Struct*, std::string> builtin_struct_names_;
+    std::unordered_map<const core::type::Struct*, std::string> builtin_struct_names_;
 
     ir::Module* const ir_;
 
@@ -171,7 +171,7 @@
     /// Non-empty only if an invariant attribute has been generated.
     std::string invariant_define_name_;
 
-    std::unordered_set<const type::Struct*> emitted_structs_;
+    std::unordered_set<const core::type::Struct*> emitted_structs_;
 
     /// The current function being emitted
     ir::Function* current_function_ = nullptr;
diff --git a/src/tint/lang/msl/writer/printer/type_test.cc b/src/tint/lang/msl/writer/printer/type_test.cc
index 2dad67a..f2a52f3 100644
--- a/src/tint/lang/msl/writer/printer/type_test.cc
+++ b/src/tint/lang/msl/writer/printer/type_test.cc
@@ -407,15 +407,15 @@
 
 struct MemberData {
     Symbol name;
-    const type::Type* type;
+    const core::type::Type* type;
     uint32_t size = 0;
     uint32_t align = 0;
 };
-type::Struct* MkStruct(ir::Module& mod,
-                       type::Manager& ty,
-                       std::string_view name,
-                       VectorRef<MemberData> data) {
-    Vector<const type::StructMember*, 26> members;
+core::type::Struct* MkStruct(ir::Module& mod,
+                             core::type::Manager& ty,
+                             std::string_view name,
+                             VectorRef<MemberData> data) {
+    Vector<const core::type::StructMember*, 26> members;
     uint32_t align = 0;
     uint32_t size = 0;
     for (uint32_t i = 0; i < data.Length(); ++i) {
@@ -425,15 +425,15 @@
         uint32_t mem_size = d.size == 0 ? d.type->Size() : d.size;
 
         uint32_t offset = tint::RoundUp(mem_align, size);
-        members.Push(ty.Get<type::StructMember>(d.name, d.type, i, offset, mem_align, mem_size,
-                                                type::StructMemberAttributes{}));
+        members.Push(ty.Get<core::type::StructMember>(
+            d.name, d.type, i, offset, mem_align, mem_size, core::type::StructMemberAttributes{}));
 
         align = std::max(align, mem_align);
         size = offset + mem_size;
     }
 
-    return ty.Get<type::Struct>(mod.symbols.New(name), std::move(members), align,
-                                tint::RoundUp(align, size), size);
+    return ty.Get<core::type::Struct>(mod.symbols.New(name), std::move(members), align,
+                                      tint::RoundUp(align, size), size);
 }
 
 TEST_F(MslPrinterTest, EmitType_Struct_Layout_NonComposites) {
@@ -573,7 +573,7 @@
                                                {mod.symbols.Register("c"), ty.f32()},
                                                {mod.symbols.Register("d"), inner_y},
                                                {mod.symbols.Register("e"), ty.f32()}});
-    const_cast<type::Struct*>(s)->AddUsage(core::AddressSpace::kStorage);
+    const_cast<core::type::Struct*>(s)->AddUsage(core::AddressSpace::kStorage);
 
 // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, ARRAY_COUNT, NAME)
 // for each field of the structure s.
@@ -677,7 +677,7 @@
                                                {mod.symbols.Register("d"), array_y},
                                                {mod.symbols.Register("e"), ty.f32()},
                                                {mod.symbols.Register("f"), array_z}});
-    const_cast<type::Struct*>(s)->AddUsage(core::AddressSpace::kStorage);
+    const_cast<core::type::Struct*>(s)->AddUsage(core::AddressSpace::kStorage);
 
     // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, ARRAY_COUNT, NAME)
     // for each field of the structure s.
@@ -772,7 +772,7 @@
                                                   {mod.symbols.Register("b"), array},
                                                   {mod.symbols.Register("c"), ty.i32()},
                                               });
-    const_cast<type::Struct*>(s)->AddUsage(core::AddressSpace::kStorage);
+    const_cast<core::type::Struct*>(s)->AddUsage(core::AddressSpace::kStorage);
 
     // ALL_FIELDS() calls the macro FIELD(ADDR, TYPE, ARRAY_COUNT, NAME)
     // for each field of the structure s.
@@ -928,7 +928,7 @@
 }
 
 struct MslDepthTextureData {
-    type::TextureDimension dim;
+    core::type::TextureDimension dim;
     std::string result;
 };
 inline std::ostream& operator<<(std::ostream& out, MslDepthTextureData data) {
@@ -941,7 +941,7 @@
 TEST_P(MslPrinterDepthTexturesTest, Emit) {
     auto params = GetParam();
 
-    auto* t = ty.Get<type::DepthTexture>(params.dim);
+    auto* t = ty.Get<core::type::DepthTexture>(params.dim);
     auto* func = b.Function("foo", ty.void_());
     b.Append(func->Block(), [&] {
         b.Var("a", ty.ptr(core::AddressSpace::kWorkgroup, t));
@@ -959,16 +959,17 @@
 INSTANTIATE_TEST_SUITE_P(
     MslPrinterTest,
     MslPrinterDepthTexturesTest,
-    testing::Values(
-        MslDepthTextureData{type::TextureDimension::k2d, "depth2d<float, access::sample>"},
-        MslDepthTextureData{type::TextureDimension::k2dArray,
-                            "depth2d_array<float, access::sample>"},
-        MslDepthTextureData{type::TextureDimension::kCube, "depthcube<float, access::sample>"},
-        MslDepthTextureData{type::TextureDimension::kCubeArray,
-                            "depthcube_array<float, access::sample>"}));
+    testing::Values(MslDepthTextureData{core::type::TextureDimension::k2d,
+                                        "depth2d<float, access::sample>"},
+                    MslDepthTextureData{core::type::TextureDimension::k2dArray,
+                                        "depth2d_array<float, access::sample>"},
+                    MslDepthTextureData{core::type::TextureDimension::kCube,
+                                        "depthcube<float, access::sample>"},
+                    MslDepthTextureData{core::type::TextureDimension::kCubeArray,
+                                        "depthcube_array<float, access::sample>"}));
 
 TEST_F(MslPrinterTest, EmiType_DepthMultisampledTexture) {
-    auto* t = ty.Get<type::DepthMultisampledTexture>(type::TextureDimension::k2d);
+    auto* t = ty.Get<core::type::DepthMultisampledTexture>(core::type::TextureDimension::k2d);
     auto* func = b.Function("foo", ty.void_());
     b.Append(func->Block(), [&] {
         b.Var("a", ty.ptr(core::AddressSpace::kWorkgroup, t));
@@ -984,7 +985,7 @@
 }
 
 struct MslTextureData {
-    type::TextureDimension dim;
+    core::type::TextureDimension dim;
     std::string result;
 };
 inline std::ostream& operator<<(std::ostream& out, MslTextureData data) {
@@ -997,7 +998,7 @@
 TEST_P(MslPrinterSampledtexturesTest, Emit) {
     auto params = GetParam();
 
-    auto* t = ty.Get<type::SampledTexture>(params.dim, ty.f32());
+    auto* t = ty.Get<core::type::SampledTexture>(params.dim, ty.f32());
     auto* func = b.Function("foo", ty.void_());
     b.Append(func->Block(), [&] {
         b.Var("a", ty.ptr(core::AddressSpace::kWorkgroup, t));
@@ -1016,16 +1017,17 @@
     MslPrinterTest,
     MslPrinterSampledtexturesTest,
     testing::Values(
-        MslTextureData{type::TextureDimension::k1d, "texture1d<float, access::sample>"},
-        MslTextureData{type::TextureDimension::k2d, "texture2d<float, access::sample>"},
-        MslTextureData{type::TextureDimension::k2dArray, "texture2d_array<float, access::sample>"},
-        MslTextureData{type::TextureDimension::k3d, "texture3d<float, access::sample>"},
-        MslTextureData{type::TextureDimension::kCube, "texturecube<float, access::sample>"},
-        MslTextureData{type::TextureDimension::kCubeArray,
+        MslTextureData{core::type::TextureDimension::k1d, "texture1d<float, access::sample>"},
+        MslTextureData{core::type::TextureDimension::k2d, "texture2d<float, access::sample>"},
+        MslTextureData{core::type::TextureDimension::k2dArray,
+                       "texture2d_array<float, access::sample>"},
+        MslTextureData{core::type::TextureDimension::k3d, "texture3d<float, access::sample>"},
+        MslTextureData{core::type::TextureDimension::kCube, "texturecube<float, access::sample>"},
+        MslTextureData{core::type::TextureDimension::kCubeArray,
                        "texturecube_array<float, access::sample>"}));
 
 TEST_F(MslPrinterTest, Emit_TypeMultisampledTexture) {
-    auto* ms = ty.Get<type::MultisampledTexture>(type::TextureDimension::k2d, ty.u32());
+    auto* ms = ty.Get<core::type::MultisampledTexture>(core::type::TextureDimension::k2d, ty.u32());
     auto* func = b.Function("foo", ty.void_());
     b.Append(func->Block(), [&] {
         b.Var("a", ty.ptr(core::AddressSpace::kWorkgroup, ms));
@@ -1041,7 +1043,7 @@
 }
 
 struct MslStorageTextureData {
-    type::TextureDimension dim;
+    core::type::TextureDimension dim;
     std::string result;
 };
 inline std::ostream& operator<<(std::ostream& out, MslStorageTextureData data) {
@@ -1053,9 +1055,9 @@
 TEST_P(MslPrinterStorageTexturesTest, Emit) {
     auto params = GetParam();
 
-    auto* f32 = const_cast<type::F32*>(ty.f32());
-    auto s = ty.Get<type::StorageTexture>(params.dim, core::TexelFormat::kR32Float,
-                                          core::Access::kWrite, f32);
+    auto* f32 = const_cast<core::type::F32*>(ty.f32());
+    auto s = ty.Get<core::type::StorageTexture>(params.dim, core::TexelFormat::kR32Float,
+                                                core::Access::kWrite, f32);
     auto* func = b.Function("foo", ty.void_());
     b.Append(func->Block(), [&] {
         b.Var("a", ty.ptr(core::AddressSpace::kWorkgroup, s));
@@ -1070,15 +1072,17 @@
 }
 )");
 }
-INSTANTIATE_TEST_SUITE_P(
-    MslPrinterTest,
-    MslPrinterStorageTexturesTest,
-    testing::Values(
-        MslStorageTextureData{type::TextureDimension::k1d, "texture1d<float, access::write>"},
-        MslStorageTextureData{type::TextureDimension::k2d, "texture2d<float, access::write>"},
-        MslStorageTextureData{type::TextureDimension::k2dArray,
-                              "texture2d_array<float, access::write>"},
-        MslStorageTextureData{type::TextureDimension::k3d, "texture3d<float, access::write>"}));
+INSTANTIATE_TEST_SUITE_P(MslPrinterTest,
+                         MslPrinterStorageTexturesTest,
+                         testing::Values(MslStorageTextureData{core::type::TextureDimension::k1d,
+                                                               "texture1d<float, access::write>"},
+                                         MslStorageTextureData{core::type::TextureDimension::k2d,
+                                                               "texture2d<float, access::write>"},
+                                         MslStorageTextureData{
+                                             core::type::TextureDimension::k2dArray,
+                                             "texture2d_array<float, access::write>"},
+                                         MslStorageTextureData{core::type::TextureDimension::k3d,
+                                                               "texture3d<float, access::write>"}));
 
 }  // namespace
 }  // namespace tint::msl::writer
diff --git a/src/tint/lang/spirv/reader/ast_parser/ast_parser.cc b/src/tint/lang/spirv/reader/ast_parser/ast_parser.cc
index 18ad99f..d33730d 100644
--- a/src/tint/lang/spirv/reader/ast_parser/ast_parser.cc
+++ b/src/tint/lang/spirv/reader/ast_parser/ast_parser.cc
@@ -2508,8 +2508,8 @@
     const Type* ast_handle_type = nullptr;
     if (usage.IsSampler()) {
         ast_handle_type =
-            ty_.Sampler(usage.IsComparisonSampler() ? type::SamplerKind::kComparisonSampler
-                                                    : type::SamplerKind::kSampler);
+            ty_.Sampler(usage.IsComparisonSampler() ? core::type::SamplerKind::kComparisonSampler
+                                                    : core::type::SamplerKind::kSampler);
     } else if (usage.IsTexture()) {
         const spvtools::opt::analysis::Image* image_type =
             type_mgr_->GetType(raw_handle_type->result_id())->AsImage();
@@ -2534,9 +2534,9 @@
             }
         }
 
-        const type::TextureDimension dim =
+        const core::type::TextureDimension dim =
             enum_converter_.ToDim(image_type->dim(), image_type->is_arrayed());
-        if (dim == type::TextureDimension::kNone) {
+        if (dim == core::type::TextureDimension::kNone) {
             return nullptr;
         }
 
@@ -2559,7 +2559,7 @@
                     ast_handle_type = ty_.DepthTexture(dim);
                 }
             } else if (image_type->is_multisampled()) {
-                if (dim != type::TextureDimension::k2d) {
+                if (dim != core::type::TextureDimension::k2d) {
                     Fail() << "WGSL multisampled textures must be 2d and non-arrayed: "
                               "invalid multisampled texture variable or function parameter "
                            << namer_.Name(obj.result_id()) << ": " << obj.PrettyPrint();
diff --git a/src/tint/lang/spirv/reader/ast_parser/enum_converter.cc b/src/tint/lang/spirv/reader/ast_parser/enum_converter.cc
index 1941989..67842ab 100644
--- a/src/tint/lang/spirv/reader/ast_parser/enum_converter.cc
+++ b/src/tint/lang/spirv/reader/ast_parser/enum_converter.cc
@@ -100,34 +100,34 @@
     return core::BuiltinValue::kUndefined;
 }
 
-type::TextureDimension EnumConverter::ToDim(spv::Dim dim, bool arrayed) {
+core::type::TextureDimension EnumConverter::ToDim(spv::Dim dim, bool arrayed) {
     if (arrayed) {
         switch (dim) {
             case spv::Dim::Dim2D:
-                return type::TextureDimension::k2dArray;
+                return core::type::TextureDimension::k2dArray;
             case spv::Dim::Cube:
-                return type::TextureDimension::kCubeArray;
+                return core::type::TextureDimension::kCubeArray;
             default:
                 break;
         }
         Fail() << "arrayed dimension must be 2D or Cube. Got " << int(dim);
-        return type::TextureDimension::kNone;
+        return core::type::TextureDimension::kNone;
     }
     // Assume non-arrayed
     switch (dim) {
         case spv::Dim::Dim1D:
-            return type::TextureDimension::k1d;
+            return core::type::TextureDimension::k1d;
         case spv::Dim::Dim2D:
-            return type::TextureDimension::k2d;
+            return core::type::TextureDimension::k2d;
         case spv::Dim::Dim3D:
-            return type::TextureDimension::k3d;
+            return core::type::TextureDimension::k3d;
         case spv::Dim::Cube:
-            return type::TextureDimension::kCube;
+            return core::type::TextureDimension::kCube;
         default:
             break;
     }
     Fail() << "invalid dimension: " << int(dim);
-    return type::TextureDimension::kNone;
+    return core::type::TextureDimension::kNone;
 }
 
 core::TexelFormat EnumConverter::ToTexelFormat(spv::ImageFormat fmt) {
diff --git a/src/tint/lang/spirv/reader/ast_parser/enum_converter.h b/src/tint/lang/spirv/reader/ast_parser/enum_converter.h
index 13b6c87..80f16fd 100644
--- a/src/tint/lang/spirv/reader/ast_parser/enum_converter.h
+++ b/src/tint/lang/spirv/reader/ast_parser/enum_converter.h
@@ -58,14 +58,14 @@
     /// @param dim the SPIR-V Dim value
     /// @param arrayed true if the texture is arrayed
     /// @returns a Tint AST texture dimension
-    type::TextureDimension ToDim(spv::Dim dim, bool arrayed);
+    core::type::TextureDimension ToDim(spv::Dim dim, bool arrayed);
 
     /// Converts a possibly arrayed SPIR-V Dim to a Tint texture dimension.
     /// On failure, logs an error and returns kNone
     /// @param dim the SPIR-V Dim value
     /// @param arrayed true if the texture is arrayed
     /// @returns a Tint AST texture dimension
-    type::TextureDimension ToDim(SpvDim dim, bool arrayed) {
+    core::type::TextureDimension ToDim(SpvDim dim, bool arrayed) {
         return ToDim(static_cast<spv::Dim>(dim), arrayed);
     }
 
diff --git a/src/tint/lang/spirv/reader/ast_parser/enum_converter_test.cc b/src/tint/lang/spirv/reader/ast_parser/enum_converter_test.cc
index 9b78d06..5ce9dc7 100644
--- a/src/tint/lang/spirv/reader/ast_parser/enum_converter_test.cc
+++ b/src/tint/lang/spirv/reader/ast_parser/enum_converter_test.cc
@@ -220,7 +220,7 @@
     spv::Dim dim;
     bool arrayed;
     bool expect_success;
-    type::TextureDimension expected;
+    core::type::TextureDimension expected;
 };
 inline std::ostream& operator<<(std::ostream& out, DimCase dc) {
     out << "DimCase{ spv::Dim:::" << int(dc.dim) << " arrayed?:" << int(dc.arrayed)
@@ -255,35 +255,35 @@
     }
 }
 
-INSTANTIATE_TEST_SUITE_P(EnumConverterGood,
-                         SpvDimTest,
-                         testing::Values(
-                             // Non-arrayed
-                             DimCase{spv::Dim::Dim1D, false, true, type::TextureDimension::k1d},
-                             DimCase{spv::Dim::Dim2D, false, true, type::TextureDimension::k2d},
-                             DimCase{spv::Dim::Dim3D, false, true, type::TextureDimension::k3d},
-                             DimCase{spv::Dim::Cube, false, true, type::TextureDimension::kCube},
-                             // Arrayed
-                             DimCase{spv::Dim::Dim2D, true, true, type::TextureDimension::k2dArray},
-                             DimCase{spv::Dim::Cube, true, true,
-                                     type::TextureDimension::kCubeArray}));
+INSTANTIATE_TEST_SUITE_P(
+    EnumConverterGood,
+    SpvDimTest,
+    testing::Values(
+        // Non-arrayed
+        DimCase{spv::Dim::Dim1D, false, true, core::type::TextureDimension::k1d},
+        DimCase{spv::Dim::Dim2D, false, true, core::type::TextureDimension::k2d},
+        DimCase{spv::Dim::Dim3D, false, true, core::type::TextureDimension::k3d},
+        DimCase{spv::Dim::Cube, false, true, core::type::TextureDimension::kCube},
+        // Arrayed
+        DimCase{spv::Dim::Dim2D, true, true, core::type::TextureDimension::k2dArray},
+        DimCase{spv::Dim::Cube, true, true, core::type::TextureDimension::kCubeArray}));
 
 INSTANTIATE_TEST_SUITE_P(
     EnumConverterBad,
     SpvDimTest,
     testing::Values(
         // Invalid SPIR-V dimensionality.
-        DimCase{spv::Dim::Max, false, false, type::TextureDimension::kNone},
-        DimCase{spv::Dim::Max, true, false, type::TextureDimension::kNone},
+        DimCase{spv::Dim::Max, false, false, core::type::TextureDimension::kNone},
+        DimCase{spv::Dim::Max, true, false, core::type::TextureDimension::kNone},
         // Vulkan non-arrayed dimensionalities not supported by WGSL.
-        DimCase{spv::Dim::Rect, false, false, type::TextureDimension::kNone},
-        DimCase{spv::Dim::Buffer, false, false, type::TextureDimension::kNone},
-        DimCase{spv::Dim::SubpassData, false, false, type::TextureDimension::kNone},
+        DimCase{spv::Dim::Rect, false, false, core::type::TextureDimension::kNone},
+        DimCase{spv::Dim::Buffer, false, false, core::type::TextureDimension::kNone},
+        DimCase{spv::Dim::SubpassData, false, false, core::type::TextureDimension::kNone},
         // Arrayed dimensionalities not supported by WGSL
-        DimCase{spv::Dim::Dim3D, true, false, type::TextureDimension::kNone},
-        DimCase{spv::Dim::Rect, true, false, type::TextureDimension::kNone},
-        DimCase{spv::Dim::Buffer, true, false, type::TextureDimension::kNone},
-        DimCase{spv::Dim::SubpassData, true, false, type::TextureDimension::kNone}));
+        DimCase{spv::Dim::Dim3D, true, false, core::type::TextureDimension::kNone},
+        DimCase{spv::Dim::Rect, true, false, core::type::TextureDimension::kNone},
+        DimCase{spv::Dim::Buffer, true, false, core::type::TextureDimension::kNone},
+        DimCase{spv::Dim::SubpassData, true, false, core::type::TextureDimension::kNone}));
 
 // TexelFormat
 
diff --git a/src/tint/lang/spirv/reader/ast_parser/function.cc b/src/tint/lang/spirv/reader/ast_parser/function.cc
index 13db76f..895efcf 100644
--- a/src/tint/lang/spirv/reader/ast_parser/function.cc
+++ b/src/tint/lang/spirv/reader/ast_parser/function.cc
@@ -5662,9 +5662,9 @@
                           << inst.PrettyPrint();
         }
         switch (texture_type->dims) {
-            case type::TextureDimension::k2d:
-            case type::TextureDimension::k2dArray:
-            case type::TextureDimension::k3d:
+            case core::type::TextureDimension::k2d:
+            case core::type::TextureDimension::k2dArray:
+            case core::type::TextureDimension::k3d:
                 break;
             default:
                 return Fail() << "ConstOffset is only permitted for 2D, 2D Arrayed, "
@@ -5787,14 +5787,14 @@
             const ast::Expression* dims_call =
                 builder_.Call("textureDimensions", std::move(dims_args));
             auto dims = texture_type->dims;
-            if ((dims == type::TextureDimension::kCube) ||
-                (dims == type::TextureDimension::kCubeArray)) {
+            if ((dims == core::type::TextureDimension::kCube) ||
+                (dims == core::type::TextureDimension::kCubeArray)) {
                 // textureDimension returns a 3-element vector but SPIR-V expects 2.
                 dims_call =
                     create<ast::MemberAccessorExpression>(Source{}, dims_call, PrefixSwizzle(2));
             }
             exprs.Push(dims_call);
-            if (type::IsTextureArray(dims)) {
+            if (core::type::IsTextureArray(dims)) {
                 auto num_layers = builder_.Call("textureNumLayers", GetImageExpression(inst));
                 exprs.Push(num_layers);
             }
@@ -5979,10 +5979,10 @@
     if (!texture_type) {
         return {};
     }
-    type::TextureDimension dim = texture_type->dims;
+    core::type::TextureDimension dim = texture_type->dims;
     // Number of regular coordinates.
-    uint32_t num_axes = static_cast<uint32_t>(type::NumCoordinateAxes(dim));
-    bool is_arrayed = type::IsTextureArray(dim);
+    uint32_t num_axes = static_cast<uint32_t>(core::type::NumCoordinateAxes(dim));
+    bool is_arrayed = core::type::IsTextureArray(dim);
     if ((num_axes == 0) || (num_axes > 3)) {
         Fail() << "unsupported image dimensionality for " << texture_type->TypeInfo().name
                << " prompted by " << inst.PrettyPrint();
diff --git a/src/tint/lang/spirv/reader/ast_parser/type.cc b/src/tint/lang/spirv/reader/ast_parser/type.cc
index ef1ee5b..115e6f5 100644
--- a/src/tint/lang/spirv/reader/ast_parser/type.cc
+++ b/src/tint/lang/spirv/reader/ast_parser/type.cc
@@ -238,31 +238,31 @@
     }
 }
 
-Sampler::Sampler(type::SamplerKind k) : kind(k) {}
+Sampler::Sampler(core::type::SamplerKind k) : kind(k) {}
 Sampler::Sampler(const Sampler&) = default;
 
 ast::Type Sampler::Build(ProgramBuilder& b) const {
     return b.ty.sampler(kind);
 }
 
-Texture::Texture(type::TextureDimension d) : dims(d) {}
+Texture::Texture(core::type::TextureDimension d) : dims(d) {}
 Texture::Texture(const Texture&) = default;
 
-DepthTexture::DepthTexture(type::TextureDimension d) : Base(d) {}
+DepthTexture::DepthTexture(core::type::TextureDimension d) : Base(d) {}
 DepthTexture::DepthTexture(const DepthTexture&) = default;
 
 ast::Type DepthTexture::Build(ProgramBuilder& b) const {
     return b.ty.depth_texture(dims);
 }
 
-DepthMultisampledTexture::DepthMultisampledTexture(type::TextureDimension d) : Base(d) {}
+DepthMultisampledTexture::DepthMultisampledTexture(core::type::TextureDimension d) : Base(d) {}
 DepthMultisampledTexture::DepthMultisampledTexture(const DepthMultisampledTexture&) = default;
 
 ast::Type DepthMultisampledTexture::Build(ProgramBuilder& b) const {
     return b.ty.depth_multisampled_texture(dims);
 }
 
-MultisampledTexture::MultisampledTexture(type::TextureDimension d, const Type* t)
+MultisampledTexture::MultisampledTexture(core::type::TextureDimension d, const Type* t)
     : Base(d), type(t) {}
 MultisampledTexture::MultisampledTexture(const MultisampledTexture&) = default;
 
@@ -270,14 +270,14 @@
     return b.ty.multisampled_texture(dims, type->Build(b));
 }
 
-SampledTexture::SampledTexture(type::TextureDimension d, const Type* t) : Base(d), type(t) {}
+SampledTexture::SampledTexture(core::type::TextureDimension d, const Type* t) : Base(d), type(t) {}
 SampledTexture::SampledTexture(const SampledTexture&) = default;
 
 ast::Type SampledTexture::Build(ProgramBuilder& b) const {
     return b.ty.sampled_texture(dims, type->Build(b));
 }
 
-StorageTexture::StorageTexture(type::TextureDimension d, core::TexelFormat f, core::Access a)
+StorageTexture::StorageTexture(core::type::TextureDimension d, core::TexelFormat f, core::Access a)
     : Base(d), format(f), access(a) {}
 StorageTexture::StorageTexture(const StorageTexture&) = default;
 
@@ -512,30 +512,31 @@
     return state->structs_.Get(name, std::move(members));
 }
 
-const reader::Sampler* TypeManager::Sampler(type::SamplerKind kind) {
+const reader::Sampler* TypeManager::Sampler(core::type::SamplerKind kind) {
     return state->samplers_.Get(kind);
 }
 
-const reader::DepthTexture* TypeManager::DepthTexture(type::TextureDimension dims) {
+const reader::DepthTexture* TypeManager::DepthTexture(core::type::TextureDimension dims) {
     return state->depth_textures_.Get(dims);
 }
 
 const reader::DepthMultisampledTexture* TypeManager::DepthMultisampledTexture(
-    type::TextureDimension dims) {
+    core::type::TextureDimension dims) {
     return state->depth_multisampled_textures_.Get(dims);
 }
 
-const reader::MultisampledTexture* TypeManager::MultisampledTexture(type::TextureDimension dims,
-                                                                    const Type* ty) {
+const reader::MultisampledTexture* TypeManager::MultisampledTexture(
+    core::type::TextureDimension dims,
+    const Type* ty) {
     return state->multisampled_textures_.Get(dims, ty);
 }
 
-const reader::SampledTexture* TypeManager::SampledTexture(type::TextureDimension dims,
+const reader::SampledTexture* TypeManager::SampledTexture(core::type::TextureDimension dims,
                                                           const Type* ty) {
     return state->sampled_textures_.Get(dims, ty);
 }
 
-const reader::StorageTexture* TypeManager::StorageTexture(type::TextureDimension dims,
+const reader::StorageTexture* TypeManager::StorageTexture(core::type::TextureDimension dims,
                                                           core::TexelFormat fmt,
                                                           core::Access access) {
     return state->storage_textures_.Get(dims, fmt, access);
@@ -595,9 +596,9 @@
 
 std::string Sampler::String() const {
     switch (kind) {
-        case type::SamplerKind::kSampler:
+        case core::type::SamplerKind::kSampler:
             return "sampler";
-        case type::SamplerKind::kComparisonSampler:
+        case core::type::SamplerKind::kComparisonSampler:
             return "sampler_comparison";
     }
     return "<unknown sampler>";
diff --git a/src/tint/lang/spirv/reader/ast_parser/type.h b/src/tint/lang/spirv/reader/ast_parser/type.h
index 2c08913..65b95f8 100644
--- a/src/tint/lang/spirv/reader/ast_parser/type.h
+++ b/src/tint/lang/spirv/reader/ast_parser/type.h
@@ -305,7 +305,7 @@
 struct Sampler final : public Castable<Sampler, Type> {
     /// Constructor
     /// @param k the sampler kind
-    explicit Sampler(type::SamplerKind k);
+    explicit Sampler(core::type::SamplerKind k);
 
     /// Copy constructor
     /// @param other the other type to copy
@@ -321,7 +321,7 @@
 #endif  // NDEBUG
 
     /// the sampler kind
-    type::SamplerKind const kind;
+    core::type::SamplerKind const kind;
 };
 
 /// Base class for texture types
@@ -330,21 +330,21 @@
 
     /// Constructor
     /// @param d the texture dimensions
-    explicit Texture(type::TextureDimension d);
+    explicit Texture(core::type::TextureDimension d);
 
     /// Copy constructor
     /// @param other the other type to copy
     Texture(const Texture& other);
 
     /// the texture dimensions
-    type::TextureDimension const dims;
+    core::type::TextureDimension const dims;
 };
 
 /// `texture_depth_D` type
 struct DepthTexture final : public Castable<DepthTexture, Texture> {
     /// Constructor
     /// @param d the texture dimensions
-    explicit DepthTexture(type::TextureDimension d);
+    explicit DepthTexture(core::type::TextureDimension d);
 
     /// Copy constructor
     /// @param other the other type to copy
@@ -364,7 +364,7 @@
 struct DepthMultisampledTexture final : public Castable<DepthMultisampledTexture, Texture> {
     /// Constructor
     /// @param d the texture dimensions
-    explicit DepthMultisampledTexture(type::TextureDimension d);
+    explicit DepthMultisampledTexture(core::type::TextureDimension d);
 
     /// Copy constructor
     /// @param other the other type to copy
@@ -385,7 +385,7 @@
     /// Constructor
     /// @param d the texture dimensions
     /// @param t the multisampled texture type
-    MultisampledTexture(type::TextureDimension d, const Type* t);
+    MultisampledTexture(core::type::TextureDimension d, const Type* t);
 
     /// Copy constructor
     /// @param other the other type to copy
@@ -409,7 +409,7 @@
     /// Constructor
     /// @param d the texture dimensions
     /// @param t the sampled texture type
-    SampledTexture(type::TextureDimension d, const Type* t);
+    SampledTexture(core::type::TextureDimension d, const Type* t);
 
     /// Copy constructor
     /// @param other the other type to copy
@@ -434,7 +434,7 @@
     /// @param d the texture dimensions
     /// @param f the storage image format
     /// @param a the access control
-    StorageTexture(type::TextureDimension d, core::TexelFormat f, core::Access a);
+    StorageTexture(core::type::TextureDimension d, core::TexelFormat f, core::Access a);
 
     /// Copy constructor
     /// @param other the other type to copy
@@ -590,31 +590,33 @@
     /// @param k the sampler kind
     /// @return a Sampler type. Repeated calls with the same arguments will return
     /// the same pointer.
-    const reader::Sampler* Sampler(type::SamplerKind k);
+    const reader::Sampler* Sampler(core::type::SamplerKind k);
     /// @param d the texture dimensions
     /// @return a DepthTexture type. Repeated calls with the same arguments will
     /// return the same pointer.
-    const reader::DepthTexture* DepthTexture(type::TextureDimension d);
+    const reader::DepthTexture* DepthTexture(core::type::TextureDimension d);
     /// @param d the texture dimensions
     /// @return a DepthMultisampledTexture type. Repeated calls with the same
     /// arguments will return the same pointer.
-    const reader::DepthMultisampledTexture* DepthMultisampledTexture(type::TextureDimension d);
+    const reader::DepthMultisampledTexture* DepthMultisampledTexture(
+        core::type::TextureDimension d);
     /// @param d the texture dimensions
     /// @param t the multisampled texture type
     /// @return a MultisampledTexture type. Repeated calls with the same arguments
     /// will return the same pointer.
-    const reader::MultisampledTexture* MultisampledTexture(type::TextureDimension d, const Type* t);
+    const reader::MultisampledTexture* MultisampledTexture(core::type::TextureDimension d,
+                                                           const Type* t);
     /// @param d the texture dimensions
     /// @param t the sampled texture type
     /// @return a SampledTexture type. Repeated calls with the same arguments will
     /// return the same pointer.
-    const reader::SampledTexture* SampledTexture(type::TextureDimension d, const Type* t);
+    const reader::SampledTexture* SampledTexture(core::type::TextureDimension d, const Type* t);
     /// @param d the texture dimensions
     /// @param f the storage image format
     /// @param a the access control
     /// @return a StorageTexture type. Repeated calls with the same arguments will
     /// return the same pointer.
-    const reader::StorageTexture* StorageTexture(type::TextureDimension d,
+    const reader::StorageTexture* StorageTexture(core::type::TextureDimension d,
                                                  core::TexelFormat f,
                                                  core::Access a);
 
diff --git a/src/tint/lang/spirv/reader/ast_parser/type_test.cc b/src/tint/lang/spirv/reader/ast_parser/type_test.cc
index fba68b8..1cbd2ff6 100644
--- a/src/tint/lang/spirv/reader/ast_parser/type_test.cc
+++ b/src/tint/lang/spirv/reader/ast_parser/type_test.cc
@@ -36,16 +36,17 @@
     EXPECT_EQ(ty.Array(ty.I32(), 3, 2), ty.Array(ty.I32(), 3, 2));
     EXPECT_EQ(ty.Alias(sym, ty.I32()), ty.Alias(sym, ty.I32()));
     EXPECT_EQ(ty.Struct(sym, {ty.I32()}), ty.Struct(sym, {ty.I32()}));
-    EXPECT_EQ(ty.Sampler(type::SamplerKind::kSampler), ty.Sampler(type::SamplerKind::kSampler));
-    EXPECT_EQ(ty.DepthTexture(type::TextureDimension::k2d),
-              ty.DepthTexture(type::TextureDimension::k2d));
-    EXPECT_EQ(ty.MultisampledTexture(type::TextureDimension::k2d, ty.I32()),
-              ty.MultisampledTexture(type::TextureDimension::k2d, ty.I32()));
-    EXPECT_EQ(ty.SampledTexture(type::TextureDimension::k2d, ty.I32()),
-              ty.SampledTexture(type::TextureDimension::k2d, ty.I32()));
-    EXPECT_EQ(ty.StorageTexture(type::TextureDimension::k2d, core::TexelFormat::kR32Uint,
+    EXPECT_EQ(ty.Sampler(core::type::SamplerKind::kSampler),
+              ty.Sampler(core::type::SamplerKind::kSampler));
+    EXPECT_EQ(ty.DepthTexture(core::type::TextureDimension::k2d),
+              ty.DepthTexture(core::type::TextureDimension::k2d));
+    EXPECT_EQ(ty.MultisampledTexture(core::type::TextureDimension::k2d, ty.I32()),
+              ty.MultisampledTexture(core::type::TextureDimension::k2d, ty.I32()));
+    EXPECT_EQ(ty.SampledTexture(core::type::TextureDimension::k2d, ty.I32()),
+              ty.SampledTexture(core::type::TextureDimension::k2d, ty.I32()));
+    EXPECT_EQ(ty.StorageTexture(core::type::TextureDimension::k2d, core::TexelFormat::kR32Uint,
                                 core::Access::kRead),
-              ty.StorageTexture(type::TextureDimension::k2d, core::TexelFormat::kR32Uint,
+              ty.StorageTexture(core::type::TextureDimension::k2d, core::TexelFormat::kR32Uint,
                                 core::Access::kRead));
 }
 
@@ -68,29 +69,29 @@
     EXPECT_NE(ty.Array(ty.I32(), 3, 2), ty.Array(ty.I32(), 3, 3));
     EXPECT_NE(ty.Alias(sym_a, ty.I32()), ty.Alias(sym_b, ty.I32()));
     EXPECT_NE(ty.Struct(sym_a, {ty.I32()}), ty.Struct(sym_b, {ty.I32()}));
-    EXPECT_NE(ty.Sampler(type::SamplerKind::kSampler),
-              ty.Sampler(type::SamplerKind::kComparisonSampler));
-    EXPECT_NE(ty.DepthTexture(type::TextureDimension::k2d),
-              ty.DepthTexture(type::TextureDimension::k1d));
-    EXPECT_NE(ty.MultisampledTexture(type::TextureDimension::k2d, ty.I32()),
-              ty.MultisampledTexture(type::TextureDimension::k3d, ty.I32()));
-    EXPECT_NE(ty.MultisampledTexture(type::TextureDimension::k2d, ty.I32()),
-              ty.MultisampledTexture(type::TextureDimension::k2d, ty.U32()));
-    EXPECT_NE(ty.SampledTexture(type::TextureDimension::k2d, ty.I32()),
-              ty.SampledTexture(type::TextureDimension::k3d, ty.I32()));
-    EXPECT_NE(ty.SampledTexture(type::TextureDimension::k2d, ty.I32()),
-              ty.SampledTexture(type::TextureDimension::k2d, ty.U32()));
-    EXPECT_NE(ty.StorageTexture(type::TextureDimension::k2d, core::TexelFormat::kR32Uint,
+    EXPECT_NE(ty.Sampler(core::type::SamplerKind::kSampler),
+              ty.Sampler(core::type::SamplerKind::kComparisonSampler));
+    EXPECT_NE(ty.DepthTexture(core::type::TextureDimension::k2d),
+              ty.DepthTexture(core::type::TextureDimension::k1d));
+    EXPECT_NE(ty.MultisampledTexture(core::type::TextureDimension::k2d, ty.I32()),
+              ty.MultisampledTexture(core::type::TextureDimension::k3d, ty.I32()));
+    EXPECT_NE(ty.MultisampledTexture(core::type::TextureDimension::k2d, ty.I32()),
+              ty.MultisampledTexture(core::type::TextureDimension::k2d, ty.U32()));
+    EXPECT_NE(ty.SampledTexture(core::type::TextureDimension::k2d, ty.I32()),
+              ty.SampledTexture(core::type::TextureDimension::k3d, ty.I32()));
+    EXPECT_NE(ty.SampledTexture(core::type::TextureDimension::k2d, ty.I32()),
+              ty.SampledTexture(core::type::TextureDimension::k2d, ty.U32()));
+    EXPECT_NE(ty.StorageTexture(core::type::TextureDimension::k2d, core::TexelFormat::kR32Uint,
                                 core::Access::kRead),
-              ty.StorageTexture(type::TextureDimension::k3d, core::TexelFormat::kR32Uint,
+              ty.StorageTexture(core::type::TextureDimension::k3d, core::TexelFormat::kR32Uint,
                                 core::Access::kRead));
-    EXPECT_NE(ty.StorageTexture(type::TextureDimension::k2d, core::TexelFormat::kR32Uint,
+    EXPECT_NE(ty.StorageTexture(core::type::TextureDimension::k2d, core::TexelFormat::kR32Uint,
                                 core::Access::kRead),
-              ty.StorageTexture(type::TextureDimension::k2d, core::TexelFormat::kR32Sint,
+              ty.StorageTexture(core::type::TextureDimension::k2d, core::TexelFormat::kR32Sint,
                                 core::Access::kRead));
-    EXPECT_NE(ty.StorageTexture(type::TextureDimension::k2d, core::TexelFormat::kR32Uint,
+    EXPECT_NE(ty.StorageTexture(core::type::TextureDimension::k2d, core::TexelFormat::kR32Uint,
                                 core::Access::kRead),
-              ty.StorageTexture(type::TextureDimension::k2d, core::TexelFormat::kR32Uint,
+              ty.StorageTexture(core::type::TextureDimension::k2d, core::TexelFormat::kR32Uint,
                                 core::Access::kWrite));
 }
 
diff --git a/src/tint/lang/spirv/writer/ast_printer/ast_builtin_test.cc b/src/tint/lang/spirv/writer/ast_printer/ast_builtin_test.cc
index 34a34a7..8a34624 100644
--- a/src/tint/lang/spirv/writer/ast_printer/ast_builtin_test.cc
+++ b/src/tint/lang/spirv/writer/ast_printer/ast_builtin_test.cc
@@ -42,8 +42,8 @@
 
 // This tests that we do not push OpTypeSampledImage and float_0 type twice.
 TEST_F(BuiltinSpirvASTPrinterTest, Call_TextureSampleCompare_Twice) {
-    auto s = ty.sampler(type::SamplerKind::kComparisonSampler);
-    auto t = ty.depth_texture(type::TextureDimension::k2d);
+    auto s = ty.sampler(core::type::SamplerKind::kComparisonSampler);
+    auto t = ty.depth_texture(core::type::TextureDimension::k2d);
 
     auto* tex = GlobalVar("texture", t, Binding(0_a), Group(0_a));
     auto* sampler = GlobalVar("sampler", s, Binding(1_a), Group(0_a));
diff --git a/src/tint/lang/spirv/writer/ast_printer/ast_type_test.cc b/src/tint/lang/spirv/writer/ast_printer/ast_type_test.cc
index dca6047..090d165 100644
--- a/src/tint/lang/spirv/writer/ast_printer/ast_type_test.cc
+++ b/src/tint/lang/spirv/writer/ast_printer/ast_type_test.cc
@@ -117,7 +117,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, GenerateBool) {
-    auto* bool_ = create<type::Bool>();
+    auto* bool_ = create<core::type::Bool>();
 
     Builder& b = Build();
 
@@ -131,8 +131,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, ReturnsGeneratedBool) {
-    auto* bool_ = create<type::Bool>();
-    auto* i32 = create<type::I32>();
+    auto* bool_ = create<core::type::Bool>();
+    auto* i32 = create<core::type::I32>();
 
     Builder& b = Build();
 
@@ -145,7 +145,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, GenerateF32) {
-    auto* f32 = create<type::F32>();
+    auto* f32 = create<core::type::F32>();
 
     Builder& b = Build();
 
@@ -159,8 +159,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, ReturnsGeneratedF32) {
-    auto* f32 = create<type::F32>();
-    auto* i32 = create<type::I32>();
+    auto* f32 = create<core::type::F32>();
+    auto* i32 = create<core::type::I32>();
 
     Builder& b = Build();
 
@@ -173,7 +173,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, GenerateF16) {
-    auto* f16 = create<type::F16>();
+    auto* f16 = create<core::type::F16>();
 
     Builder& b = Build();
 
@@ -187,8 +187,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, ReturnsGeneratedF16) {
-    auto* f16 = create<type::F16>();
-    auto* i32 = create<type::I32>();
+    auto* f16 = create<core::type::F16>();
+    auto* i32 = create<core::type::I32>();
 
     Builder& b = Build();
 
@@ -201,7 +201,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, GenerateI32) {
-    auto* i32 = create<type::I32>();
+    auto* i32 = create<core::type::I32>();
 
     Builder& b = Build();
 
@@ -215,8 +215,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, ReturnsGeneratedI32) {
-    auto* f32 = create<type::F32>();
-    auto* i32 = create<type::I32>();
+    auto* f32 = create<core::type::F32>();
+    auto* i32 = create<core::type::I32>();
 
     Builder& b = Build();
 
@@ -229,9 +229,9 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, GenerateMatrix) {
-    auto* f32 = create<type::F32>();
-    auto* vec3 = create<type::Vector>(f32, 3u);
-    auto* mat2x3 = create<type::Matrix>(vec3, 2u);
+    auto* f32 = create<core::type::F32>();
+    auto* vec3 = create<core::type::Vector>(f32, 3u);
+    auto* mat2x3 = create<core::type::Matrix>(vec3, 2u);
 
     Builder& b = Build();
 
@@ -247,9 +247,9 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, ReturnsGeneratedMatrix) {
-    auto* i32 = create<type::I32>();
-    auto* col = create<type::Vector>(i32, 4u);
-    auto* mat = create<type::Matrix>(col, 3u);
+    auto* i32 = create<core::type::I32>();
+    auto* col = create<core::type::Vector>(i32, 4u);
+    auto* mat = create<core::type::Matrix>(col, 3u);
 
     Builder& b = Build();
 
@@ -262,9 +262,9 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, GenerateF16Matrix) {
-    auto* f16 = create<type::F16>();
-    auto* vec3 = create<type::Vector>(f16, 3u);
-    auto* mat2x3 = create<type::Matrix>(vec3, 2u);
+    auto* f16 = create<core::type::F16>();
+    auto* vec3 = create<core::type::Vector>(f16, 3u);
+    auto* mat2x3 = create<core::type::Matrix>(vec3, 2u);
 
     Builder& b = Build();
 
@@ -280,9 +280,9 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, ReturnsGeneratedF16Matrix) {
-    auto* f16 = create<type::F16>();
-    auto* col = create<type::Vector>(f16, 4u);
-    auto* mat = create<type::Matrix>(col, 3u);
+    auto* f16 = create<core::type::F16>();
+    auto* col = create<core::type::Vector>(f16, 4u);
+    auto* mat = create<core::type::Matrix>(col, 3u);
 
     Builder& b = Build();
 
@@ -295,8 +295,9 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, GeneratePtr) {
-    auto* i32 = create<type::I32>();
-    auto* ptr = create<type::Pointer>(core::AddressSpace::kOut, i32, core::Access::kReadWrite);
+    auto* i32 = create<core::type::I32>();
+    auto* ptr =
+        create<core::type::Pointer>(core::AddressSpace::kOut, i32, core::Access::kReadWrite);
 
     Builder& b = Build();
 
@@ -310,8 +311,9 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, ReturnsGeneratedPtr) {
-    auto* i32 = create<type::I32>();
-    auto* ptr = create<type::Pointer>(core::AddressSpace::kOut, i32, core::Access::kReadWrite);
+    auto* i32 = create<core::type::I32>();
+    auto* ptr =
+        create<core::type::Pointer>(core::AddressSpace::kOut, i32, core::Access::kReadWrite);
 
     Builder& b = Build();
 
@@ -519,7 +521,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, GenerateU32) {
-    auto* u32 = create<type::U32>();
+    auto* u32 = create<core::type::U32>();
 
     Builder& b = Build();
 
@@ -533,8 +535,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, ReturnsGeneratedU32) {
-    auto* u32 = create<type::U32>();
-    auto* f32 = create<type::F32>();
+    auto* u32 = create<core::type::U32>();
+    auto* f32 = create<core::type::F32>();
 
     Builder& b = Build();
 
@@ -547,7 +549,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, GenerateVector) {
-    auto* vec = create<type::Vector>(create<type::F32>(), 3u);
+    auto* vec = create<core::type::Vector>(create<core::type::F32>(), 3u);
 
     Builder& b = Build();
 
@@ -562,8 +564,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, ReturnsGeneratedVector) {
-    auto* i32 = create<type::I32>();
-    auto* vec = create<type::Vector>(i32, 3u);
+    auto* i32 = create<core::type::I32>();
+    auto* vec = create<core::type::Vector>(i32, 3u);
 
     Builder& b = Build();
 
@@ -576,7 +578,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, GenerateVoid) {
-    auto* void_ = create<type::Void>();
+    auto* void_ = create<core::type::Void>();
 
     Builder& b = Build();
 
@@ -590,8 +592,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, ReturnsGeneratedVoid) {
-    auto* void_ = create<type::Void>();
-    auto* i32 = create<type::I32>();
+    auto* void_ = create<core::type::Void>();
+    auto* i32 = create<core::type::I32>();
 
     Builder& b = Build();
 
@@ -635,7 +637,7 @@
                     PtrData{core::AddressSpace::kFunction, SpvStorageClassFunction}));
 
 TEST_F(SpirvASTPrinterTest_Type, DepthTexture_Generate_2d) {
-    auto* two_d = create<type::DepthTexture>(type::TextureDimension::k2d);
+    auto* two_d = create<core::type::DepthTexture>(core::type::TextureDimension::k2d);
 
     Builder& b = Build();
 
@@ -649,7 +651,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, DepthTexture_Generate_2dArray) {
-    auto* two_d_array = create<type::DepthTexture>(type::TextureDimension::k2dArray);
+    auto* two_d_array = create<core::type::DepthTexture>(core::type::TextureDimension::k2dArray);
 
     Builder& b = Build();
 
@@ -663,7 +665,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, DepthTexture_Generate_Cube) {
-    auto* cube = create<type::DepthTexture>(type::TextureDimension::kCube);
+    auto* cube = create<core::type::DepthTexture>(core::type::TextureDimension::kCube);
 
     Builder& b = Build();
 
@@ -678,7 +680,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, DepthTexture_Generate_CubeArray) {
-    auto* cube_array = create<type::DepthTexture>(type::TextureDimension::kCubeArray);
+    auto* cube_array = create<core::type::DepthTexture>(core::type::TextureDimension::kCubeArray);
 
     Builder& b = Build();
 
@@ -695,8 +697,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, MultisampledTexture_Generate_2d_i32) {
-    auto* i32 = create<type::I32>();
-    auto* ms = create<type::MultisampledTexture>(type::TextureDimension::k2d, i32);
+    auto* i32 = create<core::type::I32>();
+    auto* ms = create<core::type::MultisampledTexture>(core::type::TextureDimension::k2d, i32);
 
     Builder& b = Build();
 
@@ -708,8 +710,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, MultisampledTexture_Generate_2d_u32) {
-    auto* u32 = create<type::U32>();
-    auto* ms = create<type::MultisampledTexture>(type::TextureDimension::k2d, u32);
+    auto* u32 = create<core::type::U32>();
+    auto* ms = create<core::type::MultisampledTexture>(core::type::TextureDimension::k2d, u32);
 
     Builder& b = Build();
 
@@ -722,8 +724,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, MultisampledTexture_Generate_2d_f32) {
-    auto* f32 = create<type::F32>();
-    auto* ms = create<type::MultisampledTexture>(type::TextureDimension::k2d, f32);
+    auto* f32 = create<core::type::F32>();
+    auto* ms = create<core::type::MultisampledTexture>(core::type::TextureDimension::k2d, f32);
 
     Builder& b = Build();
 
@@ -736,7 +738,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, SampledTexture_Generate_1d_i32) {
-    auto* s = create<type::SampledTexture>(type::TextureDimension::k1d, create<type::I32>());
+    auto* s = create<core::type::SampledTexture>(core::type::TextureDimension::k1d,
+                                                 create<core::type::I32>());
 
     Builder& b = Build();
 
@@ -753,8 +756,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, SampledTexture_Generate_1d_u32) {
-    auto* u32 = create<type::U32>();
-    auto* s = create<type::SampledTexture>(type::TextureDimension::k1d, u32);
+    auto* u32 = create<core::type::U32>();
+    auto* s = create<core::type::SampledTexture>(core::type::TextureDimension::k1d, u32);
 
     Builder& b = Build();
 
@@ -771,8 +774,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, SampledTexture_Generate_1d_f32) {
-    auto* f32 = create<type::F32>();
-    auto* s = create<type::SampledTexture>(type::TextureDimension::k1d, f32);
+    auto* f32 = create<core::type::F32>();
+    auto* s = create<core::type::SampledTexture>(core::type::TextureDimension::k1d, f32);
 
     Builder& b = Build();
 
@@ -789,8 +792,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, SampledTexture_Generate_2d) {
-    auto* f32 = create<type::F32>();
-    auto* s = create<type::SampledTexture>(type::TextureDimension::k2d, f32);
+    auto* f32 = create<core::type::F32>();
+    auto* s = create<core::type::SampledTexture>(core::type::TextureDimension::k2d, f32);
 
     Builder& b = Build();
 
@@ -803,8 +806,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, SampledTexture_Generate_2d_array) {
-    auto* f32 = create<type::F32>();
-    auto* s = create<type::SampledTexture>(type::TextureDimension::k2dArray, f32);
+    auto* f32 = create<core::type::F32>();
+    auto* s = create<core::type::SampledTexture>(core::type::TextureDimension::k2dArray, f32);
 
     Builder& b = Build();
 
@@ -817,8 +820,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, SampledTexture_Generate_3d) {
-    auto* f32 = create<type::F32>();
-    auto* s = create<type::SampledTexture>(type::TextureDimension::k3d, f32);
+    auto* f32 = create<core::type::F32>();
+    auto* s = create<core::type::SampledTexture>(core::type::TextureDimension::k3d, f32);
 
     Builder& b = Build();
 
@@ -831,8 +834,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, SampledTexture_Generate_Cube) {
-    auto* f32 = create<type::F32>();
-    auto* s = create<type::SampledTexture>(type::TextureDimension::kCube, f32);
+    auto* f32 = create<core::type::F32>();
+    auto* s = create<core::type::SampledTexture>(core::type::TextureDimension::kCube, f32);
 
     Builder& b = Build();
 
@@ -846,8 +849,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, SampledTexture_Generate_CubeArray) {
-    auto* f32 = create<type::F32>();
-    auto* s = create<type::SampledTexture>(type::TextureDimension::kCubeArray, f32);
+    auto* f32 = create<core::type::F32>();
+    auto* s = create<core::type::SampledTexture>(core::type::TextureDimension::kCubeArray, f32);
 
     Builder& b = Build();
 
@@ -863,7 +866,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, StorageTexture_Generate_1d) {
-    auto s = ty.storage_texture(type::TextureDimension::k1d, core::TexelFormat::kR32Float,
+    auto s = ty.storage_texture(core::type::TextureDimension::k1d, core::TexelFormat::kR32Float,
                                 core::Access::kWrite);
 
     ast::Type ty = GlobalVar("test_var", s, Binding(0_a), Group(0_a))->type;
@@ -878,7 +881,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, StorageTexture_Generate_2d) {
-    auto s = ty.storage_texture(type::TextureDimension::k2d, core::TexelFormat::kR32Float,
+    auto s = ty.storage_texture(core::type::TextureDimension::k2d, core::TexelFormat::kR32Float,
                                 core::Access::kWrite);
 
     ast::Type ty = GlobalVar("test_var", s, Binding(0_a), Group(0_a))->type;
@@ -893,8 +896,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, StorageTexture_Generate_2dArray) {
-    auto s = ty.storage_texture(type::TextureDimension::k2dArray, core::TexelFormat::kR32Float,
-                                core::Access::kWrite);
+    auto s = ty.storage_texture(core::type::TextureDimension::k2dArray,
+                                core::TexelFormat::kR32Float, core::Access::kWrite);
 
     ast::Type ty = GlobalVar("test_var", s, Binding(0_a), Group(0_a))->type;
 
@@ -908,7 +911,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, StorageTexture_Generate_3d) {
-    auto s = ty.storage_texture(type::TextureDimension::k3d, core::TexelFormat::kR32Float,
+    auto s = ty.storage_texture(core::type::TextureDimension::k3d, core::TexelFormat::kR32Float,
                                 core::Access::kWrite);
 
     ast::Type ty = GlobalVar("test_var", s, Binding(0_a), Group(0_a))->type;
@@ -923,7 +926,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, StorageTexture_Generate_SampledTypeFloat_Format_r32float) {
-    auto s = ty.storage_texture(type::TextureDimension::k2d, core::TexelFormat::kR32Float,
+    auto s = ty.storage_texture(core::type::TextureDimension::k2d, core::TexelFormat::kR32Float,
                                 core::Access::kWrite);
 
     ast::Type ty = GlobalVar("test_var", s, Binding(0_a), Group(0_a))->type;
@@ -938,7 +941,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, StorageTexture_Generate_SampledTypeSint_Format_r32sint) {
-    auto s = ty.storage_texture(type::TextureDimension::k2d, core::TexelFormat::kR32Sint,
+    auto s = ty.storage_texture(core::type::TextureDimension::k2d, core::TexelFormat::kR32Sint,
                                 core::Access::kWrite);
 
     ast::Type ty = GlobalVar("test_var", s, Binding(0_a), Group(0_a))->type;
@@ -953,7 +956,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, StorageTexture_Generate_SampledTypeUint_Format_r32uint) {
-    auto s = ty.storage_texture(type::TextureDimension::k2d, core::TexelFormat::kR32Uint,
+    auto s = ty.storage_texture(core::type::TextureDimension::k2d, core::TexelFormat::kR32Uint,
                                 core::Access::kWrite);
 
     ast::Type ty = GlobalVar("test_var", s, Binding(0_a), Group(0_a))->type;
@@ -968,7 +971,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, Sampler) {
-    auto* sampler = create<type::Sampler>(type::SamplerKind::kSampler);
+    auto* sampler = create<core::type::Sampler>(core::type::SamplerKind::kSampler);
 
     Builder& b = Build();
 
@@ -978,7 +981,7 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, ComparisonSampler) {
-    auto* sampler = create<type::Sampler>(type::SamplerKind::kComparisonSampler);
+    auto* sampler = create<core::type::Sampler>(core::type::SamplerKind::kComparisonSampler);
 
     Builder& b = Build();
 
@@ -988,8 +991,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest_Type, Dedup_Sampler_And_ComparisonSampler) {
-    auto* comp_sampler = create<type::Sampler>(type::SamplerKind::kComparisonSampler);
-    auto* sampler = create<type::Sampler>(type::SamplerKind::kSampler);
+    auto* comp_sampler = create<core::type::Sampler>(core::type::SamplerKind::kComparisonSampler);
+    auto* sampler = create<core::type::Sampler>(core::type::SamplerKind::kSampler);
 
     Builder& b = Build();
 
diff --git a/src/tint/lang/spirv/writer/ast_printer/builder.cc b/src/tint/lang/spirv/writer/ast_printer/builder.cc
index 99d53d0..4aa4876 100644
--- a/src/tint/lang/spirv/writer/ast_printer/builder.cc
+++ b/src/tint/lang/spirv/writer/ast_printer/builder.cc
@@ -82,11 +82,11 @@
 /// one or more levels of an arrays inside of `type`.
 /// @param type the given type, which must not be null
 /// @returns the nested matrix type, or nullptr if none
-const type::Matrix* GetNestedMatrixType(const type::Type* type) {
-    while (auto* arr = type->As<type::Array>()) {
+const core::type::Matrix* GetNestedMatrixType(const core::type::Type* type) {
+    while (auto* arr = type->As<core::type::Array>()) {
         type = arr->ElemType();
     }
-    return type->As<type::Matrix>();
+    return type->As<core::type::Matrix>();
 }
 
 uint32_t builtin_to_glsl_method(const sem::Builtin* builtin) {
@@ -232,8 +232,8 @@
 }
 
 /// @return the vector element type if ty is a vector, otherwise return ty.
-const type::Type* ElementTypeOf(const type::Type* ty) {
-    if (auto* v = ty->As<type::Vector>()) {
+const core::type::Type* ElementTypeOf(const core::type::Type* ty) {
+    if (auto* v = ty->As<core::type::Vector>()) {
         return v->type();
     }
     return ty;
@@ -572,7 +572,7 @@
     }
 
     if (InsideBasicBlock()) {
-        if (func->ReturnType()->Is<type::Void>()) {
+        if (func->ReturnType()->Is<core::type::Void>()) {
             push_function_inst(spv::Op::OpReturn, {});
         } else {
             auto zero = GenerateConstantNullIfNeeded(func->ReturnType());
@@ -722,8 +722,8 @@
     if (v->initializer) {
         ops.push_back(Operand(init_id));
     } else {
-        auto* st = type->As<type::StorageTexture>();
-        if (st || type->Is<type::Struct>()) {
+        auto* st = type->As<core::type::StorageTexture>();
+        if (st || type->Is<core::type::Struct>()) {
             // type is a type::Struct or a type::StorageTexture
             auto access = st ? st->access() : sem->Access();
             switch (access) {
@@ -740,7 +740,7 @@
                     break;
             }
         }
-        if (!type->Is<type::Sampler>()) {
+        if (!type->Is<core::type::Sampler>()) {
             // If we don't have a initializer and we're an Output or Private
             // variable, then WGSL requires that we zero-initialize.
             // If we're a Workgroup variable, and the
@@ -846,7 +846,7 @@
     // If the source is a reference, we access chain into it.
     // In the future, pointers may support access-chaining.
     // See https://github.com/gpuweb/gpuweb/pull/1580
-    if (info->source_type->Is<type::Reference>()) {
+    if (info->source_type->Is<core::type::Reference>()) {
         info->access_chain_indices.push_back(idx_id);
         info->source_type = builder_.Sem().Get(expr)->UnwrapLoad()->Type();
         return true;
@@ -881,7 +881,7 @@
     }
 
     // If the source is a vector, we use OpVectorExtractDynamic.
-    if (TINT_LIKELY(info->source_type->Is<type::Vector>())) {
+    if (TINT_LIKELY(info->source_type->Is<core::type::Vector>())) {
         if (!push_function_inst(
                 spv::Op::OpVectorExtractDynamic,
                 {Operand(result_type_id), extract, Operand(info->source_id), Operand(idx_id)})) {
@@ -908,7 +908,7 @@
         [&](const sem::StructMemberAccess* access) {
             uint32_t idx = access->Member()->Index();
 
-            if (info->source_type->Is<type::Reference>()) {
+            if (info->source_type->Is<core::type::Reference>()) {
                 auto idx_id = GenerateConstantIfNeeded(ScalarConstant::U32(idx));
                 if (TINT_UNLIKELY(idx_id == 0)) {
                     return false;
@@ -939,7 +939,7 @@
             // Single element swizzle is either an access chain or a composite extract
             auto& indices = swizzle->Indices();
             if (indices.Length() == 1) {
-                if (info->source_type->Is<type::Reference>()) {
+                if (info->source_type->Is<core::type::Reference>()) {
                     auto idx_id = GenerateConstantIfNeeded(ScalarConstant::U32(indices[0]));
                     if (TINT_UNLIKELY(idx_id == 0)) {
                         return false;
@@ -1107,7 +1107,7 @@
     return 0;
 }
 
-uint32_t Builder::GenerateLoad(const type::Reference* type, uint32_t id) {
+uint32_t Builder::GenerateLoad(const core::type::Reference* type, uint32_t id) {
     auto type_id = GenerateTypeIfNeeded(type->StoreType());
     auto result = result_op();
     auto result_id = std::get<uint32_t>(result);
@@ -1117,8 +1117,8 @@
     return result_id;
 }
 
-uint32_t Builder::GenerateLoadIfNeeded(const type::Type* type, uint32_t id) {
-    if (auto* ref = type->As<type::Reference>()) {
+uint32_t Builder::GenerateLoadIfNeeded(const core::type::Type* type, uint32_t id) {
+    if (auto* ref = type->As<core::type::Reference>()) {
         return GenerateLoad(ref, id);
     }
     return id;
@@ -1243,22 +1243,22 @@
         return 0;
     }
 
-    bool can_cast_or_copy = result_type->Is<type::Scalar>();
+    bool can_cast_or_copy = result_type->Is<core::type::Scalar>();
 
-    if (auto* res_vec = result_type->As<type::Vector>()) {
-        if (res_vec->type()->Is<type::Scalar>()) {
+    if (auto* res_vec = result_type->As<core::type::Vector>()) {
+        if (res_vec->type()->Is<core::type::Scalar>()) {
             auto* value_type = args[0]->Type()->UnwrapRef();
-            if (auto* val_vec = value_type->As<type::Vector>()) {
-                if (val_vec->type()->Is<type::Scalar>()) {
+            if (auto* val_vec = value_type->As<core::type::Vector>()) {
+                if (val_vec->type()->Is<core::type::Scalar>()) {
                     can_cast_or_copy = res_vec->Width() == val_vec->Width();
                 }
             }
         }
     }
 
-    if (auto* res_mat = result_type->As<type::Matrix>()) {
+    if (auto* res_mat = result_type->As<core::type::Matrix>()) {
         auto* value_type = args[0]->Type()->UnwrapRef();
-        if (auto* val_mat = value_type->As<type::Matrix>()) {
+        if (auto* val_mat = value_type->As<core::type::Matrix>()) {
             // Generate passthrough for matrices of the same type
             can_cast_or_copy = res_mat == val_mat;
         }
@@ -1276,7 +1276,7 @@
     bool result_is_constant_composite = constructor_is_const;
     bool result_is_spec_composite = false;
 
-    if (auto* vec = result_type->As<type::Vector>()) {
+    if (auto* vec = result_type->As<core::type::Vector>()) {
         result_type = vec->type();
     }
 
@@ -1298,15 +1298,15 @@
         // If the result and value types are the same we can just use the object.
         // If the result is not a vector then we should have validated that the
         // value type is a correctly sized vector so we can just use it directly.
-        if (result_type == value_type || result_type->Is<type::Matrix>() ||
-            result_type->Is<type::Array>() || result_type->Is<type::Struct>()) {
+        if (result_type == value_type || result_type->Is<core::type::Matrix>() ||
+            result_type->Is<core::type::Array>() || result_type->Is<core::type::Struct>()) {
             ops.push_back(Operand(id));
             continue;
         }
 
         // Both scalars, but not the same type so we need to generate a conversion
         // of the value.
-        if (value_type->Is<type::Scalar>() && result_type->Is<type::Scalar>()) {
+        if (value_type->Is<core::type::Scalar>() && result_type->Is<core::type::Scalar>()) {
             id = GenerateCastOrCopyOrPassthrough(result_type, args[0]->Declaration(), global_var);
             ops.push_back(Operand(id));
             continue;
@@ -1321,7 +1321,7 @@
         //
         // For cases 1 and 2, if the type is different we also may need to insert
         // a type cast.
-        if (auto* vec = value_type->As<type::Vector>()) {
+        if (auto* vec = value_type->As<core::type::Vector>()) {
             auto* vec_type = vec->type();
 
             auto value_type_id = GenerateTypeIfNeeded(vec_type);
@@ -1368,8 +1368,8 @@
     // For a single-value vector initializer, splat the initializer value.
     auto* const init_result_type = call->Type()->UnwrapRef();
     if (args.Length() == 1 && init_result_type->is_scalar_vector() &&
-        args[0]->Type()->UnwrapRef()->Is<type::Scalar>()) {
-        size_t vec_size = init_result_type->As<type::Vector>()->Width();
+        args[0]->Type()->UnwrapRef()->Is<core::type::Scalar>()) {
+        size_t vec_size = init_result_type->As<core::type::Vector>()->Width();
         for (size_t i = 0; i < (vec_size - 1); ++i) {
             ops.push_back(ops[kOpsFirstValueIdx]);
         }
@@ -1397,7 +1397,7 @@
     });
 }
 
-uint32_t Builder::GenerateCastOrCopyOrPassthrough(const type::Type* to_type,
+uint32_t Builder::GenerateCastOrCopyOrPassthrough(const core::type::Type* to_type,
                                                   const ast::Expression* from_expr,
                                                   bool is_global_init) {
     // This should not happen as we rely on constant folding to obviate
@@ -1408,11 +1408,11 @@
         return 0;
     }
 
-    auto elem_type_of = [](const type::Type* t) -> const type::Type* {
-        if (t->Is<type::Scalar>()) {
+    auto elem_type_of = [](const core::type::Type* t) -> const core::type::Type* {
+        if (t->Is<core::type::Scalar>()) {
             return t;
         }
-        if (auto* v = t->As<type::Vector>()) {
+        if (auto* v = t->As<core::type::Vector>()) {
             return v->type();
         }
         return nullptr;
@@ -1434,38 +1434,39 @@
     auto* from_type = TypeOf(from_expr)->UnwrapRef();
 
     spv::Op op = spv::Op::OpNop;
-    if ((from_type->Is<type::I32>() && to_type->is_float_scalar()) ||
+    if ((from_type->Is<core::type::I32>() && to_type->is_float_scalar()) ||
         (from_type->is_signed_integer_vector() && to_type->is_float_vector())) {
         op = spv::Op::OpConvertSToF;
-    } else if ((from_type->Is<type::U32>() && to_type->is_float_scalar()) ||
+    } else if ((from_type->Is<core::type::U32>() && to_type->is_float_scalar()) ||
                (from_type->is_unsigned_integer_vector() && to_type->is_float_vector())) {
         op = spv::Op::OpConvertUToF;
-    } else if ((from_type->is_float_scalar() && to_type->Is<type::I32>()) ||
+    } else if ((from_type->is_float_scalar() && to_type->Is<core::type::I32>()) ||
                (from_type->is_float_vector() && to_type->is_signed_integer_vector())) {
         op = spv::Op::OpConvertFToS;
-    } else if ((from_type->is_float_scalar() && to_type->Is<type::U32>()) ||
+    } else if ((from_type->is_float_scalar() && to_type->Is<core::type::U32>()) ||
                (from_type->is_float_vector() && to_type->is_unsigned_integer_vector())) {
         op = spv::Op::OpConvertFToU;
-    } else if (from_type->IsAnyOf<type::Bool, type::F32, type::I32, type::U32, type::F16,
-                                  type::Vector>() &&
+    } else if (from_type->IsAnyOf<core::type::Bool, core::type::F32, core::type::I32,
+                                  core::type::U32, core::type::F16, core::type::Vector>() &&
                from_type == to_type) {
         // Identity initializer for scalar and vector types
         return val_id;
     } else if ((from_type->is_float_scalar() && to_type->is_float_scalar()) ||
                (from_type->is_float_vector() && to_type->is_float_vector() &&
-                from_type->As<type::Vector>()->Width() == to_type->As<type::Vector>()->Width())) {
+                from_type->As<core::type::Vector>()->Width() ==
+                    to_type->As<core::type::Vector>()->Width())) {
         // Convert between f32 and f16 types.
         // OpFConvert requires the scalar component types to be different, and the case of from_type
         // and to_type being the same floating point scalar or vector type, i.e. identity
         // initializer, is already handled in the previous else-if clause.
         op = spv::Op::OpFConvert;
-    } else if ((from_type->Is<type::I32>() && to_type->Is<type::U32>()) ||
-               (from_type->Is<type::U32>() && to_type->Is<type::I32>()) ||
+    } else if ((from_type->Is<core::type::I32>() && to_type->Is<core::type::U32>()) ||
+               (from_type->Is<core::type::U32>() && to_type->Is<core::type::I32>()) ||
                (from_type->is_signed_integer_vector() && to_type->is_unsigned_integer_vector()) ||
                (from_type->is_unsigned_integer_vector() &&
                 to_type->is_integer_scalar_or_vector())) {
         op = spv::Op::OpBitcast;
-    } else if ((from_type->Is<type::NumericScalar>() && to_type->Is<type::Bool>()) ||
+    } else if ((from_type->Is<core::type::NumericScalar>() && to_type->Is<core::type::Bool>()) ||
                (from_type->is_numeric_vector() && to_type->is_bool_vector())) {
         // Convert scalar (vector) to bool (vector)
 
@@ -1486,23 +1487,23 @@
         const auto* to_elem_type = elem_type_of(to_type);
         uint32_t one_id;
         uint32_t zero_id;
-        if (to_elem_type->Is<type::F32>()) {
+        if (to_elem_type->Is<core::type::F32>()) {
             zero_id = GenerateConstantIfNeeded(ScalarConstant::F32(0));
             one_id = GenerateConstantIfNeeded(ScalarConstant::F32(1));
-        } else if (to_elem_type->Is<type::F16>()) {
+        } else if (to_elem_type->Is<core::type::F16>()) {
             zero_id = GenerateConstantIfNeeded(ScalarConstant::F16(0));
             one_id = GenerateConstantIfNeeded(ScalarConstant::F16(1));
-        } else if (to_elem_type->Is<type::U32>()) {
+        } else if (to_elem_type->Is<core::type::U32>()) {
             zero_id = GenerateConstantIfNeeded(ScalarConstant::U32(0));
             one_id = GenerateConstantIfNeeded(ScalarConstant::U32(1));
-        } else if (to_elem_type->Is<type::I32>()) {
+        } else if (to_elem_type->Is<core::type::I32>()) {
             zero_id = GenerateConstantIfNeeded(ScalarConstant::I32(0));
             one_id = GenerateConstantIfNeeded(ScalarConstant::I32(1));
         } else {
             TINT_ICE() << "invalid destination type for bool conversion";
             return false;
         }
-        if (auto* to_vec = to_type->As<type::Vector>()) {
+        if (auto* to_vec = to_type->As<core::type::Vector>()) {
             // Splat the scalars into vectors.
             zero_id = GenerateConstantVectorSplatIfNeeded(to_vec, zero_id);
             one_id = GenerateConstantVectorSplatIfNeeded(to_vec, one_id);
@@ -1518,12 +1519,13 @@
         }
 
         return result_id;
-    } else if (TINT_LIKELY(from_type->Is<type::Matrix>() && to_type->Is<type::Matrix>())) {
+    } else if (TINT_LIKELY(from_type->Is<core::type::Matrix>() &&
+                           to_type->Is<core::type::Matrix>())) {
         // SPIRV does not support matrix conversion, the only valid case is matrix identity
         // initializer. Matrix conversion between f32 and f16 should be transformed into vector
         // conversions for each column vectors by VectorizeMatrixConversions.
-        auto* from_mat = from_type->As<type::Matrix>();
-        auto* to_mat = to_type->As<type::Matrix>();
+        auto* from_mat = from_type->As<core::type::Matrix>();
+        auto* to_mat = to_type->As<core::type::Matrix>();
         if (TINT_LIKELY(from_mat == to_mat)) {
             return val_id;
         }
@@ -1628,37 +1630,37 @@
 
     return Switch(
         ty,  //
-        [&](const type::Bool*) {
+        [&](const core::type::Bool*) {
             bool val = constant->ValueAs<bool>();
             return GenerateConstantIfNeeded(ScalarConstant::Bool(val));
         },
-        [&](const type::F32*) {
+        [&](const core::type::F32*) {
             auto val = constant->ValueAs<f32>();
             return GenerateConstantIfNeeded(ScalarConstant::F32(val.value));
         },
-        [&](const type::F16*) {
+        [&](const core::type::F16*) {
             auto val = constant->ValueAs<f16>();
             return GenerateConstantIfNeeded(ScalarConstant::F16(val.value));
         },
-        [&](const type::I32*) {
+        [&](const core::type::I32*) {
             auto val = constant->ValueAs<i32>();
             return GenerateConstantIfNeeded(ScalarConstant::I32(val.value));
         },
-        [&](const type::U32*) {
+        [&](const core::type::U32*) {
             auto val = constant->ValueAs<u32>();
             return GenerateConstantIfNeeded(ScalarConstant::U32(val.value));
         },
-        [&](const type::Vector* v) { return composite(v->Width()); },
-        [&](const type::Matrix* m) { return composite(m->columns()); },
-        [&](const type::Array* a) {
+        [&](const core::type::Vector* v) { return composite(v->Width()); },
+        [&](const core::type::Matrix* m) { return composite(m->columns()); },
+        [&](const core::type::Array* a) {
             auto count = a->ConstantCount();
             if (!count) {
-                TINT_ICE() << type::Array::kErrExpectedConstantCount;
+                TINT_ICE() << core::type::Array::kErrExpectedConstantCount;
                 return static_cast<uint32_t>(0);
             }
             return composite(count.value());
         },
-        [&](const type::Struct* s) { return composite(s->Members().Length()); },
+        [&](const core::type::Struct* s) { return composite(s->Members().Length()); },
         [&](Default) {
             TINT_ICE() << "unhandled constant type: " + ty->FriendlyName();
             return 0;
@@ -1675,23 +1677,23 @@
 
     switch (constant.kind) {
         case ScalarConstant::Kind::kU32: {
-            type_id = GenerateTypeIfNeeded(builder_.create<type::U32>());
+            type_id = GenerateTypeIfNeeded(builder_.create<core::type::U32>());
             break;
         }
         case ScalarConstant::Kind::kI32: {
-            type_id = GenerateTypeIfNeeded(builder_.create<type::I32>());
+            type_id = GenerateTypeIfNeeded(builder_.create<core::type::I32>());
             break;
         }
         case ScalarConstant::Kind::kF32: {
-            type_id = GenerateTypeIfNeeded(builder_.create<type::F32>());
+            type_id = GenerateTypeIfNeeded(builder_.create<core::type::F32>());
             break;
         }
         case ScalarConstant::Kind::kF16: {
-            type_id = GenerateTypeIfNeeded(builder_.create<type::F16>());
+            type_id = GenerateTypeIfNeeded(builder_.create<core::type::F16>());
             break;
         }
         case ScalarConstant::Kind::kBool: {
-            type_id = GenerateTypeIfNeeded(builder_.create<type::Bool>());
+            type_id = GenerateTypeIfNeeded(builder_.create<core::type::Bool>());
             break;
         }
     }
@@ -1739,7 +1741,7 @@
     return result_id;
 }
 
-uint32_t Builder::GenerateConstantNullIfNeeded(const type::Type* type) {
+uint32_t Builder::GenerateConstantNullIfNeeded(const core::type::Type* type) {
     auto type_id = GenerateTypeIfNeeded(type);
     if (type_id == 0) {
         return 0;
@@ -1754,7 +1756,8 @@
     });
 }
 
-uint32_t Builder::GenerateConstantVectorSplatIfNeeded(const type::Vector* type, uint32_t value_id) {
+uint32_t Builder::GenerateConstantVectorSplatIfNeeded(const core::type::Vector* type,
+                                                      uint32_t value_id) {
     auto type_id = GenerateTypeIfNeeded(type);
     if (type_id == 0 || value_id == 0) {
         return 0;
@@ -1849,11 +1852,11 @@
     return result_id;
 }
 
-uint32_t Builder::GenerateSplat(uint32_t scalar_id, const type::Type* vec_type) {
+uint32_t Builder::GenerateSplat(uint32_t scalar_id, const core::type::Type* vec_type) {
     // Create a new vector to splat scalar into
     auto splat_vector = result_op();
-    auto* splat_vector_type = builder_.create<type::Pointer>(core::AddressSpace::kFunction,
-                                                             vec_type, core::Access::kReadWrite);
+    auto* splat_vector_type = builder_.create<core::type::Pointer>(
+        core::AddressSpace::kFunction, vec_type, core::Access::kReadWrite);
     push_function_var({Operand(GenerateTypeIfNeeded(splat_vector_type)), splat_vector,
                        U32Operand(ConvertAddressSpace(core::AddressSpace::kFunction)),
                        Operand(GenerateConstantNullIfNeeded(vec_type))});
@@ -1863,7 +1866,7 @@
     OperandList ops;
     ops.push_back(Operand(GenerateTypeIfNeeded(vec_type)));
     ops.push_back(splat_result);
-    for (size_t i = 0; i < vec_type->As<type::Vector>()->Width(); ++i) {
+    for (size_t i = 0; i < vec_type->As<core::type::Vector>()->Width(); ++i) {
         ops.push_back(Operand(scalar_id));
     }
     if (!push_function_inst(spv::Op::OpCompositeConstruct, ops)) {
@@ -1875,7 +1878,7 @@
 
 uint32_t Builder::GenerateMatrixAddOrSub(uint32_t lhs_id,
                                          uint32_t rhs_id,
-                                         const type::Matrix* type,
+                                         const core::type::Matrix* type,
                                          spv::Op op) {
     // Example addition of two matrices:
     // %31 = OpLoad %mat3v4float %m34
@@ -1891,7 +1894,7 @@
     // %41 = OpFAdd %v4float %39 %40
     // %42 = OpCompositeConstruct %mat3v4float %35 %38 %41
 
-    auto* column_type = builder_.create<type::Vector>(type->type(), type->rows());
+    auto* column_type = builder_.create<core::type::Vector>(type->type(), type->rows());
     auto column_type_id = GenerateTypeIfNeeded(column_type);
 
     OperandList ops;
@@ -1966,8 +1969,8 @@
     // Handle matrix-matrix addition and subtraction
     if ((expr->IsAdd() || expr->IsSubtract()) && lhs_type->is_float_matrix() &&
         rhs_type->is_float_matrix()) {
-        auto* lhs_mat = lhs_type->As<type::Matrix>();
-        auto* rhs_mat = rhs_type->As<type::Matrix>();
+        auto* lhs_mat = lhs_type->As<core::type::Matrix>();
+        auto* rhs_mat = rhs_type->As<core::type::Matrix>();
 
         // This should already have been validated by resolver
         if (lhs_mat->rows() != rhs_mat->rows() || lhs_mat->columns() != rhs_mat->columns()) {
@@ -1986,7 +1989,7 @@
                                (lhs_type->is_float_vector() && rhs_type->is_float_scalar()));
 
     if (expr->IsArithmetic() && !is_float_scalar_vector_multiply) {
-        if (lhs_type->Is<type::Vector>() && rhs_type->Is<type::NumericScalar>()) {
+        if (lhs_type->Is<core::type::Vector>() && rhs_type->Is<core::type::NumericScalar>()) {
             uint32_t splat_vector_id = GenerateSplat(rhs_id, lhs_type);
             if (splat_vector_id == 0) {
                 return 0;
@@ -1994,7 +1997,8 @@
             rhs_id = splat_vector_id;
             rhs_type = lhs_type;
 
-        } else if (lhs_type->Is<type::NumericScalar>() && rhs_type->Is<type::Vector>()) {
+        } else if (lhs_type->Is<core::type::NumericScalar>() &&
+                   rhs_type->Is<core::type::Vector>()) {
             uint32_t splat_vector_id = GenerateSplat(lhs_id, rhs_type);
             if (splat_vector_id == 0) {
                 return 0;
@@ -2280,7 +2284,7 @@
             return 0;
         }
 
-        if (generate_load && !param->Type()->Is<type::Pointer>()) {
+        if (generate_load && !param->Type()->Is<core::type::Pointer>()) {
             val_id = GenerateLoadIfNeeded(arg->Type(), val_id);
         }
         return val_id;
@@ -2300,14 +2304,14 @@
 
     switch (builtin->Type()) {
         case core::Function::kAny:
-            if (builtin->Parameters()[0]->Type()->Is<type::Bool>()) {
+            if (builtin->Parameters()[0]->Type()->Is<core::type::Bool>()) {
                 // any(v: bool) just resolves to v.
                 return get_arg_as_value_id(0);
             }
             op = spv::Op::OpAny;
             break;
         case core::Function::kAll:
-            if (builtin->Parameters()[0]->Type()->Is<type::Bool>()) {
+            if (builtin->Parameters()[0]->Type()->Is<core::type::Bool>()) {
                 // all(v: bool) just resolves to v.
                 return get_arg_as_value_id(0);
             }
@@ -2336,13 +2340,14 @@
             params.push_back(Operand(struct_id));
 
             auto* type = TypeOf(accessor->object)->UnwrapRef();
-            if (!type->Is<type::Struct>()) {
+            if (!type->Is<core::type::Struct>()) {
                 TINT_ICE() << "invalid type (" + type->FriendlyName() +
                                   ") for runtime array length";
                 return 0;
             }
             // Runtime array must be the last member in the structure
-            params.push_back(Operand(uint32_t(type->As<type::Struct>()->Members().Length() - 1)));
+            params.push_back(
+                Operand(uint32_t(type->As<core::type::Struct>()->Members().Length() - 1)));
 
             if (!push_function_inst(spv::Op::OpArrayLength, params)) {
                 return 0;
@@ -2354,7 +2359,7 @@
             break;
         case core::Function::kDot: {
             op = spv::Op::OpDot;
-            auto* vec_ty = builtin->Parameters()[0]->Type()->As<type::Vector>();
+            auto* vec_ty = builtin->Parameters()[0]->Type()->As<core::type::Vector>();
             if (vec_ty->type()->is_integer_scalar()) {
                 // TODO(crbug.com/tint/1267): OpDot requires floating-point types, but
                 // WGSL also supports integer types. SPV_KHR_integer_dot_product adds
@@ -2440,8 +2445,8 @@
 
             // If the interpolant is scalar but the objects are vectors, we need to
             // splat the interpolant into a vector of the same size.
-            auto* result_vector_type = builtin->ReturnType()->As<type::Vector>();
-            if (result_vector_type && builtin->Parameters()[2]->Type()->Is<type::Scalar>()) {
+            auto* result_vector_type = builtin->ReturnType()->As<core::type::Vector>();
+            if (result_vector_type && builtin->Parameters()[2]->Type()->Is<core::type::Scalar>()) {
                 f_id = GenerateSplat(f_id, builtin->Parameters()[0]->Type());
                 if (f_id == 0) {
                     return 0;
@@ -2473,10 +2478,10 @@
             // If the condition is scalar but the objects are vectors, we need to
             // splat the condition into a vector of the same size.
             // TODO(jrprice): If we're targeting SPIR-V 1.4, we don't need to do this.
-            auto* result_vector_type = builtin->ReturnType()->As<type::Vector>();
-            if (result_vector_type && builtin->Parameters()[2]->Type()->Is<type::Scalar>()) {
-                auto* bool_vec_ty = builder_.create<type::Vector>(builder_.create<type::Bool>(),
-                                                                  result_vector_type->Width());
+            auto* result_vector_type = builtin->ReturnType()->As<core::type::Vector>();
+            if (result_vector_type && builtin->Parameters()[2]->Type()->Is<core::type::Scalar>()) {
+                auto* bool_vec_ty = builder_.create<core::type::Vector>(
+                    builder_.create<core::type::Bool>(), result_vector_type->Width());
                 if (!GenerateTypeIfNeeded(bool_vec_ty)) {
                     return 0;
                 }
@@ -2606,7 +2611,7 @@
         TINT_ICE() << "missing texture argument";
     }
 
-    auto* texture_type = texture->Type()->UnwrapRef()->As<type::Texture>();
+    auto* texture_type = texture->Type()->UnwrapRef()->As<core::type::Texture>();
 
     auto op = spv::Op::OpNop;
 
@@ -2642,9 +2647,10 @@
     // If the texture is not a depth texture, then this function simply delegates
     // to calling append_result_type_and_id_to_spirv_params().
     auto append_result_type_and_id_to_spirv_params_for_read = [&] {
-        if (texture_type->IsAnyOf<type::DepthTexture, type::DepthMultisampledTexture>()) {
-            auto* f32 = builder_.create<type::F32>();
-            auto* spirv_result_type = builder_.create<type::Vector>(f32, 4u);
+        if (texture_type
+                ->IsAnyOf<core::type::DepthTexture, core::type::DepthMultisampledTexture>()) {
+            auto* f32 = builder_.create<core::type::F32>();
+            auto* spirv_result_type = builder_.create<core::type::Vector>(f32, 4u);
             auto spirv_result = result_op();
             post_emission = [=] {
                 return push_function_inst(spv::Op::OpCompositeExtract,
@@ -2675,7 +2681,7 @@
             auto* element_type = ElementTypeOf(call->Type());
             auto spirv_result = result_op();
             auto* spirv_result_type =
-                builder_.create<type::Vector>(element_type, spirv_result_width);
+                builder_.create<core::type::Vector>(element_type, spirv_result_width);
             if (swizzle.size() > 1) {
                 post_emission = [=] {
                     OperandList operands{
@@ -2744,16 +2750,16 @@
             std::vector<uint32_t> swizzle;
             uint32_t spirv_dims = 0;
             switch (texture_type->dim()) {
-                case type::TextureDimension::kNone:
+                case core::type::TextureDimension::kNone:
                     TINT_ICE() << "texture dimension is kNone";
                     return false;
-                case type::TextureDimension::k1d:
-                case type::TextureDimension::k2d:
-                case type::TextureDimension::k3d:
-                case type::TextureDimension::kCube:
+                case core::type::TextureDimension::k1d:
+                case core::type::TextureDimension::k2d:
+                case core::type::TextureDimension::k3d:
+                case core::type::TextureDimension::kCube:
                     break;  // No swizzle needed
-                case type::TextureDimension::kCubeArray:
-                case type::TextureDimension::k2dArray:
+                case core::type::TextureDimension::kCubeArray:
+                case core::type::TextureDimension::k2dArray:
                     swizzle = {0, 1};  // Strip array index
                     spirv_dims = 3;    // [width, height, array_count]
                     break;
@@ -2764,9 +2770,9 @@
             }
 
             spirv_params.emplace_back(gen_arg(Usage::kTexture));
-            if (texture_type->IsAnyOf<type::MultisampledTexture,       //
-                                      type::DepthMultisampledTexture,  //
-                                      type::StorageTexture>()) {
+            if (texture_type->IsAnyOf<core::type::MultisampledTexture,       //
+                                      core::type::DepthMultisampledTexture,  //
+                                      core::type::StorageTexture>()) {
                 op = spv::Op::OpImageQuerySize;
             } else if (auto* level = arg(Usage::kLevel)) {
                 op = spv::Op::OpImageQuerySizeLod;
@@ -2784,8 +2790,8 @@
                 default:
                     TINT_ICE() << "texture is not arrayed";
                     return false;
-                case type::TextureDimension::k2dArray:
-                case type::TextureDimension::kCubeArray:
+                case core::type::TextureDimension::k2dArray:
+                case core::type::TextureDimension::kCubeArray:
                     spirv_dims = 3;
                     break;
             }
@@ -2798,8 +2804,8 @@
 
             spirv_params.emplace_back(gen_arg(Usage::kTexture));
 
-            if (texture_type->Is<type::MultisampledTexture>() ||
-                texture_type->Is<type::StorageTexture>()) {
+            if (texture_type->Is<core::type::MultisampledTexture>() ||
+                texture_type->Is<core::type::StorageTexture>()) {
                 op = spv::Op::OpImageQuerySize;
             } else {
                 op = spv::Op::OpImageQuerySizeLod;
@@ -2821,8 +2827,8 @@
             break;
         }
         case core::Function::kTextureLoad: {
-            op = texture_type->Is<type::StorageTexture>() ? spv::Op::OpImageRead
-                                                          : spv::Op::OpImageFetch;
+            op = texture_type->Is<core::type::StorageTexture>() ? spv::Op::OpImageRead
+                                                                : spv::Op::OpImageFetch;
             append_result_type_and_id_to_spirv_params_for_read();
             spirv_params.emplace_back(gen_arg(Usage::kTexture));
             if (!append_coords_to_spirv_params()) {
@@ -2897,10 +2903,13 @@
                 return false;
             }
             auto level = Operand(0u);
-            if (arg(Usage::kLevel)->Type()->UnwrapRef()->IsAnyOf<type::I32, type::U32>()) {
+            if (arg(Usage::kLevel)
+                    ->Type()
+                    ->UnwrapRef()
+                    ->IsAnyOf<core::type::I32, core::type::U32>()) {
                 // Depth textures have i32 or u32 parameters for the level, but SPIR-V expects f32.
                 // Cast.
-                auto f32_type_id = GenerateTypeIfNeeded(builder_.create<type::F32>());
+                auto f32_type_id = GenerateTypeIfNeeded(builder_.create<core::type::F32>());
                 if (f32_type_id == 0) {
                     return 0;
                 }
@@ -3024,12 +3033,13 @@
                                     const sem::Builtin* builtin,
                                     Operand result_type,
                                     Operand result_id) {
-    auto is_value_signed = [&] { return builtin->Parameters()[1]->Type()->Is<type::I32>(); };
+    auto is_value_signed = [&] { return builtin->Parameters()[1]->Type()->Is<core::type::I32>(); };
 
-    auto address_space = builtin->Parameters()[0]->Type()->As<type::Pointer>()->AddressSpace();
+    auto address_space =
+        builtin->Parameters()[0]->Type()->As<core::type::Pointer>()->AddressSpace();
 
     uint32_t memory_id = 0;
-    switch (builtin->Parameters()[0]->Type()->As<type::Pointer>()->AddressSpace()) {
+    switch (builtin->Parameters()[0]->Type()->As<core::type::Pointer>()->AddressSpace()) {
         case core::AddressSpace::kWorkgroup:
             memory_id = GenerateConstantIfNeeded(
                 ScalarConstant::U32(static_cast<uint32_t>(spv::Scope::Workgroup)));
@@ -3173,7 +3183,7 @@
                 return false;
             }
 
-            auto* bool_sem_ty = builder_.create<type::Bool>();
+            auto* bool_sem_ty = builder_.create<core::type::Bool>();
             auto bool_type = GenerateTypeIfNeeded(bool_sem_ty);
             if (bool_type == 0) {
                 return false;
@@ -3226,16 +3236,16 @@
     }
 }
 
-uint32_t Builder::GenerateSampledImage(const type::Type* texture_type,
+uint32_t Builder::GenerateSampledImage(const core::type::Type* texture_type,
                                        Operand texture_operand,
                                        Operand sampler_operand) {
     // DepthTexture is always declared as SampledTexture.
     // The Vulkan spec says: The "Depth" operand of OpTypeImage is ignored.
     // In SPIRV, 0 means not depth, 1 means depth, and 2 means unknown.
     // Using anything other than 0 is problematic on various Vulkan drivers.
-    if (auto* depthTextureType = texture_type->As<type::DepthTexture>()) {
-        texture_type = builder_.create<type::SampledTexture>(depthTextureType->dim(),
-                                                             builder_.create<type::F32>());
+    if (auto* depthTextureType = texture_type->As<core::type::DepthTexture>()) {
+        texture_type = builder_.create<core::type::SampledTexture>(
+            depthTextureType->dim(), builder_.create<core::type::F32>());
     }
 
     uint32_t sampled_image_type_id =
@@ -3583,7 +3593,7 @@
     return GenerateFunctionVariable(stmt->variable);
 }
 
-uint32_t Builder::GenerateTypeIfNeeded(const type::Type* type) {
+uint32_t Builder::GenerateTypeIfNeeded(const core::type::Type* type) {
     if (type == nullptr) {
         TINT_ICE() << "attempting to generate type from null type";
         return 0;
@@ -3591,7 +3601,7 @@
 
     // Atomics are a type in WGSL, but aren't a distinct type in SPIR-V.
     // Just emit the type inside the atomic.
-    if (auto* atomic = type->As<type::Atomic>()) {
+    if (auto* atomic = type->As<core::type::Atomic>()) {
         return GenerateTypeIfNeeded(atomic->Type());
     }
 
@@ -3599,12 +3609,13 @@
     // The Vulkan spec says: The "Depth" operand of OpTypeImage is ignored.
     // In SPIRV, 0 means not depth, 1 means depth, and 2 means unknown.
     // Using anything other than 0 is problematic on various Vulkan drivers.
-    if (auto* depthTextureType = type->As<type::DepthTexture>()) {
-        type = builder_.create<type::SampledTexture>(depthTextureType->dim(),
-                                                     builder_.create<type::F32>());
-    } else if (auto* multisampledDepthTextureType = type->As<type::DepthMultisampledTexture>()) {
-        type = builder_.create<type::MultisampledTexture>(multisampledDepthTextureType->dim(),
-                                                          builder_.create<type::F32>());
+    if (auto* depthTextureType = type->As<core::type::DepthTexture>()) {
+        type = builder_.create<core::type::SampledTexture>(depthTextureType->dim(),
+                                                           builder_.create<core::type::F32>());
+    } else if (auto* multisampledDepthTextureType =
+                   type->As<core::type::DepthMultisampledTexture>()) {
+        type = builder_.create<core::type::MultisampledTexture>(multisampledDepthTextureType->dim(),
+                                                                builder_.create<core::type::F32>());
     }
 
     // Pointers and references with differing accesses should not result in a
@@ -3614,12 +3625,12 @@
     // definitions in the generated SPIR-V. Note that nested pointers and
     // references are not legal in WGSL, so only considering the top-level type is
     // fine.
-    if (auto* ptr = type->As<type::Pointer>()) {
-        type = builder_.create<type::Pointer>(ptr->AddressSpace(), ptr->StoreType(),
-                                              core::Access::kReadWrite);
-    } else if (auto* ref = type->As<type::Reference>()) {
-        type = builder_.create<type::Pointer>(ref->AddressSpace(), ref->StoreType(),
-                                              core::Access::kReadWrite);
+    if (auto* ptr = type->As<core::type::Pointer>()) {
+        type = builder_.create<core::type::Pointer>(ptr->AddressSpace(), ptr->StoreType(),
+                                                    core::Access::kReadWrite);
+    } else if (auto* ref = type->As<core::type::Reference>()) {
+        type = builder_.create<core::type::Pointer>(ref->AddressSpace(), ref->StoreType(),
+                                                    core::Access::kReadWrite);
     }
 
     return tint::GetOrCreate(type_to_id_, type, [&]() -> uint32_t {
@@ -3627,49 +3638,49 @@
         auto id = std::get<uint32_t>(result);
         bool ok = Switch(
             type,
-            [&](const type::Array* arr) {  //
+            [&](const core::type::Array* arr) {  //
                 return GenerateArrayType(arr, result);
             },
-            [&](const type::Bool*) {
+            [&](const core::type::Bool*) {
                 module_.PushType(spv::Op::OpTypeBool, {result});
                 return true;
             },
-            [&](const type::F32*) {
+            [&](const core::type::F32*) {
                 module_.PushType(spv::Op::OpTypeFloat, {result, Operand(32u)});
                 return true;
             },
-            [&](const type::F16*) {
+            [&](const core::type::F16*) {
                 module_.PushType(spv::Op::OpTypeFloat, {result, Operand(16u)});
                 return true;
             },
-            [&](const type::I32*) {
+            [&](const core::type::I32*) {
                 module_.PushType(spv::Op::OpTypeInt, {result, Operand(32u), Operand(1u)});
                 return true;
             },
-            [&](const type::Matrix* mat) {  //
+            [&](const core::type::Matrix* mat) {  //
                 return GenerateMatrixType(mat, result);
             },
-            [&](const type::Pointer* ptr) {  //
+            [&](const core::type::Pointer* ptr) {  //
                 return GeneratePointerType(ptr, result);
             },
-            [&](const type::Reference* ref) {  //
+            [&](const core::type::Reference* ref) {  //
                 return GenerateReferenceType(ref, result);
             },
-            [&](const type::Struct* str) {  //
+            [&](const core::type::Struct* str) {  //
                 return GenerateStructType(str, result);
             },
-            [&](const type::U32*) {
+            [&](const core::type::U32*) {
                 module_.PushType(spv::Op::OpTypeInt, {result, Operand(32u), Operand(0u)});
                 return true;
             },
-            [&](const type::Vector* vec) {  //
+            [&](const core::type::Vector* vec) {  //
                 return GenerateVectorType(vec, result);
             },
-            [&](const type::Void*) {
+            [&](const core::type::Void*) {
                 module_.PushType(spv::Op::OpTypeVoid, {result});
                 return true;
             },
-            [&](const type::StorageTexture* tex) {
+            [&](const core::type::StorageTexture* tex) {
                 if (!GenerateTextureType(tex, result)) {
                     return false;
                 }
@@ -3677,25 +3688,26 @@
                 // Register all three access types of StorageTexture names. In
                 // SPIR-V, we must output a single type, while the variable is
                 // annotated with the access type. Doing this ensures we de-dupe.
-                type_to_id_[builder_.create<type::StorageTexture>(
+                type_to_id_[builder_.create<core::type::StorageTexture>(
                     tex->dim(), tex->texel_format(), core::Access::kRead, tex->type())] = id;
-                type_to_id_[builder_.create<type::StorageTexture>(
+                type_to_id_[builder_.create<core::type::StorageTexture>(
                     tex->dim(), tex->texel_format(), core::Access::kWrite, tex->type())] = id;
-                type_to_id_[builder_.create<type::StorageTexture>(
+                type_to_id_[builder_.create<core::type::StorageTexture>(
                     tex->dim(), tex->texel_format(), core::Access::kReadWrite, tex->type())] = id;
                 return true;
             },
-            [&](const type::Texture* tex) { return GenerateTextureType(tex, result); },
-            [&](const type::Sampler* s) {
+            [&](const core::type::Texture* tex) { return GenerateTextureType(tex, result); },
+            [&](const core::type::Sampler* s) {
                 module_.PushType(spv::Op::OpTypeSampler, {result});
 
                 // Register both of the sampler type names. In SPIR-V they're the same
                 // sampler type, so we need to match that when we do the dedup check.
-                if (s->kind() == type::SamplerKind::kSampler) {
-                    type_to_id_[builder_.create<type::Sampler>(
-                        type::SamplerKind::kComparisonSampler)] = id;
+                if (s->kind() == core::type::SamplerKind::kSampler) {
+                    type_to_id_[builder_.create<core::type::Sampler>(
+                        core::type::SamplerKind::kComparisonSampler)] = id;
                 } else {
-                    type_to_id_[builder_.create<type::Sampler>(type::SamplerKind::kSampler)] = id;
+                    type_to_id_[builder_.create<core::type::Sampler>(
+                        core::type::SamplerKind::kSampler)] = id;
                 }
                 return true;
             },
@@ -3712,36 +3724,38 @@
     });
 }
 
-bool Builder::GenerateTextureType(const type::Texture* texture, const Operand& result) {
-    if (TINT_UNLIKELY(texture->Is<type::ExternalTexture>())) {
+bool Builder::GenerateTextureType(const core::type::Texture* texture, const Operand& result) {
+    if (TINT_UNLIKELY(texture->Is<core::type::ExternalTexture>())) {
         TINT_ICE() << "Multiplanar external texture transform was not run.";
         return false;
     }
 
     uint32_t array_literal = 0u;
     const auto dim = texture->dim();
-    if (dim == type::TextureDimension::k2dArray || dim == type::TextureDimension::kCubeArray) {
+    if (dim == core::type::TextureDimension::k2dArray ||
+        dim == core::type::TextureDimension::kCubeArray) {
         array_literal = 1u;
     }
 
     uint32_t dim_literal = SpvDim2D;
-    if (dim == type::TextureDimension::k1d) {
+    if (dim == core::type::TextureDimension::k1d) {
         dim_literal = SpvDim1D;
-        if (texture->Is<type::SampledTexture>()) {
+        if (texture->Is<core::type::SampledTexture>()) {
             module_.PushCapability(SpvCapabilitySampled1D);
-        } else if (texture->Is<type::StorageTexture>()) {
+        } else if (texture->Is<core::type::StorageTexture>()) {
             module_.PushCapability(SpvCapabilityImage1D);
         }
     }
-    if (dim == type::TextureDimension::k3d) {
+    if (dim == core::type::TextureDimension::k3d) {
         dim_literal = SpvDim3D;
     }
-    if (dim == type::TextureDimension::kCube || dim == type::TextureDimension::kCubeArray) {
+    if (dim == core::type::TextureDimension::kCube ||
+        dim == core::type::TextureDimension::kCubeArray) {
         dim_literal = SpvDimCube;
     }
 
     uint32_t ms_literal = 0u;
-    if (texture->IsAnyOf<type::MultisampledTexture, type::DepthMultisampledTexture>()) {
+    if (texture->IsAnyOf<core::type::MultisampledTexture, core::type::DepthMultisampledTexture>()) {
         ms_literal = 1u;
     }
 
@@ -3751,35 +3765,35 @@
     // Using anything other than 0 is problematic on various Vulkan drivers.
 
     uint32_t sampled_literal = 2u;
-    if (texture->IsAnyOf<type::MultisampledTexture, type::SampledTexture, type::DepthTexture,
-                         type::DepthMultisampledTexture>()) {
+    if (texture->IsAnyOf<core::type::MultisampledTexture, core::type::SampledTexture,
+                         core::type::DepthTexture, core::type::DepthMultisampledTexture>()) {
         sampled_literal = 1u;
     }
 
-    if (dim == type::TextureDimension::kCubeArray) {
-        if (texture->IsAnyOf<type::SampledTexture, type::DepthTexture>()) {
+    if (dim == core::type::TextureDimension::kCubeArray) {
+        if (texture->IsAnyOf<core::type::SampledTexture, core::type::DepthTexture>()) {
             module_.PushCapability(SpvCapabilitySampledCubeArray);
         }
     }
 
     uint32_t type_id = Switch(
         texture,
-        [&](const type::DepthTexture*) {
-            return GenerateTypeIfNeeded(builder_.create<type::F32>());
+        [&](const core::type::DepthTexture*) {
+            return GenerateTypeIfNeeded(builder_.create<core::type::F32>());
         },
-        [&](const type::DepthMultisampledTexture*) {
-            return GenerateTypeIfNeeded(builder_.create<type::F32>());
+        [&](const core::type::DepthMultisampledTexture*) {
+            return GenerateTypeIfNeeded(builder_.create<core::type::F32>());
         },
-        [&](const type::SampledTexture* t) { return GenerateTypeIfNeeded(t->type()); },
-        [&](const type::MultisampledTexture* t) { return GenerateTypeIfNeeded(t->type()); },
-        [&](const type::StorageTexture* t) { return GenerateTypeIfNeeded(t->type()); },
+        [&](const core::type::SampledTexture* t) { return GenerateTypeIfNeeded(t->type()); },
+        [&](const core::type::MultisampledTexture* t) { return GenerateTypeIfNeeded(t->type()); },
+        [&](const core::type::StorageTexture* t) { return GenerateTypeIfNeeded(t->type()); },
         [&](Default) { return 0u; });
     if (type_id == 0u) {
         return false;
     }
 
     uint32_t format_literal = SpvImageFormat_::SpvImageFormatUnknown;
-    if (auto* t = texture->As<type::StorageTexture>()) {
+    if (auto* t = texture->As<core::type::StorageTexture>()) {
         format_literal = convert_texel_format_to_spv(t->texel_format());
     }
 
@@ -3791,19 +3805,19 @@
     return true;
 }
 
-bool Builder::GenerateArrayType(const type::Array* arr, const Operand& result) {
+bool Builder::GenerateArrayType(const core::type::Array* arr, const Operand& result) {
     auto elem_type = GenerateTypeIfNeeded(arr->ElemType());
     if (elem_type == 0) {
         return false;
     }
 
     auto result_id = std::get<uint32_t>(result);
-    if (arr->Count()->Is<type::RuntimeArrayCount>()) {
+    if (arr->Count()->Is<core::type::RuntimeArrayCount>()) {
         module_.PushType(spv::Op::OpTypeRuntimeArray, {result, Operand(elem_type)});
     } else {
         auto count = arr->ConstantCount();
         if (!count) {
-            TINT_ICE() << type::Array::kErrExpectedConstantCount;
+            TINT_ICE() << core::type::Array::kErrExpectedConstantCount;
             return static_cast<uint32_t>(0);
         }
 
@@ -3821,8 +3835,8 @@
     return true;
 }
 
-bool Builder::GenerateMatrixType(const type::Matrix* mat, const Operand& result) {
-    auto* col_type = builder_.create<type::Vector>(mat->type(), mat->rows());
+bool Builder::GenerateMatrixType(const core::type::Matrix* mat, const Operand& result) {
+    auto* col_type = builder_.create<core::type::Vector>(mat->type(), mat->rows());
     auto col_type_id = GenerateTypeIfNeeded(col_type);
     if (has_error()) {
         return false;
@@ -3833,7 +3847,7 @@
     return true;
 }
 
-bool Builder::GeneratePointerType(const type::Pointer* ptr, const Operand& result) {
+bool Builder::GeneratePointerType(const core::type::Pointer* ptr, const Operand& result) {
     auto subtype_id = GenerateTypeIfNeeded(ptr->StoreType());
     if (subtype_id == 0) {
         return false;
@@ -3850,7 +3864,7 @@
     return true;
 }
 
-bool Builder::GenerateReferenceType(const type::Reference* ref, const Operand& result) {
+bool Builder::GenerateReferenceType(const core::type::Reference* ref, const Operand& result) {
     auto subtype_id = GenerateTypeIfNeeded(ref->StoreType());
     if (subtype_id == 0) {
         return false;
@@ -3867,7 +3881,7 @@
     return true;
 }
 
-bool Builder::GenerateStructType(const type::Struct* struct_type, const Operand& result) {
+bool Builder::GenerateStructType(const core::type::Struct* struct_type, const Operand& result) {
     auto struct_id = std::get<uint32_t>(result);
 
     if (struct_type->Name().IsValid()) {
@@ -3902,7 +3916,7 @@
 
 uint32_t Builder::GenerateStructMember(uint32_t struct_id,
                                        uint32_t idx,
-                                       const type::StructMember* member) {
+                                       const core::type::StructMember* member) {
     module_.PushDebug(spv::Op::OpMemberName,
                       {Operand(struct_id), Operand(idx), Operand(member->Name().Name())});
 
@@ -3931,7 +3945,7 @@
     return GenerateTypeIfNeeded(member->Type());
 }
 
-bool Builder::GenerateVectorType(const type::Vector* vec, const Operand& result) {
+bool Builder::GenerateVectorType(const core::type::Vector* vec, const Operand& result) {
     auto type_id = GenerateTypeIfNeeded(vec->type());
     if (has_error()) {
         return false;
diff --git a/src/tint/lang/spirv/writer/ast_printer/builder.h b/src/tint/lang/spirv/writer/ast_printer/builder.h
index 89bcacd..adca66c 100644
--- a/src/tint/lang/spirv/writer/ast_printer/builder.h
+++ b/src/tint/lang/spirv/writer/ast_printer/builder.h
@@ -50,9 +50,9 @@
 class ValueConstructor;
 class ValueConversion;
 }  // namespace tint::sem
-namespace tint::type {
+namespace tint::core::type {
 class Reference;
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 namespace tint::spirv::writer {
 
@@ -72,7 +72,7 @@
         uint32_t source_id;
         /// The type of the current chain source. This type matches the deduced
         /// result_type of the current source defined above.
-        const type::Type* source_type;
+        const core::type::Type* source_type;
         /// A list of access chain indices to emit. Note, we _only_ have access
         /// chain indices if the source is reference.
         std::vector<uint32_t> access_chain_indices;
@@ -212,7 +212,7 @@
     /// @param type the type to generate for
     /// @param struct_id the struct id
     /// @param member_idx the member index
-    void GenerateMemberAccessIfNeeded(const type::Type* type,
+    void GenerateMemberAccessIfNeeded(const core::type::Type* type,
                                       uint32_t struct_id,
                                       uint32_t member_idx);
     /// Generates a function variable
@@ -328,7 +328,7 @@
     /// @param texture_operand the texture operand
     /// @param sampler_operand the sampler operand
     /// @returns the expression ID
-    uint32_t GenerateSampledImage(const type::Type* texture_type,
+    uint32_t GenerateSampledImage(const core::type::Type* texture_type,
                                   Operand texture_operand,
                                   Operand sampler_operand);
     /// Generates a cast or object copy for the expression result,
@@ -338,7 +338,7 @@
     /// @param from_expr the expression to cast
     /// @param is_global_init if this is a global initializer
     /// @returns the expression ID on success or 0 otherwise
-    uint32_t GenerateCastOrCopyOrPassthrough(const type::Type* to_type,
+    uint32_t GenerateCastOrCopyOrPassthrough(const core::type::Type* to_type,
                                              const ast::Expression* from_expr,
                                              bool is_global_init);
     /// Generates a loop statement
@@ -369,13 +369,13 @@
     /// @param type the reference type of the expression
     /// @param id the SPIR-V id of the expression
     /// @returns the ID of the loaded value or 0 on failure.
-    uint32_t GenerateLoad(const type::Reference* type, uint32_t id);
+    uint32_t GenerateLoad(const core::type::Reference* type, uint32_t id);
     /// Generates an OpLoad on the given ID if it has reference type in WGSL, otherwise return the
     /// ID itself.
     /// @param type the type of the expression
     /// @param id the SPIR-V id of the expression
     /// @returns the ID of the loaded value or `id` if type is not a reference
-    uint32_t GenerateLoadIfNeeded(const type::Type* type, uint32_t id);
+    uint32_t GenerateLoadIfNeeded(const core::type::Type* type, uint32_t id);
     /// Generates an OpStore. Emits an error and returns false if we're
     /// currently outside a function.
     /// @param to the ID to store too
@@ -385,37 +385,37 @@
     /// Generates a type if not already created
     /// @param type the type to create
     /// @returns the ID to use for the given type. Returns 0 on unknown type.
-    uint32_t GenerateTypeIfNeeded(const type::Type* type);
+    uint32_t GenerateTypeIfNeeded(const core::type::Type* type);
     /// Generates a texture type declaration
     /// @param texture the texture to generate
     /// @param result the result operand
     /// @returns true if the texture was successfully generated
-    bool GenerateTextureType(const type::Texture* texture, const Operand& result);
+    bool GenerateTextureType(const core::type::Texture* texture, const Operand& result);
     /// Generates an array type declaration
     /// @param ary the array to generate
     /// @param result the result operand
     /// @returns true if the array was successfully generated
-    bool GenerateArrayType(const type::Array* ary, const Operand& result);
+    bool GenerateArrayType(const core::type::Array* ary, const Operand& result);
     /// Generates a matrix type declaration
     /// @param mat the matrix to generate
     /// @param result the result operand
     /// @returns true if the matrix was successfully generated
-    bool GenerateMatrixType(const type::Matrix* mat, const Operand& result);
+    bool GenerateMatrixType(const core::type::Matrix* mat, const Operand& result);
     /// Generates a pointer type declaration
     /// @param ptr the pointer type to generate
     /// @param result the result operand
     /// @returns true if the pointer was successfully generated
-    bool GeneratePointerType(const type::Pointer* ptr, const Operand& result);
+    bool GeneratePointerType(const core::type::Pointer* ptr, const Operand& result);
     /// Generates a reference type declaration
     /// @param ref the reference type to generate
     /// @param result the result operand
     /// @returns true if the reference was successfully generated
-    bool GenerateReferenceType(const type::Reference* ref, const Operand& result);
+    bool GenerateReferenceType(const core::type::Reference* ref, const Operand& result);
     /// Generates a vector type declaration
     /// @param struct_type the vector to generate
     /// @param result the result operand
     /// @returns true if the vector was successfully generated
-    bool GenerateStructType(const type::Struct* struct_type, const Operand& result);
+    bool GenerateStructType(const core::type::Struct* struct_type, const Operand& result);
     /// Generates a struct member
     /// @param struct_id the id of the parent structure
     /// @param idx the index of the member
@@ -423,7 +423,7 @@
     /// @returns the id of the struct member or 0 on error.
     uint32_t GenerateStructMember(uint32_t struct_id,
                                   uint32_t idx,
-                                  const type::StructMember* member);
+                                  const core::type::StructMember* member);
     /// Generates a variable declaration statement
     /// @param stmt the statement to generate
     /// @returns true on successfull generation
@@ -432,14 +432,14 @@
     /// @param vec the vector to generate
     /// @param result the result operand
     /// @returns true if the vector was successfully generated
-    bool GenerateVectorType(const type::Vector* vec, const Operand& result);
+    bool GenerateVectorType(const core::type::Vector* vec, const Operand& result);
 
     /// Generates instructions to splat `scalar_id` into a vector of type
     /// `vec_type`
     /// @param scalar_id scalar to splat
     /// @param vec_type type of vector
     /// @returns id of the new vector
-    uint32_t GenerateSplat(uint32_t scalar_id, const type::Type* vec_type);
+    uint32_t GenerateSplat(uint32_t scalar_id, const core::type::Type* vec_type);
 
     /// Generates instructions to add or subtract two matrices
     /// @param lhs_id id of multiplicand
@@ -449,7 +449,7 @@
     /// @returns id of the result matrix
     uint32_t GenerateMatrixAddOrSub(uint32_t lhs_id,
                                     uint32_t rhs_id,
-                                    const type::Matrix* type,
+                                    const core::type::Matrix* type,
                                     spv::Op op);
 
     /// Converts TexelFormat to SPIR-V and pushes an appropriate capability.
@@ -469,7 +469,9 @@
 
     /// @returns the resolved type of the ast::Expression `expr`
     /// @param expr the expression
-    const type::Type* TypeOf(const ast::Expression* expr) const { return builder_.TypeOf(expr); }
+    const core::type::Type* TypeOf(const ast::Expression* expr) const {
+        return builder_.TypeOf(expr);
+    }
 
     /// Generates a constant value if needed
     /// @param constant the constant to generate.
@@ -484,13 +486,13 @@
     /// Generates a constant-null of the given type, if needed
     /// @param type the type of the constant null to generate.
     /// @returns the ID on success or 0 on failure
-    uint32_t GenerateConstantNullIfNeeded(const type::Type* type);
+    uint32_t GenerateConstantNullIfNeeded(const core::type::Type* type);
 
     /// Generates a vector constant splat if needed
     /// @param type the type of the vector to generate
     /// @param value_id the ID of the scalar value to splat
     /// @returns the ID on success or 0 on failure
-    uint32_t GenerateConstantVectorSplatIfNeeded(const type::Vector* type, uint32_t value_id);
+    uint32_t GenerateConstantVectorSplatIfNeeded(const core::type::Vector* type, uint32_t value_id);
 
     /// Registers the semantic variable to the given SPIR-V ID
     /// @param var the semantic variable
@@ -526,11 +528,11 @@
     std::unordered_map<std::string, uint32_t> import_name_to_id_;
     std::unordered_map<Symbol, uint32_t> func_symbol_to_id_;
     std::unordered_map<sem::CallTargetSignature, uint32_t> func_sig_to_id_;
-    std::unordered_map<const type::Type*, uint32_t> type_to_id_;
+    std::unordered_map<const core::type::Type*, uint32_t> type_to_id_;
     std::unordered_map<ScalarConstant, uint32_t> const_to_id_;
-    std::unordered_map<const type::Type*, uint32_t> const_null_to_id_;
+    std::unordered_map<const core::type::Type*, uint32_t> const_null_to_id_;
     std::unordered_map<uint64_t, uint32_t> const_splat_to_id_;
-    std::unordered_map<const type::Type*, uint32_t> texture_type_to_sampled_image_type_id_;
+    std::unordered_map<const core::type::Type*, uint32_t> texture_type_to_sampled_image_type_id_;
     std::vector<Scope> scope_stack_;
     std::vector<uint32_t> merge_stack_;
     std::vector<uint32_t> continue_stack_;
diff --git a/src/tint/lang/spirv/writer/ast_printer/global_variable_test.cc b/src/tint/lang/spirv/writer/ast_printer/global_variable_test.cc
index 6a0c808..2364f69 100644
--- a/src/tint/lang/spirv/writer/ast_printer/global_variable_test.cc
+++ b/src/tint/lang/spirv/writer/ast_printer/global_variable_test.cc
@@ -235,7 +235,8 @@
 }
 
 TEST_F(SpirvASTPrinterTest, GlobalVar_WithBindingAndGroup) {
-    auto* v = GlobalVar("var", ty.sampler(type::SamplerKind::kSampler), Binding(2_a), Group(3_a));
+    auto* v =
+        GlobalVar("var", ty.sampler(core::type::SamplerKind::kSampler), Binding(2_a), Group(3_a));
 
     Builder& b = Build();
 
@@ -475,7 +476,7 @@
 TEST_F(SpirvASTPrinterTest, GlobalVar_TextureStorageWriteOnly) {
     // var<uniform_constant> a : texture_storage_2d<r32uint, write>;
 
-    auto type = ty.storage_texture(type::TextureDimension::k2d, core::TexelFormat::kR32Uint,
+    auto type = ty.storage_texture(core::type::TextureDimension::k2d, core::TexelFormat::kR32Uint,
                                    core::Access::kWrite);
 
     auto* var_a = GlobalVar("a", type, Binding(0_a), Group(0_a));
diff --git a/src/tint/lang/spirv/writer/atomic_builtin_test.cc b/src/tint/lang/spirv/writer/atomic_builtin_test.cc
index 99c4047..5818a7e 100644
--- a/src/tint/lang/spirv/writer/atomic_builtin_test.cc
+++ b/src/tint/lang/spirv/writer/atomic_builtin_test.cc
@@ -86,7 +86,7 @@
     func->SetParams({cmp, val});
 
     b.Append(func->Block(), [&] {
-        auto* result_ty = type::CreateAtomicCompareExchangeResult(ty, mod.symbols, ty.i32());
+        auto* result_ty = core::type::CreateAtomicCompareExchangeResult(ty, mod.symbols, ty.i32());
         auto* result = b.Call(result_ty, core::Function::kAtomicCompareExchangeWeak, var, cmp, val);
         auto* original = b.Access(ty.i32(), result, 0_u);
         b.Return(func, original);
diff --git a/src/tint/lang/spirv/writer/builtin_test.cc b/src/tint/lang/spirv/writer/builtin_test.cc
index 169406d..be61e83 100644
--- a/src/tint/lang/spirv/writer/builtin_test.cc
+++ b/src/tint/lang/spirv/writer/builtin_test.cc
@@ -255,7 +255,7 @@
 }
 
 TEST_F(SpirvWriterTest, Builtin_Frexp_F32) {
-    auto* str = type::CreateFrexpResult(ty, mod.symbols, ty.f32());
+    auto* str = core::type::CreateFrexpResult(ty, mod.symbols, ty.f32());
     auto* arg = b.FunctionParam("arg", ty.f32());
     auto* func = b.Function("foo", str);
     func->SetParams({arg});
@@ -270,7 +270,7 @@
 }
 
 TEST_F(SpirvWriterTest, Builtin_Frexp_F16) {
-    auto* str = type::CreateFrexpResult(ty, mod.symbols, ty.f16());
+    auto* str = core::type::CreateFrexpResult(ty, mod.symbols, ty.f16());
     auto* arg = b.FunctionParam("arg", ty.f16());
     auto* func = b.Function("foo", str);
     func->SetParams({arg});
@@ -285,7 +285,7 @@
 }
 
 TEST_F(SpirvWriterTest, Builtin_Frexp_Vec2f) {
-    auto* str = type::CreateFrexpResult(ty, mod.symbols, ty.vec2<f32>());
+    auto* str = core::type::CreateFrexpResult(ty, mod.symbols, ty.vec2<f32>());
     auto* arg = b.FunctionParam("arg", ty.vec2<f32>());
     auto* func = b.Function("foo", str);
     func->SetParams({arg});
@@ -300,7 +300,7 @@
 }
 
 TEST_F(SpirvWriterTest, Builtin_Frexp_Vec3h) {
-    auto* str = type::CreateFrexpResult(ty, mod.symbols, ty.vec3<f16>());
+    auto* str = core::type::CreateFrexpResult(ty, mod.symbols, ty.vec3<f16>());
     auto* arg = b.FunctionParam("arg", ty.vec3<f16>());
     auto* func = b.Function("foo", str);
     func->SetParams({arg});
@@ -329,7 +329,7 @@
 }
 
 TEST_F(SpirvWriterTest, Builtin_Modf_F32) {
-    auto* str = type::CreateModfResult(ty, mod.symbols, ty.f32());
+    auto* str = core::type::CreateModfResult(ty, mod.symbols, ty.f32());
     auto* arg = b.FunctionParam("arg", ty.f32());
     auto* func = b.Function("foo", str);
     func->SetParams({arg});
@@ -344,7 +344,7 @@
 }
 
 TEST_F(SpirvWriterTest, Builtin_Modf_F16) {
-    auto* str = type::CreateModfResult(ty, mod.symbols, ty.f16());
+    auto* str = core::type::CreateModfResult(ty, mod.symbols, ty.f16());
     auto* arg = b.FunctionParam("arg", ty.f16());
     auto* func = b.Function("foo", str);
     func->SetParams({arg});
@@ -359,7 +359,7 @@
 }
 
 TEST_F(SpirvWriterTest, Builtin_Modf_Vec2f) {
-    auto* str = type::CreateModfResult(ty, mod.symbols, ty.vec2<f32>());
+    auto* str = core::type::CreateModfResult(ty, mod.symbols, ty.vec2<f32>());
     auto* arg = b.FunctionParam("arg", ty.vec2<f32>());
     auto* func = b.Function("foo", str);
     func->SetParams({arg});
@@ -374,7 +374,7 @@
 }
 
 TEST_F(SpirvWriterTest, Builtin_Modf_Vec3h) {
-    auto* str = type::CreateModfResult(ty, mod.symbols, ty.vec3<f16>());
+    auto* str = core::type::CreateModfResult(ty, mod.symbols, ty.vec3<f16>());
     auto* arg = b.FunctionParam("arg", ty.vec3<f16>());
     auto* func = b.Function("foo", str);
     func->SetParams({arg});
diff --git a/src/tint/lang/spirv/writer/common/helper_test.h b/src/tint/lang/spirv/writer/common/helper_test.h
index 24d8ca1..cb946dc 100644
--- a/src/tint/lang/spirv/writer/common/helper_test.h
+++ b/src/tint/lang/spirv/writer/common/helper_test.h
@@ -83,7 +83,7 @@
     /// The test builder.
     ir::Builder b{mod};
     /// The type manager.
-    type::Manager& ty{mod.Types()};
+    core::type::Manager& ty{mod.Types()};
 
   protected:
     /// The SPIR-V writer.
@@ -170,7 +170,7 @@
     /// Helper to make a scalar type corresponding to the element type `type`.
     /// @param type the element type
     /// @returns the scalar type
-    const type::Type* MakeScalarType(TestElementType type) {
+    const core::type::Type* MakeScalarType(TestElementType type) {
         switch (type) {
             case kBool:
                 return ty.bool_();
@@ -189,7 +189,9 @@
     /// Helper to make a vector type corresponding to the element type `type`.
     /// @param type the element type
     /// @returns the vector type
-    const type::Type* MakeVectorType(TestElementType type) { return ty.vec2(MakeScalarType(type)); }
+    const core::type::Type* MakeVectorType(TestElementType type) {
+        return ty.vec2(MakeScalarType(type));
+    }
 
     /// Helper to make a scalar value with the scalar type `type`.
     /// @param type the element type
diff --git a/src/tint/lang/spirv/writer/printer/printer.cc b/src/tint/lang/spirv/writer/printer/printer.cc
index 29efe57..da1791c 100644
--- a/src/tint/lang/spirv/writer/printer/printer.cc
+++ b/src/tint/lang/spirv/writer/printer/printer.cc
@@ -112,31 +112,31 @@
     }
 }
 
-const type::Type* DedupType(const type::Type* ty, type::Manager& types) {
+const core::type::Type* DedupType(const core::type::Type* ty, core::type::Manager& types) {
     return Switch(
         ty,
 
         // Atomics are not a distinct type in SPIR-V.
-        [&](const type::Atomic* atomic) { return atomic->Type(); },
+        [&](const core::type::Atomic* atomic) { return atomic->Type(); },
 
         // Depth textures are always declared as sampled textures.
-        [&](const type::DepthTexture* depth) {
-            return types.Get<type::SampledTexture>(depth->dim(), types.f32());
+        [&](const core::type::DepthTexture* depth) {
+            return types.Get<core::type::SampledTexture>(depth->dim(), types.f32());
         },
-        [&](const type::DepthMultisampledTexture* depth) {
-            return types.Get<type::MultisampledTexture>(depth->dim(), types.f32());
+        [&](const core::type::DepthMultisampledTexture* depth) {
+            return types.Get<core::type::MultisampledTexture>(depth->dim(), types.f32());
         },
 
         // Both sampler types are the same in SPIR-V.
-        [&](const type::Sampler* s) -> const type::Type* {
+        [&](const core::type::Sampler* s) -> const core::type::Type* {
             if (s->IsComparison()) {
-                return types.Get<type::Sampler>(type::SamplerKind::kSampler);
+                return types.Get<core::type::Sampler>(core::type::SamplerKind::kSampler);
             }
             return s;
         },
 
         // Dedup a SampledImage if its underlying image will be deduped.
-        [&](const raise::SampledImage* si) -> const type::Type* {
+        [&](const raise::SampledImage* si) -> const core::type::Type* {
             auto* img = DedupType(si->Image(), types);
             if (img != si->Image()) {
                 return types.Get<raise::SampledImage>(img);
@@ -252,41 +252,41 @@
         auto* ty = constant->Type();
         Switch(
             ty,  //
-            [&](const type::Bool*) {
+            [&](const core::type::Bool*) {
                 module_.PushType(
                     constant->ValueAs<bool>() ? spv::Op::OpConstantTrue : spv::Op::OpConstantFalse,
                     {Type(ty), id});
             },
-            [&](const type::I32*) {
+            [&](const core::type::I32*) {
                 module_.PushType(spv::Op::OpConstant, {Type(ty), id, constant->ValueAs<u32>()});
             },
-            [&](const type::U32*) {
+            [&](const core::type::U32*) {
                 module_.PushType(spv::Op::OpConstant,
                                  {Type(ty), id, U32Operand(constant->ValueAs<i32>())});
             },
-            [&](const type::F32*) {
+            [&](const core::type::F32*) {
                 module_.PushType(spv::Op::OpConstant, {Type(ty), id, constant->ValueAs<f32>()});
             },
-            [&](const type::F16*) {
+            [&](const core::type::F16*) {
                 module_.PushType(
                     spv::Op::OpConstant,
                     {Type(ty), id, U32Operand(constant->ValueAs<f16>().BitsRepresentation())});
             },
-            [&](const type::Vector* vec) {
+            [&](const core::type::Vector* vec) {
                 OperandList operands = {Type(ty), id};
                 for (uint32_t i = 0; i < vec->Width(); i++) {
                     operands.push_back(Constant(constant->Index(i)));
                 }
                 module_.PushType(spv::Op::OpConstantComposite, operands);
             },
-            [&](const type::Matrix* mat) {
+            [&](const core::type::Matrix* mat) {
                 OperandList operands = {Type(ty), id};
                 for (uint32_t i = 0; i < mat->columns(); i++) {
                     operands.push_back(Constant(constant->Index(i)));
                 }
                 module_.PushType(spv::Op::OpConstantComposite, operands);
             },
-            [&](const type::Array* arr) {
+            [&](const core::type::Array* arr) {
                 TINT_ASSERT(arr->ConstantCount());
                 OperandList operands = {Type(ty), id};
                 for (uint32_t i = 0; i < arr->ConstantCount(); i++) {
@@ -294,7 +294,7 @@
                 }
                 module_.PushType(spv::Op::OpConstantComposite, operands);
             },
-            [&](const type::Struct* str) {
+            [&](const core::type::Struct* str) {
                 OperandList operands = {Type(ty), id};
                 for (uint32_t i = 0; i < str->Members().Length(); i++) {
                     operands.push_back(Constant(constant->Index(i)));
@@ -306,7 +306,7 @@
     });
 }
 
-uint32_t Printer::ConstantNull(const type::Type* type) {
+uint32_t Printer::ConstantNull(const core::type::Type* type) {
     return constant_nulls_.GetOrCreate(type, [&] {
         auto id = module_.NextId();
         module_.PushType(spv::Op::OpConstantNull, {Type(type), id});
@@ -314,7 +314,7 @@
     });
 }
 
-uint32_t Printer::Undef(const type::Type* type) {
+uint32_t Printer::Undef(const core::type::Type* type) {
     return undef_values_.GetOrCreate(type, [&] {
         auto id = module_.NextId();
         module_.PushType(spv::Op::OpUndef, {Type(type), id});
@@ -322,57 +322,58 @@
     });
 }
 
-uint32_t Printer::Type(const type::Type* ty, core::AddressSpace addrspace /* = kUndefined */) {
+uint32_t Printer::Type(const core::type::Type* ty,
+                       core::AddressSpace addrspace /* = kUndefined */) {
     ty = DedupType(ty, ir_->Types());
     return types_.GetOrCreate(ty, [&] {
         auto id = module_.NextId();
         Switch(
             ty,  //
-            [&](const type::Void*) { module_.PushType(spv::Op::OpTypeVoid, {id}); },
-            [&](const type::Bool*) { module_.PushType(spv::Op::OpTypeBool, {id}); },
-            [&](const type::I32*) {
+            [&](const core::type::Void*) { module_.PushType(spv::Op::OpTypeVoid, {id}); },
+            [&](const core::type::Bool*) { module_.PushType(spv::Op::OpTypeBool, {id}); },
+            [&](const core::type::I32*) {
                 module_.PushType(spv::Op::OpTypeInt, {id, 32u, 1u});
             },
-            [&](const type::U32*) {
+            [&](const core::type::U32*) {
                 module_.PushType(spv::Op::OpTypeInt, {id, 32u, 0u});
             },
-            [&](const type::F32*) {
+            [&](const core::type::F32*) {
                 module_.PushType(spv::Op::OpTypeFloat, {id, 32u});
             },
-            [&](const type::F16*) {
+            [&](const core::type::F16*) {
                 module_.PushCapability(SpvCapabilityFloat16);
                 module_.PushCapability(SpvCapabilityUniformAndStorageBuffer16BitAccess);
                 module_.PushCapability(SpvCapabilityStorageBuffer16BitAccess);
                 module_.PushCapability(SpvCapabilityStorageInputOutput16);
                 module_.PushType(spv::Op::OpTypeFloat, {id, 16u});
             },
-            [&](const type::Vector* vec) {
+            [&](const core::type::Vector* vec) {
                 module_.PushType(spv::Op::OpTypeVector, {id, Type(vec->type()), vec->Width()});
             },
-            [&](const type::Matrix* mat) {
+            [&](const core::type::Matrix* mat) {
                 module_.PushType(spv::Op::OpTypeMatrix,
                                  {id, Type(mat->ColumnType()), mat->columns()});
             },
-            [&](const type::Array* arr) {
+            [&](const core::type::Array* arr) {
                 if (arr->ConstantCount()) {
                     auto* count = b_.ConstantValue(u32(arr->ConstantCount().value()));
                     module_.PushType(spv::Op::OpTypeArray,
                                      {id, Type(arr->ElemType()), Constant(count)});
                 } else {
-                    TINT_ASSERT(arr->Count()->Is<type::RuntimeArrayCount>());
+                    TINT_ASSERT(arr->Count()->Is<core::type::RuntimeArrayCount>());
                     module_.PushType(spv::Op::OpTypeRuntimeArray, {id, Type(arr->ElemType())});
                 }
                 module_.PushAnnot(spv::Op::OpDecorate,
                                   {id, U32Operand(SpvDecorationArrayStride), arr->Stride()});
             },
-            [&](const type::Pointer* ptr) {
+            [&](const core::type::Pointer* ptr) {
                 module_.PushType(spv::Op::OpTypePointer,
                                  {id, U32Operand(StorageClass(ptr->AddressSpace())),
                                   Type(ptr->StoreType(), ptr->AddressSpace())});
             },
-            [&](const type::Struct* str) { EmitStructType(id, str, addrspace); },
-            [&](const type::Texture* tex) { EmitTextureType(id, tex); },
-            [&](const type::Sampler*) { module_.PushType(spv::Op::OpTypeSampler, {id}); },
+            [&](const core::type::Struct* str) { EmitStructType(id, str, addrspace); },
+            [&](const core::type::Texture* tex) { EmitTextureType(id, tex); },
+            [&](const core::type::Sampler*) { module_.PushType(spv::Op::OpTypeSampler, {id}); },
             [&](const raise::SampledImage* s) {
                 module_.PushType(spv::Op::OpTypeSampledImage, {id, Type(s->Image())});
             },
@@ -397,15 +398,15 @@
 }
 
 void Printer::EmitStructType(uint32_t id,
-                             const type::Struct* str,
+                             const core::type::Struct* str,
                              core::AddressSpace addrspace /* = kUndefined */) {
     // Helper to return `type` or a potentially nested array element type within `type` as a matrix
     // type, or nullptr if no such matrix type is present.
-    auto get_nested_matrix_type = [&](const type::Type* type) {
-        while (auto* arr = type->As<type::Array>()) {
+    auto get_nested_matrix_type = [&](const core::type::Type* type) {
+        while (auto* arr = type->As<core::type::Array>()) {
             type = arr->ElemType();
         }
-        return type->As<type::Matrix>();
+        return type->As<core::type::Matrix>();
     };
 
     OperandList operands = {id};
@@ -485,7 +486,7 @@
     module_.PushType(spv::Op::OpTypeStruct, std::move(operands));
 
     // Add a Block decoration if necessary.
-    if (str->StructFlags().Contains(type::StructFlag::kBlock)) {
+    if (str->StructFlags().Contains(core::type::StructFlag::kBlock)) {
         module_.PushAnnot(spv::Op::OpDecorate, {id, U32Operand(SpvDecorationBlock)});
     }
 
@@ -494,49 +495,49 @@
     }
 }
 
-void Printer::EmitTextureType(uint32_t id, const type::Texture* texture) {
+void Printer::EmitTextureType(uint32_t id, const core::type::Texture* texture) {
     uint32_t sampled_type = Switch(
         texture,  //
-        [&](const type::SampledTexture* t) { return Type(t->type()); },
-        [&](const type::MultisampledTexture* t) { return Type(t->type()); },
-        [&](const type::StorageTexture* t) { return Type(t->type()); });
+        [&](const core::type::SampledTexture* t) { return Type(t->type()); },
+        [&](const core::type::MultisampledTexture* t) { return Type(t->type()); },
+        [&](const core::type::StorageTexture* t) { return Type(t->type()); });
 
     uint32_t dim = SpvDimMax;
     uint32_t array = 0u;
     switch (texture->dim()) {
-        case type::TextureDimension::kNone: {
+        case core::type::TextureDimension::kNone: {
             break;
         }
-        case type::TextureDimension::k1d: {
+        case core::type::TextureDimension::k1d: {
             dim = SpvDim1D;
-            if (texture->Is<type::SampledTexture>()) {
+            if (texture->Is<core::type::SampledTexture>()) {
                 module_.PushCapability(SpvCapabilitySampled1D);
-            } else if (texture->Is<type::StorageTexture>()) {
+            } else if (texture->Is<core::type::StorageTexture>()) {
                 module_.PushCapability(SpvCapabilityImage1D);
             }
             break;
         }
-        case type::TextureDimension::k2d: {
+        case core::type::TextureDimension::k2d: {
             dim = SpvDim2D;
             break;
         }
-        case type::TextureDimension::k2dArray: {
+        case core::type::TextureDimension::k2dArray: {
             dim = SpvDim2D;
             array = 1u;
             break;
         }
-        case type::TextureDimension::k3d: {
+        case core::type::TextureDimension::k3d: {
             dim = SpvDim3D;
             break;
         }
-        case type::TextureDimension::kCube: {
+        case core::type::TextureDimension::kCube: {
             dim = SpvDimCube;
             break;
         }
-        case type::TextureDimension::kCubeArray: {
+        case core::type::TextureDimension::kCubeArray: {
             dim = SpvDimCube;
             array = 1u;
-            if (texture->Is<type::SampledTexture>()) {
+            if (texture->Is<core::type::SampledTexture>()) {
                 module_.PushCapability(SpvCapabilitySampledCubeArray);
             }
             break;
@@ -549,17 +550,17 @@
     uint32_t depth = 0u;
 
     uint32_t ms = 0u;
-    if (texture->Is<type::MultisampledTexture>()) {
+    if (texture->Is<core::type::MultisampledTexture>()) {
         ms = 1u;
     }
 
     uint32_t sampled = 2u;
-    if (texture->IsAnyOf<type::MultisampledTexture, type::SampledTexture>()) {
+    if (texture->IsAnyOf<core::type::MultisampledTexture, core::type::SampledTexture>()) {
         sampled = 1u;
     }
 
     uint32_t format = SpvImageFormat_::SpvImageFormatUnknown;
-    if (auto* st = texture->As<type::StorageTexture>()) {
+    if (auto* st = texture->As<core::type::StorageTexture>()) {
         format = TexelFormat(st->texel_format());
     }
 
@@ -658,7 +659,7 @@
                 continue;
             }
 
-            auto* ptr = var->Result()->Type()->As<type::Pointer>();
+            auto* ptr = var->Result()->Type()->As<core::type::Pointer>();
             if (!(ptr->AddressSpace() == core::AddressSpace::kIn ||
                   ptr->AddressSpace() == core::AddressSpace::kOut)) {
                 continue;
@@ -682,7 +683,7 @@
             operands.push_back(Value(var));
 
             // Add the `DepthReplacing` execution mode if `frag_depth` is used.
-            if (auto* str = ptr->StoreType()->As<type::Struct>()) {
+            if (auto* str = ptr->StoreType()->As<core::type::Struct>()) {
                 for (auto* member : str->Members()) {
                     if (member->Attributes().builtin == core::BuiltinValue::kFragDepth) {
                         module_.PushExecutionMode(spv::Op::OpExecutionMode,
@@ -874,7 +875,7 @@
     auto id = Value(access);
     OperandList operands = {Type(ty), id, Value(access->Object())};
 
-    if (ty->Is<type::Pointer>()) {
+    if (ty->Is<core::type::Pointer>()) {
         // Use OpAccessChain for accesses into pointer types.
         for (auto* idx : access->Indices()) {
             operands.push_back(Value(idx));
@@ -895,7 +896,7 @@
         } else {
             // The VarForDynamicIndex transform ensures that only value types that are vectors
             // will be dynamically indexed, as we can use OpVectorExtractDynamic for this case.
-            TINT_ASSERT(source_ty->Is<type::Vector>());
+            TINT_ASSERT(source_ty->Is<core::type::Vector>());
 
             // If this wasn't the first access in the chain then emit the chain so far as an
             // OpCompositeExtract, creating a new result ID for the resulting vector.
@@ -1083,7 +1084,7 @@
         return;
     }
     if ((builtin->Func() == core::Function::kAll || builtin->Func() == core::Function::kAny) &&
-        builtin->Args()[0]->Type()->Is<type::Bool>()) {
+        builtin->Args()[0]->Type()->Is<core::type::Bool>()) {
         // all() and any() are passthroughs for scalar arguments.
         values_.Add(builtin->Result(), Value(builtin->Args()[0]));
         return;
@@ -1474,25 +1475,25 @@
         ir::Constant* zero = nullptr;
         Switch(
             res_ty->DeepestElement(),  //
-            [&](const type::F32*) {
+            [&](const core::type::F32*) {
                 one = b_.Constant(1_f);
                 zero = b_.Constant(0_f);
             },
-            [&](const type::F16*) {
+            [&](const core::type::F16*) {
                 one = b_.Constant(1_h);
                 zero = b_.Constant(0_h);
             },
-            [&](const type::I32*) {
+            [&](const core::type::I32*) {
                 one = b_.Constant(1_i);
                 zero = b_.Constant(0_i);
             },
-            [&](const type::U32*) {
+            [&](const core::type::U32*) {
                 one = b_.Constant(1_u);
                 zero = b_.Constant(0_u);
             });
         TINT_ASSERT_OR_RETURN(one && zero);
 
-        if (auto* vec = res_ty->As<type::Vector>()) {
+        if (auto* vec = res_ty->As<core::type::Vector>()) {
             // Splat the scalars into vectors.
             one = b_.Splat(vec, one, vec->Width());
             zero = b_.Splat(vec, zero, vec->Width());
@@ -1614,7 +1615,7 @@
     }
 
     OperandList operands;
-    if (!call->Result()->Type()->Is<type::Void>()) {
+    if (!call->Result()->Type()->Is<core::type::Void>()) {
         operands = {Type(call->Result()->Type()), id};
     }
     for (auto* arg : call->Args()) {
@@ -1629,7 +1630,7 @@
 }
 
 void Printer::EmitLoadVectorElement(ir::LoadVectorElement* load) {
-    auto* vec_ptr_ty = load->From()->Type()->As<type::Pointer>();
+    auto* vec_ptr_ty = load->From()->Type()->As<core::type::Pointer>();
     auto* el_ty = load->Result()->Type();
     auto* el_ptr_ty = ir_->Types().ptr(vec_ptr_ty->AddressSpace(), el_ty, vec_ptr_ty->Access());
     auto el_ptr_id = module_.NextId();
@@ -1748,7 +1749,7 @@
 }
 
 void Printer::EmitStoreVectorElement(ir::StoreVectorElement* store) {
-    auto* vec_ptr_ty = store->To()->Type()->As<type::Pointer>();
+    auto* vec_ptr_ty = store->To()->Type()->As<core::type::Pointer>();
     auto* el_ty = store->Value()->Type();
     auto* el_ptr_ty = ir_->Types().ptr(vec_ptr_ty->AddressSpace(), el_ty, vec_ptr_ty->Access());
     auto el_ptr_id = module_.NextId();
@@ -1788,7 +1789,7 @@
 
 void Printer::EmitVar(ir::Var* var) {
     auto id = Value(var);
-    auto* ptr = var->Result()->Type()->As<type::Pointer>();
+    auto* ptr = var->Result()->Type()->As<core::type::Pointer>();
     auto ty = Type(ptr);
 
     switch (ptr->AddressSpace()) {
diff --git a/src/tint/lang/spirv/writer/printer/printer.h b/src/tint/lang/spirv/writer/printer/printer.h
index 18c98d9..dceafb0 100644
--- a/src/tint/lang/spirv/writer/printer/printer.h
+++ b/src/tint/lang/spirv/writer/printer/printer.h
@@ -66,11 +66,11 @@
 class Value;
 class Var;
 }  // namespace tint::ir
-namespace tint::type {
+namespace tint::core::type {
 class Struct;
 class Texture;
 class Type;
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 namespace tint::spirv::writer {
 
@@ -98,7 +98,7 @@
     /// @param ty the type to get the ID for
     /// @param addrspace the optional address space that this type is being used for
     /// @returns the result ID of the type
-    uint32_t Type(const type::Type* ty,
+    uint32_t Type(const core::type::Type* ty,
                   core::AddressSpace addrspace = core::AddressSpace::kUndefined);
 
   private:
@@ -122,7 +122,7 @@
     /// Get the result ID of the OpConstantNull instruction for `type`, emitting it if necessary.
     /// @param type the type to get the ID for
     /// @returns the result ID of the OpConstantNull instruction
-    uint32_t ConstantNull(const type::Type* type);
+    uint32_t ConstantNull(const core::type::Type* type);
 
     /// Get the ID of the label for `block`.
     /// @param block the block to get the label ID for
@@ -142,20 +142,20 @@
     /// Get the result ID of the OpUndef instruction with type `ty`, emitting it if necessary.
     /// @param ty the type of the undef value
     /// @returns the result ID of the instruction
-    uint32_t Undef(const type::Type* ty);
+    uint32_t Undef(const core::type::Type* ty);
 
     /// Emit a struct type.
     /// @param id the result ID to use
     /// @param addrspace the optional address space that this type is being used for
     /// @param str the struct type to emit
     void EmitStructType(uint32_t id,
-                        const type::Struct* str,
+                        const core::type::Struct* str,
                         core::AddressSpace addrspace = core::AddressSpace::kUndefined);
 
     /// Emit a texture type.
     /// @param id the result ID to use
     /// @param texture the texture type to emit
-    void EmitTextureType(uint32_t id, const type::Texture* texture);
+    void EmitTextureType(uint32_t id, const core::type::Texture* texture);
 
     /// Emit a function.
     /// @param func the function to emit
@@ -297,7 +297,7 @@
     };
 
     /// The map of types to their result IDs.
-    Hashmap<const type::Type*, uint32_t, 8> types_;
+    Hashmap<const core::type::Type*, uint32_t, 8> types_;
 
     /// The map of function types to their result IDs.
     Hashmap<FunctionType, uint32_t, 8, FunctionType::Hasher> function_types_;
@@ -306,10 +306,10 @@
     Hashmap<const core::constant::Value*, uint32_t, 16> constants_;
 
     /// The map of types to the result IDs of their OpConstantNull instructions.
-    Hashmap<const type::Type*, uint32_t, 4> constant_nulls_;
+    Hashmap<const core::type::Type*, uint32_t, 4> constant_nulls_;
 
     /// The map of types to the result IDs of their OpUndef instructions.
-    Hashmap<const type::Type*, uint32_t, 4> undef_values_;
+    Hashmap<const core::type::Type*, uint32_t, 4> undef_values_;
 
     /// The map of non-constant values to their result IDs.
     Hashmap<ir::Value*, uint32_t, 8> values_;
diff --git a/src/tint/lang/spirv/writer/raise/builtin_polyfill.cc b/src/tint/lang/spirv/writer/raise/builtin_polyfill.cc
index def794c..1173d66 100644
--- a/src/tint/lang/spirv/writer/raise/builtin_polyfill.cc
+++ b/src/tint/lang/spirv/writer/raise/builtin_polyfill.cc
@@ -47,7 +47,7 @@
     ir::Builder b{*ir};
 
     /// The type manager.
-    type::Manager& ty{ir->Types()};
+    core::type::Manager& ty{ir->Types()};
 
     /// Process the module.
     void Process() {
@@ -178,7 +178,7 @@
         auto* access = ptr->Source()->As<ir::Access>();
         TINT_ASSERT_OR_RETURN_VALUE(access, nullptr);
         TINT_ASSERT_OR_RETURN_VALUE(access->Indices().Length() == 1u, nullptr);
-        TINT_ASSERT_OR_RETURN_VALUE(access->Object()->Type()->UnwrapPtr()->Is<type::Struct>(),
+        TINT_ASSERT_OR_RETURN_VALUE(access->Object()->Type()->UnwrapPtr()->Is<core::type::Struct>(),
                                     nullptr);
         auto* const_idx = access->Indices()[0]->As<ir::Constant>();
 
@@ -198,7 +198,7 @@
 
         auto* pointer = builtin->Args()[0];
         auto* memory = [&]() -> ir::Value* {
-            switch (pointer->Type()->As<type::Pointer>()->AddressSpace()) {
+            switch (pointer->Type()->As<core::type::Pointer>()->AddressSpace()) {
                 case core::AddressSpace::kWorkgroup:
                     return b.Constant(u32(SpvScopeWorkgroup));
                 case core::AddressSpace::kStorage:
@@ -211,7 +211,7 @@
         auto* memory_semantics = b.Constant(u32(SpvMemorySemanticsMaskNone));
 
         // Helper to build the intrinsic call with the common operands.
-        auto build = [&](const type::Type* type, enum ir::IntrinsicCall::Kind intrinsic) {
+        auto build = [&](const core::type::Type* type, enum ir::IntrinsicCall::Kind intrinsic) {
             return b.Call(type, intrinsic, pointer, memory, memory_semantics);
         };
 
@@ -242,8 +242,9 @@
                 compare->InsertBefore(builtin);
 
                 // Construct the atomicCompareExchange result structure.
-                call = b.Construct(type::CreateAtomicCompareExchangeResult(ty, ir->symbols, int_ty),
-                                   Vector{original, compare->Result()});
+                call = b.Construct(
+                    core::type::CreateAtomicCompareExchangeResult(ty, ir->symbols, int_ty),
+                    Vector{original, compare->Result()});
                 break;
             }
             case core::Function::kAtomicExchange:
@@ -304,7 +305,7 @@
 
             auto* v1 = builtin->Args()[0];
             auto* v2 = builtin->Args()[1];
-            auto* vec = v1->Type()->As<type::Vector>();
+            auto* vec = v1->Type()->As<core::type::Vector>();
             auto* elty = vec->type();
             for (uint32_t i = 0; i < vec->Width(); i++) {
                 b.InsertBefore(builtin, [&] {
@@ -343,8 +344,8 @@
         // If the condition is scalar and the objects are vectors, we need to splat the condition
         // into a vector of the same size.
         // TODO(jrprice): We don't need to do this if we're targeting SPIR-V 1.4 or newer.
-        auto* vec = builtin->Result()->Type()->As<type::Vector>();
-        if (vec && args[0]->Type()->Is<type::Scalar>()) {
+        auto* vec = builtin->Result()->Type()->As<core::type::Vector>();
+        if (vec && args[0]->Type()->Is<core::type::Scalar>()) {
             Vector<ir::Value*, 4> elements;
             elements.Resize(vec->Width(), args[0]);
 
@@ -431,7 +432,7 @@
     ir::Value* AppendArrayIndex(ir::Value* coords,
                                 ir::Value* array_idx,
                                 ir::Instruction* insertion_point) {
-        auto* vec = coords->Type()->As<type::Vector>();
+        auto* vec = coords->Type()->As<core::type::Vector>();
         auto* element_ty = vec->type();
 
         // Convert the index to match the coordinate type if needed.
@@ -462,7 +463,7 @@
         auto* texture = next_arg();
         auto* sampler = next_arg();
         auto* coords = next_arg();
-        auto* texture_ty = texture->Type()->As<type::Texture>();
+        auto* texture_ty = texture->Type()->As<core::type::Texture>();
 
         // Use OpSampledImage to create an OpTypeSampledImage object.
         auto* sampled_image =
@@ -531,7 +532,7 @@
 
         // Call the intrinsic.
         // If this is a depth comparison, the result is always f32, otherwise vec4f.
-        auto* result_ty = depth ? static_cast<const type::Type*>(ty.f32()) : ty.vec4<f32>();
+        auto* result_ty = depth ? static_cast<const core::type::Type*>(ty.f32()) : ty.vec4<f32>();
         auto* texture_call = b.Call(result_ty, intrinsic, std::move(intrinsic_args));
         texture_call->InsertBefore(builtin);
 
@@ -539,7 +540,8 @@
 
         // If this is not a depth comparison but we are sampling a depth texture, extract the first
         // component to get the scalar f32 that SPIR-V expects.
-        if (!depth && texture_ty->IsAnyOf<type::DepthTexture, type::DepthMultisampledTexture>()) {
+        if (!depth &&
+            texture_ty->IsAnyOf<core::type::DepthTexture, core::type::DepthMultisampledTexture>()) {
             auto* extract = b.Access(ty.f32(), result, 0_u);
             extract->InsertBefore(builtin);
             result = extract->Result();
@@ -568,7 +570,7 @@
         auto* texture = next_arg();
         auto* sampler = next_arg();
         auto* coords = next_arg();
-        auto* texture_ty = texture->Type()->As<type::Texture>();
+        auto* texture_ty = texture->Type()->As<core::type::Texture>();
 
         // Use OpSampledImage to create an OpTypeSampledImage object.
         auto* sampled_image =
@@ -634,7 +636,7 @@
 
         auto* texture = next_arg();
         auto* coords = next_arg();
-        auto* texture_ty = texture->Type()->As<type::Texture>();
+        auto* texture_ty = texture->Type()->As<core::type::Texture>();
 
         // Append the array index to the coordinates if provided.
         auto* array_idx = IsTextureArray(texture_ty->dim()) ? next_arg() : nullptr;
@@ -650,7 +652,8 @@
 
         // Add the optional image operands, if any.
         ImageOperands operands;
-        if (texture_ty->IsAnyOf<type::MultisampledTexture, type::DepthMultisampledTexture>()) {
+        if (texture_ty->IsAnyOf<core::type::MultisampledTexture,
+                                core::type::DepthMultisampledTexture>()) {
             operands.sample = next_arg();
         } else {
             operands.lod = next_arg();
@@ -660,7 +663,7 @@
         // Call the intrinsic.
         // The result is always a vec4 in SPIR-V.
         auto* result_ty = builtin->Result()->Type();
-        bool expects_scalar_result = result_ty->Is<type::Scalar>();
+        bool expects_scalar_result = result_ty->Is<core::type::Scalar>();
         if (expects_scalar_result) {
             result_ty = ty.vec4(result_ty);
         }
@@ -691,7 +694,7 @@
 
         auto* texture = next_arg();
         auto* coords = next_arg();
-        auto* texture_ty = texture->Type()->As<type::Texture>();
+        auto* texture_ty = texture->Type()->As<core::type::Texture>();
 
         // Append the array index to the coordinates if provided.
         auto* array_idx = IsTextureArray(texture_ty->dim()) ? next_arg() : nullptr;
@@ -729,15 +732,16 @@
         };
 
         auto* texture = next_arg();
-        auto* texture_ty = texture->Type()->As<type::Texture>();
+        auto* texture_ty = texture->Type()->As<core::type::Texture>();
 
         Vector<ir::Value*, 8> intrinsic_args;
         intrinsic_args.Push(texture);
 
         // Determine which SPIR-V intrinsic to use, and add the Lod argument if needed.
         enum ir::IntrinsicCall::Kind intrinsic;
-        if (texture_ty->IsAnyOf<type::MultisampledTexture, type::DepthMultisampledTexture,
-                                type::StorageTexture>()) {
+        if (texture_ty
+                ->IsAnyOf<core::type::MultisampledTexture, core::type::DepthMultisampledTexture,
+                          core::type::StorageTexture>()) {
             intrinsic = ir::IntrinsicCall::Kind::kSpirvImageQuerySize;
         } else {
             intrinsic = ir::IntrinsicCall::Kind::kSpirvImageQuerySizeLod;
@@ -751,8 +755,8 @@
 
         // Add an extra component to the result vector for arrayed textures.
         auto* result_ty = builtin->Result()->Type();
-        if (type::IsTextureArray(texture_ty->dim())) {
-            auto* vec = result_ty->As<type::Vector>();
+        if (core::type::IsTextureArray(texture_ty->dim())) {
+            auto* vec = result_ty->As<core::type::Vector>();
             result_ty = ty.vec(vec->type(), vec->Width() + 1);
         }
 
@@ -763,7 +767,7 @@
         auto* result = texture_call->Result();
 
         // Swizzle the first two components from the result for arrayed textures.
-        if (type::IsTextureArray(texture_ty->dim())) {
+        if (core::type::IsTextureArray(texture_ty->dim())) {
             auto* swizzle = b.Swizzle(builtin->Result()->Type(), result, {0, 1});
             swizzle->InsertBefore(builtin);
             result = swizzle->Result();
@@ -777,15 +781,16 @@
     /// @returns the replacement value
     ir::Value* TextureNumLayers(ir::CoreBuiltinCall* builtin) {
         auto* texture = builtin->Args()[0];
-        auto* texture_ty = texture->Type()->As<type::Texture>();
+        auto* texture_ty = texture->Type()->As<core::type::Texture>();
 
         Vector<ir::Value*, 2> intrinsic_args;
         intrinsic_args.Push(texture);
 
         // Determine which SPIR-V intrinsic to use, and add the Lod argument if needed.
         enum ir::IntrinsicCall::Kind intrinsic;
-        if (texture_ty->IsAnyOf<type::MultisampledTexture, type::DepthMultisampledTexture,
-                                type::StorageTexture>()) {
+        if (texture_ty
+                ->IsAnyOf<core::type::MultisampledTexture, core::type::DepthMultisampledTexture,
+                          core::type::StorageTexture>()) {
             intrinsic = ir::IntrinsicCall::Kind::kSpirvImageQuerySize;
         } else {
             intrinsic = ir::IntrinsicCall::Kind::kSpirvImageQuerySizeLod;
@@ -820,12 +825,12 @@
 
 LiteralOperand::~LiteralOperand() = default;
 
-SampledImage::SampledImage(const type::Type* image)
+SampledImage::SampledImage(const core::type::Type* image)
     : Base(static_cast<size_t>(Hash(tint::TypeInfo::Of<SampledImage>().full_hashcode, image)),
-           type::Flags{}),
+           core::type::Flags{}),
       image_(image) {}
 
-SampledImage* SampledImage::Clone(type::CloneContext& ctx) const {
+SampledImage* SampledImage::Clone(core::type::CloneContext& ctx) const {
     auto* image = image_->Clone(ctx);
     return ctx.dst.mgr->Get<SampledImage>(image);
 }
diff --git a/src/tint/lang/spirv/writer/raise/builtin_polyfill.h b/src/tint/lang/spirv/writer/raise/builtin_polyfill.h
index 936174f..343caf6 100644
--- a/src/tint/lang/spirv/writer/raise/builtin_polyfill.h
+++ b/src/tint/lang/spirv/writer/raise/builtin_polyfill.h
@@ -49,11 +49,11 @@
 
 /// SampledImage represents an OpTypeSampledImage in SPIR-V.
 /// TODO(jrprice): Move this to lang/spirv.
-class SampledImage final : public Castable<SampledImage, type::Type> {
+class SampledImage final : public Castable<SampledImage, core::type::Type> {
   public:
     /// Constructor
     /// @param image the image type
-    explicit SampledImage(const type::Type* image);
+    explicit SampledImage(const core::type::Type* image);
 
     /// @param other the other node to compare against
     /// @returns true if the this type is equal to @p other
@@ -64,13 +64,13 @@
 
     /// @param ctx the clone context
     /// @returns a clone of this type
-    SampledImage* Clone(type::CloneContext& ctx) const override;
+    SampledImage* Clone(core::type::CloneContext& ctx) const override;
 
     /// @returns the image type
-    const type::Type* Image() const { return image_; }
+    const core::type::Type* Image() const { return image_; }
 
   private:
-    const type::Type* image_;
+    const core::type::Type* image_;
 };
 
 }  // namespace tint::spirv::writer::raise
diff --git a/src/tint/lang/spirv/writer/raise/builtin_polyfill_test.cc b/src/tint/lang/spirv/writer/raise/builtin_polyfill_test.cc
index 0b179a9..5f827d7 100644
--- a/src/tint/lang/spirv/writer/raise/builtin_polyfill_test.cc
+++ b/src/tint/lang/spirv/writer/raise/builtin_polyfill_test.cc
@@ -380,7 +380,7 @@
     func->SetParams({cmp, val});
 
     b.Append(func->Block(), [&] {
-        auto* result_ty = type::CreateAtomicCompareExchangeResult(ty, mod.symbols, ty.i32());
+        auto* result_ty = core::type::CreateAtomicCompareExchangeResult(ty, mod.symbols, ty.i32());
         auto* result = b.Call(result_ty, core::Function::kAtomicCompareExchangeWeak, var, cmp, val);
         b.Return(func, b.Access(ty.i32(), result, 0_u));
     });
@@ -1104,8 +1104,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureLoad_2D) {
-    auto* t =
-        b.FunctionParam("t", ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32()));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32()));
     auto* coords = b.FunctionParam("coords", ty.vec2<i32>());
     auto* lod = b.FunctionParam("lod", ty.i32());
     auto* func = b.Function("foo", ty.vec4<f32>());
@@ -1142,7 +1142,7 @@
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureLoad_2DArray) {
     auto* t = b.FunctionParam(
-        "t", ty.Get<type::SampledTexture>(type::TextureDimension::k2dArray, ty.f32()));
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2dArray, ty.f32()));
     auto* coords = b.FunctionParam("coords", ty.vec2<i32>());
     auto* array_idx = b.FunctionParam("array_idx", ty.i32());
     auto* lod = b.FunctionParam("lod", ty.i32());
@@ -1182,7 +1182,7 @@
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureLoad_2DArray_IndexDifferentType) {
     auto* t = b.FunctionParam(
-        "t", ty.Get<type::SampledTexture>(type::TextureDimension::k2dArray, ty.f32()));
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2dArray, ty.f32()));
     auto* coords = b.FunctionParam("coords", ty.vec2<i32>());
     auto* array_idx = b.FunctionParam("array_idx", ty.u32());
     auto* lod = b.FunctionParam("lod", ty.i32());
@@ -1223,7 +1223,7 @@
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureLoad_Multisampled2D) {
     auto* t = b.FunctionParam(
-        "t", ty.Get<type::MultisampledTexture>(type::TextureDimension::k2d, ty.f32()));
+        "t", ty.Get<core::type::MultisampledTexture>(core::type::TextureDimension::k2d, ty.f32()));
     auto* coords = b.FunctionParam("coords", ty.vec2<i32>());
     auto* sample_idx = b.FunctionParam("sample_idx", ty.i32());
     auto* func = b.Function("foo", ty.vec4<f32>());
@@ -1259,7 +1259,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureLoad_Depth2D) {
-    auto* t = b.FunctionParam("t", ty.Get<type::DepthTexture>(type::TextureDimension::k2d));
+    auto* t =
+        b.FunctionParam("t", ty.Get<core::type::DepthTexture>(core::type::TextureDimension::k2d));
     auto* coords = b.FunctionParam("coords", ty.vec2<i32>());
     auto* lod = b.FunctionParam("lod", ty.i32());
     auto* func = b.Function("foo", ty.f32());
@@ -1296,8 +1297,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSample_1D) {
-    auto* t =
-        b.FunctionParam("t", ty.Get<type::SampledTexture>(type::TextureDimension::k1d, ty.f32()));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k1d, ty.f32()));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.f32());
     auto* func = b.Function("foo", ty.vec4<f32>());
@@ -1334,8 +1335,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSample_2D) {
-    auto* t =
-        b.FunctionParam("t", ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32()));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32()));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* func = b.Function("foo", ty.vec4<f32>());
@@ -1372,8 +1373,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSample_2D_Offset) {
-    auto* t =
-        b.FunctionParam("t", ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32()));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32()));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* func = b.Function("foo", ty.vec4<f32>());
@@ -1412,7 +1413,7 @@
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSample_2DArray_Offset) {
     auto* t = b.FunctionParam(
-        "t", ty.Get<type::SampledTexture>(type::TextureDimension::k2dArray, ty.f32()));
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2dArray, ty.f32()));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* array_idx = b.FunctionParam("array_idx", ty.i32());
@@ -1453,8 +1454,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSampleBias_2D) {
-    auto* t =
-        b.FunctionParam("t", ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32()));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32()));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* bias = b.FunctionParam("bias", ty.f32());
@@ -1493,8 +1494,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSampleBias_2D_Offset) {
-    auto* t =
-        b.FunctionParam("t", ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32()));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32()));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* bias = b.FunctionParam("bias", ty.f32());
@@ -1534,7 +1535,7 @@
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSampleBias_2DArray_Offset) {
     auto* t = b.FunctionParam(
-        "t", ty.Get<type::SampledTexture>(type::TextureDimension::k2dArray, ty.f32()));
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2dArray, ty.f32()));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* array_idx = b.FunctionParam("array_idx", ty.i32());
@@ -1576,7 +1577,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSampleCompare_2D) {
-    auto* t = b.FunctionParam("t", ty.Get<type::DepthTexture>(type::TextureDimension::k2d));
+    auto* t =
+        b.FunctionParam("t", ty.Get<core::type::DepthTexture>(core::type::TextureDimension::k2d));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* dref = b.FunctionParam("dref", ty.f32());
@@ -1614,7 +1616,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSampleCompare_2D_Offset) {
-    auto* t = b.FunctionParam("t", ty.Get<type::DepthTexture>(type::TextureDimension::k2d));
+    auto* t =
+        b.FunctionParam("t", ty.Get<core::type::DepthTexture>(core::type::TextureDimension::k2d));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* dref = b.FunctionParam("dref", ty.f32());
@@ -1653,7 +1656,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSampleCompare_2DArray_Offset) {
-    auto* t = b.FunctionParam("t", ty.Get<type::DepthTexture>(type::TextureDimension::k2dArray));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::DepthTexture>(core::type::TextureDimension::k2dArray));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* array_idx = b.FunctionParam("array_idx", ty.i32());
@@ -1695,7 +1699,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSampleCompareLevel_2D) {
-    auto* t = b.FunctionParam("t", ty.Get<type::DepthTexture>(type::TextureDimension::k2d));
+    auto* t =
+        b.FunctionParam("t", ty.Get<core::type::DepthTexture>(core::type::TextureDimension::k2d));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* dref = b.FunctionParam("dref", ty.f32());
@@ -1734,7 +1739,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSampleCompareLevel_2D_Offset) {
-    auto* t = b.FunctionParam("t", ty.Get<type::DepthTexture>(type::TextureDimension::k2d));
+    auto* t =
+        b.FunctionParam("t", ty.Get<core::type::DepthTexture>(core::type::TextureDimension::k2d));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* dref = b.FunctionParam("dref", ty.f32());
@@ -1773,7 +1779,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSampleCompareLevel_2DArray_Offset) {
-    auto* t = b.FunctionParam("t", ty.Get<type::DepthTexture>(type::TextureDimension::k2dArray));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::DepthTexture>(core::type::TextureDimension::k2dArray));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* array_idx = b.FunctionParam("array_idx", ty.i32());
@@ -1815,8 +1822,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSampleGrad_2D) {
-    auto* t =
-        b.FunctionParam("t", ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32()));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32()));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* ddx = b.FunctionParam("ddx", ty.vec2<f32>());
@@ -1856,8 +1863,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSampleGrad_2D_Offset) {
-    auto* t =
-        b.FunctionParam("t", ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32()));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32()));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* ddx = b.FunctionParam("ddx", ty.vec2<f32>());
@@ -1898,7 +1905,7 @@
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSampleGrad_2DArray_Offset) {
     auto* t = b.FunctionParam(
-        "t", ty.Get<type::SampledTexture>(type::TextureDimension::k2dArray, ty.f32()));
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2dArray, ty.f32()));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* array_idx = b.FunctionParam("array_idx", ty.i32());
@@ -1941,8 +1948,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSampleLevel_2D) {
-    auto* t =
-        b.FunctionParam("t", ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32()));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32()));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* lod = b.FunctionParam("lod", ty.f32());
@@ -1981,8 +1988,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSampleLevel_2D_Offset) {
-    auto* t =
-        b.FunctionParam("t", ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32()));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32()));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* lod = b.FunctionParam("lod", ty.f32());
@@ -2022,7 +2029,7 @@
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureSampleLevel_2DArray_Offset) {
     auto* t = b.FunctionParam(
-        "t", ty.Get<type::SampledTexture>(type::TextureDimension::k2dArray, ty.f32()));
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2dArray, ty.f32()));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* array_idx = b.FunctionParam("array_idx", ty.i32());
@@ -2064,8 +2071,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureGather_2D) {
-    auto* t =
-        b.FunctionParam("t", ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32()));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32()));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* component = b.FunctionParam("component", ty.i32());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
@@ -2104,8 +2111,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureGather_2D_Offset) {
-    auto* t =
-        b.FunctionParam("t", ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32()));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32()));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* component = b.FunctionParam("component", ty.i32());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
@@ -2145,7 +2152,7 @@
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureGather_2DArray_Offset) {
     auto* t = b.FunctionParam(
-        "t", ty.Get<type::SampledTexture>(type::TextureDimension::k2dArray, ty.f32()));
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2dArray, ty.f32()));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* component = b.FunctionParam("component", ty.i32());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
@@ -2187,7 +2194,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureGather_Depth2D) {
-    auto* t = b.FunctionParam("t", ty.Get<type::DepthTexture>(type::TextureDimension::k2d));
+    auto* t =
+        b.FunctionParam("t", ty.Get<core::type::DepthTexture>(core::type::TextureDimension::k2d));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* func = b.Function("foo", ty.vec4<f32>());
@@ -2224,7 +2232,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureGatherCompare_Depth2D) {
-    auto* t = b.FunctionParam("t", ty.Get<type::DepthTexture>(type::TextureDimension::k2d));
+    auto* t =
+        b.FunctionParam("t", ty.Get<core::type::DepthTexture>(core::type::TextureDimension::k2d));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* depth = b.FunctionParam("depth", ty.f32());
@@ -2263,7 +2272,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureGatherCompare_Depth2D_Offset) {
-    auto* t = b.FunctionParam("t", ty.Get<type::DepthTexture>(type::TextureDimension::k2d));
+    auto* t =
+        b.FunctionParam("t", ty.Get<core::type::DepthTexture>(core::type::TextureDimension::k2d));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* depth = b.FunctionParam("depth", ty.f32());
@@ -2302,7 +2312,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureGatherCompare_Depth2DArray) {
-    auto* t = b.FunctionParam("t", ty.Get<type::DepthTexture>(type::TextureDimension::k2dArray));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::DepthTexture>(core::type::TextureDimension::k2dArray));
     auto* s = b.FunctionParam("s", ty.sampler());
     auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
     auto* array_idx = b.FunctionParam("array_idx", ty.u32());
@@ -2345,9 +2356,10 @@
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureStore_2D) {
     auto format = core::TexelFormat::kR32Float;
-    auto* t = b.FunctionParam(
-        "t", ty.Get<type::StorageTexture>(type::TextureDimension::k2d, format, core::Access::kWrite,
-                                          type::StorageTexture::SubtypeFor(format, ty)));
+    auto* t =
+        b.FunctionParam("t", ty.Get<core::type::StorageTexture>(
+                                 core::type::TextureDimension::k2d, format, core::Access::kWrite,
+                                 core::type::StorageTexture::SubtypeFor(format, ty)));
     auto* coords = b.FunctionParam("coords", ty.vec2<i32>());
     auto* texel = b.FunctionParam("texel", ty.i32());
     auto* func = b.Function("foo", ty.void_());
@@ -2385,9 +2397,9 @@
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureStore_2DArray) {
     auto format = core::TexelFormat::kR32Float;
     auto* t = b.FunctionParam(
-        "t",
-        ty.Get<type::StorageTexture>(type::TextureDimension::k2dArray, format, core::Access::kWrite,
-                                     type::StorageTexture::SubtypeFor(format, ty)));
+        "t", ty.Get<core::type::StorageTexture>(
+                 core::type::TextureDimension::k2dArray, format, core::Access::kWrite,
+                 core::type::StorageTexture::SubtypeFor(format, ty)));
     auto* coords = b.FunctionParam("coords", ty.vec2<i32>());
     auto* array_idx = b.FunctionParam("array_idx", ty.i32());
     auto* texel = b.FunctionParam("texel", ty.i32());
@@ -2427,9 +2439,9 @@
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureStore_2DArray_IndexDifferentType) {
     auto format = core::TexelFormat::kR32Float;
     auto* t = b.FunctionParam(
-        "t",
-        ty.Get<type::StorageTexture>(type::TextureDimension::k2dArray, format, core::Access::kWrite,
-                                     type::StorageTexture::SubtypeFor(format, ty)));
+        "t", ty.Get<core::type::StorageTexture>(
+                 core::type::TextureDimension::k2dArray, format, core::Access::kWrite,
+                 core::type::StorageTexture::SubtypeFor(format, ty)));
     auto* coords = b.FunctionParam("coords", ty.vec2<i32>());
     auto* array_idx = b.FunctionParam("array_idx", ty.u32());
     auto* texel = b.FunctionParam("texel", ty.i32());
@@ -2468,8 +2480,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureDimensions_2D_ImplicitLod) {
-    auto* t =
-        b.FunctionParam("t", ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32()));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32()));
     auto* func = b.Function("foo", ty.vec2<u32>());
     func->SetParams({t});
 
@@ -2503,8 +2515,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureDimensions_2D_ExplicitLod) {
-    auto* t =
-        b.FunctionParam("t", ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32()));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32()));
     auto* lod = b.FunctionParam("lod", ty.i32());
     auto* func = b.Function("foo", ty.vec2<u32>());
     func->SetParams({t, lod});
@@ -2540,7 +2552,7 @@
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureDimensions_2DArray) {
     auto* t = b.FunctionParam(
-        "t", ty.Get<type::SampledTexture>(type::TextureDimension::k2dArray, ty.f32()));
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2dArray, ty.f32()));
     auto* func = b.Function("foo", ty.vec2<u32>());
     func->SetParams({t});
 
@@ -2576,7 +2588,7 @@
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureDimensions_Multisampled) {
     auto* t = b.FunctionParam(
-        "t", ty.Get<type::MultisampledTexture>(type::TextureDimension::k2d, ty.f32()));
+        "t", ty.Get<core::type::MultisampledTexture>(core::type::TextureDimension::k2d, ty.f32()));
     auto* func = b.Function("foo", ty.vec2<u32>());
     func->SetParams({t});
 
@@ -2611,7 +2623,7 @@
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureNumLayers_2DArray) {
     auto* t = b.FunctionParam(
-        "t", ty.Get<type::SampledTexture>(type::TextureDimension::k2dArray, ty.f32()));
+        "t", ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2dArray, ty.f32()));
     auto* func = b.Function("foo", ty.u32());
     func->SetParams({t});
 
@@ -2646,8 +2658,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureNumLayers_CubeArray) {
-    auto* t = b.FunctionParam(
-        "t", ty.Get<type::SampledTexture>(type::TextureDimension::kCubeArray, ty.f32()));
+    auto* t = b.FunctionParam("t", ty.Get<core::type::SampledTexture>(
+                                       core::type::TextureDimension::kCubeArray, ty.f32()));
     auto* func = b.Function("foo", ty.u32());
     func->SetParams({t});
 
@@ -2682,7 +2694,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureNumLayers_Depth2DArray) {
-    auto* t = b.FunctionParam("t", ty.Get<type::DepthTexture>(type::TextureDimension::k2dArray));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::DepthTexture>(core::type::TextureDimension::k2dArray));
     auto* func = b.Function("foo", ty.u32());
     func->SetParams({t});
 
@@ -2717,7 +2730,8 @@
 }
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureNumLayers_DepthCubeArray) {
-    auto* t = b.FunctionParam("t", ty.Get<type::DepthTexture>(type::TextureDimension::kCubeArray));
+    auto* t = b.FunctionParam(
+        "t", ty.Get<core::type::DepthTexture>(core::type::TextureDimension::kCubeArray));
     auto* func = b.Function("foo", ty.u32());
     func->SetParams({t});
 
@@ -2753,9 +2767,10 @@
 
 TEST_F(SpirvWriter_BuiltinPolyfillTest, TextureNumLayers_Storage2DArray) {
     auto format = core::TexelFormat::kR32Float;
-    auto* t = b.FunctionParam(
-        "t", ty.Get<type::StorageTexture>(type::TextureDimension::k2d, format, core::Access::kWrite,
-                                          type::StorageTexture::SubtypeFor(format, ty)));
+    auto* t =
+        b.FunctionParam("t", ty.Get<core::type::StorageTexture>(
+                                 core::type::TextureDimension::k2d, format, core::Access::kWrite,
+                                 core::type::StorageTexture::SubtypeFor(format, ty)));
     auto* func = b.Function("foo", ty.u32());
     func->SetParams({t});
 
diff --git a/src/tint/lang/spirv/writer/raise/expand_implicit_splats.cc b/src/tint/lang/spirv/writer/raise/expand_implicit_splats.cc
index c392ec5..591d240 100644
--- a/src/tint/lang/spirv/writer/raise/expand_implicit_splats.cc
+++ b/src/tint/lang/spirv/writer/raise/expand_implicit_splats.cc
@@ -40,10 +40,10 @@
         if (auto* construct = inst->As<ir::Construct>()) {
             // A vector constructor with a single scalar argument needs to be modified to replicate
             // the argument N times.
-            auto* vec = construct->Result()->Type()->As<type::Vector>();
+            auto* vec = construct->Result()->Type()->As<core::type::Vector>();
             if (vec &&  //
                 construct->Args().Length() == 1 &&
-                construct->Args()[0]->Type()->Is<type::Scalar>()) {
+                construct->Args()[0]->Type()->Is<core::type::Scalar>()) {
                 for (uint32_t i = 1; i < vec->Width(); i++) {
                     construct->AppendArg(construct->Args()[0]);
                 }
@@ -51,9 +51,9 @@
         } else if (auto* binary = inst->As<ir::Binary>()) {
             // A binary instruction that mixes vector and scalar operands needs to have the scalar
             // operand replaced with an explicit vector constructor.
-            if (binary->Result()->Type()->Is<type::Vector>()) {
-                if (binary->LHS()->Type()->Is<type::Scalar>() ||
-                    binary->RHS()->Type()->Is<type::Scalar>()) {
+            if (binary->Result()->Type()->Is<core::type::Vector>()) {
+                if (binary->LHS()->Type()->Is<core::type::Scalar>() ||
+                    binary->RHS()->Type()->Is<core::type::Scalar>()) {
                     binary_worklist.Push(binary);
                 }
             }
@@ -61,8 +61,8 @@
             // A mix builtin call that mixes vector and scalar operands needs to have the scalar
             // operand replaced with an explicit vector constructor.
             if (builtin->Func() == core::Function::kMix) {
-                if (builtin->Result()->Type()->Is<type::Vector>()) {
-                    if (builtin->Args()[2]->Type()->Is<type::Scalar>()) {
+                if (builtin->Result()->Type()->Is<core::type::Vector>()) {
+                    if (builtin->Args()[2]->Type()->Is<core::type::Scalar>()) {
                         builtin_worklist.Push(builtin);
                     }
                 }
@@ -73,7 +73,7 @@
     // Helper to expand a scalar operand of an instruction by replacing it with an explicitly
     // constructed vector that matches the result type.
     auto expand_operand = [&](ir::Instruction* inst, size_t operand_idx) {
-        auto* vec = inst->Result()->Type()->As<type::Vector>();
+        auto* vec = inst->Result()->Type()->As<core::type::Vector>();
 
         Vector<ir::Value*, 4> args;
         args.Resize(vec->Width(), inst->Operands()[operand_idx]);
@@ -89,7 +89,7 @@
         if (result_ty->is_float_vector() && binary->Kind() == ir::Binary::Kind::kMultiply) {
             // Use OpVectorTimesScalar for floating point multiply.
             auto* vts = b.Call(result_ty, ir::IntrinsicCall::Kind::kSpirvVectorTimesScalar);
-            if (binary->LHS()->Type()->Is<type::Scalar>()) {
+            if (binary->LHS()->Type()->Is<core::type::Scalar>()) {
                 vts->AppendArg(binary->RHS());
                 vts->AppendArg(binary->LHS());
             } else {
@@ -104,9 +104,9 @@
             binary->Destroy();
         } else {
             // Expand the scalar argument into an explicitly constructed vector.
-            if (binary->LHS()->Type()->Is<type::Scalar>()) {
+            if (binary->LHS()->Type()->Is<core::type::Scalar>()) {
                 expand_operand(binary, ir::Binary::kLhsOperandOffset);
-            } else if (binary->RHS()->Type()->Is<type::Scalar>()) {
+            } else if (binary->RHS()->Type()->Is<core::type::Scalar>()) {
                 expand_operand(binary, ir::Binary::kRhsOperandOffset);
             }
         }
diff --git a/src/tint/lang/spirv/writer/raise/handle_matrix_arithmetic.cc b/src/tint/lang/spirv/writer/raise/handle_matrix_arithmetic.cc
index 0a96b1c..5e49d45 100644
--- a/src/tint/lang/spirv/writer/raise/handle_matrix_arithmetic.cc
+++ b/src/tint/lang/spirv/writer/raise/handle_matrix_arithmetic.cc
@@ -40,12 +40,12 @@
         }
         if (auto* binary = inst->As<ir::Binary>()) {
             TINT_ASSERT(binary->Operands().Length() == 2);
-            if (binary->LHS()->Type()->Is<type::Matrix>() ||
-                binary->RHS()->Type()->Is<type::Matrix>()) {
+            if (binary->LHS()->Type()->Is<core::type::Matrix>() ||
+                binary->RHS()->Type()->Is<core::type::Matrix>()) {
                 binary_worklist.Push(binary);
             }
         } else if (auto* convert = inst->As<ir::Convert>()) {
-            if (convert->Result()->Type()->Is<type::Matrix>()) {
+            if (convert->Result()->Type()->Is<core::type::Matrix>()) {
                 convert_worklist.Push(convert);
             }
         }
@@ -71,7 +71,7 @@
 
         // Helper to replace the instruction with a column-wise operation.
         auto column_wise = [&](enum ir::Binary::Kind op) {
-            auto* mat = ty->As<type::Matrix>();
+            auto* mat = ty->As<core::type::Matrix>();
             Vector<ir::Value*, 4> args;
             for (uint32_t col = 0; col < mat->columns(); col++) {
                 b.InsertBefore(binary, [&] {
@@ -93,22 +93,22 @@
                 break;
             case ir::Binary::Kind::kMultiply:
                 // Select the SPIR-V intrinsic that corresponds to the operation being performed.
-                if (lhs_ty->Is<type::Matrix>()) {
-                    if (rhs_ty->Is<type::Scalar>()) {
+                if (lhs_ty->Is<core::type::Matrix>()) {
+                    if (rhs_ty->Is<core::type::Scalar>()) {
                         replace(
                             b.Call(ty, ir::IntrinsicCall::Kind::kSpirvMatrixTimesScalar, lhs, rhs));
-                    } else if (rhs_ty->Is<type::Vector>()) {
+                    } else if (rhs_ty->Is<core::type::Vector>()) {
                         replace(
                             b.Call(ty, ir::IntrinsicCall::Kind::kSpirvMatrixTimesVector, lhs, rhs));
-                    } else if (rhs_ty->Is<type::Matrix>()) {
+                    } else if (rhs_ty->Is<core::type::Matrix>()) {
                         replace(
                             b.Call(ty, ir::IntrinsicCall::Kind::kSpirvMatrixTimesMatrix, lhs, rhs));
                     }
                 } else {
-                    if (lhs_ty->Is<type::Scalar>()) {
+                    if (lhs_ty->Is<core::type::Scalar>()) {
                         replace(
                             b.Call(ty, ir::IntrinsicCall::Kind::kSpirvMatrixTimesScalar, rhs, lhs));
-                    } else if (lhs_ty->Is<type::Vector>()) {
+                    } else if (lhs_ty->Is<core::type::Vector>()) {
                         replace(
                             b.Call(ty, ir::IntrinsicCall::Kind::kSpirvVectorTimesMatrix, lhs, rhs));
                     }
@@ -124,8 +124,8 @@
     // Replace the matrix convert instructions that we found.
     for (auto* convert : convert_worklist) {
         auto* arg = convert->Args()[ir::Convert::kValueOperandOffset];
-        auto* in_mat = arg->Type()->As<type::Matrix>();
-        auto* out_mat = convert->Result()->Type()->As<type::Matrix>();
+        auto* in_mat = arg->Type()->As<core::type::Matrix>();
+        auto* out_mat = convert->Result()->Type()->As<core::type::Matrix>();
 
         // Extract and convert each column separately.
         Vector<ir::Value*, 4> args;
diff --git a/src/tint/lang/spirv/writer/raise/merge_return.cc b/src/tint/lang/spirv/writer/raise/merge_return.cc
index 15a42bb..31e4731 100644
--- a/src/tint/lang/spirv/writer/raise/merge_return.cc
+++ b/src/tint/lang/spirv/writer/raise/merge_return.cc
@@ -39,7 +39,7 @@
     ir::Builder b{*ir};
 
     /// The type manager.
-    type::Manager& ty{ir->Types()};
+    core::type::Manager& ty{ir->Types()};
 
     /// The "has not returned" flag.
     ir::Var* continue_execution = nullptr;
@@ -80,7 +80,7 @@
         fn->Block()->Prepend(continue_execution);
 
         // Create a variable to hold the return value if needed.
-        if (!fn->ReturnType()->Is<type::Void>()) {
+        if (!fn->ReturnType()->Is<core::type::Void>()) {
             return_val = b.Var("return_value", ty.ptr(function, fn->ReturnType()));
             fn->Block()->Prepend(return_val);
         }
diff --git a/src/tint/lang/spirv/writer/raise/shader_io.cc b/src/tint/lang/spirv/writer/raise/shader_io.cc
index e2a0a33..c3e3399 100644
--- a/src/tint/lang/spirv/writer/raise/shader_io.cc
+++ b/src/tint/lang/spirv/writer/raise/shader_io.cc
@@ -68,15 +68,15 @@
     void MakeStructs(ir::Var*& builtin_var,
                      ir::Var*& location_var,
                      Vector<uint32_t, 4>* indices,
-                     Vector<type::Manager::StructMemberDesc, 4>& entries,
+                     Vector<core::type::Manager::StructMemberDesc, 4>& entries,
                      core::AddressSpace addrspace,
                      core::Access access,
                      const char* name_suffix) {
         // Build separate lists of builtin and location entries and record their new indices.
         uint32_t next_builtin_idx = 0;
         uint32_t next_location_idx = 0;
-        Vector<type::Manager::StructMemberDesc, 4> builtin_members;
-        Vector<type::Manager::StructMemberDesc, 4> location_members;
+        Vector<core::type::Manager::StructMemberDesc, 4> builtin_members;
+        Vector<core::type::Manager::StructMemberDesc, 4> location_members;
         for (auto io : entries) {
             if (io.attributes.builtin) {
                 // SampleMask must be an array for Vulkan.
@@ -96,7 +96,7 @@
             auto name = ir->NameOf(func).Name() + iotype + name_suffix;
             auto* str = ty.Struct(ir->symbols.New(name + "Struct"), std::move(members));
             auto* var = b.Var(name, ty.ptr(addrspace, str, access));
-            str->SetStructFlag(type::kBlock);
+            str->SetStructFlag(core::type::kBlock);
             b.RootBlock()->Append(var);
             return var;
         };
diff --git a/src/tint/lang/spirv/writer/raise/var_for_dynamic_index.cc b/src/tint/lang/spirv/writer/raise/var_for_dynamic_index.cc
index 0fb16f0..644f05c 100644
--- a/src/tint/lang/spirv/writer/raise/var_for_dynamic_index.cc
+++ b/src/tint/lang/spirv/writer/raise/var_for_dynamic_index.cc
@@ -37,9 +37,9 @@
     // The index of the first dynamic index.
     size_t first_dynamic_index = 0;
     // The object type that corresponds to the source of the first dynamic index.
-    const type::Type* dynamic_index_source_type = nullptr;
+    const core::type::Type* dynamic_index_source_type = nullptr;
     // If the access indexes a vector, then the type of that vector
-    const type::Vector* vector_access_type = nullptr;
+    const core::type::Vector* vector_access_type = nullptr;
 };
 
 // A partial access chain that uses constant indices to get to an object that will be
@@ -79,14 +79,14 @@
 }
 
 std::optional<AccessToReplace> ShouldReplace(ir::Access* access) {
-    if (access->Result()->Type()->Is<type::Pointer>()) {
+    if (access->Result()->Type()->Is<core::type::Pointer>()) {
         // No need to modify accesses into pointer types.
         return {};
     }
 
     std::optional<AccessToReplace> result;
-    WalkAccessChain(access, [&](size_t i, ir::Value* index, const type::Type* ty) {
-        if (auto* vec = ty->As<type::Vector>()) {
+    WalkAccessChain(access, [&](size_t i, ir::Value* index, const core::type::Type* ty) {
+        if (auto* vec = ty->As<core::type::Vector>()) {
             // If we haven't found a dynamic index before the vector, then the transform doesn't
             // need to hoist the access into a var as a vector value can be dynamically indexed.
             // If we have found a dynamic index before the vector, then make a note that we're
@@ -153,7 +153,7 @@
 
         // Create a new access instruction using the local variable as the source.
         Vector<ir::Value*, 4> indices{access->Indices().Offset(to_replace.first_dynamic_index)};
-        const type::Type* access_type = access->Result()->Type();
+        const core::type::Type* access_type = access->Result()->Type();
         ir::Value* vector_index = nullptr;
         if (to_replace.vector_access_type) {
             // The old access indexed the element of a vector.
diff --git a/src/tint/lang/spirv/writer/texture_builtin_test.cc b/src/tint/lang/spirv/writer/texture_builtin_test.cc
index ab05203..ad331ac 100644
--- a/src/tint/lang/spirv/writer/texture_builtin_test.cc
+++ b/src/tint/lang/spirv/writer/texture_builtin_test.cc
@@ -50,7 +50,7 @@
     /// The texture type.
     TextureType texture_type;
     /// The dimensionality of the texture.
-    type::TextureDimension dim;
+    core::type::TextureDimension dim;
     /// The texel type of the texture.
     TestElementType texel_type;
     /// The builtin function arguments.
@@ -94,18 +94,18 @@
 
 class TextureBuiltinTest : public SpirvWriterTestWithParam<TextureBuiltinTestCase> {
   protected:
-    const type::Texture* MakeTextureType(TextureType type,
-                                         type::TextureDimension dim,
-                                         TestElementType texel_type) {
+    const core::type::Texture* MakeTextureType(TextureType type,
+                                               core::type::TextureDimension dim,
+                                               TestElementType texel_type) {
         switch (type) {
             case kSampledTexture:
-                return ty.Get<type::SampledTexture>(dim, MakeScalarType(texel_type));
+                return ty.Get<core::type::SampledTexture>(dim, MakeScalarType(texel_type));
             case kMultisampledTexture:
-                return ty.Get<type::MultisampledTexture>(dim, MakeScalarType(texel_type));
+                return ty.Get<core::type::MultisampledTexture>(dim, MakeScalarType(texel_type));
             case kDepthTexture:
-                return ty.Get<type::DepthTexture>(dim);
+                return ty.Get<core::type::DepthTexture>(dim);
             case kDepthMultisampledTexture:
-                return ty.Get<type::DepthMultisampledTexture>(dim);
+                return ty.Get<core::type::DepthMultisampledTexture>(dim);
             case kStorageTexture:
                 core::TexelFormat format;
                 switch (texel_type) {
@@ -121,8 +121,9 @@
                     default:
                         return nullptr;
                 }
-                return ty.Get<type::StorageTexture>(dim, format, core::Access::kWrite,
-                                                    type::StorageTexture::SubtypeFor(format, ty));
+                return ty.Get<core::type::StorageTexture>(
+                    dim, format, core::Access::kWrite,
+                    core::type::StorageTexture::SubtypeFor(format, ty));
         }
         return nullptr;
     }
@@ -180,7 +181,7 @@
                 mod.SetName(value, arg.name);
             }
             auto* result = b.Call(result_ty, function, std::move(args));
-            if (result_ty->Is<type::Void>()) {
+            if (result_ty->Is<core::type::Void>()) {
                 b.Return(func);
             } else {
                 b.Return(func, result);
@@ -208,7 +209,7 @@
     testing::Values(
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k1d,
+            core::type::TextureDimension::k1d,
             /* texel type */ kF32,
             {{"coord", 1, kF32}},
             {"result", 4, kF32},
@@ -219,7 +220,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}},
             {"result", 4, kF32},
@@ -230,7 +231,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"offset", 2, kI32}},
             {"result", 4, kF32},
@@ -241,7 +242,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}},
             {"result", 4, kF32},
@@ -254,7 +255,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}, {"offset", 2, kI32}},
             {"result", 4, kF32},
@@ -267,7 +268,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k3d,
+            core::type::TextureDimension::k3d,
             /* texel type */ kF32,
             {{"coords", 3, kF32}},
             {"result", 4, kF32},
@@ -278,7 +279,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k3d,
+            core::type::TextureDimension::k3d,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"offset", 3, kI32}},
             {"result", 4, kF32},
@@ -289,7 +290,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::kCube,
+            core::type::TextureDimension::kCube,
             /* texel type */ kF32,
             {{"coords", 3, kF32}},
             {"result", 4, kF32},
@@ -300,7 +301,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::kCubeArray,
+            core::type::TextureDimension::kCubeArray,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"array_idx", 1, kI32}},
             {"result", 4, kF32},
@@ -313,7 +314,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}},
             {"result", 1, kF32},
@@ -325,7 +326,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"offset", 2, kI32}},
             {"result", 1, kF32},
@@ -337,7 +338,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::kCube,
+            core::type::TextureDimension::kCube,
             /* texel type */ kF32,
             {{"coords", 3, kF32}},
             {"result", 1, kF32},
@@ -349,7 +350,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}},
             {"result", 1, kF32},
@@ -363,7 +364,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}, {"offset", 2, kI32}},
             {"result", 1, kF32},
@@ -377,7 +378,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::kCubeArray,
+            core::type::TextureDimension::kCubeArray,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"array_idx", 1, kI32}},
             {"result", 1, kF32},
@@ -403,7 +404,7 @@
     testing::Values(
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"bias", 1, kF32}},
             {"result", 4, kF32},
@@ -414,7 +415,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"bias", 1, kF32}, {"offset", 2, kI32}},
             {"result", 4, kF32},
@@ -425,7 +426,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}, {"bias", 1, kF32}},
             {"result", 4, kF32},
@@ -438,7 +439,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}, {"bias", 1, kF32}, {"offset", 2, kI32}},
             {"result", 4, kF32},
@@ -451,7 +452,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k3d,
+            core::type::TextureDimension::k3d,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"bias", 1, kF32}},
             {"result", 4, kF32},
@@ -462,7 +463,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k3d,
+            core::type::TextureDimension::k3d,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"bias", 1, kF32}, {"offset", 3, kI32}},
             {"result", 4, kF32},
@@ -473,7 +474,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::kCube,
+            core::type::TextureDimension::kCube,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"bias", 1, kF32}},
             {"result", 4, kF32},
@@ -484,7 +485,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::kCubeArray,
+            core::type::TextureDimension::kCubeArray,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"array_idx", 1, kI32}, {"bias", 1, kF32}},
             {"result", 4, kF32},
@@ -510,7 +511,7 @@
     testing::Values(
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"ddx", 2, kF32}, {"ddy", 2, kF32}},
             {"result", 4, kF32},
@@ -521,7 +522,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"ddx", 2, kF32}, {"ddy", 2, kF32}, {"offset", 2, kI32}},
             {"result", 4, kF32},
@@ -532,7 +533,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}, {"ddx", 2, kF32}, {"ddy", 2, kF32}},
             {"result", 4, kF32},
@@ -545,7 +546,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32},
              {"array_idx", 1, kI32},
@@ -562,7 +563,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k3d,
+            core::type::TextureDimension::k3d,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"ddx", 3, kF32}, {"ddy", 3, kF32}},
             {"result", 4, kF32},
@@ -573,7 +574,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k3d,
+            core::type::TextureDimension::k3d,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"ddx", 3, kF32}, {"ddy", 3, kF32}, {"offset", 3, kI32}},
             {"result", 4, kF32},
@@ -584,7 +585,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::kCube,
+            core::type::TextureDimension::kCube,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"ddx", 3, kF32}, {"ddy", 3, kF32}},
             {"result", 4, kF32},
@@ -595,7 +596,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::kCubeArray,
+            core::type::TextureDimension::kCubeArray,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"array_idx", 1, kI32}, {"ddx", 3, kF32}, {"ddy", 3, kF32}},
             {"result", 4, kF32},
@@ -621,7 +622,7 @@
     testing::Values(
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"lod", 1, kF32}},
             {"result", 4, kF32},
@@ -632,7 +633,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"lod", 1, kF32}, {"offset", 2, kI32}},
             {"result", 4, kF32},
@@ -643,7 +644,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}, {"lod", 1, kF32}},
             {"result", 4, kF32},
@@ -656,7 +657,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}, {"lod", 1, kF32}, {"offset", 2, kI32}},
             {"result", 4, kF32},
@@ -669,7 +670,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k3d,
+            core::type::TextureDimension::k3d,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"lod", 1, kF32}},
             {"result", 4, kF32},
@@ -680,7 +681,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k3d,
+            core::type::TextureDimension::k3d,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"lod", 1, kF32}, {"offset", 3, kI32}},
             {"result", 4, kF32},
@@ -691,7 +692,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::kCube,
+            core::type::TextureDimension::kCube,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"lod", 1, kF32}},
             {"result", 4, kF32},
@@ -702,7 +703,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::kCubeArray,
+            core::type::TextureDimension::kCubeArray,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"array_idx", 1, kI32}, {"lod", 1, kF32}},
             {"result", 4, kF32},
@@ -715,7 +716,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"lod", 1, kI32}},
             {"result", 1, kF32},
@@ -728,7 +729,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"lod", 1, kI32}, {"offset", 2, kI32}},
             {"result", 1, kF32},
@@ -741,7 +742,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}, {"lod", 1, kI32}},
             {"result", 1, kF32},
@@ -756,7 +757,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}, {"lod", 1, kI32}, {"offset", 2, kI32}},
             {"result", 1, kF32},
@@ -771,7 +772,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::kCube,
+            core::type::TextureDimension::kCube,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"lod", 1, kI32}},
             {"result", 1, kF32},
@@ -784,7 +785,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::kCubeArray,
+            core::type::TextureDimension::kCubeArray,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"array_idx", 1, kI32}, {"lod", 1, kI32}},
             {"result", 1, kF32},
@@ -811,7 +812,7 @@
     testing::Values(
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"depth", 1, kF32}},
             {"result", 1, kF32},
@@ -822,7 +823,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"depth", 1, kF32}, {"offset", 2, kI32}},
             {"result", 1, kF32},
@@ -833,7 +834,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}, {"depth", 1, kF32}},
             {"result", 1, kF32},
@@ -846,7 +847,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}, {"depth", 1, kF32}, {"offset", 2, kI32}},
             {"result", 1, kF32},
@@ -859,7 +860,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::kCube,
+            core::type::TextureDimension::kCube,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"depth", 1, kF32}},
             {"result", 1, kF32},
@@ -870,7 +871,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::kCubeArray,
+            core::type::TextureDimension::kCubeArray,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"array_idx", 1, kI32}, {"depth", 1, kF32}},
             {"result", 1, kF32},
@@ -896,7 +897,7 @@
     testing::Values(
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"depth_l0", 1, kF32}},
             {"result", 1, kF32},
@@ -907,7 +908,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"depth_l0", 1, kF32}, {"offset", 2, kI32}},
             {"result", 1, kF32},
@@ -919,7 +920,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}, {"depth_l0", 1, kF32}},
             {"result", 1, kF32},
@@ -932,7 +933,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32},
              {"array_idx", 1, kI32},
@@ -949,7 +950,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::kCube,
+            core::type::TextureDimension::kCube,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"depth_l0", 1, kF32}},
             {"result", 1, kF32},
@@ -960,7 +961,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::kCubeArray,
+            core::type::TextureDimension::kCubeArray,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"array_idx", 1, kI32}, {"depth_l0", 1, kF32}},
             {"result", 1, kF32},
@@ -986,7 +987,7 @@
     testing::Values(
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}},
             {"result", 4, kF32},
@@ -997,7 +998,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"offset", 2, kI32}},
             {"result", 4, kF32},
@@ -1008,7 +1009,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}},
             {"result", 4, kF32},
@@ -1021,7 +1022,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}, {"offset", 2, kI32}},
             {"result", 4, kF32},
@@ -1034,7 +1035,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::kCube,
+            core::type::TextureDimension::kCube,
             /* texel type */ kF32,
             {{"coords", 3, kF32}},
             {"result", 4, kF32},
@@ -1045,7 +1046,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::kCubeArray,
+            core::type::TextureDimension::kCubeArray,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"array_idx", 1, kI32}},
             {"result", 4, kF32},
@@ -1058,7 +1059,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}},
             {"result", 4, kF32},
@@ -1069,7 +1070,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"offset", 2, kI32}},
             {"result", 4, kF32},
@@ -1080,7 +1081,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::kCube,
+            core::type::TextureDimension::kCube,
             /* texel type */ kF32,
             {{"coords", 3, kF32}},
             {"result", 4, kF32},
@@ -1091,7 +1092,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}},
             {"result", 4, kF32},
@@ -1104,7 +1105,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}, {"offset", 2, kI32}},
             {"result", 4, kF32},
@@ -1117,7 +1118,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::kCubeArray,
+            core::type::TextureDimension::kCubeArray,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"array_idx", 1, kI32}},
             {"result", 4, kF32},
@@ -1132,7 +1133,7 @@
         // Test some textures with integer texel types.
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kI32,
             {{"coords", 2, kF32}},
             {"result", 4, kI32},
@@ -1143,7 +1144,7 @@
         },
         TextureBuiltinTestCase{
             kSampledTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kU32,
             {{"coords", 2, kF32}},
             {"result", 4, kU32},
@@ -1167,7 +1168,7 @@
     testing::Values(
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"depth", 1, kF32}},
             {"result", 4, kF32},
@@ -1178,7 +1179,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"depth", 1, kF32}, {"offset", 2, kI32}},
             {"result", 4, kF32},
@@ -1189,7 +1190,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}, {"depth", 1, kF32}},
             {"result", 4, kF32},
@@ -1202,7 +1203,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             /* texel type */ kF32,
             {{"coords", 2, kF32}, {"array_idx", 1, kI32}, {"depth", 1, kF32}, {"offset", 2, kI32}},
             {"result", 4, kF32},
@@ -1215,7 +1216,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::kCube,
+            core::type::TextureDimension::kCube,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"depth", 1, kF32}},
             {"result", 4, kF32},
@@ -1226,7 +1227,7 @@
         },
         TextureBuiltinTestCase{
             kDepthTexture,
-            type::TextureDimension::kCubeArray,
+            core::type::TextureDimension::kCubeArray,
             /* texel type */ kF32,
             {{"coords", 3, kF32}, {"array_idx", 1, kI32}, {"depth", 1, kF32}},
             {"result", 4, kF32},
@@ -1251,7 +1252,7 @@
                          testing::Values(
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k1d,
+                                 core::type::TextureDimension::k1d,
                                  /* texel type */ kF32,
                                  {{"coord", 1, kI32}, {"lod", 1, kI32}},
                                  {"result", 4, kF32},
@@ -1261,7 +1262,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kF32,
                                  {{"coords", 2, kI32}, {"lod", 1, kI32}},
                                  {"result", 4, kF32},
@@ -1271,7 +1272,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  /* texel type */ kF32,
                                  {{"coords", 2, kI32}, {"array_idx", 1, kI32}, {"lod", 1, kI32}},
                                  {"result", 4, kF32},
@@ -1282,7 +1283,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k3d,
+                                 core::type::TextureDimension::k3d,
                                  /* texel type */ kF32,
                                  {{"coords", 3, kI32}, {"lod", 1, kI32}},
                                  {"result", 4, kF32},
@@ -1292,7 +1293,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kMultisampledTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kF32,
                                  {{"coords", 2, kI32}, {"sample_idx", 1, kI32}},
                                  {"result", 4, kF32},
@@ -1302,7 +1303,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kF32,
                                  {{"coords", 2, kI32}, {"lod", 1, kI32}},
                                  {"result", 1, kF32},
@@ -1313,7 +1314,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthTexture,
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  /* texel type */ kF32,
                                  {{"coords", 2, kI32}, {"array_idx", 1, kI32}, {"lod", 1, kI32}},
                                  {"result", 1, kF32},
@@ -1325,7 +1326,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthMultisampledTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kF32,
                                  {{"coords", 3, kI32}, {"sample_idx", 1, kI32}},
                                  {"result", 1, kF32},
@@ -1338,7 +1339,7 @@
                              // Test some textures with integer texel types.
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kI32,
                                  {{"coords", 2, kI32}, {"lod", 1, kI32}},
                                  {"result", 4, kI32},
@@ -1348,7 +1349,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kU32,
                                  {{"coords", 2, kI32}, {"lod", 1, kI32}},
                                  {"result", 4, kU32},
@@ -1370,7 +1371,7 @@
                          testing::Values(
                              TextureBuiltinTestCase{
                                  kStorageTexture,
-                                 type::TextureDimension::k1d,
+                                 core::type::TextureDimension::k1d,
                                  /* texel type */ kF32,
                                  {{"coord", 1, kI32}, {"texel", 4, kF32}},
                                  {},
@@ -1380,7 +1381,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kStorageTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kF32,
                                  {{"coords", 2, kI32}, {"texel", 4, kF32}},
                                  {},
@@ -1390,7 +1391,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kStorageTexture,
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  /* texel type */ kF32,
                                  {{"coords", 2, kI32}, {"array_idx", 1, kI32}, {"texel", 4, kF32}},
                                  {},
@@ -1401,7 +1402,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kStorageTexture,
-                                 type::TextureDimension::k3d,
+                                 core::type::TextureDimension::k3d,
                                  /* texel type */ kF32,
                                  {{"coords", 3, kI32}, {"texel", 4, kF32}},
                                  {},
@@ -1413,7 +1414,7 @@
                              // Test some textures with integer texel types.
                              TextureBuiltinTestCase{
                                  kStorageTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kI32,
                                  {{"coords", 2, kI32}, {"texel", 4, kI32}},
                                  {},
@@ -1423,7 +1424,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kStorageTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kU32,
                                  {{"coords", 2, kI32}, {"texel", 4, kU32}},
                                  {},
@@ -1446,7 +1447,7 @@
                              // 1D implicit Lod.
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k1d,
+                                 core::type::TextureDimension::k1d,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kU32},
@@ -1454,7 +1455,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kStorageTexture,
-                                 type::TextureDimension::k1d,
+                                 core::type::TextureDimension::k1d,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kU32},
@@ -1464,7 +1465,7 @@
                              // 1D explicit Lod.
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k1d,
+                                 core::type::TextureDimension::k1d,
                                  /* texel type */ kF32,
                                  {{"lod", 1, kU32}},
                                  {"result", 1, kU32},
@@ -1474,7 +1475,7 @@
                              // 2D implicit Lod.
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 2, kU32},
@@ -1482,7 +1483,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 2, kU32},
@@ -1493,7 +1494,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::kCube,
+                                 core::type::TextureDimension::kCube,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 2, kU32},
@@ -1501,7 +1502,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::kCubeArray,
+                                 core::type::TextureDimension::kCubeArray,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 2, kU32},
@@ -1512,7 +1513,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kMultisampledTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 2, kU32},
@@ -1520,7 +1521,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 2, kU32},
@@ -1528,7 +1529,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthTexture,
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 2, kU32},
@@ -1539,7 +1540,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthTexture,
-                                 type::TextureDimension::kCube,
+                                 core::type::TextureDimension::kCube,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 2, kU32},
@@ -1547,7 +1548,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthTexture,
-                                 type::TextureDimension::kCubeArray,
+                                 core::type::TextureDimension::kCubeArray,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 2, kU32},
@@ -1558,7 +1559,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthMultisampledTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 2, kU32},
@@ -1566,7 +1567,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kStorageTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 2, kU32},
@@ -1574,7 +1575,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kStorageTexture,
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 2, kU32},
@@ -1587,7 +1588,7 @@
                              // 2D explicit Lod.
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kF32,
                                  {{"lod", 1, kU32}},
                                  {"result", 2, kU32},
@@ -1595,7 +1596,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  /* texel type */ kF32,
                                  {{"lod", 1, kU32}},
                                  {"result", 2, kU32},
@@ -1606,7 +1607,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::kCube,
+                                 core::type::TextureDimension::kCube,
                                  /* texel type */ kF32,
                                  {{"lod", 1, kU32}},
                                  {"result", 2, kU32},
@@ -1614,7 +1615,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::kCubeArray,
+                                 core::type::TextureDimension::kCubeArray,
                                  /* texel type */ kF32,
                                  {{"lod", 1, kU32}},
                                  {"result", 2, kU32},
@@ -1625,7 +1626,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kF32,
                                  {{"lod", 1, kU32}},
                                  {"result", 2, kU32},
@@ -1633,7 +1634,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthTexture,
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  /* texel type */ kF32,
                                  {{"lod", 1, kU32}},
                                  {"result", 2, kU32},
@@ -1644,7 +1645,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthTexture,
-                                 type::TextureDimension::kCube,
+                                 core::type::TextureDimension::kCube,
                                  /* texel type */ kF32,
                                  {{"lod", 1, kU32}},
                                  {"result", 2, kU32},
@@ -1652,7 +1653,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthTexture,
-                                 type::TextureDimension::kCubeArray,
+                                 core::type::TextureDimension::kCubeArray,
                                  /* texel type */ kF32,
                                  {{"lod", 1, kU32}},
                                  {"result", 2, kU32},
@@ -1665,7 +1666,7 @@
                              // 3D implicit lod.
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k3d,
+                                 core::type::TextureDimension::k3d,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 3, kU32},
@@ -1675,7 +1676,7 @@
                              // 3D explicit lod.
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k3d,
+                                 core::type::TextureDimension::k3d,
                                  /* texel type */ kF32,
                                  {{"lod", 1, kU32}},
                                  {"result", 3, kU32},
@@ -1695,7 +1696,7 @@
                          testing::Values(
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kU32},
@@ -1706,7 +1707,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::kCubeArray,
+                                 core::type::TextureDimension::kCubeArray,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kU32},
@@ -1717,7 +1718,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthTexture,
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kU32},
@@ -1728,7 +1729,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthTexture,
-                                 type::TextureDimension::kCubeArray,
+                                 core::type::TextureDimension::kCubeArray,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kU32},
@@ -1739,7 +1740,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kStorageTexture,
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kU32},
@@ -1762,7 +1763,7 @@
                          testing::Values(
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k1d,
+                                 core::type::TextureDimension::k1d,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kI32},
@@ -1770,7 +1771,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kI32},
@@ -1778,7 +1779,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kI32},
@@ -1786,7 +1787,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::k3d,
+                                 core::type::TextureDimension::k3d,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kI32},
@@ -1794,7 +1795,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::kCube,
+                                 core::type::TextureDimension::kCube,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kI32},
@@ -1802,7 +1803,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kSampledTexture,
-                                 type::TextureDimension::kCubeArray,
+                                 core::type::TextureDimension::kCubeArray,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kI32},
@@ -1810,7 +1811,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kI32},
@@ -1818,7 +1819,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthTexture,
-                                 type::TextureDimension::k2dArray,
+                                 core::type::TextureDimension::k2dArray,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kI32},
@@ -1826,7 +1827,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthTexture,
-                                 type::TextureDimension::kCube,
+                                 core::type::TextureDimension::kCube,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kI32},
@@ -1834,7 +1835,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthTexture,
-                                 type::TextureDimension::kCubeArray,
+                                 core::type::TextureDimension::kCubeArray,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kI32},
@@ -1854,7 +1855,7 @@
                          testing::Values(
                              TextureBuiltinTestCase{
                                  kMultisampledTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kU32},
@@ -1862,7 +1863,7 @@
                              },
                              TextureBuiltinTestCase{
                                  kDepthMultisampledTexture,
-                                 type::TextureDimension::k2d,
+                                 core::type::TextureDimension::k2d,
                                  /* texel type */ kF32,
                                  {},
                                  {"result", 1, kU32},
@@ -1875,7 +1876,8 @@
 ////////////////////////////////////////////////////////////////
 
 TEST_F(SpirvWriterTest, TextureSampleBaseClampToEdge_2d_f32) {
-    auto* texture_ty = ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32());
+    auto* texture_ty =
+        ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32());
 
     Vector<ir::FunctionParam*, 4> args;
     args.Push(b.FunctionParam("texture", texture_ty));
@@ -1910,9 +1912,9 @@
 
 TEST_F(SpirvWriterTest, Bgra8Unorm_textureStore) {
     auto format = core::TexelFormat::kBgra8Unorm;
-    auto* texture_ty =
-        ty.Get<type::StorageTexture>(type::TextureDimension::k2d, format, core::Access::kWrite,
-                                     type::StorageTexture::SubtypeFor(format, ty));
+    auto* texture_ty = ty.Get<core::type::StorageTexture>(
+        core::type::TextureDimension::k2d, format, core::Access::kWrite,
+        core::type::StorageTexture::SubtypeFor(format, ty));
 
     auto* texture = b.FunctionParam("texture", texture_ty);
     auto* coords = b.FunctionParam("coords", ty.vec2<u32>());
diff --git a/src/tint/lang/spirv/writer/type_test.cc b/src/tint/lang/spirv/writer/type_test.cc
index 3192988..4c18e10 100644
--- a/src/tint/lang/spirv/writer/type_test.cc
+++ b/src/tint/lang/spirv/writer/type_test.cc
@@ -229,7 +229,7 @@
     ASSERT_TRUE(Generate()) << Error() << output_;
 }
 
-using Dim = type::TextureDimension;
+using Dim = core::type::TextureDimension;
 struct TextureCase {
     std::string result;
     Dim dim;
@@ -239,7 +239,7 @@
 using Type_SampledTexture = SpirvWriterTestWithParam<TextureCase>;
 TEST_P(Type_SampledTexture, Emit) {
     auto params = GetParam();
-    writer_.Type(ty.Get<type::SampledTexture>(params.dim, MakeScalarType(params.format)));
+    writer_.Type(ty.Get<core::type::SampledTexture>(params.dim, MakeScalarType(params.format)));
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST(params.result);
@@ -270,7 +270,8 @@
 using Type_MultisampledTexture = SpirvWriterTestWithParam<TextureCase>;
 TEST_P(Type_MultisampledTexture, Emit) {
     auto params = GetParam();
-    writer_.Type(ty.Get<type::MultisampledTexture>(params.dim, MakeScalarType(params.format)));
+    writer_.Type(
+        ty.Get<core::type::MultisampledTexture>(params.dim, MakeScalarType(params.format)));
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST(params.result);
@@ -285,7 +286,7 @@
 using Type_DepthTexture = SpirvWriterTestWithParam<TextureCase>;
 TEST_P(Type_DepthTexture, Emit) {
     auto params = GetParam();
-    writer_.Type(ty.Get<type::DepthTexture>(params.dim));
+    writer_.Type(ty.Get<core::type::DepthTexture>(params.dim));
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST(params.result);
@@ -299,8 +300,8 @@
                     TextureCase{"%1 = OpTypeImage %float Cube 0 1 0 1 Unknown", Dim::kCubeArray}));
 
 TEST_F(SpirvWriterTest, Type_DepthTexture_DedupWithSampledTexture) {
-    writer_.Type(ty.Get<type::SampledTexture>(Dim::k2d, ty.f32()));
-    writer_.Type(ty.Get<type::DepthTexture>(Dim::k2d));
+    writer_.Type(ty.Get<core::type::SampledTexture>(Dim::k2d, ty.f32()));
+    writer_.Type(ty.Get<core::type::DepthTexture>(Dim::k2d));
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_EQ(DumpTypes(), R"(%2 = OpTypeFloat 32
@@ -311,15 +312,15 @@
 }
 
 TEST_F(SpirvWriterTest, Type_DepthMultiSampledTexture) {
-    writer_.Type(ty.Get<type::DepthMultisampledTexture>(Dim::k2d));
+    writer_.Type(ty.Get<core::type::DepthMultisampledTexture>(Dim::k2d));
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST("%1 = OpTypeImage %float 2D 0 0 1 1 Unknown");
 }
 
 TEST_F(SpirvWriterTest, Type_DepthMultisampledTexture_DedupWithMultisampledTexture) {
-    writer_.Type(ty.Get<type::MultisampledTexture>(Dim::k2d, ty.f32()));
-    writer_.Type(ty.Get<type::DepthMultisampledTexture>(Dim::k2d));
+    writer_.Type(ty.Get<core::type::MultisampledTexture>(Dim::k2d, ty.f32()));
+    writer_.Type(ty.Get<core::type::DepthMultisampledTexture>(Dim::k2d));
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_EQ(DumpTypes(), R"(%2 = OpTypeFloat 32
@@ -338,9 +339,9 @@
 using Type_StorageTexture = SpirvWriterTestWithParam<StorageTextureCase>;
 TEST_P(Type_StorageTexture, Emit) {
     auto params = GetParam();
-    writer_.Type(
-        ty.Get<type::StorageTexture>(params.dim, params.format, core::Access::kWrite,
-                                     type::StorageTexture::SubtypeFor(params.format, mod.Types())));
+    writer_.Type(ty.Get<core::type::StorageTexture>(
+        params.dim, params.format, core::Access::kWrite,
+        core::type::StorageTexture::SubtypeFor(params.format, mod.Types())));
 
     ASSERT_TRUE(Generate()) << Error() << output_;
     EXPECT_INST(params.result);
diff --git a/src/tint/lang/spirv/writer/var_test.cc b/src/tint/lang/spirv/writer/var_test.cc
index 5516ace..cc91515 100644
--- a/src/tint/lang/spirv/writer/var_test.cc
+++ b/src/tint/lang/spirv/writer/var_test.cc
@@ -325,9 +325,10 @@
 }
 
 TEST_F(SpirvWriterTest, TextureVar) {
-    auto* v = b.Var("v", ty.ptr(core::AddressSpace::kHandle,
-                                ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32()),
-                                core::Access::kRead));
+    auto* v = b.Var(
+        "v", ty.ptr(core::AddressSpace::kHandle,
+                    ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32()),
+                    core::Access::kRead));
     v->SetBindingPoint(0, 0);
     b.RootBlock()->Append(v);
 
@@ -344,9 +345,10 @@
 }
 
 TEST_F(SpirvWriterTest, TextureVar_Load) {
-    auto* v = b.Var("v", ty.ptr(core::AddressSpace::kHandle,
-                                ty.Get<type::SampledTexture>(type::TextureDimension::k2d, ty.f32()),
-                                core::Access::kRead));
+    auto* v = b.Var(
+        "v", ty.ptr(core::AddressSpace::kHandle,
+                    ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32()),
+                    core::Access::kRead));
     v->SetBindingPoint(0, 0);
     b.RootBlock()->Append(v);
 
diff --git a/src/tint/lang/wgsl/ast/builder.h b/src/tint/lang/wgsl/ast/builder.h
index def0930..fd9ec3a 100644
--- a/src/tint/lang/wgsl/ast/builder.h
+++ b/src/tint/lang/wgsl/ast/builder.h
@@ -1127,16 +1127,18 @@
 
         /// @param kind the kind of sampler
         /// @returns the sampler
-        ast::Type sampler(type::SamplerKind kind) const { return sampler(builder->source_, kind); }
+        ast::Type sampler(core::type::SamplerKind kind) const {
+            return sampler(builder->source_, kind);
+        }
 
         /// @param source the Source of the node
         /// @param kind the kind of sampler
         /// @returns the sampler
-        ast::Type sampler(const Source& source, type::SamplerKind kind) const {
+        ast::Type sampler(const Source& source, core::type::SamplerKind kind) const {
             switch (kind) {
-                case type::SamplerKind::kSampler:
+                case core::type::SamplerKind::kSampler:
                     return (*this)(source, "sampler");
-                case type::SamplerKind::kComparisonSampler:
+                case core::type::SamplerKind::kComparisonSampler:
                     return (*this)(source, "sampler_comparison");
             }
             TINT_ICE() << "invalid sampler kind " << kind;
@@ -1145,22 +1147,22 @@
 
         /// @param dims the dimensionality of the texture
         /// @returns the depth texture
-        ast::Type depth_texture(type::TextureDimension dims) const {
+        ast::Type depth_texture(core::type::TextureDimension dims) const {
             return depth_texture(builder->source_, dims);
         }
 
         /// @param source the Source of the node
         /// @param dims the dimensionality of the texture
         /// @returns the depth texture
-        ast::Type depth_texture(const Source& source, type::TextureDimension dims) const {
+        ast::Type depth_texture(const Source& source, core::type::TextureDimension dims) const {
             switch (dims) {
-                case type::TextureDimension::k2d:
+                case core::type::TextureDimension::k2d:
                     return (*this)(source, "texture_depth_2d");
-                case type::TextureDimension::k2dArray:
+                case core::type::TextureDimension::k2dArray:
                     return (*this)(source, "texture_depth_2d_array");
-                case type::TextureDimension::kCube:
+                case core::type::TextureDimension::kCube:
                     return (*this)(source, "texture_depth_cube");
-                case type::TextureDimension::kCubeArray:
+                case core::type::TextureDimension::kCubeArray:
                     return (*this)(source, "texture_depth_cube_array");
                 default:
                     break;
@@ -1171,7 +1173,7 @@
 
         /// @param dims the dimensionality of the texture
         /// @returns the multisampled depth texture
-        ast::Type depth_multisampled_texture(type::TextureDimension dims) const {
+        ast::Type depth_multisampled_texture(core::type::TextureDimension dims) const {
             return depth_multisampled_texture(builder->source_, dims);
         }
 
@@ -1179,8 +1181,8 @@
         /// @param dims the dimensionality of the texture
         /// @returns the multisampled depth texture
         ast::Type depth_multisampled_texture(const Source& source,
-                                             type::TextureDimension dims) const {
-            if (dims == type::TextureDimension::k2d) {
+                                             core::type::TextureDimension dims) const {
+            if (dims == core::type::TextureDimension::k2d) {
                 return (*this)(source, "texture_depth_multisampled_2d");
             }
             TINT_ICE() << "invalid depth_multisampled_texture dimensions: " << dims;
@@ -1190,7 +1192,7 @@
         /// @param dims the dimensionality of the texture
         /// @param subtype the texture subtype.
         /// @returns the sampled texture
-        ast::Type sampled_texture(type::TextureDimension dims, ast::Type subtype) const {
+        ast::Type sampled_texture(core::type::TextureDimension dims, ast::Type subtype) const {
             return sampled_texture(builder->source_, dims, subtype);
         }
 
@@ -1199,20 +1201,20 @@
         /// @param subtype the texture subtype.
         /// @returns the sampled texture
         ast::Type sampled_texture(const Source& source,
-                                  type::TextureDimension dims,
+                                  core::type::TextureDimension dims,
                                   ast::Type subtype) const {
             switch (dims) {
-                case type::TextureDimension::k1d:
+                case core::type::TextureDimension::k1d:
                     return (*this)(source, "texture_1d", subtype);
-                case type::TextureDimension::k2d:
+                case core::type::TextureDimension::k2d:
                     return (*this)(source, "texture_2d", subtype);
-                case type::TextureDimension::k3d:
+                case core::type::TextureDimension::k3d:
                     return (*this)(source, "texture_3d", subtype);
-                case type::TextureDimension::k2dArray:
+                case core::type::TextureDimension::k2dArray:
                     return (*this)(source, "texture_2d_array", subtype);
-                case type::TextureDimension::kCube:
+                case core::type::TextureDimension::kCube:
                     return (*this)(source, "texture_cube", subtype);
-                case type::TextureDimension::kCubeArray:
+                case core::type::TextureDimension::kCubeArray:
                     return (*this)(source, "texture_cube_array", subtype);
                 default:
                     break;
@@ -1224,7 +1226,7 @@
         /// @param dims the dimensionality of the texture
         /// @param subtype the texture subtype.
         /// @returns the multisampled texture
-        ast::Type multisampled_texture(type::TextureDimension dims, ast::Type subtype) const {
+        ast::Type multisampled_texture(core::type::TextureDimension dims, ast::Type subtype) const {
             return multisampled_texture(builder->source_, dims, subtype);
         }
 
@@ -1233,9 +1235,9 @@
         /// @param subtype the texture subtype.
         /// @returns the multisampled texture
         ast::Type multisampled_texture(const Source& source,
-                                       type::TextureDimension dims,
+                                       core::type::TextureDimension dims,
                                        ast::Type subtype) const {
-            if (dims == type::TextureDimension::k2d) {
+            if (dims == core::type::TextureDimension::k2d) {
                 return (*this)(source, "texture_multisampled_2d", subtype);
             }
             TINT_ICE() << "invalid multisampled_texture dimensions: " << dims;
@@ -1246,7 +1248,7 @@
         /// @param format the texel format of the texture
         /// @param access the access control of the texture
         /// @returns the storage texture
-        ast::Type storage_texture(type::TextureDimension dims,
+        ast::Type storage_texture(core::type::TextureDimension dims,
                                   core::TexelFormat format,
                                   core::Access access) const {
             return storage_texture(builder->source_, dims, format, access);
@@ -1258,17 +1260,17 @@
         /// @param access the access control of the texture
         /// @returns the storage texture
         ast::Type storage_texture(const Source& source,
-                                  type::TextureDimension dims,
+                                  core::type::TextureDimension dims,
                                   core::TexelFormat format,
                                   core::Access access) const {
             switch (dims) {
-                case type::TextureDimension::k1d:
+                case core::type::TextureDimension::k1d:
                     return (*this)(source, "texture_storage_1d", format, access);
-                case type::TextureDimension::k2d:
+                case core::type::TextureDimension::k2d:
                     return (*this)(source, "texture_storage_2d", format, access);
-                case type::TextureDimension::k2dArray:
+                case core::type::TextureDimension::k2dArray:
                     return (*this)(source, "texture_storage_2d_array", format, access);
-                case type::TextureDimension::k3d:
+                case core::type::TextureDimension::k3d:
                     return (*this)(source, "texture_storage_3d", format, access);
                 default:
                     break;
diff --git a/src/tint/lang/wgsl/ast/builtin_texture_helper_test.cc b/src/tint/lang/wgsl/ast/builtin_texture_helper_test.cc
index 4be2f20..3633616 100644
--- a/src/tint/lang/wgsl/ast/builtin_texture_helper_test.cc
+++ b/src/tint/lang/wgsl/ast/builtin_texture_helper_test.cc
@@ -68,8 +68,8 @@
 TextureOverloadCase::TextureOverloadCase(ValidTextureOverload o,
                                          const char* desc,
                                          TextureKind tk,
-                                         type::SamplerKind sk,
-                                         type::TextureDimension dims,
+                                         core::type::SamplerKind sk,
+                                         core::type::TextureDimension dims,
                                          TextureDataType datatype,
                                          const char* f,
                                          std::function<Args(ProgramBuilder*)> a,
@@ -86,7 +86,7 @@
 TextureOverloadCase::TextureOverloadCase(ValidTextureOverload o,
                                          const char* desc,
                                          TextureKind tk,
-                                         type::TextureDimension dims,
+                                         core::type::TextureDimension dims,
                                          TextureDataType datatype,
                                          const char* f,
                                          std::function<Args(ProgramBuilder*)> a,
@@ -103,7 +103,7 @@
                                          const char* d,
                                          tint::core::Access acc,
                                          tint::core::TexelFormat fmt,
-                                         type::TextureDimension dims,
+                                         core::type::TextureDimension dims,
                                          TextureDataType datatype,
                                          const char* f,
                                          std::function<Args(ProgramBuilder*)> a,
@@ -201,8 +201,8 @@
             ValidTextureOverload::kDimensions1d,
             "textureDimensions(t : texture_1d<f32>) -> u32",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k1d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k1d,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -212,8 +212,8 @@
             ValidTextureOverload::kDimensions2d,
             "textureDimensions(t : texture_2d<f32>) -> vec2<u32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -224,8 +224,8 @@
             "textureDimensions(t     : texture_2d<f32>,\n"
             "                  level : i32) -> vec2<u32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName, 1_i); },
@@ -235,8 +235,8 @@
             ValidTextureOverload::kDimensions2dArray,
             "textureDimensions(t : texture_2d_array<f32>) -> vec2<u32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -247,8 +247,8 @@
             "textureDimensions(t     : texture_2d_array<f32>,\n"
             "                  level : i32) -> vec2<u32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName, 1_i); },
@@ -258,8 +258,8 @@
             ValidTextureOverload::kDimensions3d,
             "textureDimensions(t : texture_3d<f32>) -> vec3<u32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k3d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k3d,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -270,8 +270,8 @@
             "textureDimensions(t     : texture_3d<f32>,\n"
             "                  level : i32) -> vec3<u32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k3d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k3d,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName, 1_i); },
@@ -281,8 +281,8 @@
             ValidTextureOverload::kDimensionsCube,
             "textureDimensions(t : texture_cube<f32>) -> vec2<u32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCube,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCube,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -293,8 +293,8 @@
             "textureDimensions(t     : texture_cube<f32>,\n"
             "                  level : i32) -> vec2<u32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCube,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCube,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName, 1_i); },
@@ -304,8 +304,8 @@
             ValidTextureOverload::kDimensionsCubeArray,
             "textureDimensions(t : texture_cube_array<f32>) -> vec2<u32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -316,8 +316,8 @@
             "textureDimensions(t     : texture_cube_array<f32>,\n"
             "                  level : i32) -> vec2<u32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName, 1_i); },
@@ -327,8 +327,8 @@
             ValidTextureOverload::kDimensionsMultisampled2d,
             "textureDimensions(t : texture_multisampled_2d<f32>)-> vec2<u32>",
             TextureKind::kMultisampled,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -338,8 +338,8 @@
             ValidTextureOverload::kDimensionsDepth2d,
             "textureDimensions(t : texture_depth_2d) -> vec2<u32>",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -350,8 +350,8 @@
             "textureDimensions(t     : texture_depth_2d,\n"
             "                  level : i32) -> vec2<u32>",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName, 1_i); },
@@ -361,8 +361,8 @@
             ValidTextureOverload::kDimensionsDepth2dArray,
             "textureDimensions(t : texture_depth_2d_array) -> vec2<u32>",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -373,8 +373,8 @@
             "textureDimensions(t     : texture_depth_2d_array,\n"
             "                  level : i32) -> vec2<u32>",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName, 1_i); },
@@ -384,8 +384,8 @@
             ValidTextureOverload::kDimensionsDepthCube,
             "textureDimensions(t : texture_depth_cube) -> vec2<u32>",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCube,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCube,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -396,8 +396,8 @@
             "textureDimensions(t     : texture_depth_cube,\n"
             "                  level : i32) -> vec2<u32>",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCube,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCube,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName, 1_i); },
@@ -407,8 +407,8 @@
             ValidTextureOverload::kDimensionsDepthCubeArray,
             "textureDimensions(t : texture_depth_cube_array) -> vec2<u32>",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -419,8 +419,8 @@
             "textureDimensions(t     : texture_depth_cube_array,\n"
             "                  level : i32) -> vec2<u32>",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName, 1_i); },
@@ -430,8 +430,8 @@
             ValidTextureOverload::kDimensionsDepthMultisampled2d,
             "textureDimensions(t : texture_depth_multisampled_2d) -> vec2<u32>",
             TextureKind::kDepthMultisampled,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -442,7 +442,7 @@
             "textureDimensions(t : texture_storage_1d<rgba32float>) -> u32",
             tint::core::Access::kWrite,
             tint::core::TexelFormat::kRgba32Float,
-            type::TextureDimension::k1d,
+            core::type::TextureDimension::k1d,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -453,7 +453,7 @@
             "textureDimensions(t : texture_storage_2d<rgba32float>) -> vec2<u32>",
             tint::core::Access::kWrite,
             tint::core::TexelFormat::kRgba32Float,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -464,7 +464,7 @@
             "textureDimensions(t : texture_storage_2d_array<rgba32float>) -> vec2<u32>",
             tint::core::Access::kWrite,
             tint::core::TexelFormat::kRgba32Float,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -475,7 +475,7 @@
             "textureDimensions(t : texture_storage_3d<rgba32float>) -> vec3<u32>",
             tint::core::Access::kWrite,
             tint::core::TexelFormat::kRgba32Float,
-            type::TextureDimension::k3d,
+            core::type::TextureDimension::k3d,
             TextureDataType::kF32,
             "textureDimensions",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -489,8 +489,8 @@
             "              s         : sampler,\n"
             "              coords    : vec2<f32>) -> vec4<T>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureGather",
             [](ProgramBuilder* b) {
@@ -509,8 +509,8 @@
             "              coords    : vec2<f32>,\n"
             "              offset    : vec2<i32>) -> vec4<T>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureGather",
             [](ProgramBuilder* b) {
@@ -530,8 +530,8 @@
             "              coords      : vec2<f32>,\n"
             "              array_index : i32) -> vec4<T>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureGather",
             [](ProgramBuilder* b) {
@@ -552,8 +552,8 @@
             "              array_index : u32,\n"
             "              offset      : vec2<i32>) -> vec4<T>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureGather",
             [](ProgramBuilder* b) {
@@ -573,8 +573,8 @@
             "              s         : sampler,\n"
             "              coords    : vec3<f32>) -> vec4<T>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCube,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCube,
             TextureDataType::kF32,
             "textureGather",
             [](ProgramBuilder* b) {
@@ -593,8 +593,8 @@
             "              coords      : vec3<f32>,\n"
             "              array_index : u32) -> vec4<T>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureGather",
             [](ProgramBuilder* b) {
@@ -612,8 +612,8 @@
             "              s      : sampler,\n"
             "              coords : vec2<f32>) -> vec4<f32>",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureGather",
             [](ProgramBuilder* b) {
@@ -630,8 +630,8 @@
             "              coords : vec2<f32>,\n"
             "              offset : vec2<i32>) -> vec4<f32>",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureGather",
             [](ProgramBuilder* b) {
@@ -649,8 +649,8 @@
             "              coords      : vec2<f32>,\n"
             "              array_index : u32) -> vec4<f32>",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureGather",
             [](ProgramBuilder* b) {
@@ -669,8 +669,8 @@
             "              array_index : i32,\n"
             "              offset      : vec2<i32>) -> vec4<f32>",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureGather",
             [](ProgramBuilder* b) {
@@ -688,8 +688,8 @@
             "              s      : sampler,\n"
             "              coords : vec3<f32>) -> vec4<f32>",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCube,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCube,
             TextureDataType::kF32,
             "textureGather",
             [](ProgramBuilder* b) {
@@ -706,8 +706,8 @@
             "              coords      : vec3<f32>,\n"
             "              array_index : u32) -> vec4<f32>",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureGather",
             [](ProgramBuilder* b) {
@@ -725,8 +725,8 @@
             "                     coords    : vec2<f32>,\n"
             "                     depth_ref : f32) -> vec4<f32>",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureGatherCompare",
             [](ProgramBuilder* b) {
@@ -745,8 +745,8 @@
             "                     depth_ref : f32,\n"
             "                     offset    : vec2<i32>) -> vec4<f32>",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureGatherCompare",
             [](ProgramBuilder* b) {
@@ -766,8 +766,8 @@
             "                     array_index : i32,\n"
             "                     depth_ref   : f32) -> vec4<f32>",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureGatherCompare",
             [](ProgramBuilder* b) {
@@ -788,8 +788,8 @@
             "                     depth_ref   : f32,\n"
             "                     offset      : vec2<i32>) -> vec4<f32>",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureGatherCompare",
             [](ProgramBuilder* b) {
@@ -809,8 +809,8 @@
             "                     coords    : vec3<f32>,\n"
             "                     depth_ref : f32) -> vec4<f32>",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::kCube,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::kCube,
             TextureDataType::kF32,
             "textureGatherCompare",
             [](ProgramBuilder* b) {
@@ -829,8 +829,8 @@
             "                     array_index : u32,\n"
             "                     depth_ref   : f32) -> vec4<f32>",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureGatherCompare",
             [](ProgramBuilder* b) {
@@ -846,8 +846,8 @@
             ValidTextureOverload::kNumLayers2dArray,
             "textureNumLayers(t : texture_2d_array<f32>) -> u32",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureNumLayers",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -857,8 +857,8 @@
             ValidTextureOverload::kNumLayersCubeArray,
             "textureNumLayers(t : texture_cube_array<f32>) -> u32",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureNumLayers",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -868,8 +868,8 @@
             ValidTextureOverload::kNumLayersDepth2dArray,
             "textureNumLayers(t : texture_depth_2d_array) -> u32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureNumLayers",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -879,8 +879,8 @@
             ValidTextureOverload::kNumLayersDepthCubeArray,
             "textureNumLayers(t : texture_depth_cube_array) -> u32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureNumLayers",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -891,7 +891,7 @@
             "textureNumLayers(t : texture_storage_2d_array<rgba32float>) -> u32",
             tint::core::Access::kWrite,
             tint::core::TexelFormat::kRgba32Float,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureNumLayers",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -901,8 +901,8 @@
             ValidTextureOverload::kNumLevels2d,
             "textureNumLevels(t : texture_2d<f32>) -> u32",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureNumLevels",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -912,8 +912,8 @@
             ValidTextureOverload::kNumLevels2dArray,
             "textureNumLevels(t : texture_2d_array<f32>) -> u32",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureNumLevels",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -923,8 +923,8 @@
             ValidTextureOverload::kNumLevels3d,
             "textureNumLevels(t : texture_3d<f32>) -> u32",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k3d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k3d,
             TextureDataType::kF32,
             "textureNumLevels",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -934,8 +934,8 @@
             ValidTextureOverload::kNumLevelsCube,
             "textureNumLevels(t : texture_cube<f32>) -> u32",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCube,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCube,
             TextureDataType::kF32,
             "textureNumLevels",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -945,8 +945,8 @@
             ValidTextureOverload::kNumLevelsCubeArray,
             "textureNumLevels(t : texture_cube_array<f32>) -> u32",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureNumLevels",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -956,8 +956,8 @@
             ValidTextureOverload::kNumLevelsDepth2d,
             "textureNumLevels(t : texture_depth_2d) -> u32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureNumLevels",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -967,8 +967,8 @@
             ValidTextureOverload::kNumLevelsDepth2dArray,
             "textureNumLevels(t : texture_depth_2d_array) -> u32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureNumLevels",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -978,8 +978,8 @@
             ValidTextureOverload::kNumLevelsDepthCube,
             "textureNumLevels(t : texture_depth_cube) -> u32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCube,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCube,
             TextureDataType::kF32,
             "textureNumLevels",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -989,8 +989,8 @@
             ValidTextureOverload::kNumLevelsDepthCubeArray,
             "textureNumLevels(t : texture_depth_cube_array) -> u32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureNumLevels",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -1000,8 +1000,8 @@
             ValidTextureOverload::kNumSamplesMultisampled2d,
             "textureNumSamples(t : texture_multisampled_2d<f32>) -> u32",
             TextureKind::kMultisampled,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureNumSamples",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -1011,8 +1011,8 @@
             ValidTextureOverload::kNumSamplesDepthMultisampled2d,
             "textureNumSamples(t : texture_depth_multisampled_2d<f32>) -> u32",
             TextureKind::kMultisampled,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureNumSamples",
             [](ProgramBuilder* b) { return b->ExprList(kTextureName); },
@@ -1024,8 +1024,8 @@
             "              s      : sampler,\n"
             "              coords : f32) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k1d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k1d,
             TextureDataType::kF32,
             "textureSample",
             [](ProgramBuilder* b) {
@@ -1041,8 +1041,8 @@
             "              s      : sampler,\n"
             "              coords : vec2<f32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureSample",
             [](ProgramBuilder* b) {
@@ -1059,8 +1059,8 @@
             "              coords : vec2<f32>\n"
             "              offset : vec2<i32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureSample",
             [](ProgramBuilder* b) {
@@ -1078,8 +1078,8 @@
             "              coords      : vec2<f32>,\n"
             "              array_index : i32) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureSample",
             [](ProgramBuilder* b) {
@@ -1098,8 +1098,8 @@
             "              array_index : u32\n"
             "              offset      : vec2<i32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureSample",
             [](ProgramBuilder* b) {
@@ -1117,8 +1117,8 @@
             "              s      : sampler,\n"
             "              coords : vec3<f32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k3d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k3d,
             TextureDataType::kF32,
             "textureSample",
             [](ProgramBuilder* b) {
@@ -1135,8 +1135,8 @@
             "              coords : vec3<f32>\n"
             "              offset : vec3<i32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k3d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k3d,
             TextureDataType::kF32,
             "textureSample",
             [](ProgramBuilder* b) {
@@ -1153,8 +1153,8 @@
             "              s      : sampler,\n"
             "              coords : vec3<f32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCube,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCube,
             TextureDataType::kF32,
             "textureSample",
             [](ProgramBuilder* b) {
@@ -1171,8 +1171,8 @@
             "              coords      : vec3<f32>,\n"
             "              array_index : i32) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureSample",
             [](ProgramBuilder* b) {
@@ -1189,8 +1189,8 @@
             "              s      : sampler,\n"
             "              coords : vec2<f32>) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureSample",
             [](ProgramBuilder* b) {
@@ -1207,8 +1207,8 @@
             "              coords : vec2<f32>\n"
             "              offset : vec2<i32>) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureSample",
             [](ProgramBuilder* b) {
@@ -1226,8 +1226,8 @@
             "              coords      : vec2<f32>,\n"
             "              array_index : i32) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureSample",
             [](ProgramBuilder* b) {
@@ -1246,8 +1246,8 @@
             "              array_index : i32\n"
             "              offset      : vec2<i32>) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureSample",
             [](ProgramBuilder* b) {
@@ -1265,8 +1265,8 @@
             "              s      : sampler,\n"
             "              coords : vec3<f32>) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCube,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCube,
             TextureDataType::kF32,
             "textureSample",
             [](ProgramBuilder* b) {
@@ -1283,8 +1283,8 @@
             "              coords      : vec3<f32>,\n"
             "              array_index : u32) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureSample",
             [](ProgramBuilder* b) {
@@ -1302,8 +1302,8 @@
             "                  coords : vec2<f32>,\n"
             "                  bias   : f32) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureSampleBias",
             [](ProgramBuilder* b) {
@@ -1322,8 +1322,8 @@
             "                  bias   : f32,\n"
             "                  offset : vec2<i32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureSampleBias",
             [](ProgramBuilder* b) {
@@ -1343,8 +1343,8 @@
             "                  array_index : u32,\n"
             "                  bias        : f32) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureSampleBias",
             [](ProgramBuilder* b) {
@@ -1365,8 +1365,8 @@
             "                  bias        : f32,\n"
             "                  offset      : vec2<i32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureSampleBias",
             [](ProgramBuilder* b) {
@@ -1386,8 +1386,8 @@
             "                  coords : vec3<f32>,\n"
             "                  bias   : f32) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k3d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k3d,
             TextureDataType::kF32,
             "textureSampleBias",
             [](ProgramBuilder* b) {
@@ -1406,8 +1406,8 @@
             "                  bias   : f32,\n"
             "                  offset : vec3<i32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k3d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k3d,
             TextureDataType::kF32,
             "textureSampleBias",
             [](ProgramBuilder* b) {
@@ -1426,8 +1426,8 @@
             "                  coords : vec3<f32>,\n"
             "                  bias   : f32) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCube,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCube,
             TextureDataType::kF32,
             "textureSampleBias",
             [](ProgramBuilder* b) {
@@ -1446,8 +1446,8 @@
             "                  array_index : i32,\n"
             "                  bias        : f32) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureSampleBias",
             [](ProgramBuilder* b) {
@@ -1466,8 +1466,8 @@
             "                   coords : vec2<f32>,\n"
             "                   level  : f32) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureSampleLevel",
             [](ProgramBuilder* b) {
@@ -1486,8 +1486,8 @@
             "                   level  : f32,\n"
             "                   offset : vec2<i32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureSampleLevel",
             [](ProgramBuilder* b) {
@@ -1507,8 +1507,8 @@
             "                   array_index : i32,\n"
             "                   level       : f32) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureSampleLevel",
             [](ProgramBuilder* b) {
@@ -1529,8 +1529,8 @@
             "                   level       : f32,\n"
             "                   offset      : vec2<i32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureSampleLevel",
             [](ProgramBuilder* b) {
@@ -1550,8 +1550,8 @@
             "                   coords : vec3<f32>,\n"
             "                   level  : f32) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k3d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k3d,
             TextureDataType::kF32,
             "textureSampleLevel",
             [](ProgramBuilder* b) {
@@ -1570,8 +1570,8 @@
             "                   level  : f32,\n"
             "                   offset : vec3<i32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k3d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k3d,
             TextureDataType::kF32,
             "textureSampleLevel",
             [](ProgramBuilder* b) {
@@ -1590,8 +1590,8 @@
             "                   coords : vec3<f32>,\n"
             "                   level  : f32) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCube,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCube,
             TextureDataType::kF32,
             "textureSampleLevel",
             [](ProgramBuilder* b) {
@@ -1610,8 +1610,8 @@
             "                   array_index : i32,\n"
             "                   level       : f32) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureSampleLevel",
             [](ProgramBuilder* b) {
@@ -1630,8 +1630,8 @@
             "                   coords : vec2<f32>,\n"
             "                   level  : u32) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureSampleLevel",
             [](ProgramBuilder* b) {
@@ -1650,8 +1650,8 @@
             "                   level  : i32,\n"
             "                   offset : vec2<i32>) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureSampleLevel",
             [](ProgramBuilder* b) {
@@ -1671,8 +1671,8 @@
             "                   array_index : u32,\n"
             "                   level       : u32) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureSampleLevel",
             [](ProgramBuilder* b) {
@@ -1693,8 +1693,8 @@
             "                   level       : u32,\n"
             "                   offset      : vec2<i32>) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureSampleLevel",
             [](ProgramBuilder* b) {
@@ -1714,8 +1714,8 @@
             "                   coords : vec3<f32>,\n"
             "                   level  : i32) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCube,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCube,
             TextureDataType::kF32,
             "textureSampleLevel",
             [](ProgramBuilder* b) {
@@ -1734,8 +1734,8 @@
             "                   array_index : i32,\n"
             "                   level       : i32) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureSampleLevel",
             [](ProgramBuilder* b) {
@@ -1755,8 +1755,8 @@
             "                  ddx    : vec2<f32>,\n"
             "                  ddy    : vec2<f32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureSampleGrad",
             [](ProgramBuilder* b) {
@@ -1777,8 +1777,8 @@
             "                  ddy    : vec2<f32>,\n"
             "                  offset : vec2<i32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureSampleGrad",
             [](ProgramBuilder* b) {
@@ -1800,8 +1800,8 @@
             "                  ddx         : vec2<f32>,\n"
             "                  ddy         : vec2<f32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureSampleGrad",
             [](ProgramBuilder* b) {
@@ -1824,8 +1824,8 @@
             "                  ddy         : vec2<f32>,\n"
             "                  offset      : vec2<i32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureSampleGrad",
             [](ProgramBuilder* b) {
@@ -1847,8 +1847,8 @@
             "                  ddx    : vec3<f32>,\n"
             "                  ddy    : vec3<f32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k3d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k3d,
             TextureDataType::kF32,
             "textureSampleGrad",
             [](ProgramBuilder* b) {
@@ -1869,8 +1869,8 @@
             "                  ddy    : vec3<f32>,\n"
             "                  offset : vec3<i32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::k3d,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::k3d,
             TextureDataType::kF32,
             "textureSampleGrad",
             [](ProgramBuilder* b) {
@@ -1891,8 +1891,8 @@
             "                  ddx    : vec3<f32>,\n"
             "                  ddy    : vec3<f32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCube,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCube,
             TextureDataType::kF32,
             "textureSampleGrad",
             [](ProgramBuilder* b) {
@@ -1913,8 +1913,8 @@
             "                  ddx         : vec3<f32>,\n"
             "                  ddy         : vec3<f32>) -> vec4<f32>",
             TextureKind::kRegular,
-            type::SamplerKind::kSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureSampleGrad",
             [](ProgramBuilder* b) {
@@ -1934,8 +1934,8 @@
             "                     coords    : vec2<f32>,\n"
             "                     depth_ref : f32) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureSampleCompare",
             [](ProgramBuilder* b) {
@@ -1954,8 +1954,8 @@
             "                     depth_ref : f32,\n"
             "                     offset    : vec2<i32>) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureSampleCompare",
             [](ProgramBuilder* b) {
@@ -1975,8 +1975,8 @@
             "                     array_index : i32,\n"
             "                     depth_ref   : f32) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureSampleCompare",
             [](ProgramBuilder* b) {
@@ -1997,8 +1997,8 @@
             "                     depth_ref   : f32,\n"
             "                     offset      : vec2<i32>) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureSampleCompare",
             [](ProgramBuilder* b) {
@@ -2018,8 +2018,8 @@
             "                     coords    : vec3<f32>,\n"
             "                     depth_ref : f32) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::kCube,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::kCube,
             TextureDataType::kF32,
             "textureSampleCompare",
             [](ProgramBuilder* b) {
@@ -2038,8 +2038,8 @@
             "                     array_index : i32,\n"
             "                     depth_ref   : f32) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureSampleCompare",
             [](ProgramBuilder* b) {
@@ -2058,8 +2058,8 @@
             "                          coords    : vec2<f32>,\n"
             "                          depth_ref : f32) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureSampleCompareLevel",
             [](ProgramBuilder* b) {
@@ -2078,8 +2078,8 @@
             "                          depth_ref : f32,\n"
             "                          offset    : vec2<i32>) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::k2d,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureSampleCompareLevel",
             [](ProgramBuilder* b) {
@@ -2099,8 +2099,8 @@
             "                          array_index : i32,\n"
             "                          depth_ref   : f32) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureSampleCompareLevel",
             [](ProgramBuilder* b) {
@@ -2121,8 +2121,8 @@
             "                          depth_ref   : f32,\n"
             "                          offset      : vec2<i32>) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::k2dArray,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureSampleCompareLevel",
             [](ProgramBuilder* b) {
@@ -2142,8 +2142,8 @@
             "                          coords      : vec3<f32>,\n"
             "                          depth_ref   : f32) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::kCube,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::kCube,
             TextureDataType::kF32,
             "textureSampleCompareLevel",
             [](ProgramBuilder* b) {
@@ -2162,8 +2162,8 @@
             "                          array_index : i32,\n"
             "                          depth_ref   : f32) -> f32",
             TextureKind::kDepth,
-            type::SamplerKind::kComparisonSampler,
-            type::TextureDimension::kCubeArray,
+            core::type::SamplerKind::kComparisonSampler,
+            core::type::TextureDimension::kCubeArray,
             TextureDataType::kF32,
             "textureSampleCompareLevel",
             [](ProgramBuilder* b) {
@@ -2181,7 +2181,7 @@
             "            coords : u32,\n"
             "            level  : u32) -> vec4<f32>",
             TextureKind::kRegular,
-            type::TextureDimension::k1d,
+            core::type::TextureDimension::k1d,
             TextureDataType::kF32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2197,7 +2197,7 @@
             "            coords : i32,\n"
             "            level  : i32) -> vec4<u32>",
             TextureKind::kRegular,
-            type::TextureDimension::k1d,
+            core::type::TextureDimension::k1d,
             TextureDataType::kU32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2213,7 +2213,7 @@
             "            coords : i32,\n"
             "            level  : i32) -> vec4<i32>",
             TextureKind::kRegular,
-            type::TextureDimension::k1d,
+            core::type::TextureDimension::k1d,
             TextureDataType::kI32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2229,7 +2229,7 @@
             "            coords : vec2<u32>,\n"
             "            level  : u32) -> vec4<f32>",
             TextureKind::kRegular,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2245,7 +2245,7 @@
             "            coords : vec2<i32>,\n"
             "            level  : i32) -> vec4<u32>",
             TextureKind::kRegular,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             TextureDataType::kU32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2261,7 +2261,7 @@
             "            coords : vec2<u32>,\n"
             "            level  : u32) -> vec4<i32>",
             TextureKind::kRegular,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             TextureDataType::kI32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2278,7 +2278,7 @@
             "            array_index : i32,\n"
             "            level       : i32) -> vec4<f32>",
             TextureKind::kRegular,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2296,7 +2296,7 @@
             "            array_index : i32,\n"
             "            level       : i32) -> vec4<u32>",
             TextureKind::kRegular,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kU32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2314,7 +2314,7 @@
             "            array_index : u32,\n"
             "            level       : u32) -> vec4<i32>",
             TextureKind::kRegular,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kI32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2331,7 +2331,7 @@
             "            coords : vec3<i32>,\n"
             "            level  : i32) -> vec4<f32>",
             TextureKind::kRegular,
-            type::TextureDimension::k3d,
+            core::type::TextureDimension::k3d,
             TextureDataType::kF32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2347,7 +2347,7 @@
             "            coords : vec3<i32>,\n"
             "            level  : i32) -> vec4<u32>",
             TextureKind::kRegular,
-            type::TextureDimension::k3d,
+            core::type::TextureDimension::k3d,
             TextureDataType::kU32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2363,7 +2363,7 @@
             "            coords : vec3<u32>,\n"
             "            level  : u32) -> vec4<i32>",
             TextureKind::kRegular,
-            type::TextureDimension::k3d,
+            core::type::TextureDimension::k3d,
             TextureDataType::kI32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2379,7 +2379,7 @@
             "            coords       : vec2<i32>,\n"
             "            sample_index : i32) -> vec4<f32>",
             TextureKind::kMultisampled,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2395,7 +2395,7 @@
             "            coords       : vec2<i32>,\n"
             "            sample_index : i32) -> vec4<u32>",
             TextureKind::kMultisampled,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             TextureDataType::kU32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2411,7 +2411,7 @@
             "            coords       : vec2<u32>,\n"
             "            sample_index : u32) -> vec4<i32>",
             TextureKind::kMultisampled,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             TextureDataType::kI32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2427,7 +2427,7 @@
             "            coords : vec2<i32>,\n"
             "            level  : i32) -> f32",
             TextureKind::kDepth,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2444,7 +2444,7 @@
             "            array_index : u32,\n"
             "            level       : u32) -> f32",
             TextureKind::kDepth,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2461,7 +2461,7 @@
             "            coords       : vec2<u32>,\n"
             "            sample_index : u32) -> f32",
             TextureKind::kDepthMultisampled,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureLoad",
             [](ProgramBuilder* b) {
@@ -2478,7 +2478,7 @@
             "             value  : vec4<T>)",
             tint::core::Access::kWrite,
             tint::core::TexelFormat::kRgba32Float,
-            type::TextureDimension::k1d,
+            core::type::TextureDimension::k1d,
             TextureDataType::kF32,
             "textureStore",
             [](ProgramBuilder* b) {
@@ -2495,7 +2495,7 @@
             "             value  : vec4<T>)",
             tint::core::Access::kWrite,
             tint::core::TexelFormat::kRgba32Float,
-            type::TextureDimension::k2d,
+            core::type::TextureDimension::k2d,
             TextureDataType::kF32,
             "textureStore",
             [](ProgramBuilder* b) {
@@ -2513,7 +2513,7 @@
             "             value       : vec4<T>)",
             tint::core::Access::kWrite,
             tint::core::TexelFormat::kRgba32Float,
-            type::TextureDimension::k2dArray,
+            core::type::TextureDimension::k2dArray,
             TextureDataType::kF32,
             "textureStore",
             [](ProgramBuilder* b) {
@@ -2531,7 +2531,7 @@
             "             value  : vec4<T>)",
             tint::core::Access::kWrite,
             tint::core::TexelFormat::kRgba32Float,
-            type::TextureDimension::k3d,
+            core::type::TextureDimension::k3d,
             TextureDataType::kF32,
             "textureStore",
             [](ProgramBuilder* b) {
diff --git a/src/tint/lang/wgsl/ast/builtin_texture_helper_test.h b/src/tint/lang/wgsl/ast/builtin_texture_helper_test.h
index f1d1703..c54775f 100644
--- a/src/tint/lang/wgsl/ast/builtin_texture_helper_test.h
+++ b/src/tint/lang/wgsl/ast/builtin_texture_helper_test.h
@@ -192,8 +192,8 @@
     TextureOverloadCase(ValidTextureOverload,
                         const char*,
                         TextureKind,
-                        type::SamplerKind,
-                        type::TextureDimension,
+                        core::type::SamplerKind,
+                        core::type::TextureDimension,
                         TextureDataType,
                         const char*,
                         std::function<Args(ProgramBuilder*)>,
@@ -202,7 +202,7 @@
     TextureOverloadCase(ValidTextureOverload,
                         const char*,
                         TextureKind,
-                        type::TextureDimension,
+                        core::type::TextureDimension,
                         TextureDataType,
                         const char*,
                         std::function<Args(ProgramBuilder*)>,
@@ -212,7 +212,7 @@
                         const char*,
                         tint::core::Access,
                         tint::core::TexelFormat,
-                        type::TextureDimension,
+                        core::type::TextureDimension,
                         TextureDataType,
                         const char*,
                         std::function<Args(ProgramBuilder*)>,
@@ -247,7 +247,7 @@
     const TextureKind texture_kind;
     /// The sampler kind for the sampler parameter
     /// Used only when texture_kind is not kStorage
-    type::SamplerKind const sampler_kind = type::SamplerKind::kSampler;
+    core::type::SamplerKind const sampler_kind = core::type::SamplerKind::kSampler;
     /// The access control for the storage texture
     /// Used only when texture_kind is kStorage
     tint::core::Access const access = tint::core::Access::kReadWrite;
@@ -255,7 +255,7 @@
     /// Used only when texture_kind is kStorage
     tint::core::TexelFormat const texel_format = tint::core::TexelFormat::kUndefined;
     /// The dimensions of the texture parameter
-    type::TextureDimension const texture_dimension;
+    core::type::TextureDimension const texture_dimension;
     /// The data type of the texture parameter
     const TextureDataType texture_data_type;
     /// Name of the function. e.g. `textureSample`, `textureSampleGrad`, etc
diff --git a/src/tint/lang/wgsl/ast/module_clone_test.cc b/src/tint/lang/wgsl/ast/module_clone_test.cc
index 5d9a7ab..9e3c7f9 100644
--- a/src/tint/lang/wgsl/ast/module_clone_test.cc
+++ b/src/tint/lang/wgsl/ast/module_clone_test.cc
@@ -139,7 +139,7 @@
     for (auto* src_node : src.ASTNodes().Objects()) {
         src_nodes.emplace(src_node);
     }
-    std::unordered_set<const type::Type*> src_types;
+    std::unordered_set<const core::type::Type*> src_types;
     for (auto* src_type : src.Types()) {
         src_types.emplace(src_type);
     }
diff --git a/src/tint/lang/wgsl/ast/transform/add_block_attribute.cc b/src/tint/lang/wgsl/ast/transform/add_block_attribute.cc
index 6b7399a..e9ad3ef 100644
--- a/src/tint/lang/wgsl/ast/transform/add_block_attribute.cc
+++ b/src/tint/lang/wgsl/ast/transform/add_block_attribute.cc
@@ -43,7 +43,7 @@
 
     // A map from a type in the source program to a block-decorated wrapper that contains it in the
     // destination program.
-    Hashmap<const type::Type*, const Struct*, 8> wrapper_structs;
+    Hashmap<const core::type::Type*, const Struct*, 8> wrapper_structs;
 
     // Process global 'var' declarations that are buffers.
     bool made_changes = false;
diff --git a/src/tint/lang/wgsl/ast/transform/array_length_from_uniform.cc b/src/tint/lang/wgsl/ast/transform/array_length_from_uniform.cc
index 20be913..edf28d0 100644
--- a/src/tint/lang/wgsl/ast/transform/array_length_from_uniform.cc
+++ b/src/tint/lang/wgsl/ast/transform/array_length_from_uniform.cc
@@ -148,14 +148,14 @@
             //                             array_stride
             const Expression* total_size = total_storage_buffer_size;
             auto* storage_buffer_type = storage_buffer_sem->Type()->UnwrapRef();
-            const type::Array* array_type = nullptr;
-            if (auto* str = storage_buffer_type->As<type::Struct>()) {
+            const core::type::Array* array_type = nullptr;
+            if (auto* str = storage_buffer_type->As<core::type::Struct>()) {
                 // The variable is a struct, so subtract the byte offset of the array
                 // member.
                 auto* array_member_sem = str->Members().Back();
-                array_type = array_member_sem->Type()->As<type::Array>();
+                array_type = array_member_sem->Type()->As<core::type::Array>();
                 total_size = b.Sub(total_storage_buffer_size, u32(array_member_sem->Offset()));
-            } else if (auto* arr = storage_buffer_type->As<type::Array>()) {
+            } else if (auto* arr = storage_buffer_type->As<core::type::Array>()) {
                 array_type = arr;
             } else {
                 TINT_ICE() << "expected form of arrayLength argument to be &array_var or "
diff --git a/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc b/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc
index 63716fa..38605ac 100644
--- a/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc
+++ b/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc
@@ -40,7 +40,8 @@
 namespace tint::ast::transform {
 
 /// BinaryOpSignature is tuple of a binary op, LHS type and RHS type
-using BinaryOpSignature = std::tuple<core::BinaryOp, const type::Type*, const type::Type*>;
+using BinaryOpSignature =
+    std::tuple<core::BinaryOp, const core::type::Type*, const core::type::Type*>;
 
 /// PIMPL state for the transform
 struct BuiltinPolyfill::State {
@@ -117,7 +118,7 @@
                 [&](const Expression* expr) {
                     if (cfg.builtins.bgra8unorm) {
                         if (auto* ty_expr = src->Sem().Get<sem::TypeExpression>(expr)) {
-                            if (auto* tex = ty_expr->Type()->As<type::StorageTexture>()) {
+                            if (auto* tex = ty_expr->Type()->As<core::type::StorageTexture>()) {
                                 if (tex->texel_format() == core::TexelFormat::kBgra8Unorm) {
                                     ctx.Replace(expr, [this, tex] {
                                         return ctx.dst->Expr(ctx.dst->ty.storage_texture(
@@ -156,7 +157,7 @@
     /// Polyfill builtins.
     Hashmap<const sem::Builtin*, Symbol, 8> builtin_polyfills;
     /// Polyfill f32 conversion to i32 or u32 (or vectors of)
-    Hashmap<const type::Type*, Symbol, 2> f32_conv_polyfills;
+    Hashmap<const core::type::Type*, Symbol, 2> f32_conv_polyfills;
     // Tracks whether the chromium_experimental_full_ptr_parameters extension has been enabled.
     bool has_full_ptr_params = false;
     /// True if the transform has made changes (i.e. the program needs cloning)
@@ -169,7 +170,7 @@
     /// Builds the polyfill function for the `acosh` builtin
     /// @param ty the parameter and return type for the function
     /// @return the polyfill function name
-    Symbol acosh(const type::Type* ty) {
+    Symbol acosh(const core::type::Type* ty) {
         auto name = b.Symbols().New("tint_acosh");
         uint32_t width = WidthOf(ty);
 
@@ -207,7 +208,7 @@
     /// Builds the polyfill function for the `asinh` builtin
     /// @param ty the parameter and return type for the function
     /// @return the polyfill function name
-    Symbol asinh(const type::Type* ty) {
+    Symbol asinh(const core::type::Type* ty) {
         auto name = b.Symbols().New("tint_sinh");
 
         // return log(x + sqrt(x*x + 1));
@@ -222,7 +223,7 @@
     /// Builds the polyfill function for the `atanh` builtin
     /// @param ty the parameter and return type for the function
     /// @return the polyfill function name
-    Symbol atanh(const type::Type* ty) {
+    Symbol atanh(const core::type::Type* ty) {
         auto name = b.Symbols().New("tint_atanh");
         uint32_t width = WidthOf(ty);
 
@@ -260,7 +261,7 @@
     /// (scalar or vector)
     /// @param ty the parameter and return type for the function
     /// @return the polyfill function name
-    Symbol clampInteger(const type::Type* ty) {
+    Symbol clampInteger(const core::type::Type* ty) {
         auto name = b.Symbols().New("tint_clamp");
 
         b.Func(name,
@@ -280,7 +281,7 @@
     /// Builds the polyfill function for the `countLeadingZeros` builtin
     /// @param ty the parameter and return type for the function
     /// @return the polyfill function name
-    Symbol countLeadingZeros(const type::Type* ty) {
+    Symbol countLeadingZeros(const core::type::Type* ty) {
         auto name = b.Symbols().New("tint_count_leading_zeros");
         uint32_t width = WidthOf(ty);
 
@@ -338,7 +339,7 @@
     /// Builds the polyfill function for the `countTrailingZeros` builtin
     /// @param ty the parameter and return type for the function
     /// @return the polyfill function name
-    Symbol countTrailingZeros(const type::Type* ty) {
+    Symbol countTrailingZeros(const core::type::Type* ty) {
         auto name = b.Symbols().New("tint_count_trailing_zeros");
         uint32_t width = WidthOf(ty);
 
@@ -397,7 +398,7 @@
     /// Builds the polyfill function for the `extractBits` builtin
     /// @param ty the parameter and return type for the function
     /// @return the polyfill function name
-    Symbol extractBits(const type::Type* ty) {
+    Symbol extractBits(const core::type::Type* ty) {
         auto name = b.Symbols().New("tint_extract_bits");
         uint32_t width = WidthOf(ty);
 
@@ -455,7 +456,7 @@
     /// Builds the polyfill function for the `firstLeadingBit` builtin
     /// @param ty the parameter and return type for the function
     /// @return the polyfill function name
-    Symbol firstLeadingBit(const type::Type* ty) {
+    Symbol firstLeadingBit(const core::type::Type* ty) {
         auto name = b.Symbols().New("tint_first_leading_bit");
         uint32_t width = WidthOf(ty);
 
@@ -527,7 +528,7 @@
     /// Builds the polyfill function for the `firstTrailingBit` builtin
     /// @param ty the parameter and return type for the function
     /// @return the polyfill function name
-    Symbol firstTrailingBit(const type::Type* ty) {
+    Symbol firstTrailingBit(const core::type::Type* ty) {
         auto name = b.Symbols().New("tint_first_trailing_bit");
         uint32_t width = WidthOf(ty);
 
@@ -586,12 +587,12 @@
     /// Builds the polyfill function for the `insertBits` builtin
     /// @param ty the parameter and return type for the function
     /// @return the polyfill function name
-    Symbol insertBits(const type::Type* ty) {
+    Symbol insertBits(const core::type::Type* ty) {
         auto name = b.Symbols().New("tint_insert_bits");
         uint32_t width = WidthOf(ty);
 
         // Currently in WGSL parameters of insertBits must be i32, u32, vecN<i32> or vecN<u32>
-        if (TINT_UNLIKELY(((!ty->DeepestElement()->IsAnyOf<type::I32, type::U32>())))) {
+        if (TINT_UNLIKELY(((!ty->DeepestElement()->IsAnyOf<core::type::I32, core::type::U32>())))) {
             TINT_ICE()
                 << "insertBits polyfill only support i32, u32, and vector of i32 or u32, got "
                 << ty->FriendlyName();
@@ -605,7 +606,7 @@
             if (!ty->is_unsigned_integer_scalar_or_vector()) {
                 expr = b.Call<i32>(expr);
             }
-            if (ty->Is<type::Vector>()) {
+            if (ty->Is<core::type::Vector>()) {
                 expr = b.Call(T(ty), expr);
             }
             return expr;
@@ -694,7 +695,7 @@
     /// Builds the polyfill function for the `reflect` builtin
     /// @param ty the parameter and return type for the function
     /// @return the polyfill function name
-    Symbol reflect(const type::Type* ty) {
+    Symbol reflect(const core::type::Type* ty) {
         auto name = b.Symbols().New("tint_reflect");
 
         // WGSL polyfill function:
@@ -721,7 +722,7 @@
     /// Builds the polyfill function for the `saturate` builtin
     /// @param ty the parameter and return type for the function
     /// @return the polyfill function name
-    Symbol saturate(const type::Type* ty) {
+    Symbol saturate(const core::type::Type* ty) {
         auto name = b.Symbols().New("tint_saturate");
         auto body = tint::Vector{
             b.Return(b.Call("clamp", "v", b.Call(T(ty), 0_a), b.Call(T(ty), 1_a))),
@@ -738,7 +739,7 @@
     /// Builds the polyfill function for the `sign` builtin when the element type is integer
     /// @param ty the parameter and return type for the function
     /// @return the polyfill function name
-    Symbol sign_int(const type::Type* ty) {
+    Symbol sign_int(const core::type::Type* ty) {
         const uint32_t width = WidthOf(ty);
         auto zero = [&] { return ScalarOrVector(width, 0_a); };
 
@@ -773,13 +774,14 @@
                 b.Let("clamped", b.Call("clamp", "coord", "half_texel", b.Sub(1_a, "half_texel")))),
             b.Return(b.Call("textureSampleLevel", "t", "s", "clamped", 0_a)),
         };
-        b.Func(name,
-               tint::Vector{
-                   b.Param("t", b.ty.sampled_texture(type::TextureDimension::k2d, b.ty.f32())),
-                   b.Param("s", b.ty.sampler(type::SamplerKind::kSampler)),
-                   b.Param("coord", b.ty.vec2<f32>()),
-               },
-               b.ty.vec4<f32>(), body);
+        b.Func(
+            name,
+            tint::Vector{
+                b.Param("t", b.ty.sampled_texture(core::type::TextureDimension::k2d, b.ty.f32())),
+                b.Param("s", b.ty.sampler(core::type::SamplerKind::kSampler)),
+                b.Param("coord", b.ty.vec2<f32>()),
+            },
+            b.ty.vec4<f32>(), body);
         return name;
     }
 
@@ -787,7 +789,7 @@
     /// with scalar calls.
     /// @param vec the vector type
     /// @return the polyfill function name
-    Symbol quantizeToF16(const type::Vector* vec) {
+    Symbol quantizeToF16(const core::type::Vector* vec) {
         auto name = b.Symbols().New("tint_quantizeToF16");
         tint::Vector<const Expression*, 4> args;
         for (uint32_t i = 0; i < vec->Width(); i++) {
@@ -807,7 +809,7 @@
     /// Builds the polyfill function for the `workgroupUniformLoad` builtin.
     /// @param type the type being loaded
     /// @return the polyfill function name
-    Symbol workgroupUniformLoad(const type::Type* type) {
+    Symbol workgroupUniformLoad(const core::type::Type* type) {
         if (!has_full_ptr_params) {
             b.Enable(core::Extension::kChromiumExperimentalFullPtrParameters);
             has_full_ptr_params = true;
@@ -832,7 +834,7 @@
     /// @param source the type of the value being converted
     /// @param target the target conversion type
     /// @return the polyfill function name
-    Symbol ConvF32ToIU32(const type::Type* source, const type::Type* target) {
+    Symbol ConvF32ToIU32(const core::type::Type* source, const core::type::Type* target) {
         struct Limits {
             AFloat low_condition;
             AInt low_limit;
@@ -886,7 +888,7 @@
         auto* rhs_ty = src->TypeOf(bin_op->rhs)->UnwrapRef();
         auto* lhs_el_ty = lhs_ty->DeepestElement();
         const Expression* mask = b.Expr(AInt(lhs_el_ty->Size() * 8 - 1));
-        if (rhs_ty->Is<type::Vector>()) {
+        if (rhs_ty->Is<core::type::Vector>()) {
             mask = b.Call(CreateASTTypeFor(ctx, rhs_ty), mask);
         }
         auto* lhs = ctx.Clone(bin_op->lhs);
@@ -1039,11 +1041,11 @@
     }
 
     /// @returns the AST type for the given sem type
-    Type T(const type::Type* ty) { return CreateASTTypeFor(ctx, ty); }
+    Type T(const core::type::Type* ty) { return CreateASTTypeFor(ctx, ty); }
 
     /// @returns 1 if `ty` is not a vector, otherwise the vector width
-    uint32_t WidthOf(const type::Type* ty) const {
-        if (auto* v = ty->As<type::Vector>()) {
+    uint32_t WidthOf(const core::type::Type* ty) const {
+        if (auto* v = ty->As<core::type::Vector>()) {
             return v->Width();
         }
         return 1;
@@ -1156,8 +1158,8 @@
                         // more details.
                         if (cfg.builtins.reflect_vec2_f32) {
                             auto& sig = builtin->Signature();
-                            auto* vec = sig.return_type->As<type::Vector>();
-                            if (vec && vec->Width() == 2 && vec->type()->Is<type::F32>()) {
+                            auto* vec = sig.return_type->As<core::type::Vector>();
+                            if (vec && vec->Width() == 2 && vec->type()->Is<core::type::F32>()) {
                                 return builtin_polyfills.GetOrCreate(
                                     builtin, [&] { return reflect(builtin->ReturnType()); });
                             }
@@ -1185,8 +1187,8 @@
                         if (cfg.builtins.texture_sample_base_clamp_to_edge_2d_f32) {
                             auto& sig = builtin->Signature();
                             auto* tex = sig.Parameter(core::ParameterUsage::kTexture);
-                            if (auto* stex = tex->Type()->As<type::SampledTexture>()) {
-                                if (stex->type()->Is<type::F32>()) {
+                            if (auto* stex = tex->Type()->As<core::type::SampledTexture>()) {
+                                if (stex->type()->Is<core::type::F32>()) {
                                     return builtin_polyfills.GetOrCreate(builtin, [&] {
                                         return textureSampleBaseClampToEdge_2d_f32();
                                     });
@@ -1199,7 +1201,7 @@
                         if (cfg.builtins.bgra8unorm) {
                             auto& sig = builtin->Signature();
                             auto* tex = sig.Parameter(core::ParameterUsage::kTexture);
-                            if (auto* stex = tex->Type()->As<type::StorageTexture>()) {
+                            if (auto* stex = tex->Type()->As<core::type::StorageTexture>()) {
                                 if (stex->texel_format() == core::TexelFormat::kBgra8Unorm) {
                                     size_t value_idx = static_cast<size_t>(
                                         sig.IndexOf(core::ParameterUsage::kValue));
@@ -1224,7 +1226,7 @@
 
                     case core::Function::kQuantizeToF16:
                         if (cfg.builtins.quantize_to_vec_f16) {
-                            if (auto* vec = builtin->ReturnType()->As<type::Vector>()) {
+                            if (auto* vec = builtin->ReturnType()->As<core::type::Vector>()) {
                                 return builtin_polyfills.GetOrCreate(
                                     builtin, [&] { return quantizeToF16(vec); });
                             }
@@ -1246,9 +1248,10 @@
             [&](const sem::ValueConversion* conv) {
                 if (cfg.builtins.conv_f32_to_iu32) {
                     auto* src_ty = conv->Source();
-                    if (tint::Is<type::F32>(src_ty->Elements(src_ty).type)) {
+                    if (tint::Is<core::type::F32>(src_ty->Elements(src_ty).type)) {
                         auto* dst_ty = conv->Target();
-                        if (tint::IsAnyOf<type::I32, type::U32>(dst_ty->Elements(dst_ty).type)) {
+                        if (tint::IsAnyOf<core::type::I32, core::type::U32>(
+                                dst_ty->Elements(dst_ty).type)) {
                             return f32_conv_polyfills.GetOrCreate(dst_ty, [&] {  //
                                 return ConvF32ToIU32(src_ty, dst_ty);
                             });
diff --git a/src/tint/lang/wgsl/ast/transform/calculate_array_length.cc b/src/tint/lang/wgsl/ast/transform/calculate_array_length.cc
index 82fa160..2def1be 100644
--- a/src/tint/lang/wgsl/ast/transform/calculate_array_length.cc
+++ b/src/tint/lang/wgsl/ast/transform/calculate_array_length.cc
@@ -101,8 +101,8 @@
     // get_buffer_size_intrinsic() emits the function decorated with
     // BufferSizeIntrinsic that is transformed by the HLSL writer into a call to
     // [RW]ByteAddressBuffer.GetDimensions().
-    std::unordered_map<const type::Reference*, Symbol> buffer_size_intrinsics;
-    auto get_buffer_size_intrinsic = [&](const type::Reference* buffer_type) {
+    std::unordered_map<const core::type::Reference*, Symbol> buffer_size_intrinsics;
+    auto get_buffer_size_intrinsic = [&](const core::type::Reference* buffer_type) {
         return tint::GetOrCreate(buffer_size_intrinsics, buffer_type, [&] {
             auto name = b.Sym();
             auto type = CreateASTTypeFor(ctx, buffer_type);
@@ -166,7 +166,8 @@
                         break;
                     }
                     auto* storage_buffer_var = storage_buffer_sem->Variable();
-                    auto* storage_buffer_type = storage_buffer_sem->Type()->As<type::Reference>();
+                    auto* storage_buffer_type =
+                        storage_buffer_sem->Type()->As<core::type::Reference>();
 
                     // Generate BufferSizeIntrinsic for this storage type if we haven't already
                     auto buffer_size = get_buffer_size_intrinsic(storage_buffer_type);
@@ -199,16 +200,16 @@
                             auto name = b.Sym();
                             const Expression* total_size = b.Expr(buffer_size_result->variable);
 
-                            const type::Array* array_type = Switch(
+                            const core::type::Array* array_type = Switch(
                                 storage_buffer_type->StoreType(),
-                                [&](const type::Struct* str) {
+                                [&](const core::type::Struct* str) {
                                     // The variable is a struct, so subtract the byte offset of
                                     // the array member.
                                     auto* array_member_sem = str->Members().Back();
                                     total_size = b.Sub(total_size, u32(array_member_sem->Offset()));
-                                    return array_member_sem->Type()->As<type::Array>();
+                                    return array_member_sem->Type()->As<core::type::Array>();
                                 },
-                                [&](const type::Array* arr) { return arr; });
+                                [&](const core::type::Array* arr) { return arr; });
 
                             if (TINT_UNLIKELY(!array_type)) {
                                 TINT_ICE() << "expected form of arrayLength argument to be "
diff --git a/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc
index 0460997..838e871 100644
--- a/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc
+++ b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc
@@ -272,7 +272,7 @@
     /// @param attrs the attributes to apply to the shader input
     /// @returns an expression which evaluates to the value of the shader input
     const Expression* AddInput(std::string name,
-                               const type::Type* type,
+                               const core::type::Type* type,
                                std::optional<uint32_t> location,
                                tint::Vector<const Attribute*, 8> attrs) {
         auto ast_type = CreateASTTypeFor(ctx, type);
@@ -346,7 +346,7 @@
     /// @param attrs the attributes to apply to the shader output
     /// @param value the value of the shader output
     void AddOutput(std::string name,
-                   const type::Type* type,
+                   const core::type::Type* type,
                    std::optional<uint32_t> location,
                    std::optional<uint32_t> index,
                    tint::Vector<const Attribute*, 8> attrs,
@@ -432,7 +432,7 @@
         // list to pass them through to the inner function.
         tint::Vector<const Expression*, 8> inner_struct_values;
         for (auto* member : str->Members()) {
-            if (TINT_UNLIKELY(member->Type()->Is<type::Struct>())) {
+            if (TINT_UNLIKELY(member->Type()->Is<core::type::Struct>())) {
                 TINT_ICE() << "nested IO struct";
                 continue;
             }
@@ -461,12 +461,12 @@
     /// function.
     /// @param inner_ret_type the original function return type
     /// @param original_result the result object produced by the original function
-    void ProcessReturnType(const type::Type* inner_ret_type, Symbol original_result) {
+    void ProcessReturnType(const core::type::Type* inner_ret_type, Symbol original_result) {
         // Do not add interpolation attributes on fragment output
         bool do_interpolate = func_ast->PipelineStage() != PipelineStage::kFragment;
         if (auto* str = inner_ret_type->As<sem::Struct>()) {
             for (auto* member : str->Members()) {
-                if (TINT_UNLIKELY(member->Type()->Is<type::Struct>())) {
+                if (TINT_UNLIKELY(member->Type()->Is<core::type::Struct>())) {
                     TINT_ICE() << "nested IO struct";
                     continue;
                 }
@@ -480,7 +480,7 @@
                           member->Attributes().index, std::move(attributes),
                           b.MemberAccessor(original_result, name));
             }
-        } else if (!inner_ret_type->Is<type::Void>()) {
+        } else if (!inner_ret_type->Is<core::type::Void>()) {
             auto attributes =
                 CloneShaderIOAttributes(func_ast->return_type_attributes, do_interpolate);
 
@@ -507,8 +507,8 @@
         // sample mask.
         auto* builtin = b.Builtin(core::BuiltinValue::kSampleMask);
         builtin_attrs.Add(builtin, core::BuiltinValue::kSampleMask);
-        AddOutput("fixed_sample_mask", b.create<type::U32>(), std::nullopt, std::nullopt, {builtin},
-                  b.Expr(u32(cfg.fixed_sample_mask)));
+        AddOutput("fixed_sample_mask", b.create<core::type::U32>(), std::nullopt, std::nullopt,
+                  {builtin}, b.Expr(u32(cfg.fixed_sample_mask)));
     }
 
     /// Add a point size builtin to the wrapper function output.
@@ -516,8 +516,8 @@
         // Create a new output value and assign it a literal 1.0 value.
         auto* builtin = b.Builtin(core::BuiltinValue::kPointSize);
         builtin_attrs.Add(builtin, core::BuiltinValue::kPointSize);
-        AddOutput("vertex_point_size", b.create<type::F32>(), std::nullopt, std::nullopt, {builtin},
-                  b.Expr(1_f));
+        AddOutput("vertex_point_size", b.create<core::type::F32>(), std::nullopt, std::nullopt,
+                  {builtin}, b.Expr(1_f));
     }
 
     /// Create an expression for gl_Position.[component]
@@ -690,9 +690,9 @@
         }
 
         // Exit early if there is no shader IO to handle.
-        if (func_sem->Parameters().Length() == 0 && func_sem->ReturnType()->Is<type::Void>() &&
-            !needs_fixed_sample_mask && !needs_vertex_point_size &&
-            cfg.shader_style != ShaderStyle::kGlsl) {
+        if (func_sem->Parameters().Length() == 0 &&
+            func_sem->ReturnType()->Is<core::type::Void>() && !needs_fixed_sample_mask &&
+            !needs_vertex_point_size && cfg.shader_style != ShaderStyle::kGlsl) {
             return;
         }
 
@@ -700,7 +700,7 @@
         // aggregated into a single structure.
         if (!func_sem->Parameters().IsEmpty()) {
             for (auto* param : func_sem->Parameters()) {
-                if (param->Type()->Is<type::Struct>()) {
+                if (param->Type()->Is<core::type::Struct>()) {
                     ProcessStructParameter(param);
                 } else {
                     ProcessNonStructParameter(param);
@@ -718,7 +718,7 @@
 
         // Process the return type, and start building the wrapper function body.
         std::function<Type()> wrapper_ret_type = [&] { return b.ty.void_(); };
-        if (func_sem->ReturnType()->Is<type::Void>()) {
+        if (func_sem->ReturnType()->Is<core::type::Void>()) {
             // The function call is just a statement with no result.
             wrapper_body.Push(b.CallStmt(call_inner));
         } else {
@@ -866,13 +866,13 @@
     /// @returns the converted value which can be assigned to the GLSL builtin
     const Expression* ToGLSLBuiltin(core::BuiltinValue builtin,
                                     const Expression* value,
-                                    const type::Type*& type) {
+                                    const core::type::Type*& type) {
         switch (builtin) {
             case core::BuiltinValue::kVertexIndex:
             case core::BuiltinValue::kInstanceIndex:
             case core::BuiltinValue::kSampleIndex:
             case core::BuiltinValue::kSampleMask:
-                type = b.create<type::I32>();
+                type = b.create<core::type::I32>();
                 value = b.Bitcast(CreateASTTypeFor(ctx, type), value);
                 break;
             default:
diff --git a/src/tint/lang/wgsl/ast/transform/combine_samplers.cc b/src/tint/lang/wgsl/ast/transform/combine_samplers.cc
index 404f872..5313b7a 100644
--- a/src/tint/lang/wgsl/ast/transform/combine_samplers.cc
+++ b/src/tint/lang/wgsl/ast/transform/combine_samplers.cc
@@ -120,9 +120,9 @@
     /// Creates placeholder global sampler variables.
     /// @param kind the sampler kind to create for
     /// @returns the newly-created global variable
-    const Variable* CreatePlaceholder(type::SamplerKind kind) {
+    const Variable* CreatePlaceholder(core::type::SamplerKind kind) {
         Type type = ctx.dst->ty.sampler(kind);
-        const char* name = kind == type::SamplerKind::kComparisonSampler
+        const char* name = kind == core::type::SamplerKind::kComparisonSampler
                                ? "placeholder_comparison_sampler"
                                : "placeholder_sampler";
         Symbol symbol = ctx.dst->Symbols().New(name);
@@ -136,8 +136,8 @@
     /// @param sampler the texture variable of interest
     /// @returns the newly-created type
     Type CreateCombinedASTTypeFor(const sem::Variable* texture, const sem::Variable* sampler) {
-        const type::Type* texture_type = texture->Type()->UnwrapRef();
-        const type::DepthTexture* depth = texture_type->As<type::DepthTexture>();
+        const core::type::Type* texture_type = texture->Type()->UnwrapRef();
+        const core::type::DepthTexture* depth = texture_type->As<core::type::DepthTexture>();
         if (depth && !sampler) {
             return ctx.dst->ty.sampled_texture(depth->dim(), ctx.dst->ty.f32());
         } else {
@@ -155,8 +155,8 @@
         for (auto* global : ctx.src->AST().GlobalVariables()) {
             auto* global_sem = sem.Get(global)->As<sem::GlobalVariable>();
             auto* type = ctx.src->TypeOf(global->type);
-            if (tint::IsAnyOf<type::Texture, type::Sampler>(type) &&
-                !type->Is<type::StorageTexture>()) {
+            if (tint::IsAnyOf<core::type::Texture, core::type::Sampler>(type) &&
+                !type->Is<core::type::StorageTexture>()) {
                 ctx.Remove(ctx.src->AST().GlobalDeclarations(), global);
             } else if (auto binding_point = global_sem->BindingPoint()) {
                 if (binding_point->group == 0 && binding_point->binding == 0) {
@@ -200,7 +200,7 @@
                 // Filter out separate textures and samplers from the original
                 // function signature.
                 for (auto* param : fn->Parameters()) {
-                    if (!param->Type()->IsAnyOf<type::Texture, type::Sampler>()) {
+                    if (!param->Type()->IsAnyOf<core::type::Texture, core::type::Sampler>()) {
                         params.Push(ctx.Clone(param->Declaration()));
                     }
                 }
@@ -236,7 +236,7 @@
                         call->Arguments()[static_cast<size_t>(texture_index)];
                     // We don't want to combine storage textures with anything, since
                     // they never have associated samplers in GLSL.
-                    if (texture->Type()->UnwrapRef()->Is<type::StorageTexture>()) {
+                    if (texture->Type()->UnwrapRef()->Is<core::type::StorageTexture>()) {
                         return nullptr;
                     }
                     const sem::ValueExpression* sampler =
@@ -249,16 +249,16 @@
                     sem::VariablePair new_pair(texture_var, sampler_var);
                     for (auto* arg : expr->args) {
                         auto* type = ctx.src->TypeOf(arg)->UnwrapRef();
-                        if (type->Is<type::Texture>()) {
+                        if (type->Is<core::type::Texture>()) {
                             const Variable* var =
                                 IsGlobal(new_pair)
                                     ? global_combined_texture_samplers_[new_pair]
                                     : function_combined_texture_samplers_[call->Stmt()->Function()]
                                                                          [new_pair];
                             args.Push(ctx.dst->Expr(var->name->symbol));
-                        } else if (auto* sampler_type = type->As<type::Sampler>()) {
-                            type::SamplerKind kind = sampler_type->kind();
-                            int index = (kind == type::SamplerKind::kSampler) ? 0 : 1;
+                        } else if (auto* sampler_type = type->As<core::type::Sampler>()) {
+                            core::type::SamplerKind kind = sampler_type->kind();
+                            int index = (kind == core::type::SamplerKind::kSampler) ? 0 : 1;
                             const Variable*& p = placeholder_samplers_[index];
                             if (!p) {
                                 p = CreatePlaceholder(kind);
@@ -270,7 +270,7 @@
                     }
                     const Expression* value = ctx.dst->Call(ctx.Clone(expr->target), args);
                     if (builtin->Type() == core::Function::kTextureLoad &&
-                        texture_var->Type()->UnwrapRef()->Is<type::DepthTexture>() &&
+                        texture_var->Type()->UnwrapRef()->Is<core::type::DepthTexture>() &&
                         !call->Stmt()->Declaration()->Is<CallStatement>()) {
                         value = ctx.dst->MemberAccessor(value, "x");
                     }
@@ -316,7 +316,7 @@
                     for (auto* arg : expr->args) {
                         if (!ctx.src->TypeOf(arg)
                                  ->UnwrapRef()
-                                 ->IsAnyOf<type::Texture, type::Sampler>()) {
+                                 ->IsAnyOf<core::type::Texture, core::type::Sampler>()) {
                             args.Push(ctx.Clone(arg));
                         }
                     }
diff --git a/src/tint/lang/wgsl/ast/transform/decompose_memory_access.cc b/src/tint/lang/wgsl/ast/transform/decompose_memory_access.cc
index aea0162..68e4b8a 100644
--- a/src/tint/lang/wgsl/ast/transform/decompose_memory_access.cc
+++ b/src/tint/lang/wgsl/ast/transform/decompose_memory_access.cc
@@ -79,7 +79,7 @@
     const Expression* Build(program::CloneContext& ctx) const override {
         auto* type = ctx.src->Sem().GetVal(expr)->Type()->UnwrapRef();
         auto* res = ctx.Clone(expr);
-        if (!type->Is<type::U32>()) {
+        if (!type->Is<core::type::U32>()) {
             res = ctx.dst->Call<u32>(res);
         }
         return res;
@@ -112,7 +112,7 @@
 
 /// LoadStoreKey is the unordered map key to a load or store intrinsic.
 struct LoadStoreKey {
-    type::Type const* el_ty = nullptr;  // element type
+    core::type::Type const* el_ty = nullptr;  // element type
     Symbol const buffer;                // buffer name
     bool operator==(const LoadStoreKey& rhs) const {
         return el_ty == rhs.el_ty && buffer == rhs.buffer;
@@ -126,7 +126,7 @@
 
 /// AtomicKey is the unordered map key to an atomic intrinsic.
 struct AtomicKey {
-    type::Type const* el_ty = nullptr;  // element type
+    core::type::Type const* el_ty = nullptr;  // element type
     core::Function const op;            // atomic op
     Symbol const buffer;                // buffer name
     bool operator==(const AtomicKey& rhs) const {
@@ -139,75 +139,76 @@
     };
 };
 
-bool IntrinsicDataTypeFor(const type::Type* ty, DecomposeMemoryAccess::Intrinsic::DataType& out) {
-    if (ty->Is<type::I32>()) {
+bool IntrinsicDataTypeFor(const core::type::Type* ty,
+                          DecomposeMemoryAccess::Intrinsic::DataType& out) {
+    if (ty->Is<core::type::I32>()) {
         out = DecomposeMemoryAccess::Intrinsic::DataType::kI32;
         return true;
     }
-    if (ty->Is<type::U32>()) {
+    if (ty->Is<core::type::U32>()) {
         out = DecomposeMemoryAccess::Intrinsic::DataType::kU32;
         return true;
     }
-    if (ty->Is<type::F32>()) {
+    if (ty->Is<core::type::F32>()) {
         out = DecomposeMemoryAccess::Intrinsic::DataType::kF32;
         return true;
     }
-    if (ty->Is<type::F16>()) {
+    if (ty->Is<core::type::F16>()) {
         out = DecomposeMemoryAccess::Intrinsic::DataType::kF16;
         return true;
     }
-    if (auto* vec = ty->As<type::Vector>()) {
+    if (auto* vec = ty->As<core::type::Vector>()) {
         switch (vec->Width()) {
             case 2:
-                if (vec->type()->Is<type::I32>()) {
+                if (vec->type()->Is<core::type::I32>()) {
                     out = DecomposeMemoryAccess::Intrinsic::DataType::kVec2I32;
                     return true;
                 }
-                if (vec->type()->Is<type::U32>()) {
+                if (vec->type()->Is<core::type::U32>()) {
                     out = DecomposeMemoryAccess::Intrinsic::DataType::kVec2U32;
                     return true;
                 }
-                if (vec->type()->Is<type::F32>()) {
+                if (vec->type()->Is<core::type::F32>()) {
                     out = DecomposeMemoryAccess::Intrinsic::DataType::kVec2F32;
                     return true;
                 }
-                if (vec->type()->Is<type::F16>()) {
+                if (vec->type()->Is<core::type::F16>()) {
                     out = DecomposeMemoryAccess::Intrinsic::DataType::kVec2F16;
                     return true;
                 }
                 break;
             case 3:
-                if (vec->type()->Is<type::I32>()) {
+                if (vec->type()->Is<core::type::I32>()) {
                     out = DecomposeMemoryAccess::Intrinsic::DataType::kVec3I32;
                     return true;
                 }
-                if (vec->type()->Is<type::U32>()) {
+                if (vec->type()->Is<core::type::U32>()) {
                     out = DecomposeMemoryAccess::Intrinsic::DataType::kVec3U32;
                     return true;
                 }
-                if (vec->type()->Is<type::F32>()) {
+                if (vec->type()->Is<core::type::F32>()) {
                     out = DecomposeMemoryAccess::Intrinsic::DataType::kVec3F32;
                     return true;
                 }
-                if (vec->type()->Is<type::F16>()) {
+                if (vec->type()->Is<core::type::F16>()) {
                     out = DecomposeMemoryAccess::Intrinsic::DataType::kVec3F16;
                     return true;
                 }
                 break;
             case 4:
-                if (vec->type()->Is<type::I32>()) {
+                if (vec->type()->Is<core::type::I32>()) {
                     out = DecomposeMemoryAccess::Intrinsic::DataType::kVec4I32;
                     return true;
                 }
-                if (vec->type()->Is<type::U32>()) {
+                if (vec->type()->Is<core::type::U32>()) {
                     out = DecomposeMemoryAccess::Intrinsic::DataType::kVec4U32;
                     return true;
                 }
-                if (vec->type()->Is<type::F32>()) {
+                if (vec->type()->Is<core::type::F32>()) {
                     out = DecomposeMemoryAccess::Intrinsic::DataType::kVec4F32;
                     return true;
                 }
-                if (vec->type()->Is<type::F16>()) {
+                if (vec->type()->Is<core::type::F16>()) {
                     out = DecomposeMemoryAccess::Intrinsic::DataType::kVec4F16;
                     return true;
                 }
@@ -222,7 +223,7 @@
 /// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied to a stub function to
 /// load the type @p ty from the uniform or storage buffer with name @p buffer.
 DecomposeMemoryAccess::Intrinsic* IntrinsicLoadFor(ast::Builder* builder,
-                                                   const type::Type* ty,
+                                                   const core::type::Type* ty,
                                                    core::AddressSpace address_space,
                                                    const Symbol& buffer) {
     DecomposeMemoryAccess::Intrinsic::DataType type;
@@ -237,7 +238,7 @@
 /// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied to a stub function to
 /// store the type @p ty to the storage buffer with name @p buffer.
 DecomposeMemoryAccess::Intrinsic* IntrinsicStoreFor(ast::Builder* builder,
-                                                    const type::Type* ty,
+                                                    const core::type::Type* ty,
                                                     const Symbol& buffer) {
     DecomposeMemoryAccess::Intrinsic::DataType type;
     if (!IntrinsicDataTypeFor(ty, type)) {
@@ -252,7 +253,7 @@
 /// the atomic op and the type @p ty.
 DecomposeMemoryAccess::Intrinsic* IntrinsicAtomicFor(ast::Builder* builder,
                                                      core::Function ity,
-                                                     const type::Type* ty,
+                                                     const core::type::Type* ty,
                                                      const Symbol& buffer) {
     auto op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicLoad;
     switch (ity) {
@@ -308,7 +309,7 @@
 struct BufferAccess {
     sem::GlobalVariable const* var = nullptr;  // Storage or uniform buffer variable
     Offset const* offset = nullptr;            // The byte offset on var
-    type::Type const* type = nullptr;          // The type of the access
+    core::type::Type const* type = nullptr;    // The type of the access
     operator bool() const { return var; }      // Returns true if valid
 };
 
@@ -463,7 +464,7 @@
     /// @param buffer the symbol of the storage or uniform buffer variable, owned by the target
     /// ProgramBuilder.
     /// @return the name of the function that performs the load
-    Symbol LoadFunc(const type::Type* el_ty,
+    Symbol LoadFunc(const core::type::Type* el_ty,
                     core::AddressSpace address_space,
                     const Symbol& buffer) {
         return tint::GetOrCreate(load_funcs, LoadStoreKey{el_ty, buffer}, [&] {
@@ -478,7 +479,7 @@
                            intrinsic,
                            b.Disable(DisabledValidation::kFunctionHasNoBody),
                        });
-            } else if (auto* arr_ty = el_ty->As<type::Array>()) {
+            } else if (auto* arr_ty = el_ty->As<core::type::Array>()) {
                 // fn load_func(buffer : buf_ty, offset : u32) -> array<T, N> {
                 //   var arr : array<T, N>;
                 //   for (var i = 0u; i < array_count; i = i + 1) {
@@ -516,14 +517,14 @@
                        });
             } else {
                 tint::Vector<const Expression*, 8> values;
-                if (auto* mat_ty = el_ty->As<type::Matrix>()) {
+                if (auto* mat_ty = el_ty->As<core::type::Matrix>()) {
                     auto* vec_ty = mat_ty->ColumnType();
                     Symbol load = LoadFunc(vec_ty, address_space, buffer);
                     for (uint32_t i = 0; i < mat_ty->columns(); i++) {
                         auto* offset = b.Add("offset", u32(i * mat_ty->ColumnStride()));
                         values.Push(b.Call(load, offset));
                     }
-                } else if (auto* str = el_ty->As<type::Struct>()) {
+                } else if (auto* str = el_ty->As<core::type::Struct>()) {
                     for (auto* member : str->Members()) {
                         auto* offset = b.Add("offset", u32(member->Offset()));
                         Symbol load = LoadFunc(member->Type()->UnwrapRef(), address_space, buffer);
@@ -545,7 +546,7 @@
     /// @param el_ty the storage buffer element type
     /// @param buffer the symbol of the storage buffer variable, owned by the target ProgramBuilder.
     /// @return the name of the function that performs the store
-    Symbol StoreFunc(const type::Type* el_ty, const Symbol& buffer) {
+    Symbol StoreFunc(const core::type::Type* el_ty, const Symbol& buffer) {
         return tint::GetOrCreate(store_funcs, LoadStoreKey{el_ty, buffer}, [&] {
             tint::Vector params{
                 b.Param("offset", b.ty.u32()),
@@ -563,7 +564,7 @@
             } else {
                 auto body = Switch<tint::Vector<const Statement*, 8>>(
                     el_ty,  //
-                    [&](const type::Array* arr_ty) {
+                    [&](const core::type::Array* arr_ty) {
                         // fn store_func(buffer : buf_ty, offset : u32, value : el_ty) {
                         //   var array = value; // No dynamic indexing on constant arrays
                         //   for (var i = 0u; i < array_count; i = i + 1) {
@@ -595,7 +596,7 @@
 
                         return tint::Vector{b.Decl(array), for_loop};
                     },
-                    [&](const type::Matrix* mat_ty) {
+                    [&](const core::type::Matrix* mat_ty) {
                         auto* vec_ty = mat_ty->ColumnType();
                         Symbol store = StoreFunc(vec_ty, buffer);
                         tint::Vector<const Statement*, 4> stmts;
@@ -607,7 +608,7 @@
                         }
                         return stmts;
                     },
-                    [&](const type::Struct* str) {
+                    [&](const core::type::Struct* str) {
                         tint::Vector<const Statement*, 8> stmts;
                         for (auto* member : str->Members()) {
                             auto* offset = b.Add("offset", u32(member->Offset()));
@@ -633,7 +634,7 @@
     /// @param intrinsic the atomic intrinsic
     /// @param buffer the symbol of the storage buffer variable, owned by the target ProgramBuilder.
     /// @return the name of the function that performs the load
-    Symbol AtomicFunc(const type::Type* el_ty,
+    Symbol AtomicFunc(const core::type::Type* el_ty,
                       const sem::Builtin* intrinsic,
                       const Symbol& buffer) {
         auto op = intrinsic->Type();
@@ -838,7 +839,7 @@
             if (auto* swizzle = accessor_sem->As<sem::Swizzle>()) {
                 if (swizzle->Indices().Length() == 1) {
                     if (auto access = state.TakeAccess(accessor->object)) {
-                        auto* vec_ty = access.type->As<type::Vector>();
+                        auto* vec_ty = access.type->As<core::type::Vector>();
                         auto* offset = state.Mul(vec_ty->type()->Size(), swizzle->Indices()[0u]);
                         state.AddAccess(accessor, {
                                                       access.var,
@@ -849,7 +850,7 @@
                 }
             } else {
                 if (auto access = state.TakeAccess(accessor->object)) {
-                    auto* str_ty = access.type->As<type::Struct>();
+                    auto* str_ty = access.type->As<core::type::Struct>();
                     auto* member = str_ty->FindMember(accessor->member->symbol);
                     auto offset = member->Offset();
                     state.AddAccess(accessor, {
@@ -865,7 +866,7 @@
         if (auto* accessor = node->As<IndexAccessorExpression>()) {
             if (auto access = state.TakeAccess(accessor->object)) {
                 // X[Y]
-                if (auto* arr = access.type->As<type::Array>()) {
+                if (auto* arr = access.type->As<core::type::Array>()) {
                     auto* offset = state.Mul(arr->Stride(), accessor->index);
                     state.AddAccess(accessor, {
                                                   access.var,
@@ -874,7 +875,7 @@
                                               });
                     continue;
                 }
-                if (auto* vec_ty = access.type->As<type::Vector>()) {
+                if (auto* vec_ty = access.type->As<core::type::Vector>()) {
                     auto* offset = state.Mul(vec_ty->type()->Size(), accessor->index);
                     state.AddAccess(accessor, {
                                                   access.var,
@@ -883,7 +884,7 @@
                                               });
                     continue;
                 }
-                if (auto* mat_ty = access.type->As<type::Matrix>()) {
+                if (auto* mat_ty = access.type->As<core::type::Matrix>()) {
                     auto* offset = state.Mul(mat_ty->ColumnStride(), accessor->index);
                     state.AddAccess(accessor, {
                                                   access.var,
@@ -929,7 +930,8 @@
                         // atomic___(X)
                         ctx.Replace(call_expr, [=, &ctx, &state] {
                             auto* offset = access.offset->Build(ctx);
-                            auto* el_ty = access.type->UnwrapRef()->As<type::Atomic>()->Type();
+                            auto* el_ty =
+                                access.type->UnwrapRef()->As<core::type::Atomic>()->Type();
                             auto buffer = ctx.Clone(access.var->Declaration()->name->symbol);
                             Symbol func = state.AtomicFunc(el_ty, builtin, buffer);
 
diff --git a/src/tint/lang/wgsl/ast/transform/decompose_strided_array.cc b/src/tint/lang/wgsl/ast/transform/decompose_strided_array.cc
index c1de1a4..bf0bd0d 100644
--- a/src/tint/lang/wgsl/ast/transform/decompose_strided_array.cc
+++ b/src/tint/lang/wgsl/ast/transform/decompose_strided_array.cc
@@ -35,7 +35,7 @@
 namespace tint::ast::transform {
 namespace {
 
-using DecomposedArrays = std::unordered_map<const type::Array*, Symbol>;
+using DecomposedArrays = std::unordered_map<const core::type::Array*, Symbol>;
 
 bool ShouldRun(const Program* program) {
     for (auto* node : program->ASTNodes().Objects()) {
@@ -69,7 +69,7 @@
 
     // Maps an array type in the source program to the name of the struct wrapper
     // type in the target program.
-    std::unordered_map<const type::Array*, Symbol> decomposed;
+    std::unordered_map<const core::type::Array*, Symbol> decomposed;
 
     // Find and replace all arrays with a @stride attribute with a array that has
     // the @stride removed. If the source array stride does not match the natural
@@ -85,7 +85,7 @@
         if (!type_expr) {
             return nullptr;
         }
-        auto* arr = type_expr->Type()->As<type::Array>();
+        auto* arr = type_expr->Type()->As<core::type::Array>();
         if (!arr) {
             return nullptr;
         }
@@ -126,7 +126,7 @@
     // Example: `arr[i]` -> `arr[i].el`
     ctx.ReplaceAll([&](const IndexAccessorExpression* idx) -> const Expression* {
         if (auto* ty = src->TypeOf(idx->object)) {
-            if (auto* arr = ty->UnwrapRef()->As<type::Array>()) {
+            if (auto* arr = ty->UnwrapRef()->As<core::type::Array>()) {
                 if (!arr->IsStrideImplicit()) {
                     auto* expr = ctx.CloneWithoutTransform(idx);
                     return b.MemberAccessor(expr, kMemberName);
@@ -146,7 +146,7 @@
         if (!expr->args.IsEmpty()) {
             if (auto* call = sem.Get(expr)->UnwrapMaterialize()->As<sem::Call>()) {
                 if (auto* ctor = call->Target()->As<sem::ValueConstructor>()) {
-                    if (auto* arr = ctor->ReturnType()->As<type::Array>()) {
+                    if (auto* arr = ctor->ReturnType()->As<core::type::Array>()) {
                         // Begin by cloning the array initializer type or name
                         // If this is an unaliased array, this may add a new entry to
                         // decomposed.
diff --git a/src/tint/lang/wgsl/ast/transform/decompose_strided_matrix.cc b/src/tint/lang/wgsl/ast/transform/decompose_strided_matrix.cc
index 6e6bffe..cc251e2 100644
--- a/src/tint/lang/wgsl/ast/transform/decompose_strided_matrix.cc
+++ b/src/tint/lang/wgsl/ast/transform/decompose_strided_matrix.cc
@@ -37,7 +37,7 @@
     /// The stride in bytes between columns of the matrix
     uint32_t stride = 0;
     /// The type of the matrix
-    const type::Matrix* matrix = nullptr;
+    const core::type::Matrix* matrix = nullptr;
 
     /// @returns the identifier of an array that holds an vector column for each row of the matrix.
     Type array(ast::Builder* b) const {
@@ -72,7 +72,7 @@
     // Scan the program for all storage and uniform structure matrix members with
     // a custom stride attribute. Replace these matrices with an equivalent array,
     // and populate the `decomposed` map with the members that have been replaced.
-    Hashmap<const type::StructMember*, MatrixInfo, 8> decomposed;
+    Hashmap<const core::type::StructMember*, MatrixInfo, 8> decomposed;
     for (auto* node : src->ASTNodes().Objects()) {
         if (auto* str = node->As<Struct>()) {
             auto* str_ty = src->Sem().Get(str);
@@ -81,7 +81,7 @@
                 continue;
             }
             for (auto* member : str_ty->Members()) {
-                auto* matrix = member->Type()->As<type::Matrix>();
+                auto* matrix = member->Type()->As<core::type::Matrix>();
                 if (!matrix) {
                     continue;
                 }
diff --git a/src/tint/lang/wgsl/ast/transform/demote_to_helper.cc b/src/tint/lang/wgsl/ast/transform/demote_to_helper.cc
index 2796cfb..fa439fa 100644
--- a/src/tint/lang/wgsl/ast/transform/demote_to_helper.cc
+++ b/src/tint/lang/wgsl/ast/transform/demote_to_helper.cc
@@ -106,7 +106,7 @@
     // Mask all writes to host-visible memory using the discarded flag.
     // We also insert a discard statement before all return statements in entry points for shaders
     // that discard.
-    std::unordered_map<const type::Type*, Symbol> atomic_cmpxchg_result_types;
+    std::unordered_map<const core::type::Type*, Symbol> atomic_cmpxchg_result_types;
     for (auto* node : src->ASTNodes().Objects()) {
         Switch(
             node,
@@ -125,7 +125,7 @@
                 }
 
                 // Skip writes to invocation-private address spaces.
-                auto* ref = sem.GetVal(assign->lhs)->Type()->As<type::Reference>();
+                auto* ref = sem.GetVal(assign->lhs)->Type()->As<core::type::Reference>();
                 switch (ref->AddressSpace()) {
                     case core::AddressSpace::kStorage:
                         // Need to mask these.
@@ -186,7 +186,7 @@
                             // original member values over to it.
 
                             // Declare a struct to hold the result values.
-                            auto* result_struct = sem_call->Type()->As<type::Struct>();
+                            auto* result_struct = sem_call->Type()->As<core::type::Struct>();
                             auto* atomic_ty = result_struct->Members()[0]->Type();
                             result_ty =
                                 b.ty(tint::GetOrCreate(atomic_cmpxchg_result_types, atomic_ty, [&] {
diff --git a/src/tint/lang/wgsl/ast/transform/direct_variable_access.cc b/src/tint/lang/wgsl/ast/transform/direct_variable_access.cc
index ef56e04..e222e31 100644
--- a/src/tint/lang/wgsl/ast/transform/direct_variable_access.cc
+++ b/src/tint/lang/wgsl/ast/transform/direct_variable_access.cc
@@ -48,7 +48,7 @@
     /// The pointer-unwrapped type of the *transformed* variable.
     /// This may be different for pointers in 'private' and 'function' address space, as the pointer
     /// parameter type is to the *base object* instead of the input pointer type.
-    tint::type::Type const* type = nullptr;
+    tint::core::type::Type const* type = nullptr;
     /// The originating module-scope variable ('private', 'storage', 'uniform', 'workgroup'),
     /// function-scope variable ('function'), or pointer parameter in the source program.
     tint::sem::Variable const* variable = nullptr;
@@ -444,7 +444,7 @@
                     chain->root.variable = variable;
                     chain->root.type = variable->Type();
                     chain->root.address_space = variable->AddressSpace();
-                    if (auto* ptr = chain->root.type->As<type::Pointer>()) {
+                    if (auto* ptr = chain->root.type->As<core::type::Pointer>()) {
                         chain->root.address_space = ptr->AddressSpace();
                     }
                     access_chains.Add(expr, chain);
@@ -459,13 +459,13 @@
                         }
                     },
                     [&](const Parameter*) {
-                        if (variable->Type()->Is<type::Pointer>()) {
+                        if (variable->Type()->Is<core::type::Pointer>()) {
                             // Start a new access chain for the pointer parameter access
                             create_new_chain();
                         }
                     },
                     [&](const Let*) {
-                        if (variable->Type()->Is<type::Pointer>()) {
+                        if (variable->Type()->Is<core::type::Pointer>()) {
                             // variable is a pointer-let.
                             auto* init = sem.GetVal(variable->Declaration()->initializer);
                             // Note: We do not use take_chain() here, as we need to preserve the
@@ -576,7 +576,7 @@
             if (!idx->UnwrapMaterialize()
                      ->Type()
                      ->UnwrapRef()
-                     ->IsAnyOf<type::U32, type::AbstractInt>()) {
+                     ->IsAnyOf<core::type::U32, core::type::AbstractInt>()) {
                 expr = b.Call<u32>(expr);
             }
         }
@@ -640,7 +640,7 @@
             for (size_t i = 0; i < call->Arguments().Length(); i++) {
                 const auto* arg = call->Arguments()[i];
                 const auto* param = target->Parameters()[i];
-                const auto* param_ty = param->Type()->As<type::Pointer>();
+                const auto* param_ty = param->Type()->As<core::type::Pointer>();
                 if (!param_ty) {
                     continue;  // Parameter type is not a pointer.
                 }
@@ -883,7 +883,7 @@
             for (size_t arg_idx = 0; arg_idx < call->Arguments().Length(); arg_idx++) {
                 auto* arg = call->Arguments()[arg_idx];
                 auto* param = call->Target()->Parameters()[arg_idx];
-                auto* param_ty = param->Type()->As<type::Pointer>();
+                auto* param_ty = param->Type()->As<core::type::Pointer>();
                 if (!param_ty) {
                     // Parameter is not a pointer.
                     // Just clone the unaltered argument.
@@ -1051,7 +1051,7 @@
 
             // BuildAccessExpr() always returns a non-pointer.
             // If the expression we're replacing is a pointer, take the address.
-            if (expr->Type()->Is<type::Pointer>()) {
+            if (expr->Type()->Is<core::type::Pointer>()) {
                 chain_expr = b.AddressOf(chain_expr);
             }
 
@@ -1127,7 +1127,7 @@
 
         const Expression* expr = b.Expr(ctx.Clone(root.variable->Declaration()->name->symbol));
         if (deref) {
-            if (root.variable->Type()->Is<type::Pointer>()) {
+            if (root.variable->Type()->Is<core::type::Pointer>()) {
                 expr = b.Deref(expr);
             }
         }
@@ -1168,7 +1168,7 @@
     /// @returns true if the function @p fn has at least one pointer parameter.
     static bool HasPointerParameter(const sem::Function* fn) {
         for (auto* param : fn->Parameters()) {
-            if (param->Type()->Is<type::Pointer>()) {
+            if (param->Type()->Is<core::type::Pointer>()) {
                 return true;
             }
         }
@@ -1180,7 +1180,7 @@
     /// generated, and must be stripped.
     static bool MustBeCalled(const sem::Function* fn) {
         for (auto* param : fn->Parameters()) {
-            if (auto* ptr = param->Type()->As<type::Pointer>()) {
+            if (auto* ptr = param->Type()->As<core::type::Pointer>()) {
                 switch (ptr->AddressSpace()) {
                     case core::AddressSpace::kUniform:
                     case core::AddressSpace::kStorage:
diff --git a/src/tint/lang/wgsl/ast/transform/expand_compound_assignment.cc b/src/tint/lang/wgsl/ast/transform/expand_compound_assignment.cc
index cd766a6..995f581 100644
--- a/src/tint/lang/wgsl/ast/transform/expand_compound_assignment.cc
+++ b/src/tint/lang/wgsl/ast/transform/expand_compound_assignment.cc
@@ -90,7 +90,7 @@
         // Helper function that returns `true` if the type of `expr` is a vector.
         auto is_vec = [&](const Expression* expr) {
             if (auto* val_expr = ctx.src->Sem().GetVal(expr)) {
-                return val_expr->Type()->UnwrapRef()->Is<type::Vector>();
+                return val_expr->Type()->UnwrapRef()->Is<core::type::Vector>();
             }
             return false;
         };
diff --git a/src/tint/lang/wgsl/ast/transform/first_index_offset.cc b/src/tint/lang/wgsl/ast/transform/first_index_offset.cc
index e85812a..2f242f8 100644
--- a/src/tint/lang/wgsl/ast/transform/first_index_offset.cc
+++ b/src/tint/lang/wgsl/ast/transform/first_index_offset.cc
@@ -81,7 +81,7 @@
 
     // Map of builtin usages
     std::unordered_map<const sem::Variable*, const char*> builtin_vars;
-    std::unordered_map<const type::StructMember*, const char*> builtin_members;
+    std::unordered_map<const core::type::StructMember*, const char*> builtin_members;
 
     bool has_vertex_index = false;
     bool has_instance_index = false;
diff --git a/src/tint/lang/wgsl/ast/transform/localize_struct_array_assignment.cc b/src/tint/lang/wgsl/ast/transform/localize_struct_array_assignment.cc
index b2b2b7d0..e4c1bb4 100644
--- a/src/tint/lang/wgsl/ast/transform/localize_struct_array_assignment.cc
+++ b/src/tint/lang/wgsl/ast/transform/localize_struct_array_assignment.cc
@@ -62,7 +62,7 @@
                     continue;
                 }
                 auto og = GetOriginatingTypeAndAddressSpace(assign_stmt);
-                if (!(og.first->Is<type::Struct>() &&
+                if (!(og.first->Is<core::type::Struct>() &&
                       (og.second == core::AddressSpace::kFunction ||
                        og.second == core::AddressSpace::kPrivate))) {
                     continue;
@@ -170,7 +170,7 @@
                 // Indexing a member access expr?
                 if (auto* ma = ia->object->As<MemberAccessorExpression>()) {
                     // That accesses an array?
-                    if (src->TypeOf(ma)->UnwrapRef()->Is<type::Array>()) {
+                    if (src->TypeOf(ma)->UnwrapRef()->Is<core::type::Array>()) {
                         result = true;
                         return TraverseAction::Stop;
                     }
@@ -185,7 +185,7 @@
     // Returns the type and address space of the originating variable of the lhs
     // of the assignment statement.
     // See https://www.w3.org/TR/WGSL/#originating-variable-section
-    std::pair<const type::Type*, core::AddressSpace> GetOriginatingTypeAndAddressSpace(
+    std::pair<const core::type::Type*, core::AddressSpace> GetOriginatingTypeAndAddressSpace(
         const AssignmentStatement* assign_stmt) {
         auto* root_ident = src->Sem().GetVal(assign_stmt->lhs)->RootIdentifier();
         if (TINT_UNLIKELY(!root_ident)) {
@@ -196,16 +196,16 @@
 
         return Switch(
             root_ident->Type(),  //
-            [&](const type::Reference* ref) {
+            [&](const core::type::Reference* ref) {
                 return std::make_pair(ref->StoreType(), ref->AddressSpace());
             },
-            [&](const type::Pointer* ptr) {
+            [&](const core::type::Pointer* ptr) {
                 return std::make_pair(ptr->StoreType(), ptr->AddressSpace());
             },
             [&](Default) {
                 TINT_ICE() << "Expecting to find variable of type pointer or reference on lhs "
                               "of assignment statement";
-                return std::pair<const type::Type*, core::AddressSpace>{};
+                return std::pair<const core::type::Type*, core::AddressSpace>{};
             });
     }
 };
diff --git a/src/tint/lang/wgsl/ast/transform/module_scope_var_to_entry_point_param.cc b/src/tint/lang/wgsl/ast/transform/module_scope_var_to_entry_point_param.cc
index 79f52893..3a997be 100644
--- a/src/tint/lang/wgsl/ast/transform/module_scope_var_to_entry_point_param.cc
+++ b/src/tint/lang/wgsl/ast/transform/module_scope_var_to_entry_point_param.cc
@@ -53,13 +53,13 @@
 }
 
 // Returns `true` if `type` is or contains a matrix type.
-bool ContainsMatrix(const type::Type* type) {
+bool ContainsMatrix(const core::type::Type* type) {
     type = type->UnwrapRef();
-    if (type->Is<type::Matrix>()) {
+    if (type->Is<core::type::Matrix>()) {
         return true;
-    } else if (auto* ary = type->As<type::Array>()) {
+    } else if (auto* ary = type->As<core::type::Array>()) {
         return ContainsMatrix(ary->ElemType());
-    } else if (auto* str = type->As<type::Struct>()) {
+    } else if (auto* str = type->As<core::type::Struct>()) {
         for (auto* member : str->Members()) {
             if (ContainsMatrix(member->Type())) {
                 return true;
@@ -83,7 +83,7 @@
     /// and add it to the global declarations now, so that they precede new global
     /// declarations that need to reference them.
     /// @param ty the type to clone
-    void CloneStructTypes(const type::Type* ty) {
+    void CloneStructTypes(const core::type::Type* ty) {
         if (auto* str = ty->As<sem::Struct>()) {
             if (!cloned_structs_.emplace(str).second) {
                 // The struct has already been cloned.
@@ -100,7 +100,7 @@
             auto* ast_str = str->Declaration();
             ctx.dst->AST().AddTypeDecl(ctx.Clone(ast_str));
             ctx.Remove(ctx.src->AST().GlobalDeclarations(), ast_str);
-        } else if (auto* arr = ty->As<type::Array>()) {
+        } else if (auto* arr = ty->As<core::type::Array>()) {
             CloneStructTypes(arr->ElemType());
         }
     }
@@ -150,8 +150,8 @@
                 attributes.Push(ctx.dst->Disable(DisabledValidation::kIgnoreAddressSpace));
 
                 auto param_type = store_type();
-                if (auto* arr = ty->As<type::Array>();
-                    arr && arr->Count()->Is<type::RuntimeArrayCount>()) {
+                if (auto* arr = ty->As<core::type::Array>();
+                    arr && arr->Count()->Is<core::type::RuntimeArrayCount>()) {
                     // Wrap runtime-sized arrays in structures, so that we can declare pointers to
                     // them. Ideally we'd just emit the array itself as a pointer, but this is not
                     // representable in Tint's AST.
diff --git a/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc b/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc
index a454d7c..5ebe504 100644
--- a/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc
+++ b/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc
@@ -36,7 +36,7 @@
 using namespace tint::number_suffixes;     // NOLINT
 
 bool ShouldRun(const Program* program) {
-    auto ext = program->Types().Find<type::ExternalTexture>();
+    auto ext = program->Types().Find<core::type::ExternalTexture>();
     return ext != nullptr;
 }
 
@@ -99,7 +99,7 @@
         // one uniform buffer for the ExternalTextureParams struct).
         for (auto* global : ctx.src->AST().GlobalVariables()) {
             auto* sem_var = sem.Get<sem::GlobalVariable>(global);
-            if (!sem_var->Type()->UnwrapRef()->Is<type::ExternalTexture>()) {
+            if (!sem_var->Type()->UnwrapRef()->Is<core::type::ExternalTexture>()) {
                 continue;
             }
 
@@ -138,7 +138,8 @@
             auto& syms = new_binding_symbols[sem_var];
             syms.plane_0 = ctx.Clone(global->name->symbol);
             syms.plane_1 = b.Symbols().New("ext_tex_plane_1");
-            b.GlobalVar(syms.plane_1, b.ty.sampled_texture(type::TextureDimension::k2d, b.ty.f32()),
+            b.GlobalVar(syms.plane_1,
+                        b.ty.sampled_texture(core::type::TextureDimension::k2d, b.ty.f32()),
                         b.Group(AInt(bps.plane_1.group)), b.Binding(AInt(bps.plane_1.binding)));
             syms.params = b.Symbols().New("ext_tex_params");
             b.GlobalVar(syms.params, b.ty("ExternalTextureParams"), core::AddressSpace::kUniform,
@@ -148,9 +149,9 @@
             auto cloned_attributes = ctx.Clone(global->attributes);
             const Expression* cloned_initializer = ctx.Clone(global->initializer);
 
-            auto* replacement =
-                b.Var(syms.plane_0, b.ty.sampled_texture(type::TextureDimension::k2d, b.ty.f32()),
-                      cloned_initializer, cloned_attributes);
+            auto* replacement = b.Var(
+                syms.plane_0, b.ty.sampled_texture(core::type::TextureDimension::k2d, b.ty.f32()),
+                cloned_initializer, cloned_attributes);
             ctx.Replace(global, replacement);
         }
 
@@ -158,7 +159,7 @@
         for (auto* fn : ctx.src->AST().Functions()) {
             for (const Variable* param : fn->params) {
                 if (auto* sem_var = sem.Get(param)) {
-                    if (!sem_var->Type()->UnwrapRef()->Is<type::ExternalTexture>()) {
+                    if (!sem_var->Type()->UnwrapRef()->Is<core::type::ExternalTexture>()) {
                         continue;
                     }
                     // If we find a texture_external, we must ensure the ExternalTextureParams
@@ -175,7 +176,7 @@
                     syms.plane_1 = b.Symbols().New("ext_tex_plane_1");
                     syms.params = b.Symbols().New("ext_tex_params");
                     auto tex2d_f32 = [&] {
-                        return b.ty.sampled_texture(type::TextureDimension::k2d, b.ty.f32());
+                        return b.ty.sampled_texture(core::type::TextureDimension::k2d, b.ty.f32());
                     };
                     ctx.Replace(param, b.Param(syms.plane_0, tex2d_f32()));
                     ctx.InsertAfter(fn->params, param, b.Param(syms.plane_1, tex2d_f32()));
@@ -192,7 +193,7 @@
             auto* builtin = call->Target()->As<sem::Builtin>();
 
             if (builtin && !builtin->Parameters().IsEmpty() &&
-                builtin->Parameters()[0]->Type()->Is<type::ExternalTexture>() &&
+                builtin->Parameters()[0]->Type()->Is<core::type::ExternalTexture>() &&
                 builtin->Type() != core::Function::kTextureDimensions) {
                 if (auto* var_user =
                         sem.GetVal(expr->args[0])->UnwrapLoad()->As<sem::VariableUser>()) {
@@ -422,10 +423,10 @@
             b.Func(texture_sample_external_sym,
                    tint::Vector{
                        b.Param("plane0",
-                               b.ty.sampled_texture(type::TextureDimension::k2d, b.ty.f32())),
+                               b.ty.sampled_texture(core::type::TextureDimension::k2d, b.ty.f32())),
                        b.Param("plane1",
-                               b.ty.sampled_texture(type::TextureDimension::k2d, b.ty.f32())),
-                       b.Param("smp", b.ty.sampler(type::SamplerKind::kSampler)),
+                               b.ty.sampled_texture(core::type::TextureDimension::k2d, b.ty.f32())),
+                       b.Param("smp", b.ty.sampler(core::type::SamplerKind::kSampler)),
                        b.Param("coord", b.ty.vec2(b.ty.f32())),
                        b.Param("params", b.ty(params_struct_sym)),
                    },
@@ -470,9 +471,9 @@
             b.Func(name,
                    tint::Vector{
                        b.Param("plane0",
-                               b.ty.sampled_texture(type::TextureDimension::k2d, b.ty.f32())),
+                               b.ty.sampled_texture(core::type::TextureDimension::k2d, b.ty.f32())),
                        b.Param("plane1",
-                               b.ty.sampled_texture(type::TextureDimension::k2d, b.ty.f32())),
+                               b.ty.sampled_texture(core::type::TextureDimension::k2d, b.ty.f32())),
                        b.Param("coord", CreateASTTypeFor(ctx, coord_ty)),
                        b.Param("params", b.ty(params_struct_sym)),
                    },
diff --git a/src/tint/lang/wgsl/ast/transform/packed_vec3.cc b/src/tint/lang/wgsl/ast/transform/packed_vec3.cc
index 48d73ad..3d38924 100644
--- a/src/tint/lang/wgsl/ast/transform/packed_vec3.cc
+++ b/src/tint/lang/wgsl/ast/transform/packed_vec3.cc
@@ -53,21 +53,21 @@
     static constexpr const char* kStructMemberName = "elements";
 
     /// The names of the structures used to wrap packed vec3 types.
-    Hashmap<const type::Type*, Symbol, 4> packed_vec3_wrapper_struct_names;
+    Hashmap<const core::type::Type*, Symbol, 4> packed_vec3_wrapper_struct_names;
 
     /// A cache of host-shareable structures that have been rewritten.
-    Hashmap<const type::Type*, Symbol, 4> rewritten_structs;
+    Hashmap<const core::type::Type*, Symbol, 4> rewritten_structs;
 
     /// A map from type to the name of a helper function used to pack that type.
-    Hashmap<const type::Type*, Symbol, 4> pack_helpers;
+    Hashmap<const core::type::Type*, Symbol, 4> pack_helpers;
 
     /// A map from type to the name of a helper function used to unpack that type.
-    Hashmap<const type::Type*, Symbol, 4> unpack_helpers;
+    Hashmap<const core::type::Type*, Symbol, 4> unpack_helpers;
 
     /// @param ty the type to test
     /// @returns true if `ty` is a vec3, false otherwise
-    bool IsVec3(const type::Type* ty) {
-        if (auto* vec = ty->As<type::Vector>()) {
+    bool IsVec3(const core::type::Type* ty) {
+        if (auto* vec = ty->As<core::type::Vector>()) {
             if (vec->Width() == 3) {
                 return true;
             }
@@ -77,13 +77,13 @@
 
     /// @param ty the type to test
     /// @returns true if `ty` is or contains a vec3, false otherwise
-    bool ContainsVec3(const type::Type* ty) {
+    bool ContainsVec3(const core::type::Type* ty) {
         return Switch(
             ty,  //
-            [&](const type::Vector* vec) { return IsVec3(vec); },
-            [&](const type::Matrix* mat) { return ContainsVec3(mat->ColumnType()); },
-            [&](const type::Array* arr) { return ContainsVec3(arr->ElemType()); },
-            [&](const type::Struct* str) {
+            [&](const core::type::Vector* vec) { return IsVec3(vec); },
+            [&](const core::type::Matrix* mat) { return ContainsVec3(mat->ColumnType()); },
+            [&](const core::type::Array* arr) { return ContainsVec3(arr->ElemType()); },
+            [&](const core::type::Struct* str) {
                 for (auto* member : str->Members()) {
                     if (ContainsVec3(member->Type())) {
                         return true;
@@ -96,8 +96,8 @@
     /// Create a `__packed_vec3` type with the same element type as `ty`.
     /// @param ty a three-element vector type
     /// @returns the new AST type
-    Type MakePackedVec3(const type::Type* ty) {
-        auto* vec = ty->As<type::Vector>();
+    Type MakePackedVec3(const core::type::Type* ty) {
+        auto* vec = ty->As<core::type::Vector>();
         TINT_ASSERT(vec != nullptr && vec->Width() == 3);
         return b.ty(core::Builtin::kPackedVec3, CreateASTTypeFor(ctx, vec->type()));
     }
@@ -111,10 +111,10 @@
     /// @param ty the type to rewrite
     /// @param array_element `true` if this is being called for the element of an array
     /// @returns the new AST type, or nullptr if rewriting was not necessary
-    Type RewriteType(const type::Type* ty, bool array_element = false) {
+    Type RewriteType(const core::type::Type* ty, bool array_element = false) {
         return Switch(
             ty,
-            [&](const type::Vector* vec) -> Type {
+            [&](const core::type::Vector* vec) -> Type {
                 if (IsVec3(vec)) {
                     if (array_element) {
                         // Create a struct with a single `__packed_vec3` member.
@@ -136,7 +136,7 @@
                 }
                 return {};
             },
-            [&](const type::Matrix* mat) -> Type {
+            [&](const core::type::Matrix* mat) -> Type {
                 // Rewrite the matrix as an array of columns that use the aligned wrapper struct.
                 auto new_col_type = RewriteType(mat->ColumnType(), /* array_element */ true);
                 if (new_col_type) {
@@ -144,23 +144,23 @@
                 }
                 return {};
             },
-            [&](const type::Array* arr) -> Type {
+            [&](const core::type::Array* arr) -> Type {
                 // Rewrite the array with the modified element type.
                 auto new_type = RewriteType(arr->ElemType(), /* array_element */ true);
                 if (new_type) {
                     tint::Vector<const Attribute*, 1> attrs;
-                    if (arr->Count()->Is<type::RuntimeArrayCount>()) {
+                    if (arr->Count()->Is<core::type::RuntimeArrayCount>()) {
                         return b.ty.array(new_type, std::move(attrs));
                     } else if (auto count = arr->ConstantCount()) {
                         return b.ty.array(new_type, u32(count.value()), std::move(attrs));
                     } else {
-                        TINT_ICE() << type::Array::kErrExpectedConstantCount;
+                        TINT_ICE() << core::type::Array::kErrExpectedConstantCount;
                         return {};
                     }
                 }
                 return {};
             },
-            [&](const type::Struct* str) -> Type {
+            [&](const core::type::Struct* str) -> Type {
                 if (ContainsVec3(str)) {
                     auto name = rewritten_structs.GetOrCreate(str, [&] {
                         tint::Vector<const StructMember*, 4> members;
@@ -219,8 +219,8 @@
     /// @returns the name of the helper function
     Symbol MakePackUnpackHelper(
         const char* name_prefix,
-        const type::Type* ty,
-        const std::function<const Expression*(const Expression*, const type::Type*)>&
+        const core::type::Type* ty,
+        const std::function<const Expression*(const Expression*, const core::type::Type*)>&
             pack_or_unpack_element,
         const std::function<Type()>& in_type,
         const std::function<Type()>& out_type) {
@@ -232,7 +232,8 @@
         //   for (var i = 0u; i < num_elements; i = i + 1) {
         //     result[i] = pack_or_unpack_element(in[i]);
         //   }
-        auto copy_array_elements = [&](uint32_t num_elements, const type::Type* element_type) {
+        auto copy_array_elements = [&](uint32_t num_elements,
+                                       const core::type::Type* element_type) {
             // Generate an expression for packing or unpacking an element of the array.
             auto* element = pack_or_unpack_element(b.IndexAccessor("in", "i"), element_type);
             statements.Push(b.For(                   //
@@ -247,14 +248,14 @@
         // Copy the elements of the value over to the result.
         Switch(
             ty,
-            [&](const type::Array* arr) {
+            [&](const core::type::Array* arr) {
                 TINT_ASSERT(arr->ConstantCount());
                 copy_array_elements(arr->ConstantCount().value(), arr->ElemType());
             },
-            [&](const type::Matrix* mat) {
+            [&](const core::type::Matrix* mat) {
                 copy_array_elements(mat->columns(), mat->ColumnType());
             },
-            [&](const type::Struct* str) {
+            [&](const core::type::Struct* str) {
                 // Copy the struct members over one at a time, packing/unpacking as necessary.
                 for (auto* member : str->Members()) {
                     const Expression* element =
@@ -281,13 +282,13 @@
     /// @param expr the composite value expression to unpack
     /// @param ty the unpacked type
     /// @returns an expression that holds the unpacked value
-    const Expression* UnpackComposite(const Expression* expr, const type::Type* ty) {
+    const Expression* UnpackComposite(const Expression* expr, const core::type::Type* ty) {
         auto helper = unpack_helpers.GetOrCreate(ty, [&] {
             return MakePackUnpackHelper(
                 "tint_unpack_vec3_in_composite", ty,
                 [&](const Expression* element,
-                    const type::Type* element_type) -> const Expression* {
-                    if (element_type->Is<type::Vector>()) {
+                    const core::type::Type* element_type) -> const Expression* {
+                    if (element_type->Is<core::type::Vector>()) {
                         // Unpack a `__packed_vec3` by casting it to a regular vec3.
                         // If it is an array element, extract the vector from the wrapper struct.
                         if (element->Is<IndexAccessorExpression>()) {
@@ -309,13 +310,13 @@
     /// @param expr the composite value expression to pack
     /// @param ty the unpacked type
     /// @returns an expression that holds the packed value
-    const Expression* PackComposite(const Expression* expr, const type::Type* ty) {
+    const Expression* PackComposite(const Expression* expr, const core::type::Type* ty) {
         auto helper = pack_helpers.GetOrCreate(ty, [&] {
             return MakePackUnpackHelper(
                 "tint_pack_vec3_in_composite", ty,
                 [&](const Expression* element,
-                    const type::Type* element_type) -> const Expression* {
-                    if (element_type->Is<type::Vector>()) {
+                    const core::type::Type* element_type) -> const Expression* {
+                    if (element_type->Is<core::type::Vector>()) {
                         // Pack a vector element by casting it to a packed_vec3.
                         // If it is an array element, construct a wrapper struct.
                         auto* packed = b.Call(MakePackedVec3(element_type), element);
@@ -375,7 +376,7 @@
                 sem.Get(node),
                 [&](const sem::TypeExpression* type) {
                     // Rewrite pointers to types that contain vec3s.
-                    auto* ptr = type->Type()->As<type::Pointer>();
+                    auto* ptr = type->Type()->As<core::type::Pointer>();
                     if (ptr && core::IsHostShareable(ptr->AddressSpace())) {
                         auto new_store_type = RewriteType(ptr->StoreType());
                         if (new_store_type) {
@@ -406,7 +407,7 @@
                         auto* rhs = sem.GetVal(assign->rhs);
                         if (!ContainsVec3(rhs->Type()) ||
                             !core::IsHostShareable(
-                                lhs->Type()->As<type::Reference>()->AddressSpace())) {
+                                lhs->Type()->As<core::type::Reference>()->AddressSpace())) {
                             // Skip assignments to address spaces that are not host-shareable, or
                             // that do not contain vec3 types.
                             return;
@@ -441,7 +442,7 @@
                     // If the expression produces a reference to a vec3 in a host-shareable address
                     // space from an array element, extract the packed vector from the wrapper
                     // struct.
-                    if (auto* ref = accessor->Type()->As<type::Reference>()) {
+                    if (auto* ref = accessor->Type()->As<core::type::Reference>()) {
                         if (IsVec3(ref->StoreType()) &&
                             core::IsHostShareable(ref->AddressSpace())) {
                             ctx.Replace(node, b.MemberAccessor(ctx.Clone(accessor->Declaration()),
diff --git a/src/tint/lang/wgsl/ast/transform/packed_vec3_test.cc b/src/tint/lang/wgsl/ast/transform/packed_vec3_test.cc
index 09e13bd..c0adb8f 100644
--- a/src/tint/lang/wgsl/ast/transform/packed_vec3_test.cc
+++ b/src/tint/lang/wgsl/ast/transform/packed_vec3_test.cc
@@ -4329,7 +4329,7 @@
         // The first member should have an alignment of 16 bytes, a size of 12 bytes, and the second
         // member should have an offset of 12 bytes.
         auto* sem_str = got.program.Sem().Get(vars[0]);
-        auto* str_ty = sem_str->Type()->UnwrapRef()->As<type::Struct>();
+        auto* str_ty = sem_str->Type()->UnwrapRef()->As<core::type::Struct>();
         ASSERT_NE(str_ty, nullptr);
         ASSERT_EQ(str_ty->Members().Length(), 2u);
         EXPECT_EQ(str_ty->Members()[0]->Align(), 16u);
@@ -4341,7 +4341,7 @@
         // Check the layout of the array type of "arr".
         // The element stride should be 16 bytes.
         auto* sem_arr = got.program.Sem().Get(vars[1]);
-        auto* arr_ty = sem_arr->Type()->UnwrapRef()->As<type::Array>();
+        auto* arr_ty = sem_arr->Type()->UnwrapRef()->As<core::type::Array>();
         ASSERT_NE(arr_ty, nullptr);
         EXPECT_EQ(arr_ty->Stride(), 16u);
     }
diff --git a/src/tint/lang/wgsl/ast/transform/pad_structs.cc b/src/tint/lang/wgsl/ast/transform/pad_structs.cc
index e8400c6..49c3eaf 100644
--- a/src/tint/lang/wgsl/ast/transform/pad_structs.cc
+++ b/src/tint/lang/wgsl/ast/transform/pad_structs.cc
@@ -86,11 +86,11 @@
             new_members.Push(b.Member(name, type));
 
             uint32_t size = ty->Size();
-            if (ty->Is<type::Struct>() && str->UsedAs(core::AddressSpace::kUniform)) {
+            if (ty->Is<core::type::Struct>() && str->UsedAs(core::AddressSpace::kUniform)) {
                 // std140 structs should be padded out to 16 bytes.
                 size = tint::RoundUp(16u, size);
-            } else if (auto* array_ty = ty->As<type::Array>()) {
-                if (array_ty->Count()->Is<type::RuntimeArrayCount>()) {
+            } else if (auto* array_ty = ty->As<core::type::Array>()) {
+                if (array_ty->Count()->Is<core::type::RuntimeArrayCount>()) {
                     has_runtime_sized_array = true;
                 }
             }
diff --git a/src/tint/lang/wgsl/ast/transform/preserve_padding.cc b/src/tint/lang/wgsl/ast/transform/preserve_padding.cc
index 64c48e5..5dba8d0 100644
--- a/src/tint/lang/wgsl/ast/transform/preserve_padding.cc
+++ b/src/tint/lang/wgsl/ast/transform/preserve_padding.cc
@@ -57,7 +57,8 @@
                         // Ignore phony assignment.
                         return;
                     }
-                    if (ty->As<type::Reference>()->AddressSpace() != core::AddressSpace::kStorage) {
+                    if (ty->As<core::type::Reference>()->AddressSpace() !=
+                        core::AddressSpace::kStorage) {
                         // We only care about assignments that write to variables in the storage
                         // address space, as nothing else is host-visible.
                         return;
@@ -98,7 +99,7 @@
     /// @param lhs the lhs expression (in the destination program)
     /// @param rhs the rhs expression (in the destination program)
     /// @returns the statement that performs the assignment
-    const Statement* MakeAssignment(const type::Type* ty,
+    const Statement* MakeAssignment(const core::type::Type* ty,
                                     const Expression* lhs,
                                     const Expression* rhs) {
         if (!HasPadding(ty)) {
@@ -135,7 +136,7 @@
 
         return Switch(
             ty,  //
-            [&](const type::Array* arr) {
+            [&](const core::type::Array* arr) {
                 // Call a helper function that uses a loop to assigns each element separately.
                 return call_helper([&] {
                     tint::Vector<const Statement*, 8> body;
@@ -149,7 +150,7 @@
                     return body;
                 });
             },
-            [&](const type::Matrix* mat) {
+            [&](const core::type::Matrix* mat) {
                 // Call a helper function that assigns each column separately.
                 return call_helper([&] {
                     tint::Vector<const Statement*, 4> body;
@@ -161,7 +162,7 @@
                     return body;
                 });
             },
-            [&](const type::Struct* str) {
+            [&](const core::type::Struct* str) {
                 // Call a helper function that assigns each member separately.
                 return call_helper([&] {
                     tint::Vector<const Statement*, 8> body;
@@ -183,24 +184,24 @@
     /// Checks if a type contains padding bytes.
     /// @param ty the type to check
     /// @returns true if `ty` (or any of its contained types) have padding bytes
-    bool HasPadding(const type::Type* ty) {
+    bool HasPadding(const core::type::Type* ty) {
         return Switch(
             ty,  //
-            [&](const type::Array* arr) {
+            [&](const core::type::Array* arr) {
                 auto* elem_ty = arr->ElemType();
                 if (elem_ty->Size() % elem_ty->Align() > 0) {
                     return true;
                 }
                 return HasPadding(elem_ty);
             },
-            [&](const type::Matrix* mat) {
+            [&](const core::type::Matrix* mat) {
                 auto* col_ty = mat->ColumnType();
                 if (mat->ColumnStride() > col_ty->Size()) {
                     return true;
                 }
                 return HasPadding(col_ty);
             },
-            [&](const type::Struct* str) {
+            [&](const core::type::Struct* str) {
                 uint32_t current_offset = 0;
                 for (auto* member : str->Members()) {
                     if (member->Offset() > current_offset) {
@@ -236,7 +237,7 @@
     /// Flag to track whether we have already enabled the full pointer parameters extension.
     bool ext_enabled = false;
     /// Map of semantic types to their assignment helper functions.
-    Hashmap<const type::Type*, Symbol, 8> helpers;
+    Hashmap<const core::type::Type*, Symbol, 8> helpers;
 };
 
 Transform::ApplyResult PreservePadding::Apply(const Program* program,
diff --git a/src/tint/lang/wgsl/ast/transform/promote_initializers_to_let.cc b/src/tint/lang/wgsl/ast/transform/promote_initializers_to_let.cc
index 4b2a439..9533281 100644
--- a/src/tint/lang/wgsl/ast/transform/promote_initializers_to_let.cc
+++ b/src/tint/lang/wgsl/ast/transform/promote_initializers_to_let.cc
@@ -44,7 +44,7 @@
     // Returns true if the expression should be hoisted to a new let statement before the
     // expression's statement.
     auto should_hoist = [&](const sem::ValueExpression* expr) {
-        if (!expr->Type()->IsAnyOf<type::Array, type::Struct>()) {
+        if (!expr->Type()->IsAnyOf<core::type::Array, core::type::Struct>()) {
             // We only care about array and struct initializers
             return false;
         }
diff --git a/src/tint/lang/wgsl/ast/transform/promote_side_effects_to_decl.cc b/src/tint/lang/wgsl/ast/transform/promote_side_effects_to_decl.cc
index 8d36a86..61dcccc 100644
--- a/src/tint/lang/wgsl/ast/transform/promote_side_effects_to_decl.cc
+++ b/src/tint/lang/wgsl/ast/transform/promote_side_effects_to_decl.cc
@@ -290,7 +290,9 @@
                         }
                         // Don't hoist textures / samplers as they can't be placed into a let, nor
                         // can they have side effects.
-                        if (var_user->Variable()->Type()->IsAnyOf<type::Texture, type::Sampler>()) {
+                        if (var_user->Variable()
+                                ->Type()
+                                ->IsAnyOf<core::type::Texture, core::type::Sampler>()) {
                             return false;
                         }
                         return true;
diff --git a/src/tint/lang/wgsl/ast/transform/remove_phonies.cc b/src/tint/lang/wgsl/ast/transform/remove_phonies.cc
index 0c653f6..e50b3b6 100644
--- a/src/tint/lang/wgsl/ast/transform/remove_phonies.cc
+++ b/src/tint/lang/wgsl/ast/transform/remove_phonies.cc
@@ -35,7 +35,7 @@
 namespace tint::ast::transform {
 namespace {
 
-using SinkSignature = std::vector<const type::Type*>;
+using SinkSignature = std::vector<const core::type::Type*>;
 
 }  // namespace
 
diff --git a/src/tint/lang/wgsl/ast/transform/renamer.cc b/src/tint/lang/wgsl/ast/transform/renamer.cc
index 1d9558b..af66929 100644
--- a/src/tint/lang/wgsl/ast/transform/renamer.cc
+++ b/src/tint/lang/wgsl/ast/transform/renamer.cc
@@ -1283,7 +1283,7 @@
                 if (sem->Is<sem::Swizzle>()) {
                     preserved_identifiers.Add(accessor->member);
                 } else if (auto* str_expr = src->Sem().GetVal(accessor->object)) {
-                    if (auto* ty = str_expr->Type()->UnwrapRef()->As<type::Struct>()) {
+                    if (auto* ty = str_expr->Type()->UnwrapRef()->As<core::type::Struct>()) {
                         if (!ty->Is<sem::Struct>()) {  // Builtin structure
                             preserved_identifiers.Add(accessor->member);
                         }
diff --git a/src/tint/lang/wgsl/ast/transform/robustness.cc b/src/tint/lang/wgsl/ast/transform/robustness.cc
index 2f7b5a5..dcd0157 100644
--- a/src/tint/lang/wgsl/ast/transform/robustness.cc
+++ b/src/tint/lang/wgsl/ast/transform/robustness.cc
@@ -92,7 +92,7 @@
                     // Inspect.
                     if (auto* user = sem.Get<sem::VariableUser>(e)) {
                         auto* v = user->Variable();
-                        if (v->Type()->Is<type::Pointer>()) {
+                        if (v->Type()->Is<core::type::Pointer>()) {
                             // Propagate predicate from pointer
                             if (auto pred = predicates.Get(v->Declaration()->initializer)) {
                                 predicates.Add(e, *pred);
@@ -181,7 +181,7 @@
                 if (auto pred = predicates.Get(expr)) {
                     // Expression is predicated
                     auto* sem_expr = sem.GetVal(expr);
-                    if (!sem_expr->Type()->IsAnyOf<type::Reference, type::Pointer>()) {
+                    if (!sem_expr->Type()->IsAnyOf<core::type::Reference, core::type::Pointer>()) {
                         auto pred_load = b.Symbols().New("predicated_expr");
                         auto ty = CreateASTTypeFor(ctx, sem_expr->Type());
                         hoist.InsertBefore(sem_expr->Stmt(), b.Decl(b.Var(pred_load, ty)));
@@ -224,7 +224,7 @@
         auto* obj_type = expr->Object()->Type();
         return Switch(
             obj_type->UnwrapRef(),  //
-            [&](const type::Vector* vec) -> const Expression* {
+            [&](const core::type::Vector* vec) -> const Expression* {
                 if (expr->Index()->ConstantValue() || expr->Index()->Is<sem::Swizzle>()) {
                     // Index and size is constant.
                     // Validation will have rejected any OOB accesses.
@@ -232,7 +232,7 @@
                 }
                 return b.Expr(u32(vec->Width() - 1u));
             },
-            [&](const type::Matrix* mat) -> const Expression* {
+            [&](const core::type::Matrix* mat) -> const Expression* {
                 if (expr->Index()->ConstantValue()) {
                     // Index and size is constant.
                     // Validation will have rejected any OOB accesses.
@@ -240,8 +240,8 @@
                 }
                 return b.Expr(u32(mat->columns() - 1u));
             },
-            [&](const type::Array* arr) -> const Expression* {
-                if (arr->Count()->Is<type::RuntimeArrayCount>()) {
+            [&](const core::type::Array* arr) -> const Expression* {
+                if (arr->Count()->Is<core::type::RuntimeArrayCount>()) {
                     // Size is unknown until runtime.
                     // Must clamp, even if the index is constant.
 
@@ -259,7 +259,7 @@
                 // Note: Don't be tempted to use the array override variable as an expression here,
                 // the name might be shadowed!
                 b.Diagnostics().add_error(diag::System::Transform,
-                                          type::Array::kErrExpectedConstantCount);
+                                          core::type::Array::kErrExpectedConstantCount);
                 return nullptr;
             },
             [&](Default) -> const Expression* {
@@ -275,7 +275,7 @@
         for (auto* fn : src->AST().Functions()) {
             for (auto* param : fn->params) {
                 auto* sem_param = sem.Get(param);
-                if (auto* ptr = sem_param->Type()->As<type::Pointer>()) {
+                if (auto* ptr = sem_param->Type()->As<core::type::Pointer>()) {
                     if (ActionFor(ptr->AddressSpace()) == Action::kPredicate) {
                         auto name = b.Symbols().New(param->name->symbol.Name() + "_predicate");
                         ctx.InsertAfter(fn->params, param, b.Param(name, b.ty.bool_()));
@@ -296,7 +296,7 @@
         auto* expr = call->Declaration();
         for (size_t i = 0; i < fn->Parameters().Length(); i++) {
             auto* param = fn->Parameters()[i];
-            if (auto* ptr = param->Type()->As<type::Pointer>()) {
+            if (auto* ptr = param->Type()->As<core::type::Pointer>()) {
                 if (ActionFor(ptr->AddressSpace()) == Action::kPredicate) {
                     auto* arg = expr->args[i];
                     if (auto predicate = predicates.Get(arg)) {
@@ -615,7 +615,7 @@
     Action ActionFor(const sem::ValueExpression* expr) {
         return Switch(
             expr->Type(),  //
-            [&](const type::Reference* t) { return ActionFor(t->AddressSpace()); },
+            [&](const core::type::Reference* t) { return ActionFor(t->AddressSpace()); },
             [&](Default) { return cfg.value_action; });
     }
 
@@ -645,8 +645,8 @@
     }
 
     /// @returns the vector width of @p ty, or 1 if @p ty is not a vector
-    static uint32_t WidthOf(const type::Type* ty) {
-        if (auto* vec = ty->As<type::Vector>()) {
+    static uint32_t WidthOf(const core::type::Type* ty) {
+        if (auto* vec = ty->As<core::type::Vector>()) {
             return vec->Width();
         }
         return 1u;
@@ -699,8 +699,8 @@
 
     /// @returns true if expr is an IndexAccessorExpression whose object is a runtime-sized array.
     bool IsIndexAccessingRuntimeSizedArray(const sem::IndexAccessorExpression* expr) {
-        auto* array_type = expr->Object()->Type()->UnwrapRef()->As<type::Array>();
-        return array_type != nullptr && array_type->Count()->Is<type::RuntimeArrayCount>();
+        auto* array_type = expr->Object()->Type()->UnwrapRef()->As<core::type::Array>();
+        return array_type != nullptr && array_type->Count()->Is<core::type::RuntimeArrayCount>();
     }
 
     /// @returns a clone of expr->Declaration() if it is an unsigned integer scalar, or
diff --git a/src/tint/lang/wgsl/ast/transform/simplify_pointers.cc b/src/tint/lang/wgsl/ast/transform/simplify_pointers.cc
index 42fe6a6..98de628 100644
--- a/src/tint/lang/wgsl/ast/transform/simplify_pointers.cc
+++ b/src/tint/lang/wgsl/ast/transform/simplify_pointers.cc
@@ -118,7 +118,7 @@
                 auto* var = user->Variable();
                 if (var->Is<sem::LocalVariable>() &&  //
                     var->Declaration()->Is<Let>() &&  //
-                    var->Type()->Is<type::Pointer>()) {
+                    var->Type()->Is<core::type::Pointer>()) {
                     op.expr = var->Declaration()->initializer;
                     continue;
                 }
@@ -135,7 +135,7 @@
 
         bool needs_transform = false;
         for (auto* ty : ctx.src->Types()) {
-            if (ty->Is<type::Pointer>()) {
+            if (ty->Is<core::type::Pointer>()) {
                 // Program contains pointers which need removing.
                 needs_transform = true;
                 break;
@@ -154,7 +154,7 @@
                     }
 
                     auto* var = ctx.src->Sem().Get(let->variable);
-                    if (!var->Type()->Is<type::Pointer>()) {
+                    if (!var->Type()->Is<core::type::Pointer>()) {
                         return;  // Not a pointer type. Ignore.
                     }
 
diff --git a/src/tint/lang/wgsl/ast/transform/single_entry_point.cc b/src/tint/lang/wgsl/ast/transform/single_entry_point.cc
index 5684e25..9976562 100644
--- a/src/tint/lang/wgsl/ast/transform/single_entry_point.cc
+++ b/src/tint/lang/wgsl/ast/transform/single_entry_point.cc
@@ -73,7 +73,7 @@
             decl,  //
             [&](const TypeDecl* ty) {
                 // Strip aliases that reference unused override declarations.
-                if (auto* arr = sem.Get(ty)->As<type::Array>()) {
+                if (auto* arr = sem.Get(ty)->As<core::type::Array>()) {
                     auto* refs = sem.TransitivelyReferencedOverrides(arr);
                     if (refs) {
                         for (auto* o : *refs) {
diff --git a/src/tint/lang/wgsl/ast/transform/spirv_atomic.cc b/src/tint/lang/wgsl/ast/transform/spirv_atomic.cc
index dc9dc11..fdbbba2 100644
--- a/src/tint/lang/wgsl/ast/transform/spirv_atomic.cc
+++ b/src/tint/lang/wgsl/ast/transform/spirv_atomic.cc
@@ -55,7 +55,7 @@
     ProgramBuilder b;
     /// The clone context
     program::CloneContext ctx = {&b, src, /* auto_clone_symbols */ true};
-    std::unordered_map<const type::Struct*, ForkedStruct> forked_structs;
+    std::unordered_map<const core::type::Struct*, ForkedStruct> forked_structs;
     std::unordered_set<const sem::Variable*> atomic_variables;
     UniqueVector<const sem::ValueExpression*, 8> atomic_expressions;
 
@@ -157,7 +157,7 @@
     }
 
   private:
-    ForkedStruct& Fork(const type::Struct* str) {
+    ForkedStruct& Fork(const core::type::Struct* str) {
         auto& forked = forked_structs[str];
         if (!forked.name.IsValid()) {
             forked.name = b.Symbols().New(str->Name().Name() + "_atomic");
@@ -196,14 +196,14 @@
         }
     }
 
-    Type AtomicTypeFor(const type::Type* ty) {
+    Type AtomicTypeFor(const core::type::Type* ty) {
         return Switch(
             ty,  //
-            [&](const type::I32*) { return b.ty.atomic(CreateASTTypeFor(ctx, ty)); },
-            [&](const type::U32*) { return b.ty.atomic(CreateASTTypeFor(ctx, ty)); },
-            [&](const type::Struct* str) { return b.ty(Fork(str).name); },
-            [&](const type::Array* arr) {
-                if (arr->Count()->Is<type::RuntimeArrayCount>()) {
+            [&](const core::type::I32*) { return b.ty.atomic(CreateASTTypeFor(ctx, ty)); },
+            [&](const core::type::U32*) { return b.ty.atomic(CreateASTTypeFor(ctx, ty)); },
+            [&](const core::type::Struct* str) { return b.ty(Fork(str).name); },
+            [&](const core::type::Array* arr) {
+                if (arr->Count()->Is<core::type::RuntimeArrayCount>()) {
                     return b.ty.array(AtomicTypeFor(arr->ElemType()));
                 }
                 auto count = arr->ConstantCount();
@@ -216,11 +216,11 @@
                 }
                 return b.ty.array(AtomicTypeFor(arr->ElemType()), u32(count.value()));
             },
-            [&](const type::Pointer* ptr) {
+            [&](const core::type::Pointer* ptr) {
                 return b.ty.ptr(ptr->AddressSpace(), AtomicTypeFor(ptr->StoreType()),
                                 ptr->Access());
             },
-            [&](const type::Reference* ref) { return AtomicTypeFor(ref->StoreType()); },
+            [&](const core::type::Reference* ref) { return AtomicTypeFor(ref->StoreType()); },
             [&](Default) {
                 TINT_ICE() << "unhandled type: " << ty->FriendlyName();
                 return Type{};
@@ -230,7 +230,7 @@
     void ReplaceLoadsAndStores() {
         // Returns true if 'e' is a reference to an atomic variable or struct member
         auto is_ref_to_atomic_var = [&](const sem::ValueExpression* e) {
-            if (tint::Is<type::Reference>(e->Type()) && e->RootIdentifier() &&
+            if (tint::Is<core::type::Reference>(e->Type()) && e->RootIdentifier() &&
                 (atomic_variables.count(e->RootIdentifier()) != 0)) {
                 // If it's a struct member, make sure it's one we marked as atomic
                 if (auto* ma = e->As<sem::StructMemberAccess>()) {
diff --git a/src/tint/lang/wgsl/ast/transform/std140.cc b/src/tint/lang/wgsl/ast/transform/std140.cc
index fafaea0..6b2b6a2 100644
--- a/src/tint/lang/wgsl/ast/transform/std140.cc
+++ b/src/tint/lang/wgsl/ast/transform/std140.cc
@@ -132,11 +132,11 @@
     /// @returns true if this transform should be run for the given program
     bool ShouldRun() const {
         // Returns true if the type needs to be forked for std140 usage.
-        auto needs_fork = [&](const type::Type* ty) {
-            while (auto* arr = ty->As<type::Array>()) {
+        auto needs_fork = [&](const core::type::Type* ty) {
+            while (auto* arr = ty->As<core::type::Array>()) {
                 ty = arr->ElemType();
             }
-            if (auto* mat = ty->As<type::Matrix>()) {
+            if (auto* mat = ty->As<core::type::Matrix>()) {
                 if (MatrixNeedsDecomposing(mat)) {
                     return true;
                 }
@@ -146,7 +146,7 @@
 
         // Scan structures for members that need forking
         for (auto* ty : src->Types()) {
-            if (auto* str = ty->As<type::Struct>()) {
+            if (auto* str = ty->As<core::type::Struct>()) {
                 if (str->UsedAs(core::AddressSpace::kUniform)) {
                     for (auto* member : str->Members()) {
                         if (needs_fork(member->Type())) {
@@ -222,17 +222,18 @@
     Hashmap<LoadFnKey, Symbol, 8, LoadFnKey::Hasher> load_fns;
 
     /// Map of std140-forked type to converter function name
-    Hashmap<const type::Type*, Symbol, 8> conv_fns;
+    Hashmap<const core::type::Type*, Symbol, 8> conv_fns;
 
     // Uniform variables that have been modified to use a std140 type
     Hashset<const sem::Variable*, 8> std140_uniforms;
 
     // Map of original structure to 'std140' forked structure
-    Hashmap<const type::Struct*, Symbol, 8> std140_structs;
+    Hashmap<const core::type::Struct*, Symbol, 8> std140_structs;
 
     // Map of structure member in src of a matrix type, to list of decomposed column
     // members in ctx.dst.
-    Hashmap<const type::StructMember*, tint::Vector<const StructMember*, 4>, 8> std140_mat_members;
+    Hashmap<const core::type::StructMember*, tint::Vector<const StructMember*, 4>, 8>
+        std140_mat_members;
 
     /// Describes a matrix that has been forked to a std140-structure holding the decomposed column
     /// vectors of the matrix.
@@ -244,7 +245,7 @@
     };
 
     // Map of matrix type in src, to decomposed column structure in ctx.dst.
-    Hashmap<const type::Matrix*, Std140Matrix, 8> std140_mats;
+    Hashmap<const core::type::Matrix*, Std140Matrix, 8> std140_mats;
 
     /// AccessChain describes a chain of access expressions to uniform buffer variable.
     struct AccessChain {
@@ -256,7 +257,7 @@
         tint::Vector<const sem::ValueExpression*, 8> dynamic_indices;
         /// The type of the std140-decomposed matrix being accessed.
         /// May be nullptr if the chain does not pass through a std140-decomposed matrix.
-        const type::Matrix* std140_mat_ty = nullptr;
+        const core::type::Matrix* std140_mat_ty = nullptr;
         /// The index in #indices of the access that resolves to the std140-decomposed matrix.
         /// May hold no value if the chain does not pass through a std140-decomposed matrix.
         std::optional<size_t> std140_mat_idx;
@@ -269,7 +270,7 @@
 
     /// @returns true if the given matrix needs decomposing to column vectors for std140 layout.
     /// Std140 layout require matrix stride to be 16, otherwise decomposing is needed.
-    static bool MatrixNeedsDecomposing(const type::Matrix* mat) {
+    static bool MatrixNeedsDecomposing(const core::type::Matrix* mat) {
         return mat->ColumnStride() != 16;
     }
 
@@ -287,7 +288,7 @@
                 bool fork_std140 = false;
                 tint::Vector<const StructMember*, 8> members;
                 for (auto* member : str->Members()) {
-                    if (auto* mat = member->Type()->As<type::Matrix>()) {
+                    if (auto* mat = member->Type()->As<core::type::Matrix>()) {
                         // Is this member a matrix that needs decomposition for std140-layout?
                         if (MatrixNeedsDecomposing(mat)) {
                             // Structure member of matrix type needs decomposition.
@@ -399,16 +400,16 @@
     ///          If the semantic type is not split for std140-layout, then nullptr is returned.
     /// @note will construct new std140 structures to hold decomposed matrices, populating
     ///       #std140_mats.
-    Type Std140Type(const type::Type* ty) {
+    Type Std140Type(const core::type::Type* ty) {
         return Switch(
             ty,  //
-            [&](const type::Struct* str) {
+            [&](const core::type::Struct* str) {
                 if (auto std140 = std140_structs.Find(str)) {
                     return b.ty(*std140);
                 }
                 return Type{};
             },
-            [&](const type::Matrix* mat) {
+            [&](const core::type::Matrix* mat) {
                 if (MatrixNeedsDecomposing(mat)) {
                     auto std140_mat = std140_mats.GetOrCreate(mat, [&] {
                         auto name = b.Symbols().New("mat" + std::to_string(mat->columns()) + "x" +
@@ -427,7 +428,7 @@
                 }
                 return Type{};
             },
-            [&](const type::Array* arr) {
+            [&](const core::type::Array* arr) {
                 if (auto std140 = Std140Type(arr->ElemType())) {
                     tint::Vector<const Attribute*, 1> attrs;
                     if (!arr->IsStrideImplicit()) {
@@ -454,7 +455,7 @@
     /// @param size the size in bytes of the matrix.
     /// @returns a vector of decomposed matrix column vectors as structure members (in ctx.dst).
     tint::Vector<const StructMember*, 4> DecomposedMatrixStructMembers(
-        const type::Matrix* mat,
+        const core::type::Matrix* mat,
         const std::string& name_prefix,
         uint32_t align,
         uint32_t size) {
@@ -517,7 +518,7 @@
                         access.indices.Push(UniformVariable{});
                         return Action::kStop;
                     }
-                    if (TINT_LIKELY(user->Variable()->Type()->Is<type::Pointer>())) {
+                    if (TINT_LIKELY(user->Variable()->Type()->Is<core::type::Pointer>())) {
                         // Found a pointer. As the root identifier is a uniform buffer variable,
                         // this must be a pointer-let. Continue traversing from the let
                         // initializer.
@@ -533,7 +534,7 @@
                     if (std140_mat_members.Contains(a->Member())) {
                         // Record this on the access.
                         access.std140_mat_idx = access.indices.Length();
-                        access.std140_mat_ty = expr->Type()->UnwrapRef()->As<type::Matrix>();
+                        access.std140_mat_ty = expr->Type()->UnwrapRef()->As<core::type::Matrix>();
                     }
                     // Structure member accesses are always statically indexed
                     access.indices.Push(u32(a->Member()->Index()));
@@ -551,7 +552,7 @@
                     expr = a->Object();
 
                     // Is the object a std140 decomposed matrix?
-                    if (auto* mat = expr->Type()->UnwrapRef()->As<type::Matrix>()) {
+                    if (auto* mat = expr->Type()->UnwrapRef()->As<core::type::Matrix>()) {
                         if (std140_mats.Contains(mat)) {
                             // Record this on the access.
                             access.std140_mat_idx = access.indices.Length();
@@ -623,11 +624,11 @@
 
     /// @returns a name suffix for a std140 -> non-std140 conversion function based on the type
     ///          being converted.
-    const std::string ConvertSuffix(const type::Type* ty) {
+    const std::string ConvertSuffix(const core::type::Type* ty) {
         return Switch(
             ty,  //
-            [&](const type::Struct* str) { return str->Name().Name(); },
-            [&](const type::Array* arr) {
+            [&](const core::type::Struct* str) { return str->Name().Name(); },
+            [&](const core::type::Array* arr) {
                 auto count = arr->ConstantCount();
                 if (TINT_UNLIKELY(!count)) {
                     // Non-constant counts should not be possible:
@@ -639,12 +640,12 @@
                 }
                 return "arr" + std::to_string(count.value()) + "_" + ConvertSuffix(arr->ElemType());
             },
-            [&](const type::Matrix* mat) {
+            [&](const core::type::Matrix* mat) {
                 return "mat" + std::to_string(mat->columns()) + "x" + std::to_string(mat->rows()) +
                        "_" + ConvertSuffix(mat->type());
             },
-            [&](const type::F32*) { return "f32"; },  //
-            [&](const type::F16*) { return "f16"; },
+            [&](const core::type::F32*) { return "f32"; },  //
+            [&](const core::type::F16*) { return "f16"; },
             [&](Default) {
                 TINT_ICE() << "unhandled type for conversion name: " << ty->FriendlyName();
                 return "";
@@ -656,7 +657,7 @@
     /// @param chain the access chain from a uniform buffer to the value to load.
     const Expression* LoadWithConvert(const AccessChain& chain) {
         const Expression* expr = nullptr;
-        const type::Type* ty = nullptr;
+        const core::type::Type* ty = nullptr;
         auto dynamic_index = [&](size_t idx) {
             return ctx.Clone(chain.dynamic_indices[idx]->Declaration());
         };
@@ -672,7 +673,7 @@
     /// std140-forked type to the type @p ty. If @p expr is not a std140-forked type, then Convert()
     /// will simply return @p expr.
     /// @returns the converted value expression.
-    const Expression* Convert(const type::Type* ty, const Expression* expr) {
+    const Expression* Convert(const core::type::Type* ty, const Expression* expr) {
         // Get an existing, or create a new function for converting the std140 type to ty.
         auto fn = conv_fns.GetOrCreate(ty, [&] {
             auto std140_ty = Std140Type(ty);
@@ -688,7 +689,7 @@
 
             Switch(
                 ty,  //
-                [&](const type::Struct* str) {
+                [&](const core::type::Struct* str) {
                     // Convert each of the structure members using either a converter function
                     // call, or by reassembling a std140 matrix from column vector members.
                     tint::Vector<const Expression*, 8> args;
@@ -709,7 +710,7 @@
                     }
                     stmts.Push(b.Return(b.Call(CreateASTTypeFor(ctx, ty), std::move(args))));
                 },  //
-                [&](const type::Matrix* mat) {
+                [&](const core::type::Matrix* mat) {
                     // Reassemble a std140 matrix from the structure of column vector members.
                     auto std140_mat = std140_mats.Get(mat);
                     if (TINT_LIKELY(std140_mat)) {
@@ -725,7 +726,7 @@
                             << "failed to find std140 matrix info for: " << ty->FriendlyName();
                     }
                 },  //
-                [&](const type::Array* arr) {
+                [&](const core::type::Array* arr) {
                     // Converting an array. Create a function var for the converted array, and
                     // loop over the input elements, converting each and assigning the result to
                     // the local array.
@@ -810,7 +811,7 @@
         };
 
         const Expression* expr = nullptr;
-        const type::Type* ty = nullptr;
+        const core::type::Type* ty = nullptr;
 
         // Build the expression up to, but not including the matrix member
         auto std140_mat_idx = *chain.std140_mat_idx;
@@ -824,13 +825,13 @@
         // As this is accessing only part of the matrix, we just need to pick the right column
         // vector member.
         auto column_idx = std::get<u32>(chain.indices[std140_mat_idx + 1]);
-        if (auto* str = tint::As<type::Struct>(ty)) {
+        if (auto* str = tint::As<core::type::Struct>(ty)) {
             // Structure member matrix. The columns are decomposed into the structure.
             auto mat_member_idx = std::get<u32>(chain.indices[std140_mat_idx]);
             auto* mat_member = str->Members()[mat_member_idx];
             auto mat_columns = *std140_mat_members.Get(mat_member);
             expr = b.MemberAccessor(expr, mat_columns[column_idx]->name->symbol);
-            ty = mat_member->Type()->As<type::Matrix>()->ColumnType();
+            ty = mat_member->Type()->As<core::type::Matrix>()->ColumnType();
         } else {
             // Non-structure-member matrix. The columns are decomposed into a new, bespoke std140
             // structure.
@@ -838,8 +839,8 @@
                 BuildAccessExpr(expr, ty, chain, std140_mat_idx, dynamic_index);
             expr = new_expr;
             ty = new_ty;
-            auto* mat = ty->As<type::Matrix>();
-            auto std140_mat = std140_mats.Get(ty->As<type::Matrix>());
+            auto* mat = ty->As<core::type::Matrix>();
+            auto std140_mat = std140_mats.Get(ty->As<core::type::Matrix>());
             expr = b.MemberAccessor(expr, std140_mat->columns[column_idx]);
             ty = mat->ColumnType();
         }
@@ -886,13 +887,13 @@
         tint::Vector<const CaseStatement*, 4> cases;
 
         // The function return type.
-        const type::Type* ret_ty = nullptr;
+        const core::type::Type* ret_ty = nullptr;
 
         // Build switch() cases for each column of the matrix
         auto num_columns = chain.std140_mat_ty->columns();
         for (uint32_t column_idx = 0; column_idx < num_columns; column_idx++) {
             const Expression* expr = nullptr;
-            const type::Type* ty = nullptr;
+            const core::type::Type* ty = nullptr;
 
             // Build the expression up to, but not including the matrix
             for (size_t i = 0; i < std140_mat_idx; i++) {
@@ -905,7 +906,7 @@
                 }
             }
 
-            if (auto* str = tint::As<type::Struct>(ty)) {
+            if (auto* str = tint::As<core::type::Struct>(ty)) {
                 // Structure member matrix. The columns are decomposed into the structure.
                 auto mat_member_idx = std::get<u32>(chain.indices[std140_mat_idx]);
                 auto* mat_member = str->Members()[mat_member_idx];
@@ -915,7 +916,7 @@
                 }
                 auto mat_columns = *std140_mat_members.Get(mat_member);
                 expr = b.MemberAccessor(expr, mat_columns[column_idx]->name->symbol);
-                ty = mat_member->Type()->As<type::Matrix>()->ColumnType();
+                ty = mat_member->Type()->As<core::type::Matrix>()->ColumnType();
             } else {
                 // Non-structure-member matrix. The columns are decomposed into a new, bespoke
                 // std140 structure.
@@ -926,8 +927,8 @@
                 if (column_idx == 0) {
                     name += "_" + mat_name + "_p" + std::to_string(column_param_idx);
                 }
-                auto* mat = ty->As<type::Matrix>();
-                auto std140_mat = std140_mats.Get(ty->As<type::Matrix>());
+                auto* mat = ty->As<core::type::Matrix>();
+                auto std140_mat = std140_mats.Get(ty->As<core::type::Matrix>());
                 expr = b.MemberAccessor(expr, std140_mat->columns[column_idx]);
                 ty = mat->ColumnType();
             }
@@ -984,7 +985,7 @@
         };
 
         const Expression* expr = nullptr;
-        const type::Type* ty = nullptr;
+        const core::type::Type* ty = nullptr;
         std::string name = "load";
 
         // Build the expression up to, but not including the matrix member
@@ -1004,7 +1005,7 @@
         stmts.Push(b.Decl(let));
 
         tint::Vector<const MemberAccessorExpression*, 4> columns;
-        if (auto* str = tint::As<type::Struct>(ty)) {
+        if (auto* str = tint::As<core::type::Struct>(ty)) {
             // Structure member matrix. The columns are decomposed into the structure.
             auto mat_member_idx = std::get<u32>(chain.indices[std140_mat_idx]);
             auto* mat_member = str->Members()[mat_member_idx];
@@ -1020,8 +1021,8 @@
             auto [new_expr, new_ty, mat_name] =
                 BuildAccessExpr(expr, ty, chain, std140_mat_idx, dynamic_index);
             expr = new_expr;
-            auto* mat = ty->As<type::Matrix>();
-            auto std140_mat = std140_mats.Get(ty->As<type::Matrix>());
+            auto* mat = ty->As<core::type::Matrix>();
+            auto std140_mat = std140_mats.Get(ty->As<core::type::Matrix>());
             columns = tint::Transform(std140_mat->columns, [&](auto column_name) {
                 return b.MemberAccessor(b.Deref(let), column_name);
             });
@@ -1047,7 +1048,7 @@
         /// The new, post-access expression
         const Expression* expr;
         /// The type of #expr
-        const type::Type* type;
+        const core::type::Type* type;
         /// A name segment which can be used to build sensible names for helper functions
         std::string name;
     };
@@ -1060,7 +1061,7 @@
     /// @returns a ExprTypeName which holds the new expression, new type and a name segment which
     ///          can be used for creating helper function names.
     ExprTypeName BuildAccessExpr(const Expression* lhs,
-                                 const type::Type* ty,
+                                 const core::type::Type* ty,
                                  const AccessChain& chain,
                                  size_t index,
                                  std::function<const Expression*(size_t)> dynamic_index) {
@@ -1079,17 +1080,17 @@
             auto name = "p" + std::to_string(dyn_idx->slot);
             return Switch(
                 ty,  //
-                [&](const type::Array* arr) -> ExprTypeName {
+                [&](const core::type::Array* arr) -> ExprTypeName {
                     auto* idx = dynamic_index(dyn_idx->slot);
                     auto* expr = b.IndexAccessor(lhs, idx);
                     return {expr, arr->ElemType(), name};
                 },  //
-                [&](const type::Matrix* mat) -> ExprTypeName {
+                [&](const core::type::Matrix* mat) -> ExprTypeName {
                     auto* idx = dynamic_index(dyn_idx->slot);
                     auto* expr = b.IndexAccessor(lhs, idx);
                     return {expr, mat->ColumnType(), name};
                 },  //
-                [&](const type::Vector* vec) -> ExprTypeName {
+                [&](const core::type::Vector* vec) -> ExprTypeName {
                     auto* idx = dynamic_index(dyn_idx->slot);
                     auto* expr = b.IndexAccessor(lhs, idx);
                     return {expr, vec->type(), name};
@@ -1103,13 +1104,13 @@
             /// The access is a vector swizzle.
             return Switch(
                 ty,  //
-                [&](const type::Vector* vec) -> ExprTypeName {
+                [&](const core::type::Vector* vec) -> ExprTypeName {
                     static const char xyzw[] = {'x', 'y', 'z', 'w'};
                     std::string rhs;
                     for (auto el : *swizzle) {
                         rhs += xyzw[el];
                     }
-                    auto swizzle_ty = src->Types().Find<type::Vector>(
+                    auto swizzle_ty = src->Types().Find<core::type::Vector>(
                         vec->type(), static_cast<uint32_t>(swizzle->Length()));
                     auto* expr = b.MemberAccessor(lhs, rhs);
                     return {expr, swizzle_ty, rhs};
@@ -1123,22 +1124,22 @@
         auto idx = std::get<u32>(access);
         return Switch(
             ty,  //
-            [&](const type::Struct* str) -> ExprTypeName {
+            [&](const core::type::Struct* str) -> ExprTypeName {
                 auto* member = str->Members()[idx];
                 auto member_name = member->Name().Name();
                 auto* expr = b.MemberAccessor(lhs, member_name);
                 ty = member->Type();
                 return {expr, ty, member_name};
             },  //
-            [&](const type::Array* arr) -> ExprTypeName {
+            [&](const core::type::Array* arr) -> ExprTypeName {
                 auto* expr = b.IndexAccessor(lhs, idx);
                 return {expr, arr->ElemType(), std::to_string(idx)};
             },  //
-            [&](const type::Matrix* mat) -> ExprTypeName {
+            [&](const core::type::Matrix* mat) -> ExprTypeName {
                 auto* expr = b.IndexAccessor(lhs, idx);
                 return {expr, mat->ColumnType(), std::to_string(idx)};
             },  //
-            [&](const type::Vector* vec) -> ExprTypeName {
+            [&](const core::type::Vector* vec) -> ExprTypeName {
                 auto* expr = b.IndexAccessor(lhs, idx);
                 return {expr, vec->type(), std::to_string(idx)};
             },  //
diff --git a/src/tint/lang/wgsl/ast/transform/substitute_override.cc b/src/tint/lang/wgsl/ast/transform/substitute_override.cc
index 817b1bf..07cd479 100644
--- a/src/tint/lang/wgsl/ast/transform/substitute_override.cc
+++ b/src/tint/lang/wgsl/ast/transform/substitute_override.cc
@@ -85,11 +85,11 @@
         auto value = iter->second;
         auto* ctor = Switch(
             sem->Type(),
-            [&](const type::Bool*) { return b.Expr(!std::equal_to<double>()(value, 0.0)); },
-            [&](const type::I32*) { return b.Expr(i32(value)); },
-            [&](const type::U32*) { return b.Expr(u32(value)); },
-            [&](const type::F32*) { return b.Expr(f32(value)); },
-            [&](const type::F16*) { return b.Expr(f16(value)); });
+            [&](const core::type::Bool*) { return b.Expr(!std::equal_to<double>()(value, 0.0)); },
+            [&](const core::type::I32*) { return b.Expr(i32(value)); },
+            [&](const core::type::U32*) { return b.Expr(u32(value)); },
+            [&](const core::type::F32*) { return b.Expr(f32(value)); },
+            [&](const core::type::F16*) { return b.Expr(f16(value)); });
 
         if (!ctor) {
             b.Diagnostics().add_error(diag::System::Transform,
diff --git a/src/tint/lang/wgsl/ast/transform/texture_1d_to_2d.cc b/src/tint/lang/wgsl/ast/transform/texture_1d_to_2d.cc
index e038ba1..f0cc8c8 100644
--- a/src/tint/lang/wgsl/ast/transform/texture_1d_to_2d.cc
+++ b/src/tint/lang/wgsl/ast/transform/texture_1d_to_2d.cc
@@ -40,8 +40,8 @@
                 const auto& signature = builtin->Signature();
                 auto texture = signature.Parameter(core::ParameterUsage::kTexture);
                 if (texture) {
-                    auto* tex = texture->Type()->As<type::Texture>();
-                    if (tex->dim() == type::TextureDimension::k1d) {
+                    auto* tex = texture->Type()->As<core::type::Texture>();
+                    if (tex->dim() == core::type::TextureDimension::k1d) {
                         return true;
                     }
                 }
@@ -51,11 +51,11 @@
     for (auto* var : program->AST().GlobalVariables()) {
         if (Switch(
                 program->Sem().Get(var)->Type()->UnwrapRef(),
-                [&](const type::SampledTexture* tex) {
-                    return tex->dim() == type::TextureDimension::k1d;
+                [&](const core::type::SampledTexture* tex) {
+                    return tex->dim() == core::type::TextureDimension::k1d;
                 },
-                [&](const type::StorageTexture* storage_tex) {
-                    return storage_tex->dim() == type::TextureDimension::k1d;
+                [&](const core::type::StorageTexture* storage_tex) {
+                    return storage_tex->dim() == core::type::TextureDimension::k1d;
                 })) {
             return true;
         }
@@ -98,18 +98,18 @@
         ctx.ReplaceAll([&](const Variable* v) -> const Variable* {
             const Variable* r = Switch(
                 sem.Get(v)->Type()->UnwrapRef(),
-                [&](const type::SampledTexture* tex) -> const Variable* {
-                    if (tex->dim() == type::TextureDimension::k1d) {
-                        auto type = ctx.dst->ty.sampled_texture(type::TextureDimension::k2d,
+                [&](const core::type::SampledTexture* tex) -> const Variable* {
+                    if (tex->dim() == core::type::TextureDimension::k1d) {
+                        auto type = ctx.dst->ty.sampled_texture(core::type::TextureDimension::k2d,
                                                                 CreateASTTypeFor(ctx, tex->type()));
                         return create_var(v, type);
                     } else {
                         return nullptr;
                     }
                 },
-                [&](const type::StorageTexture* storage_tex) -> const Variable* {
-                    if (storage_tex->dim() == type::TextureDimension::k1d) {
-                        auto type = ctx.dst->ty.storage_texture(type::TextureDimension::k2d,
+                [&](const core::type::StorageTexture* storage_tex) -> const Variable* {
+                    if (storage_tex->dim() == core::type::TextureDimension::k1d) {
+                        auto type = ctx.dst->ty.storage_texture(core::type::TextureDimension::k2d,
                                                                 storage_tex->texel_format(),
                                                                 storage_tex->access());
                         return create_var(v, type);
@@ -135,8 +135,8 @@
             if (!texture) {
                 return nullptr;
             }
-            auto* tex = texture->Type()->As<type::Texture>();
-            if (tex->dim() != type::TextureDimension::k1d) {
+            auto* tex = texture->Type()->As<core::type::Texture>();
+            if (tex->dim() != core::type::TextureDimension::k1d) {
                 return nullptr;
             }
 
diff --git a/src/tint/lang/wgsl/ast/transform/transform.cc b/src/tint/lang/wgsl/ast/transform/transform.cc
index 8c78229..fc3006f 100644
--- a/src/tint/lang/wgsl/ast/transform/transform.cc
+++ b/src/tint/lang/wgsl/ast/transform/transform.cc
@@ -64,30 +64,30 @@
     TINT_ICE() << "unable to remove statement from parent of type " << sem->TypeInfo().name;
 }
 
-Type Transform::CreateASTTypeFor(program::CloneContext& ctx, const type::Type* ty) {
-    if (ty->Is<type::Void>()) {
+Type Transform::CreateASTTypeFor(program::CloneContext& ctx, const core::type::Type* ty) {
+    if (ty->Is<core::type::Void>()) {
         return Type{};
     }
-    if (ty->Is<type::I32>()) {
+    if (ty->Is<core::type::I32>()) {
         return ctx.dst->ty.i32();
     }
-    if (ty->Is<type::U32>()) {
+    if (ty->Is<core::type::U32>()) {
         return ctx.dst->ty.u32();
     }
-    if (ty->Is<type::F16>()) {
+    if (ty->Is<core::type::F16>()) {
         return ctx.dst->ty.f16();
     }
-    if (ty->Is<type::F32>()) {
+    if (ty->Is<core::type::F32>()) {
         return ctx.dst->ty.f32();
     }
-    if (ty->Is<type::Bool>()) {
+    if (ty->Is<core::type::Bool>()) {
         return ctx.dst->ty.bool_();
     }
-    if (auto* m = ty->As<type::Matrix>()) {
+    if (auto* m = ty->As<core::type::Matrix>()) {
         auto el = CreateASTTypeFor(ctx, m->type());
         return ctx.dst->ty.mat(el, m->columns(), m->rows());
     }
-    if (auto* v = ty->As<type::Vector>()) {
+    if (auto* v = ty->As<core::type::Vector>()) {
         auto el = CreateASTTypeFor(ctx, v->type());
         if (v->Packed()) {
             TINT_ASSERT(v->Width() == 3u);
@@ -96,13 +96,13 @@
             return ctx.dst->ty.vec(el, v->Width());
         }
     }
-    if (auto* a = ty->As<type::Array>()) {
+    if (auto* a = ty->As<core::type::Array>()) {
         auto el = CreateASTTypeFor(ctx, a->ElemType());
         tint::Vector<const Attribute*, 1> attrs;
         if (!a->IsStrideImplicit()) {
             attrs.Push(ctx.dst->create<StrideAttribute>(a->Stride()));
         }
-        if (a->Count()->Is<type::RuntimeArrayCount>()) {
+        if (a->Count()->Is<core::type::RuntimeArrayCount>()) {
             return ctx.dst->ty.array(el, std::move(attrs));
         }
         if (auto* override = a->Count()->As<sem::NamedOverrideArrayCount>()) {
@@ -128,43 +128,43 @@
         }
         auto count = a->ConstantCount();
         if (TINT_UNLIKELY(!count)) {
-            TINT_ICE() << type::Array::kErrExpectedConstantCount;
+            TINT_ICE() << core::type::Array::kErrExpectedConstantCount;
             return ctx.dst->ty.array(el, u32(1), std::move(attrs));
         }
         return ctx.dst->ty.array(el, u32(count.value()), std::move(attrs));
     }
-    if (auto* s = ty->As<type::Struct>()) {
+    if (auto* s = ty->As<core::type::Struct>()) {
         return ctx.dst->ty(ctx.Clone(s->Name()));
     }
-    if (auto* s = ty->As<type::Reference>()) {
+    if (auto* s = ty->As<core::type::Reference>()) {
         return CreateASTTypeFor(ctx, s->StoreType());
     }
-    if (auto* a = ty->As<type::Atomic>()) {
+    if (auto* a = ty->As<core::type::Atomic>()) {
         return ctx.dst->ty.atomic(CreateASTTypeFor(ctx, a->Type()));
     }
-    if (auto* t = ty->As<type::DepthTexture>()) {
+    if (auto* t = ty->As<core::type::DepthTexture>()) {
         return ctx.dst->ty.depth_texture(t->dim());
     }
-    if (auto* t = ty->As<type::DepthMultisampledTexture>()) {
+    if (auto* t = ty->As<core::type::DepthMultisampledTexture>()) {
         return ctx.dst->ty.depth_multisampled_texture(t->dim());
     }
-    if (ty->Is<type::ExternalTexture>()) {
+    if (ty->Is<core::type::ExternalTexture>()) {
         return ctx.dst->ty.external_texture();
     }
-    if (auto* t = ty->As<type::MultisampledTexture>()) {
+    if (auto* t = ty->As<core::type::MultisampledTexture>()) {
         return ctx.dst->ty.multisampled_texture(t->dim(), CreateASTTypeFor(ctx, t->type()));
     }
-    if (auto* t = ty->As<type::SampledTexture>()) {
+    if (auto* t = ty->As<core::type::SampledTexture>()) {
         return ctx.dst->ty.sampled_texture(t->dim(), CreateASTTypeFor(ctx, t->type()));
     }
-    if (auto* t = ty->As<type::StorageTexture>()) {
+    if (auto* t = ty->As<core::type::StorageTexture>()) {
         return ctx.dst->ty.storage_texture(t->dim(), t->texel_format(), t->access());
     }
-    if (auto* s = ty->As<type::Sampler>()) {
+    if (auto* s = ty->As<core::type::Sampler>()) {
         return ctx.dst->ty.sampler(s->kind());
     }
-    if (auto* p = ty->As<type::Pointer>()) {
-        // Note: type::Pointer always has an inferred access, but WGSL only allows an explicit
+    if (auto* p = ty->As<core::type::Pointer>()) {
+        // Note: core::type::Pointer always has an inferred access, but WGSL only allows an explicit
         // access in the 'storage' address space.
         auto address_space = p->AddressSpace();
         auto access =
diff --git a/src/tint/lang/wgsl/ast/transform/transform.h b/src/tint/lang/wgsl/ast/transform/transform.h
index b5a461a..8e7400c 100644
--- a/src/tint/lang/wgsl/ast/transform/transform.h
+++ b/src/tint/lang/wgsl/ast/transform/transform.h
@@ -88,7 +88,7 @@
     /// @param ctx the clone context
     /// @param ty the semantic type to reconstruct
     /// @returns an Type that when resolved, will produce the semantic type `ty`.
-    static Type CreateASTTypeFor(program::CloneContext& ctx, const type::Type* ty);
+    static Type CreateASTTypeFor(program::CloneContext& ctx, const core::type::Type* ty);
 
   protected:
     /// Removes the statement `stmt` from the transformed program.
diff --git a/src/tint/lang/wgsl/ast/transform/transform_test.cc b/src/tint/lang/wgsl/ast/transform/transform_test.cc
index f708ec9..0c6de47 100644
--- a/src/tint/lang/wgsl/ast/transform/transform_test.cc
+++ b/src/tint/lang/wgsl/ast/transform/transform_test.cc
@@ -33,7 +33,7 @@
         return SkipTransform;
     }
 
-    Type create(std::function<type::Type*(ProgramBuilder&)> create_sem_type) {
+    Type create(std::function<core::type::Type*(ProgramBuilder&)> create_sem_type) {
         ProgramBuilder sem_type_builder;
         auto* sem_type = create_sem_type(sem_type_builder);
         Program program = resolver::Resolve(sem_type_builder);
@@ -47,33 +47,35 @@
 TEST_F(CreateASTTypeForTest, Basic) {
     auto check = [&](Type ty, const char* expect) { CheckIdentifier(ty->identifier, expect); };
 
-    check(create([](ProgramBuilder& b) { return b.create<type::I32>(); }), "i32");
-    check(create([](ProgramBuilder& b) { return b.create<type::U32>(); }), "u32");
-    check(create([](ProgramBuilder& b) { return b.create<type::F32>(); }), "f32");
-    check(create([](ProgramBuilder& b) { return b.create<type::Bool>(); }), "bool");
-    EXPECT_EQ(create([](ProgramBuilder& b) { return b.create<type::Void>(); }), nullptr);
+    check(create([](ProgramBuilder& b) { return b.create<core::type::I32>(); }), "i32");
+    check(create([](ProgramBuilder& b) { return b.create<core::type::U32>(); }), "u32");
+    check(create([](ProgramBuilder& b) { return b.create<core::type::F32>(); }), "f32");
+    check(create([](ProgramBuilder& b) { return b.create<core::type::Bool>(); }), "bool");
+    EXPECT_EQ(create([](ProgramBuilder& b) { return b.create<core::type::Void>(); }), nullptr);
 }
 
 TEST_F(CreateASTTypeForTest, Matrix) {
     auto mat = create([](ProgramBuilder& b) {
-        auto* column_type = b.create<type::Vector>(b.create<type::F32>(), 2u);
-        return b.create<type::Matrix>(column_type, 3u);
+        auto* column_type = b.create<core::type::Vector>(b.create<core::type::F32>(), 2u);
+        return b.create<core::type::Matrix>(column_type, 3u);
     });
 
     CheckIdentifier(mat, Template("mat3x2", "f32"));
 }
 
 TEST_F(CreateASTTypeForTest, Vector) {
-    auto vec =
-        create([](ProgramBuilder& b) { return b.create<type::Vector>(b.create<type::F32>(), 2u); });
+    auto vec = create([](ProgramBuilder& b) {
+        return b.create<core::type::Vector>(b.create<core::type::F32>(), 2u);
+    });
 
     CheckIdentifier(vec, Template("vec2", "f32"));
 }
 
 TEST_F(CreateASTTypeForTest, ArrayImplicitStride) {
     auto arr = create([](ProgramBuilder& b) {
-        return b.create<type::Array>(b.create<type::F32>(), b.create<type::ConstantArrayCount>(2u),
-                                     4u, 4u, 32u, 32u);
+        return b.create<core::type::Array>(b.create<core::type::F32>(),
+                                           b.create<core::type::ConstantArrayCount>(2u), 4u, 4u,
+                                           32u, 32u);
     });
 
     CheckIdentifier(arr, Template("array", "f32", 2_u));
@@ -84,8 +86,9 @@
 
 TEST_F(CreateASTTypeForTest, ArrayNonImplicitStride) {
     auto arr = create([](ProgramBuilder& b) {
-        return b.create<type::Array>(b.create<type::F32>(), b.create<type::ConstantArrayCount>(2u),
-                                     4u, 4u, 64u, 32u);
+        return b.create<core::type::Array>(b.create<core::type::F32>(),
+                                           b.create<core::type::ConstantArrayCount>(2u), 4u, 4u,
+                                           64u, 32u);
     });
     CheckIdentifier(arr, Template("array", "f32", 2_u));
     auto* tmpl_attr = arr->identifier->As<TemplatedIdentifier>();
@@ -128,8 +131,8 @@
 
 TEST_F(CreateASTTypeForTest, PrivatePointer) {
     auto ptr = create([](ProgramBuilder& b) {
-        return b.create<type::Pointer>(core::AddressSpace::kPrivate, b.create<type::I32>(),
-                                       core::Access::kReadWrite);
+        return b.create<core::type::Pointer>(core::AddressSpace::kPrivate,
+                                             b.create<core::type::I32>(), core::Access::kReadWrite);
     });
 
     CheckIdentifier(ptr, Template("ptr", "private", "i32"));
@@ -137,8 +140,8 @@
 
 TEST_F(CreateASTTypeForTest, StorageReadWritePointer) {
     auto ptr = create([](ProgramBuilder& b) {
-        return b.create<type::Pointer>(core::AddressSpace::kStorage, b.create<type::I32>(),
-                                       core::Access::kReadWrite);
+        return b.create<core::type::Pointer>(core::AddressSpace::kStorage,
+                                             b.create<core::type::I32>(), core::Access::kReadWrite);
     });
 
     CheckIdentifier(ptr, Template("ptr", "storage", "i32", "read_write"));
diff --git a/src/tint/lang/wgsl/ast/transform/var_for_dynamic_index.cc b/src/tint/lang/wgsl/ast/transform/var_for_dynamic_index.cc
index cbbd881..70df29f 100644
--- a/src/tint/lang/wgsl/ast/transform/var_for_dynamic_index.cc
+++ b/src/tint/lang/wgsl/ast/transform/var_for_dynamic_index.cc
@@ -51,7 +51,7 @@
         }
 
         auto* indexed = sem.GetVal(object_expr);
-        if (!indexed->Type()->IsAnyOf<type::Array, type::Matrix>()) {
+        if (!indexed->Type()->IsAnyOf<core::type::Array, core::type::Matrix>()) {
             // We only care about array and matrices.
             return true;
         }
diff --git a/src/tint/lang/wgsl/ast/transform/vectorize_matrix_conversions.cc b/src/tint/lang/wgsl/ast/transform/vectorize_matrix_conversions.cc
index df9a7a4..83e30ed 100644
--- a/src/tint/lang/wgsl/ast/transform/vectorize_matrix_conversions.cc
+++ b/src/tint/lang/wgsl/ast/transform/vectorize_matrix_conversions.cc
@@ -39,7 +39,7 @@
         if (auto* sem = program->Sem().GetVal(node)) {
             if (auto* call = sem->UnwrapMaterialize()->As<sem::Call>()) {
                 if (call->Target()->Is<sem::ValueConversion>() &&
-                    call->Type()->Is<type::Matrix>()) {
+                    call->Type()->Is<core::type::Matrix>()) {
                     auto& args = call->Arguments();
                     if (args.Length() == 1 && args[0]->Type()->UnwrapRef()->is_float_matrix()) {
                         return true;
@@ -68,7 +68,7 @@
     program::CloneContext ctx{&b, src, /* auto_clone_symbols */ true};
 
     using HelperFunctionKey =
-        tint::UnorderedKeyWrapper<std::tuple<const type::Matrix*, const type::Matrix*>>;
+        tint::UnorderedKeyWrapper<std::tuple<const core::type::Matrix*, const core::type::Matrix*>>;
 
     std::unordered_map<HelperFunctionKey, Symbol> matrix_convs;
 
@@ -78,7 +78,7 @@
         if (!ty_conv) {
             return nullptr;
         }
-        auto* dst_type = call->Type()->As<type::Matrix>();
+        auto* dst_type = call->Type()->As<core::type::Matrix>();
         if (!dst_type) {
             return nullptr;
         }
@@ -90,7 +90,7 @@
 
         auto& matrix = args[0];
 
-        auto* src_type = matrix->Type()->UnwrapRef()->As<type::Matrix>();
+        auto* src_type = matrix->Type()->UnwrapRef()->As<core::type::Matrix>();
         if (!src_type) {
             return nullptr;
         }
diff --git a/src/tint/lang/wgsl/ast/transform/vectorize_scalar_matrix_initializers.cc b/src/tint/lang/wgsl/ast/transform/vectorize_scalar_matrix_initializers.cc
index 52d628d..d670b91 100644
--- a/src/tint/lang/wgsl/ast/transform/vectorize_scalar_matrix_initializers.cc
+++ b/src/tint/lang/wgsl/ast/transform/vectorize_scalar_matrix_initializers.cc
@@ -34,9 +34,10 @@
 bool ShouldRun(const Program* program) {
     for (auto* node : program->ASTNodes().Objects()) {
         if (auto* call = program->Sem().Get<sem::Call>(node)) {
-            if (call->Target()->Is<sem::ValueConstructor>() && call->Type()->Is<type::Matrix>()) {
+            if (call->Target()->Is<sem::ValueConstructor>() &&
+                call->Type()->Is<core::type::Matrix>()) {
                 auto& args = call->Arguments();
-                if (!args.IsEmpty() && args[0]->Type()->UnwrapRef()->Is<type::Scalar>()) {
+                if (!args.IsEmpty() && args[0]->Type()->UnwrapRef()->Is<core::type::Scalar>()) {
                     return true;
                 }
             }
@@ -61,7 +62,7 @@
     ProgramBuilder b;
     program::CloneContext ctx{&b, src, /* auto_clone_symbols */ true};
 
-    std::unordered_map<const type::Matrix*, Symbol> scalar_inits;
+    std::unordered_map<const core::type::Matrix*, Symbol> scalar_inits;
 
     ctx.ReplaceAll([&](const CallExpression* expr) -> const CallExpression* {
         auto* call = src->Sem().Get(expr)->UnwrapMaterialize()->As<sem::Call>();
@@ -69,7 +70,7 @@
         if (!ty_init) {
             return nullptr;
         }
-        auto* mat_type = call->Type()->As<type::Matrix>();
+        auto* mat_type = call->Type()->As<core::type::Matrix>();
         if (!mat_type) {
             return nullptr;
         }
@@ -86,7 +87,7 @@
         if (args[0]
                 ->Type()
                 ->UnwrapRef()
-                ->IsAnyOf<type::Matrix, type::Vector, type::AbstractNumeric>()) {
+                ->IsAnyOf<core::type::Matrix, core::type::Vector, core::type::AbstractNumeric>()) {
             return nullptr;
         }
 
diff --git a/src/tint/lang/wgsl/ast/transform/vertex_pulling.cc b/src/tint/lang/wgsl/ast/transform/vertex_pulling.cc
index ac2fcb3..09faca7 100644
--- a/src/tint/lang/wgsl/ast/transform/vertex_pulling.cc
+++ b/src/tint/lang/wgsl/ast/transform/vertex_pulling.cc
@@ -157,22 +157,22 @@
     }
 }
 
-AttributeWGSLType WGSLTypeOf(const type::Type* ty) {
+AttributeWGSLType WGSLTypeOf(const core::type::Type* ty) {
     return Switch(
         ty,
-        [](const type::I32*) -> AttributeWGSLType {
+        [](const core::type::I32*) -> AttributeWGSLType {
             return {BaseWGSLType::kI32, 1};
         },
-        [](const type::U32*) -> AttributeWGSLType {
+        [](const core::type::U32*) -> AttributeWGSLType {
             return {BaseWGSLType::kU32, 1};
         },
-        [](const type::F32*) -> AttributeWGSLType {
+        [](const core::type::F32*) -> AttributeWGSLType {
             return {BaseWGSLType::kF32, 1};
         },
-        [](const type::F16*) -> AttributeWGSLType {
+        [](const core::type::F16*) -> AttributeWGSLType {
             return {BaseWGSLType::kF16, 1};
         },
-        [](const type::Vector* vec) -> AttributeWGSLType {
+        [](const core::type::Vector* vec) -> AttributeWGSLType {
             return {WGSLTypeOf(vec->type()).base_type, vec->Width()};
         },
         [](Default) -> AttributeWGSLType {
@@ -280,7 +280,7 @@
         /// A builder that builds the expression that resolves to the (transformed) input location
         std::function<const Expression*()> expr;
         /// The store type of the location variable
-        const type::Type* type;
+        const core::type::Type* type;
     };
 
     /// The source program
diff --git a/src/tint/lang/wgsl/ast/transform/zero_init_workgroup_memory.cc b/src/tint/lang/wgsl/ast/transform/zero_init_workgroup_memory.cc
index 3000954..a7d3c87 100644
--- a/src/tint/lang/wgsl/ast/transform/zero_init_workgroup_memory.cc
+++ b/src/tint/lang/wgsl/ast/transform/zero_init_workgroup_memory.cc
@@ -168,7 +168,7 @@
                 }
             }
 
-            if (auto* str = sem.Get(param)->Type()->As<type::Struct>()) {
+            if (auto* str = sem.Get(param)->Type()->As<core::type::Struct>()) {
                 for (auto* member : str->Members()) {
                     if (member->Attributes().builtin == core::BuiltinValue::kLocalInvocationIndex) {
                         local_index = [=] {
@@ -289,7 +289,7 @@
     /// @param ty the expression type
     /// @param get_expr a function that builds the AST nodes for the expression.
     /// @returns true on success, false on failure
-    [[nodiscard]] bool BuildZeroingStatements(const type::Type* ty,
+    [[nodiscard]] bool BuildZeroingStatements(const core::type::Type* ty,
                                               const BuildZeroingExpr& get_expr) {
         if (CanTriviallyZero(ty)) {
             auto var = get_expr(1u);
@@ -302,7 +302,7 @@
             return true;
         }
 
-        if (auto* atomic = ty->As<type::Atomic>()) {
+        if (auto* atomic = ty->As<core::type::Atomic>()) {
             auto* zero_init = b.Call(CreateASTTypeFor(ctx, atomic->Type()));
             auto expr = get_expr(1u);
             if (!expr) {
@@ -314,7 +314,7 @@
             return true;
         }
 
-        if (auto* str = ty->As<type::Struct>()) {
+        if (auto* str = ty->As<core::type::Struct>()) {
             for (auto* member : str->Members()) {
                 auto name = ctx.Clone(member->Name());
                 auto get_member = [&](uint32_t num_values) {
@@ -332,7 +332,7 @@
             return true;
         }
 
-        if (auto* arr = ty->As<type::Array>()) {
+        if (auto* arr = ty->As<core::type::Array>()) {
             auto get_el = [&](uint32_t num_values) {
                 // num_values is the number of values to zero for the element type.
                 // The number of iterations required to zero the array and its elements is:
@@ -342,7 +342,7 @@
                 auto count = arr->ConstantCount();
                 if (!count) {
                     ctx.dst->Diagnostics().add_error(diag::System::Transform,
-                                                     type::Array::kErrExpectedConstantCount);
+                                                     core::type::Array::kErrExpectedConstantCount);
                     return Expression{};  // error
                 }
                 auto modulo = num_values * count.value();
@@ -409,7 +409,7 @@
             // Constant value could not be found. Build expression instead.
             workgroup_size_expr = [this, expr, size = workgroup_size_expr] {
                 auto* e = ctx.Clone(expr);
-                if (ctx.src->TypeOf(expr)->UnwrapRef()->Is<type::I32>()) {
+                if (ctx.src->TypeOf(expr)->UnwrapRef()->Is<core::type::I32>()) {
                     e = b.Call<u32>(e);
                 }
                 return size ? b.Mul(size(), e) : e;
@@ -435,18 +435,18 @@
     /// then the type needs to be initialized by decomposing the initialization into multiple
     /// sub-initializations.
     /// @param ty the type to inspect
-    bool CanTriviallyZero(const type::Type* ty) {
-        if (ty->Is<type::Atomic>()) {
+    bool CanTriviallyZero(const core::type::Type* ty) {
+        if (ty->Is<core::type::Atomic>()) {
             return false;
         }
-        if (auto* str = ty->As<type::Struct>()) {
+        if (auto* str = ty->As<core::type::Struct>()) {
             for (auto* member : str->Members()) {
                 if (!CanTriviallyZero(member->Type())) {
                     return false;
                 }
             }
         }
-        if (ty->Is<type::Array>()) {
+        if (ty->Is<core::type::Array>()) {
             return false;
         }
         // True for all other storable types
diff --git a/src/tint/lang/wgsl/helpers/append_vector.cc b/src/tint/lang/wgsl/helpers/append_vector.cc
index 1069281..a5c547d 100644
--- a/src/tint/lang/wgsl/helpers/append_vector.cc
+++ b/src/tint/lang/wgsl/helpers/append_vector.cc
@@ -37,7 +37,7 @@
 VectorConstructorInfo AsVectorConstructor(const sem::ValueExpression* expr) {
     if (auto* call = expr->As<sem::Call>()) {
         if (auto* ctor = call->Target()->As<sem::ValueConstructor>()) {
-            if (ctor->ReturnType()->Is<type::Vector>()) {
+            if (ctor->ReturnType()->Is<core::type::Vector>()) {
                 return {call, ctor};
             }
         }
@@ -46,16 +46,16 @@
 }
 
 const sem::ValueExpression* Zero(ProgramBuilder& b,
-                                 const type::Type* ty,
+                                 const core::type::Type* ty,
                                  const sem::Statement* stmt) {
     const ast::Expression* expr = nullptr;
-    if (ty->Is<type::I32>()) {
+    if (ty->Is<core::type::I32>()) {
         expr = b.Expr(0_i);
-    } else if (ty->Is<type::U32>()) {
+    } else if (ty->Is<core::type::U32>()) {
         expr = b.Expr(0_u);
-    } else if (ty->Is<type::F32>()) {
+    } else if (ty->Is<core::type::F32>()) {
         expr = b.Expr(0_f);
-    } else if (ty->Is<type::Bool>()) {
+    } else if (ty->Is<core::type::Bool>()) {
         expr = b.Expr(false);
     } else {
         TINT_UNREACHABLE() << "unsupported vector element type: " << ty->TypeInfo().name;
@@ -74,11 +74,11 @@
                               const ast::Expression* vector_ast,
                               const ast::Expression* scalar_ast) {
     uint32_t packed_size;
-    const type::Type* packed_el_sem_ty;
+    const core::type::Type* packed_el_sem_ty;
     auto* vector_sem = b->Sem().GetVal(vector_ast);
     auto* scalar_sem = b->Sem().GetVal(scalar_ast);
     auto* vector_ty = vector_sem->Type()->UnwrapRef();
-    if (auto* vec = vector_ty->As<type::Vector>()) {
+    if (auto* vec = vector_ty->As<core::type::Vector>()) {
         packed_size = vec->Width() + 1;
         packed_el_sem_ty = vec->type();
     } else {
@@ -88,10 +88,10 @@
 
     auto packed_el_ast_ty = Switch(
         packed_el_sem_ty,  //
-        [&](const type::I32*) { return b->ty.i32(); },
-        [&](const type::U32*) { return b->ty.u32(); },
-        [&](const type::F32*) { return b->ty.f32(); },
-        [&](const type::Bool*) { return b->ty.bool_(); },
+        [&](const core::type::I32*) { return b->ty.i32(); },
+        [&](const core::type::U32*) { return b->ty.u32(); },
+        [&](const core::type::F32*) { return b->ty.f32(); },
+        [&](const core::type::Bool*) { return b->ty.bool_(); },
         [&](Default) {
             TINT_UNREACHABLE() << "unsupported vector element type: "
                                << packed_el_sem_ty->TypeInfo().name;
@@ -101,7 +101,7 @@
     auto* statement = vector_sem->Stmt();
 
     auto packed_ast_ty = b->ty.vec(packed_el_ast_ty, packed_size);
-    auto* packed_sem_ty = b->create<type::Vector>(packed_el_sem_ty, packed_size);
+    auto* packed_sem_ty = b->create<core::type::Vector>(packed_el_sem_ty, packed_size);
 
     // If the coordinates are already passed in a vector constructor, with only
     // scalar components supplied, extract the elements into the new vector
diff --git a/src/tint/lang/wgsl/helpers/append_vector_test.cc b/src/tint/lang/wgsl/helpers/append_vector_test.cc
index f340159..a876d85f 100644
--- a/src/tint/lang/wgsl/helpers/append_vector_test.cc
+++ b/src/tint/lang/wgsl/helpers/append_vector_test.cc
@@ -58,15 +58,15 @@
 
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
-    ASSERT_TRUE(ctor->ReturnType()->Is<type::Vector>());
-    EXPECT_EQ(ctor->ReturnType()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(ctor->ReturnType()->As<type::Vector>()->type()->Is<type::I32>());
+    ASSERT_TRUE(ctor->ReturnType()->Is<core::type::Vector>());
+    EXPECT_EQ(ctor->ReturnType()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(ctor->ReturnType()->As<core::type::Vector>()->type()->Is<core::type::I32>());
     EXPECT_EQ(ctor->ReturnType(), call->Type());
 
     ASSERT_EQ(ctor->Parameters().Length(), 3u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::I32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::I32>());
-    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<core::type::I32>());
 }
 
 // AppendVector(vec2<i32>(1, 2), 3u) -> vec3<i32>(1, 2, i32(3u))
@@ -104,15 +104,15 @@
 
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
-    ASSERT_TRUE(ctor->ReturnType()->Is<type::Vector>());
-    EXPECT_EQ(ctor->ReturnType()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(ctor->ReturnType()->As<type::Vector>()->type()->Is<type::I32>());
+    ASSERT_TRUE(ctor->ReturnType()->Is<core::type::Vector>());
+    EXPECT_EQ(ctor->ReturnType()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(ctor->ReturnType()->As<core::type::Vector>()->type()->Is<core::type::I32>());
     EXPECT_EQ(ctor->ReturnType(), call->Type());
 
     ASSERT_EQ(ctor->Parameters().Length(), 3u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::I32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::I32>());
-    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<core::type::I32>());
 }
 
 // AppendVector(vec2<i32>(vec2<u32>(1u, 2u)), 3u) ->
@@ -156,14 +156,14 @@
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
 
-    ASSERT_TRUE(ctor->ReturnType()->Is<type::Vector>());
-    EXPECT_EQ(ctor->ReturnType()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(ctor->ReturnType()->As<type::Vector>()->type()->Is<type::I32>());
+    ASSERT_TRUE(ctor->ReturnType()->Is<core::type::Vector>());
+    EXPECT_EQ(ctor->ReturnType()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(ctor->ReturnType()->As<core::type::Vector>()->type()->Is<core::type::I32>());
     EXPECT_EQ(ctor->ReturnType(), call->Type());
 
     ASSERT_EQ(ctor->Parameters().Length(), 2u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::I32>());
 }
 
 // AppendVector(vec2<i32>(1, 2), 3.0f) -> vec3<i32>(1, 2, i32(3.0f))
@@ -200,15 +200,15 @@
 
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
-    ASSERT_TRUE(ctor->ReturnType()->Is<type::Vector>());
-    EXPECT_EQ(ctor->ReturnType()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(ctor->ReturnType()->As<type::Vector>()->type()->Is<type::I32>());
+    ASSERT_TRUE(ctor->ReturnType()->Is<core::type::Vector>());
+    EXPECT_EQ(ctor->ReturnType()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(ctor->ReturnType()->As<core::type::Vector>()->type()->Is<core::type::I32>());
     EXPECT_EQ(ctor->ReturnType(), call->Type());
 
     ASSERT_EQ(ctor->Parameters().Length(), 3u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::I32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::I32>());
-    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<core::type::I32>());
 }
 
 // AppendVector(vec3<i32>(1, 2, 3), 4) -> vec4<i32>(1, 2, 3, 4)
@@ -244,16 +244,16 @@
 
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
-    ASSERT_TRUE(ctor->ReturnType()->Is<type::Vector>());
-    EXPECT_EQ(ctor->ReturnType()->As<type::Vector>()->Width(), 4u);
-    EXPECT_TRUE(ctor->ReturnType()->As<type::Vector>()->type()->Is<type::I32>());
+    ASSERT_TRUE(ctor->ReturnType()->Is<core::type::Vector>());
+    EXPECT_EQ(ctor->ReturnType()->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_TRUE(ctor->ReturnType()->As<core::type::Vector>()->type()->Is<core::type::I32>());
     EXPECT_EQ(ctor->ReturnType(), call->Type());
 
     ASSERT_EQ(ctor->Parameters().Length(), 4u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::I32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::I32>());
-    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<type::I32>());
-    EXPECT_TRUE(ctor->Parameters()[3]->Type()->Is<type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[3]->Type()->Is<core::type::I32>());
 }
 
 // AppendVector(vec_12, 3) -> vec3<i32>(vec_12, 3)
@@ -283,14 +283,14 @@
 
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
-    ASSERT_TRUE(ctor->ReturnType()->Is<type::Vector>());
-    EXPECT_EQ(ctor->ReturnType()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(ctor->ReturnType()->As<type::Vector>()->type()->Is<type::I32>());
+    ASSERT_TRUE(ctor->ReturnType()->Is<core::type::Vector>());
+    EXPECT_EQ(ctor->ReturnType()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(ctor->ReturnType()->As<core::type::Vector>()->type()->Is<core::type::I32>());
     EXPECT_EQ(ctor->ReturnType(), call->Type());
 
     ASSERT_EQ(ctor->Parameters().Length(), 2u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::I32>());
 }
 
 // AppendVector(1, 2, scalar_3) -> vec3<i32>(1, 2, scalar_3)
@@ -324,15 +324,15 @@
 
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
-    ASSERT_TRUE(ctor->ReturnType()->Is<type::Vector>());
-    EXPECT_EQ(ctor->ReturnType()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(ctor->ReturnType()->As<type::Vector>()->type()->Is<type::I32>());
+    ASSERT_TRUE(ctor->ReturnType()->Is<core::type::Vector>());
+    EXPECT_EQ(ctor->ReturnType()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(ctor->ReturnType()->As<core::type::Vector>()->type()->Is<core::type::I32>());
     EXPECT_EQ(ctor->ReturnType(), call->Type());
 
     ASSERT_EQ(ctor->Parameters().Length(), 3u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::I32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::I32>());
-    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<core::type::I32>());
 }
 
 // AppendVector(vec_12, scalar_3) -> vec3<i32>(vec_12, scalar_3)
@@ -363,14 +363,14 @@
 
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
-    ASSERT_TRUE(ctor->ReturnType()->Is<type::Vector>());
-    EXPECT_EQ(ctor->ReturnType()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(ctor->ReturnType()->As<type::Vector>()->type()->Is<type::I32>());
+    ASSERT_TRUE(ctor->ReturnType()->Is<core::type::Vector>());
+    EXPECT_EQ(ctor->ReturnType()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(ctor->ReturnType()->As<core::type::Vector>()->type()->Is<core::type::I32>());
     EXPECT_EQ(ctor->ReturnType(), call->Type());
 
     ASSERT_EQ(ctor->Parameters().Length(), 2u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::I32>());
 }
 
 // AppendVector(vec_12, scalar_3) -> vec3<i32>(vec_12, i32(scalar_3))
@@ -405,14 +405,14 @@
 
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
-    ASSERT_TRUE(ctor->ReturnType()->Is<type::Vector>());
-    EXPECT_EQ(ctor->ReturnType()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(ctor->ReturnType()->As<type::Vector>()->type()->Is<type::I32>());
+    ASSERT_TRUE(ctor->ReturnType()->Is<core::type::Vector>());
+    EXPECT_EQ(ctor->ReturnType()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(ctor->ReturnType()->As<core::type::Vector>()->type()->Is<core::type::I32>());
     EXPECT_EQ(ctor->ReturnType(), call->Type());
 
     ASSERT_EQ(ctor->Parameters().Length(), 2u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::I32>());
 }
 
 // AppendVector(vec_12, scalar_3) -> vec3<bool>(vec_12, scalar_3)
@@ -443,14 +443,14 @@
 
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
-    ASSERT_TRUE(ctor->ReturnType()->Is<type::Vector>());
-    EXPECT_EQ(ctor->ReturnType()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(ctor->ReturnType()->As<type::Vector>()->type()->Is<type::Bool>());
+    ASSERT_TRUE(ctor->ReturnType()->Is<core::type::Vector>());
+    EXPECT_EQ(ctor->ReturnType()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(ctor->ReturnType()->As<core::type::Vector>()->type()->Is<core::type::Bool>());
     EXPECT_EQ(ctor->ReturnType(), call->Type());
 
     ASSERT_EQ(ctor->Parameters().Length(), 2u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::Bool>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::Bool>());
 }
 
 // AppendVector(vec3<i32>(), 4) -> vec3<bool>(0, 0, 0, 4)
@@ -485,16 +485,16 @@
 
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
-    ASSERT_TRUE(ctor->ReturnType()->Is<type::Vector>());
-    EXPECT_EQ(ctor->ReturnType()->As<type::Vector>()->Width(), 4u);
-    EXPECT_TRUE(ctor->ReturnType()->As<type::Vector>()->type()->Is<type::I32>());
+    ASSERT_TRUE(ctor->ReturnType()->Is<core::type::Vector>());
+    EXPECT_EQ(ctor->ReturnType()->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_TRUE(ctor->ReturnType()->As<core::type::Vector>()->type()->Is<core::type::I32>());
     EXPECT_EQ(ctor->ReturnType(), call->Type());
 
     ASSERT_EQ(ctor->Parameters().Length(), 4u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::I32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::I32>());
-    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<type::I32>());
-    EXPECT_TRUE(ctor->Parameters()[3]->Type()->Is<type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[3]->Type()->Is<core::type::I32>());
 }
 
 }  // namespace
diff --git a/src/tint/lang/wgsl/helpers/flatten_bindings_test.cc b/src/tint/lang/wgsl/helpers/flatten_bindings_test.cc
index ac798f4..7d4b38e 100644
--- a/src/tint/lang/wgsl/helpers/flatten_bindings_test.cc
+++ b/src/tint/lang/wgsl/helpers/flatten_bindings_test.cc
@@ -92,23 +92,24 @@
                 b.Group(2_a), b.Binding(2_a));
 
     const size_t num_samplers = 2;
-    b.GlobalVar("sampler1", b.ty.sampler(type::SamplerKind::kSampler), b.Group(3_a),
+    b.GlobalVar("sampler1", b.ty.sampler(core::type::SamplerKind::kSampler), b.Group(3_a),
                 b.Binding(3_a));
-    b.GlobalVar("sampler2", b.ty.sampler(type::SamplerKind::kComparisonSampler), b.Group(4_a),
+    b.GlobalVar("sampler2", b.ty.sampler(core::type::SamplerKind::kComparisonSampler), b.Group(4_a),
                 b.Binding(4_a));
 
     const size_t num_textures = 6;
-    b.GlobalVar("texture1", b.ty.sampled_texture(type::TextureDimension::k2d, b.ty.f32()),
+    b.GlobalVar("texture1", b.ty.sampled_texture(core::type::TextureDimension::k2d, b.ty.f32()),
                 b.Group(5_a), b.Binding(5_a));
-    b.GlobalVar("texture2", b.ty.multisampled_texture(type::TextureDimension::k2d, b.ty.f32()),
+    b.GlobalVar("texture2",
+                b.ty.multisampled_texture(core::type::TextureDimension::k2d, b.ty.f32()),
                 b.Group(6_a), b.Binding(6_a));
     b.GlobalVar("texture3",
-                b.ty.storage_texture(type::TextureDimension::k2d, core::TexelFormat::kR32Float,
-                                     core::Access::kWrite),
+                b.ty.storage_texture(core::type::TextureDimension::k2d,
+                                     core::TexelFormat::kR32Float, core::Access::kWrite),
                 b.Group(7_a), b.Binding(7_a));
-    b.GlobalVar("texture4", b.ty.depth_texture(type::TextureDimension::k2d), b.Group(8_a),
+    b.GlobalVar("texture4", b.ty.depth_texture(core::type::TextureDimension::k2d), b.Group(8_a),
                 b.Binding(8_a));
-    b.GlobalVar("texture5", b.ty.depth_multisampled_texture(type::TextureDimension::k2d),
+    b.GlobalVar("texture5", b.ty.depth_multisampled_texture(core::type::TextureDimension::k2d),
                 b.Group(9_a), b.Binding(9_a));
     b.GlobalVar("texture6", b.ty.external_texture(), b.Group(10_a), b.Binding(10_a));
 
diff --git a/src/tint/lang/wgsl/inspector/inspector.cc b/src/tint/lang/wgsl/inspector/inspector.cc
index 3163a3d..8ef8162 100644
--- a/src/tint/lang/wgsl/inspector/inspector.cc
+++ b/src/tint/lang/wgsl/inspector/inspector.cc
@@ -75,23 +75,23 @@
 }
 
 std::tuple<ComponentType, CompositionType> CalculateComponentAndComposition(
-    const type::Type* type) {
+    const core::type::Type* type) {
     // entry point in/out variables must of numeric scalar or vector types.
     TINT_ASSERT(type->is_numeric_scalar_or_vector());
 
     ComponentType componentType = Switch(
         type->DeepestElement(),  //
-        [&](const type::F32*) { return ComponentType::kF32; },
-        [&](const type::F16*) { return ComponentType::kF16; },
-        [&](const type::I32*) { return ComponentType::kI32; },
-        [&](const type::U32*) { return ComponentType::kU32; },
+        [&](const core::type::F32*) { return ComponentType::kF32; },
+        [&](const core::type::F16*) { return ComponentType::kF16; },
+        [&](const core::type::I32*) { return ComponentType::kI32; },
+        [&](const core::type::U32*) { return ComponentType::kU32; },
         [&](Default) {
             TINT_UNREACHABLE() << "unhandled component type";
             return ComponentType::kUnknown;
         });
 
     CompositionType compositionType;
-    if (auto* vec = type->As<type::Vector>()) {
+    if (auto* vec = type->As<core::type::Vector>()) {
         switch (vec->Width()) {
             case 2: {
                 compositionType = CompositionType::kVec2;
@@ -177,7 +177,7 @@
             core::BuiltinValue::kNumWorkgroups, param->Type(), param->Declaration()->attributes);
     }
 
-    if (!sem->ReturnType()->Is<type::Void>()) {
+    if (!sem->ReturnType()->Is<core::type::Void>()) {
         AddEntryPointInOutVariables("<retval>", sem->ReturnType(), func->return_type_attributes,
                                     sem->ReturnLocation(), entry_point.output_variables);
 
@@ -198,11 +198,11 @@
             override.name = name;
             override.id = global->OverrideId();
             auto* type = var->Type();
-            TINT_ASSERT(type->Is<type::Scalar>());
+            TINT_ASSERT(type->Is<core::type::Scalar>());
             if (type->is_bool_scalar_or_vector()) {
                 override.type = Override::Type::kBool;
             } else if (type->is_float_scalar()) {
-                if (type->Is<type::F16>()) {
+                if (type->Is<core::type::F16>()) {
                     override.type = Override::Type::kFloat16;
                 } else {
                     override.type = Override::Type::kFloat32;
@@ -269,14 +269,14 @@
             if (auto* value = global->Initializer()->ConstantValue()) {
                 result[override_id] = Switch(
                     value->Type(),  //
-                    [&](const type::I32*) { return Scalar(value->ValueAs<i32>()); },
-                    [&](const type::U32*) { return Scalar(value->ValueAs<u32>()); },
-                    [&](const type::F32*) { return Scalar(value->ValueAs<f32>()); },
-                    [&](const type::F16*) {
+                    [&](const core::type::I32*) { return Scalar(value->ValueAs<i32>()); },
+                    [&](const core::type::U32*) { return Scalar(value->ValueAs<u32>()); },
+                    [&](const core::type::F32*) { return Scalar(value->ValueAs<f32>()); },
+                    [&](const core::type::F16*) {
                         // Default value of f16 override is also stored as float scalar.
                         return Scalar(static_cast<float>(value->ValueAs<f16>()));
                     },
-                    [&](const type::Bool*) { return Scalar(value->ValueAs<bool>()); });
+                    [&](const core::type::Bool*) { return Scalar(value->ValueAs<bool>()); });
                 continue;
             }
         }
@@ -472,7 +472,7 @@
         entry.bind_group = binding_info.group;
         entry.binding = binding_info.binding;
 
-        auto* tex = var->Type()->UnwrapRef()->As<type::Texture>();
+        auto* tex = var->Type()->UnwrapRef()->As<core::type::Texture>();
         entry.dim = TypeTextureDimensionToResourceBindingTextureDimension(tex->dim());
 
         result.push_back(entry);
@@ -483,20 +483,21 @@
 
 std::vector<ResourceBinding> Inspector::GetDepthTextureResourceBindings(
     const std::string& entry_point) {
-    return GetTextureResourceBindings(entry_point, &tint::TypeInfo::Of<type::DepthTexture>(),
+    return GetTextureResourceBindings(entry_point, &tint::TypeInfo::Of<core::type::DepthTexture>(),
                                       ResourceBinding::ResourceType::kDepthTexture);
 }
 
 std::vector<ResourceBinding> Inspector::GetDepthMultisampledTextureResourceBindings(
     const std::string& entry_point) {
     return GetTextureResourceBindings(entry_point,
-                                      &tint::TypeInfo::Of<type::DepthMultisampledTexture>(),
+                                      &tint::TypeInfo::Of<core::type::DepthMultisampledTexture>(),
                                       ResourceBinding::ResourceType::kDepthMultisampledTexture);
 }
 
 std::vector<ResourceBinding> Inspector::GetExternalTextureResourceBindings(
     const std::string& entry_point) {
-    return GetTextureResourceBindings(entry_point, &tint::TypeInfo::Of<type::ExternalTexture>(),
+    return GetTextureResourceBindings(entry_point,
+                                      &tint::TypeInfo::Of<core::type::ExternalTexture>(),
                                       ResourceBinding::ResourceType::kExternalTexture);
 }
 
@@ -602,7 +603,7 @@
 }
 
 void Inspector::AddEntryPointInOutVariables(std::string name,
-                                            const type::Type* type,
+                                            const core::type::Type* type,
                                             VectorRef<const ast::Attribute*> attributes,
                                             std::optional<uint32_t> location,
                                             std::vector<StageVariable>& variables) const {
@@ -641,7 +642,7 @@
 }
 
 bool Inspector::ContainsBuiltin(core::BuiltinValue builtin,
-                                const type::Type* type,
+                                const core::type::Type* type,
                                 VectorRef<const ast::Attribute*> attributes) const {
     auto* unwrapped_type = type->UnwrapRef();
 
@@ -725,14 +726,14 @@
         entry.bind_group = binding_info.group;
         entry.binding = binding_info.binding;
 
-        auto* texture_type = var->Type()->UnwrapRef()->As<type::Texture>();
+        auto* texture_type = var->Type()->UnwrapRef()->As<core::type::Texture>();
         entry.dim = TypeTextureDimensionToResourceBindingTextureDimension(texture_type->dim());
 
-        const type::Type* base_type = nullptr;
+        const core::type::Type* base_type = nullptr;
         if (multisampled_only) {
-            base_type = texture_type->As<type::MultisampledTexture>()->type();
+            base_type = texture_type->As<core::type::MultisampledTexture>()->type();
         } else {
-            base_type = texture_type->As<type::SampledTexture>()->type();
+            base_type = texture_type->As<core::type::SampledTexture>()->type();
         }
         entry.sampled_kind = BaseTypeToSampledKind(base_type);
 
@@ -751,11 +752,12 @@
 
     auto* func_sem = program_->Sem().Get(func);
     std::vector<ResourceBinding> result;
-    for (auto& ref : func_sem->TransitivelyReferencedVariablesOfType<type::StorageTexture>()) {
+    for (auto& ref :
+         func_sem->TransitivelyReferencedVariablesOfType<core::type::StorageTexture>()) {
         auto* var = ref.first;
         auto binding_info = ref.second;
 
-        auto* texture_type = var->Type()->UnwrapRef()->As<type::StorageTexture>();
+        auto* texture_type = var->Type()->UnwrapRef()->As<core::type::StorageTexture>();
 
         ResourceBinding entry;
         entry.resource_type = ResourceBinding::ResourceType::kWriteOnlyStorageTexture;
@@ -845,7 +847,7 @@
 }
 
 std::tuple<InterpolationType, InterpolationSampling> Inspector::CalculateInterpolationData(
-    const type::Type* type,
+    const core::type::Type* type,
     VectorRef<const ast::Attribute*> attributes) const {
     auto* interpolation_attribute = ast::GetAttribute<ast::InterpolateAttribute>(attributes);
     if (type->is_integer_scalar_or_vector()) {
diff --git a/src/tint/lang/wgsl/inspector/inspector.h b/src/tint/lang/wgsl/inspector/inspector.h
index 2e0e1b2..ec88c04 100644
--- a/src/tint/lang/wgsl/inspector/inspector.h
+++ b/src/tint/lang/wgsl/inspector/inspector.h
@@ -174,7 +174,7 @@
     /// @param location the location value if provided
     /// @param variables the list to add the variables to
     void AddEntryPointInOutVariables(std::string name,
-                                     const type::Type* type,
+                                     const core::type::Type* type,
                                      VectorRef<const ast::Attribute*> attributes,
                                      std::optional<uint32_t> location,
                                      std::vector<StageVariable>& variables) const;
@@ -183,7 +183,7 @@
     /// If `type` is a struct, recurse into members to check for the attribute.
     /// Otherwise, check `attributes` for the attribute.
     bool ContainsBuiltin(core::BuiltinValue builtin,
-                         const type::Type* type,
+                         const core::type::Type* type,
                          VectorRef<const ast::Attribute*> attributes) const;
 
     /// Gathers all the texture resource bindings of the given type for the given
@@ -226,7 +226,7 @@
     /// @param attributes attributes associated with the parameter or structure member
     /// @returns the interpolation type and sampling modes for the value
     std::tuple<InterpolationType, InterpolationSampling> CalculateInterpolationData(
-        const type::Type* type,
+        const core::type::Type* type,
         VectorRef<const ast::Attribute*> attributes) const;
 
     /// For a N-uple of expressions, resolve to the appropriate global resources
diff --git a/src/tint/lang/wgsl/inspector/inspector_builder_test.cc b/src/tint/lang/wgsl/inspector/inspector_builder_test.cc
index 2d6a6c3..5119b40 100644
--- a/src/tint/lang/wgsl/inspector/inspector_builder_test.cc
+++ b/src/tint/lang/wgsl/inspector/inspector_builder_test.cc
@@ -170,14 +170,14 @@
 }
 
 void InspectorBuilder::AddSampler(const std::string& name, uint32_t group, uint32_t binding) {
-    GlobalVar(name, ty.sampler(type::SamplerKind::kSampler), Binding(AInt(binding)),
+    GlobalVar(name, ty.sampler(core::type::SamplerKind::kSampler), Binding(AInt(binding)),
               Group(AInt(group)));
 }
 
 void InspectorBuilder::AddComparisonSampler(const std::string& name,
                                             uint32_t group,
                                             uint32_t binding) {
-    GlobalVar(name, ty.sampler(type::SamplerKind::kComparisonSampler), Binding(AInt(binding)),
+    GlobalVar(name, ty.sampler(core::type::SamplerKind::kComparisonSampler), Binding(AInt(binding)),
               Group(AInt(group)));
 }
 
@@ -260,16 +260,16 @@
     }
 }
 
-ast::Type InspectorBuilder::GetCoordsType(type::TextureDimension dim, ast::Type scalar) {
+ast::Type InspectorBuilder::GetCoordsType(core::type::TextureDimension dim, ast::Type scalar) {
     switch (dim) {
-        case type::TextureDimension::k1d:
+        case core::type::TextureDimension::k1d:
             return scalar;
-        case type::TextureDimension::k2d:
-        case type::TextureDimension::k2dArray:
+        case core::type::TextureDimension::k2d:
+        case core::type::TextureDimension::k2dArray:
             return ty.vec2(scalar);
-        case type::TextureDimension::k3d:
-        case type::TextureDimension::kCube:
-        case type::TextureDimension::kCubeArray:
+        case core::type::TextureDimension::k3d:
+        case core::type::TextureDimension::kCube:
+        case core::type::TextureDimension::kCubeArray:
             return ty.vec3(scalar);
         default:
             [=] {
@@ -281,7 +281,7 @@
     return ast::Type{};
 }
 
-ast::Type InspectorBuilder::MakeStorageTextureTypes(type::TextureDimension dim,
+ast::Type InspectorBuilder::MakeStorageTextureTypes(core::type::TextureDimension dim,
                                                     core::TexelFormat format) {
     return ty.storage_texture(dim, format, core::Access::kWrite);
 }
diff --git a/src/tint/lang/wgsl/inspector/inspector_builder_test.h b/src/tint/lang/wgsl/inspector/inspector_builder_test.h
index 1e2ec3a..84162b2 100644
--- a/src/tint/lang/wgsl/inspector/inspector_builder_test.h
+++ b/src/tint/lang/wgsl/inspector/inspector_builder_test.h
@@ -280,13 +280,13 @@
     /// @param dim dimensionality of the texture being sampled
     /// @param scalar the scalar type
     /// @returns a pointer to a type appropriate for the coord param
-    ast::Type GetCoordsType(type::TextureDimension dim, ast::Type scalar);
+    ast::Type GetCoordsType(core::type::TextureDimension dim, ast::Type scalar);
 
     /// Generates appropriate types for a Read-Only StorageTexture
     /// @param dim the texture dimension of the storage texture
     /// @param format the texel format of the storage texture
     /// @returns the storage texture type
-    ast::Type MakeStorageTextureTypes(type::TextureDimension dim, core::TexelFormat format);
+    ast::Type MakeStorageTextureTypes(core::type::TextureDimension dim, core::TexelFormat format);
 
     /// Adds a storage texture variable to the program
     /// @param name the name of the variable
diff --git a/src/tint/lang/wgsl/inspector/inspector_test.cc b/src/tint/lang/wgsl/inspector/inspector_test.cc
index 02a9421..3bf9cd3 100644
--- a/src/tint/lang/wgsl/inspector/inspector_test.cc
+++ b/src/tint/lang/wgsl/inspector/inspector_test.cc
@@ -77,7 +77,7 @@
 class InspectorGetSampledArrayTextureResourceBindingsTest : public InspectorBuilder,
                                                             public testing::Test {};
 struct GetSampledTextureTestParams {
-    type::TextureDimension type_dim;
+    core::type::TextureDimension type_dim;
     inspector::ResourceBinding::TextureDimension inspector_dim;
     inspector::ResourceBinding::SampledKind sampled_kind;
 };
@@ -101,7 +101,7 @@
 class InspectorGetStorageTextureResourceBindingsTest : public InspectorBuilder,
                                                        public testing::Test {};
 struct GetDepthTextureTestParams {
-    type::TextureDimension type_dim;
+    core::type::TextureDimension type_dim;
     inspector::ResourceBinding::TextureDimension inspector_dim;
 };
 class InspectorGetDepthTextureResourceBindingsTestWithParam
@@ -111,7 +111,7 @@
 class InspectorGetDepthMultisampledTextureResourceBindingsTest : public InspectorBuilder,
                                                                  public testing::Test {};
 
-typedef std::tuple<type::TextureDimension, ResourceBinding::TextureDimension> DimensionParams;
+typedef std::tuple<core::type::TextureDimension, ResourceBinding::TextureDimension> DimensionParams;
 typedef std::tuple<core::TexelFormat, ResourceBinding::TexelFormat, ResourceBinding::SampledKind>
     TexelFormatParams;
 typedef std::tuple<DimensionParams, TexelFormatParams> GetStorageTextureTestParams;
@@ -1830,14 +1830,14 @@
                                                 MemberInfo{0, ty.i32()},
                                             });
 
-    auto s_texture_type = ty.sampled_texture(type::TextureDimension::k1d, ty.f32());
+    auto s_texture_type = ty.sampled_texture(core::type::TextureDimension::k1d, ty.f32());
     AddResource("s_texture", s_texture_type, 2, 0);
     AddSampler("s_var", 3, 0);
     AddGlobalVariable("s_coords", ty.f32());
     MakeSamplerReferenceBodyFunction("s_func", "s_texture", "s_var", "s_coords", ty.f32(),
                                      tint::Empty);
 
-    auto cs_depth_texture_type = ty.depth_texture(type::TextureDimension::k2d);
+    auto cs_depth_texture_type = ty.depth_texture(core::type::TextureDimension::k2d);
     AddResource("cs_texture", cs_depth_texture_type, 3, 1);
     AddComparisonSampler("cs_var", 3, 2);
     AddGlobalVariable("cs_coords", ty.vec2<f32>());
@@ -1845,7 +1845,7 @@
     MakeComparisonSamplerReferenceBodyFunction("cs_func", "cs_texture", "cs_var", "cs_coords",
                                                "cs_depth", ty.f32(), tint::Empty);
 
-    auto depth_ms_texture_type = ty.depth_multisampled_texture(type::TextureDimension::k2d);
+    auto depth_ms_texture_type = ty.depth_multisampled_texture(core::type::TextureDimension::k2d);
     AddResource("depth_ms_texture", depth_ms_texture_type, 3, 3);
     Func("depth_ms_func", tint::Empty, ty.void_(),
          Vector{
@@ -1853,7 +1853,7 @@
          });
 
     auto st_type =
-        MakeStorageTextureTypes(type::TextureDimension::k2d, core::TexelFormat::kR32Uint);
+        MakeStorageTextureTypes(core::type::TextureDimension::k2d, core::TexelFormat::kR32Uint);
     AddStorageTexture("st_var", st_type, 4, 0);
     MakeStorageTextureBodyFunction("st_func", "st_var", ty.vec2<u32>(), tint::Empty);
 
@@ -2631,7 +2631,7 @@
 }
 
 TEST_F(InspectorGetSamplerResourceBindingsTest, Simple) {
-    auto sampled_texture_type = ty.sampled_texture(type::TextureDimension::k1d, ty.f32());
+    auto sampled_texture_type = ty.sampled_texture(core::type::TextureDimension::k1d, ty.f32());
     AddResource("foo_texture", sampled_texture_type, 0, 0);
     AddSampler("foo_sampler", 0, 1);
     AddGlobalVariable("foo_coords", ty.f32());
@@ -2666,7 +2666,7 @@
 }
 
 TEST_F(InspectorGetSamplerResourceBindingsTest, InFunction) {
-    auto sampled_texture_type = ty.sampled_texture(type::TextureDimension::k1d, ty.f32());
+    auto sampled_texture_type = ty.sampled_texture(core::type::TextureDimension::k1d, ty.f32());
     AddResource("foo_texture", sampled_texture_type, 0, 0);
     AddSampler("foo_sampler", 0, 1);
     AddGlobalVariable("foo_coords", ty.f32());
@@ -2691,7 +2691,7 @@
 }
 
 TEST_F(InspectorGetSamplerResourceBindingsTest, UnknownEntryPoint) {
-    auto sampled_texture_type = ty.sampled_texture(type::TextureDimension::k1d, ty.f32());
+    auto sampled_texture_type = ty.sampled_texture(core::type::TextureDimension::k1d, ty.f32());
     AddResource("foo_texture", sampled_texture_type, 0, 0);
     AddSampler("foo_sampler", 0, 1);
     AddGlobalVariable("foo_coords", ty.f32());
@@ -2708,7 +2708,7 @@
 }
 
 TEST_F(InspectorGetSamplerResourceBindingsTest, SkipsComparisonSamplers) {
-    auto depth_texture_type = ty.depth_texture(type::TextureDimension::k2d);
+    auto depth_texture_type = ty.depth_texture(core::type::TextureDimension::k2d);
     AddResource("foo_texture", depth_texture_type, 0, 0);
     AddComparisonSampler("foo_sampler", 0, 1);
     AddGlobalVariable("foo_coords", ty.vec2<f32>());
@@ -2729,7 +2729,7 @@
 }
 
 TEST_F(InspectorGetComparisonSamplerResourceBindingsTest, Simple) {
-    auto depth_texture_type = ty.depth_texture(type::TextureDimension::k2d);
+    auto depth_texture_type = ty.depth_texture(core::type::TextureDimension::k2d);
     AddResource("foo_texture", depth_texture_type, 0, 0);
     AddComparisonSampler("foo_sampler", 0, 1);
     AddGlobalVariable("foo_coords", ty.vec2<f32>());
@@ -2766,7 +2766,7 @@
 }
 
 TEST_F(InspectorGetComparisonSamplerResourceBindingsTest, InFunction) {
-    auto depth_texture_type = ty.depth_texture(type::TextureDimension::k2d);
+    auto depth_texture_type = ty.depth_texture(core::type::TextureDimension::k2d);
     AddResource("foo_texture", depth_texture_type, 0, 0);
     AddComparisonSampler("foo_sampler", 0, 1);
     AddGlobalVariable("foo_coords", ty.vec2<f32>());
@@ -2792,7 +2792,7 @@
 }
 
 TEST_F(InspectorGetComparisonSamplerResourceBindingsTest, UnknownEntryPoint) {
-    auto depth_texture_type = ty.depth_texture(type::TextureDimension::k2d);
+    auto depth_texture_type = ty.depth_texture(core::type::TextureDimension::k2d);
     AddResource("foo_texture", depth_texture_type, 0, 0);
     AddComparisonSampler("foo_sampler", 0, 1);
     AddGlobalVariable("foo_coords", ty.vec2<f32>());
@@ -2811,7 +2811,7 @@
 }
 
 TEST_F(InspectorGetComparisonSamplerResourceBindingsTest, SkipsSamplers) {
-    auto sampled_texture_type = ty.sampled_texture(type::TextureDimension::k1d, ty.f32());
+    auto sampled_texture_type = ty.sampled_texture(core::type::TextureDimension::k1d, ty.f32());
     AddResource("foo_texture", sampled_texture_type, 0, 0);
     AddSampler("foo_sampler", 0, 1);
     AddGlobalVariable("foo_coords", ty.f32());
@@ -2878,16 +2878,16 @@
 INSTANTIATE_TEST_SUITE_P(
     InspectorGetSampledTextureResourceBindingsTest,
     InspectorGetSampledTextureResourceBindingsTestWithParam,
-    testing::Values(GetSampledTextureTestParams{type::TextureDimension::k1d,
+    testing::Values(GetSampledTextureTestParams{core::type::TextureDimension::k1d,
                                                 inspector::ResourceBinding::TextureDimension::k1d,
                                                 inspector::ResourceBinding::SampledKind::kFloat},
-                    GetSampledTextureTestParams{type::TextureDimension::k2d,
+                    GetSampledTextureTestParams{core::type::TextureDimension::k2d,
                                                 inspector::ResourceBinding::TextureDimension::k2d,
                                                 inspector::ResourceBinding::SampledKind::kFloat},
-                    GetSampledTextureTestParams{type::TextureDimension::k3d,
+                    GetSampledTextureTestParams{core::type::TextureDimension::k3d,
                                                 inspector::ResourceBinding::TextureDimension::k3d,
                                                 inspector::ResourceBinding::SampledKind::kFloat},
-                    GetSampledTextureTestParams{type::TextureDimension::kCube,
+                    GetSampledTextureTestParams{core::type::TextureDimension::kCube,
                                                 inspector::ResourceBinding::TextureDimension::kCube,
                                                 inspector::ResourceBinding::SampledKind::kFloat}));
 
@@ -2923,10 +2923,10 @@
     InspectorGetSampledArrayTextureResourceBindingsTest,
     InspectorGetSampledArrayTextureResourceBindingsTestWithParam,
     testing::Values(
-        GetSampledTextureTestParams{type::TextureDimension::k2dArray,
+        GetSampledTextureTestParams{core::type::TextureDimension::k2dArray,
                                     inspector::ResourceBinding::TextureDimension::k2dArray,
                                     inspector::ResourceBinding::SampledKind::kFloat},
-        GetSampledTextureTestParams{type::TextureDimension::kCubeArray,
+        GetSampledTextureTestParams{core::type::TextureDimension::kCubeArray,
                                     inspector::ResourceBinding::TextureDimension::kCubeArray,
                                     inspector::ResourceBinding::SampledKind::kFloat}));
 
@@ -2969,13 +2969,13 @@
     InspectorGetMultisampledTextureResourceBindingsTest,
     InspectorGetMultisampledTextureResourceBindingsTestWithParam,
     testing::Values(
-        GetMultisampledTextureTestParams{type::TextureDimension::k2d,
+        GetMultisampledTextureTestParams{core::type::TextureDimension::k2d,
                                          inspector::ResourceBinding::TextureDimension::k2d,
                                          inspector::ResourceBinding::SampledKind::kFloat},
-        GetMultisampledTextureTestParams{type::TextureDimension::k2d,
+        GetMultisampledTextureTestParams{core::type::TextureDimension::k2d,
                                          inspector::ResourceBinding::TextureDimension::k2d,
                                          inspector::ResourceBinding::SampledKind::kSInt},
-        GetMultisampledTextureTestParams{type::TextureDimension::k2d,
+        GetMultisampledTextureTestParams{core::type::TextureDimension::k2d,
                                          inspector::ResourceBinding::TextureDimension::k2d,
                                          inspector::ResourceBinding::SampledKind::kUInt}));
 
@@ -3009,7 +3009,7 @@
     TexelFormatParams format_params;
     std::tie(dim_params, format_params) = GetParam();
 
-    type::TextureDimension dim;
+    core::type::TextureDimension dim;
     ResourceBinding::TextureDimension expected_dim;
     std::tie(dim, expected_dim) = dim_params;
 
@@ -3023,14 +3023,14 @@
 
     ast::Type dim_type;
     switch (dim) {
-        case type::TextureDimension::k1d:
+        case core::type::TextureDimension::k1d:
             dim_type = ty.u32();
             break;
-        case type::TextureDimension::k2d:
-        case type::TextureDimension::k2dArray:
+        case core::type::TextureDimension::k2d:
+        case core::type::TextureDimension::k2dArray:
             dim_type = ty.vec2<u32>();
             break;
-        case type::TextureDimension::k3d:
+        case core::type::TextureDimension::k3d:
             dim_type = ty.vec3<u32>();
             break;
         default:
@@ -3061,13 +3061,13 @@
 INSTANTIATE_TEST_SUITE_P(
     InspectorGetStorageTextureResourceBindingsTest,
     InspectorGetStorageTextureResourceBindingsTestWithParam,
-    testing::Combine(testing::Values(std::make_tuple(type::TextureDimension::k1d,
+    testing::Combine(testing::Values(std::make_tuple(core::type::TextureDimension::k1d,
                                                      ResourceBinding::TextureDimension::k1d),
-                                     std::make_tuple(type::TextureDimension::k2d,
+                                     std::make_tuple(core::type::TextureDimension::k2d,
                                                      ResourceBinding::TextureDimension::k2d),
-                                     std::make_tuple(type::TextureDimension::k2dArray,
+                                     std::make_tuple(core::type::TextureDimension::k2dArray,
                                                      ResourceBinding::TextureDimension::k2dArray),
-                                     std::make_tuple(type::TextureDimension::k3d,
+                                     std::make_tuple(core::type::TextureDimension::k3d,
                                                      ResourceBinding::TextureDimension::k3d)),
                      testing::Values(std::make_tuple(core::TexelFormat::kR32Float,
                                                      ResourceBinding::TexelFormat::kR32Float,
@@ -3146,17 +3146,17 @@
     InspectorGetDepthTextureResourceBindingsTest,
     InspectorGetDepthTextureResourceBindingsTestWithParam,
     testing::Values(
-        GetDepthTextureTestParams{type::TextureDimension::k2d,
+        GetDepthTextureTestParams{core::type::TextureDimension::k2d,
                                   inspector::ResourceBinding::TextureDimension::k2d},
-        GetDepthTextureTestParams{type::TextureDimension::k2dArray,
+        GetDepthTextureTestParams{core::type::TextureDimension::k2dArray,
                                   inspector::ResourceBinding::TextureDimension::k2dArray},
-        GetDepthTextureTestParams{type::TextureDimension::kCube,
+        GetDepthTextureTestParams{core::type::TextureDimension::kCube,
                                   inspector::ResourceBinding::TextureDimension::kCube},
-        GetDepthTextureTestParams{type::TextureDimension::kCubeArray,
+        GetDepthTextureTestParams{core::type::TextureDimension::kCubeArray,
                                   inspector::ResourceBinding::TextureDimension::kCubeArray}));
 
 TEST_F(InspectorGetDepthMultisampledTextureResourceBindingsTest, textureDimensions) {
-    auto depth_ms_texture_type = ty.depth_multisampled_texture(type::TextureDimension::k2d);
+    auto depth_ms_texture_type = ty.depth_multisampled_texture(core::type::TextureDimension::k2d);
     AddResource("tex", depth_ms_texture_type, 0, 0);
 
     Func("ep", tint::Empty, ty.void_(),
diff --git a/src/tint/lang/wgsl/inspector/resource_binding.cc b/src/tint/lang/wgsl/inspector/resource_binding.cc
index 8185020..20ab2b3 100644
--- a/src/tint/lang/wgsl/inspector/resource_binding.cc
+++ b/src/tint/lang/wgsl/inspector/resource_binding.cc
@@ -26,44 +26,44 @@
 namespace tint::inspector {
 
 ResourceBinding::TextureDimension TypeTextureDimensionToResourceBindingTextureDimension(
-    const type::TextureDimension& type_dim) {
+    const core::type::TextureDimension& type_dim) {
     switch (type_dim) {
-        case type::TextureDimension::k1d:
+        case core::type::TextureDimension::k1d:
             return ResourceBinding::TextureDimension::k1d;
-        case type::TextureDimension::k2d:
+        case core::type::TextureDimension::k2d:
             return ResourceBinding::TextureDimension::k2d;
-        case type::TextureDimension::k2dArray:
+        case core::type::TextureDimension::k2dArray:
             return ResourceBinding::TextureDimension::k2dArray;
-        case type::TextureDimension::k3d:
+        case core::type::TextureDimension::k3d:
             return ResourceBinding::TextureDimension::k3d;
-        case type::TextureDimension::kCube:
+        case core::type::TextureDimension::kCube:
             return ResourceBinding::TextureDimension::kCube;
-        case type::TextureDimension::kCubeArray:
+        case core::type::TextureDimension::kCubeArray:
             return ResourceBinding::TextureDimension::kCubeArray;
-        case type::TextureDimension::kNone:
+        case core::type::TextureDimension::kNone:
             return ResourceBinding::TextureDimension::kNone;
     }
     return ResourceBinding::TextureDimension::kNone;
 }
 
-ResourceBinding::SampledKind BaseTypeToSampledKind(const type::Type* base_type) {
+ResourceBinding::SampledKind BaseTypeToSampledKind(const core::type::Type* base_type) {
     if (!base_type) {
         return ResourceBinding::SampledKind::kUnknown;
     }
 
-    if (auto* at = base_type->As<type::Array>()) {
+    if (auto* at = base_type->As<core::type::Array>()) {
         base_type = at->ElemType();
-    } else if (auto* mt = base_type->As<type::Matrix>()) {
+    } else if (auto* mt = base_type->As<core::type::Matrix>()) {
         base_type = mt->type();
-    } else if (auto* vt = base_type->As<type::Vector>()) {
+    } else if (auto* vt = base_type->As<core::type::Vector>()) {
         base_type = vt->type();
     }
 
-    if (base_type->Is<type::F32>()) {
+    if (base_type->Is<core::type::F32>()) {
         return ResourceBinding::SampledKind::kFloat;
-    } else if (base_type->Is<type::U32>()) {
+    } else if (base_type->Is<core::type::U32>()) {
         return ResourceBinding::SampledKind::kUInt;
-    } else if (base_type->Is<type::I32>()) {
+    } else if (base_type->Is<core::type::I32>()) {
         return ResourceBinding::SampledKind::kSInt;
     } else {
         return ResourceBinding::SampledKind::kUnknown;
diff --git a/src/tint/lang/wgsl/inspector/resource_binding.h b/src/tint/lang/wgsl/inspector/resource_binding.h
index d234fea..c9d372c 100644
--- a/src/tint/lang/wgsl/inspector/resource_binding.h
+++ b/src/tint/lang/wgsl/inspector/resource_binding.h
@@ -104,17 +104,17 @@
     TexelFormat image_format;
 };
 
-/// Convert from internal type::TextureDimension to public
+/// Convert from internal core::type::TextureDimension to public
 /// ResourceBinding::TextureDimension
 /// @param type_dim internal value to convert from
 /// @returns the publicly visible equivalent
 ResourceBinding::TextureDimension TypeTextureDimensionToResourceBindingTextureDimension(
-    const type::TextureDimension& type_dim);
+    const core::type::TextureDimension& type_dim);
 
-/// Infer ResourceBinding::SampledKind for a given type::Type
+/// Infer ResourceBinding::SampledKind for a given core::type::Type
 /// @param base_type internal type to infer from
 /// @returns the publicly visible equivalent
-ResourceBinding::SampledKind BaseTypeToSampledKind(const type::Type* base_type);
+ResourceBinding::SampledKind BaseTypeToSampledKind(const core::type::Type* base_type);
 
 /// Convert from internal core::TexelFormat to public
 /// ResourceBinding::TexelFormat
diff --git a/src/tint/lang/wgsl/program/program.cc b/src/tint/lang/wgsl/program/program.cc
index ee199caa..5c058c9 100644
--- a/src/tint/lang/wgsl/program/program.cc
+++ b/src/tint/lang/wgsl/program/program.cc
@@ -108,19 +108,19 @@
     return is_valid_;
 }
 
-const type::Type* Program::TypeOf(const ast::Expression* expr) const {
+const core::type::Type* Program::TypeOf(const ast::Expression* expr) const {
     return tint::Switch(
         Sem().Get(expr),  //
         [](const sem::ValueExpression* ty_expr) { return ty_expr->Type(); },
         [](const sem::TypeExpression* ty_expr) { return ty_expr->Type(); });
 }
 
-const type::Type* Program::TypeOf(const ast::Variable* var) const {
+const core::type::Type* Program::TypeOf(const ast::Variable* var) const {
     auto* sem = Sem().Get(var);
     return sem ? sem->Type() : nullptr;
 }
 
-const type::Type* Program::TypeOf(const ast::TypeDecl* type_decl) const {
+const core::type::Type* Program::TypeOf(const ast::TypeDecl* type_decl) const {
     return Sem().Get(type_decl);
 }
 
diff --git a/src/tint/lang/wgsl/program/program.h b/src/tint/lang/wgsl/program/program.h
index e30f46f..a367412 100644
--- a/src/tint/lang/wgsl/program/program.h
+++ b/src/tint/lang/wgsl/program/program.h
@@ -73,7 +73,7 @@
     }
 
     /// @returns a reference to the program's types
-    const type::Manager& Types() const {
+    const core::type::Manager& Types() const {
         AssertNotMoved();
         return constants_.types;
     }
@@ -136,20 +136,20 @@
     /// @param expr the AST expression
     /// @return the resolved semantic type for the expression, or nullptr if the
     /// expression has no resolved type.
-    const type::Type* TypeOf(const ast::Expression* expr) const;
+    const core::type::Type* TypeOf(const ast::Expression* expr) const;
 
     /// Helper for returning the resolved semantic type of the variable `var`.
     /// @param var the AST variable
     /// @return the resolved semantic type for the variable, or nullptr if the
     /// variable has no resolved type.
-    const type::Type* TypeOf(const ast::Variable* var) const;
+    const core::type::Type* TypeOf(const ast::Variable* var) const;
 
     /// Helper for returning the resolved semantic type of the AST type
     /// declaration `type_decl`.
     /// @param type_decl the AST type declaration
     /// @return the resolved semantic type for the type declaration, or nullptr if
     /// the type declaration has no resolved type.
-    const type::Type* TypeOf(const ast::TypeDecl* type_decl) const;
+    const core::type::Type* TypeOf(const ast::TypeDecl* type_decl) const;
 
     /// A function that can be used to print a program
     using Printer = std::string (*)(const Program*);
diff --git a/src/tint/lang/wgsl/program/program_builder.cc b/src/tint/lang/wgsl/program/program_builder.cc
index 870901e..29d441c 100644
--- a/src/tint/lang/wgsl/program/program_builder.cc
+++ b/src/tint/lang/wgsl/program/program_builder.cc
@@ -65,19 +65,19 @@
     }
 }
 
-const type::Type* ProgramBuilder::TypeOf(const ast::Expression* expr) const {
+const core::type::Type* ProgramBuilder::TypeOf(const ast::Expression* expr) const {
     return tint::Switch(
         Sem().Get(expr),  //
         [](const sem::ValueExpression* e) { return e->Type(); },
         [](const sem::TypeExpression* e) { return e->Type(); });
 }
 
-const type::Type* ProgramBuilder::TypeOf(const ast::Variable* var) const {
+const core::type::Type* ProgramBuilder::TypeOf(const ast::Variable* var) const {
     auto* sem = Sem().Get(var);
     return sem ? sem->Type() : nullptr;
 }
 
-const type::Type* ProgramBuilder::TypeOf(const ast::TypeDecl* type_decl) const {
+const core::type::Type* ProgramBuilder::TypeOf(const ast::TypeDecl* type_decl) const {
     return Sem().Get(type_decl);
 }
 
diff --git a/src/tint/lang/wgsl/program/program_builder.h b/src/tint/lang/wgsl/program/program_builder.h
index 97aee37..391d251 100644
--- a/src/tint/lang/wgsl/program/program_builder.h
+++ b/src/tint/lang/wgsl/program/program_builder.h
@@ -93,13 +93,13 @@
     static ProgramBuilder Wrap(const Program* program);
 
     /// @returns a reference to the program's types
-    type::Manager& Types() {
+    core::type::Manager& Types() {
         AssertNotMoved();
         return constants.types;
     }
 
     /// @returns a reference to the program's types
-    const type::Manager& Types() const {
+    const core::type::Manager& Types() const {
         AssertNotMoved();
         return constants.types;
     }
@@ -143,21 +143,21 @@
     /// @returns the node pointer
     template <typename T, typename... ARGS>
     tint::traits::EnableIf<tint::traits::IsTypeOrDerived<T, sem::Node> &&
-                               !tint::traits::IsTypeOrDerived<T, type::Node>,
+                               !tint::traits::IsTypeOrDerived<T, core::type::Node>,
                            T>*
     create(ARGS&&... args) {
         AssertNotMoved();
         return sem_nodes_.Create<T>(std::forward<ARGS>(args)...);
     }
 
-    /// Creates a new type::Node owned by the ProgramBuilder.
+    /// Creates a new core::type::Node owned by the ProgramBuilder.
     /// When the ProgramBuilder is destructed, owned ProgramBuilder and the returned node will also
-    /// be destructed. If T derives from type::UniqueNode, then the calling create() for the same
-    /// `T` and arguments will return the same pointer.
+    /// be destructed. If T derives from core::type::UniqueNode, then the calling create() for the
+    /// same `T` and arguments will return the same pointer.
     /// @param args the arguments to pass to the constructor
     /// @returns the new, or existing node
     template <typename T, typename... ARGS>
-    tint::traits::EnableIfIsType<T, type::Node>* create(ARGS&&... args) {
+    tint::traits::EnableIfIsType<T, core::type::Node>* create(ARGS&&... args) {
         AssertNotMoved();
         return constants.types.Get<T>(std::forward<ARGS>(args)...);
     }
@@ -168,7 +168,7 @@
     /// @param expr the AST expression
     /// @return the resolved semantic type for the expression, or nullptr if the
     /// expression has no resolved type.
-    const type::Type* TypeOf(const ast::Expression* expr) const;
+    const core::type::Type* TypeOf(const ast::Expression* expr) const;
 
     /// Helper for returning the resolved semantic type of the variable `var`.
     /// @note As the Resolver is run when the Program is built, this will only be
@@ -176,7 +176,7 @@
     /// @param var the AST variable
     /// @return the resolved semantic type for the variable, or nullptr if the
     /// variable has no resolved type.
-    const type::Type* TypeOf(const ast::Variable* var) const;
+    const core::type::Type* TypeOf(const ast::Variable* var) const;
 
     /// Helper for returning the resolved semantic type of the AST type
     /// declaration `type_decl`.
@@ -185,7 +185,7 @@
     /// @param type_decl the AST type declaration
     /// @return the resolved semantic type for the type declaration, or nullptr if
     /// the type declaration has no resolved type.
-    const type::Type* TypeOf(const ast::TypeDecl* type_decl) const;
+    const core::type::Type* TypeOf(const ast::TypeDecl* type_decl) const;
 
     /// The constants manager
     core::constant::Manager constants;
diff --git a/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir.cc b/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir.cc
index 7d0c972..f9dc57d 100644
--- a/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir.cc
+++ b/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir.cc
@@ -137,7 +137,7 @@
 
     // The clone context used to clone data from #program_
     core::constant::CloneContext clone_ctx_{
-        /* type_ctx */ type::CloneContext{
+        /* type_ctx */ core::type::CloneContext{
             /* src */ {&program_->Symbols()},
             /* dst */ {&builder_.ir.symbols, &builder_.ir.Types()},
         },
@@ -919,8 +919,10 @@
 
                 // The access result type should match the source result type. If the source is a
                 // pointer, we generate a pointer.
-                const type::Type* ty = sem->Type()->UnwrapRef()->Clone(impl.clone_ctx_.type_ctx);
-                if (auto* ptr = obj->Type()->As<type::Pointer>(); ptr && !ty->Is<type::Pointer>()) {
+                const core::type::Type* ty =
+                    sem->Type()->UnwrapRef()->Clone(impl.clone_ctx_.type_ctx);
+                if (auto* ptr = obj->Type()->As<core::type::Pointer>();
+                    ptr && !ty->Is<core::type::Pointer>()) {
                     ty = impl.builder_.ir.Types().ptr(ptr->AddressSpace(), ty, ptr->Access());
                 }
 
@@ -1141,12 +1143,12 @@
                     return std::nullopt;
                 }
 
-                auto* ref = access->Object()->Type()->As<type::Reference>();
+                auto* ref = access->Object()->Type()->As<core::type::Reference>();
                 if (!ref) {
                     return std::nullopt;
                 }
 
-                if (!ref->StoreType()->Is<type::Vector>()) {
+                if (!ref->StoreType()->Is<core::type::Vector>()) {
                     return std::nullopt;
                 }
                 return tint::Switch(
@@ -1280,8 +1282,8 @@
         return tint::Switch(  //
             var,
             [&](const ast::Var* v) {
-                auto* ref = sem->Type()->As<type::Reference>();
-                auto* ty = builder_.ir.Types().Get<type::Pointer>(
+                auto* ref = sem->Type()->As<core::type::Reference>();
+                auto* ty = builder_.ir.Types().Get<core::type::Pointer>(
                     ref->AddressSpace(), ref->StoreType()->Clone(clone_ctx_.type_ctx),
                     ref->Access());
 
@@ -1349,7 +1351,10 @@
             });
     }
 
-    ir::Binary* BinaryOp(const type::Type* ty, ir::Value* lhs, ir::Value* rhs, core::BinaryOp op) {
+    ir::Binary* BinaryOp(const core::type::Type* ty,
+                         ir::Value* lhs,
+                         ir::Value* rhs,
+                         core::BinaryOp op) {
         switch (op) {
             case core::BinaryOp::kAnd:
                 return builder_.And(ty, lhs, rhs);
diff --git a/src/tint/lang/wgsl/resolver/array_accessor_test.cc b/src/tint/lang/wgsl/resolver/array_accessor_test.cc
index 8e3931e..470ea97 100644
--- a/src/tint/lang/wgsl/resolver/array_accessor_test.cc
+++ b/src/tint/lang/wgsl/resolver/array_accessor_test.cc
@@ -109,8 +109,8 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(acc), nullptr);
-    ASSERT_TRUE(TypeOf(acc)->Is<type::Vector>());
-    EXPECT_EQ(TypeOf(acc)->As<type::Vector>()->Width(), 3u);
+    ASSERT_TRUE(TypeOf(acc)->Is<core::type::Vector>());
+    EXPECT_EQ(TypeOf(acc)->As<core::type::Vector>()->Width(), 3u);
 
     auto idx_sem = Sem().Get(acc)->UnwrapLoad()->As<sem::IndexAccessorExpression>();
     ASSERT_NE(idx_sem, nullptr);
@@ -127,7 +127,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(acc), nullptr);
-    EXPECT_TRUE(TypeOf(acc)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(acc)->Is<core::type::F32>());
 
     auto idx_sem = Sem().Get(acc)->UnwrapLoad()->As<sem::IndexAccessorExpression>();
     ASSERT_NE(idx_sem, nullptr);
@@ -176,7 +176,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(acc), nullptr);
-    EXPECT_TRUE(TypeOf(acc)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(acc)->Is<core::type::F32>());
 
     auto idx_sem = Sem().Get(acc)->UnwrapLoad()->As<sem::IndexAccessorExpression>();
     ASSERT_NE(idx_sem, nullptr);
@@ -189,7 +189,7 @@
     auto* acc = IndexAccessor("my_var", 2_i);
     WrapInFunction(acc);
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    EXPECT_TRUE(TypeOf(acc)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(acc)->Is<core::type::F32>());
 
     auto idx_sem = Sem().Get(acc)->UnwrapLoad()->As<sem::IndexAccessorExpression>();
     ASSERT_NE(idx_sem, nullptr);
@@ -202,7 +202,7 @@
     auto* acc = IndexAccessor("my_var", 2_u);
     WrapInFunction(acc);
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    EXPECT_TRUE(TypeOf(acc)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(acc)->Is<core::type::F32>());
 
     auto idx_sem = Sem().Get(acc)->UnwrapLoad()->As<sem::IndexAccessorExpression>();
     ASSERT_NE(idx_sem, nullptr);
@@ -215,7 +215,7 @@
     auto* acc = IndexAccessor("my_var", 2_a);
     WrapInFunction(acc);
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    EXPECT_TRUE(TypeOf(acc)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(acc)->Is<core::type::F32>());
 
     auto idx_sem = Sem().Get(acc)->UnwrapLoad()->As<sem::IndexAccessorExpression>();
     ASSERT_NE(idx_sem, nullptr);
@@ -234,7 +234,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(acc), nullptr);
-    EXPECT_TRUE(TypeOf(acc)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(acc)->Is<core::type::F32>());
 
     auto idx_sem = Sem().Get(acc)->UnwrapLoad()->As<sem::IndexAccessorExpression>();
     ASSERT_NE(idx_sem, nullptr);
@@ -251,7 +251,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(acc), nullptr);
-    EXPECT_TRUE(TypeOf(acc)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(acc)->Is<core::type::F32>());
 }
 
 TEST_F(ResolverIndexAccessorTest, Array_Dynamic_I32) {
diff --git a/src/tint/lang/wgsl/resolver/assignment_validation_test.cc b/src/tint/lang/wgsl/resolver/assignment_validation_test.cc
index 3aaeaae..7539446 100644
--- a/src/tint/lang/wgsl/resolver/assignment_validation_test.cc
+++ b/src/tint/lang/wgsl/resolver/assignment_validation_test.cc
@@ -290,7 +290,7 @@
     // a = b;
 
     auto make_type = [&] {
-        return ty.storage_texture(type::TextureDimension::k1d, core::TexelFormat::kRgba8Unorm,
+        return ty.storage_texture(core::type::TextureDimension::k1d, core::TexelFormat::kRgba8Unorm,
                                   core::Access::kWrite);
     };
 
@@ -420,9 +420,9 @@
     auto* U = Structure("U", Vector{
                                  Member("i", ty.i32()),
                              });
-    GlobalVar("tex", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(0_a),
+    GlobalVar("tex", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Group(0_a),
               Binding(0_a));
-    GlobalVar("smp", ty.sampler(type::SamplerKind::kSampler), Group(0_a), Binding(1_a));
+    GlobalVar("smp", ty.sampler(core::type::SamplerKind::kSampler), Group(0_a), Binding(1_a));
     GlobalVar("u", ty.Of(U), core::AddressSpace::kUniform, Group(0_a), Binding(2_a));
     GlobalVar("s", ty.Of(S), core::AddressSpace::kStorage, Group(0_a), Binding(3_a));
     GlobalVar("wg", ty.array<f32, 10>(), core::AddressSpace::kWorkgroup);
diff --git a/src/tint/lang/wgsl/resolver/atomics_test.cc b/src/tint/lang/wgsl/resolver/atomics_test.cc
index 6e106aa..e19fe74 100644
--- a/src/tint/lang/wgsl/resolver/atomics_test.cc
+++ b/src/tint/lang/wgsl/resolver/atomics_test.cc
@@ -30,20 +30,20 @@
     auto* g = GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.i32()), core::AddressSpace::kWorkgroup);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    ASSERT_TRUE(TypeOf(g)->Is<type::Reference>());
-    auto* atomic = TypeOf(g)->UnwrapRef()->As<type::Atomic>();
+    ASSERT_TRUE(TypeOf(g)->Is<core::type::Reference>());
+    auto* atomic = TypeOf(g)->UnwrapRef()->As<core::type::Atomic>();
     ASSERT_NE(atomic, nullptr);
-    EXPECT_TRUE(atomic->Type()->Is<type::I32>());
+    EXPECT_TRUE(atomic->Type()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverAtomicTest, GlobalWorkgroupU32) {
     auto* g = GlobalVar("a", ty.atomic(Source{{12, 34}}, ty.u32()), core::AddressSpace::kWorkgroup);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    ASSERT_TRUE(TypeOf(g)->Is<type::Reference>());
-    auto* atomic = TypeOf(g)->UnwrapRef()->As<type::Atomic>();
+    ASSERT_TRUE(TypeOf(g)->Is<core::type::Reference>());
+    auto* atomic = TypeOf(g)->UnwrapRef()->As<core::type::Atomic>();
     ASSERT_NE(atomic, nullptr);
-    EXPECT_TRUE(atomic->Type()->Is<type::U32>());
+    EXPECT_TRUE(atomic->Type()->Is<core::type::U32>());
 }
 
 TEST_F(ResolverAtomicTest, GlobalStorageStruct) {
@@ -52,13 +52,13 @@
                         Binding(0_a), Group(0_a));
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    ASSERT_TRUE(TypeOf(g)->Is<type::Reference>());
+    ASSERT_TRUE(TypeOf(g)->Is<core::type::Reference>());
     auto* str = TypeOf(g)->UnwrapRef()->As<sem::Struct>();
     ASSERT_NE(str, nullptr);
     ASSERT_EQ(str->Members().Length(), 1u);
-    auto* atomic = str->Members()[0]->Type()->As<type::Atomic>();
+    auto* atomic = str->Members()[0]->Type()->As<core::type::Atomic>();
     ASSERT_NE(atomic, nullptr);
-    ASSERT_TRUE(atomic->Type()->Is<type::I32>());
+    ASSERT_TRUE(atomic->Type()->Is<core::type::I32>());
 }
 
 }  // namespace
diff --git a/src/tint/lang/wgsl/resolver/attribute_validation_test.cc b/src/tint/lang/wgsl/resolver/attribute_validation_test.cc
index b046d56..3b7a35a 100644
--- a/src/tint/lang/wgsl/resolver/attribute_validation_test.cc
+++ b/src/tint/lang/wgsl/resolver/attribute_validation_test.cc
@@ -596,7 +596,7 @@
 }
 
 TEST_F(EntryPointParameterAttributeTest, DuplicateInternalAttribute) {
-    auto* s = Param("s", ty.sampler(type::SamplerKind::kSampler),
+    auto* s = Param("s", ty.sampler(core::type::SamplerKind::kSampler),
                     Vector{
                         Binding(0_a),
                         Group(0_a),
@@ -975,7 +975,7 @@
 
     auto attrs = createAttributes(Source{{12, 34}}, *this, params.kind);
     if (IsBindingAttribute(params.kind)) {
-        GlobalVar("a", ty.sampler(type::SamplerKind::kSampler), attrs);
+        GlobalVar("a", ty.sampler(core::type::SamplerKind::kSampler), attrs);
     } else {
         GlobalVar("a", ty.f32(), core::AddressSpace::kPrivate, attrs);
     }
@@ -1011,7 +1011,7 @@
                                          TestParams{AttributeKind::kBindingAndGroup, true}));
 
 TEST_F(VariableAttributeTest, DuplicateAttribute) {
-    GlobalVar("a", ty.sampler(type::SamplerKind::kSampler), Binding(Source{{12, 34}}, 2_a),
+    GlobalVar("a", ty.sampler(core::type::SamplerKind::kSampler), Binding(Source{{12, 34}}, 2_a),
               Group(2_a), Binding(Source{{56, 78}}, 3_a));
 
     EXPECT_FALSE(r()->Resolve());
@@ -1610,7 +1610,7 @@
 }
 
 TEST_F(ResourceAttributeTest, TextureMissingBinding) {
-    GlobalVar(Source{{12, 34}}, "G", ty.depth_texture(type::TextureDimension::k2d));
+    GlobalVar(Source{{12, 34}}, "G", ty.depth_texture(core::type::TextureDimension::k2d));
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
@@ -1618,7 +1618,7 @@
 }
 
 TEST_F(ResourceAttributeTest, SamplerMissingBinding) {
-    GlobalVar(Source{{12, 34}}, "G", ty.sampler(type::SamplerKind::kSampler));
+    GlobalVar(Source{{12, 34}}, "G", ty.sampler(core::type::SamplerKind::kSampler));
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
@@ -1626,7 +1626,7 @@
 }
 
 TEST_F(ResourceAttributeTest, BindingPairMissingBinding) {
-    GlobalVar(Source{{12, 34}}, "G", ty.sampler(type::SamplerKind::kSampler), Group(1_a));
+    GlobalVar(Source{{12, 34}}, "G", ty.sampler(core::type::SamplerKind::kSampler), Group(1_a));
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
@@ -1634,7 +1634,7 @@
 }
 
 TEST_F(ResourceAttributeTest, BindingPairMissingGroup) {
-    GlobalVar(Source{{12, 34}}, "G", ty.sampler(type::SamplerKind::kSampler), Binding(1_a));
+    GlobalVar(Source{{12, 34}}, "G", ty.sampler(core::type::SamplerKind::kSampler), Binding(1_a));
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
@@ -1642,10 +1642,12 @@
 }
 
 TEST_F(ResourceAttributeTest, BindingPointUsedTwiceByEntryPoint) {
-    GlobalVar(Source{{12, 34}}, "A", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()),
-              Binding(1_a), Group(2_a));
-    GlobalVar(Source{{56, 78}}, "B", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()),
-              Binding(1_a), Group(2_a));
+    GlobalVar(Source{{12, 34}}, "A",
+              ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Binding(1_a),
+              Group(2_a));
+    GlobalVar(Source{{56, 78}}, "B",
+              ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Binding(1_a),
+              Group(2_a));
 
     Func("F", tint::Empty, ty.void_(),
          Vector{
@@ -1666,10 +1668,12 @@
 }
 
 TEST_F(ResourceAttributeTest, BindingPointUsedTwiceByDifferentEntryPoints) {
-    GlobalVar(Source{{12, 34}}, "A", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()),
-              Binding(1_a), Group(2_a));
-    GlobalVar(Source{{56, 78}}, "B", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()),
-              Binding(1_a), Group(2_a));
+    GlobalVar(Source{{12, 34}}, "A",
+              ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Binding(1_a),
+              Group(2_a));
+    GlobalVar(Source{{56, 78}}, "B",
+              ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Binding(1_a),
+              Group(2_a));
 
     Func("F_A", tint::Empty, ty.void_(),
          Vector{
@@ -2040,7 +2044,7 @@
 TEST_F(GroupAndBindingTest, Const_I32) {
     GlobalConst("b", Expr(4_i));
     GlobalConst("g", Expr(2_i));
-    GlobalVar("val", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Binding("b"),
+    GlobalVar("val", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Binding("b"),
               Group("g"));
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -2049,7 +2053,7 @@
 TEST_F(GroupAndBindingTest, Const_U32) {
     GlobalConst("b", Expr(4_u));
     GlobalConst("g", Expr(2_u));
-    GlobalVar("val", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Binding("b"),
+    GlobalVar("val", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Binding("b"),
               Group("g"));
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -2058,14 +2062,14 @@
 TEST_F(GroupAndBindingTest, Const_AInt) {
     GlobalConst("b", Expr(4_a));
     GlobalConst("g", Expr(2_a));
-    GlobalVar("val", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Binding("b"),
+    GlobalVar("val", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Binding("b"),
               Group("g"));
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }
 
 TEST_F(GroupAndBindingTest, Binding_NonConstant) {
-    GlobalVar("val", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()),
+    GlobalVar("val", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()),
               Binding(Call<u32>(Call(Source{{12, 34}}, "dpdx", 1_a))), Group(1_i));
 
     EXPECT_FALSE(r()->Resolve());
@@ -2075,7 +2079,7 @@
 }
 
 TEST_F(GroupAndBindingTest, Binding_Negative) {
-    GlobalVar("val", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()),
+    GlobalVar("val", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()),
               Binding(Source{{12, 34}}, -2_i), Group(1_i));
 
     EXPECT_FALSE(r()->Resolve());
@@ -2083,7 +2087,7 @@
 }
 
 TEST_F(GroupAndBindingTest, Binding_F32) {
-    GlobalVar("val", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()),
+    GlobalVar("val", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()),
               Binding(Source{{12, 34}}, 2.0_f), Group(1_u));
 
     EXPECT_FALSE(r()->Resolve());
@@ -2091,7 +2095,7 @@
 }
 
 TEST_F(GroupAndBindingTest, Binding_AFloat) {
-    GlobalVar("val", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()),
+    GlobalVar("val", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()),
               Binding(Source{{12, 34}}, 2.0_a), Group(1_u));
 
     EXPECT_FALSE(r()->Resolve());
@@ -2099,7 +2103,7 @@
 }
 
 TEST_F(GroupAndBindingTest, Group_NonConstant) {
-    GlobalVar("val", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Binding(2_u),
+    GlobalVar("val", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Binding(2_u),
               Group(Call<u32>(Call(Source{{12, 34}}, "dpdx", 1_a))));
 
     EXPECT_FALSE(r()->Resolve());
@@ -2109,7 +2113,7 @@
 }
 
 TEST_F(GroupAndBindingTest, Group_Negative) {
-    GlobalVar("val", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Binding(2_u),
+    GlobalVar("val", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Binding(2_u),
               Group(Source{{12, 34}}, -1_i));
 
     EXPECT_FALSE(r()->Resolve());
@@ -2117,7 +2121,7 @@
 }
 
 TEST_F(GroupAndBindingTest, Group_F32) {
-    GlobalVar("val", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Binding(2_u),
+    GlobalVar("val", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Binding(2_u),
               Group(Source{{12, 34}}, 1.0_f));
 
     EXPECT_FALSE(r()->Resolve());
@@ -2125,7 +2129,7 @@
 }
 
 TEST_F(GroupAndBindingTest, Group_AFloat) {
-    GlobalVar("val", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Binding(2_u),
+    GlobalVar("val", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Binding(2_u),
               Group(Source{{12, 34}}, 1.0_a));
 
     EXPECT_FALSE(r()->Resolve());
diff --git a/src/tint/lang/wgsl/resolver/builtin_structs_test.cc b/src/tint/lang/wgsl/resolver/builtin_structs_test.cc
index c86fd53..fe96142 100644
--- a/src/tint/lang/wgsl/resolver/builtin_structs_test.cc
+++ b/src/tint/lang/wgsl/resolver/builtin_structs_test.cc
@@ -34,7 +34,7 @@
     auto* var = GlobalVar("p", ty(GetParam()), core::AddressSpace::kPrivate);
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
-    auto* str = As<type::Struct>(TypeOf(var)->UnwrapRef());
+    auto* str = As<core::type::Struct>(TypeOf(var)->UnwrapRef());
     ASSERT_NE(str, nullptr);
     EXPECT_EQ(str->Name().Name(), tint::ToString(GetParam()));
     EXPECT_FALSE(Is<sem::Struct>(str));
diff --git a/src/tint/lang/wgsl/resolver/builtin_test.cc b/src/tint/lang/wgsl/resolver/builtin_test.cc
index 52ee20f..535cb5f 100644
--- a/src/tint/lang/wgsl/resolver/builtin_test.cc
+++ b/src/tint/lang/wgsl/resolver/builtin_test.cc
@@ -109,7 +109,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    EXPECT_TRUE(TypeOf(expr)->Is<type::Bool>());
+    EXPECT_TRUE(TypeOf(expr)->Is<core::type::Bool>());
 }
 TEST_P(ResolverBuiltinTest_BoolMethod, Vector) {
     auto name = GetParam();
@@ -122,7 +122,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    EXPECT_TRUE(TypeOf(expr)->Is<type::Bool>());
+    EXPECT_TRUE(TypeOf(expr)->Is<core::type::Bool>());
 }
 INSTANTIATE_TEST_SUITE_P(ResolverTest,
                          ResolverBuiltinTest_BoolMethod,
@@ -139,9 +139,9 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    EXPECT_TRUE(TypeOf(expr)->Is<type::Vector>());
-    EXPECT_EQ(TypeOf(expr)->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(TypeOf(expr)->As<type::Vector>()->type()->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(expr)->Is<core::type::Vector>());
+    EXPECT_EQ(TypeOf(expr)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(TypeOf(expr)->As<core::type::Vector>()->type()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverBuiltinTest, Select_Error_NoParams) {
@@ -245,7 +245,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::U32>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::U32>());
 }
 
 TEST_F(ResolverBuiltinArrayTest, ArrayLength_Error_ArraySized) {
@@ -313,7 +313,7 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
 
         ASSERT_NE(TypeOf(call), nullptr);
-        EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::F32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -338,9 +338,9 @@
 
         ASSERT_NE(TypeOf(call), nullptr);
         EXPECT_TRUE(TypeOf(call)->is_float_vector());
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-        ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-        EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F32>());
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+        ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+        EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::F32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -361,7 +361,7 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
 
         ASSERT_NE(TypeOf(call), nullptr);
-        EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::F32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -383,9 +383,9 @@
 
         ASSERT_NE(TypeOf(call), nullptr);
         EXPECT_TRUE(TypeOf(call)->is_float_vector());
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-        ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-        EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F32>());
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+        ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+        EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::F32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -406,7 +406,7 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
 
         ASSERT_NE(TypeOf(call), nullptr);
-        EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::F32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -429,9 +429,9 @@
 
         ASSERT_NE(TypeOf(call), nullptr);
         EXPECT_TRUE(TypeOf(call)->is_float_vector());
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-        ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-        EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F32>());
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+        ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+        EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::F32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -453,7 +453,7 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
 
         ASSERT_NE(TypeOf(call), nullptr);
-        EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::F32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -476,9 +476,9 @@
 
         ASSERT_NE(TypeOf(call), nullptr);
         EXPECT_TRUE(TypeOf(call)->is_float_vector());
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-        ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-        EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F32>());
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+        ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+        EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::F32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -507,7 +507,7 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
 
         ASSERT_NE(TypeOf(call), nullptr);
-        EXPECT_TRUE(TypeOf(call)->Is<type::F16>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::F16>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -534,9 +534,9 @@
 
         ASSERT_NE(TypeOf(call), nullptr);
         EXPECT_TRUE(TypeOf(call)->is_float_vector());
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-        ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-        EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F16>());
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+        ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+        EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::F16>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -559,7 +559,7 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
 
         ASSERT_NE(TypeOf(call), nullptr);
-        EXPECT_TRUE(TypeOf(call)->Is<type::F16>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::F16>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -583,9 +583,9 @@
 
         ASSERT_NE(TypeOf(call), nullptr);
         EXPECT_TRUE(TypeOf(call)->is_float_vector());
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-        ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-        EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F16>());
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+        ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+        EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::F16>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -608,7 +608,7 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
 
         ASSERT_NE(TypeOf(call), nullptr);
-        EXPECT_TRUE(TypeOf(call)->Is<type::F16>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::F16>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -633,9 +633,9 @@
 
         ASSERT_NE(TypeOf(call), nullptr);
         EXPECT_TRUE(TypeOf(call)->is_float_vector());
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-        ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-        EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F16>());
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+        ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+        EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::F16>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -659,7 +659,7 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
 
         ASSERT_NE(TypeOf(call), nullptr);
-        EXPECT_TRUE(TypeOf(call)->Is<type::F16>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::F16>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -684,9 +684,9 @@
 
         ASSERT_NE(TypeOf(call), nullptr);
         EXPECT_TRUE(TypeOf(call)->is_float_vector());
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-        ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-        EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F16>());
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+        ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+        EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::F16>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -761,8 +761,8 @@
 
     ASSERT_NE(TypeOf(call), nullptr);
     EXPECT_TRUE(TypeOf(call)->is_float_vector());
-    EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F32>());
+    EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverBuiltinFloatTest, Cross_f16) {
@@ -775,8 +775,8 @@
 
     ASSERT_NE(TypeOf(call), nullptr);
     EXPECT_TRUE(TypeOf(call)->is_float_vector());
-    EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F16>());
+    EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::F16>());
 }
 
 TEST_F(ResolverBuiltinFloatTest, Cross_Error_NoArgs) {
@@ -859,7 +859,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::F32>());
 }
 
 TEST_F(ResolverBuiltinFloatTest, Distance_Scalar_f16) {
@@ -871,7 +871,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::F16>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::F16>());
 }
 
 TEST_F(ResolverBuiltinFloatTest, Distance_Vector_f32) {
@@ -881,7 +881,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::F32>());
 }
 
 TEST_F(ResolverBuiltinFloatTest, Distance_Vector_f16) {
@@ -893,7 +893,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::F16>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::F16>());
 }
 
 TEST_F(ResolverBuiltinFloatTest, Distance_TooManyParams) {
@@ -948,19 +948,19 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    auto* ty = TypeOf(call)->As<type::Struct>();
+    auto* ty = TypeOf(call)->As<core::type::Struct>();
     ASSERT_NE(ty, nullptr);
     ASSERT_EQ(ty->Members().Length(), 2u);
 
     auto* fract = ty->Members()[0];
-    EXPECT_TRUE(fract->Type()->Is<type::F32>());
+    EXPECT_TRUE(fract->Type()->Is<core::type::F32>());
     EXPECT_EQ(fract->Offset(), 0u);
     EXPECT_EQ(fract->Size(), 4u);
     EXPECT_EQ(fract->Align(), 4u);
     EXPECT_EQ(fract->Name(), Sym("fract"));
 
     auto* exp = ty->Members()[1];
-    EXPECT_TRUE(exp->Type()->Is<type::I32>());
+    EXPECT_TRUE(exp->Type()->Is<core::type::I32>());
     EXPECT_EQ(exp->Offset(), 4u);
     EXPECT_EQ(exp->Size(), 4u);
     EXPECT_EQ(exp->Align(), 4u);
@@ -979,19 +979,19 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    auto* ty = TypeOf(call)->As<type::Struct>();
+    auto* ty = TypeOf(call)->As<core::type::Struct>();
     ASSERT_NE(ty, nullptr);
     ASSERT_EQ(ty->Members().Length(), 2u);
 
     auto* fract = ty->Members()[0];
-    EXPECT_TRUE(fract->Type()->Is<type::F16>());
+    EXPECT_TRUE(fract->Type()->Is<core::type::F16>());
     EXPECT_EQ(fract->Offset(), 0u);
     EXPECT_EQ(fract->Size(), 2u);
     EXPECT_EQ(fract->Align(), 2u);
     EXPECT_EQ(fract->Name(), Sym("fract"));
 
     auto* exp = ty->Members()[1];
-    EXPECT_TRUE(exp->Type()->Is<type::I32>());
+    EXPECT_TRUE(exp->Type()->Is<core::type::I32>());
     EXPECT_EQ(exp->Offset(), 4u);
     EXPECT_EQ(exp->Size(), 4u);
     EXPECT_EQ(exp->Align(), 4u);
@@ -1008,23 +1008,23 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    auto* ty = TypeOf(call)->As<type::Struct>();
+    auto* ty = TypeOf(call)->As<core::type::Struct>();
     ASSERT_NE(ty, nullptr);
     ASSERT_EQ(ty->Members().Length(), 2u);
 
     auto* fract = ty->Members()[0];
-    ASSERT_TRUE(fract->Type()->Is<type::Vector>());
-    EXPECT_EQ(fract->Type()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(fract->Type()->As<type::Vector>()->type()->Is<type::F32>());
+    ASSERT_TRUE(fract->Type()->Is<core::type::Vector>());
+    EXPECT_EQ(fract->Type()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(fract->Type()->As<core::type::Vector>()->type()->Is<core::type::F32>());
     EXPECT_EQ(fract->Offset(), 0u);
     EXPECT_EQ(fract->Size(), 12u);
     EXPECT_EQ(fract->Align(), 16u);
     EXPECT_EQ(fract->Name(), Sym("fract"));
 
     auto* exp = ty->Members()[1];
-    ASSERT_TRUE(exp->Type()->Is<type::Vector>());
-    EXPECT_EQ(exp->Type()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(exp->Type()->As<type::Vector>()->type()->Is<type::I32>());
+    ASSERT_TRUE(exp->Type()->Is<core::type::Vector>());
+    EXPECT_EQ(exp->Type()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(exp->Type()->As<core::type::Vector>()->type()->Is<core::type::I32>());
     EXPECT_EQ(exp->Offset(), 16u);
     EXPECT_EQ(exp->Size(), 12u);
     EXPECT_EQ(exp->Align(), 16u);
@@ -1043,23 +1043,23 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    auto* ty = TypeOf(call)->As<type::Struct>();
+    auto* ty = TypeOf(call)->As<core::type::Struct>();
     ASSERT_NE(ty, nullptr);
     ASSERT_EQ(ty->Members().Length(), 2u);
 
     auto* fract = ty->Members()[0];
-    ASSERT_TRUE(fract->Type()->Is<type::Vector>());
-    EXPECT_EQ(fract->Type()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(fract->Type()->As<type::Vector>()->type()->Is<type::F16>());
+    ASSERT_TRUE(fract->Type()->Is<core::type::Vector>());
+    EXPECT_EQ(fract->Type()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(fract->Type()->As<core::type::Vector>()->type()->Is<core::type::F16>());
     EXPECT_EQ(fract->Offset(), 0u);
     EXPECT_EQ(fract->Size(), 6u);
     EXPECT_EQ(fract->Align(), 8u);
     EXPECT_EQ(fract->Name(), Sym("fract"));
 
     auto* exp = ty->Members()[1];
-    ASSERT_TRUE(exp->Type()->Is<type::Vector>());
-    EXPECT_EQ(exp->Type()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(exp->Type()->As<type::Vector>()->type()->Is<type::I32>());
+    ASSERT_TRUE(exp->Type()->Is<core::type::Vector>());
+    EXPECT_EQ(exp->Type()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(exp->Type()->As<core::type::Vector>()->type()->Is<core::type::I32>());
     EXPECT_EQ(exp->Offset(), 16u);
     EXPECT_EQ(exp->Size(), 12u);
     EXPECT_EQ(exp->Align(), 16u);
@@ -1093,7 +1093,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::F32>());
 }
 
 TEST_F(ResolverBuiltinFloatTest, Length_Scalar_f16) {
@@ -1105,7 +1105,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::F16>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::F16>());
 }
 
 TEST_F(ResolverBuiltinFloatTest, Length_FloatVector_f32) {
@@ -1115,7 +1115,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::F32>());
 }
 
 TEST_F(ResolverBuiltinFloatTest, Length_FloatVector_f16) {
@@ -1127,7 +1127,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::F16>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::F16>());
 }
 
 TEST_F(ResolverBuiltinFloatTest, Length_NoParams) {
@@ -1168,9 +1168,9 @@
 
     ASSERT_NE(TypeOf(call), nullptr);
     EXPECT_TRUE(TypeOf(call)->is_float_vector());
-    EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-    ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-    EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F32>());
+    EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+    ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+    EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverBuiltinFloatTest, Mix_VectorScalar_f16) {
@@ -1183,9 +1183,9 @@
 
     ASSERT_NE(TypeOf(call), nullptr);
     EXPECT_TRUE(TypeOf(call)->is_float_vector());
-    EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-    ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-    EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F16>());
+    EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+    ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+    EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::F16>());
 }
 
 // modf: (f32) -> __modf_result, (vecN<f32>) -> __modf_result_vecN, (f16) -> __modf_result_f16,
@@ -1197,19 +1197,19 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    auto* ty = TypeOf(call)->As<type::Struct>();
+    auto* ty = TypeOf(call)->As<core::type::Struct>();
     ASSERT_NE(ty, nullptr);
     ASSERT_EQ(ty->Members().Length(), 2u);
 
     auto* fract = ty->Members()[0];
-    EXPECT_TRUE(fract->Type()->Is<type::F32>());
+    EXPECT_TRUE(fract->Type()->Is<core::type::F32>());
     EXPECT_EQ(fract->Offset(), 0u);
     EXPECT_EQ(fract->Size(), 4u);
     EXPECT_EQ(fract->Align(), 4u);
     EXPECT_EQ(fract->Name(), Sym("fract"));
 
     auto* whole = ty->Members()[1];
-    EXPECT_TRUE(whole->Type()->Is<type::F32>());
+    EXPECT_TRUE(whole->Type()->Is<core::type::F32>());
     EXPECT_EQ(whole->Offset(), 4u);
     EXPECT_EQ(whole->Size(), 4u);
     EXPECT_EQ(whole->Align(), 4u);
@@ -1228,19 +1228,19 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    auto* ty = TypeOf(call)->As<type::Struct>();
+    auto* ty = TypeOf(call)->As<core::type::Struct>();
     ASSERT_NE(ty, nullptr);
     ASSERT_EQ(ty->Members().Length(), 2u);
 
     auto* fract = ty->Members()[0];
-    EXPECT_TRUE(fract->Type()->Is<type::F16>());
+    EXPECT_TRUE(fract->Type()->Is<core::type::F16>());
     EXPECT_EQ(fract->Offset(), 0u);
     EXPECT_EQ(fract->Size(), 2u);
     EXPECT_EQ(fract->Align(), 2u);
     EXPECT_EQ(fract->Name(), Sym("fract"));
 
     auto* whole = ty->Members()[1];
-    EXPECT_TRUE(whole->Type()->Is<type::F16>());
+    EXPECT_TRUE(whole->Type()->Is<core::type::F16>());
     EXPECT_EQ(whole->Offset(), 2u);
     EXPECT_EQ(whole->Size(), 2u);
     EXPECT_EQ(whole->Align(), 2u);
@@ -1257,23 +1257,23 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    auto* ty = TypeOf(call)->As<type::Struct>();
+    auto* ty = TypeOf(call)->As<core::type::Struct>();
     ASSERT_NE(ty, nullptr);
     ASSERT_EQ(ty->Members().Length(), 2u);
 
     auto* fract = ty->Members()[0];
-    ASSERT_TRUE(fract->Type()->Is<type::Vector>());
-    EXPECT_EQ(fract->Type()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(fract->Type()->As<type::Vector>()->type()->Is<type::F32>());
+    ASSERT_TRUE(fract->Type()->Is<core::type::Vector>());
+    EXPECT_EQ(fract->Type()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(fract->Type()->As<core::type::Vector>()->type()->Is<core::type::F32>());
     EXPECT_EQ(fract->Offset(), 0u);
     EXPECT_EQ(fract->Size(), 12u);
     EXPECT_EQ(fract->Align(), 16u);
     EXPECT_EQ(fract->Name(), Sym("fract"));
 
     auto* whole = ty->Members()[1];
-    ASSERT_TRUE(whole->Type()->Is<type::Vector>());
-    EXPECT_EQ(whole->Type()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(whole->Type()->As<type::Vector>()->type()->Is<type::F32>());
+    ASSERT_TRUE(whole->Type()->Is<core::type::Vector>());
+    EXPECT_EQ(whole->Type()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(whole->Type()->As<core::type::Vector>()->type()->Is<core::type::F32>());
     EXPECT_EQ(whole->Offset(), 16u);
     EXPECT_EQ(whole->Size(), 12u);
     EXPECT_EQ(whole->Align(), 16u);
@@ -1292,23 +1292,23 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    auto* ty = TypeOf(call)->As<type::Struct>();
+    auto* ty = TypeOf(call)->As<core::type::Struct>();
     ASSERT_NE(ty, nullptr);
     ASSERT_EQ(ty->Members().Length(), 2u);
 
     auto* fract = ty->Members()[0];
-    ASSERT_TRUE(fract->Type()->Is<type::Vector>());
-    EXPECT_EQ(fract->Type()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(fract->Type()->As<type::Vector>()->type()->Is<type::F16>());
+    ASSERT_TRUE(fract->Type()->Is<core::type::Vector>());
+    EXPECT_EQ(fract->Type()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(fract->Type()->As<core::type::Vector>()->type()->Is<core::type::F16>());
     EXPECT_EQ(fract->Offset(), 0u);
     EXPECT_EQ(fract->Size(), 6u);
     EXPECT_EQ(fract->Align(), 8u);
     EXPECT_EQ(fract->Name(), Sym("fract"));
 
     auto* whole = ty->Members()[1];
-    ASSERT_TRUE(whole->Type()->Is<type::Vector>());
-    EXPECT_EQ(whole->Type()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(whole->Type()->As<type::Vector>()->type()->Is<type::F16>());
+    ASSERT_TRUE(whole->Type()->Is<core::type::Vector>());
+    EXPECT_EQ(whole->Type()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(whole->Type()->As<core::type::Vector>()->type()->Is<core::type::F16>());
     EXPECT_EQ(whole->Offset(), 8u);
     EXPECT_EQ(whole->Size(), 6u);
     EXPECT_EQ(whole->Align(), 8u);
@@ -1389,8 +1389,8 @@
 
     ASSERT_NE(TypeOf(call), nullptr);
     EXPECT_TRUE(TypeOf(call)->is_float_vector());
-    EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F32>());
+    EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverBuiltinFloatTest, Normalize_Vector_f16) {
@@ -1403,8 +1403,8 @@
 
     ASSERT_NE(TypeOf(call), nullptr);
     EXPECT_TRUE(TypeOf(call)->is_float_vector());
-    EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::F16>());
+    EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::F16>());
 }
 
 TEST_F(ResolverBuiltinFloatTest, Normalize_Error_NoParams) {
@@ -1465,7 +1465,7 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
 
         ASSERT_NE(TypeOf(call), nullptr);
-        EXPECT_TRUE(TypeOf(call)->Is<type::I32>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::I32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -1487,9 +1487,9 @@
 
         ASSERT_NE(TypeOf(call), nullptr);
         EXPECT_TRUE(TypeOf(call)->is_signed_integer_vector());
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-        ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-        EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::I32>());
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+        ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+        EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::I32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -1510,7 +1510,7 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
 
         ASSERT_NE(TypeOf(call), nullptr);
-        EXPECT_TRUE(TypeOf(call)->Is<type::U32>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::U32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -1532,9 +1532,9 @@
 
         ASSERT_NE(TypeOf(call), nullptr);
         EXPECT_TRUE(TypeOf(call)->is_unsigned_integer_vector());
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-        ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-        EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::U32>());
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+        ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+        EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::U32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -1555,7 +1555,7 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
 
         ASSERT_NE(TypeOf(call), nullptr);
-        EXPECT_TRUE(TypeOf(call)->Is<type::I32>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::I32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -1577,9 +1577,9 @@
 
         ASSERT_NE(TypeOf(call), nullptr);
         EXPECT_TRUE(TypeOf(call)->is_signed_integer_vector());
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-        ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-        EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::I32>());
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+        ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+        EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::I32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -1600,7 +1600,7 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
 
         ASSERT_NE(TypeOf(call), nullptr);
-        EXPECT_TRUE(TypeOf(call)->Is<type::U32>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::U32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -1622,9 +1622,9 @@
 
         ASSERT_NE(TypeOf(call), nullptr);
         EXPECT_TRUE(TypeOf(call)->is_unsigned_integer_vector());
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-        ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-        EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::U32>());
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+        ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+        EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::U32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -1645,7 +1645,7 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
 
         ASSERT_NE(TypeOf(call), nullptr);
-        EXPECT_TRUE(TypeOf(call)->Is<type::I32>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::I32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -1668,9 +1668,9 @@
 
         ASSERT_NE(TypeOf(call), nullptr);
         EXPECT_TRUE(TypeOf(call)->is_signed_integer_vector());
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-        ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-        EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::I32>());
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+        ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+        EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::I32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -1692,7 +1692,7 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
 
         ASSERT_NE(TypeOf(call), nullptr);
-        EXPECT_TRUE(TypeOf(call)->Is<type::U32>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::U32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -1715,9 +1715,9 @@
 
         ASSERT_NE(TypeOf(call), nullptr);
         EXPECT_TRUE(TypeOf(call)->is_unsigned_integer_vector());
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-        ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-        EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::U32>());
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+        ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+        EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::U32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -1739,7 +1739,7 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
 
         ASSERT_NE(TypeOf(call), nullptr);
-        EXPECT_TRUE(TypeOf(call)->Is<type::I32>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::I32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -1762,9 +1762,9 @@
 
         ASSERT_NE(TypeOf(call), nullptr);
         EXPECT_TRUE(TypeOf(call)->is_signed_integer_vector());
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-        ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-        EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::I32>());
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+        ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+        EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::I32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -1786,7 +1786,7 @@
         EXPECT_TRUE(r()->Resolve()) << r()->error();
 
         ASSERT_NE(TypeOf(call), nullptr);
-        EXPECT_TRUE(TypeOf(call)->Is<type::U32>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::U32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -1809,9 +1809,9 @@
 
         ASSERT_NE(TypeOf(call), nullptr);
         EXPECT_TRUE(TypeOf(call)->is_unsigned_integer_vector());
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 3u);
-        ASSERT_NE(TypeOf(call)->As<type::Vector>()->type(), nullptr);
-        EXPECT_TRUE(TypeOf(call)->As<type::Vector>()->type()->Is<type::U32>());
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 3u);
+        ASSERT_NE(TypeOf(call)->As<core::type::Vector>()->type(), nullptr);
+        EXPECT_TRUE(TypeOf(call)->As<core::type::Vector>()->type()->Is<core::type::U32>());
     } else {
         // Invalid parameter count.
         EXPECT_FALSE(r()->Resolve());
@@ -1853,7 +1853,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::F32>());
 }
 
 TEST_F(ResolverBuiltinTest, Determinant_2x2_f16) {
@@ -1867,7 +1867,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::F16>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::F16>());
 }
 
 TEST_F(ResolverBuiltinTest, Determinant_3x3_f32) {
@@ -1879,7 +1879,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::F32>());
 }
 
 TEST_F(ResolverBuiltinTest, Determinant_3x3_f16) {
@@ -1893,7 +1893,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::F16>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::F16>());
 }
 
 TEST_F(ResolverBuiltinTest, Determinant_4x4_f32) {
@@ -1905,7 +1905,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::F32>());
 }
 
 TEST_F(ResolverBuiltinTest, Determinant_4x4_f16) {
@@ -1919,7 +1919,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::F16>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::F16>());
 }
 
 TEST_F(ResolverBuiltinTest, Determinant_NotSquare) {
@@ -1966,7 +1966,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    EXPECT_TRUE(TypeOf(expr)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(expr)->Is<core::type::F32>());
 }
 
 TEST_F(ResolverBuiltinTest, Dot_Vec2_f16) {
@@ -1980,7 +1980,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    EXPECT_TRUE(TypeOf(expr)->Is<type::F16>());
+    EXPECT_TRUE(TypeOf(expr)->Is<core::type::F16>());
 }
 
 TEST_F(ResolverBuiltinTest, Dot_Vec3_i32) {
@@ -1992,7 +1992,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    EXPECT_TRUE(TypeOf(expr)->Is<type::I32>());
+    EXPECT_TRUE(TypeOf(expr)->Is<core::type::I32>());
 }
 
 TEST_F(ResolverBuiltinTest, Dot_Vec4_u32) {
@@ -2004,7 +2004,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    EXPECT_TRUE(TypeOf(expr)->Is<type::U32>());
+    EXPECT_TRUE(TypeOf(expr)->Is<core::type::U32>());
 }
 
 TEST_F(ResolverBuiltinTest, Dot_Error_Scalar) {
@@ -2040,7 +2040,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    ASSERT_TRUE(TypeOf(expr)->Is<type::F32>());
+    ASSERT_TRUE(TypeOf(expr)->Is<core::type::F32>());
 }
 
 TEST_P(ResolverBuiltinDerivativeTest, Vector) {
@@ -2054,9 +2054,9 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    ASSERT_TRUE(TypeOf(expr)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(expr)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(expr)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(expr)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(expr)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(expr)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_P(ResolverBuiltinDerivativeTest, MissingParam) {
@@ -2104,7 +2104,7 @@
 }
 
 struct TextureTestParams {
-    type::TextureDimension dim;
+    core::type::TextureDimension dim;
     Texture type = Texture::kF32;
     core::TexelFormat format = core::TexelFormat::kR32Float;
 };
@@ -2122,16 +2122,16 @@
     /// @param dim dimensionality of the texture being sampled
     /// @param scalar the scalar type
     /// @returns a pointer to a type appropriate for the coord param
-    ast::Type GetCoordsType(type::TextureDimension dim, ast::Type scalar) {
+    ast::Type GetCoordsType(core::type::TextureDimension dim, ast::Type scalar) {
         switch (dim) {
-            case type::TextureDimension::k1d:
+            case core::type::TextureDimension::k1d:
                 return ty(scalar);
-            case type::TextureDimension::k2d:
-            case type::TextureDimension::k2dArray:
+            case core::type::TextureDimension::k2d:
+            case core::type::TextureDimension::k2dArray:
                 return ty.vec2(scalar);
-            case type::TextureDimension::k3d:
-            case type::TextureDimension::kCube:
-            case type::TextureDimension::kCubeArray:
+            case core::type::TextureDimension::k3d:
+            case core::type::TextureDimension::kCube:
+            case core::type::TextureDimension::kCubeArray:
                 return ty.vec3(scalar);
             default:
                 [=] {
@@ -2177,7 +2177,7 @@
 
     add_call_param("texture", texture_type, &call_params);
     add_call_param("coords", coords_type, &call_params);
-    if (dim == type::TextureDimension::k2dArray) {
+    if (dim == core::type::TextureDimension::k2dArray) {
         add_call_param("array_index", ty.i32(), &call_params);
     }
     add_call_param("level", ty.i32(), &call_params);
@@ -2188,23 +2188,23 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    ASSERT_TRUE(TypeOf(expr)->Is<type::Vector>());
+    ASSERT_TRUE(TypeOf(expr)->Is<core::type::Vector>());
     if (type == Texture::kF32) {
-        EXPECT_TRUE(TypeOf(expr)->As<type::Vector>()->type()->Is<type::F32>());
+        EXPECT_TRUE(TypeOf(expr)->As<core::type::Vector>()->type()->Is<core::type::F32>());
     } else if (type == Texture::kI32) {
-        EXPECT_TRUE(TypeOf(expr)->As<type::Vector>()->type()->Is<type::I32>());
+        EXPECT_TRUE(TypeOf(expr)->As<core::type::Vector>()->type()->Is<core::type::I32>());
     } else {
-        EXPECT_TRUE(TypeOf(expr)->As<type::Vector>()->type()->Is<type::U32>());
+        EXPECT_TRUE(TypeOf(expr)->As<core::type::Vector>()->type()->Is<core::type::U32>());
     }
-    EXPECT_EQ(TypeOf(expr)->As<type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(expr)->As<core::type::Vector>()->Width(), 4u);
 }
 
 INSTANTIATE_TEST_SUITE_P(ResolverTest,
                          ResolverBuiltinTest_SampledTextureOperation,
-                         testing::Values(TextureTestParams{type::TextureDimension::k1d},
-                                         TextureTestParams{type::TextureDimension::k2d},
-                                         TextureTestParams{type::TextureDimension::k2dArray},
-                                         TextureTestParams{type::TextureDimension::k3d}));
+                         testing::Values(TextureTestParams{core::type::TextureDimension::k1d},
+                                         TextureTestParams{core::type::TextureDimension::k2d},
+                                         TextureTestParams{core::type::TextureDimension::k2dArray},
+                                         TextureTestParams{core::type::TextureDimension::k3d}));
 
 using ResolverBuiltinTest_Texture = ResolverTestWithParam<ast::test::TextureOverloadCase>;
 
@@ -2480,78 +2480,78 @@
                 str << param.texture_dimension;
                 FAIL() << "invalid texture dimensions: " << str.str();
             }
-            case type::TextureDimension::k1d:
-                EXPECT_TRUE(TypeOf(call)->Is<type::U32>());
+            case core::type::TextureDimension::k1d:
+                EXPECT_TRUE(TypeOf(call)->Is<core::type::U32>());
                 break;
-            case type::TextureDimension::k2d:
-            case type::TextureDimension::k2dArray:
-            case type::TextureDimension::kCube:
-            case type::TextureDimension::kCubeArray: {
-                auto* vec = As<type::Vector>(TypeOf(call));
+            case core::type::TextureDimension::k2d:
+            case core::type::TextureDimension::k2dArray:
+            case core::type::TextureDimension::kCube:
+            case core::type::TextureDimension::kCubeArray: {
+                auto* vec = As<core::type::Vector>(TypeOf(call));
                 ASSERT_NE(vec, nullptr);
                 EXPECT_EQ(vec->Width(), 2u);
-                EXPECT_TRUE(vec->type()->Is<type::U32>());
+                EXPECT_TRUE(vec->type()->Is<core::type::U32>());
                 break;
             }
-            case type::TextureDimension::k3d: {
-                auto* vec = As<type::Vector>(TypeOf(call));
+            case core::type::TextureDimension::k3d: {
+                auto* vec = As<core::type::Vector>(TypeOf(call));
                 ASSERT_NE(vec, nullptr);
                 EXPECT_EQ(vec->Width(), 3u);
-                EXPECT_TRUE(vec->type()->Is<type::U32>());
+                EXPECT_TRUE(vec->type()->Is<core::type::U32>());
                 break;
             }
         }
     } else if (std::string(param.function) == "textureNumLayers") {
-        EXPECT_TRUE(TypeOf(call)->Is<type::U32>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::U32>());
     } else if (std::string(param.function) == "textureNumLevels") {
-        EXPECT_TRUE(TypeOf(call)->Is<type::U32>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::U32>());
     } else if (std::string(param.function) == "textureNumSamples") {
-        EXPECT_TRUE(TypeOf(call)->Is<type::U32>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::U32>());
     } else if (std::string(param.function) == "textureStore") {
-        EXPECT_TRUE(TypeOf(call)->Is<type::Void>());
+        EXPECT_TRUE(TypeOf(call)->Is<core::type::Void>());
     } else if (std::string(param.function) == "textureGather") {
-        auto* vec = As<type::Vector>(TypeOf(call));
+        auto* vec = As<core::type::Vector>(TypeOf(call));
         ASSERT_NE(vec, nullptr);
         EXPECT_EQ(vec->Width(), 4u);
         switch (param.texture_data_type) {
             case ast::test::TextureDataType::kF32:
-                EXPECT_TRUE(vec->type()->Is<type::F32>());
+                EXPECT_TRUE(vec->type()->Is<core::type::F32>());
                 break;
             case ast::test::TextureDataType::kU32:
-                EXPECT_TRUE(vec->type()->Is<type::U32>());
+                EXPECT_TRUE(vec->type()->Is<core::type::U32>());
                 break;
             case ast::test::TextureDataType::kI32:
-                EXPECT_TRUE(vec->type()->Is<type::I32>());
+                EXPECT_TRUE(vec->type()->Is<core::type::I32>());
                 break;
         }
     } else if (std::string(param.function) == "textureGatherCompare") {
-        auto* vec = As<type::Vector>(TypeOf(call));
+        auto* vec = As<core::type::Vector>(TypeOf(call));
         ASSERT_NE(vec, nullptr);
         EXPECT_EQ(vec->Width(), 4u);
-        EXPECT_TRUE(vec->type()->Is<type::F32>());
+        EXPECT_TRUE(vec->type()->Is<core::type::F32>());
     } else {
         switch (param.texture_kind) {
             case ast::test::TextureKind::kRegular:
             case ast::test::TextureKind::kMultisampled:
             case ast::test::TextureKind::kStorage: {
-                auto* vec = TypeOf(call)->As<type::Vector>();
+                auto* vec = TypeOf(call)->As<core::type::Vector>();
                 ASSERT_NE(vec, nullptr);
                 switch (param.texture_data_type) {
                     case ast::test::TextureDataType::kF32:
-                        EXPECT_TRUE(vec->type()->Is<type::F32>());
+                        EXPECT_TRUE(vec->type()->Is<core::type::F32>());
                         break;
                     case ast::test::TextureDataType::kU32:
-                        EXPECT_TRUE(vec->type()->Is<type::U32>());
+                        EXPECT_TRUE(vec->type()->Is<core::type::U32>());
                         break;
                     case ast::test::TextureDataType::kI32:
-                        EXPECT_TRUE(vec->type()->Is<type::I32>());
+                        EXPECT_TRUE(vec->type()->Is<core::type::I32>());
                         break;
                 }
                 break;
             }
             case ast::test::TextureKind::kDepth:
             case ast::test::TextureKind::kDepthMultisampled: {
-                EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+                EXPECT_TRUE(TypeOf(call)->Is<core::type::F32>());
                 break;
             }
         }
@@ -2585,7 +2585,7 @@
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::U32>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::U32>());
 }
 
 TEST_P(ResolverBuiltinTest_DataPacking, Error_IncorrectParamType) {
@@ -2657,9 +2657,9 @@
     ASSERT_NE(TypeOf(call), nullptr);
     EXPECT_TRUE(TypeOf(call)->is_float_vector());
     if (pack4) {
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 4u);
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 4u);
     } else {
-        EXPECT_EQ(TypeOf(call)->As<type::Vector>()->Width(), 2u);
+        EXPECT_EQ(TypeOf(call)->As<core::type::Vector>()->Width(), 2u);
     }
 }
 
@@ -2686,7 +2686,7 @@
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::Void>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::Void>());
 }
 
 TEST_P(ResolverBuiltinTest_Barrier, Error_TooManyParams) {
diff --git a/src/tint/lang/wgsl/resolver/builtins_validation_test.cc b/src/tint/lang/wgsl/resolver/builtins_validation_test.cc
index 74d7fd3..204a678 100644
--- a/src/tint/lang/wgsl/resolver/builtins_validation_test.cc
+++ b/src/tint/lang/wgsl/resolver/builtins_validation_test.cc
@@ -936,12 +936,12 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    auto* res_ty = TypeOf(builtin)->As<type::Struct>();
+    auto* res_ty = TypeOf(builtin)->As<core::type::Struct>();
     ASSERT_TRUE(res_ty != nullptr);
     auto members = res_ty->Members();
     ASSERT_EQ(members.Length(), 2u);
-    EXPECT_TRUE(members[0]->Type()->Is<type::F32>());
-    EXPECT_TRUE(members[1]->Type()->Is<type::I32>());
+    EXPECT_TRUE(members[0]->Type()->Is<core::type::F32>());
+    EXPECT_TRUE(members[1]->Type()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverBuiltinsValidationTest, Frexp_Vec2) {
@@ -949,16 +949,16 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    auto* res_ty = TypeOf(builtin)->As<type::Struct>();
+    auto* res_ty = TypeOf(builtin)->As<core::type::Struct>();
     ASSERT_TRUE(res_ty != nullptr);
     auto members = res_ty->Members();
     ASSERT_EQ(members.Length(), 2u);
-    ASSERT_TRUE(members[0]->Type()->Is<type::Vector>());
-    ASSERT_TRUE(members[1]->Type()->Is<type::Vector>());
-    EXPECT_EQ(members[0]->Type()->As<type::Vector>()->Width(), 2u);
-    EXPECT_TRUE(members[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(members[1]->Type()->As<type::Vector>()->Width(), 2u);
-    EXPECT_TRUE(members[1]->Type()->As<type::Vector>()->type()->Is<type::I32>());
+    ASSERT_TRUE(members[0]->Type()->Is<core::type::Vector>());
+    ASSERT_TRUE(members[1]->Type()->Is<core::type::Vector>());
+    EXPECT_EQ(members[0]->Type()->As<core::type::Vector>()->Width(), 2u);
+    EXPECT_TRUE(members[0]->Type()->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(members[1]->Type()->As<core::type::Vector>()->Width(), 2u);
+    EXPECT_TRUE(members[1]->Type()->As<core::type::Vector>()->type()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverBuiltinsValidationTest, Frexp_Vec3) {
@@ -966,16 +966,16 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    auto* res_ty = TypeOf(builtin)->As<type::Struct>();
+    auto* res_ty = TypeOf(builtin)->As<core::type::Struct>();
     ASSERT_TRUE(res_ty != nullptr);
     auto members = res_ty->Members();
     ASSERT_EQ(members.Length(), 2u);
-    ASSERT_TRUE(members[0]->Type()->Is<type::Vector>());
-    ASSERT_TRUE(members[1]->Type()->Is<type::Vector>());
-    EXPECT_EQ(members[0]->Type()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(members[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(members[1]->Type()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(members[1]->Type()->As<type::Vector>()->type()->Is<type::I32>());
+    ASSERT_TRUE(members[0]->Type()->Is<core::type::Vector>());
+    ASSERT_TRUE(members[1]->Type()->Is<core::type::Vector>());
+    EXPECT_EQ(members[0]->Type()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(members[0]->Type()->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(members[1]->Type()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(members[1]->Type()->As<core::type::Vector>()->type()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverBuiltinsValidationTest, Frexp_Vec4) {
@@ -983,16 +983,16 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    auto* res_ty = TypeOf(builtin)->As<type::Struct>();
+    auto* res_ty = TypeOf(builtin)->As<core::type::Struct>();
     ASSERT_TRUE(res_ty != nullptr);
     auto members = res_ty->Members();
     ASSERT_EQ(members.Length(), 2u);
-    ASSERT_TRUE(members[0]->Type()->Is<type::Vector>());
-    ASSERT_TRUE(members[1]->Type()->Is<type::Vector>());
-    EXPECT_EQ(members[0]->Type()->As<type::Vector>()->Width(), 4u);
-    EXPECT_TRUE(members[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(members[1]->Type()->As<type::Vector>()->Width(), 4u);
-    EXPECT_TRUE(members[1]->Type()->As<type::Vector>()->type()->Is<type::I32>());
+    ASSERT_TRUE(members[0]->Type()->Is<core::type::Vector>());
+    ASSERT_TRUE(members[1]->Type()->Is<core::type::Vector>());
+    EXPECT_EQ(members[0]->Type()->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_TRUE(members[0]->Type()->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(members[1]->Type()->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_TRUE(members[1]->Type()->As<core::type::Vector>()->type()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverBuiltinsValidationTest, Modf_Scalar) {
@@ -1000,12 +1000,12 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    auto* res_ty = TypeOf(builtin)->As<type::Struct>();
+    auto* res_ty = TypeOf(builtin)->As<core::type::Struct>();
     ASSERT_TRUE(res_ty != nullptr);
     auto members = res_ty->Members();
     ASSERT_EQ(members.Length(), 2u);
-    EXPECT_TRUE(members[0]->Type()->Is<type::F32>());
-    EXPECT_TRUE(members[1]->Type()->Is<type::F32>());
+    EXPECT_TRUE(members[0]->Type()->Is<core::type::F32>());
+    EXPECT_TRUE(members[1]->Type()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverBuiltinsValidationTest, Modf_Vec2) {
@@ -1013,16 +1013,16 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    auto* res_ty = TypeOf(builtin)->As<type::Struct>();
+    auto* res_ty = TypeOf(builtin)->As<core::type::Struct>();
     ASSERT_TRUE(res_ty != nullptr);
     auto members = res_ty->Members();
     ASSERT_EQ(members.Length(), 2u);
-    ASSERT_TRUE(members[0]->Type()->Is<type::Vector>());
-    ASSERT_TRUE(members[1]->Type()->Is<type::Vector>());
-    EXPECT_EQ(members[0]->Type()->As<type::Vector>()->Width(), 2u);
-    EXPECT_TRUE(members[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(members[1]->Type()->As<type::Vector>()->Width(), 2u);
-    EXPECT_TRUE(members[1]->Type()->As<type::Vector>()->type()->Is<type::F32>());
+    ASSERT_TRUE(members[0]->Type()->Is<core::type::Vector>());
+    ASSERT_TRUE(members[1]->Type()->Is<core::type::Vector>());
+    EXPECT_EQ(members[0]->Type()->As<core::type::Vector>()->Width(), 2u);
+    EXPECT_TRUE(members[0]->Type()->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(members[1]->Type()->As<core::type::Vector>()->Width(), 2u);
+    EXPECT_TRUE(members[1]->Type()->As<core::type::Vector>()->type()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverBuiltinsValidationTest, Modf_Vec3) {
@@ -1030,16 +1030,16 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    auto* res_ty = TypeOf(builtin)->As<type::Struct>();
+    auto* res_ty = TypeOf(builtin)->As<core::type::Struct>();
     ASSERT_TRUE(res_ty != nullptr);
     auto members = res_ty->Members();
     ASSERT_EQ(members.Length(), 2u);
-    ASSERT_TRUE(members[0]->Type()->Is<type::Vector>());
-    ASSERT_TRUE(members[1]->Type()->Is<type::Vector>());
-    EXPECT_EQ(members[0]->Type()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(members[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(members[1]->Type()->As<type::Vector>()->Width(), 3u);
-    EXPECT_TRUE(members[1]->Type()->As<type::Vector>()->type()->Is<type::F32>());
+    ASSERT_TRUE(members[0]->Type()->Is<core::type::Vector>());
+    ASSERT_TRUE(members[1]->Type()->Is<core::type::Vector>());
+    EXPECT_EQ(members[0]->Type()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(members[0]->Type()->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(members[1]->Type()->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_TRUE(members[1]->Type()->As<core::type::Vector>()->type()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverBuiltinsValidationTest, Modf_Vec4) {
@@ -1047,16 +1047,16 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    auto* res_ty = TypeOf(builtin)->As<type::Struct>();
+    auto* res_ty = TypeOf(builtin)->As<core::type::Struct>();
     ASSERT_TRUE(res_ty != nullptr);
     auto members = res_ty->Members();
     ASSERT_EQ(members.Length(), 2u);
-    ASSERT_TRUE(members[0]->Type()->Is<type::Vector>());
-    ASSERT_TRUE(members[1]->Type()->Is<type::Vector>());
-    EXPECT_EQ(members[0]->Type()->As<type::Vector>()->Width(), 4u);
-    EXPECT_TRUE(members[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(members[1]->Type()->As<type::Vector>()->Width(), 4u);
-    EXPECT_TRUE(members[1]->Type()->As<type::Vector>()->type()->Is<type::F32>());
+    ASSERT_TRUE(members[0]->Type()->Is<core::type::Vector>());
+    ASSERT_TRUE(members[1]->Type()->Is<core::type::Vector>());
+    EXPECT_EQ(members[0]->Type()->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_TRUE(members[0]->Type()->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(members[1]->Type()->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_TRUE(members[1]->Type()->As<core::type::Vector>()->type()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverBuiltinsValidationTest, Cross_Float_Vec3) {
@@ -1158,7 +1158,7 @@
          });
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    EXPECT_TRUE(TypeOf(builtin)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(builtin)->Is<core::type::F32>());
 }
 
 TEST_P(FloatAllMatching, Vec2) {
@@ -1282,7 +1282,7 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    EXPECT_TRUE(TypeOf(builtin)->Is<type::U32>());
+    EXPECT_TRUE(TypeOf(builtin)->Is<core::type::U32>());
 }
 
 TEST_P(IntegerAllMatching, Vec2Unsigned) {
@@ -1342,7 +1342,7 @@
     WrapInFunction(builtin);
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
-    EXPECT_TRUE(TypeOf(builtin)->Is<type::I32>());
+    EXPECT_TRUE(TypeOf(builtin)->Is<core::type::I32>());
 }
 
 TEST_P(IntegerAllMatching, Vec2Signed) {
diff --git a/src/tint/lang/wgsl/resolver/dependency_graph_test.cc b/src/tint/lang/wgsl/resolver/dependency_graph_test.cc
index 9f3fb00..1ceb195 100644
--- a/src/tint/lang/wgsl/resolver/dependency_graph_test.cc
+++ b/src/tint/lang/wgsl/resolver/dependency_graph_test.cc
@@ -489,12 +489,13 @@
         }
         case SymbolUseKind::GlobalVarSampledTexElemType: {
             ast::Type node = b.ty(source, symbol);
-            b.GlobalVar(b.Sym(), b.ty.sampled_texture(type::TextureDimension::k2d, node));
+            b.GlobalVar(b.Sym(), b.ty.sampled_texture(core::type::TextureDimension::k2d, node));
             return node->identifier;
         }
         case SymbolUseKind::GlobalVarMultisampledTexElemType: {
             ast::Type node = b.ty(source, symbol);
-            b.GlobalVar(b.Sym(), b.ty.multisampled_texture(type::TextureDimension::k2d, node));
+            b.GlobalVar(b.Sym(),
+                        b.ty.multisampled_texture(core::type::TextureDimension::k2d, node));
             return node->identifier;
         }
         case SymbolUseKind::GlobalVarValue: {
@@ -1722,14 +1723,14 @@
     GlobalVar(Sym(), ty.vec3(T));
     GlobalVar(Sym(), ty.mat3x2(T));
     GlobalVar(Sym(), ty.ptr<private_>(T));
-    GlobalVar(Sym(), ty.sampled_texture(type::TextureDimension::k2d, T));
-    GlobalVar(Sym(), ty.depth_texture(type::TextureDimension::k2d));
-    GlobalVar(Sym(), ty.depth_multisampled_texture(type::TextureDimension::k2d));
+    GlobalVar(Sym(), ty.sampled_texture(core::type::TextureDimension::k2d, T));
+    GlobalVar(Sym(), ty.depth_texture(core::type::TextureDimension::k2d));
+    GlobalVar(Sym(), ty.depth_multisampled_texture(core::type::TextureDimension::k2d));
     GlobalVar(Sym(), ty.external_texture());
-    GlobalVar(Sym(), ty.multisampled_texture(type::TextureDimension::k2d, T));
-    GlobalVar(Sym(), ty.storage_texture(type::TextureDimension::k2d, core::TexelFormat::kR32Float,
-                                        core::Access::kRead));
-    GlobalVar(Sym(), ty.sampler(type::SamplerKind::kSampler));
+    GlobalVar(Sym(), ty.multisampled_texture(core::type::TextureDimension::k2d, T));
+    GlobalVar(Sym(), ty.storage_texture(core::type::TextureDimension::k2d,
+                                        core::TexelFormat::kR32Float, core::Access::kRead));
+    GlobalVar(Sym(), ty.sampler(core::type::SamplerKind::kSampler));
 
     GlobalVar(Sym(), ty.i32(), Vector{Binding(V), Group(V)});
     GlobalVar(Sym(), ty.i32(), Vector{Location(V)});
diff --git a/src/tint/lang/wgsl/resolver/expression_kind_test.cc b/src/tint/lang/wgsl/resolver/expression_kind_test.cc
index 3e1e991..00511d9 100644
--- a/src/tint/lang/wgsl/resolver/expression_kind_test.cc
+++ b/src/tint/lang/wgsl/resolver/expression_kind_test.cc
@@ -178,7 +178,7 @@
                 ASSERT_NE(expr, nullptr);
                 auto* ty_expr = expr->As<sem::TypeExpression>();
                 ASSERT_NE(ty_expr, nullptr);
-                EXPECT_TRUE(ty_expr->Type()->Is<type::Vector>());
+                EXPECT_TRUE(ty_expr->Type()->Is<core::type::Vector>());
             };
             break;
         }
@@ -266,7 +266,7 @@
                 ASSERT_NE(expr, nullptr);
                 auto* ty_expr = expr->As<sem::TypeExpression>();
                 ASSERT_NE(ty_expr, nullptr);
-                EXPECT_TRUE(ty_expr->Type()->Is<type::I32>());
+                EXPECT_TRUE(ty_expr->Type()->Is<core::type::I32>());
             };
             break;
         }
diff --git a/src/tint/lang/wgsl/resolver/inferred_type_test.cc b/src/tint/lang/wgsl/resolver/inferred_type_test.cc
index 5032828..750fc39 100644
--- a/src/tint/lang/wgsl/resolver/inferred_type_test.cc
+++ b/src/tint/lang/wgsl/resolver/inferred_type_test.cc
@@ -124,8 +124,9 @@
 
 TEST_F(ResolverInferredTypeTest, InferArray_Pass) {
     auto type = ty.array<u32, 10>();
-    auto* expected_type = create<type::Array>(
-        create<type::U32>(), create<type::ConstantArrayCount>(10u), 4u, 4u * 10u, 4u, 4u);
+    auto* expected_type = create<core::type::Array>(create<core::type::U32>(),
+                                                    create<core::type::ConstantArrayCount>(10u), 4u,
+                                                    4u * 10u, 4u, 4u);
 
     auto* ctor_expr = Call(type);
     auto* var = Var("a", core::AddressSpace::kFunction, ctor_expr);
@@ -141,8 +142,8 @@
 
     auto* expected_type = create<sem::Struct>(
         str, str->name->symbol,
-        Vector{create<sem::StructMember>(member, member->name->symbol, create<type::I32>(), 0u, 0u,
-                                         0u, 4u, type::StructMemberAttributes{})},
+        Vector{create<sem::StructMember>(member, member->name->symbol, create<core::type::I32>(),
+                                         0u, 0u, 0u, 4u, core::type::StructMemberAttributes{})},
         0u, 4u, 4u);
 
     auto* ctor_expr = Call(ty.Of(str));
diff --git a/src/tint/lang/wgsl/resolver/is_host_shareable_test.cc b/src/tint/lang/wgsl/resolver/is_host_shareable_test.cc
index f6b4e00..e23a9b5 100644
--- a/src/tint/lang/wgsl/resolver/is_host_shareable_test.cc
+++ b/src/tint/lang/wgsl/resolver/is_host_shareable_test.cc
@@ -24,96 +24,96 @@
 using ResolverIsHostShareable = ResolverTest;
 
 TEST_F(ResolverIsHostShareable, Void) {
-    EXPECT_FALSE(r()->IsHostShareable(create<type::Void>()));
+    EXPECT_FALSE(r()->IsHostShareable(create<core::type::Void>()));
 }
 
 TEST_F(ResolverIsHostShareable, Bool) {
-    EXPECT_FALSE(r()->IsHostShareable(create<type::Bool>()));
+    EXPECT_FALSE(r()->IsHostShareable(create<core::type::Bool>()));
 }
 
 TEST_F(ResolverIsHostShareable, NumericScalar) {
-    EXPECT_TRUE(r()->IsHostShareable(create<type::I32>()));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::U32>()));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::F32>()));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::F16>()));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::I32>()));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::U32>()));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::F32>()));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::F16>()));
 }
 
 TEST_F(ResolverIsHostShareable, NumericVector) {
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::I32>(), 2u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::I32>(), 3u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::I32>(), 4u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::U32>(), 2u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::U32>(), 3u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::U32>(), 4u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::F32>(), 2u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::F32>(), 3u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::F32>(), 4u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::F16>(), 2u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::F16>(), 3u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Vector>(create<type::F16>(), 4u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::I32>(), 2u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::I32>(), 3u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::I32>(), 4u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::U32>(), 2u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::U32>(), 3u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::U32>(), 4u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::F32>(), 2u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::F32>(), 3u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::F32>(), 4u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::F16>(), 2u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::F16>(), 3u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::F16>(), 4u)));
 }
 
 TEST_F(ResolverIsHostShareable, BoolVector) {
-    EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 2u)));
-    EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 3u)));
-    EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 4u)));
-    EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 2u)));
-    EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 3u)));
-    EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 4u)));
-    EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 2u)));
-    EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 3u)));
-    EXPECT_FALSE(r()->IsHostShareable(create<type::Vector>(create<type::Bool>(), 4u)));
+    EXPECT_FALSE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::Bool>(), 2u)));
+    EXPECT_FALSE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::Bool>(), 3u)));
+    EXPECT_FALSE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::Bool>(), 4u)));
+    EXPECT_FALSE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::Bool>(), 2u)));
+    EXPECT_FALSE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::Bool>(), 3u)));
+    EXPECT_FALSE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::Bool>(), 4u)));
+    EXPECT_FALSE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::Bool>(), 2u)));
+    EXPECT_FALSE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::Bool>(), 3u)));
+    EXPECT_FALSE(r()->IsHostShareable(create<core::type::Vector>(create<core::type::Bool>(), 4u)));
 }
 
 TEST_F(ResolverIsHostShareable, Matrix) {
-    auto* vec2_f32 = create<type::Vector>(create<type::F32>(), 2u);
-    auto* vec3_f32 = create<type::Vector>(create<type::F32>(), 3u);
-    auto* vec4_f32 = create<type::Vector>(create<type::F32>(), 4u);
-    auto* vec2_f16 = create<type::Vector>(create<type::F16>(), 2u);
-    auto* vec3_f16 = create<type::Vector>(create<type::F16>(), 3u);
-    auto* vec4_f16 = create<type::Vector>(create<type::F16>(), 4u);
+    auto* vec2_f32 = create<core::type::Vector>(create<core::type::F32>(), 2u);
+    auto* vec3_f32 = create<core::type::Vector>(create<core::type::F32>(), 3u);
+    auto* vec4_f32 = create<core::type::Vector>(create<core::type::F32>(), 4u);
+    auto* vec2_f16 = create<core::type::Vector>(create<core::type::F16>(), 2u);
+    auto* vec3_f16 = create<core::type::Vector>(create<core::type::F16>(), 3u);
+    auto* vec4_f16 = create<core::type::Vector>(create<core::type::F16>(), 4u);
 
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec2_f32, 2u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec2_f32, 3u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec2_f32, 4u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec3_f32, 2u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec3_f32, 3u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec3_f32, 4u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec4_f32, 2u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec4_f32, 3u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec4_f32, 4u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec2_f32, 2u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec2_f32, 3u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec2_f32, 4u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec3_f32, 2u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec3_f32, 3u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec3_f32, 4u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec4_f32, 2u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec4_f32, 3u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec4_f32, 4u)));
 
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec2_f16, 2u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec2_f16, 3u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec2_f16, 4u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec3_f16, 2u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec3_f16, 3u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec3_f16, 4u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec4_f16, 2u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec4_f16, 3u)));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Matrix>(vec4_f16, 4u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec2_f16, 2u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec2_f16, 3u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec2_f16, 4u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec3_f16, 2u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec3_f16, 3u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec3_f16, 4u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec4_f16, 2u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec4_f16, 3u)));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Matrix>(vec4_f16, 4u)));
 }
 
 TEST_F(ResolverIsHostShareable, Pointer) {
-    auto* ptr = create<type::Pointer>(core::AddressSpace::kPrivate, create<type::I32>(),
-                                      core::Access::kReadWrite);
+    auto* ptr = create<core::type::Pointer>(core::AddressSpace::kPrivate, create<core::type::I32>(),
+                                            core::Access::kReadWrite);
     EXPECT_FALSE(r()->IsHostShareable(ptr));
 }
 
 TEST_F(ResolverIsHostShareable, Atomic) {
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Atomic>(create<type::I32>())));
-    EXPECT_TRUE(r()->IsHostShareable(create<type::Atomic>(create<type::U32>())));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Atomic>(create<core::type::I32>())));
+    EXPECT_TRUE(r()->IsHostShareable(create<core::type::Atomic>(create<core::type::U32>())));
 }
 
 TEST_F(ResolverIsHostShareable, ArraySizedOfHostShareable) {
-    auto* arr = create<type::Array>(create<type::I32>(), create<type::ConstantArrayCount>(5u), 4u,
-                                    20u, 4u, 4u);
+    auto* arr = create<core::type::Array>(
+        create<core::type::I32>(), create<core::type::ConstantArrayCount>(5u), 4u, 20u, 4u, 4u);
     EXPECT_TRUE(r()->IsHostShareable(arr));
 }
 
 TEST_F(ResolverIsHostShareable, ArrayUnsizedOfHostShareable) {
-    auto* arr =
-        create<type::Array>(create<type::I32>(), create<type::RuntimeArrayCount>(), 4u, 4u, 4u, 4u);
+    auto* arr = create<core::type::Array>(create<core::type::I32>(),
+                                          create<core::type::RuntimeArrayCount>(), 4u, 4u, 4u, 4u);
     EXPECT_TRUE(r()->IsHostShareable(arr));
 }
 
diff --git a/src/tint/lang/wgsl/resolver/is_storeable_test.cc b/src/tint/lang/wgsl/resolver/is_storeable_test.cc
index 30cf8b8..b040dce 100644
--- a/src/tint/lang/wgsl/resolver/is_storeable_test.cc
+++ b/src/tint/lang/wgsl/resolver/is_storeable_test.cc
@@ -26,79 +26,79 @@
 using ResolverIsStorableTest = ResolverTest;
 
 TEST_F(ResolverIsStorableTest, Void) {
-    EXPECT_FALSE(r()->IsStorable(create<type::Void>()));
+    EXPECT_FALSE(r()->IsStorable(create<core::type::Void>()));
 }
 
 TEST_F(ResolverIsStorableTest, Scalar) {
-    EXPECT_TRUE(r()->IsStorable(create<type::Bool>()));
-    EXPECT_TRUE(r()->IsStorable(create<type::I32>()));
-    EXPECT_TRUE(r()->IsStorable(create<type::U32>()));
-    EXPECT_TRUE(r()->IsStorable(create<type::F32>()));
-    EXPECT_TRUE(r()->IsStorable(create<type::F16>()));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Bool>()));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::I32>()));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::U32>()));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::F32>()));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::F16>()));
 }
 
 TEST_F(ResolverIsStorableTest, Vector) {
-    EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::I32>(), 2u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::I32>(), 3u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::I32>(), 4u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::U32>(), 2u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::U32>(), 3u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::U32>(), 4u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::F32>(), 2u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::F32>(), 3u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::F32>(), 4u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::F16>(), 2u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::F16>(), 3u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Vector>(create<type::F16>(), 4u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Vector>(create<core::type::I32>(), 2u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Vector>(create<core::type::I32>(), 3u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Vector>(create<core::type::I32>(), 4u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Vector>(create<core::type::U32>(), 2u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Vector>(create<core::type::U32>(), 3u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Vector>(create<core::type::U32>(), 4u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Vector>(create<core::type::F32>(), 2u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Vector>(create<core::type::F32>(), 3u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Vector>(create<core::type::F32>(), 4u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Vector>(create<core::type::F16>(), 2u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Vector>(create<core::type::F16>(), 3u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Vector>(create<core::type::F16>(), 4u)));
 }
 
 TEST_F(ResolverIsStorableTest, Matrix) {
-    auto* vec2_f32 = create<type::Vector>(create<type::F32>(), 2u);
-    auto* vec3_f32 = create<type::Vector>(create<type::F32>(), 3u);
-    auto* vec4_f32 = create<type::Vector>(create<type::F32>(), 4u);
-    auto* vec2_f16 = create<type::Vector>(create<type::F16>(), 2u);
-    auto* vec3_f16 = create<type::Vector>(create<type::F16>(), 3u);
-    auto* vec4_f16 = create<type::Vector>(create<type::F16>(), 4u);
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec2_f32, 2u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec2_f32, 3u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec2_f32, 4u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec3_f32, 2u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec3_f32, 3u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec3_f32, 4u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec4_f32, 2u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec4_f32, 3u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec4_f32, 4u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec2_f16, 2u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec2_f16, 3u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec2_f16, 4u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec3_f16, 2u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec3_f16, 3u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec3_f16, 4u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec4_f16, 2u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec4_f16, 3u)));
-    EXPECT_TRUE(r()->IsStorable(create<type::Matrix>(vec4_f16, 4u)));
+    auto* vec2_f32 = create<core::type::Vector>(create<core::type::F32>(), 2u);
+    auto* vec3_f32 = create<core::type::Vector>(create<core::type::F32>(), 3u);
+    auto* vec4_f32 = create<core::type::Vector>(create<core::type::F32>(), 4u);
+    auto* vec2_f16 = create<core::type::Vector>(create<core::type::F16>(), 2u);
+    auto* vec3_f16 = create<core::type::Vector>(create<core::type::F16>(), 3u);
+    auto* vec4_f16 = create<core::type::Vector>(create<core::type::F16>(), 4u);
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec2_f32, 2u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec2_f32, 3u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec2_f32, 4u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec3_f32, 2u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec3_f32, 3u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec3_f32, 4u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec4_f32, 2u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec4_f32, 3u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec4_f32, 4u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec2_f16, 2u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec2_f16, 3u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec2_f16, 4u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec3_f16, 2u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec3_f16, 3u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec3_f16, 4u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec4_f16, 2u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec4_f16, 3u)));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Matrix>(vec4_f16, 4u)));
 }
 
 TEST_F(ResolverIsStorableTest, Pointer) {
-    auto* ptr = create<type::Pointer>(core::AddressSpace::kPrivate, create<type::I32>(),
-                                      core::Access::kReadWrite);
+    auto* ptr = create<core::type::Pointer>(core::AddressSpace::kPrivate, create<core::type::I32>(),
+                                            core::Access::kReadWrite);
     EXPECT_FALSE(r()->IsStorable(ptr));
 }
 
 TEST_F(ResolverIsStorableTest, Atomic) {
-    EXPECT_TRUE(r()->IsStorable(create<type::Atomic>(create<type::I32>())));
-    EXPECT_TRUE(r()->IsStorable(create<type::Atomic>(create<type::U32>())));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Atomic>(create<core::type::I32>())));
+    EXPECT_TRUE(r()->IsStorable(create<core::type::Atomic>(create<core::type::U32>())));
 }
 
 TEST_F(ResolverIsStorableTest, ArraySizedOfStorable) {
-    auto* arr = create<type::Array>(create<type::I32>(), create<type::ConstantArrayCount>(5u), 4u,
-                                    20u, 4u, 4u);
+    auto* arr = create<core::type::Array>(
+        create<core::type::I32>(), create<core::type::ConstantArrayCount>(5u), 4u, 20u, 4u, 4u);
     EXPECT_TRUE(r()->IsStorable(arr));
 }
 
 TEST_F(ResolverIsStorableTest, ArrayUnsizedOfStorable) {
-    auto* arr =
-        create<type::Array>(create<type::I32>(), create<type::RuntimeArrayCount>(), 4u, 4u, 4u, 4u);
+    auto* arr = create<core::type::Array>(create<core::type::I32>(),
+                                          create<core::type::RuntimeArrayCount>(), 4u, 4u, 4u, 4u);
     EXPECT_TRUE(r()->IsStorable(arr));
 }
 
diff --git a/src/tint/lang/wgsl/resolver/load_test.cc b/src/tint/lang/wgsl/resolver/load_test.cc
index 26cb8c8..9c5f5ab 100644
--- a/src/tint/lang/wgsl/resolver/load_test.cc
+++ b/src/tint/lang/wgsl/resolver/load_test.cc
@@ -38,9 +38,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* load = Sem().Get<sem::Load>(ident);
     ASSERT_NE(load, nullptr);
-    EXPECT_TRUE(load->Type()->Is<type::I32>());
-    EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::I32>());
+    EXPECT_TRUE(load->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverLoadTest, LetInitializer) {
@@ -53,9 +53,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* load = Sem().Get<sem::Load>(ident);
     ASSERT_NE(load, nullptr);
-    EXPECT_TRUE(load->Type()->Is<type::I32>());
-    EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::I32>());
+    EXPECT_TRUE(load->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverLoadTest, Assignment) {
@@ -70,9 +70,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* load = Sem().Get<sem::Load>(ident);
     ASSERT_NE(load, nullptr);
-    EXPECT_TRUE(load->Type()->Is<type::I32>());
-    EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::I32>());
+    EXPECT_TRUE(load->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverLoadTest, CompoundAssignment) {
@@ -87,9 +87,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* load = Sem().Get<sem::Load>(ident);
     ASSERT_NE(load, nullptr);
-    EXPECT_TRUE(load->Type()->Is<type::I32>());
-    EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::I32>());
+    EXPECT_TRUE(load->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverLoadTest, UnaryOp) {
@@ -102,9 +102,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* load = Sem().Get<sem::Load>(ident);
     ASSERT_NE(load, nullptr);
-    EXPECT_TRUE(load->Type()->Is<type::I32>());
-    EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::I32>());
+    EXPECT_TRUE(load->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverLoadTest, UnaryOp_NoLoad) {
@@ -117,8 +117,8 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* var_user = Sem().Get<sem::VariableUser>(ident);
     ASSERT_NE(var_user, nullptr);
-    EXPECT_TRUE(var_user->Type()->Is<type::Reference>());
-    EXPECT_TRUE(var_user->Type()->UnwrapRef()->Is<type::I32>());
+    EXPECT_TRUE(var_user->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(var_user->Type()->UnwrapRef()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverLoadTest, BinaryOp) {
@@ -131,9 +131,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* load = Sem().Get<sem::Load>(ident);
     ASSERT_NE(load, nullptr);
-    EXPECT_TRUE(load->Type()->Is<type::I32>());
-    EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::I32>());
+    EXPECT_TRUE(load->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverLoadTest, Index) {
@@ -146,9 +146,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* load = Sem().Get<sem::Load>(ident);
     ASSERT_NE(load, nullptr);
-    EXPECT_TRUE(load->Type()->Is<type::I32>());
-    EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::I32>());
+    EXPECT_TRUE(load->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverLoadTest, MultiComponentSwizzle) {
@@ -161,9 +161,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* load = Sem().Get<sem::Load>(ident);
     ASSERT_NE(load, nullptr);
-    EXPECT_TRUE(load->Type()->Is<type::Vector>());
-    EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::Vector>());
+    EXPECT_TRUE(load->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::Vector>());
 }
 
 TEST_F(ResolverLoadTest, Bitcast) {
@@ -176,9 +176,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* load = Sem().Get<sem::Load>(ident);
     ASSERT_NE(load, nullptr);
-    EXPECT_TRUE(load->Type()->Is<type::F32>());
-    EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::F32>());
+    EXPECT_TRUE(load->Type()->Is<core::type::F32>());
+    EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverLoadTest, BuiltinArg) {
@@ -191,9 +191,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* load = Sem().Get<sem::Load>(ident);
     ASSERT_NE(load, nullptr);
-    EXPECT_TRUE(load->Type()->Is<type::F32>());
-    EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::F32>());
+    EXPECT_TRUE(load->Type()->Is<core::type::F32>());
+    EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverLoadTest, FunctionArg) {
@@ -208,9 +208,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* load = Sem().Get<sem::Load>(ident);
     ASSERT_NE(load, nullptr);
-    EXPECT_TRUE(load->Type()->Is<type::F32>());
-    EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::F32>());
+    EXPECT_TRUE(load->Type()->Is<core::type::F32>());
+    EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverLoadTest, FunctionArg_Handles) {
@@ -220,13 +220,13 @@
     //   return textureSampleLevel(tp, sp, vec2(), 0);
     // }
     // f(t, s);
-    GlobalVar("t", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()),
+    GlobalVar("t", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()),
               Vector{Group(0_a), Binding(0_a)});
-    GlobalVar("s", ty.sampler(type::SamplerKind::kSampler), Vector{Group(0_a), Binding(1_a)});
+    GlobalVar("s", ty.sampler(core::type::SamplerKind::kSampler), Vector{Group(0_a), Binding(1_a)});
     Func("f",
          Vector{
-             Param("tp", ty.sampled_texture(type::TextureDimension::k2d, ty.f32())),
-             Param("sp", ty.sampler(type::SamplerKind::kSampler)),
+             Param("tp", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32())),
+             Param("sp", ty.sampler(core::type::SamplerKind::kSampler)),
          },
          ty.vec4<f32>(),
          Vector{
@@ -241,16 +241,16 @@
     {
         auto* load = Sem().Get<sem::Load>(t_ident);
         ASSERT_NE(load, nullptr);
-        EXPECT_TRUE(load->Type()->Is<type::SampledTexture>());
-        EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-        EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::SampledTexture>());
+        EXPECT_TRUE(load->Type()->Is<core::type::SampledTexture>());
+        EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+        EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::SampledTexture>());
     }
     {
         auto* load = Sem().Get<sem::Load>(s_ident);
         ASSERT_NE(load, nullptr);
-        EXPECT_TRUE(load->Type()->Is<type::Sampler>());
-        EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-        EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::Sampler>());
+        EXPECT_TRUE(load->Type()->Is<core::type::Sampler>());
+        EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+        EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::Sampler>());
     }
 }
 
@@ -267,9 +267,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* load = Sem().Get<sem::Load>(ident);
     ASSERT_NE(load, nullptr);
-    EXPECT_TRUE(load->Type()->Is<type::F32>());
-    EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::F32>());
+    EXPECT_TRUE(load->Type()->Is<core::type::F32>());
+    EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverLoadTest, IfCond) {
@@ -282,9 +282,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* load = Sem().Get<sem::Load>(ident);
     ASSERT_NE(load, nullptr);
-    EXPECT_TRUE(load->Type()->Is<type::Bool>());
-    EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::Bool>());
+    EXPECT_TRUE(load->Type()->Is<core::type::Bool>());
+    EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::Bool>());
 }
 
 TEST_F(ResolverLoadTest, Switch) {
@@ -299,9 +299,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* load = Sem().Get<sem::Load>(ident);
     ASSERT_NE(load, nullptr);
-    EXPECT_TRUE(load->Type()->Is<type::I32>());
-    EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::I32>());
+    EXPECT_TRUE(load->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverLoadTest, BreakIfCond) {
@@ -318,9 +318,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* load = Sem().Get<sem::Load>(ident);
     ASSERT_NE(load, nullptr);
-    EXPECT_TRUE(load->Type()->Is<type::Bool>());
-    EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::Bool>());
+    EXPECT_TRUE(load->Type()->Is<core::type::Bool>());
+    EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::Bool>());
 }
 
 TEST_F(ResolverLoadTest, ForCond) {
@@ -333,9 +333,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* load = Sem().Get<sem::Load>(ident);
     ASSERT_NE(load, nullptr);
-    EXPECT_TRUE(load->Type()->Is<type::Bool>());
-    EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::Bool>());
+    EXPECT_TRUE(load->Type()->Is<core::type::Bool>());
+    EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::Bool>());
 }
 
 TEST_F(ResolverLoadTest, WhileCond) {
@@ -348,9 +348,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* load = Sem().Get<sem::Load>(ident);
     ASSERT_NE(load, nullptr);
-    EXPECT_TRUE(load->Type()->Is<type::Bool>());
-    EXPECT_TRUE(load->Reference()->Type()->Is<type::Reference>());
-    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<type::Bool>());
+    EXPECT_TRUE(load->Type()->Is<core::type::Bool>());
+    EXPECT_TRUE(load->Reference()->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(load->Reference()->Type()->UnwrapRef()->Is<core::type::Bool>());
 }
 
 TEST_F(ResolverLoadTest, AddressOf) {
@@ -363,7 +363,7 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* no_load = Sem().GetVal(ident);
     ASSERT_NE(no_load, nullptr);
-    EXPECT_TRUE(no_load->Type()->Is<type::Reference>());  // No load
+    EXPECT_TRUE(no_load->Type()->Is<core::type::Reference>());  // No load
 }
 
 }  // namespace
diff --git a/src/tint/lang/wgsl/resolver/materialize_test.cc b/src/tint/lang/wgsl/resolver/materialize_test.cc
index 28fc798..c56245b 100644
--- a/src/tint/lang/wgsl/resolver/materialize_test.cc
+++ b/src/tint/lang/wgsl/resolver/materialize_test.cc
@@ -77,7 +77,7 @@
 class MaterializeTest : public resolver::ResolverTestWithParam<CASE> {
   protected:
     void CheckTypesAndValues(const sem::ValueExpression* expr,
-                             const tint::type::Type* expected_sem_ty,
+                             const tint::core::type::Type* expected_sem_ty,
                              const std::variant<AInt, AFloat>& expected_value) {
         std::visit([&](auto v) { CheckTypesAndValuesImpl(expr, expected_sem_ty, v); },
                    expected_value);
@@ -86,7 +86,7 @@
   private:
     template <typename T>
     void CheckTypesAndValuesImpl(const sem::ValueExpression* expr,
-                                 const tint::type::Type* expected_sem_ty,
+                                 const tint::core::type::Type* expected_sem_ty,
                                  T expected_value) {
         EXPECT_TYPE(expr->Type(), expected_sem_ty);
 
@@ -96,7 +96,7 @@
 
         tint::Switch(
             expected_sem_ty,  //
-            [&](const type::Vector* v) {
+            [&](const core::type::Vector* v) {
                 for (uint32_t i = 0; i < v->Width(); i++) {
                     auto* el = value->Index(i);
                     ASSERT_NE(el, nullptr);
@@ -104,7 +104,7 @@
                     EXPECT_EQ(el->ValueAs<T>(), expected_value);
                 }
             },
-            [&](const type::Matrix* m) {
+            [&](const core::type::Matrix* m) {
                 for (uint32_t c = 0; c < m->columns(); c++) {
                     auto* column = value->Index(c);
                     ASSERT_NE(column, nullptr);
@@ -117,7 +117,7 @@
                     }
                 }
             },
-            [&](const type::Array* a) {
+            [&](const core::type::Array* a) {
                 auto count = a->ConstantCount();
                 ASSERT_NE(count, 0u);
                 for (uint32_t i = 0; i < count; i++) {
@@ -1266,12 +1266,12 @@
     auto* sem = Sem().Get(call);
     ASSERT_TRUE(sem->Is<sem::Materialize>());
     auto* materialize = sem->As<sem::Materialize>();
-    ASSERT_TRUE(materialize->Type()->Is<type::Struct>());
-    auto* concrete_str = materialize->Type()->As<type::Struct>();
-    ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::F32>());
-    ASSERT_TRUE(materialize->Expr()->Type()->Is<type::Struct>());
-    auto* abstract_str = materialize->Expr()->Type()->As<type::Struct>();
-    ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::AbstractFloat>());
+    ASSERT_TRUE(materialize->Type()->Is<core::type::Struct>());
+    auto* concrete_str = materialize->Type()->As<core::type::Struct>();
+    ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<core::type::F32>());
+    ASSERT_TRUE(materialize->Expr()->Type()->Is<core::type::Struct>());
+    auto* abstract_str = materialize->Expr()->Type()->As<core::type::Struct>();
+    ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<core::type::AbstractFloat>());
 }
 
 TEST_F(MaterializeAbstractStructure, Modf_Vector_DefaultType) {
@@ -1282,15 +1282,22 @@
     auto* sem = Sem().Get(call);
     ASSERT_TRUE(sem->Is<sem::Materialize>());
     auto* materialize = sem->As<sem::Materialize>();
-    ASSERT_TRUE(materialize->Type()->Is<type::Struct>());
-    auto* concrete_str = materialize->Type()->As<type::Struct>();
-    ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::Vector>());
-    ASSERT_TRUE(concrete_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
-    ASSERT_TRUE(materialize->Expr()->Type()->Is<type::Struct>());
-    auto* abstract_str = materialize->Expr()->Type()->As<type::Struct>();
-    ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::Vector>());
-    ASSERT_TRUE(
-        abstract_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::AbstractFloat>());
+    ASSERT_TRUE(materialize->Type()->Is<core::type::Struct>());
+    auto* concrete_str = materialize->Type()->As<core::type::Struct>();
+    ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<core::type::Vector>());
+    ASSERT_TRUE(concrete_str->Members()[0]
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::F32>());
+    ASSERT_TRUE(materialize->Expr()->Type()->Is<core::type::Struct>());
+    auto* abstract_str = materialize->Expr()->Type()->As<core::type::Struct>();
+    ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<core::type::Vector>());
+    ASSERT_TRUE(abstract_str->Members()[0]
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::AbstractFloat>());
 }
 
 TEST_F(MaterializeAbstractStructure, Modf_Scalar_ExplicitType) {
@@ -1304,12 +1311,12 @@
     auto* sem = Sem().Get(call);
     ASSERT_TRUE(sem->Is<sem::Materialize>());
     auto* materialize = sem->As<sem::Materialize>();
-    ASSERT_TRUE(materialize->Type()->Is<type::Struct>());
-    auto* concrete_str = materialize->Type()->As<type::Struct>();
-    ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::F16>());
-    ASSERT_TRUE(materialize->Expr()->Type()->Is<type::Struct>());
-    auto* abstract_str = materialize->Expr()->Type()->As<type::Struct>();
-    ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::AbstractFloat>());
+    ASSERT_TRUE(materialize->Type()->Is<core::type::Struct>());
+    auto* concrete_str = materialize->Type()->As<core::type::Struct>();
+    ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<core::type::F16>());
+    ASSERT_TRUE(materialize->Expr()->Type()->Is<core::type::Struct>());
+    auto* abstract_str = materialize->Expr()->Type()->As<core::type::Struct>();
+    ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<core::type::AbstractFloat>());
 }
 
 TEST_F(MaterializeAbstractStructure, Modf_Vector_ExplicitType) {
@@ -1322,15 +1329,22 @@
     auto* sem = Sem().Get(call);
     ASSERT_TRUE(sem->Is<sem::Materialize>());
     auto* materialize = sem->As<sem::Materialize>();
-    ASSERT_TRUE(materialize->Type()->Is<type::Struct>());
-    auto* concrete_str = materialize->Type()->As<type::Struct>();
-    ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::Vector>());
-    ASSERT_TRUE(concrete_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::F16>());
-    ASSERT_TRUE(materialize->Expr()->Type()->Is<type::Struct>());
-    auto* abstract_str = materialize->Expr()->Type()->As<type::Struct>();
-    ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::Vector>());
-    ASSERT_TRUE(
-        abstract_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::AbstractFloat>());
+    ASSERT_TRUE(materialize->Type()->Is<core::type::Struct>());
+    auto* concrete_str = materialize->Type()->As<core::type::Struct>();
+    ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<core::type::Vector>());
+    ASSERT_TRUE(concrete_str->Members()[0]
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::F16>());
+    ASSERT_TRUE(materialize->Expr()->Type()->Is<core::type::Struct>());
+    auto* abstract_str = materialize->Expr()->Type()->As<core::type::Struct>();
+    ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<core::type::Vector>());
+    ASSERT_TRUE(abstract_str->Members()[0]
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::AbstractFloat>());
 }
 
 TEST_F(MaterializeAbstractStructure, Frexp_Scalar_DefaultType) {
@@ -1341,14 +1355,14 @@
     auto* sem = Sem().Get(call);
     ASSERT_TRUE(sem->Is<sem::Materialize>());
     auto* materialize = sem->As<sem::Materialize>();
-    ASSERT_TRUE(materialize->Type()->Is<type::Struct>());
-    auto* concrete_str = materialize->Type()->As<type::Struct>();
-    ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::F32>());
-    ASSERT_TRUE(concrete_str->Members()[1]->Type()->Is<type::I32>());
-    ASSERT_TRUE(materialize->Expr()->Type()->Is<type::Struct>());
-    auto* abstract_str = materialize->Expr()->Type()->As<type::Struct>();
-    ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::AbstractFloat>());
-    ASSERT_TRUE(abstract_str->Members()[1]->Type()->Is<type::AbstractInt>());
+    ASSERT_TRUE(materialize->Type()->Is<core::type::Struct>());
+    auto* concrete_str = materialize->Type()->As<core::type::Struct>();
+    ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<core::type::F32>());
+    ASSERT_TRUE(concrete_str->Members()[1]->Type()->Is<core::type::I32>());
+    ASSERT_TRUE(materialize->Expr()->Type()->Is<core::type::Struct>());
+    auto* abstract_str = materialize->Expr()->Type()->As<core::type::Struct>();
+    ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<core::type::AbstractFloat>());
+    ASSERT_TRUE(abstract_str->Members()[1]->Type()->Is<core::type::AbstractInt>());
 }
 
 TEST_F(MaterializeAbstractStructure, Frexp_Vector_DefaultType) {
@@ -1359,19 +1373,33 @@
     auto* sem = Sem().Get(call);
     ASSERT_TRUE(sem->Is<sem::Materialize>());
     auto* materialize = sem->As<sem::Materialize>();
-    ASSERT_TRUE(materialize->Type()->Is<type::Struct>());
-    auto* concrete_str = materialize->Type()->As<type::Struct>();
-    ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::Vector>());
-    ASSERT_TRUE(concrete_str->Members()[1]->Type()->Is<type::Vector>());
-    ASSERT_TRUE(concrete_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
-    ASSERT_TRUE(concrete_str->Members()[1]->Type()->As<type::Vector>()->type()->Is<type::I32>());
-    ASSERT_TRUE(materialize->Expr()->Type()->Is<type::Struct>());
-    auto* abstract_str = materialize->Expr()->Type()->As<type::Struct>();
-    ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::Vector>());
-    ASSERT_TRUE(
-        abstract_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::AbstractFloat>());
-    ASSERT_TRUE(
-        abstract_str->Members()[1]->Type()->As<type::Vector>()->type()->Is<type::AbstractInt>());
+    ASSERT_TRUE(materialize->Type()->Is<core::type::Struct>());
+    auto* concrete_str = materialize->Type()->As<core::type::Struct>();
+    ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<core::type::Vector>());
+    ASSERT_TRUE(concrete_str->Members()[1]->Type()->Is<core::type::Vector>());
+    ASSERT_TRUE(concrete_str->Members()[0]
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::F32>());
+    ASSERT_TRUE(concrete_str->Members()[1]
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::I32>());
+    ASSERT_TRUE(materialize->Expr()->Type()->Is<core::type::Struct>());
+    auto* abstract_str = materialize->Expr()->Type()->As<core::type::Struct>();
+    ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<core::type::Vector>());
+    ASSERT_TRUE(abstract_str->Members()[0]
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::AbstractFloat>());
+    ASSERT_TRUE(abstract_str->Members()[1]
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::AbstractInt>());
 }
 
 TEST_F(MaterializeAbstractStructure, Frexp_Scalar_ExplicitType) {
@@ -1385,14 +1413,14 @@
     auto* sem = Sem().Get(call);
     ASSERT_TRUE(sem->Is<sem::Materialize>());
     auto* materialize = sem->As<sem::Materialize>();
-    ASSERT_TRUE(materialize->Type()->Is<type::Struct>());
-    auto* concrete_str = materialize->Type()->As<type::Struct>();
-    ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::F16>());
-    ASSERT_TRUE(concrete_str->Members()[1]->Type()->Is<type::I32>());
-    ASSERT_TRUE(materialize->Expr()->Type()->Is<type::Struct>());
-    auto* abstract_str = materialize->Expr()->Type()->As<type::Struct>();
-    ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::AbstractFloat>());
-    ASSERT_TRUE(abstract_str->Members()[1]->Type()->Is<type::AbstractInt>());
+    ASSERT_TRUE(materialize->Type()->Is<core::type::Struct>());
+    auto* concrete_str = materialize->Type()->As<core::type::Struct>();
+    ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<core::type::F16>());
+    ASSERT_TRUE(concrete_str->Members()[1]->Type()->Is<core::type::I32>());
+    ASSERT_TRUE(materialize->Expr()->Type()->Is<core::type::Struct>());
+    auto* abstract_str = materialize->Expr()->Type()->As<core::type::Struct>();
+    ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<core::type::AbstractFloat>());
+    ASSERT_TRUE(abstract_str->Members()[1]->Type()->Is<core::type::AbstractInt>());
 }
 
 TEST_F(MaterializeAbstractStructure, Frexp_Vector_ExplicitType) {
@@ -1405,19 +1433,33 @@
     auto* sem = Sem().Get(call);
     ASSERT_TRUE(sem->Is<sem::Materialize>());
     auto* materialize = sem->As<sem::Materialize>();
-    ASSERT_TRUE(materialize->Type()->Is<type::Struct>());
-    auto* concrete_str = materialize->Type()->As<type::Struct>();
-    ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<type::Vector>());
-    ASSERT_TRUE(concrete_str->Members()[1]->Type()->Is<type::Vector>());
-    ASSERT_TRUE(concrete_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::F16>());
-    ASSERT_TRUE(concrete_str->Members()[1]->Type()->As<type::Vector>()->type()->Is<type::I32>());
-    ASSERT_TRUE(materialize->Expr()->Type()->Is<type::Struct>());
-    auto* abstract_str = materialize->Expr()->Type()->As<type::Struct>();
-    ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<type::Vector>());
-    ASSERT_TRUE(
-        abstract_str->Members()[0]->Type()->As<type::Vector>()->type()->Is<type::AbstractFloat>());
-    ASSERT_TRUE(
-        abstract_str->Members()[1]->Type()->As<type::Vector>()->type()->Is<type::AbstractInt>());
+    ASSERT_TRUE(materialize->Type()->Is<core::type::Struct>());
+    auto* concrete_str = materialize->Type()->As<core::type::Struct>();
+    ASSERT_TRUE(concrete_str->Members()[0]->Type()->Is<core::type::Vector>());
+    ASSERT_TRUE(concrete_str->Members()[1]->Type()->Is<core::type::Vector>());
+    ASSERT_TRUE(concrete_str->Members()[0]
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::F16>());
+    ASSERT_TRUE(concrete_str->Members()[1]
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::I32>());
+    ASSERT_TRUE(materialize->Expr()->Type()->Is<core::type::Struct>());
+    auto* abstract_str = materialize->Expr()->Type()->As<core::type::Struct>();
+    ASSERT_TRUE(abstract_str->Members()[0]->Type()->Is<core::type::Vector>());
+    ASSERT_TRUE(abstract_str->Members()[0]
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::AbstractFloat>());
+    ASSERT_TRUE(abstract_str->Members()[1]
+                    ->Type()
+                    ->As<core::type::Vector>()
+                    ->type()
+                    ->Is<core::type::AbstractInt>());
 }
 
 }  // namespace materialize_abstract_structure
diff --git a/src/tint/lang/wgsl/resolver/ptr_ref_test.cc b/src/tint/lang/wgsl/resolver/ptr_ref_test.cc
index 3257029..e22f9b9 100644
--- a/src/tint/lang/wgsl/resolver/ptr_ref_test.cc
+++ b/src/tint/lang/wgsl/resolver/ptr_ref_test.cc
@@ -37,9 +37,10 @@
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(expr)->Is<type::Pointer>());
-    EXPECT_TRUE(TypeOf(expr)->As<type::Pointer>()->StoreType()->Is<type::I32>());
-    EXPECT_EQ(TypeOf(expr)->As<type::Pointer>()->AddressSpace(), core::AddressSpace::kFunction);
+    ASSERT_TRUE(TypeOf(expr)->Is<core::type::Pointer>());
+    EXPECT_TRUE(TypeOf(expr)->As<core::type::Pointer>()->StoreType()->Is<core::type::I32>());
+    EXPECT_EQ(TypeOf(expr)->As<core::type::Pointer>()->AddressSpace(),
+              core::AddressSpace::kFunction);
 }
 
 TEST_F(ResolverPtrRefTest, AddressOfThenDeref) {
@@ -59,8 +60,8 @@
     auto* ref = load->Reference();
     ASSERT_NE(ref, nullptr);
 
-    ASSERT_TRUE(ref->Type()->Is<type::Reference>());
-    EXPECT_TRUE(ref->Type()->As<type::Reference>()->StoreType()->Is<type::I32>());
+    ASSERT_TRUE(ref->Type()->Is<core::type::Reference>());
+    EXPECT_TRUE(ref->Type()->As<core::type::Reference>()->StoreType()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverPtrRefTest, DefaultPtrAddressSpace) {
@@ -90,22 +91,22 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(function_ptr)->Is<type::Pointer>())
+    ASSERT_TRUE(TypeOf(function_ptr)->Is<core::type::Pointer>())
         << "function_ptr is " << TypeOf(function_ptr)->TypeInfo().name;
-    ASSERT_TRUE(TypeOf(private_ptr)->Is<type::Pointer>())
+    ASSERT_TRUE(TypeOf(private_ptr)->Is<core::type::Pointer>())
         << "private_ptr is " << TypeOf(private_ptr)->TypeInfo().name;
-    ASSERT_TRUE(TypeOf(workgroup_ptr)->Is<type::Pointer>())
+    ASSERT_TRUE(TypeOf(workgroup_ptr)->Is<core::type::Pointer>())
         << "workgroup_ptr is " << TypeOf(workgroup_ptr)->TypeInfo().name;
-    ASSERT_TRUE(TypeOf(uniform_ptr)->Is<type::Pointer>())
+    ASSERT_TRUE(TypeOf(uniform_ptr)->Is<core::type::Pointer>())
         << "uniform_ptr is " << TypeOf(uniform_ptr)->TypeInfo().name;
-    ASSERT_TRUE(TypeOf(storage_ptr)->Is<type::Pointer>())
+    ASSERT_TRUE(TypeOf(storage_ptr)->Is<core::type::Pointer>())
         << "storage_ptr is " << TypeOf(storage_ptr)->TypeInfo().name;
 
-    EXPECT_EQ(TypeOf(function_ptr)->As<type::Pointer>()->Access(), core::Access::kReadWrite);
-    EXPECT_EQ(TypeOf(private_ptr)->As<type::Pointer>()->Access(), core::Access::kReadWrite);
-    EXPECT_EQ(TypeOf(workgroup_ptr)->As<type::Pointer>()->Access(), core::Access::kReadWrite);
-    EXPECT_EQ(TypeOf(uniform_ptr)->As<type::Pointer>()->Access(), core::Access::kRead);
-    EXPECT_EQ(TypeOf(storage_ptr)->As<type::Pointer>()->Access(), core::Access::kRead);
+    EXPECT_EQ(TypeOf(function_ptr)->As<core::type::Pointer>()->Access(), core::Access::kReadWrite);
+    EXPECT_EQ(TypeOf(private_ptr)->As<core::type::Pointer>()->Access(), core::Access::kReadWrite);
+    EXPECT_EQ(TypeOf(workgroup_ptr)->As<core::type::Pointer>()->Access(), core::Access::kReadWrite);
+    EXPECT_EQ(TypeOf(uniform_ptr)->As<core::type::Pointer>()->Access(), core::Access::kRead);
+    EXPECT_EQ(TypeOf(storage_ptr)->As<core::type::Pointer>()->Access(), core::Access::kRead);
 }
 
 }  // namespace
diff --git a/src/tint/lang/wgsl/resolver/ptr_ref_validation_test.cc b/src/tint/lang/wgsl/resolver/ptr_ref_validation_test.cc
index f806252..d4ddb72 100644
--- a/src/tint/lang/wgsl/resolver/ptr_ref_validation_test.cc
+++ b/src/tint/lang/wgsl/resolver/ptr_ref_validation_test.cc
@@ -55,7 +55,7 @@
 TEST_F(ResolverPtrRefValidationTest, AddressOfHandle) {
     // @group(0) @binding(0) var t: texture_3d<f32>;
     // &t
-    GlobalVar("t", ty.sampled_texture(type::TextureDimension::k3d, ty.f32()), Group(0_a),
+    GlobalVar("t", ty.sampled_texture(core::type::TextureDimension::k3d, ty.f32()), Group(0_a),
               Binding(0_a));
     auto* expr = AddressOf(Expr(Source{{12, 34}}, "t"));
     WrapInFunction(expr);
@@ -95,7 +95,7 @@
 TEST_F(ResolverPtrRefValidationTest, IndirectOfAddressOfHandle) {
     // @group(0) @binding(0) var t: texture_3d<f32>;
     // *&t
-    GlobalVar("t", ty.sampled_texture(type::TextureDimension::k3d, ty.f32()), Group(0_a),
+    GlobalVar("t", ty.sampled_texture(core::type::TextureDimension::k3d, ty.f32()), Group(0_a),
               Binding(0_a));
     auto* expr = Deref(AddressOf(Expr(Source{{12, 34}}, "t")));
     WrapInFunction(expr);
diff --git a/src/tint/lang/wgsl/resolver/resolver.cc b/src/tint/lang/wgsl/resolver/resolver.cc
index c231fcc..45e1d94 100644
--- a/src/tint/lang/wgsl/resolver/resolver.cc
+++ b/src/tint/lang/wgsl/resolver/resolver.cc
@@ -245,7 +245,7 @@
 }
 
 sem::Variable* Resolver::Let(const ast::Let* v, bool is_global) {
-    const type::Type* ty = nullptr;
+    const core::type::Type* ty = nullptr;
 
     // If the variable has a declared type, resolve it.
     if (v->type) {
@@ -288,8 +288,8 @@
         return nullptr;
     }
 
-    if (!ApplyAddressSpaceUsageToType(core::AddressSpace::kUndefined, const_cast<type::Type*>(ty),
-                                      v->source)) {
+    if (!ApplyAddressSpaceUsageToType(core::AddressSpace::kUndefined,
+                                      const_cast<core::type::Type*>(ty), v->source)) {
         AddNote("while instantiating 'let' " + v->name->symbol.Name(), v->source);
         return nullptr;
     }
@@ -313,7 +313,7 @@
 }
 
 sem::Variable* Resolver::Override(const ast::Override* v) {
-    const type::Type* ty = nullptr;
+    const core::type::Type* ty = nullptr;
 
     // If the variable has a declared type, resolve it.
     if (v->type) {
@@ -351,8 +351,8 @@
         return nullptr;
     }
 
-    if (!ApplyAddressSpaceUsageToType(core::AddressSpace::kUndefined, const_cast<type::Type*>(ty),
-                                      v->source)) {
+    if (!ApplyAddressSpaceUsageToType(core::AddressSpace::kUndefined,
+                                      const_cast<core::type::Type*>(ty), v->source)) {
         AddNote("while instantiating 'override' " + v->name->symbol.Name(), v->source);
         return nullptr;
     }
@@ -375,7 +375,7 @@
                 if (!materialized) {
                     return false;
                 }
-                if (!materialized->Type()->IsAnyOf<type::I32, type::U32>()) {
+                if (!materialized->Type()->IsAnyOf<core::type::I32, core::type::U32>()) {
                     AddError("@id must be an i32 or u32 value", attr->source);
                     return false;
                 }
@@ -415,7 +415,7 @@
 }
 
 sem::Variable* Resolver::Const(const ast::Const* c, bool is_global) {
-    const type::Type* ty = nullptr;
+    const core::type::Type* ty = nullptr;
 
     // If the variable has a declared type, resolve it.
     if (c->type) {
@@ -470,8 +470,8 @@
         return nullptr;
     }
 
-    if (!ApplyAddressSpaceUsageToType(core::AddressSpace::kUndefined, const_cast<type::Type*>(ty),
-                                      c->source)) {
+    if (!ApplyAddressSpaceUsageToType(core::AddressSpace::kUndefined,
+                                      const_cast<core::type::Type*>(ty), c->source)) {
         AddNote("while instantiating 'const' " + c->name->symbol.Name(), c->source);
         return nullptr;
     }
@@ -491,7 +491,7 @@
 }
 
 sem::Variable* Resolver::Var(const ast::Var* var, bool is_global) {
-    const type::Type* storage_ty = nullptr;
+    const core::type::Type* storage_ty = nullptr;
 
     // If the variable has a declared type, resolve it.
     if (auto ty = var->type) {
@@ -568,7 +568,7 @@
         return nullptr;
     }
 
-    auto* var_ty = builder_->create<type::Reference>(address_space, storage_ty, access);
+    auto* var_ty = builder_->create<core::type::Reference>(address_space, storage_ty, access);
 
     if (!ApplyAddressSpaceUsageToType(address_space, var_ty,
                                       var->type ? var->type->source : var->source)) {
@@ -782,7 +782,7 @@
         return nullptr;
     }
 
-    type::Type* ty = Type(param->type);
+    core::type::Type* ty = Type(param->type);
     if (!ty) {
         return nullptr;
     }
@@ -792,11 +792,12 @@
         return nullptr;
     }
 
-    if (auto* ptr = ty->As<type::Pointer>()) {
+    if (auto* ptr = ty->As<core::type::Pointer>()) {
         // For MSL, we push module-scope variables into the entry point as pointer
         // parameters, so we also need to handle their store type.
-        if (!ApplyAddressSpaceUsageToType(
-                ptr->AddressSpace(), const_cast<type::Type*>(ptr->StoreType()), param->source)) {
+        if (!ApplyAddressSpaceUsageToType(ptr->AddressSpace(),
+                                          const_cast<core::type::Type*>(ptr->StoreType()),
+                                          param->source)) {
             add_note();
             return nullptr;
         }
@@ -920,7 +921,7 @@
     for (auto* var : transitively_referenced_overrides) {
         builder_->Sem().AddTransitivelyReferencedOverride(sem, var);
     }
-    if (auto* arr = sem->Type()->UnwrapRef()->As<type::Array>()) {
+    if (auto* arr = sem->Type()->UnwrapRef()->As<core::type::Array>()) {
         auto* refs = builder_->Sem().TransitivelyReferencedOverrides(arr);
         if (refs) {
             for (auto* var : *refs) {
@@ -940,7 +941,7 @@
         return nullptr;
     }
     auto* cond = expr->ConstantValue();
-    if (auto* ty = cond->Type(); !ty->Is<type::Bool>()) {
+    if (auto* ty = cond->Type(); !ty->Is<core::type::Bool>()) {
         AddError("const assertion condition must be a bool, got '" + ty->FriendlyName() + "'",
                  assertion->condition->source);
         return nullptr;
@@ -1015,17 +1016,17 @@
 
         func->AddParameter(p);
 
-        auto* p_ty = const_cast<type::Type*>(p->Type());
-        if (auto* str = p_ty->As<type::Struct>()) {
+        auto* p_ty = const_cast<core::type::Type*>(p->Type());
+        if (auto* str = p_ty->As<core::type::Struct>()) {
             switch (decl->PipelineStage()) {
                 case ast::PipelineStage::kVertex:
-                    str->AddUsage(type::PipelineStageUsage::kVertexInput);
+                    str->AddUsage(core::type::PipelineStageUsage::kVertexInput);
                     break;
                 case ast::PipelineStage::kFragment:
-                    str->AddUsage(type::PipelineStageUsage::kFragmentInput);
+                    str->AddUsage(core::type::PipelineStageUsage::kFragmentInput);
                     break;
                 case ast::PipelineStage::kCompute:
-                    str->AddUsage(type::PipelineStageUsage::kComputeInput);
+                    str->AddUsage(core::type::PipelineStageUsage::kComputeInput);
                     break;
                 case ast::PipelineStage::kNone:
                     break;
@@ -1034,14 +1035,14 @@
     }
 
     // Resolve the return type
-    type::Type* return_type = nullptr;
+    core::type::Type* return_type = nullptr;
     if (auto ty = decl->return_type) {
         return_type = Type(ty);
         if (!return_type) {
             return nullptr;
         }
     } else {
-        return_type = builder_->create<type::Void>();
+        return_type = builder_->create<core::type::Void>();
     }
     func->SetReturnType(return_type);
 
@@ -1123,7 +1124,7 @@
         }
     }
 
-    if (auto* str = return_type->As<type::Struct>()) {
+    if (auto* str = return_type->As<core::type::Struct>()) {
         if (!ApplyAddressSpaceUsageToType(core::AddressSpace::kUndefined, str, decl->source)) {
             AddNote("while instantiating return type for " + decl->name->symbol.Name(),
                     decl->source);
@@ -1132,13 +1133,13 @@
 
         switch (decl->PipelineStage()) {
             case ast::PipelineStage::kVertex:
-                str->AddUsage(type::PipelineStageUsage::kVertexOutput);
+                str->AddUsage(core::type::PipelineStageUsage::kVertexOutput);
                 break;
             case ast::PipelineStage::kFragment:
-                str->AddUsage(type::PipelineStageUsage::kFragmentOutput);
+                str->AddUsage(core::type::PipelineStageUsage::kFragmentOutput);
                 break;
             case ast::PipelineStage::kCompute:
-                str->AddUsage(type::PipelineStageUsage::kComputeOutput);
+                str->AddUsage(core::type::PipelineStageUsage::kComputeOutput);
                 break;
             case ast::PipelineStage::kNone:
                 break;
@@ -1259,7 +1260,8 @@
         });
 }
 
-sem::CaseStatement* Resolver::CaseStatement(const ast::CaseStatement* stmt, const type::Type* ty) {
+sem::CaseStatement* Resolver::CaseStatement(const ast::CaseStatement* stmt,
+                                            const core::type::Type* ty) {
     auto* sem =
         builder_->create<sem::CaseStatement>(stmt, current_compound_statement_, current_function_);
     return StatementScope(stmt, sem, [&] {
@@ -1278,7 +1280,7 @@
                 if (!materialized) {
                     return false;
                 }
-                if (!materialized->Type()->IsAnyOf<type::I32, type::U32>()) {
+                if (!materialized->Type()->IsAnyOf<core::type::I32, core::type::U32>()) {
                     AddError("case selector must be an i32 or u32 value", sel->source);
                     return false;
                 }
@@ -1517,11 +1519,11 @@
             [&](const ast::MemberAccessorExpression* member) { return MemberAccessor(member); },
             [&](const ast::UnaryOpExpression* unary) { return UnaryOp(unary); },
             [&](const ast::PhonyExpression*) {
-                return builder_->create<sem::ValueExpression>(expr, builder_->create<type::Void>(),
-                                                              core::EvaluationStage::kRuntime,
-                                                              current_statement_,
-                                                              /* constant_value */ nullptr,
-                                                              /* has_side_effects */ false);
+                return builder_->create<sem::ValueExpression>(
+                    expr, builder_->create<core::type::Void>(), core::EvaluationStage::kRuntime,
+                    current_statement_,
+                    /* constant_value */ nullptr,
+                    /* has_side_effects */ false);
             },
             [&](Default) {
                 StringStream err;
@@ -1589,12 +1591,12 @@
     return sem_.AsFunctionExpression(Expression(expr));
 }
 
-type::Type* Resolver::Type(const ast::Expression* ast) {
+core::type::Type* Resolver::Type(const ast::Expression* ast) {
     auto* type_expr = TypeExpression(ast);
     if (!type_expr) {
         return nullptr;
     }
-    return const_cast<type::Type*>(type_expr->Type());
+    return const_cast<core::type::Type*>(type_expr->Type());
 }
 
 sem::BuiltinEnumExpression<core::AddressSpace>* Resolver::AddressSpaceExpression(
@@ -1688,7 +1690,7 @@
     std::unordered_map<const sem::Variable*, const sem::ValueExpression*> arg_writes;
     for (size_t i = 0; i < args.Length(); i++) {
         auto* arg = args[i];
-        if (!arg->Type()->Is<type::Pointer>()) {
+        if (!arg->Type()->Is<core::type::Pointer>()) {
             continue;
         }
 
@@ -1752,38 +1754,40 @@
     return true;
 }
 
-const type::Type* Resolver::ConcreteType(const type::Type* ty,
-                                         const type::Type* target_ty,
-                                         const Source& source) {
-    auto i32 = [&] { return builder_->create<type::I32>(); };
-    auto f32 = [&] { return builder_->create<type::F32>(); };
-    auto i32v = [&](uint32_t width) { return builder_->create<type::Vector>(i32(), width); };
-    auto f32v = [&](uint32_t width) { return builder_->create<type::Vector>(f32(), width); };
+const core::type::Type* Resolver::ConcreteType(const core::type::Type* ty,
+                                               const core::type::Type* target_ty,
+                                               const Source& source) {
+    auto i32 = [&] { return builder_->create<core::type::I32>(); };
+    auto f32 = [&] { return builder_->create<core::type::F32>(); };
+    auto i32v = [&](uint32_t width) { return builder_->create<core::type::Vector>(i32(), width); };
+    auto f32v = [&](uint32_t width) { return builder_->create<core::type::Vector>(f32(), width); };
     auto f32m = [&](uint32_t columns, uint32_t rows) {
-        return builder_->create<type::Matrix>(f32v(rows), columns);
+        return builder_->create<core::type::Matrix>(f32v(rows), columns);
     };
 
     return Switch(
         ty,  //
-        [&](const type::AbstractInt*) { return target_ty ? target_ty : i32(); },
-        [&](const type::AbstractFloat*) { return target_ty ? target_ty : f32(); },
-        [&](const type::Vector* v) {
+        [&](const core::type::AbstractInt*) { return target_ty ? target_ty : i32(); },
+        [&](const core::type::AbstractFloat*) { return target_ty ? target_ty : f32(); },
+        [&](const core::type::Vector* v) {
             return Switch(
                 v->type(),  //
-                [&](const type::AbstractInt*) { return target_ty ? target_ty : i32v(v->Width()); },
-                [&](const type::AbstractFloat*) {
+                [&](const core::type::AbstractInt*) {
+                    return target_ty ? target_ty : i32v(v->Width());
+                },
+                [&](const core::type::AbstractFloat*) {
                     return target_ty ? target_ty : f32v(v->Width());
                 });
         },
-        [&](const type::Matrix* m) {
+        [&](const core::type::Matrix* m) {
             return Switch(m->type(),  //
-                          [&](const type::AbstractFloat*) {
+                          [&](const core::type::AbstractFloat*) {
                               return target_ty ? target_ty : f32m(m->columns(), m->rows());
                           });
         },
-        [&](const type::Array* a) -> const type::Type* {
-            const type::Type* target_el_ty = nullptr;
-            if (auto* target_arr_ty = As<type::Array>(target_ty)) {
+        [&](const core::type::Array* a) -> const core::type::Type* {
+            const core::type::Type* target_el_ty = nullptr;
+            if (auto* target_arr_ty = As<core::type::Array>(target_ty)) {
                 target_el_ty = target_arr_ty->ElemType();
             }
             if (auto* el_ty = ConcreteType(a->ElemType(), target_el_ty, source)) {
@@ -1791,7 +1795,7 @@
             }
             return nullptr;
         },
-        [&](const type::Struct* s) -> const type::Type* {
+        [&](const core::type::Struct* s) -> const core::type::Type* {
             if (auto tys = s->ConcreteTypes(); !tys.IsEmpty()) {
                 return target_ty ? target_ty : tys[0];
             }
@@ -1805,7 +1809,7 @@
         return nullptr;
     }
 
-    if (!expr->Type()->Is<type::Reference>()) {
+    if (!expr->Type()->Is<core::type::Reference>()) {
         // Expression is not a reference type, so cannot be loaded. Just return expr.
         return expr;
     }
@@ -1826,8 +1830,9 @@
     return load;
 }
 
-const sem::ValueExpression* Resolver::Materialize(const sem::ValueExpression* expr,
-                                                  const type::Type* target_type /* = nullptr */) {
+const sem::ValueExpression* Resolver::Materialize(
+    const sem::ValueExpression* expr,
+    const core::type::Type* target_type /* = nullptr */) {
     if (!expr) {
         // Allow for Materialize(ValueExpression(blah)), where failures pass through Materialize()
         return nullptr;
@@ -1890,7 +1895,7 @@
             }
             args[i] = materialized;
         }
-        if (!param_ty->Is<type::Reference>()) {
+        if (!param_ty->Is<core::type::Reference>()) {
             auto* load = Load(args[i]);
             if (!load) {
                 return false;
@@ -1901,13 +1906,13 @@
     return true;
 }
 
-bool Resolver::ShouldMaterializeArgument(const type::Type* parameter_ty) const {
+bool Resolver::ShouldMaterializeArgument(const core::type::Type* parameter_ty) const {
     const auto* param_el_ty = parameter_ty->DeepestElement();
-    return param_el_ty && !param_el_ty->Is<type::AbstractNumeric>();
+    return param_el_ty && !param_el_ty->Is<core::type::AbstractNumeric>();
 }
 
 bool Resolver::Convert(const core::constant::Value*& c,
-                       const type::Type* target_ty,
+                       const core::type::Type* target_ty,
                        const Source& source) {
     auto r = const_eval_.Convert(target_ty, c, source);
     if (!r) {
@@ -1950,10 +1955,10 @@
     auto* obj_ty = obj_raw_ty->UnwrapRef();
     auto* ty = Switch(
         obj_ty,  //
-        [&](const type::Array* arr) { return arr->ElemType(); },
-        [&](const type::Vector* vec) { return vec->type(); },
-        [&](const type::Matrix* mat) {
-            return builder_->create<type::Vector>(mat->type(), mat->rows());
+        [&](const core::type::Array* arr) { return arr->ElemType(); },
+        [&](const core::type::Vector* vec) { return vec->type(); },
+        [&](const core::type::Matrix* mat) {
+            return builder_->create<core::type::Vector>(mat->type(), mat->rows());
         },
         [&](Default) {
             AddError("cannot index type '" + sem_.TypeNameOf(obj_ty) + "'", expr->source);
@@ -1964,15 +1969,15 @@
     }
 
     auto* idx_ty = idx->Type()->UnwrapRef();
-    if (!idx_ty->IsAnyOf<type::I32, type::U32>()) {
+    if (!idx_ty->IsAnyOf<core::type::I32, core::type::U32>()) {
         AddError("index must be of type 'i32' or 'u32', found: '" + sem_.TypeNameOf(idx_ty) + "'",
                  idx->Declaration()->source);
         return nullptr;
     }
 
     // If we're extracting from a reference, we return a reference.
-    if (auto* ref = obj_raw_ty->As<type::Reference>()) {
-        ty = builder_->create<type::Reference>(ref->AddressSpace(), ty, ref->Access());
+    if (auto* ref = obj_raw_ty->As<core::type::Reference>()) {
+        ty = builder_->create<core::type::Reference>(ref->AddressSpace(), ty, ref->Access());
     }
 
     const core::constant::Value* val = nullptr;
@@ -2064,7 +2069,8 @@
 
     // ctor_or_conv is a helper for building either a sem::ValueConstructor or
     // sem::ValueConversion call for a CtorConvIntrinsic with an optional template argument type.
-    auto ctor_or_conv = [&](CtorConvIntrinsic ty, const type::Type* template_arg) -> sem::Call* {
+    auto ctor_or_conv = [&](CtorConvIntrinsic ty,
+                            const core::type::Type* template_arg) -> sem::Call* {
         auto arg_tys = tint::Transform(args, [](auto* arg) { return arg->Type(); });
         auto match = intrinsic_table_->Lookup(ty, template_arg, arg_tys, args_stage, expr->source);
         if (!match) {
@@ -2127,7 +2133,7 @@
 
     // arr_or_str_init is a helper for building a sem::ValueConstructor for an array or structure
     // constructor call target.
-    auto arr_or_str_init = [&](const type::Type* ty,
+    auto arr_or_str_init = [&](const core::type::Type* ty,
                                const sem::CallTarget* call_target) -> sem::Call* {
         if (!MaybeMaterializeAndLoadArguments(args, call_target)) {
             return nullptr;
@@ -2159,30 +2165,32 @@
                                            current_statement_, value, has_side_effects);
     };
 
-    auto ty_init_or_conv = [&](const type::Type* type) {
+    auto ty_init_or_conv = [&](const core::type::Type* type) {
         return Switch(
             type,  //
-            [&](const type::I32*) { return ctor_or_conv(CtorConvIntrinsic::kI32, nullptr); },
-            [&](const type::U32*) { return ctor_or_conv(CtorConvIntrinsic::kU32, nullptr); },
-            [&](const type::F16*) {
+            [&](const core::type::I32*) { return ctor_or_conv(CtorConvIntrinsic::kI32, nullptr); },
+            [&](const core::type::U32*) { return ctor_or_conv(CtorConvIntrinsic::kU32, nullptr); },
+            [&](const core::type::F16*) {
                 return validator_.CheckF16Enabled(expr->source)
                            ? ctor_or_conv(CtorConvIntrinsic::kF16, nullptr)
                            : nullptr;
             },
-            [&](const type::F32*) { return ctor_or_conv(CtorConvIntrinsic::kF32, nullptr); },
-            [&](const type::Bool*) { return ctor_or_conv(CtorConvIntrinsic::kBool, nullptr); },
-            [&](const type::Vector* v) {
+            [&](const core::type::F32*) { return ctor_or_conv(CtorConvIntrinsic::kF32, nullptr); },
+            [&](const core::type::Bool*) {
+                return ctor_or_conv(CtorConvIntrinsic::kBool, nullptr);
+            },
+            [&](const core::type::Vector* v) {
                 if (v->Packed()) {
                     TINT_ASSERT(v->Width() == 3u);
                     return ctor_or_conv(CtorConvIntrinsic::kPackedVec3, v->type());
                 }
                 return ctor_or_conv(core::intrinsic::VectorCtorConv(v->Width()), v->type());
             },
-            [&](const type::Matrix* m) {
+            [&](const core::type::Matrix* m) {
                 return ctor_or_conv(core::intrinsic::MatrixCtorConv(m->columns(), m->rows()),
                                     m->type());
             },
-            [&](const type::Array* arr) -> sem::Call* {
+            [&](const core::type::Array* arr) -> sem::Call* {
                 auto* call_target = array_ctors_.GetOrCreate(
                     ArrayConstructorSig{{arr, args.Length(), args_stage}},
                     [&]() -> sem::ValueConstructor* {
@@ -2209,7 +2217,7 @@
                 }
                 return call;
             },
-            [&](const type::Struct* str) -> sem::Call* {
+            [&](const core::type::Struct* str) -> sem::Call* {
                 auto* call_target = struct_ctors_.GetOrCreate(
                     StructConstructorSig{{str, args.Length(), args_stage}},
                     [&]() -> sem::ValueConstructor* {
@@ -2246,13 +2254,13 @@
 
     auto inferred_array = [&]() -> tint::sem::Call* {
         auto el_count =
-            builder_->create<type::ConstantArrayCount>(static_cast<uint32_t>(args.Length()));
+            builder_->create<core::type::ConstantArrayCount>(static_cast<uint32_t>(args.Length()));
         auto arg_tys = tint::Transform(args, [](auto* arg) { return arg->Type()->UnwrapRef(); });
-        auto el_ty = type::Type::Common(arg_tys);
+        auto el_ty = core::type::Type::Common(arg_tys);
         if (!el_ty) {
             AddError("cannot infer common array element type from constructor arguments",
                      expr->source);
-            Hashset<const type::Type*, 8> types;
+            Hashset<const core::type::Type*, 8> types;
             for (size_t i = 0; i < args.Length(); i++) {
                 if (types.Add(args[i]->Type())) {
                     AddNote("argument " + std::to_string(i) + " is of type '" +
@@ -2282,7 +2290,7 @@
         if (auto* ast_node = resolved->Node()) {
             return Switch(
                 sem_.Get(ast_node),  //
-                [&](type::Type* t) -> tint::sem::Call* {
+                [&](core::type::Type* t) -> tint::sem::Call* {
                     // User declared types cannot be templated.
                     if (!TINT_LIKELY(CheckNotTemplated("type", ident))) {
                         return nullptr;
@@ -2490,18 +2498,18 @@
     return call;
 }
 
-type::Type* Resolver::BuiltinType(core::Builtin builtin_ty, const ast::Identifier* ident) {
+core::type::Type* Resolver::BuiltinType(core::Builtin builtin_ty, const ast::Identifier* ident) {
     auto& b = *builder_;
 
-    auto check_no_tmpl_args = [&](type::Type* ty) -> type::Type* {
+    auto check_no_tmpl_args = [&](core::type::Type* ty) -> core::type::Type* {
         return TINT_LIKELY(CheckNotTemplated("type", ident)) ? ty : nullptr;
     };
-    auto af = [&] { return b.create<type::AbstractFloat>(); };
-    auto f32 = [&] { return b.create<type::F32>(); };
-    auto i32 = [&] { return b.create<type::I32>(); };
-    auto u32 = [&] { return b.create<type::U32>(); };
+    auto af = [&] { return b.create<core::type::AbstractFloat>(); };
+    auto f32 = [&] { return b.create<core::type::F32>(); };
+    auto i32 = [&] { return b.create<core::type::I32>(); };
+    auto u32 = [&] { return b.create<core::type::U32>(); };
     auto f16 = [&] {
-        return validator_.CheckF16Enabled(ident->source) ? b.create<type::F16>() : nullptr;
+        return validator_.CheckF16Enabled(ident->source) ? b.create<core::type::F16>() : nullptr;
     };
     auto templated_identifier =
         [&](size_t min_args, size_t max_args = /* use min */ 0) -> const ast::TemplatedIdentifier* {
@@ -2539,16 +2547,17 @@
         }
         return tmpl_ident;
     };
-    auto vec = [&](type::Type* el, uint32_t n) -> type::Vector* {
+    auto vec = [&](core::type::Type* el, uint32_t n) -> core::type::Vector* {
         if (TINT_UNLIKELY(!el)) {
             return nullptr;
         }
         if (TINT_UNLIKELY(!validator_.Vector(el, ident->source))) {
             return nullptr;
         }
-        return b.create<type::Vector>(el, n);
+        return b.create<core::type::Vector>(el, n);
     };
-    auto mat = [&](type::Type* el, uint32_t num_columns, uint32_t num_rows) -> type::Matrix* {
+    auto mat = [&](core::type::Type* el, uint32_t num_columns,
+                   uint32_t num_rows) -> core::type::Matrix* {
         if (TINT_UNLIKELY(!el)) {
             return nullptr;
         }
@@ -2559,9 +2568,9 @@
         if (!column) {
             return nullptr;
         }
-        return b.create<type::Matrix>(column, num_columns);
+        return b.create<core::type::Matrix>(column, num_columns);
     };
-    auto vec_t = [&](uint32_t n) -> type::Vector* {
+    auto vec_t = [&](uint32_t n) -> core::type::Vector* {
         auto* tmpl_ident = templated_identifier(1);
         if (TINT_UNLIKELY(!tmpl_ident)) {
             return nullptr;
@@ -2570,9 +2579,9 @@
         if (TINT_UNLIKELY(!ty)) {
             return nullptr;
         }
-        return vec(const_cast<type::Type*>(ty), n);
+        return vec(const_cast<core::type::Type*>(ty), n);
     };
-    auto mat_t = [&](uint32_t num_columns, uint32_t num_rows) -> type::Matrix* {
+    auto mat_t = [&](uint32_t num_columns, uint32_t num_rows) -> core::type::Matrix* {
         auto* tmpl_ident = templated_identifier(1);
         if (TINT_UNLIKELY(!tmpl_ident)) {
             return nullptr;
@@ -2581,9 +2590,9 @@
         if (TINT_UNLIKELY(!ty)) {
             return nullptr;
         }
-        return mat(const_cast<type::Type*>(ty), num_columns, num_rows);
+        return mat(const_cast<core::type::Type*>(ty), num_columns, num_rows);
     };
-    auto array = [&]() -> type::Array* {
+    auto array = [&]() -> core::type::Array* {
         UniqueVector<const sem::GlobalVariable*, 4> transitively_referenced_overrides;
         TINT_SCOPED_ASSIGNMENT(resolved_overrides_, &transitively_referenced_overrides);
 
@@ -2599,8 +2608,8 @@
             return nullptr;
         }
 
-        const type::ArrayCount* el_count =
-            ast_count ? ArrayCount(ast_count) : builder_->create<type::RuntimeArrayCount>();
+        const core::type::ArrayCount* el_count =
+            ast_count ? ArrayCount(ast_count) : builder_->create<core::type::RuntimeArrayCount>();
         if (!el_count) {
             return nullptr;
         }
@@ -2619,7 +2628,7 @@
             return nullptr;
         }
 
-        if (el_ty->Is<type::Atomic>()) {
+        if (el_ty->Is<core::type::Atomic>()) {
             atomic_composite_info_.Add(out, &ast_el_ty->source);
         } else {
             if (auto found = atomic_composite_info_.Get(el_ty)) {
@@ -2634,7 +2643,7 @@
         }
         return out;
     };
-    auto atomic = [&]() -> type::Atomic* {
+    auto atomic = [&]() -> core::type::Atomic* {
         auto* tmpl_ident = templated_identifier(1);  // atomic<type>
         if (TINT_UNLIKELY(!tmpl_ident)) {
             return nullptr;
@@ -2646,13 +2655,13 @@
         }
         auto* ty = ty_expr->Type();
 
-        auto* out = builder_->create<type::Atomic>(ty);
+        auto* out = builder_->create<core::type::Atomic>(ty);
         if (!validator_.Atomic(tmpl_ident, out)) {
             return nullptr;
         }
         return out;
     };
-    auto ptr = [&]() -> type::Pointer* {
+    auto ptr = [&]() -> core::type::Pointer* {
         auto* tmpl_ident = templated_identifier(2, 3);  // ptr<address, type [, access]>
         if (TINT_UNLIKELY(!tmpl_ident)) {
             return nullptr;
@@ -2668,7 +2677,7 @@
         if (TINT_UNLIKELY(!store_ty_expr)) {
             return nullptr;
         }
-        auto* store_ty = const_cast<type::Type*>(store_ty_expr->Type());
+        auto* store_ty = const_cast<core::type::Type*>(store_ty_expr->Type());
 
         auto access = DefaultAccessForAddressSpace(address_space);
         if (tmpl_ident->arguments.Length() > 2) {
@@ -2679,7 +2688,7 @@
             access = access_expr->Value();
         }
 
-        auto* out = b.create<type::Pointer>(address_space, store_ty, access);
+        auto* out = b.create<core::type::Pointer>(address_space, store_ty, access);
         if (!validator_.Pointer(tmpl_ident, out)) {
             return nullptr;
         }
@@ -2690,7 +2699,7 @@
         }
         return out;
     };
-    auto sampled_texture = [&](type::TextureDimension dim) -> type::SampledTexture* {
+    auto sampled_texture = [&](core::type::TextureDimension dim) -> core::type::SampledTexture* {
         auto* tmpl_ident = templated_identifier(1);
         if (TINT_UNLIKELY(!tmpl_ident)) {
             return nullptr;
@@ -2700,10 +2709,11 @@
         if (TINT_UNLIKELY(!ty_expr)) {
             return nullptr;
         }
-        auto* out = b.create<type::SampledTexture>(dim, ty_expr->Type());
+        auto* out = b.create<core::type::SampledTexture>(dim, ty_expr->Type());
         return validator_.SampledTexture(out, ident->source) ? out : nullptr;
     };
-    auto multisampled_texture = [&](type::TextureDimension dim) -> type::MultisampledTexture* {
+    auto multisampled_texture =
+        [&](core::type::TextureDimension dim) -> core::type::MultisampledTexture* {
         auto* tmpl_ident = templated_identifier(1);
         if (TINT_UNLIKELY(!tmpl_ident)) {
             return nullptr;
@@ -2713,10 +2723,10 @@
         if (TINT_UNLIKELY(!ty_expr)) {
             return nullptr;
         }
-        auto* out = b.create<type::MultisampledTexture>(dim, ty_expr->Type());
+        auto* out = b.create<core::type::MultisampledTexture>(dim, ty_expr->Type());
         return validator_.MultisampledTexture(out, ident->source) ? out : nullptr;
     };
-    auto storage_texture = [&](type::TextureDimension dim) -> type::StorageTexture* {
+    auto storage_texture = [&](core::type::TextureDimension dim) -> core::type::StorageTexture* {
         auto* tmpl_ident = templated_identifier(2);
         if (TINT_UNLIKELY(!tmpl_ident)) {
             return nullptr;
@@ -2730,14 +2740,15 @@
         if (TINT_UNLIKELY(!access)) {
             return nullptr;
         }
-        auto* subtype = type::StorageTexture::SubtypeFor(format->Value(), builder_->Types());
-        auto* tex = b.create<type::StorageTexture>(dim, format->Value(), access->Value(), subtype);
+        auto* subtype = core::type::StorageTexture::SubtypeFor(format->Value(), builder_->Types());
+        auto* tex =
+            b.create<core::type::StorageTexture>(dim, format->Value(), access->Value(), subtype);
         if (!validator_.StorageTexture(tex, ident->source)) {
             return nullptr;
         }
         return tex;
     };
-    auto packed_vec3_t = [&]() -> type::Vector* {
+    auto packed_vec3_t = [&]() -> core::type::Vector* {
         auto* tmpl_ident = templated_identifier(1);
         if (TINT_UNLIKELY(!tmpl_ident)) {
             return nullptr;
@@ -2750,12 +2761,12 @@
         if (TINT_UNLIKELY(!validator_.Vector(el_ty, ident->source))) {
             return nullptr;
         }
-        return b.create<type::Vector>(el_ty, 3u, true);
+        return b.create<core::type::Vector>(el_ty, 3u, true);
     };
 
     switch (builtin_ty) {
         case core::Builtin::kBool:
-            return check_no_tmpl_args(b.create<type::Bool>());
+            return check_no_tmpl_args(b.create<core::type::Bool>());
         case core::Builtin::kI32:
             return check_no_tmpl_args(i32());
         case core::Builtin::kU32:
@@ -2763,7 +2774,7 @@
         case core::Builtin::kF16:
             return check_no_tmpl_args(f16());
         case core::Builtin::kF32:
-            return check_no_tmpl_args(b.create<type::F32>());
+            return check_no_tmpl_args(b.create<core::type::F32>());
         case core::Builtin::kVec2:
             return vec_t(2);
         case core::Builtin::kVec3:
@@ -2855,105 +2866,124 @@
         case core::Builtin::kPtr:
             return ptr();
         case core::Builtin::kSampler:
-            return check_no_tmpl_args(builder_->create<type::Sampler>(type::SamplerKind::kSampler));
+            return check_no_tmpl_args(
+                builder_->create<core::type::Sampler>(core::type::SamplerKind::kSampler));
         case core::Builtin::kSamplerComparison:
             return check_no_tmpl_args(
-                builder_->create<type::Sampler>(type::SamplerKind::kComparisonSampler));
+                builder_->create<core::type::Sampler>(core::type::SamplerKind::kComparisonSampler));
         case core::Builtin::kTexture1D:
-            return sampled_texture(type::TextureDimension::k1d);
+            return sampled_texture(core::type::TextureDimension::k1d);
         case core::Builtin::kTexture2D:
-            return sampled_texture(type::TextureDimension::k2d);
+            return sampled_texture(core::type::TextureDimension::k2d);
         case core::Builtin::kTexture2DArray:
-            return sampled_texture(type::TextureDimension::k2dArray);
+            return sampled_texture(core::type::TextureDimension::k2dArray);
         case core::Builtin::kTexture3D:
-            return sampled_texture(type::TextureDimension::k3d);
+            return sampled_texture(core::type::TextureDimension::k3d);
         case core::Builtin::kTextureCube:
-            return sampled_texture(type::TextureDimension::kCube);
+            return sampled_texture(core::type::TextureDimension::kCube);
         case core::Builtin::kTextureCubeArray:
-            return sampled_texture(type::TextureDimension::kCubeArray);
+            return sampled_texture(core::type::TextureDimension::kCubeArray);
         case core::Builtin::kTextureDepth2D:
             return check_no_tmpl_args(
-                builder_->create<type::DepthTexture>(type::TextureDimension::k2d));
+                builder_->create<core::type::DepthTexture>(core::type::TextureDimension::k2d));
         case core::Builtin::kTextureDepth2DArray:
             return check_no_tmpl_args(
-                builder_->create<type::DepthTexture>(type::TextureDimension::k2dArray));
+                builder_->create<core::type::DepthTexture>(core::type::TextureDimension::k2dArray));
         case core::Builtin::kTextureDepthCube:
             return check_no_tmpl_args(
-                builder_->create<type::DepthTexture>(type::TextureDimension::kCube));
+                builder_->create<core::type::DepthTexture>(core::type::TextureDimension::kCube));
         case core::Builtin::kTextureDepthCubeArray:
-            return check_no_tmpl_args(
-                builder_->create<type::DepthTexture>(type::TextureDimension::kCubeArray));
+            return check_no_tmpl_args(builder_->create<core::type::DepthTexture>(
+                core::type::TextureDimension::kCubeArray));
         case core::Builtin::kTextureDepthMultisampled2D:
-            return check_no_tmpl_args(
-                builder_->create<type::DepthMultisampledTexture>(type::TextureDimension::k2d));
+            return check_no_tmpl_args(builder_->create<core::type::DepthMultisampledTexture>(
+                core::type::TextureDimension::k2d));
         case core::Builtin::kTextureExternal:
-            return check_no_tmpl_args(builder_->create<type::ExternalTexture>());
+            return check_no_tmpl_args(builder_->create<core::type::ExternalTexture>());
         case core::Builtin::kTextureMultisampled2D:
-            return multisampled_texture(type::TextureDimension::k2d);
+            return multisampled_texture(core::type::TextureDimension::k2d);
         case core::Builtin::kTextureStorage1D:
-            return storage_texture(type::TextureDimension::k1d);
+            return storage_texture(core::type::TextureDimension::k1d);
         case core::Builtin::kTextureStorage2D:
-            return storage_texture(type::TextureDimension::k2d);
+            return storage_texture(core::type::TextureDimension::k2d);
         case core::Builtin::kTextureStorage2DArray:
-            return storage_texture(type::TextureDimension::k2dArray);
+            return storage_texture(core::type::TextureDimension::k2dArray);
         case core::Builtin::kTextureStorage3D:
-            return storage_texture(type::TextureDimension::k3d);
+            return storage_texture(core::type::TextureDimension::k3d);
         case core::Builtin::kPackedVec3:
             return packed_vec3_t();
         case core::Builtin::kAtomicCompareExchangeResultI32:
-            return type::CreateAtomicCompareExchangeResult(builder_->Types(), builder_->Symbols(),
-                                                           i32());
+            return core::type::CreateAtomicCompareExchangeResult(builder_->Types(),
+                                                                 builder_->Symbols(), i32());
         case core::Builtin::kAtomicCompareExchangeResultU32:
-            return type::CreateAtomicCompareExchangeResult(builder_->Types(), builder_->Symbols(),
-                                                           u32());
+            return core::type::CreateAtomicCompareExchangeResult(builder_->Types(),
+                                                                 builder_->Symbols(), u32());
         case core::Builtin::kFrexpResultAbstract:
-            return type::CreateFrexpResult(builder_->Types(), builder_->Symbols(), af());
+            return core::type::CreateFrexpResult(builder_->Types(), builder_->Symbols(), af());
         case core::Builtin::kFrexpResultF16:
-            return type::CreateFrexpResult(builder_->Types(), builder_->Symbols(), f16());
+            return core::type::CreateFrexpResult(builder_->Types(), builder_->Symbols(), f16());
         case core::Builtin::kFrexpResultF32:
-            return type::CreateFrexpResult(builder_->Types(), builder_->Symbols(), f32());
+            return core::type::CreateFrexpResult(builder_->Types(), builder_->Symbols(), f32());
         case core::Builtin::kFrexpResultVec2Abstract:
-            return type::CreateFrexpResult(builder_->Types(), builder_->Symbols(), vec(af(), 2));
+            return core::type::CreateFrexpResult(builder_->Types(), builder_->Symbols(),
+                                                 vec(af(), 2));
         case core::Builtin::kFrexpResultVec2F16:
-            return type::CreateFrexpResult(builder_->Types(), builder_->Symbols(), vec(f16(), 2));
+            return core::type::CreateFrexpResult(builder_->Types(), builder_->Symbols(),
+                                                 vec(f16(), 2));
         case core::Builtin::kFrexpResultVec2F32:
-            return type::CreateFrexpResult(builder_->Types(), builder_->Symbols(), vec(f32(), 2));
+            return core::type::CreateFrexpResult(builder_->Types(), builder_->Symbols(),
+                                                 vec(f32(), 2));
         case core::Builtin::kFrexpResultVec3Abstract:
-            return type::CreateFrexpResult(builder_->Types(), builder_->Symbols(), vec(af(), 3));
+            return core::type::CreateFrexpResult(builder_->Types(), builder_->Symbols(),
+                                                 vec(af(), 3));
         case core::Builtin::kFrexpResultVec3F16:
-            return type::CreateFrexpResult(builder_->Types(), builder_->Symbols(), vec(f16(), 3));
+            return core::type::CreateFrexpResult(builder_->Types(), builder_->Symbols(),
+                                                 vec(f16(), 3));
         case core::Builtin::kFrexpResultVec3F32:
-            return type::CreateFrexpResult(builder_->Types(), builder_->Symbols(), vec(f32(), 3));
+            return core::type::CreateFrexpResult(builder_->Types(), builder_->Symbols(),
+                                                 vec(f32(), 3));
         case core::Builtin::kFrexpResultVec4Abstract:
-            return type::CreateFrexpResult(builder_->Types(), builder_->Symbols(), vec(af(), 4));
+            return core::type::CreateFrexpResult(builder_->Types(), builder_->Symbols(),
+                                                 vec(af(), 4));
         case core::Builtin::kFrexpResultVec4F16:
-            return type::CreateFrexpResult(builder_->Types(), builder_->Symbols(), vec(f16(), 4));
+            return core::type::CreateFrexpResult(builder_->Types(), builder_->Symbols(),
+                                                 vec(f16(), 4));
         case core::Builtin::kFrexpResultVec4F32:
-            return type::CreateFrexpResult(builder_->Types(), builder_->Symbols(), vec(f32(), 4));
+            return core::type::CreateFrexpResult(builder_->Types(), builder_->Symbols(),
+                                                 vec(f32(), 4));
         case core::Builtin::kModfResultAbstract:
-            return type::CreateModfResult(builder_->Types(), builder_->Symbols(), af());
+            return core::type::CreateModfResult(builder_->Types(), builder_->Symbols(), af());
         case core::Builtin::kModfResultF16:
-            return type::CreateModfResult(builder_->Types(), builder_->Symbols(), f16());
+            return core::type::CreateModfResult(builder_->Types(), builder_->Symbols(), f16());
         case core::Builtin::kModfResultF32:
-            return type::CreateModfResult(builder_->Types(), builder_->Symbols(), f32());
+            return core::type::CreateModfResult(builder_->Types(), builder_->Symbols(), f32());
         case core::Builtin::kModfResultVec2Abstract:
-            return type::CreateModfResult(builder_->Types(), builder_->Symbols(), vec(af(), 2));
+            return core::type::CreateModfResult(builder_->Types(), builder_->Symbols(),
+                                                vec(af(), 2));
         case core::Builtin::kModfResultVec2F16:
-            return type::CreateModfResult(builder_->Types(), builder_->Symbols(), vec(f16(), 2));
+            return core::type::CreateModfResult(builder_->Types(), builder_->Symbols(),
+                                                vec(f16(), 2));
         case core::Builtin::kModfResultVec2F32:
-            return type::CreateModfResult(builder_->Types(), builder_->Symbols(), vec(f32(), 2));
+            return core::type::CreateModfResult(builder_->Types(), builder_->Symbols(),
+                                                vec(f32(), 2));
         case core::Builtin::kModfResultVec3Abstract:
-            return type::CreateModfResult(builder_->Types(), builder_->Symbols(), vec(af(), 3));
+            return core::type::CreateModfResult(builder_->Types(), builder_->Symbols(),
+                                                vec(af(), 3));
         case core::Builtin::kModfResultVec3F16:
-            return type::CreateModfResult(builder_->Types(), builder_->Symbols(), vec(f16(), 3));
+            return core::type::CreateModfResult(builder_->Types(), builder_->Symbols(),
+                                                vec(f16(), 3));
         case core::Builtin::kModfResultVec3F32:
-            return type::CreateModfResult(builder_->Types(), builder_->Symbols(), vec(f32(), 3));
+            return core::type::CreateModfResult(builder_->Types(), builder_->Symbols(),
+                                                vec(f32(), 3));
         case core::Builtin::kModfResultVec4Abstract:
-            return type::CreateModfResult(builder_->Types(), builder_->Symbols(), vec(af(), 4));
+            return core::type::CreateModfResult(builder_->Types(), builder_->Symbols(),
+                                                vec(af(), 4));
         case core::Builtin::kModfResultVec4F16:
-            return type::CreateModfResult(builder_->Types(), builder_->Symbols(), vec(f16(), 4));
+            return core::type::CreateModfResult(builder_->Types(), builder_->Symbols(),
+                                                vec(f16(), 4));
         case core::Builtin::kModfResultVec4F32:
-            return type::CreateModfResult(builder_->Types(), builder_->Symbols(), vec(f32(), 4));
+            return core::type::CreateModfResult(builder_->Types(), builder_->Symbols(),
+                                                vec(f32(), 4));
         case core::Builtin::kUndefined:
             break;
     }
@@ -2965,11 +2995,11 @@
     return nullptr;
 }
 
-size_t Resolver::NestDepth(const type::Type* ty) const {
+size_t Resolver::NestDepth(const core::type::Type* ty) const {
     return Switch(
         ty,  //
-        [](const type::Vector*) { return size_t{1}; },
-        [](const type::Matrix*) { return size_t{2}; },
+        [](const core::type::Vector*) { return size_t{1}; },
+        [](const core::type::Matrix*) { return size_t{2}; },
         [&](Default) {
             if (auto d = nest_depth_.Get(ty)) {
                 return *d;
@@ -2992,7 +3022,7 @@
     if (auto* user =
             args[static_cast<size_t>(texture_index)]->UnwrapLoad()->As<sem::VariableUser>()) {
         auto* texture = user->Variable();
-        if (!texture->Type()->UnwrapRef()->Is<type::StorageTexture>()) {
+        if (!texture->Type()->UnwrapRef()->Is<core::type::StorageTexture>()) {
             int sampler_index = signature.IndexOf(core::ParameterUsage::kSampler);
             const sem::Variable* sampler = sampler_index != -1
                                                ? args[static_cast<size_t>(sampler_index)]
@@ -3086,33 +3116,33 @@
 sem::ValueExpression* Resolver::Literal(const ast::LiteralExpression* literal) {
     auto* ty = Switch(
         literal,
-        [&](const ast::IntLiteralExpression* i) -> type::Type* {
+        [&](const ast::IntLiteralExpression* i) -> core::type::Type* {
             switch (i->suffix) {
                 case ast::IntLiteralExpression::Suffix::kNone:
-                    return builder_->create<type::AbstractInt>();
+                    return builder_->create<core::type::AbstractInt>();
                 case ast::IntLiteralExpression::Suffix::kI:
-                    return builder_->create<type::I32>();
+                    return builder_->create<core::type::I32>();
                 case ast::IntLiteralExpression::Suffix::kU:
-                    return builder_->create<type::U32>();
+                    return builder_->create<core::type::U32>();
             }
             TINT_UNREACHABLE() << "Unhandled integer literal suffix: " << i->suffix;
             return nullptr;
         },
-        [&](const ast::FloatLiteralExpression* f) -> type::Type* {
+        [&](const ast::FloatLiteralExpression* f) -> core::type::Type* {
             switch (f->suffix) {
                 case ast::FloatLiteralExpression::Suffix::kNone:
-                    return builder_->create<type::AbstractFloat>();
+                    return builder_->create<core::type::AbstractFloat>();
                 case ast::FloatLiteralExpression::Suffix::kF:
-                    return builder_->create<type::F32>();
+                    return builder_->create<core::type::F32>();
                 case ast::FloatLiteralExpression::Suffix::kH:
                     return validator_.CheckF16Enabled(literal->source)
-                               ? builder_->create<type::F16>()
+                               ? builder_->create<core::type::F16>()
                                : nullptr;
             }
             TINT_UNREACHABLE() << "Unhandled float literal suffix: " << f->suffix;
             return nullptr;
         },
-        [&](const ast::BoolLiteralExpression*) { return builder_->create<type::Bool>(); },
+        [&](const ast::BoolLiteralExpression*) { return builder_->create<core::type::Bool>(); },
         [&](Default) {
             TINT_UNREACHABLE() << "Unhandled literal type: " << literal->TypeInfo().name;
             return nullptr;
@@ -3260,7 +3290,7 @@
                 variable->AddUser(user);
                 return user;
             },
-            [&](const type::Type* ty) -> sem::TypeExpression* {
+            [&](const core::type::Type* ty) -> sem::TypeExpression* {
                 // User declared types cannot be templated.
                 if (!TINT_LIKELY(CheckNotTemplated("type", ident))) {
                     return nullptr;
@@ -3371,7 +3401,7 @@
 
     auto* root_ident = object->RootIdentifier();
 
-    const type::Type* ty = nullptr;
+    const core::type::Type* ty = nullptr;
 
     // Object may be a side-effecting expression (e.g. function call).
     bool has_side_effects = object->HasSideEffects();
@@ -3380,10 +3410,10 @@
 
     return Switch(
         storage_ty,  //
-        [&](const type::Struct* str) -> sem::ValueExpression* {
+        [&](const core::type::Struct* str) -> sem::ValueExpression* {
             auto symbol = expr->member->symbol;
 
-            const type::StructMember* member = nullptr;
+            const core::type::StructMember* member = nullptr;
             for (auto* m : str->Members()) {
                 if (m->Name() == symbol) {
                     member = m;
@@ -3399,8 +3429,9 @@
             ty = member->Type();
 
             // If we're extracting from a reference, we return a reference.
-            if (auto* ref = object_ty->As<type::Reference>()) {
-                ty = builder_->create<type::Reference>(ref->AddressSpace(), ty, ref->Access());
+            if (auto* ref = object_ty->As<core::type::Reference>()) {
+                ty =
+                    builder_->create<core::type::Reference>(ref->AddressSpace(), ty, ref->Access());
             }
 
             const core::constant::Value* val = nullptr;
@@ -3411,7 +3442,7 @@
                 expr, ty, current_statement_, val, object, member, has_side_effects, root_ident);
         },
 
-        [&](const type::Vector* vec) -> sem::ValueExpression* {
+        [&](const core::type::Vector* vec) -> sem::ValueExpression* {
             std::string s = expr->member->symbol.Name();
             auto size = s.size();
             Vector<uint32_t, 4> swizzle;
@@ -3467,13 +3498,14 @@
                 // A single element swizzle is just the type of the vector.
                 ty = vec->type();
                 // If we're extracting from a reference, we return a reference.
-                if (auto* ref = object_ty->As<type::Reference>()) {
-                    ty = builder_->create<type::Reference>(ref->AddressSpace(), ty, ref->Access());
+                if (auto* ref = object_ty->As<core::type::Reference>()) {
+                    ty = builder_->create<core::type::Reference>(ref->AddressSpace(), ty,
+                                                                 ref->Access());
                 }
             } else {
                 // The vector will have a number of components equal to the length of
                 // the swizzle.
-                ty = builder_->create<type::Vector>(vec->type(), static_cast<uint32_t>(size));
+                ty = builder_->create<core::type::Vector>(vec->type(), static_cast<uint32_t>(size));
 
                 // The load rule is invoked before the swizzle, if necessary.
                 obj_expr = Load(object);
@@ -3591,14 +3623,14 @@
     }
     auto* expr_ty = expr->Type();
 
-    const type::Type* ty = nullptr;
+    const core::type::Type* ty = nullptr;
     const sem::Variable* root_ident = nullptr;
     const core::constant::Value* value = nullptr;
     auto stage = core::EvaluationStage::kRuntime;
 
     switch (unary->op) {
         case core::UnaryOp::kAddressOf:
-            if (auto* ref = expr_ty->As<type::Reference>()) {
+            if (auto* ref = expr_ty->As<core::type::Reference>()) {
                 if (ref->StoreType()->UnwrapRef()->is_handle()) {
                     AddError("cannot take the address of expression in handle address space",
                              unary->expr->source);
@@ -3607,14 +3639,15 @@
 
                 auto* array = unary->expr->As<ast::IndexAccessorExpression>();
                 auto* member = unary->expr->As<ast::MemberAccessorExpression>();
-                if ((array && sem_.TypeOf(array->object)->UnwrapRef()->Is<type::Vector>()) ||
-                    (member && sem_.TypeOf(member->object)->UnwrapRef()->Is<type::Vector>())) {
+                if ((array && sem_.TypeOf(array->object)->UnwrapRef()->Is<core::type::Vector>()) ||
+                    (member &&
+                     sem_.TypeOf(member->object)->UnwrapRef()->Is<core::type::Vector>())) {
                     AddError("cannot take the address of a vector component", unary->expr->source);
                     return nullptr;
                 }
 
-                ty = builder_->create<type::Pointer>(ref->AddressSpace(), ref->StoreType(),
-                                                     ref->Access());
+                ty = builder_->create<core::type::Pointer>(ref->AddressSpace(), ref->StoreType(),
+                                                           ref->Access());
 
                 root_ident = expr->RootIdentifier();
             } else {
@@ -3624,9 +3657,9 @@
             break;
 
         case core::UnaryOp::kIndirection:
-            if (auto* ptr = expr_ty->As<type::Pointer>()) {
-                ty = builder_->create<type::Reference>(ptr->AddressSpace(), ptr->StoreType(),
-                                                       ptr->Access());
+            if (auto* ptr = expr_ty->As<core::type::Pointer>()) {
+                ty = builder_->create<core::type::Reference>(ptr->AddressSpace(), ptr->StoreType(),
+                                                             ptr->Access());
                 root_ident = expr->RootIdentifier();
             } else {
                 AddError("cannot dereference expression of type '" + sem_.TypeNameOf(expr_ty) + "'",
@@ -3688,7 +3721,7 @@
         return tint::Failure;
     }
 
-    if (!materialized->Type()->IsAnyOf<type::I32, type::U32>()) {
+    if (!materialized->Type()->IsAnyOf<core::type::I32, core::type::U32>()) {
         AddError("@location must be an i32 or u32 value", attr->source);
         return tint::Failure;
     }
@@ -3712,7 +3745,7 @@
         return tint::Failure;
     }
 
-    if (!materialized->Type()->IsAnyOf<type::I32, type::U32>()) {
+    if (!materialized->Type()->IsAnyOf<core::type::I32, core::type::U32>()) {
         AddError("@location must be an i32 or u32 value", attr->source);
         return tint::Failure;
     }
@@ -3735,7 +3768,7 @@
     if (!materialized) {
         return tint::Failure;
     }
-    if (!materialized->Type()->IsAnyOf<type::I32, type::U32>()) {
+    if (!materialized->Type()->IsAnyOf<core::type::I32, core::type::U32>()) {
         AddError("@binding must be an i32 or u32 value", attr->source);
         return tint::Failure;
     }
@@ -3757,7 +3790,7 @@
     if (!materialized) {
         return tint::Failure;
     }
-    if (!materialized->Type()->IsAnyOf<type::I32, type::U32>()) {
+    if (!materialized->Type()->IsAnyOf<core::type::I32, core::type::U32>()) {
         AddError("@group must be an i32 or u32 value", attr->source);
         return tint::Failure;
     }
@@ -3780,7 +3813,7 @@
 
     auto values = attr->Values();
     Vector<const sem::ValueExpression*, 3> args;
-    Vector<const type::Type*, 3> arg_tys;
+    Vector<const core::type::Type*, 3> arg_tys;
 
     constexpr const char* kErrBadExpr =
         "workgroup_size argument must be a constant or override-expression of type "
@@ -3798,7 +3831,7 @@
             return tint::Failure;
         }
         auto* ty = expr->Type();
-        if (!ty->IsAnyOf<type::I32, type::U32, type::AbstractInt>()) {
+        if (!ty->IsAnyOf<core::type::I32, core::type::U32, core::type::AbstractInt>()) {
             AddError(kErrBadExpr, value->source);
             return tint::Failure;
         }
@@ -3813,7 +3846,7 @@
         arg_tys.Push(ty);
     }
 
-    auto* common_ty = type::Type::Common(arg_tys);
+    auto* common_ty = core::type::Type::Common(arg_tys);
     if (!common_ty) {
         AddError("workgroup_size arguments must be of the same type, either i32 or u32",
                  attr->source);
@@ -3821,8 +3854,8 @@
     }
 
     // If all arguments are abstract-integers, then materialize to i32.
-    if (common_ty->Is<type::AbstractInt>()) {
-        common_ty = builder_->create<type::I32>();
+    if (common_ty->Is<core::type::AbstractInt>()) {
+        common_ty = builder_->create<core::type::I32>();
     }
 
     for (size_t i = 0; i < args.Length(); i++) {
@@ -3955,10 +3988,10 @@
     return true;
 }
 
-type::Type* Resolver::TypeDecl(const ast::TypeDecl* named_type) {
+core::type::Type* Resolver::TypeDecl(const ast::TypeDecl* named_type) {
     Mark(named_type->name);
 
-    type::Type* result = nullptr;
+    core::type::Type* result = nullptr;
     if (auto* alias = named_type->As<ast::Alias>()) {
         result = Alias(alias);
     } else if (auto* str = named_type->As<ast::Struct>()) {
@@ -3975,7 +4008,7 @@
     return result;
 }
 
-const type::ArrayCount* Resolver::ArrayCount(const ast::Expression* count_expr) {
+const core::type::ArrayCount* Resolver::ArrayCount(const ast::Expression* count_expr) {
     // Evaluate the constant array count expression.
     const auto* count_sem = Materialize(ValueExpression(count_expr));
     if (!count_sem) {
@@ -4014,11 +4047,11 @@
         return nullptr;
     }
 
-    return builder_->create<type::ConstantArrayCount>(static_cast<uint32_t>(count));
+    return builder_->create<core::type::ConstantArrayCount>(static_cast<uint32_t>(count));
 }
 
 bool Resolver::ArrayAttributes(VectorRef<const ast::Attribute*> attributes,
-                               const type::Type* el_ty,
+                               const core::type::Type* el_ty,
                                uint32_t& explicit_stride) {
     if (!validator_.NoDuplicateAttributes(attributes)) {
         return false;
@@ -4053,19 +4086,19 @@
     return true;
 }
 
-type::Array* Resolver::Array(const Source& array_source,
-                             const Source& el_source,
-                             const Source& count_source,
-                             const type::Type* el_ty,
-                             const type::ArrayCount* el_count,
-                             uint32_t explicit_stride) {
+core::type::Array* Resolver::Array(const Source& array_source,
+                                   const Source& el_source,
+                                   const Source& count_source,
+                                   const core::type::Type* el_ty,
+                                   const core::type::ArrayCount* el_count,
+                                   uint32_t explicit_stride) {
     uint32_t el_align = el_ty->Align();
     uint32_t el_size = el_ty->Size();
     uint64_t implicit_stride = el_size ? tint::RoundUp<uint64_t>(el_align, el_size) : 0;
     uint64_t stride = explicit_stride ? explicit_stride : implicit_stride;
     uint64_t size = 0;
 
-    if (auto const_count = el_count->As<type::ConstantArrayCount>()) {
+    if (auto const_count = el_count->As<core::type::ConstantArrayCount>()) {
         size = const_count->value * stride;
         if (size > std::numeric_limits<uint32_t>::max()) {
             StringStream msg;
@@ -4074,10 +4107,10 @@
             AddError(msg.str(), count_source);
             return nullptr;
         }
-    } else if (el_count->Is<type::RuntimeArrayCount>()) {
+    } else if (el_count->Is<core::type::RuntimeArrayCount>()) {
         size = stride;
     }
-    auto* out = builder_->create<type::Array>(
+    auto* out = builder_->create<core::type::Array>(
         el_ty, el_count, el_align, static_cast<uint32_t>(size), static_cast<uint32_t>(stride),
         static_cast<uint32_t>(implicit_stride));
 
@@ -4099,7 +4132,7 @@
     return out;
 }
 
-type::Type* Resolver::Alias(const ast::Alias* alias) {
+core::type::Type* Resolver::Alias(const ast::Alias* alias) {
     auto* ty = Type(alias->type);
     if (!ty) {
         return nullptr;
@@ -4194,7 +4227,7 @@
         bool has_offset_attr = false;
         bool has_align_attr = false;
         bool has_size_attr = false;
-        type::StructMemberAttributes attributes;
+        core::type::StructMemberAttributes attributes;
         for (auto* attribute : member->attributes) {
             Mark(attribute);
             bool ok = Switch(
@@ -4233,7 +4266,7 @@
                     if (!materialized) {
                         return false;
                     }
-                    if (!materialized->Type()->IsAnyOf<type::I32, type::U32>()) {
+                    if (!materialized->Type()->IsAnyOf<core::type::I32, core::type::U32>()) {
                         AddError("@align must be an i32 or u32 value", attr->source);
                         return false;
                     }
@@ -4262,7 +4295,7 @@
                     if (!materialized) {
                         return false;
                     }
-                    if (!materialized->Type()->IsAnyOf<type::U32, type::I32>()) {
+                    if (!materialized->Type()->IsAnyOf<core::type::U32, core::type::I32>()) {
                         AddError("@size must be an i32 or u32 value", attr->source);
                         return false;
                     }
@@ -4392,7 +4425,7 @@
 
     for (size_t i = 0; i < sem_members.Length(); i++) {
         auto* mem_type = sem_members[i]->Type();
-        if (mem_type->Is<type::Atomic>()) {
+        if (mem_type->Is<core::type::Atomic>()) {
             atomic_composite_info_.Add(out, &sem_members[i]->Declaration()->source);
             break;
         } else {
@@ -4433,13 +4466,13 @@
         auto& behaviors = current_statement_->Behaviors();
         behaviors = sem::Behavior::kReturn;
 
-        const type::Type* value_ty = nullptr;
+        const core::type::Type* value_ty = nullptr;
         if (auto* value = stmt->value) {
             const auto* expr = Load(ValueExpression(value));
             if (!expr) {
                 return false;
             }
-            if (auto* ret_ty = current_function_->ReturnType(); !ret_ty->Is<type::Void>()) {
+            if (auto* ret_ty = current_function_->ReturnType(); !ret_ty->Is<core::type::Void>()) {
                 expr = Materialize(expr, ret_ty);
                 if (!expr) {
                     return false;
@@ -4449,7 +4482,7 @@
 
             value_ty = expr->Type();
         } else {
-            value_ty = builder_->create<type::Void>();
+            value_ty = builder_->create<core::type::Void>();
         }
 
         // Validate after processing the return value expression so that its type
@@ -4475,7 +4508,7 @@
 
         // Determine the common type across all selectors and the switch expression
         // This must materialize to an integer scalar (non-abstract).
-        Vector<const type::Type*, 8> types;
+        Vector<const core::type::Type*, 8> types;
         types.Push(cond_ty);
         for (auto* case_stmt : stmt->body) {
             for (auto* sel : case_stmt->selectors) {
@@ -4489,11 +4522,11 @@
                 types.Push(sem_expr->Type()->UnwrapRef());
             }
         }
-        auto* common_ty = type::Type::Common(types);
+        auto* common_ty = core::type::Type::Common(types);
         if (!common_ty || !common_ty->is_integer_scalar()) {
             // No common type found or the common type was abstract.
             // Pick i32 and let validation deal with any mismatches.
-            common_ty = builder_->create<type::I32>();
+            common_ty = builder_->create<core::type::I32>();
         }
         cond = Materialize(cond, common_ty);
         if (!cond) {
@@ -4726,9 +4759,9 @@
 }
 
 bool Resolver::ApplyAddressSpaceUsageToType(core::AddressSpace address_space,
-                                            type::Type* ty,
+                                            core::type::Type* ty,
                                             const Source& usage) {
-    ty = const_cast<type::Type*>(ty->UnwrapRef());
+    ty = const_cast<core::type::Type*>(ty->UnwrapRef());
 
     if (auto* str = ty->As<sem::Struct>()) {
         if (str->AddressSpaceUsage().count(address_space)) {
@@ -4739,9 +4772,9 @@
 
         for (auto* member : str->Members()) {
             auto decl = member->Declaration();
-            if (decl &&
-                !ApplyAddressSpaceUsageToType(
-                    address_space, const_cast<type::Type*>(member->Type()), decl->type->source)) {
+            if (decl && !ApplyAddressSpaceUsageToType(address_space,
+                                                      const_cast<core::type::Type*>(member->Type()),
+                                                      decl->type->source)) {
                 StringStream err;
                 err << "while analyzing structure member " << sem_.TypeNameOf(str) << "."
                     << member->Name().Name();
@@ -4752,9 +4785,9 @@
         return true;
     }
 
-    if (auto* arr = ty->As<type::Array>()) {
+    if (auto* arr = ty->As<core::type::Array>()) {
         if (address_space != core::AddressSpace::kStorage) {
-            if (arr->Count()->Is<type::RuntimeArrayCount>()) {
+            if (arr->Count()->Is<core::type::RuntimeArrayCount>()) {
                 AddError("runtime-sized arrays can only be used in the <storage> address space",
                          usage);
                 return false;
@@ -4768,8 +4801,8 @@
                 return false;
             }
         }
-        return ApplyAddressSpaceUsageToType(address_space, const_cast<type::Type*>(arr->ElemType()),
-                                            usage);
+        return ApplyAddressSpaceUsageToType(address_space,
+                                            const_cast<core::type::Type*>(arr->ElemType()), usage);
     }
 
     if (core::IsHostShareable(address_space) && !validator_.IsHostShareable(ty)) {
diff --git a/src/tint/lang/wgsl/resolver/resolver.h b/src/tint/lang/wgsl/resolver/resolver.h
index fce71e5..4c9ac88 100644
--- a/src/tint/lang/wgsl/resolver/resolver.h
+++ b/src/tint/lang/wgsl/resolver/resolver.h
@@ -71,9 +71,9 @@
 class ValueConversion;
 class WhileStatement;
 }  // namespace tint::sem
-namespace tint::type {
+namespace tint::core::type {
 class Atomic;
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 namespace tint::resolver {
 
@@ -98,21 +98,23 @@
 
     /// @param type the given type
     /// @returns true if the given type is a plain type
-    bool IsPlain(const type::Type* type) const { return validator_.IsPlain(type); }
+    bool IsPlain(const core::type::Type* type) const { return validator_.IsPlain(type); }
 
     /// @param type the given type
     /// @returns true if the given type is a fixed-footprint type
-    bool IsFixedFootprint(const type::Type* type) const {
+    bool IsFixedFootprint(const core::type::Type* type) const {
         return validator_.IsFixedFootprint(type);
     }
 
     /// @param type the given type
     /// @returns true if the given type is storable
-    bool IsStorable(const type::Type* type) const { return validator_.IsStorable(type); }
+    bool IsStorable(const core::type::Type* type) const { return validator_.IsStorable(type); }
 
     /// @param type the given type
     /// @returns true if the given type is host-shareable
-    bool IsHostShareable(const type::Type* type) const { return validator_.IsHostShareable(type); }
+    bool IsHostShareable(const core::type::Type* type) const {
+        return validator_.IsHostShareable(type);
+    }
 
     /// @returns the validator for testing
     const Validator* GetValidatorForTesting() const { return &validator_; }
@@ -140,7 +142,7 @@
     sem::FunctionExpression* FunctionExpression(const ast::Expression* expr);
 
     /// @returns the resolved type from an expression, or nullptr on error
-    type::Type* Type(const ast::Expression* ast);
+    core::type::Type* Type(const ast::Expression* ast);
 
     /// @returns the call of Expression() cast to a
     /// sem::BuiltinEnumExpression<core::AddressSpace>. If the sem::Expression is not a
@@ -156,9 +158,10 @@
     sem::BuiltinEnumExpression<core::BuiltinValue>* BuiltinValueExpression(
         const ast::Expression* expr);
 
-    /// @returns the call of Expression() cast to a sem::BuiltinEnumExpression<type::TexelFormat>.
-    /// If the sem::Expression is not a sem::BuiltinEnumExpression<type::TexelFormat>, then an error
-    /// diagnostic is raised and nullptr is returned.
+    /// @returns the call of Expression() cast to a
+    /// sem::BuiltinEnumExpression<core::type::TexelFormat>. If the sem::Expression is not a
+    /// sem::BuiltinEnumExpression<core::type::TexelFormat>, then an error diagnostic is raised and
+    /// nullptr is returned.
     sem::BuiltinEnumExpression<core::TexelFormat>* TexelFormatExpression(
         const ast::Expression* expr);
 
@@ -241,7 +244,7 @@
     /// If `expr` is not of an abstract-numeric type, then Materialize() will just return `expr`.
     /// If `expr` is nullptr, then Materialize() will also return nullptr.
     const sem::ValueExpression* Materialize(const sem::ValueExpression* expr,
-                                            const type::Type* target_type = nullptr);
+                                            const core::type::Type* target_type = nullptr);
 
     /// For each argument in `args`:
     /// * Calls Materialize() passing the argument and the corresponding parameter type.
@@ -254,12 +257,12 @@
 
     /// @returns true if an argument of an abstract numeric type, passed to a parameter of type
     /// `parameter_ty` should be materialized.
-    bool ShouldMaterializeArgument(const type::Type* parameter_ty) const;
+    bool ShouldMaterializeArgument(const core::type::Type* parameter_ty) const;
 
     /// Converts `c` to `target_ty`
     /// @returns true on success, false on failure.
     bool Convert(const core::constant::Value*& c,
-                 const type::Type* target_ty,
+                 const core::type::Type* target_ty,
                  const Source& source);
 
     /// Transforms `args` to a vector of constants, and converts each constant to the call target's
@@ -276,9 +279,9 @@
     /// @param source the source of the expression requiring materialization
     /// @returns the concrete (materialized) type for the given type, or nullptr if the type is
     ///          already concrete.
-    const type::Type* ConcreteType(const type::Type* ty,
-                                   const type::Type* target_ty,
-                                   const Source& source);
+    const core::type::Type* ConcreteType(const core::type::Type* ty,
+                                         const core::type::Type* target_ty,
+                                         const Source& source);
 
     // Statement resolving methods
     // Each return true on success, false on failure.
@@ -287,7 +290,7 @@
     sem::Statement* BreakStatement(const ast::BreakStatement*);
     sem::Statement* BreakIfStatement(const ast::BreakIfStatement*);
     sem::Statement* CallStatement(const ast::CallStatement*);
-    sem::CaseStatement* CaseStatement(const ast::CaseStatement*, const type::Type*);
+    sem::CaseStatement* CaseStatement(const ast::CaseStatement*, const core::type::Type*);
     sem::Statement* CompoundAssignmentStatement(const ast::CompoundAssignmentStatement*);
     sem::Statement* ContinueStatement(const ast::ContinueStatement*);
     sem::Statement* ConstAssert(const ast::ConstAssert*);
@@ -378,12 +381,12 @@
 
     /// @param named_type the named type to resolve
     /// @returns the resolved semantic type
-    type::Type* TypeDecl(const ast::TypeDecl* named_type);
+    core::type::Type* TypeDecl(const ast::TypeDecl* named_type);
 
     /// Resolves and validates the expression used as the count parameter of an array.
     /// @param count_expr the expression used as the second template parameter to an array<>.
     /// @returns the number of elements in the array.
-    const type::ArrayCount* ArrayCount(const ast::Expression* count_expr);
+    const core::type::ArrayCount* ArrayCount(const ast::Expression* count_expr);
 
     /// Resolves and validates the attributes on an array.
     /// @param attributes the attributes on the array type.
@@ -391,7 +394,7 @@
     /// @param explicit_stride assigned the specified stride of the array in bytes.
     /// @returns true on success, false on failure
     bool ArrayAttributes(VectorRef<const ast::Attribute*> attributes,
-                         const type::Type* el_ty,
+                         const core::type::Type* el_ty,
                          uint32_t& explicit_stride);
 
     /// Builds and returns the semantic information for an array.
@@ -404,18 +407,18 @@
     /// @param el_ty the Array element type
     /// @param el_count the number of elements in the array.
     /// @param explicit_stride the explicit byte stride of the array. Zero means implicit stride.
-    type::Array* Array(const Source& array_source,
-                       const Source& el_source,
-                       const Source& count_source,
-                       const type::Type* el_ty,
-                       const type::ArrayCount* el_count,
-                       uint32_t explicit_stride);
+    core::type::Array* Array(const Source& array_source,
+                             const Source& el_source,
+                             const Source& count_source,
+                             const core::type::Type* el_ty,
+                             const core::type::ArrayCount* el_count,
+                             uint32_t explicit_stride);
 
     /// Builds and returns the semantic information for the alias `alias`.
     /// This method does not mark the ast::Alias node, nor attach the generated
     /// semantic information to the AST node.
     /// @returns the aliased type, or nullptr if an error is raised.
-    type::Type* Alias(const ast::Alias* alias);
+    core::type::Type* Alias(const ast::Alias* alias);
 
     /// Builds and returns the semantic information for the structure `str`.
     /// This method does not mark the ast::Struct node, nor attach the generated
@@ -482,7 +485,9 @@
     /// given type and address space. Used for generating sensible error
     /// messages.
     /// @returns true on success, false on error
-    bool ApplyAddressSpaceUsageToType(core::AddressSpace sc, type::Type* ty, const Source& usage);
+    bool ApplyAddressSpaceUsageToType(core::AddressSpace sc,
+                                      core::type::Type* ty,
+                                      const Source& usage);
 
     /// @param address_space the address space
     /// @returns the default access control for the given address space
@@ -551,24 +556,25 @@
     /// Adds the given note message to the diagnostics
     void AddNote(const std::string& msg, const Source& source) const;
 
-    /// @returns the type::Type for the builtin type @p builtin_ty with the identifier @p ident
+    /// @returns the core::type::Type for the builtin type @p builtin_ty with the identifier @p
+    /// ident
     /// @note: Will raise an ICE if @p symbol is not a builtin type.
-    type::Type* BuiltinType(core::Builtin builtin_ty, const ast::Identifier* ident);
+    core::type::Type* BuiltinType(core::Builtin builtin_ty, const ast::Identifier* ident);
 
     /// @returns the nesting depth of @ty as defined in
     /// https://gpuweb.github.io/gpuweb/wgsl/#composite-types
-    size_t NestDepth(const type::Type* ty) const;
+    size_t NestDepth(const core::type::Type* ty) const;
 
     // ArrayConstructorSig represents a unique array constructor signature.
     // It is a tuple of the array type, number of arguments provided and earliest evaluation stage.
-    using ArrayConstructorSig =
-        tint::UnorderedKeyWrapper<std::tuple<const type::Array*, size_t, core::EvaluationStage>>;
+    using ArrayConstructorSig = tint::UnorderedKeyWrapper<
+        std::tuple<const core::type::Array*, size_t, core::EvaluationStage>>;
 
     // StructConstructorSig represents a unique structure constructor signature.
     // It is a tuple of the structure type, number of arguments provided and earliest evaluation
     // stage.
-    using StructConstructorSig =
-        tint::UnorderedKeyWrapper<std::tuple<const type::Struct*, size_t, core::EvaluationStage>>;
+    using StructConstructorSig = tint::UnorderedKeyWrapper<
+        std::tuple<const core::type::Struct*, size_t, core::EvaluationStage>>;
 
     /// ExprEvalStageConstraint describes a constraint on when expressions can be evaluated.
     struct ExprEvalStageConstraint {
@@ -612,7 +618,7 @@
     Validator validator_;
     core::Extensions enabled_extensions_;
     Vector<sem::Function*, 8> entry_points_;
-    Hashmap<const type::Type*, const Source*, 8> atomic_composite_info_;
+    Hashmap<const core::type::Type*, const Source*, 8> atomic_composite_info_;
     tint::Bitset<0> marked_;
     ExprEvalStageConstraint expr_eval_stage_constraint_;
     std::unordered_map<const sem::Function*, AliasAnalysisInfo> alias_analysis_infos_;
@@ -628,7 +634,7 @@
     Hashmap<const ast::Expression*, const ast::BinaryExpression*, 8> logical_binary_lhs_to_parent_;
     Hashset<const ast::Expression*, 8> skip_const_eval_;
     IdentifierResolveHint identifier_resolve_hint_;
-    Hashmap<const type::Type*, size_t, 8> nest_depth_;
+    Hashmap<const core::type::Type*, size_t, 8> nest_depth_;
     Hashmap<std::pair<core::intrinsic::Table::Overload, core::Function>, sem::Builtin*, 64>
         builtins_;
     Hashmap<core::intrinsic::Table::Overload, sem::ValueConstructor*, 16> constructors_;
diff --git a/src/tint/lang/wgsl/resolver/resolver_helper_test.h b/src/tint/lang/wgsl/resolver/resolver_helper_test.h
index ec5bce6..9ed8395 100644
--- a/src/tint/lang/wgsl/resolver/resolver_helper_test.h
+++ b/src/tint/lang/wgsl/resolver/resolver_helper_test.h
@@ -116,7 +116,7 @@
     /// @param type a type
     /// @returns the name for `type` that closely resembles how it would be
     /// declared in WGSL.
-    std::string FriendlyName(const type::Type* type) { return type->FriendlyName(); }
+    std::string FriendlyName(const core::type::Type* type) { return type->FriendlyName(); }
 
   private:
     std::unique_ptr<Resolver> resolver_;
@@ -153,7 +153,7 @@
 using ast_type_func_ptr = ast::Type (*)(ProgramBuilder& b);
 using ast_expr_func_ptr = const ast::Expression* (*)(ProgramBuilder& b, VectorRef<Scalar> args);
 using ast_expr_from_double_func_ptr = const ast::Expression* (*)(ProgramBuilder& b, double v);
-using sem_type_func_ptr = const type::Type* (*)(ProgramBuilder& b);
+using sem_type_func_ptr = const core::type::Type* (*)(ProgramBuilder& b);
 using type_name_func_ptr = std::string (*)();
 
 struct UnspecializedElementType {};
@@ -174,7 +174,7 @@
     /// @return nullptr
     static inline ast::Type AST(ProgramBuilder&) { return {}; }
     /// @return nullptr
-    static inline const type::Type* Sem(ProgramBuilder&) { return nullptr; }
+    static inline const core::type::Type* Sem(ProgramBuilder&) { return nullptr; }
 };
 
 /// Helper for building bool types and expressions
@@ -191,7 +191,9 @@
     static inline ast::Type AST(ProgramBuilder& b) { return b.ty.bool_(); }
     /// @param b the ProgramBuilder
     /// @return the semantic bool type
-    static inline const type::Type* Sem(ProgramBuilder& b) { return b.create<type::Bool>(); }
+    static inline const core::type::Type* Sem(ProgramBuilder& b) {
+        return b.create<core::type::Bool>();
+    }
     /// @param b the ProgramBuilder
     /// @param args args of size 1 with the boolean value to init with
     /// @return a new AST expression of the bool type
@@ -222,7 +224,9 @@
     static inline ast::Type AST(ProgramBuilder& b) { return b.ty.i32(); }
     /// @param b the ProgramBuilder
     /// @return the semantic i32 type
-    static inline const type::Type* Sem(ProgramBuilder& b) { return b.create<type::I32>(); }
+    static inline const core::type::Type* Sem(ProgramBuilder& b) {
+        return b.create<core::type::I32>();
+    }
     /// @param b the ProgramBuilder
     /// @param args args of size 1 with the i32 value to init with
     /// @return a new AST i32 literal value expression
@@ -253,7 +257,9 @@
     static inline ast::Type AST(ProgramBuilder& b) { return b.ty.u32(); }
     /// @param b the ProgramBuilder
     /// @return the semantic u32 type
-    static inline const type::Type* Sem(ProgramBuilder& b) { return b.create<type::U32>(); }
+    static inline const core::type::Type* Sem(ProgramBuilder& b) {
+        return b.create<core::type::U32>();
+    }
     /// @param b the ProgramBuilder
     /// @param args args of size 1 with the u32 value to init with
     /// @return a new AST u32 literal value expression
@@ -284,7 +290,9 @@
     static inline ast::Type AST(ProgramBuilder& b) { return b.ty.f32(); }
     /// @param b the ProgramBuilder
     /// @return the semantic f32 type
-    static inline const type::Type* Sem(ProgramBuilder& b) { return b.create<type::F32>(); }
+    static inline const core::type::Type* Sem(ProgramBuilder& b) {
+        return b.create<core::type::F32>();
+    }
     /// @param b the ProgramBuilder
     /// @param args args of size 1 with the f32 value to init with
     /// @return a new AST f32 literal value expression
@@ -315,7 +323,9 @@
     static inline ast::Type AST(ProgramBuilder& b) { return b.ty.f16(); }
     /// @param b the ProgramBuilder
     /// @return the semantic f16 type
-    static inline const type::Type* Sem(ProgramBuilder& b) { return b.create<type::F16>(); }
+    static inline const core::type::Type* Sem(ProgramBuilder& b) {
+        return b.create<core::type::F16>();
+    }
     /// @param b the ProgramBuilder
     /// @param args args of size 1 with the f16 value to init with
     /// @return a new AST f16 literal value expression
@@ -345,8 +355,8 @@
     static inline ast::Type AST(ProgramBuilder&) { return {}; }
     /// @param b the ProgramBuilder
     /// @return the semantic abstract-float type
-    static inline const type::Type* Sem(ProgramBuilder& b) {
-        return b.create<type::AbstractFloat>();
+    static inline const core::type::Type* Sem(ProgramBuilder& b) {
+        return b.create<core::type::AbstractFloat>();
     }
     /// @param b the ProgramBuilder
     /// @param args args of size 1 with the abstract-float value to init with
@@ -377,7 +387,9 @@
     static inline ast::Type AST(ProgramBuilder&) { return {}; }
     /// @param b the ProgramBuilder
     /// @return the semantic abstract-int type
-    static inline const type::Type* Sem(ProgramBuilder& b) { return b.create<type::AbstractInt>(); }
+    static inline const core::type::Type* Sem(ProgramBuilder& b) {
+        return b.create<core::type::AbstractInt>();
+    }
     /// @param b the ProgramBuilder
     /// @param args args of size 1 with the abstract-int value to init with
     /// @return a new AST abstract-int literal value expression
@@ -414,8 +426,8 @@
     }
     /// @param b the ProgramBuilder
     /// @return the semantic vector type
-    static inline const type::Type* Sem(ProgramBuilder& b) {
-        return b.create<type::Vector>(DataType<T>::Sem(b), N);
+    static inline const core::type::Type* Sem(ProgramBuilder& b) {
+        return b.create<core::type::Vector>(DataType<T>::Sem(b), N);
     }
     /// @param b the ProgramBuilder
     /// @param args args of size 1 or N with values of type T to initialize with
@@ -466,9 +478,9 @@
     }
     /// @param b the ProgramBuilder
     /// @return the semantic matrix type
-    static inline const type::Type* Sem(ProgramBuilder& b) {
-        auto* column_type = b.create<type::Vector>(DataType<T>::Sem(b), M);
-        return b.create<type::Matrix>(column_type, N);
+    static inline const core::type::Type* Sem(ProgramBuilder& b) {
+        auto* column_type = b.create<core::type::Vector>(DataType<T>::Sem(b), M);
+        return b.create<core::type::Matrix>(column_type, N);
     }
     /// @param b the ProgramBuilder
     /// @param args args of size 1 or N*M with values of type T to initialize with
@@ -532,7 +544,7 @@
 
     /// @param b the ProgramBuilder
     /// @return the semantic aliased type
-    static inline const type::Type* Sem(ProgramBuilder& b) { return DataType<T>::Sem(b); }
+    static inline const core::type::Type* Sem(ProgramBuilder& b) { return DataType<T>::Sem(b); }
 
     /// @param b the ProgramBuilder
     /// @param args the value nested elements will be initialized with
@@ -585,9 +597,9 @@
 
     /// @param b the ProgramBuilder
     /// @return the semantic aliased type
-    static inline const type::Type* Sem(ProgramBuilder& b) {
-        return b.create<type::Pointer>(core::AddressSpace::kPrivate, DataType<T>::Sem(b),
-                                       core::Access::kReadWrite);
+    static inline const core::type::Type* Sem(ProgramBuilder& b) {
+        return b.create<core::type::Pointer>(core::AddressSpace::kPrivate, DataType<T>::Sem(b),
+                                             core::Access::kReadWrite);
     }
 
     /// @param b the ProgramBuilder
@@ -628,15 +640,15 @@
     }
     /// @param b the ProgramBuilder
     /// @return the semantic array type
-    static inline const type::Type* Sem(ProgramBuilder& b) {
+    static inline const core::type::Type* Sem(ProgramBuilder& b) {
         auto* el = DataType<T>::Sem(b);
-        const type::ArrayCount* count = nullptr;
+        const core::type::ArrayCount* count = nullptr;
         if (N == 0) {
-            count = b.create<type::RuntimeArrayCount>();
+            count = b.create<core::type::RuntimeArrayCount>();
         } else {
-            count = b.create<type::ConstantArrayCount>(N);
+            count = b.create<core::type::ConstantArrayCount>(N);
         }
-        return b.create<type::Array>(
+        return b.create<core::type::Array>(
             /* element */ el,
             /* count */ count,
             /* align */ el->Align(),
diff --git a/src/tint/lang/wgsl/resolver/resolver_test.cc b/src/tint/lang/wgsl/resolver/resolver_test.cc
index 2e5ef7d..10c36ba 100644
--- a/src/tint/lang/wgsl/resolver/resolver_test.cc
+++ b/src/tint/lang/wgsl/resolver/resolver_test.cc
@@ -83,8 +83,8 @@
     ASSERT_NE(TypeOf(lhs), nullptr);
     ASSERT_NE(TypeOf(rhs), nullptr);
 
-    EXPECT_TRUE(TypeOf(lhs)->UnwrapRef()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(rhs)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(lhs)->UnwrapRef()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(rhs)->Is<core::type::F32>());
     EXPECT_EQ(StmtOf(lhs), assign);
     EXPECT_EQ(StmtOf(rhs), assign);
 }
@@ -107,8 +107,8 @@
 
     ASSERT_NE(TypeOf(lhs), nullptr);
     ASSERT_NE(TypeOf(rhs), nullptr);
-    EXPECT_TRUE(TypeOf(lhs)->UnwrapRef()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(rhs)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(lhs)->UnwrapRef()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(rhs)->Is<core::type::F32>());
     EXPECT_EQ(StmtOf(lhs), assign);
     EXPECT_EQ(StmtOf(rhs), assign);
     EXPECT_EQ(BlockOf(assign), block);
@@ -140,8 +140,8 @@
 
     ASSERT_NE(TypeOf(lhs), nullptr);
     ASSERT_NE(TypeOf(rhs), nullptr);
-    EXPECT_TRUE(TypeOf(lhs)->UnwrapRef()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(rhs)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(lhs)->UnwrapRef()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(rhs)->Is<core::type::F32>());
     EXPECT_EQ(StmtOf(lhs), assign);
     EXPECT_EQ(StmtOf(rhs), assign);
     EXPECT_EQ(BlockOf(lhs), block);
@@ -175,11 +175,11 @@
     ASSERT_NE(TypeOf(else_rhs), nullptr);
     ASSERT_NE(TypeOf(lhs), nullptr);
     ASSERT_NE(TypeOf(rhs), nullptr);
-    EXPECT_TRUE(TypeOf(stmt->condition)->Is<type::Bool>());
-    EXPECT_TRUE(TypeOf(else_lhs)->UnwrapRef()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(else_rhs)->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(lhs)->UnwrapRef()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(rhs)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(stmt->condition)->Is<core::type::Bool>());
+    EXPECT_TRUE(TypeOf(else_lhs)->UnwrapRef()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(else_rhs)->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(lhs)->UnwrapRef()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(rhs)->Is<core::type::F32>());
     EXPECT_EQ(StmtOf(lhs), assign);
     EXPECT_EQ(StmtOf(rhs), assign);
     EXPECT_EQ(StmtOf(cond), stmt);
@@ -210,10 +210,10 @@
     ASSERT_NE(TypeOf(body_rhs), nullptr);
     ASSERT_NE(TypeOf(continuing_lhs), nullptr);
     ASSERT_NE(TypeOf(continuing_rhs), nullptr);
-    EXPECT_TRUE(TypeOf(body_lhs)->UnwrapRef()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(body_rhs)->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(continuing_lhs)->UnwrapRef()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(continuing_rhs)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(body_lhs)->UnwrapRef()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(body_rhs)->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(continuing_lhs)->UnwrapRef()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(continuing_rhs)->Is<core::type::F32>());
     EXPECT_EQ(BlockOf(body_lhs), body);
     EXPECT_EQ(BlockOf(body_rhs), body);
     EXPECT_EQ(BlockOf(continuing_lhs), continuing);
@@ -230,7 +230,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(cond), nullptr);
-    EXPECT_TRUE(TypeOf(cond)->Is<type::I32>());
+    EXPECT_TRUE(TypeOf(cond)->Is<core::type::I32>());
 }
 
 TEST_F(ResolverTest, Stmt_Return_WithoutValue) {
@@ -254,9 +254,9 @@
     ASSERT_NE(TypeOf(lhs), nullptr);
     ASSERT_NE(TypeOf(rhs), nullptr);
 
-    EXPECT_TRUE(TypeOf(stmt->condition)->Is<type::I32>());
-    EXPECT_TRUE(TypeOf(lhs)->UnwrapRef()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(rhs)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(stmt->condition)->Is<core::type::I32>());
+    EXPECT_TRUE(TypeOf(lhs)->UnwrapRef()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(rhs)->Is<core::type::F32>());
     EXPECT_EQ(BlockOf(lhs), case_block);
     EXPECT_EQ(BlockOf(rhs), case_block);
 }
@@ -275,7 +275,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    EXPECT_TRUE(TypeOf(expr)->Is<type::Void>());
+    EXPECT_TRUE(TypeOf(expr)->Is<core::type::Void>());
     EXPECT_EQ(StmtOf(expr), call);
 }
 
@@ -289,7 +289,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(init), nullptr);
-    EXPECT_TRUE(TypeOf(init)->Is<type::I32>());
+    EXPECT_TRUE(TypeOf(init)->Is<core::type::I32>());
 }
 
 TEST_F(ResolverTest, Stmt_VariableDecl_Alias) {
@@ -303,7 +303,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(init), nullptr);
-    EXPECT_TRUE(TypeOf(init)->Is<type::I32>());
+    EXPECT_TRUE(TypeOf(init)->Is<core::type::I32>());
 }
 
 TEST_F(ResolverTest, Stmt_VariableDecl_ModuleScope) {
@@ -313,7 +313,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(init), nullptr);
-    EXPECT_TRUE(TypeOf(init)->Is<type::I32>());
+    EXPECT_TRUE(TypeOf(init)->Is<core::type::I32>());
     EXPECT_EQ(StmtOf(init), nullptr);
 }
 
@@ -353,13 +353,13 @@
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
     ASSERT_NE(TypeOf(foo_i32_init), nullptr);
-    EXPECT_TRUE(TypeOf(foo_i32_init)->Is<type::I32>());
+    EXPECT_TRUE(TypeOf(foo_i32_init)->Is<core::type::I32>());
     ASSERT_NE(TypeOf(foo_f32_init), nullptr);
-    EXPECT_TRUE(TypeOf(foo_f32_init)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(foo_f32_init)->Is<core::type::F32>());
     ASSERT_NE(TypeOf(bar_i32_init), nullptr);
-    EXPECT_TRUE(TypeOf(bar_i32_init)->UnwrapRef()->Is<type::I32>());
+    EXPECT_TRUE(TypeOf(bar_i32_init)->UnwrapRef()->Is<core::type::I32>());
     ASSERT_NE(TypeOf(bar_f32_init), nullptr);
-    EXPECT_TRUE(TypeOf(bar_f32_init)->UnwrapRef()->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(bar_f32_init)->UnwrapRef()->Is<core::type::F32>());
     EXPECT_EQ(StmtOf(foo_i32_init), foo_i32_decl);
     EXPECT_EQ(StmtOf(bar_i32_init), bar_i32_decl);
     EXPECT_EQ(StmtOf(foo_f32_init), foo_f32_decl);
@@ -400,11 +400,11 @@
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
     ASSERT_NE(TypeOf(mod_init), nullptr);
-    EXPECT_TRUE(TypeOf(mod_init)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(mod_init)->Is<core::type::F32>());
     ASSERT_NE(TypeOf(fn_i32_init), nullptr);
-    EXPECT_TRUE(TypeOf(fn_i32_init)->Is<type::I32>());
+    EXPECT_TRUE(TypeOf(fn_i32_init)->Is<core::type::I32>());
     ASSERT_NE(TypeOf(fn_f32_init), nullptr);
-    EXPECT_TRUE(TypeOf(fn_f32_init)->UnwrapRef()->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(fn_f32_init)->UnwrapRef()->Is<core::type::F32>());
     EXPECT_EQ(StmtOf(fn_i32_init), fn_i32_decl);
     EXPECT_EQ(StmtOf(mod_init), nullptr);
     EXPECT_EQ(StmtOf(fn_f32_init), fn_f32_decl);
@@ -421,10 +421,10 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(a), nullptr);
-    auto* ref = TypeOf(a)->As<type::Reference>();
+    auto* ref = TypeOf(a)->As<core::type::Reference>();
     ASSERT_NE(ref, nullptr);
-    auto* ary = ref->StoreType()->As<type::Array>();
-    EXPECT_EQ(ary->Count(), create<type::ConstantArrayCount>(10u));
+    auto* ary = ref->StoreType()->As<core::type::Array>();
+    EXPECT_EQ(ary->Count(), create<core::type::ConstantArrayCount>(10u));
 }
 
 TEST_F(ResolverTest, ArraySize_SignedLiteral) {
@@ -434,10 +434,10 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(a), nullptr);
-    auto* ref = TypeOf(a)->As<type::Reference>();
+    auto* ref = TypeOf(a)->As<core::type::Reference>();
     ASSERT_NE(ref, nullptr);
-    auto* ary = ref->StoreType()->As<type::Array>();
-    EXPECT_EQ(ary->Count(), create<type::ConstantArrayCount>(10u));
+    auto* ary = ref->StoreType()->As<core::type::Array>();
+    EXPECT_EQ(ary->Count(), create<core::type::ConstantArrayCount>(10u));
 }
 
 TEST_F(ResolverTest, ArraySize_UnsignedConst) {
@@ -449,10 +449,10 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(a), nullptr);
-    auto* ref = TypeOf(a)->As<type::Reference>();
+    auto* ref = TypeOf(a)->As<core::type::Reference>();
     ASSERT_NE(ref, nullptr);
-    auto* ary = ref->StoreType()->As<type::Array>();
-    EXPECT_EQ(ary->Count(), create<type::ConstantArrayCount>(10u));
+    auto* ary = ref->StoreType()->As<core::type::Array>();
+    EXPECT_EQ(ary->Count(), create<core::type::ConstantArrayCount>(10u));
 }
 
 TEST_F(ResolverTest, ArraySize_SignedConst) {
@@ -464,10 +464,10 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(a), nullptr);
-    auto* ref = TypeOf(a)->As<type::Reference>();
+    auto* ref = TypeOf(a)->As<core::type::Reference>();
     ASSERT_NE(ref, nullptr);
-    auto* ary = ref->StoreType()->As<type::Array>();
-    EXPECT_EQ(ary->Count(), create<type::ConstantArrayCount>(10u));
+    auto* ary = ref->StoreType()->As<core::type::Array>();
+    EXPECT_EQ(ary->Count(), create<core::type::ConstantArrayCount>(10u));
 }
 
 TEST_F(ResolverTest, ArraySize_NamedOverride) {
@@ -479,9 +479,9 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(a), nullptr);
-    auto* ref = TypeOf(a)->As<type::Reference>();
+    auto* ref = TypeOf(a)->As<core::type::Reference>();
     ASSERT_NE(ref, nullptr);
-    auto* ary = ref->StoreType()->As<type::Array>();
+    auto* ary = ref->StoreType()->As<core::type::Array>();
     auto* sem_override = Sem().Get(override);
     ASSERT_NE(sem_override, nullptr);
     EXPECT_EQ(ary->Count(), create<sem::NamedOverrideArrayCount>(sem_override));
@@ -498,14 +498,14 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(a), nullptr);
-    auto* ref_a = TypeOf(a)->As<type::Reference>();
+    auto* ref_a = TypeOf(a)->As<core::type::Reference>();
     ASSERT_NE(ref_a, nullptr);
-    auto* ary_a = ref_a->StoreType()->As<type::Array>();
+    auto* ary_a = ref_a->StoreType()->As<core::type::Array>();
 
     ASSERT_NE(TypeOf(b), nullptr);
-    auto* ref_b = TypeOf(b)->As<type::Reference>();
+    auto* ref_b = TypeOf(b)->As<core::type::Reference>();
     ASSERT_NE(ref_b, nullptr);
-    auto* ary_b = ref_b->StoreType()->As<type::Array>();
+    auto* ary_b = ref_b->StoreType()->As<core::type::Array>();
 
     auto* sem_override = Sem().Get(override);
     ASSERT_NE(sem_override, nullptr);
@@ -524,9 +524,9 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(a), nullptr);
-    auto* ref = TypeOf(a)->As<type::Reference>();
+    auto* ref = TypeOf(a)->As<core::type::Reference>();
     ASSERT_NE(ref, nullptr);
-    auto* ary = ref->StoreType()->As<type::Array>();
+    auto* ary = ref->StoreType()->As<core::type::Array>();
     auto* sem_override = Sem().Get(override);
     ASSERT_NE(sem_override, nullptr);
     EXPECT_EQ(ary->Count(), create<sem::UnnamedOverrideArrayCount>(Sem().Get(cnt)));
@@ -545,14 +545,14 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(a), nullptr);
-    auto* ref_a = TypeOf(a)->As<type::Reference>();
+    auto* ref_a = TypeOf(a)->As<core::type::Reference>();
     ASSERT_NE(ref_a, nullptr);
-    auto* ary_a = ref_a->StoreType()->As<type::Array>();
+    auto* ary_a = ref_a->StoreType()->As<core::type::Array>();
 
     ASSERT_NE(TypeOf(b), nullptr);
-    auto* ref_b = TypeOf(b)->As<type::Reference>();
+    auto* ref_b = TypeOf(b)->As<core::type::Reference>();
     ASSERT_NE(ref_b, nullptr);
-    auto* ary_b = ref_b->StoreType()->As<type::Array>();
+    auto* ary_b = ref_b->StoreType()->As<core::type::Array>();
 
     auto* sem_override = Sem().Get(override);
     ASSERT_NE(sem_override, nullptr);
@@ -570,7 +570,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(bitcast), nullptr);
-    EXPECT_TRUE(TypeOf(bitcast)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(bitcast)->Is<core::type::F32>());
 }
 
 TEST_F(ResolverTest, Expr_Call) {
@@ -582,7 +582,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::F32>());
 }
 
 TEST_F(ResolverTest, Expr_Call_InBinaryOp) {
@@ -594,7 +594,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    EXPECT_TRUE(TypeOf(expr)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(expr)->Is<core::type::F32>());
 }
 
 TEST_F(ResolverTest, Expr_Call_WithParams) {
@@ -611,7 +611,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(param), nullptr);
-    EXPECT_TRUE(TypeOf(param)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(param)->Is<core::type::F32>());
 }
 
 TEST_F(ResolverTest, Expr_Call_Builtin) {
@@ -621,7 +621,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::F32>());
 }
 
 TEST_F(ResolverTest, Expr_Cast) {
@@ -633,7 +633,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(cast), nullptr);
-    EXPECT_TRUE(TypeOf(cast)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(cast)->Is<core::type::F32>());
 }
 
 TEST_F(ResolverTest, Expr_Initializer_Scalar) {
@@ -643,7 +643,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(s), nullptr);
-    EXPECT_TRUE(TypeOf(s)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(s)->Is<core::type::F32>());
 }
 
 TEST_F(ResolverTest, Expr_Initializer_Type_Vec2) {
@@ -653,9 +653,9 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 2u);
 }
 
 TEST_F(ResolverTest, Expr_Initializer_Type_Vec3) {
@@ -665,9 +665,9 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 3u);
 }
 
 TEST_F(ResolverTest, Expr_Initializer_Type_Vec4) {
@@ -677,9 +677,9 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverTest, Expr_Identifier_GlobalVariable) {
@@ -691,7 +691,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(ident), nullptr);
-    EXPECT_TRUE(TypeOf(ident)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(ident)->Is<core::type::F32>());
     EXPECT_TRUE(CheckVarUsers(my_var, Vector{ident}));
     ASSERT_NE(VarOf(ident), nullptr);
     EXPECT_EQ(VarOf(ident)->Declaration(), my_var);
@@ -706,7 +706,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(ident), nullptr);
-    EXPECT_TRUE(TypeOf(ident)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(ident)->Is<core::type::F32>());
     EXPECT_TRUE(CheckVarUsers(my_var, Vector{ident}));
     ASSERT_NE(VarOf(ident), nullptr);
     EXPECT_EQ(VarOf(ident)->Declaration(), my_var);
@@ -726,7 +726,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(my_var_a), nullptr);
-    EXPECT_TRUE(TypeOf(my_var_a)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(my_var_a)->Is<core::type::F32>());
     EXPECT_EQ(StmtOf(my_var_a), decl);
     EXPECT_TRUE(CheckVarUsers(var, Vector{my_var_a}));
     ASSERT_NE(VarOf(my_var_a), nullptr);
@@ -767,11 +767,11 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(my_var_a), nullptr);
-    ASSERT_TRUE(TypeOf(my_var_a)->Is<type::Reference>());
-    EXPECT_TRUE(TypeOf(my_var_a)->UnwrapRef()->Is<type::F32>());
+    ASSERT_TRUE(TypeOf(my_var_a)->Is<core::type::Reference>());
+    EXPECT_TRUE(TypeOf(my_var_a)->UnwrapRef()->Is<core::type::F32>());
     EXPECT_EQ(StmtOf(my_var_a), assign);
     ASSERT_NE(TypeOf(my_var_b), nullptr);
-    EXPECT_TRUE(TypeOf(my_var_b)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(my_var_b)->Is<core::type::F32>());
     EXPECT_EQ(StmtOf(my_var_b), assign);
     EXPECT_TRUE(CheckVarUsers(var, Vector{my_var_a, my_var_b}));
     ASSERT_NE(VarOf(my_var_a), nullptr);
@@ -796,12 +796,12 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(v), nullptr);
-    ASSERT_TRUE(TypeOf(v)->Is<type::Reference>());
-    EXPECT_TRUE(TypeOf(v)->UnwrapRef()->Is<type::F32>());
+    ASSERT_TRUE(TypeOf(v)->Is<core::type::Reference>());
+    EXPECT_TRUE(TypeOf(v)->UnwrapRef()->Is<core::type::F32>());
     EXPECT_EQ(StmtOf(v), p_decl);
     ASSERT_NE(TypeOf(p), nullptr);
-    ASSERT_TRUE(TypeOf(p)->Is<type::Pointer>());
-    EXPECT_TRUE(TypeOf(p)->UnwrapPtr()->Is<type::F32>());
+    ASSERT_TRUE(TypeOf(p)->Is<core::type::Pointer>());
+    EXPECT_TRUE(TypeOf(p)->UnwrapPtr()->Is<core::type::F32>());
     EXPECT_EQ(StmtOf(p), assign);
 }
 
@@ -817,7 +817,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(call), nullptr);
-    EXPECT_TRUE(TypeOf(call)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(call)->Is<core::type::F32>());
 }
 
 TEST_F(ResolverTest, Expr_Identifier_Unknown) {
@@ -845,13 +845,13 @@
     auto* func_sem = Sem().Get(func);
     ASSERT_NE(func_sem, nullptr);
     EXPECT_EQ(func_sem->Parameters().Length(), 3u);
-    EXPECT_TRUE(func_sem->Parameters()[0]->Type()->Is<type::F32>());
-    EXPECT_TRUE(func_sem->Parameters()[1]->Type()->Is<type::I32>());
-    EXPECT_TRUE(func_sem->Parameters()[2]->Type()->Is<type::U32>());
+    EXPECT_TRUE(func_sem->Parameters()[0]->Type()->Is<core::type::F32>());
+    EXPECT_TRUE(func_sem->Parameters()[1]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(func_sem->Parameters()[2]->Type()->Is<core::type::U32>());
     EXPECT_EQ(func_sem->Parameters()[0]->Declaration(), param_a);
     EXPECT_EQ(func_sem->Parameters()[1]->Declaration(), param_b);
     EXPECT_EQ(func_sem->Parameters()[2]->Declaration(), param_c);
-    EXPECT_TRUE(func_sem->ReturnType()->Is<type::Void>());
+    EXPECT_TRUE(func_sem->ReturnType()->Is<core::type::Void>());
 }
 
 TEST_F(ResolverTest, Function_Parameters_Locations) {
@@ -919,7 +919,7 @@
     auto* func_sem = Sem().Get(func);
     ASSERT_NE(func_sem, nullptr);
     EXPECT_EQ(func_sem->Parameters().Length(), 0u);
-    EXPECT_TRUE(func_sem->ReturnType()->Is<type::Void>());
+    EXPECT_TRUE(func_sem->ReturnType()->Is<core::type::Void>());
 
     const auto& vars = func_sem->TransitivelyReferencedGlobals();
     ASSERT_EQ(vars.Length(), 3u);
@@ -1011,7 +1011,7 @@
     ASSERT_NE(func_sem, nullptr);
 
     EXPECT_EQ(func_sem->TransitivelyReferencedGlobals().Length(), 0u);
-    EXPECT_TRUE(func_sem->ReturnType()->Is<type::Void>());
+    EXPECT_TRUE(func_sem->ReturnType()->Is<core::type::Void>());
 }
 
 TEST_F(ResolverTest, Function_NotRegisterFunctionConstant) {
@@ -1026,7 +1026,7 @@
     ASSERT_NE(func_sem, nullptr);
 
     EXPECT_EQ(func_sem->TransitivelyReferencedGlobals().Length(), 0u);
-    EXPECT_TRUE(func_sem->ReturnType()->Is<type::Void>());
+    EXPECT_TRUE(func_sem->ReturnType()->Is<core::type::Void>());
 }
 
 TEST_F(ResolverTest, Function_NotRegisterFunctionParams) {
@@ -1037,7 +1037,7 @@
     ASSERT_NE(func_sem, nullptr);
 
     EXPECT_EQ(func_sem->TransitivelyReferencedGlobals().Length(), 0u);
-    EXPECT_TRUE(func_sem->ReturnType()->Is<type::Void>());
+    EXPECT_TRUE(func_sem->ReturnType()->Is<core::type::Void>());
 }
 
 TEST_F(ResolverTest, Function_CallSites) {
@@ -1239,10 +1239,10 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(mem), nullptr);
-    EXPECT_TRUE(TypeOf(mem)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(mem)->Is<core::type::F32>());
     auto* sma = Sem().Get(mem)->UnwrapLoad()->As<sem::StructMemberAccess>();
     ASSERT_NE(sma, nullptr);
-    EXPECT_TRUE(sma->Member()->Type()->Is<type::F32>());
+    EXPECT_TRUE(sma->Member()->Type()->Is<core::type::F32>());
     EXPECT_EQ(sma->Object()->Declaration(), mem->object);
     EXPECT_EQ(sma->Member()->Index(), 1u);
     EXPECT_EQ(sma->Member()->Name().Name(), "second_member");
@@ -1260,11 +1260,11 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(mem), nullptr);
-    EXPECT_TRUE(TypeOf(mem)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(mem)->Is<core::type::F32>());
     auto* sma = Sem().Get(mem)->UnwrapLoad()->As<sem::StructMemberAccess>();
     ASSERT_NE(sma, nullptr);
     EXPECT_EQ(sma->Object()->Declaration(), mem->object);
-    EXPECT_TRUE(sma->Member()->Type()->Is<type::F32>());
+    EXPECT_TRUE(sma->Member()->Type()->Is<core::type::F32>());
     EXPECT_EQ(sma->Member()->Index(), 1u);
 }
 
@@ -1277,9 +1277,9 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(mem), nullptr);
-    ASSERT_TRUE(TypeOf(mem)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(mem)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(mem)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(mem)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(mem)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(mem)->As<core::type::Vector>()->Width(), 4u);
     auto* sma = Sem().Get(mem)->As<sem::Swizzle>();
     ASSERT_NE(sma, nullptr);
     EXPECT_EQ(sma->Object()->Declaration(), mem->object);
@@ -1295,7 +1295,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(mem), nullptr);
-    ASSERT_TRUE(TypeOf(mem)->Is<type::F32>());
+    ASSERT_TRUE(TypeOf(mem)->Is<core::type::F32>());
     auto* sma = Sem().Get(mem)->UnwrapLoad()->As<sem::Swizzle>();
     ASSERT_NE(sma, nullptr);
     EXPECT_EQ(sma->Object()->Declaration(), mem->object);
@@ -1329,9 +1329,9 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(mem), nullptr);
-    ASSERT_TRUE(TypeOf(mem)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(mem)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(mem)->As<type::Vector>()->Width(), 2u);
+    ASSERT_TRUE(TypeOf(mem)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(mem)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(mem)->As<core::type::Vector>()->Width(), 2u);
     ASSERT_TRUE(Sem().Get(mem)->Is<sem::Swizzle>());
 }
 
@@ -1347,7 +1347,7 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    EXPECT_TRUE(TypeOf(expr)->Is<type::F32>());
+    EXPECT_TRUE(TypeOf(expr)->Is<core::type::F32>());
 }
 
 namespace ExprBinaryTest {
@@ -1747,18 +1747,18 @@
 
     ast::Type lhs_type;
     ast::Type rhs_type;
-    const type::Type* result_type = nullptr;
+    const core::type::Type* result_type = nullptr;
     bool is_valid_expr;
 
     if (vec_by_mat) {
         lhs_type = ty.vec<f32>(vec_size);
         rhs_type = ty.mat<f32>(mat_cols, mat_rows);
-        result_type = create<type::Vector>(create<type::F32>(), mat_cols);
+        result_type = create<core::type::Vector>(create<core::type::F32>(), mat_cols);
         is_valid_expr = vec_size == mat_rows;
     } else {
         lhs_type = ty.mat<f32>(mat_cols, mat_rows);
         rhs_type = ty.vec<f32>(vec_size);
-        result_type = create<type::Vector>(create<type::F32>(), mat_rows);
+        result_type = create<core::type::Vector>(create<core::type::F32>(), mat_rows);
         is_valid_expr = vec_size == mat_cols;
     }
 
@@ -1795,9 +1795,9 @@
     auto lhs_type = ty.mat<f32>(lhs_mat_cols, lhs_mat_rows);
     auto rhs_type = ty.mat<f32>(rhs_mat_cols, rhs_mat_rows);
 
-    auto* f32 = create<type::F32>();
-    auto* col = create<type::Vector>(f32, lhs_mat_rows);
-    auto* result_type = create<type::Matrix>(col, rhs_mat_cols);
+    auto* f32 = create<core::type::F32>();
+    auto* col = create<core::type::Vector>(f32, lhs_mat_rows);
+    auto* result_type = create<core::type::Matrix>(col, rhs_mat_cols);
 
     GlobalVar("lhs", lhs_type, core::AddressSpace::kPrivate);
     GlobalVar("rhs", rhs_type, core::AddressSpace::kPrivate);
@@ -1840,15 +1840,15 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(der), nullptr);
-    ASSERT_TRUE(TypeOf(der)->Is<type::Vector>());
+    ASSERT_TRUE(TypeOf(der)->Is<core::type::Vector>());
     if (op == core::UnaryOp::kNot) {
-        EXPECT_TRUE(TypeOf(der)->As<type::Vector>()->type()->Is<type::Bool>());
+        EXPECT_TRUE(TypeOf(der)->As<core::type::Vector>()->type()->Is<core::type::Bool>());
     } else if (op == core::UnaryOp::kNegation || op == core::UnaryOp::kComplement) {
-        EXPECT_TRUE(TypeOf(der)->As<type::Vector>()->type()->Is<type::I32>());
+        EXPECT_TRUE(TypeOf(der)->As<core::type::Vector>()->type()->Is<core::type::I32>());
     } else {
-        EXPECT_TRUE(TypeOf(der)->As<type::Vector>()->type()->Is<type::F32>());
+        EXPECT_TRUE(TypeOf(der)->As<core::type::Vector>()->type()->Is<core::type::F32>());
     }
-    EXPECT_EQ(TypeOf(der)->As<type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(der)->As<core::type::Vector>()->Width(), 4u);
 }
 INSTANTIATE_TEST_SUITE_P(ResolverTest,
                          UnaryOpExpressionTest,
@@ -1868,7 +1868,7 @@
 }
 
 TEST_F(ResolverTest, AddressSpace_SetForSampler) {
-    auto t = ty.sampler(type::SamplerKind::kSampler);
+    auto t = ty.sampler(core::type::SamplerKind::kSampler);
     auto* var = GlobalVar("var", t, Binding(0_a), Group(0_a));
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1877,7 +1877,7 @@
 }
 
 TEST_F(ResolverTest, AddressSpace_SetForTexture) {
-    auto t = ty.sampled_texture(type::TextureDimension::k1d, ty.f32());
+    auto t = ty.sampled_texture(core::type::TextureDimension::k1d, ty.f32());
     auto* var = GlobalVar("var", t, Binding(0_a), Group(0_a));
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -1910,8 +1910,10 @@
 TEST_F(ResolverTest, BindingPoint_SetForResources) {
     // @group(1) @binding(2) var s1 : sampler;
     // @group(3) @binding(4) var s2 : sampler;
-    auto* s1 = GlobalVar(Sym(), ty.sampler(type::SamplerKind::kSampler), Group(1_a), Binding(2_a));
-    auto* s2 = GlobalVar(Sym(), ty.sampler(type::SamplerKind::kSampler), Group(3_a), Binding(4_a));
+    auto* s1 =
+        GlobalVar(Sym(), ty.sampler(core::type::SamplerKind::kSampler), Group(1_a), Binding(2_a));
+    auto* s2 =
+        GlobalVar(Sym(), ty.sampler(core::type::SamplerKind::kSampler), Group(3_a), Binding(4_a));
 
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 
@@ -2115,9 +2117,9 @@
 }
 
 TEST_F(ResolverTest, TextureSampler_TextureSample) {
-    GlobalVar("t", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(1_a),
+    GlobalVar("t", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Group(1_a),
               Binding(1_a));
-    GlobalVar("s", ty.sampler(type::SamplerKind::kSampler), Group(1_a), Binding(2_a));
+    GlobalVar("s", ty.sampler(core::type::SamplerKind::kSampler), Group(1_a), Binding(2_a));
 
     auto* call = Call("textureSample", "t", "s", Call<vec2<f32>>(1_f, 2_f));
     const ast::Function* f =
@@ -2134,9 +2136,9 @@
 }
 
 TEST_F(ResolverTest, TextureSampler_TextureSampleInFunction) {
-    GlobalVar("t", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(1_a),
+    GlobalVar("t", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Group(1_a),
               Binding(1_a));
-    GlobalVar("s", ty.sampler(type::SamplerKind::kSampler), Group(1_a), Binding(2_a));
+    GlobalVar("s", ty.sampler(core::type::SamplerKind::kSampler), Group(1_a), Binding(2_a));
 
     auto* inner_call = Assign(Phony(), Call("textureSample", "t", "s", Call<vec2<f32>>(1_f, 2_f)));
     const ast::Function* inner_func =
@@ -2160,9 +2162,9 @@
 }
 
 TEST_F(ResolverTest, TextureSampler_TextureSampleFunctionDiamondSameVariables) {
-    GlobalVar("t", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(1_a),
+    GlobalVar("t", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Group(1_a),
               Binding(1_a));
-    GlobalVar("s", ty.sampler(type::SamplerKind::kSampler), Group(1_a), Binding(2_a));
+    GlobalVar("s", ty.sampler(core::type::SamplerKind::kSampler), Group(1_a), Binding(2_a));
 
     auto* inner_call_1 =
         Assign(Phony(), Call("textureSample", "t", "s", Call<vec2<f32>>(1_f, 2_f)));
@@ -2197,11 +2199,11 @@
 }
 
 TEST_F(ResolverTest, TextureSampler_TextureSampleFunctionDiamondDifferentVariables) {
-    GlobalVar("t1", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(1_a),
+    GlobalVar("t1", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Group(1_a),
               Binding(1_a));
-    GlobalVar("t2", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(1_a),
+    GlobalVar("t2", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Group(1_a),
               Binding(2_a));
-    GlobalVar("s", ty.sampler(type::SamplerKind::kSampler), Group(1_a), Binding(3_a));
+    GlobalVar("s", ty.sampler(core::type::SamplerKind::kSampler), Group(1_a), Binding(3_a));
 
     auto* inner_call_1 =
         Assign(Phony(), Call("textureSample", "t1", "s", Call<vec2<f32>>(1_f, 2_f)));
@@ -2238,7 +2240,7 @@
 }
 
 TEST_F(ResolverTest, TextureSampler_TextureDimensions) {
-    GlobalVar("t", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(1_a),
+    GlobalVar("t", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Group(1_a),
               Binding(2_a));
 
     auto* call = Call("textureDimensions", "t");
@@ -2266,8 +2268,8 @@
     // fn helper(sl: ptr<function, sampler>, tl: ptr<function, texture_2d<f32>>) -> vec4<f32> {
     //     return textureSampleLevel(*tl, *sl, c, 0.0);
     // }
-    GlobalVar("s", ty.sampler(type::SamplerKind::kSampler), Group(0_a), Binding(0_a));
-    GlobalVar("t", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(0_a),
+    GlobalVar("s", ty.sampler(core::type::SamplerKind::kSampler), Group(0_a), Binding(0_a));
+    GlobalVar("t", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()), Group(0_a),
               Binding(1_a));
     GlobalVar("c", ty.vec2<f32>(), core::AddressSpace::kUniform, Group(0_a), Binding(2_a));
 
@@ -2284,9 +2286,9 @@
 
     Func("helper",
          Vector{
-             Param("sl", ty.ptr<function>(ty.sampler(type::SamplerKind::kSampler))),
-             Param("tl",
-                   ty.ptr<function>(ty.sampled_texture(type::TextureDimension::k2d, ty.f32()))),
+             Param("sl", ty.ptr<function>(ty.sampler(core::type::SamplerKind::kSampler))),
+             Param("tl", ty.ptr<function>(
+                             ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()))),
          },
          ty.vec4<f32>(),
          Vector{
diff --git a/src/tint/lang/wgsl/resolver/root_identifier_test.cc b/src/tint/lang/wgsl/resolver/root_identifier_test.cc
index a178c54..cae41a8 100644
--- a/src/tint/lang/wgsl/resolver/root_identifier_test.cc
+++ b/src/tint/lang/wgsl/resolver/root_identifier_test.cc
@@ -72,7 +72,7 @@
 }
 
 TEST_F(ResolverRootIdentifierTest, GlobalTextureVar) {
-    auto* a = GlobalVar("a", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()),
+    auto* a = GlobalVar("a", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()),
                         core::AddressSpace::kUndefined, Group(0_a), Binding(0_a));
     auto* expr = Expr(a);
     WrapInFunction(Call("textureDimensions", expr));
diff --git a/src/tint/lang/wgsl/resolver/sem_helper.cc b/src/tint/lang/wgsl/resolver/sem_helper.cc
index c31fb2e..ce4c0d6 100644
--- a/src/tint/lang/wgsl/resolver/sem_helper.cc
+++ b/src/tint/lang/wgsl/resolver/sem_helper.cc
@@ -27,17 +27,17 @@
 
 SemHelper::~SemHelper() = default;
 
-std::string SemHelper::TypeNameOf(const type::Type* ty) const {
+std::string SemHelper::TypeNameOf(const core::type::Type* ty) const {
     return RawTypeNameOf(ty->UnwrapRef());
 }
 
-std::string SemHelper::RawTypeNameOf(const type::Type* ty) const {
+std::string SemHelper::RawTypeNameOf(const core::type::Type* ty) const {
     return ty->FriendlyName();
 }
 
-type::Type* SemHelper::TypeOf(const ast::Expression* expr) const {
+core::type::Type* SemHelper::TypeOf(const ast::Expression* expr) const {
     auto* sem = GetVal(expr);
-    return sem ? const_cast<type::Type*>(sem->Type()) : nullptr;
+    return sem ? const_cast<core::type::Type*>(sem->Type()) : nullptr;
 }
 
 std::string SemHelper::Describe(const sem::Expression* expr) const {
diff --git a/src/tint/lang/wgsl/resolver/sem_helper.h b/src/tint/lang/wgsl/resolver/sem_helper.h
index 532f5dd..4dfbe64 100644
--- a/src/tint/lang/wgsl/resolver/sem_helper.h
+++ b/src/tint/lang/wgsl/resolver/sem_helper.h
@@ -137,8 +137,8 @@
 
     /// @param expr the semantic node
     /// @returns nullptr if @p expr is nullptr, or @p expr cast to
-    /// sem::BuiltinEnumExpression<type::TexelFormat> if the cast is successful, otherwise an error
-    /// diagnostic is raised.
+    /// sem::BuiltinEnumExpression<core::type::TexelFormat> if the cast is successful, otherwise an
+    /// error diagnostic is raised.
     sem::BuiltinEnumExpression<core::TexelFormat>* AsTexelFormat(sem::Expression* expr) const {
         if (TINT_LIKELY(expr)) {
             auto* enum_expr = expr->As<sem::BuiltinEnumExpression<core::TexelFormat>>();
@@ -199,15 +199,15 @@
 
     /// @returns the resolved type of the ast::Expression @p expr
     /// @param expr the expression
-    type::Type* TypeOf(const ast::Expression* expr) const;
+    core::type::Type* TypeOf(const ast::Expression* expr) const;
 
     /// @returns the type name of the given semantic type, unwrapping references.
     /// @param ty the type to look up
-    std::string TypeNameOf(const type::Type* ty) const;
+    std::string TypeNameOf(const core::type::Type* ty) const;
 
     /// @returns the type name of the given semantic type, without unwrapping references.
     /// @param ty the type to look up
-    std::string RawTypeNameOf(const type::Type* ty) const;
+    std::string RawTypeNameOf(const core::type::Type* ty) const;
 
     /// Raises an error diagnostic that the expression @p got was expected to be a
     /// sem::ValueExpression, but the expression evaluated to something different.
diff --git a/src/tint/lang/wgsl/resolver/side_effects_test.cc b/src/tint/lang/wgsl/resolver/side_effects_test.cc
index 8437c43..777896f 100644
--- a/src/tint/lang/wgsl/resolver/side_effects_test.cc
+++ b/src/tint/lang/wgsl/resolver/side_effects_test.cc
@@ -186,22 +186,22 @@
     GlobalVar("a", ty.atomic(ty.i32()), tint::core::AddressSpace::kStorage,
               tint::core::Access::kReadWrite, Group(0_a), Binding(AInt(next_binding++)));
     if (c.pipeline_stage != ast::PipelineStage::kCompute) {
-        GlobalVar("t2d", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()), Group(0_a),
-                  Binding(AInt(next_binding++)));
-        GlobalVar("tdepth2d", ty.depth_texture(type::TextureDimension::k2d), Group(0_a),
-                  Binding(AInt(next_binding++)));
-        GlobalVar("t2d_arr", ty.sampled_texture(type::TextureDimension::k2dArray, ty.f32()),
+        GlobalVar("t2d", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()),
                   Group(0_a), Binding(AInt(next_binding++)));
-        GlobalVar("t2d_multi", ty.multisampled_texture(type::TextureDimension::k2d, ty.f32()),
+        GlobalVar("tdepth2d", ty.depth_texture(core::type::TextureDimension::k2d), Group(0_a),
+                  Binding(AInt(next_binding++)));
+        GlobalVar("t2d_arr", ty.sampled_texture(core::type::TextureDimension::k2dArray, ty.f32()),
+                  Group(0_a), Binding(AInt(next_binding++)));
+        GlobalVar("t2d_multi", ty.multisampled_texture(core::type::TextureDimension::k2d, ty.f32()),
                   Group(0_a), Binding(AInt(next_binding++)));
         GlobalVar(
             "tstorage2d",
-            ty.storage_texture(type::TextureDimension::k2d, tint::core::TexelFormat::kR32Float,
-                               tint::core::Access::kWrite),
+            ty.storage_texture(core::type::TextureDimension::k2d,
+                               tint::core::TexelFormat::kR32Float, tint::core::Access::kWrite),
             Group(0_a), Binding(AInt(next_binding++)));
-        GlobalVar("s2d", ty.sampler(type::SamplerKind::kSampler), Group(0_a),
+        GlobalVar("s2d", ty.sampler(core::type::SamplerKind::kSampler), Group(0_a),
                   Binding(AInt(next_binding++)));
-        GlobalVar("scomp", ty.sampler(type::SamplerKind::kComparisonSampler), Group(0_a),
+        GlobalVar("scomp", ty.sampler(core::type::SamplerKind::kComparisonSampler), Group(0_a),
                   Binding(AInt(next_binding++)));
     }
 
diff --git a/src/tint/lang/wgsl/resolver/struct_address_space_use_test.cc b/src/tint/lang/wgsl/resolver/struct_address_space_use_test.cc
index f713466..d90b466 100644
--- a/src/tint/lang/wgsl/resolver/struct_address_space_use_test.cc
+++ b/src/tint/lang/wgsl/resolver/struct_address_space_use_test.cc
@@ -32,7 +32,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_TRUE(sem->AddressSpaceUsage().empty());
 }
@@ -44,7 +44,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(core::AddressSpace::kUndefined));
 }
@@ -56,7 +56,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(core::AddressSpace::kUndefined));
 }
@@ -68,7 +68,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(core::AddressSpace::kPrivate));
 }
@@ -80,7 +80,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(core::AddressSpace::kPrivate));
 }
@@ -92,7 +92,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(core::AddressSpace::kPrivate));
 }
@@ -104,7 +104,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(core::AddressSpace::kPrivate));
 }
@@ -116,7 +116,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(core::AddressSpace::kFunction));
 }
@@ -128,7 +128,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(core::AddressSpace::kFunction));
 }
@@ -140,7 +140,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(core::AddressSpace::kFunction));
 }
@@ -152,7 +152,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(), UnorderedElementsAre(core::AddressSpace::kFunction));
 }
@@ -166,7 +166,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->AddressSpaceUsage(),
                 UnorderedElementsAre(core::AddressSpace::kUniform, core::AddressSpace::kStorage,
diff --git a/src/tint/lang/wgsl/resolver/struct_pipeline_stage_use_test.cc b/src/tint/lang/wgsl/resolver/struct_pipeline_stage_use_test.cc
index 8ef618b..d40b767 100644
--- a/src/tint/lang/wgsl/resolver/struct_pipeline_stage_use_test.cc
+++ b/src/tint/lang/wgsl/resolver/struct_pipeline_stage_use_test.cc
@@ -34,7 +34,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_TRUE(sem->PipelineStageUses().empty());
 }
@@ -46,7 +46,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_TRUE(sem->PipelineStageUses().empty());
 }
@@ -58,7 +58,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_TRUE(sem->PipelineStageUses().empty());
 }
@@ -72,10 +72,10 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->PipelineStageUses(),
-                UnorderedElementsAre(type::PipelineStageUsage::kVertexInput));
+                UnorderedElementsAre(core::type::PipelineStageUsage::kVertexInput));
 }
 
 TEST_F(ResolverPipelineStageUseTest, StructUsedAsVertexShaderReturnType) {
@@ -87,10 +87,10 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->PipelineStageUses(),
-                UnorderedElementsAre(type::PipelineStageUsage::kVertexOutput));
+                UnorderedElementsAre(core::type::PipelineStageUsage::kVertexOutput));
 }
 
 TEST_F(ResolverPipelineStageUseTest, StructUsedAsFragmentShaderParam) {
@@ -101,10 +101,10 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->PipelineStageUses(),
-                UnorderedElementsAre(type::PipelineStageUsage::kFragmentInput));
+                UnorderedElementsAre(core::type::PipelineStageUsage::kFragmentInput));
 }
 
 TEST_F(ResolverPipelineStageUseTest, StructUsedAsFragmentShaderReturnType) {
@@ -115,10 +115,10 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->PipelineStageUses(),
-                UnorderedElementsAre(type::PipelineStageUsage::kFragmentOutput));
+                UnorderedElementsAre(core::type::PipelineStageUsage::kFragmentOutput));
 }
 
 TEST_F(ResolverPipelineStageUseTest, StructUsedAsComputeShaderParam) {
@@ -131,10 +131,10 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->PipelineStageUses(),
-                UnorderedElementsAre(type::PipelineStageUsage::kComputeInput));
+                UnorderedElementsAre(core::type::PipelineStageUsage::kComputeInput));
 }
 
 TEST_F(ResolverPipelineStageUseTest, StructUsedMultipleStages) {
@@ -149,11 +149,11 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->PipelineStageUses(),
-                UnorderedElementsAre(type::PipelineStageUsage::kVertexOutput,
-                                     type::PipelineStageUsage::kFragmentInput));
+                UnorderedElementsAre(core::type::PipelineStageUsage::kVertexOutput,
+                                     core::type::PipelineStageUsage::kFragmentInput));
 }
 
 TEST_F(ResolverPipelineStageUseTest, StructUsedAsShaderParamViaAlias) {
@@ -165,10 +165,10 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->PipelineStageUses(),
-                UnorderedElementsAre(type::PipelineStageUsage::kFragmentInput));
+                UnorderedElementsAre(core::type::PipelineStageUsage::kFragmentInput));
 }
 
 TEST_F(ResolverPipelineStageUseTest, StructUsedAsShaderParamLocationSet) {
@@ -179,7 +179,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     ASSERT_EQ(1u, sem->Members().Length());
     EXPECT_EQ(3u, sem->Members()[0]->Attributes().location);
@@ -194,10 +194,10 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     EXPECT_THAT(sem->PipelineStageUses(),
-                UnorderedElementsAre(type::PipelineStageUsage::kFragmentOutput));
+                UnorderedElementsAre(core::type::PipelineStageUsage::kFragmentOutput));
 }
 
 TEST_F(ResolverPipelineStageUseTest, StructUsedAsShaderReturnTypeLocationSet) {
@@ -208,7 +208,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    auto* sem = TypeOf(s)->As<type::Struct>();
+    auto* sem = TypeOf(s)->As<core::type::Struct>();
     ASSERT_NE(sem, nullptr);
     ASSERT_EQ(1u, sem->Members().Length());
     EXPECT_EQ(3u, sem->Members()[0]->Attributes().location);
diff --git a/src/tint/lang/wgsl/resolver/type_validation_test.cc b/src/tint/lang/wgsl/resolver/type_validation_test.cc
index da96651..0132b9b 100644
--- a/src/tint/lang/wgsl/resolver/type_validation_test.cc
+++ b/src/tint/lang/wgsl/resolver/type_validation_test.cc
@@ -836,7 +836,7 @@
 }
 
 TEST_F(ResolverTypeValidationTest, ArrayOfNonStorableType) {
-    auto tex_ty = ty.sampled_texture(Source{{12, 34}}, type::TextureDimension::k2d, ty.f32());
+    auto tex_ty = ty.sampled_texture(Source{{12, 34}}, core::type::TextureDimension::k2d, ty.f32());
     GlobalVar("arr", ty.array(tex_ty, 4_i), core::AddressSpace::kPrivate);
 
     EXPECT_FALSE(r()->Resolve());
@@ -912,7 +912,7 @@
 
 namespace SampledTextureTests {
 
-using SampledTextureDimensionTest = ResolverTestWithParam<type::TextureDimension>;
+using SampledTextureDimensionTest = ResolverTestWithParam<core::type::TextureDimension>;
 TEST_P(SampledTextureDimensionTest, All) {
     auto& params = GetParam();
     GlobalVar(Source{{12, 34}}, "a", ty.sampled_texture(params, ty.i32()), Group(0_a),
@@ -923,14 +923,14 @@
 INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest,
                          SampledTextureDimensionTest,
                          testing::Values(  //
-                             type::TextureDimension::k1d,
-                             type::TextureDimension::k2d,
-                             type::TextureDimension::k2dArray,
-                             type::TextureDimension::k3d,
-                             type::TextureDimension::kCube,
-                             type::TextureDimension::kCubeArray));
+                             core::type::TextureDimension::k1d,
+                             core::type::TextureDimension::k2d,
+                             core::type::TextureDimension::k2dArray,
+                             core::type::TextureDimension::k3d,
+                             core::type::TextureDimension::kCube,
+                             core::type::TextureDimension::kCubeArray));
 
-using MultisampledTextureDimensionTest = ResolverTestWithParam<type::TextureDimension>;
+using MultisampledTextureDimensionTest = ResolverTestWithParam<core::type::TextureDimension>;
 TEST_P(MultisampledTextureDimensionTest, All) {
     auto& params = GetParam();
     GlobalVar("a", ty.multisampled_texture(Source{{12, 34}}, params, ty.i32()), Group(0_a),
@@ -940,7 +940,7 @@
 }
 INSTANTIATE_TEST_SUITE_P(ResolverTypeValidationTest,
                          MultisampledTextureDimensionTest,
-                         testing::Values(type::TextureDimension::k2d));
+                         testing::Values(core::type::TextureDimension::k2d));
 
 struct TypeParams {
     builder::ast_type_func_ptr type_func;
@@ -978,10 +978,10 @@
 TEST_P(SampledTextureTypeTest, All) {
     auto& params = GetParam();
     Enable(core::Extension::kF16);
-    GlobalVar(
-        "a",
-        ty.sampled_texture(Source{{12, 34}}, type::TextureDimension::k2d, params.type_func(*this)),
-        Group(0_a), Binding(0_a));
+    GlobalVar("a",
+              ty.sampled_texture(Source{{12, 34}}, core::type::TextureDimension::k2d,
+                                 params.type_func(*this)),
+              Group(0_a), Binding(0_a));
 
     if (params.is_valid) {
         EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -999,7 +999,7 @@
     auto& params = GetParam();
     Enable(core::Extension::kF16);
     GlobalVar("a",
-              ty.multisampled_texture(Source{{12, 34}}, type::TextureDimension::k2d,
+              ty.multisampled_texture(Source{{12, 34}}, core::type::TextureDimension::k2d,
                                       params.type_func(*this)),
               Group(0_a), Binding(0_a));
 
@@ -1088,20 +1088,20 @@
     // @group(0) @binding(3)
     // var d : texture_storage_3d<*, write>;
 
-    auto st_a = ty.storage_texture(Source{{12, 34}}, type::TextureDimension::k1d, params.format,
-                                   core::Access::kWrite);
+    auto st_a = ty.storage_texture(Source{{12, 34}}, core::type::TextureDimension::k1d,
+                                   params.format, core::Access::kWrite);
     GlobalVar("a", st_a, Group(0_a), Binding(0_a));
 
     ast::Type st_b =
-        ty.storage_texture(type::TextureDimension::k2d, params.format, core::Access::kWrite);
+        ty.storage_texture(core::type::TextureDimension::k2d, params.format, core::Access::kWrite);
     GlobalVar("b", st_b, Group(0_a), Binding(1_a));
 
-    ast::Type st_c =
-        ty.storage_texture(type::TextureDimension::k2dArray, params.format, core::Access::kWrite);
+    ast::Type st_c = ty.storage_texture(core::type::TextureDimension::k2dArray, params.format,
+                                        core::Access::kWrite);
     GlobalVar("c", st_c, Group(0_a), Binding(2_a));
 
     ast::Type st_d =
-        ty.storage_texture(type::TextureDimension::k3d, params.format, core::Access::kWrite);
+        ty.storage_texture(core::type::TextureDimension::k3d, params.format, core::Access::kWrite);
     GlobalVar("d", st_d, Group(0_a), Binding(3_a));
 
     if (params.is_valid) {
@@ -1147,7 +1147,7 @@
     // @group(0) @binding(0)
     // var a : texture_storage_1d<r32uint, read_write>;
 
-    auto st = ty.storage_texture(Source{{12, 34}}, type::TextureDimension::k1d,
+    auto st = ty.storage_texture(Source{{12, 34}}, core::type::TextureDimension::k1d,
                                  core::TexelFormat::kR32Uint, core::Access::kReadWrite);
 
     GlobalVar("a", st, Group(0_a), Binding(0_a));
@@ -1161,7 +1161,7 @@
     // @group(0) @binding(0)
     // var a : texture_storage_1d<r32uint, read>;
 
-    auto st = ty.storage_texture(Source{{12, 34}}, type::TextureDimension::k1d,
+    auto st = ty.storage_texture(Source{{12, 34}}, core::type::TextureDimension::k1d,
                                  core::TexelFormat::kR32Uint, core::Access::kRead);
 
     GlobalVar("a", st, Group(0_a), Binding(0_a));
@@ -1175,7 +1175,7 @@
     // @group(0) @binding(0)
     // var a : texture_storage_1d<r32uint, write>;
 
-    auto st = ty.storage_texture(type::TextureDimension::k1d, core::TexelFormat::kR32Uint,
+    auto st = ty.storage_texture(core::type::TextureDimension::k1d, core::TexelFormat::kR32Uint,
                                  core::Access::kWrite);
 
     GlobalVar("a", st, Group(0_a), Binding(0_a));
diff --git a/src/tint/lang/wgsl/resolver/uniformity.cc b/src/tint/lang/wgsl/resolver/uniformity.cc
index ced3391..8ed869b 100644
--- a/src/tint/lang/wgsl/resolver/uniformity.cc
+++ b/src/tint/lang/wgsl/resolver/uniformity.cc
@@ -201,7 +201,7 @@
             parameters[i].sem = sem;
 
             parameters[i].value = CreateNode({"param_", param_name});
-            if (sem->Type()->Is<type::Pointer>()) {
+            if (sem->Type()->Is<core::type::Pointer>()) {
                 // Create extra nodes for a pointer parameter's initial contents and its contents
                 // when the function returns.
                 parameters[i].ptr_input_contents =
@@ -442,7 +442,7 @@
         auto get_param_tag = [&](UniqueVector<Node*, 4>& reachable, size_t index) {
             auto* param = sem_.Get(func->params[index]);
             auto& param_info = current_function_->parameters[index];
-            if (param->Type()->Is<type::Pointer>()) {
+            if (param->Type()->Is<core::type::Pointer>()) {
                 // For pointers, we distinguish between requiring uniformity of the contents versus
                 // the pointer itself.
                 if (reachable.Contains(param_info.ptr_input_contents)) {
@@ -1134,7 +1134,7 @@
                     node = v;
 
                     // Store if lhs is a partial pointer
-                    if (sem_var->Type()->Is<type::Pointer>()) {
+                    if (sem_var->Type()->Is<core::type::Pointer>()) {
                         auto* init = sem_.Get(decl->variable->initializer);
                         if (auto* unary_init = init->Declaration()->As<ast::UnaryOpExpression>()) {
                             auto* e = UnwrapIndirectAndAddressOfChain(unary_init);
@@ -1221,7 +1221,7 @@
                     node->AddEdge(cf);
 
                     auto* current_value = current_function_->variables.Get(param);
-                    if (param->Type()->Is<type::Pointer>()) {
+                    if (param->Type()->Is<core::type::Pointer>()) {
                         if (load_rule) {
                             // We are loading from the pointer, so add an edge to its contents.
                             node->AddEdge(current_value);
@@ -1254,7 +1254,7 @@
                 node->AddEdge(cf);
 
                 auto* local_value = current_function_->variables.Get(local);
-                if (local->Type()->Is<type::Pointer>()) {
+                if (local->Type()->Is<core::type::Pointer>()) {
                     if (load_rule) {
                         // We are loading from the pointer, so add an edge to its contents.
                         auto* root = var_user->RootIdentifier();
@@ -1276,7 +1276,7 @@
                         // the pointer value itself.
                         node->AddEdge(local_value);
                     }
-                } else if (local->Type()->Is<type::Reference>()) {
+                } else if (local->Type()->Is<core::type::Reference>()) {
                     if (load_rule) {
                         // We are loading from the reference, so add an edge to its contents.
                         node->AddEdge(local_value);
@@ -1505,7 +1505,7 @@
             // For pointer arguments, create an additional node to represent the contents of that
             // pointer prior to the function call.
             auto* sem_arg = sem_.GetVal(call->args[i]);
-            if (sem_arg->Type()->Is<type::Pointer>()) {
+            if (sem_arg->Type()->Is<core::type::Pointer>()) {
                 auto* arg_contents =
                     CreateNode({name, "_ptrarg_", std::to_string(i), "_contents"}, call);
                 arg_contents->type = Node::kFunctionCallArgumentContents;
@@ -1632,7 +1632,7 @@
                 // Capture the effects of other call parameters on the contents of this parameter
                 // after the call returns.
                 auto* sem_arg = sem_.GetVal(call->args[i]);
-                if (sem_arg->Type()->Is<type::Pointer>()) {
+                if (sem_arg->Type()->Is<core::type::Pointer>()) {
                     auto* ptr_result =
                         CreateNode({name, "_ptrarg_", std::to_string(i), "_result"}, call);
                     ptr_result->type = Node::kFunctionCallPointerArgumentResult;
diff --git a/src/tint/lang/wgsl/resolver/validation_test.cc b/src/tint/lang/wgsl/resolver/validation_test.cc
index a3355f8..75e9e80 100644
--- a/src/tint/lang/wgsl/resolver/validation_test.cc
+++ b/src/tint/lang/wgsl/resolver/validation_test.cc
@@ -295,7 +295,7 @@
 }
 
 TEST_F(ResolverValidationTest, AddressSpace_SamplerExplicitAddressSpace) {
-    auto t = ty.sampler(type::SamplerKind::kSampler);
+    auto t = ty.sampler(core::type::SamplerKind::kSampler);
     GlobalVar(Source{{12, 34}}, "var", t, core::AddressSpace::kPrivate, Binding(0_a), Group(0_a));
 
     EXPECT_FALSE(r()->Resolve());
@@ -305,7 +305,7 @@
 }
 
 TEST_F(ResolverValidationTest, AddressSpace_TextureExplicitAddressSpace) {
-    auto t = ty.sampled_texture(type::TextureDimension::k1d, ty.f32());
+    auto t = ty.sampled_texture(core::type::TextureDimension::k1d, ty.f32());
     GlobalVar(Source{{12, 34}}, "var", t, core::AddressSpace::kFunction, Binding(0_a), Group(0_a));
 
     EXPECT_FALSE(r()->Resolve()) << r()->error();
diff --git a/src/tint/lang/wgsl/resolver/validator.cc b/src/tint/lang/wgsl/resolver/validator.cc
index c91d2fc..5e39cad 100644
--- a/src/tint/lang/wgsl/resolver/validator.cc
+++ b/src/tint/lang/wgsl/resolver/validator.cc
@@ -81,12 +81,12 @@
 constexpr size_t kMaxFunctionParameters = 255;
 constexpr size_t kMaxSwitchCaseSelectors = 16383;
 
-bool IsValidStorageTextureDimension(type::TextureDimension dim) {
+bool IsValidStorageTextureDimension(core::type::TextureDimension dim) {
     switch (dim) {
-        case type::TextureDimension::k1d:
-        case type::TextureDimension::k2d:
-        case type::TextureDimension::k2dArray:
-        case type::TextureDimension::k3d:
+        case core::type::TextureDimension::k1d:
+        case core::type::TextureDimension::k2d:
+        case core::type::TextureDimension::k2dArray:
+        case core::type::TextureDimension::k3d:
             return true;
         default:
             return false;
@@ -144,11 +144,12 @@
 
 }  // namespace
 
-Validator::Validator(ProgramBuilder* builder,
-                     SemHelper& sem,
-                     const core::Extensions& enabled_extensions,
-                     const Hashmap<const type::Type*, const Source*, 8>& atomic_composite_info,
-                     Hashset<TypeAndAddressSpace, 8>& valid_type_storage_layouts)
+Validator::Validator(
+    ProgramBuilder* builder,
+    SemHelper& sem,
+    const core::Extensions& enabled_extensions,
+    const Hashmap<const core::type::Type*, const Source*, 8>& atomic_composite_info,
+    Hashset<TypeAndAddressSpace, 8>& valid_type_storage_layouts)
     : symbols_(builder->Symbols()),
       diagnostics_(builder->Diagnostics()),
       sem_(sem),
@@ -195,23 +196,23 @@
 }
 
 // https://gpuweb.github.io/gpuweb/wgsl/#plain-types-section
-bool Validator::IsPlain(const type::Type* type) const {
-    return type->IsAnyOf<type::Scalar, type::Atomic, type::Vector, type::Matrix, type::Array,
-                         type::Struct>();
+bool Validator::IsPlain(const core::type::Type* type) const {
+    return type->IsAnyOf<core::type::Scalar, core::type::Atomic, core::type::Vector,
+                         core::type::Matrix, core::type::Array, core::type::Struct>();
 }
 
 // https://gpuweb.github.io/gpuweb/wgsl/#fixed-footprint-types
-bool Validator::IsFixedFootprint(const type::Type* type) const {
+bool Validator::IsFixedFootprint(const core::type::Type* type) const {
     return Switch(
-        type,                                       //
-        [&](const type::Vector*) { return true; },  //
-        [&](const type::Matrix*) { return true; },  //
-        [&](const type::Atomic*) { return true; },
-        [&](const type::Array* arr) {
-            return !arr->Count()->Is<type::RuntimeArrayCount>() &&
+        type,                                             //
+        [&](const core::type::Vector*) { return true; },  //
+        [&](const core::type::Matrix*) { return true; },  //
+        [&](const core::type::Atomic*) { return true; },
+        [&](const core::type::Array* arr) {
+            return !arr->Count()->Is<core::type::RuntimeArrayCount>() &&
                    IsFixedFootprint(arr->ElemType());
         },
-        [&](const type::Struct* str) {
+        [&](const core::type::Struct* str) {
             for (auto* member : str->Members()) {
                 if (!IsFixedFootprint(member->Type())) {
                     return false;
@@ -219,20 +220,20 @@
             }
             return true;
         },
-        [&](Default) { return type->Is<type::Scalar>(); });
+        [&](Default) { return type->Is<core::type::Scalar>(); });
 }
 
 // https://gpuweb.github.io/gpuweb/wgsl.html#host-shareable-types
-bool Validator::IsHostShareable(const type::Type* type) const {
-    if (type->IsAnyOf<type::I32, type::U32, type::F32, type::F16>()) {
+bool Validator::IsHostShareable(const core::type::Type* type) const {
+    if (type->IsAnyOf<core::type::I32, core::type::U32, core::type::F32, core::type::F16>()) {
         return true;
     }
     return Switch(
         type,  //
-        [&](const type::Vector* vec) { return IsHostShareable(vec->type()); },
-        [&](const type::Matrix* mat) { return IsHostShareable(mat->type()); },
-        [&](const type::Array* arr) { return IsHostShareable(arr->ElemType()); },
-        [&](const type::Struct* str) {
+        [&](const core::type::Vector* vec) { return IsHostShareable(vec->type()); },
+        [&](const core::type::Matrix* mat) { return IsHostShareable(mat->type()); },
+        [&](const core::type::Array* arr) { return IsHostShareable(arr->ElemType()); },
+        [&](const core::type::Struct* str) {
             for (auto* member : str->Members()) {
                 if (!IsHostShareable(member->Type())) {
                     return false;
@@ -240,12 +241,12 @@
             }
             return true;
         },
-        [&](const type::Atomic* atomic) { return IsHostShareable(atomic->Type()); });
+        [&](const core::type::Atomic* atomic) { return IsHostShareable(atomic->Type()); });
 }
 
 // https://gpuweb.github.io/gpuweb/wgsl.html#storable-types
-bool Validator::IsStorable(const type::Type* type) const {
-    return IsPlain(type) || type->IsAnyOf<type::Texture, type::Sampler>();
+bool Validator::IsStorable(const core::type::Type* type) const {
+    return IsPlain(type) || type->IsAnyOf<core::type::Texture, core::type::Sampler>();
 }
 
 const ast::Statement* Validator::ClosestContinuing(bool stop_at_loop,
@@ -274,17 +275,17 @@
     return nullptr;
 }
 
-bool Validator::Atomic(const ast::TemplatedIdentifier* a, const type::Atomic* s) const {
+bool Validator::Atomic(const ast::TemplatedIdentifier* a, const core::type::Atomic* s) const {
     // https://gpuweb.github.io/gpuweb/wgsl/#atomic-types
     // T must be either u32 or i32.
-    if (!s->Type()->IsAnyOf<type::U32, type::I32>()) {
+    if (!s->Type()->IsAnyOf<core::type::U32, core::type::I32>()) {
         AddError("atomic only supports i32 or u32 types", a->arguments[0]->source);
         return false;
     }
     return true;
 }
 
-bool Validator::Pointer(const ast::TemplatedIdentifier* a, const type::Pointer* s) const {
+bool Validator::Pointer(const ast::TemplatedIdentifier* a, const core::type::Pointer* s) const {
     if (s->AddressSpace() == core::AddressSpace::kUndefined) {
         AddError("ptr missing address space", a->source);
         return false;
@@ -306,7 +307,7 @@
                                        a->source);
 }
 
-bool Validator::StorageTexture(const type::StorageTexture* t, const Source& source) const {
+bool Validator::StorageTexture(const core::type::StorageTexture* t, const Source& source) const {
     switch (t->access()) {
         case core::Access::kWrite:
             break;
@@ -333,8 +334,8 @@
     return true;
 }
 
-bool Validator::SampledTexture(const type::SampledTexture* t, const Source& source) const {
-    if (!t->type()->UnwrapRef()->IsAnyOf<type::F32, type::I32, type::U32>()) {
+bool Validator::SampledTexture(const core::type::SampledTexture* t, const Source& source) const {
+    if (!t->type()->UnwrapRef()->IsAnyOf<core::type::F32, core::type::I32, core::type::U32>()) {
         AddError("texture_2d<type>: type must be f32, i32 or u32", source);
         return false;
     }
@@ -342,14 +343,14 @@
     return true;
 }
 
-bool Validator::MultisampledTexture(const type::MultisampledTexture* t,
+bool Validator::MultisampledTexture(const core::type::MultisampledTexture* t,
                                     const Source& source) const {
-    if (t->dim() != type::TextureDimension::k2d) {
+    if (t->dim() != core::type::TextureDimension::k2d) {
         AddError("only 2d multisampled textures are supported", source);
         return false;
     }
 
-    if (!t->type()->UnwrapRef()->IsAnyOf<type::F32, type::I32, type::U32>()) {
+    if (!t->type()->UnwrapRef()->IsAnyOf<core::type::F32, core::type::I32, core::type::U32>()) {
         AddError("texture_multisampled_2d<type>: type must be f32, i32 or u32", source);
         return false;
     }
@@ -357,10 +358,10 @@
     return true;
 }
 
-bool Validator::Materialize(const type::Type* to,
-                            const type::Type* from,
+bool Validator::Materialize(const core::type::Type* to,
+                            const core::type::Type* from,
                             const Source& source) const {
-    if (type::Type::ConversionRank(from, to) == type::Type::kNoConversion) {
+    if (core::type::Type::ConversionRank(from, to) == core::type::Type::kNoConversion) {
         AddError("cannot convert value of type '" + sem_.TypeNameOf(from) + "' to type '" +
                      sem_.TypeNameOf(to) + "'",
                  source);
@@ -370,7 +371,7 @@
 }
 
 bool Validator::VariableInitializer(const ast::Variable* v,
-                                    const type::Type* storage_ty,
+                                    const core::type::Type* storage_ty,
                                     const sem::ValueExpression* initializer) const {
     auto* initializer_ty = initializer->Type();
     auto* value_type = initializer_ty->UnwrapRef();  // Implicit load of RHS
@@ -387,21 +388,21 @@
     return true;
 }
 
-bool Validator::AddressSpaceLayout(const type::Type* store_ty,
+bool Validator::AddressSpaceLayout(const core::type::Type* store_ty,
                                    core::AddressSpace address_space,
                                    Source source) const {
     // https://gpuweb.github.io/gpuweb/wgsl/#storage-class-layout-constraints
 
-    auto is_uniform_struct_or_array = [address_space](const type::Type* ty) {
+    auto is_uniform_struct_or_array = [address_space](const core::type::Type* ty) {
         return address_space == core::AddressSpace::kUniform &&
-               ty->IsAnyOf<type::Array, type::Struct>();
+               ty->IsAnyOf<core::type::Array, core::type::Struct>();
     };
 
-    auto is_uniform_struct = [address_space](const type::Type* ty) {
-        return address_space == core::AddressSpace::kUniform && ty->Is<type::Struct>();
+    auto is_uniform_struct = [address_space](const core::type::Type* ty) {
+        return address_space == core::AddressSpace::kUniform && ty->Is<core::type::Struct>();
     };
 
-    auto required_alignment_of = [&](const type::Type* ty) {
+    auto required_alignment_of = [&](const core::type::Type* ty) {
         uint32_t actual_align = ty->Align();
         uint32_t required_align = actual_align;
         if (is_uniform_struct_or_array(ty)) {
@@ -410,7 +411,7 @@
         return required_align;
     };
 
-    auto member_name_of = [](const type::StructMember* sm) { return sm->Name().Name(); };
+    auto member_name_of = [](const core::type::StructMember* sm) { return sm->Name().Name(); };
 
     // Only validate the [type + address space] once
     if (!valid_type_storage_layouts_.Add(TypeAndAddressSpace{store_ty, address_space})) {
@@ -429,7 +430,7 @@
 
     // Among three host-shareable address spaces, f16 is supported in "uniform" and
     // "storage" address space, but not "push_constant" address space yet.
-    if (Is<type::F16>(store_ty->DeepestElement()) &&
+    if (Is<core::type::F16>(store_ty->DeepestElement()) &&
         address_space == core::AddressSpace::kPushConstant) {
         AddError("using f16 types in 'push_constant' address space is not implemented yet", source);
         return false;
@@ -501,7 +502,7 @@
     }
 
     // For uniform buffer array members, validate that array elements are aligned to 16 bytes
-    if (auto* arr = store_ty->As<type::Array>()) {
+    if (auto* arr = store_ty->As<core::type::Array>()) {
         // Recurse into the element type.
         // TODO(crbug.com/tint/1388): Ideally we'd pass the source for nested element type here, but
         // we can't easily get that from the semantic node. We should consider recursing through the
@@ -518,9 +519,9 @@
                 // Since WGSL has no stride attribute, try to provide a useful hint for how the
                 // shader author can resolve the issue.
                 std::string hint;
-                if (arr->ElemType()->Is<type::Scalar>()) {
+                if (arr->ElemType()->Is<core::type::Scalar>()) {
                     hint = "Consider using a vector or struct as the element type instead.";
-                } else if (auto* vec = arr->ElemType()->As<type::Vector>();
+                } else if (auto* vec = arr->ElemType()->As<core::type::Vector>();
                            vec && vec->type()->Size() == 4) {
                     hint = "Consider using a vec4 instead.";
                 } else if (arr->ElemType()->Is<sem::Struct>()) {
@@ -714,7 +715,7 @@
     auto* decl = v->Declaration();
     auto* storage_ty = v->Type()->UnwrapRef();
 
-    if (!(storage_ty->IsConstructible() || storage_ty->Is<type::Pointer>())) {
+    if (!(storage_ty->IsConstructible() || storage_ty->Is<core::type::Pointer>())) {
         AddError(sem_.TypeNameOf(storage_ty) + " cannot be used as the type of a 'let'",
                  decl->source);
         return false;
@@ -747,7 +748,7 @@
         }
     }
 
-    if (!storage_ty->Is<type::Scalar>()) {
+    if (!storage_ty->Is<core::type::Scalar>()) {
         AddError(sem_.TypeNameOf(storage_ty) + " cannot be used as the type of a 'override'",
                  decl->source);
         return false;
@@ -767,7 +768,7 @@
         return true;
     }
 
-    if (auto* ref = var->Type()->As<type::Pointer>()) {
+    if (auto* ref = var->Type()->As<core::type::Pointer>()) {
         if (IsValidationEnabled(decl->attributes, ast::DisabledValidation::kIgnoreAddressSpace)) {
             bool ok = false;
 
@@ -801,7 +802,8 @@
             AddError("type of function parameter must be constructible", decl->type->source);
             return false;
         }
-    } else if (!var->Type()->IsAnyOf<type::Texture, type::Sampler, type::Pointer>()) {
+    } else if (!var->Type()
+                    ->IsAnyOf<core::type::Texture, core::type::Sampler, core::type::Pointer>()) {
         AddError("type of function parameter cannot be " + sem_.TypeNameOf(var->Type()),
                  decl->source);
         return false;
@@ -811,7 +813,7 @@
 }
 
 bool Validator::BuiltinAttribute(const ast::BuiltinAttribute* attr,
-                                 const type::Type* storage_ty,
+                                 const core::type::Type* storage_ty,
                                  ast::PipelineStage stage,
                                  const bool is_input) const {
     auto* type = storage_ty->UnwrapRef();
@@ -827,7 +829,7 @@
                   (is_output && stage == ast::PipelineStage::kVertex))) {
                 is_stage_mismatch = true;
             }
-            if (!(type->is_float_vector() && type->As<type::Vector>()->Width() == 4)) {
+            if (!(type->is_float_vector() && type->As<core::type::Vector>()->Width() == 4)) {
                 StringStream err;
                 err << "store type of @builtin(" << builtin << ") must be 'vec4<f32>'";
                 AddError(err.str(), attr->source);
@@ -842,7 +844,8 @@
                 !(stage == ast::PipelineStage::kCompute && is_input)) {
                 is_stage_mismatch = true;
             }
-            if (!(type->is_unsigned_integer_vector() && type->As<type::Vector>()->Width() == 3)) {
+            if (!(type->is_unsigned_integer_vector() &&
+                  type->As<core::type::Vector>()->Width() == 3)) {
                 StringStream err;
                 err << "store type of @builtin(" << builtin << ") must be 'vec3<u32>'";
                 AddError(err.str(), attr->source);
@@ -854,7 +857,7 @@
                 !(stage == ast::PipelineStage::kFragment && !is_input)) {
                 is_stage_mismatch = true;
             }
-            if (!type->Is<type::F32>()) {
+            if (!type->Is<core::type::F32>()) {
                 StringStream err;
                 err << "store type of @builtin(" << builtin << ") must be 'f32'";
                 AddError(err.str(), attr->source);
@@ -866,7 +869,7 @@
                 !(stage == ast::PipelineStage::kFragment && is_input)) {
                 is_stage_mismatch = true;
             }
-            if (!type->Is<type::Bool>()) {
+            if (!type->Is<core::type::Bool>()) {
                 StringStream err;
                 err << "store type of @builtin(" << builtin << ") must be 'bool'";
                 AddError(err.str(), attr->source);
@@ -878,7 +881,7 @@
                 !(stage == ast::PipelineStage::kCompute && is_input)) {
                 is_stage_mismatch = true;
             }
-            if (!type->Is<type::U32>()) {
+            if (!type->Is<core::type::U32>()) {
                 StringStream err;
                 err << "store type of @builtin(" << builtin << ") must be 'u32'";
                 AddError(err.str(), attr->source);
@@ -891,7 +894,7 @@
                 !(stage == ast::PipelineStage::kVertex && is_input)) {
                 is_stage_mismatch = true;
             }
-            if (!type->Is<type::U32>()) {
+            if (!type->Is<core::type::U32>()) {
                 StringStream err;
                 err << "store type of @builtin(" << builtin << ") must be 'u32'";
                 AddError(err.str(), attr->source);
@@ -902,7 +905,7 @@
             if (stage != ast::PipelineStage::kNone && !(stage == ast::PipelineStage::kFragment)) {
                 is_stage_mismatch = true;
             }
-            if (!type->Is<type::U32>()) {
+            if (!type->Is<core::type::U32>()) {
                 StringStream err;
                 err << "store type of @builtin(" << builtin << ") must be 'u32'";
                 AddError(err.str(), attr->source);
@@ -914,7 +917,7 @@
                 !(stage == ast::PipelineStage::kFragment && is_input)) {
                 is_stage_mismatch = true;
             }
-            if (!type->Is<type::U32>()) {
+            if (!type->Is<core::type::U32>()) {
                 StringStream err;
                 err << "store type of @builtin(" << builtin << ") must be 'u32'";
                 AddError(err.str(), attr->source);
@@ -930,7 +933,7 @@
                 AddError(err.str(), attr->source);
                 return false;
             }
-            if (!type->Is<type::U32>()) {
+            if (!type->Is<core::type::U32>()) {
                 StringStream err;
                 err << "store type of @builtin(" << builtin << ") must be 'u32'";
                 AddError(err.str(), attr->source);
@@ -959,7 +962,7 @@
 }
 
 bool Validator::InterpolateAttribute(const ast::InterpolateAttribute* attr,
-                                     const type::Type* storage_ty) const {
+                                     const core::type::Type* storage_ty) const {
     auto* type = storage_ty->UnwrapRef();
 
     auto i_type = sem_.AsInterpolationType(sem_.Get(attr->type));
@@ -995,7 +998,7 @@
                 return true;
             },
             [&](const ast::MustUseAttribute*) {
-                if (func->ReturnType()->Is<type::Void>()) {
+                if (func->ReturnType()->Is<core::type::Void>()) {
                     AddError("@must_use can only be applied to functions that return a value",
                              attr->source);
                     return false;
@@ -1015,7 +1018,7 @@
         return false;
     }
 
-    if (!func->ReturnType()->Is<type::Void>()) {
+    if (!func->ReturnType()->Is<core::type::Void>()) {
         if (!func->ReturnType()->IsConstructible()) {
             AddError("function return type must be a constructible type",
                      decl->return_type->source);
@@ -1071,7 +1074,7 @@
 
     // Inner lambda that is applied to a type and all of its members.
     auto validate_entry_point_attributes_inner = [&](VectorRef<const ast::Attribute*> attrs,
-                                                     const type::Type* ty, Source source,
+                                                     const core::type::Type* ty, Source source,
                                                      ParamOrRetType param_or_ret,
                                                      bool is_struct_member,
                                                      std::optional<uint32_t> location,
@@ -1156,12 +1159,12 @@
         }
 
         if (IsValidationEnabled(attrs, ast::DisabledValidation::kEntryPointParameter)) {
-            if (is_struct_member && ty->Is<type::Struct>()) {
+            if (is_struct_member && ty->Is<core::type::Struct>()) {
                 AddError("nested structures cannot be used for entry point IO", source);
                 return false;
             }
 
-            if (!ty->Is<type::Struct>() && !pipeline_io_attribute) {
+            if (!ty->Is<core::type::Struct>() && !pipeline_io_attribute) {
                 std::string err = "missing entry point IO attribute";
                 if (!is_struct_member) {
                     err += (param_or_ret == ParamOrRetType::kParameter ? " on parameter"
@@ -1258,7 +1261,7 @@
 
     // Outer lambda for validating the entry point attributes for a type.
     auto validate_entry_point_attributes = [&](VectorRef<const ast::Attribute*> attrs,
-                                               const type::Type* ty, Source source,
+                                               const core::type::Type* ty, Source source,
                                                ParamOrRetType param_or_ret,
                                                std::optional<uint32_t> location,
                                                std::optional<uint32_t> index) {
@@ -1298,7 +1301,7 @@
     builtins.Clear();
     locationsAndIndexes.Clear();
 
-    if (!func->ReturnType()->Is<type::Void>()) {
+    if (!func->ReturnType()->Is<core::type::Void>()) {
         if (!validate_entry_point_attributes(decl->return_type_attributes, func->ReturnType(),
                                              decl->source, ParamOrRetType::kReturnType,
                                              func->ReturnLocation(), func->ReturnIndex())) {
@@ -1420,7 +1423,7 @@
     return true;
 }
 
-bool Validator::Bitcast(const ast::BitcastExpression* cast, const type::Type* to) const {
+bool Validator::Bitcast(const ast::BitcastExpression* cast, const core::type::Type* to) const {
     auto* from = sem_.TypeOf(cast->expr)->UnwrapRef();
     if (!from->is_numeric_scalar_or_vector()) {
         AddError("'" + sem_.TypeNameOf(from) + "' cannot be bitcast", cast->expr->source);
@@ -1529,7 +1532,7 @@
     }
     if (auto* cond = stmt->Condition()) {
         auto* cond_ty = cond->Type()->UnwrapRef();
-        if (!cond_ty->Is<type::Bool>()) {
+        if (!cond_ty->Is<core::type::Bool>()) {
             AddError("for-loop condition must be bool, got " + sem_.TypeNameOf(cond_ty),
                      stmt->Condition()->Declaration()->source);
             return false;
@@ -1545,7 +1548,7 @@
     }
     if (auto* cond = stmt->Condition()) {
         auto* cond_ty = cond->Type()->UnwrapRef();
-        if (!cond_ty->Is<type::Bool>()) {
+        if (!cond_ty->Is<core::type::Bool>()) {
             AddError("while condition must be bool, got " + sem_.TypeNameOf(cond_ty),
                      stmt->Condition()->Declaration()->source);
             return false;
@@ -1557,7 +1560,7 @@
 bool Validator::BreakIfStatement(const sem::BreakIfStatement* stmt,
                                  sem::Statement* current_statement) const {
     auto* cond_ty = stmt->Condition()->Type()->UnwrapRef();
-    if (!cond_ty->Is<type::Bool>()) {
+    if (!cond_ty->Is<core::type::Bool>()) {
         AddError("break-if statement condition must be bool, got " + sem_.TypeNameOf(cond_ty),
                  stmt->Condition()->Declaration()->source);
         return false;
@@ -1584,7 +1587,7 @@
 
 bool Validator::IfStatement(const sem::IfStatement* stmt) const {
     auto* cond_ty = stmt->Condition()->Type()->UnwrapRef();
-    if (!cond_ty->Is<type::Bool>()) {
+    if (!cond_ty->Is<core::type::Bool>()) {
         AddError("if statement condition must be bool, got " + sem_.TypeNameOf(cond_ty),
                  stmt->Condition()->Declaration()->source);
         return false;
@@ -1593,7 +1596,7 @@
 }
 
 bool Validator::BuiltinCall(const sem::Call* call) const {
-    if (call->Type()->Is<type::Void>()) {
+    if (call->Type()->Is<core::type::Void>()) {
         bool is_call_statement = false;
         // Some built-in call are not owned by a statement, e.g. a built-in called in global
         // variable declaration. Calling no-return-value built-in in these context is invalid as
@@ -1637,7 +1640,7 @@
         std::string name{core::ToString(usage)};
         auto* arg = call->Arguments()[index];
         if (auto values = arg->ConstantValue()) {
-            if (auto* vector = values->Type()->As<type::Vector>()) {
+            if (auto* vector = values->Type()->As<core::type::Vector>()) {
                 for (size_t i = 0; i < vector->Width(); i++) {
                     auto value = values->Index(i)->ValueAs<AInt>();
                     if (value < min || value > max) {
@@ -1678,11 +1681,11 @@
 
     TINT_ASSERT(call->Arguments().Length() > 0);
     auto* arg = call->Arguments()[0];
-    auto* ptr = arg->Type()->As<type::Pointer>();
+    auto* ptr = arg->Type()->As<core::type::Pointer>();
     TINT_ASSERT(ptr != nullptr);
     auto* ty = ptr->StoreType();
 
-    if (ty->Is<type::Atomic>() || atomic_composite_info_.Contains(ty)) {
+    if (ty->Is<core::type::Atomic>() || atomic_composite_info_.Contains(ty)) {
         AddError(
             "workgroupUniformLoad must not be called with an argument that contains an atomic type",
             arg->Declaration()->source);
@@ -1764,7 +1767,7 @@
             return false;
         }
 
-        if (param_type->Is<type::Pointer>() &&
+        if (param_type->Is<core::type::Pointer>() &&
             !enabled_extensions_.Contains(
                 core::Extension::kChromiumExperimentalFullPtrParameters)) {
             // https://gpuweb.github.io/gpuweb/wgsl/#function-restriction
@@ -1772,12 +1775,12 @@
             // view as its root identifier.
             // We can validate this by just comparing the store type of the argument with that of
             // its root identifier, as these will match iff the memory view is the same.
-            auto* arg_store_type = arg_type->As<type::Pointer>()->StoreType();
+            auto* arg_store_type = arg_type->As<core::type::Pointer>()->StoreType();
             auto* root = call->Arguments()[i]->RootIdentifier();
-            auto* root_ptr_ty = root->Type()->As<type::Pointer>();
-            auto* root_ref_ty = root->Type()->As<type::Reference>();
+            auto* root_ptr_ty = root->Type()->As<core::type::Pointer>();
+            auto* root_ref_ty = root->Type()->As<core::type::Reference>();
             TINT_ASSERT(root_ptr_ty || root_ref_ty);
-            const type::Type* root_store_type;
+            const core::type::Type* root_store_type;
             if (root_ptr_ty) {
                 root_store_type = root_ptr_ty->StoreType();
             } else {
@@ -1795,7 +1798,7 @@
         }
     }
 
-    if (call->Type()->Is<type::Void>()) {
+    if (call->Type()->Is<core::type::Void>()) {
         bool is_call_statement = false;
         if (auto* call_stmt = As<ast::CallStatement>(call->Stmt()->Declaration())) {
             if (call_stmt->expr == call->Declaration()) {
@@ -1815,7 +1818,7 @@
 }
 
 bool Validator::StructureInitializer(const ast::CallExpression* ctor,
-                                     const type::Struct* struct_type) const {
+                                     const core::type::Struct* struct_type) const {
     if (!struct_type->IsConstructible()) {
         AddError("structure constructor has non-constructible type", ctor->source);
         return false;
@@ -1847,12 +1850,13 @@
 }
 
 bool Validator::ArrayConstructor(const ast::CallExpression* ctor,
-                                 const type::Array* array_type) const {
+                                 const core::type::Array* array_type) const {
     auto& values = ctor->args;
     auto* elem_ty = array_type->ElemType();
     for (auto* value : values) {
         auto* value_ty = sem_.TypeOf(value)->UnwrapRef();
-        if (type::Type::ConversionRank(value_ty, elem_ty) == type::Type::kNoConversion) {
+        if (core::type::Type::ConversionRank(value_ty, elem_ty) ==
+            core::type::Type::kNoConversion) {
             AddError("'" + sem_.TypeNameOf(value_ty) +
                          "' cannot be used to construct an array of '" + sem_.TypeNameOf(elem_ty) +
                          "'",
@@ -1862,7 +1866,7 @@
     }
 
     auto* c = array_type->Count();
-    if (c->Is<type::RuntimeArrayCount>()) {
+    if (c->Is<core::type::RuntimeArrayCount>()) {
         AddError("cannot construct a runtime-sized array", ctor->source);
         return false;
     }
@@ -1877,12 +1881,12 @@
         return false;
     }
 
-    if (TINT_UNLIKELY(!c->Is<type::ConstantArrayCount>())) {
+    if (TINT_UNLIKELY(!c->Is<core::type::ConstantArrayCount>())) {
         TINT_ICE() << "Invalid ArrayCount found";
         return false;
     }
 
-    const auto count = c->As<type::ConstantArrayCount>()->value;
+    const auto count = c->As<core::type::ConstantArrayCount>()->value;
     if (!values.IsEmpty() && (values.Length() != count)) {
         std::string fm = values.Length() < count ? "few" : "many";
         AddError("array constructor has too " + fm + " elements: expected " +
@@ -1893,15 +1897,15 @@
     return true;
 }
 
-bool Validator::Vector(const type::Type* el_ty, const Source& source) const {
-    if (!el_ty->Is<type::Scalar>()) {
+bool Validator::Vector(const core::type::Type* el_ty, const Source& source) const {
+    if (!el_ty->Is<core::type::Scalar>()) {
         AddError("vector element type must be 'bool', 'f32', 'f16', 'i32' or 'u32'", source);
         return false;
     }
     return true;
 }
 
-bool Validator::Matrix(const type::Type* el_ty, const Source& source) const {
+bool Validator::Matrix(const core::type::Type* el_ty, const Source& source) const {
     if (!el_ty->is_float_scalar()) {
         AddError("matrix element type must be 'f32' or 'f16'", source);
         return false;
@@ -2070,7 +2074,7 @@
     return true;
 }
 
-bool Validator::Array(const type::Array* arr, const Source& el_source) const {
+bool Validator::Array(const core::type::Array* arr, const Source& el_source) const {
     auto* el_ty = arr->ElemType();
 
     if (!IsPlain(el_ty)) {
@@ -2123,8 +2127,8 @@
 
     Hashset<std::pair<uint32_t, uint32_t>, 8> locationsAndIndexes;
     for (auto* member : str->Members()) {
-        if (auto* r = member->Type()->As<type::Array>()) {
-            if (r->Count()->Is<type::RuntimeArrayCount>()) {
+        if (auto* r = member->Type()->As<core::type::Array>()) {
+            if (r->Count()->Is<core::type::RuntimeArrayCount>()) {
                 if (member != str->Members().Back()) {
                     AddError("runtime arrays may only appear as the last member of a struct",
                              member->Declaration()->source);
@@ -2259,7 +2263,7 @@
 }
 
 bool Validator::LocationAttribute(const ast::LocationAttribute* loc_attr,
-                                  const type::Type* type,
+                                  const core::type::Type* type,
                                   ast::PipelineStage stage,
                                   const Source& source,
                                   const bool is_input) const {
@@ -2309,8 +2313,8 @@
 }
 
 bool Validator::Return(const ast::ReturnStatement* ret,
-                       const type::Type* func_type,
-                       const type::Type* ret_type,
+                       const core::type::Type* func_type,
+                       const core::type::Type* ret_type,
                        sem::Statement* current_statement) const {
     if (func_type->UnwrapRef() != ret_type) {
         AddError("return statement type must match its function return type, returned '" +
@@ -2376,7 +2380,7 @@
             auto value = selector->Value()->ValueAs<u32>();
             if (auto added = selectors.Add(value, selector->Declaration()->source); !added) {
                 AddError("duplicate switch case '" +
-                             (decl_ty->IsAnyOf<type::I32, type::AbstractNumeric>()
+                             (decl_ty->IsAnyOf<core::type::I32, core::type::AbstractNumeric>()
                                   ? std::to_string(i32(value))
                                   : std::to_string(value)) +
                              "'",
@@ -2396,7 +2400,7 @@
     return true;
 }
 
-bool Validator::Assignment(const ast::Statement* a, const type::Type* rhs_ty) const {
+bool Validator::Assignment(const ast::Statement* a, const core::type::Type* rhs_ty) const {
     const ast::Expression* lhs;
     const ast::Expression* rhs;
     if (auto* assign = a->As<ast::AssignmentStatement>()) {
@@ -2414,7 +2418,8 @@
         // https://www.w3.org/TR/WGSL/#phony-assignment-section
         auto* ty = rhs_ty->UnwrapRef();
         if (!ty->IsConstructible() &&
-            !ty->IsAnyOf<type::Pointer, type::Texture, type::Sampler, type::AbstractNumeric>()) {
+            !ty->IsAnyOf<core::type::Pointer, core::type::Texture, core::type::Sampler,
+                         core::type::AbstractNumeric>()) {
             AddError("cannot assign '" + sem_.TypeNameOf(rhs_ty) +
                          "' to '_'. '_' can only be assigned a constructible, pointer, texture or "
                          "sampler type",
@@ -2428,7 +2433,7 @@
     auto const* lhs_sem = sem_.GetVal(lhs);
     auto const* lhs_ty = lhs_sem->Type();
 
-    auto* lhs_ref = lhs_ty->As<type::Reference>();
+    auto* lhs_ref = lhs_ty->As<core::type::Reference>();
     if (!lhs_ref) {
         // LHS is not a reference, so it has no storage.
         AddError("cannot assign to " + sem_.Describe(lhs_sem), lhs->source);
@@ -2511,7 +2516,7 @@
     }
 
     auto const* lhs_ty = sem_.TypeOf(lhs);
-    auto* lhs_ref = lhs_ty->As<type::Reference>();
+    auto* lhs_ref = lhs_ty->As<core::type::Reference>();
     if (!lhs_ref) {
         // LHS is not a reference, so it has no storage.
         AddError("cannot modify value of type '" + sem_.TypeNameOf(lhs_ty) + "'", lhs->source);
@@ -2595,8 +2600,8 @@
     return !IsValidationDisabled(attributes, validation);
 }
 
-bool Validator::IsArrayWithOverrideCount(const type::Type* ty) const {
-    if (auto* arr = ty->UnwrapRef()->As<type::Array>()) {
+bool Validator::IsArrayWithOverrideCount(const core::type::Type* ty) const {
+    if (auto* arr = ty->UnwrapRef()->As<core::type::Array>()) {
         if (arr->Count()->IsAnyOf<sem::NamedOverrideArrayCount, sem::UnnamedOverrideArrayCount>()) {
             return true;
         }
@@ -2611,12 +2616,12 @@
         source);
 }
 
-std::string Validator::VectorPretty(uint32_t size, const type::Type* element_type) const {
-    type::Vector vec_type(element_type, size);
+std::string Validator::VectorPretty(uint32_t size, const core::type::Type* element_type) const {
+    core::type::Vector vec_type(element_type, size);
     return vec_type.FriendlyName();
 }
 
-bool Validator::CheckTypeAccessAddressSpace(const type::Type* store_ty,
+bool Validator::CheckTypeAccessAddressSpace(const core::type::Type* store_ty,
                                             core::Access access,
                                             core::AddressSpace address_space,
                                             VectorRef<const tint::ast::Attribute*> attributes,
@@ -2667,15 +2672,15 @@
 
     return Switch(
         store_ty,  //
-        [&](const type::Atomic*) {
+        [&](const core::type::Atomic*) {
             if (auto* err = atomic_error()) {
                 AddError(err, source);
                 return false;
             }
             return true;
         },
-        [&](const type::Struct*) { return check_sub_atomics(); },  //
-        [&](const type::Array*) { return check_sub_atomics(); },   //
+        [&](const core::type::Struct*) { return check_sub_atomics(); },  //
+        [&](const core::type::Array*) { return check_sub_atomics(); },   //
         [&](Default) { return true; });
 }
 
diff --git a/src/tint/lang/wgsl/resolver/validator.h b/src/tint/lang/wgsl/resolver/validator.h
index dfd4f56..40c6cfb 100644
--- a/src/tint/lang/wgsl/resolver/validator.h
+++ b/src/tint/lang/wgsl/resolver/validator.h
@@ -63,16 +63,16 @@
 class SwitchStatement;
 class WhileStatement;
 }  // namespace tint::sem
-namespace tint::type {
+namespace tint::core::type {
 class Atomic;
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 namespace tint::resolver {
 
 /// TypeAndAddressSpace is a pair of type and address space
 struct TypeAndAddressSpace {
     /// The type
-    const type::Type* type;
+    const core::type::Type* type;
     /// The address space
     core::AddressSpace address_space;
 
@@ -102,7 +102,7 @@
     Validator(ProgramBuilder* builder,
               SemHelper& helper,
               const core::Extensions& enabled_extensions,
-              const Hashmap<const type::Type*, const Source*, 8>& atomic_composite_info,
+              const Hashmap<const core::type::Type*, const Source*, 8>& atomic_composite_info,
               Hashset<TypeAndAddressSpace, 8>& valid_type_storage_layouts);
     ~Validator();
 
@@ -135,19 +135,19 @@
 
     /// @param type the given type
     /// @returns true if the given type is a plain type
-    bool IsPlain(const type::Type* type) const;
+    bool IsPlain(const core::type::Type* type) const;
 
     /// @param type the given type
     /// @returns true if the given type is a fixed-footprint type
-    bool IsFixedFootprint(const type::Type* type) const;
+    bool IsFixedFootprint(const core::type::Type* type) const;
 
     /// @param type the given type
     /// @returns true if the given type is storable
-    bool IsStorable(const type::Type* type) const;
+    bool IsStorable(const core::type::Type* type) const;
 
     /// @param type the given type
     /// @returns true if the given type is host-shareable
-    bool IsHostShareable(const type::Type* type) const;
+    bool IsHostShareable(const core::type::Type* type) const;
 
     /// Validates pipeline stages
     /// @param entry_points the entry points to the module
@@ -169,7 +169,7 @@
     /// @param el_source the source of the array element, or the array if the array does not have a
     ///        locally-declared element AST node.
     /// @returns true on success, false otherwise.
-    bool Array(const type::Array* arr, const Source& el_source) const;
+    bool Array(const core::type::Array* arr, const Source& el_source) const;
 
     /// Validates an array stride attribute
     /// @param attr the stride attribute to validate
@@ -184,25 +184,25 @@
     /// @param a the atomic ast node
     /// @param s the atomic sem node
     /// @returns true on success, false otherwise.
-    bool Atomic(const ast::TemplatedIdentifier* a, const type::Atomic* s) const;
+    bool Atomic(const ast::TemplatedIdentifier* a, const core::type::Atomic* s) const;
 
     /// Validates a pointer type
     /// @param a the pointer ast node
     /// @param s the pointer sem node
     /// @returns true on success, false otherwise.
-    bool Pointer(const ast::TemplatedIdentifier* a, const type::Pointer* s) const;
+    bool Pointer(const ast::TemplatedIdentifier* a, const core::type::Pointer* s) const;
 
     /// Validates an assignment
     /// @param a the assignment statement
     /// @param rhs_ty the type of the right hand side
     /// @returns true on success, false otherwise.
-    bool Assignment(const ast::Statement* a, const type::Type* rhs_ty) const;
+    bool Assignment(const ast::Statement* a, const core::type::Type* rhs_ty) const;
 
     /// Validates a bitcase
     /// @param cast the bitcast expression
     /// @param to the destination type
     /// @returns true on success, false otherwise
-    bool Bitcast(const ast::BitcastExpression* cast, const type::Type* to) const;
+    bool Bitcast(const ast::BitcastExpression* cast, const core::type::Type* to) const;
 
     /// Validates a break statement
     /// @param stmt the break statement to validate
@@ -217,7 +217,7 @@
     /// @param is_input true if this is an input attribute
     /// @returns true on success, false otherwise.
     bool BuiltinAttribute(const ast::BuiltinAttribute* attr,
-                          const type::Type* storage_type,
+                          const core::type::Type* storage_type,
                           ast::PipelineStage stage,
                           const bool is_input) const;
 
@@ -299,7 +299,7 @@
     /// @param storage_type the storage type of the attached variable
     /// @returns true on succes, false otherwise
     bool InterpolateAttribute(const ast::InterpolateAttribute* attr,
-                              const type::Type* storage_type) const;
+                              const core::type::Type* storage_type) const;
 
     /// Validates a builtin call
     /// @param call the builtin call to validate
@@ -319,7 +319,7 @@
     /// @param is_input true if this is an input variable
     /// @returns true on success, false otherwise.
     bool LocationAttribute(const ast::LocationAttribute* loc_attr,
-                           const type::Type* type,
+                           const core::type::Type* type,
                            ast::PipelineStage stage,
                            const Source& source,
                            const bool is_input = false) const;
@@ -340,13 +340,15 @@
     /// @param from the abstract numeric type
     /// @param source the source of the materialization
     /// @returns true on success, false otherwise
-    bool Materialize(const type::Type* to, const type::Type* from, const Source& source) const;
+    bool Materialize(const core::type::Type* to,
+                     const core::type::Type* from,
+                     const Source& source) const;
 
     /// Validates a matrix
     /// @param el_ty the matrix element type to validate
     /// @param source the source of the matrix
     /// @returns true on success, false otherwise
-    bool Matrix(const type::Type* el_ty, const Source& source) const;
+    bool Matrix(const core::type::Type* el_ty, const Source& source) const;
 
     /// Validates a function parameter
     /// @param var the variable to validate
@@ -360,8 +362,8 @@
     /// @param current_statement the current statement being resolved
     /// @returns true on success, false otherwise
     bool Return(const ast::ReturnStatement* ret,
-                const type::Type* func_type,
-                const type::Type* ret_type,
+                const core::type::Type* func_type,
+                const core::type::Type* ret_type,
                 sem::Statement* current_statement) const;
 
     /// Validates a list of statements
@@ -373,19 +375,19 @@
     /// @param t the texture to validate
     /// @param source the source of the texture
     /// @returns true on success, false otherwise
-    bool StorageTexture(const type::StorageTexture* t, const Source& source) const;
+    bool StorageTexture(const core::type::StorageTexture* t, const Source& source) const;
 
     /// Validates a sampled texture
     /// @param t the texture to validate
     /// @param source the source of the texture
     /// @returns true on success, false otherwise
-    bool SampledTexture(const type::SampledTexture* t, const Source& source) const;
+    bool SampledTexture(const core::type::SampledTexture* t, const Source& source) const;
 
     /// Validates a multisampled texture
     /// @param t the texture to validate
     /// @param source the source of the texture
     /// @returns true on success, false otherwise
-    bool MultisampledTexture(const type::MultisampledTexture* t, const Source& source) const;
+    bool MultisampledTexture(const core::type::MultisampledTexture* t, const Source& source) const;
 
     /// Validates a structure
     /// @param str the structure to validate
@@ -398,7 +400,7 @@
     /// @param struct_type the type of the structure
     /// @returns true on success, false otherwise
     bool StructureInitializer(const ast::CallExpression* ctor,
-                              const type::Struct* struct_type) const;
+                              const core::type::Struct* struct_type) const;
 
     /// Validates a switch statement
     /// @param s the switch to validate
@@ -433,20 +435,20 @@
     /// @param initializer the RHS initializer expression
     /// @returns true on succes, false otherwise
     bool VariableInitializer(const ast::Variable* v,
-                             const type::Type* storage_type,
+                             const core::type::Type* storage_type,
                              const sem::ValueExpression* initializer) const;
 
     /// Validates a vector
     /// @param el_ty the vector element type to validate
     /// @param source the source of the vector
     /// @returns true on success, false otherwise
-    bool Vector(const type::Type* el_ty, const Source& source) const;
+    bool Vector(const core::type::Type* el_ty, const Source& source) const;
 
     /// Validates an array constructor
     /// @param ctor the call expresion to validate
     /// @param arr_type the type of the array
     /// @returns true on success, false otherwise
-    bool ArrayConstructor(const ast::CallExpression* ctor, const type::Array* arr_type) const;
+    bool ArrayConstructor(const ast::CallExpression* ctor, const core::type::Array* arr_type) const;
 
     /// Validates a texture builtin function
     /// @param call the builtin call to validate
@@ -485,7 +487,9 @@
     /// @param sc the address space
     /// @param source the source of the type
     /// @returns true on success, false otherwise
-    bool AddressSpaceLayout(const type::Type* type, core::AddressSpace sc, Source source) const;
+    bool AddressSpaceLayout(const core::type::Type* type,
+                            core::AddressSpace sc,
+                            Source source) const;
 
     /// @returns true if the attribute list contains a
     /// ast::DisableValidationAttribute with the validation mode equal to
@@ -507,7 +511,7 @@
     /// @param ty the type to check
     /// @returns true if @p ty is an array with an `override` expression element count, otherwise
     ///          false.
-    bool IsArrayWithOverrideCount(const type::Type* ty) const;
+    bool IsArrayWithOverrideCount(const core::type::Type* ty) const;
 
     /// Raises an error about an array type using an `override` expression element count, outside
     /// the single allowed use of a `var<workgroup>`.
@@ -529,7 +533,7 @@
     /// @param size the vector dimension
     /// @param element_type scalar vector sub-element type
     /// @return pretty string representation
-    std::string VectorPretty(uint32_t size, const type::Type* element_type) const;
+    std::string VectorPretty(uint32_t size, const core::type::Type* element_type) const;
 
     /// Raises an error if combination of @p store_ty, @p access and @p address_space are not valid
     /// for a `var` or `ptr` declaration.
@@ -538,7 +542,7 @@
     /// @param address_space the var or pointer address space
     /// @param source the source for the error
     /// @returns true on success, false if an error was raised.
-    bool CheckTypeAccessAddressSpace(const type::Type* store_ty,
+    bool CheckTypeAccessAddressSpace(const core::type::Type* store_ty,
                                      core::Access access,
                                      core::AddressSpace address_space,
                                      VectorRef<const tint::ast::Attribute*> attributes,
@@ -548,7 +552,7 @@
     SemHelper& sem_;
     DiagnosticFilterStack diagnostic_filters_;
     const core::Extensions& enabled_extensions_;
-    const Hashmap<const type::Type*, const Source*, 8>& atomic_composite_info_;
+    const Hashmap<const core::type::Type*, const Source*, 8>& atomic_composite_info_;
     Hashset<TypeAndAddressSpace, 8>& valid_type_storage_layouts_;
 };
 
diff --git a/src/tint/lang/wgsl/resolver/validator_is_storeable_test.cc b/src/tint/lang/wgsl/resolver/validator_is_storeable_test.cc
index 29dc947..8674a75 100644
--- a/src/tint/lang/wgsl/resolver/validator_is_storeable_test.cc
+++ b/src/tint/lang/wgsl/resolver/validator_is_storeable_test.cc
@@ -24,79 +24,79 @@
 using ValidatorIsStorableTest = ResolverTest;
 
 TEST_F(ValidatorIsStorableTest, Void) {
-    EXPECT_FALSE(v()->IsStorable(create<type::Void>()));
+    EXPECT_FALSE(v()->IsStorable(create<core::type::Void>()));
 }
 
 TEST_F(ValidatorIsStorableTest, Scalar) {
-    EXPECT_TRUE(v()->IsStorable(create<type::Bool>()));
-    EXPECT_TRUE(v()->IsStorable(create<type::I32>()));
-    EXPECT_TRUE(v()->IsStorable(create<type::U32>()));
-    EXPECT_TRUE(v()->IsStorable(create<type::F32>()));
-    EXPECT_TRUE(v()->IsStorable(create<type::F16>()));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Bool>()));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::I32>()));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::U32>()));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::F32>()));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::F16>()));
 }
 
 TEST_F(ValidatorIsStorableTest, Vector) {
-    EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::I32>(), 2u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::I32>(), 3u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::I32>(), 4u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::U32>(), 2u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::U32>(), 3u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::U32>(), 4u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::F32>(), 2u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::F32>(), 3u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::F32>(), 4u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::F16>(), 2u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::F16>(), 3u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Vector>(create<type::F16>(), 4u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Vector>(create<core::type::I32>(), 2u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Vector>(create<core::type::I32>(), 3u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Vector>(create<core::type::I32>(), 4u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Vector>(create<core::type::U32>(), 2u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Vector>(create<core::type::U32>(), 3u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Vector>(create<core::type::U32>(), 4u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Vector>(create<core::type::F32>(), 2u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Vector>(create<core::type::F32>(), 3u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Vector>(create<core::type::F32>(), 4u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Vector>(create<core::type::F16>(), 2u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Vector>(create<core::type::F16>(), 3u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Vector>(create<core::type::F16>(), 4u)));
 }
 
 TEST_F(ValidatorIsStorableTest, Matrix) {
-    auto* vec2_f32 = create<type::Vector>(create<type::F32>(), 2u);
-    auto* vec3_f32 = create<type::Vector>(create<type::F32>(), 3u);
-    auto* vec4_f32 = create<type::Vector>(create<type::F32>(), 4u);
-    auto* vec2_f16 = create<type::Vector>(create<type::F16>(), 2u);
-    auto* vec3_f16 = create<type::Vector>(create<type::F16>(), 3u);
-    auto* vec4_f16 = create<type::Vector>(create<type::F16>(), 4u);
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec2_f32, 2u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec2_f32, 3u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec2_f32, 4u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec3_f32, 2u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec3_f32, 3u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec3_f32, 4u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec4_f32, 2u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec4_f32, 3u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec4_f32, 4u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec2_f16, 2u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec2_f16, 3u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec2_f16, 4u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec3_f16, 2u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec3_f16, 3u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec3_f16, 4u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec4_f16, 2u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec4_f16, 3u)));
-    EXPECT_TRUE(v()->IsStorable(create<type::Matrix>(vec4_f16, 4u)));
+    auto* vec2_f32 = create<core::type::Vector>(create<core::type::F32>(), 2u);
+    auto* vec3_f32 = create<core::type::Vector>(create<core::type::F32>(), 3u);
+    auto* vec4_f32 = create<core::type::Vector>(create<core::type::F32>(), 4u);
+    auto* vec2_f16 = create<core::type::Vector>(create<core::type::F16>(), 2u);
+    auto* vec3_f16 = create<core::type::Vector>(create<core::type::F16>(), 3u);
+    auto* vec4_f16 = create<core::type::Vector>(create<core::type::F16>(), 4u);
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec2_f32, 2u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec2_f32, 3u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec2_f32, 4u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec3_f32, 2u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec3_f32, 3u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec3_f32, 4u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec4_f32, 2u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec4_f32, 3u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec4_f32, 4u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec2_f16, 2u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec2_f16, 3u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec2_f16, 4u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec3_f16, 2u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec3_f16, 3u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec3_f16, 4u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec4_f16, 2u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec4_f16, 3u)));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Matrix>(vec4_f16, 4u)));
 }
 
 TEST_F(ValidatorIsStorableTest, Pointer) {
-    auto* ptr = create<type::Pointer>(core::AddressSpace::kPrivate, create<type::I32>(),
-                                      core::Access::kReadWrite);
+    auto* ptr = create<core::type::Pointer>(core::AddressSpace::kPrivate, create<core::type::I32>(),
+                                            core::Access::kReadWrite);
     EXPECT_FALSE(v()->IsStorable(ptr));
 }
 
 TEST_F(ValidatorIsStorableTest, Atomic) {
-    EXPECT_TRUE(v()->IsStorable(create<type::Atomic>(create<type::I32>())));
-    EXPECT_TRUE(v()->IsStorable(create<type::Atomic>(create<type::U32>())));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Atomic>(create<core::type::I32>())));
+    EXPECT_TRUE(v()->IsStorable(create<core::type::Atomic>(create<core::type::U32>())));
 }
 
 TEST_F(ValidatorIsStorableTest, ArraySizedOfStorable) {
-    auto* arr = create<type::Array>(create<type::I32>(), create<type::ConstantArrayCount>(5u), 4u,
-                                    20u, 4u, 4u);
+    auto* arr = create<core::type::Array>(
+        create<core::type::I32>(), create<core::type::ConstantArrayCount>(5u), 4u, 20u, 4u, 4u);
     EXPECT_TRUE(v()->IsStorable(arr));
 }
 
 TEST_F(ValidatorIsStorableTest, ArrayUnsizedOfStorable) {
-    auto* arr =
-        create<type::Array>(create<type::I32>(), create<type::RuntimeArrayCount>(), 4u, 4u, 4u, 4u);
+    auto* arr = create<core::type::Array>(create<core::type::I32>(),
+                                          create<core::type::RuntimeArrayCount>(), 4u, 4u, 4u, 4u);
     EXPECT_TRUE(v()->IsStorable(arr));
 }
 
diff --git a/src/tint/lang/wgsl/resolver/value_constructor_validation_test.cc b/src/tint/lang/wgsl/resolver/value_constructor_validation_test.cc
index 3ed7125..7e74e69 100644
--- a/src/tint/lang/wgsl/resolver/value_constructor_validation_test.cc
+++ b/src/tint/lang/wgsl/resolver/value_constructor_validation_test.cc
@@ -61,13 +61,13 @@
     WrapInFunction(a, b, Assign(a_ident, "a"), Assign(b_ident, "b"));
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
-    ASSERT_TRUE(TypeOf(a_ident)->Is<type::Reference>());
-    EXPECT_TRUE(TypeOf(a_ident)->As<type::Reference>()->StoreType()->Is<type::I32>());
-    EXPECT_EQ(TypeOf(a_ident)->As<type::Reference>()->AddressSpace(),
+    ASSERT_TRUE(TypeOf(a_ident)->Is<core::type::Reference>());
+    EXPECT_TRUE(TypeOf(a_ident)->As<core::type::Reference>()->StoreType()->Is<core::type::I32>());
+    EXPECT_EQ(TypeOf(a_ident)->As<core::type::Reference>()->AddressSpace(),
               core::AddressSpace::kFunction);
-    ASSERT_TRUE(TypeOf(b_ident)->Is<type::Reference>());
-    EXPECT_TRUE(TypeOf(b_ident)->As<type::Reference>()->StoreType()->Is<type::I32>());
-    EXPECT_EQ(TypeOf(b_ident)->As<type::Reference>()->AddressSpace(),
+    ASSERT_TRUE(TypeOf(b_ident)->Is<core::type::Reference>());
+    EXPECT_TRUE(TypeOf(b_ident)->As<core::type::Reference>()->StoreType()->Is<core::type::I32>());
+    EXPECT_EQ(TypeOf(b_ident)->As<core::type::Reference>()->AddressSpace(),
               core::AddressSpace::kFunction);
 }
 
@@ -91,7 +91,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* got = TypeOf(a_ident);
-    auto* expected = create<type::Reference>(
+    auto* expected = create<core::type::Reference>(
         core::AddressSpace::kFunction, params.create_rhs_sem_type(*this), core::Access::kReadWrite);
     ASSERT_EQ(got, expected) << "got:      " << FriendlyName(got) << "\n"
                              << "expected: " << FriendlyName(expected) << "\n";
@@ -145,7 +145,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* got = TypeOf(a_ident);
-    auto* expected = create<type::Reference>(
+    auto* expected = create<core::type::Reference>(
         core::AddressSpace::kFunction, params.create_rhs_sem_type(*this), core::Access::kReadWrite);
     ASSERT_EQ(got, expected) << "got:      " << FriendlyName(got) << "\n"
                              << "expected: " << FriendlyName(expected) << "\n";
@@ -193,7 +193,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
     auto* got = TypeOf(a_ident);
-    auto* expected = create<type::Reference>(
+    auto* expected = create<core::type::Reference>(
         core::AddressSpace::kFunction, params.create_rhs_sem_type(*this), core::Access::kReadWrite);
     ASSERT_EQ(got, expected) << "got:      " << FriendlyName(got) << "\n"
                              << "expected: " << FriendlyName(expected) << "\n";
@@ -489,7 +489,7 @@
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
-    EXPECT_TRUE(call->Type()->Is<type::Array>());
+    EXPECT_TRUE(call->Type()->Is<core::type::Array>());
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
@@ -505,14 +505,14 @@
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
-    EXPECT_TRUE(call->Type()->Is<type::Array>());
+    EXPECT_TRUE(call->Type()->Is<core::type::Array>());
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 3u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::U32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::U32>());
-    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<core::type::U32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, InferredArray_U32U32U32) {
@@ -524,14 +524,14 @@
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
-    EXPECT_TRUE(call->Type()->Is<type::Array>());
+    EXPECT_TRUE(call->Type()->Is<core::type::Array>());
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 3u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::U32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::U32>());
-    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<core::type::U32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Array_U32AIU32) {
@@ -543,14 +543,14 @@
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
-    EXPECT_TRUE(call->Type()->Is<type::Array>());
+    EXPECT_TRUE(call->Type()->Is<core::type::Array>());
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 3u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::U32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::U32>());
-    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<core::type::U32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, InferredArray_U32AIU32) {
@@ -562,14 +562,14 @@
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
-    EXPECT_TRUE(call->Type()->Is<type::Array>());
+    EXPECT_TRUE(call->Type()->Is<core::type::Array>());
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 3u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::U32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::U32>());
-    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<core::type::U32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, ArrayU32_AIAIAI) {
@@ -581,14 +581,14 @@
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
-    EXPECT_TRUE(call->Type()->Is<type::Array>());
+    EXPECT_TRUE(call->Type()->Is<core::type::Array>());
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 3u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::U32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::U32>());
-    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<core::type::U32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, InferredArray_AIAIAI) {
@@ -600,14 +600,14 @@
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
-    EXPECT_TRUE(call->Type()->Is<type::Array>());
+    EXPECT_TRUE(call->Type()->Is<core::type::Array>());
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 3u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::AbstractInt>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::AbstractInt>());
-    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<type::AbstractInt>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::AbstractInt>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::AbstractInt>());
+    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<core::type::AbstractInt>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, InferredArrayU32_VecI32_VecAI) {
@@ -621,15 +621,17 @@
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
-    EXPECT_TRUE(call->Type()->Is<type::Array>());
+    EXPECT_TRUE(call->Type()->Is<core::type::Array>());
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 2u);
-    ASSERT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->As<type::Vector>()->type()->Is<type::I32>());
-    ASSERT_TRUE(ctor->Parameters()[1]->Type()->Is<type::Vector>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->As<type::Vector>()->type()->Is<type::I32>());
+    ASSERT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(
+        ctor->Parameters()[0]->Type()->As<core::type::Vector>()->type()->Is<core::type::I32>());
+    ASSERT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(
+        ctor->Parameters()[1]->Type()->As<core::type::Vector>()->type()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, InferredArrayU32_VecAI_VecF32) {
@@ -643,15 +645,17 @@
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
-    EXPECT_TRUE(call->Type()->Is<type::Array>());
+    EXPECT_TRUE(call->Type()->Is<core::type::Array>());
     auto* ctor = call->Target()->As<sem::ValueConstructor>();
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 2u);
-    ASSERT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->As<type::Vector>()->type()->Is<type::F32>());
-    ASSERT_TRUE(ctor->Parameters()[1]->Type()->Is<type::Vector>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->As<type::Vector>()->type()->Is<type::F32>());
+    ASSERT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(
+        ctor->Parameters()[0]->Type()->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    ASSERT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(
+        ctor->Parameters()[1]->Type()->As<core::type::Vector>()->type()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, ArrayArgumentTypeMismatch_U32F32) {
@@ -892,7 +896,7 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    ASSERT_TRUE(TypeOf(expr)->Is<type::I32>());
+    ASSERT_TRUE(TypeOf(expr)->Is<core::type::I32>());
 
     auto* call = Sem().Get<sem::Call>(expr);
     ASSERT_NE(call, nullptr);
@@ -900,7 +904,7 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 1u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, U32_Success) {
@@ -910,7 +914,7 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    ASSERT_TRUE(TypeOf(expr)->Is<type::U32>());
+    ASSERT_TRUE(TypeOf(expr)->Is<core::type::U32>());
 
     auto* call = Sem().Get<sem::Call>(expr);
     ASSERT_NE(call, nullptr);
@@ -918,7 +922,7 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 1u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::U32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, F32_Success) {
@@ -928,7 +932,7 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    ASSERT_TRUE(TypeOf(expr)->Is<type::F32>());
+    ASSERT_TRUE(TypeOf(expr)->Is<core::type::F32>());
 
     auto* call = Sem().Get<sem::Call>(expr);
     ASSERT_NE(call, nullptr);
@@ -936,7 +940,7 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 1u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::F32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, F16_Success) {
@@ -948,7 +952,7 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    ASSERT_TRUE(TypeOf(expr)->Is<type::F16>());
+    ASSERT_TRUE(TypeOf(expr)->Is<core::type::F16>());
 
     auto* call = Sem().Get<sem::Call>(expr);
     ASSERT_NE(call, nullptr);
@@ -956,7 +960,7 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 1u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::F16>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::F16>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Convert_f32_to_i32_Success) {
@@ -966,7 +970,7 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    ASSERT_TRUE(TypeOf(expr)->Is<type::I32>());
+    ASSERT_TRUE(TypeOf(expr)->Is<core::type::I32>());
 
     auto* call = Sem().Get<sem::Call>(expr);
     ASSERT_NE(call, nullptr);
@@ -974,7 +978,7 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 1u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::F32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Convert_i32_to_u32_Success) {
@@ -984,7 +988,7 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    ASSERT_TRUE(TypeOf(expr)->Is<type::U32>());
+    ASSERT_TRUE(TypeOf(expr)->Is<core::type::U32>());
 
     auto* call = Sem().Get<sem::Call>(expr);
     ASSERT_NE(call, nullptr);
@@ -992,7 +996,7 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 1u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Convert_u32_to_f16_Success) {
@@ -1004,7 +1008,7 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    ASSERT_TRUE(TypeOf(expr)->Is<type::F16>());
+    ASSERT_TRUE(TypeOf(expr)->Is<core::type::F16>());
 
     auto* call = Sem().Get<sem::Call>(expr);
     ASSERT_NE(call, nullptr);
@@ -1012,7 +1016,7 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 1u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::U32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Convert_f16_to_f32_Success) {
@@ -1024,7 +1028,7 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(expr), nullptr);
-    ASSERT_TRUE(TypeOf(expr)->Is<type::F32>());
+    ASSERT_TRUE(TypeOf(expr)->Is<core::type::F32>());
 
     auto* call = Sem().Get<sem::Call>(expr);
     ASSERT_NE(call, nullptr);
@@ -1032,7 +1036,7 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 1u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::F16>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::F16>());
 }
 
 }  // namespace ScalarConstructor
@@ -1137,9 +1141,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 2u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1156,9 +1160,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 2u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1166,8 +1170,8 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 2u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::F32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::F32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::F32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec2F16_Success_Scalar) {
@@ -1179,9 +1183,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F16>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F16>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 2u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1189,8 +1193,8 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 2u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::F16>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::F16>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::F16>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::F16>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec2U32_Success_Scalar) {
@@ -1200,9 +1204,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::U32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::U32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 2u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1210,8 +1214,8 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 2u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::U32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::U32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec2I32_Success_Scalar) {
@@ -1221,9 +1225,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::I32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::I32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 2u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1231,8 +1235,8 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 2u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::I32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec2Bool_Success_Scalar) {
@@ -1242,9 +1246,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::Bool>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::Bool>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 2u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1252,8 +1256,8 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 2u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Bool>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::Bool>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::Bool>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::Bool>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec2_Success_Identity) {
@@ -1263,9 +1267,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 2u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1273,7 +1277,7 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 1u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::Vector>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec2_Success_Vec2TypeConversion) {
@@ -1283,9 +1287,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 2u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 2u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1293,7 +1297,7 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 1u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::Vector>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec3F32_Error_ScalarArgumentTypeMismatch) {
@@ -1412,9 +1416,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 3u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1431,9 +1435,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 3u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1441,9 +1445,9 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 3u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::F32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::F32>());
-    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<type::F32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::F32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::F32>());
+    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec3F16_Success_Scalar) {
@@ -1455,9 +1459,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F16>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F16>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 3u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1465,9 +1469,9 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 3u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::F16>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::F16>());
-    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<type::F16>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::F16>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::F16>());
+    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<core::type::F16>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec3U32_Success_Scalar) {
@@ -1477,9 +1481,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::U32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::U32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 3u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1487,9 +1491,9 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 3u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::U32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::U32>());
-    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::U32>());
+    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<core::type::U32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec3I32_Success_Scalar) {
@@ -1499,9 +1503,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::I32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::I32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 3u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1509,9 +1513,9 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 3u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::I32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::I32>());
-    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::I32>());
+    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<core::type::I32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec3Bool_Success_Scalar) {
@@ -1521,9 +1525,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::Bool>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::Bool>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 3u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1531,9 +1535,9 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 3u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Bool>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::Bool>());
-    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<type::Bool>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::Bool>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::Bool>());
+    EXPECT_TRUE(ctor->Parameters()[2]->Type()->Is<core::type::Bool>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec3_Success_Vec2AndScalar) {
@@ -1543,9 +1547,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 3u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1553,8 +1557,8 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 2u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::F32>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::Vector>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::F32>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec3_Success_ScalarAndVec2) {
@@ -1564,9 +1568,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 3u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1574,8 +1578,8 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 2u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::F32>());
-    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<type::Vector>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::F32>());
+    EXPECT_TRUE(ctor->Parameters()[1]->Type()->Is<core::type::Vector>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec3_Success_Identity) {
@@ -1585,9 +1589,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 3u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1595,7 +1599,7 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 1u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::Vector>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec3_Success_Vec3TypeConversion) {
@@ -1605,9 +1609,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 3u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 3u);
 
     auto* call = Sem().Get<sem::Call>(tc);
     ASSERT_NE(call, nullptr);
@@ -1615,7 +1619,7 @@
     ASSERT_NE(ctor, nullptr);
     EXPECT_EQ(call->Type(), ctor->ReturnType());
     ASSERT_EQ(ctor->Parameters().Length(), 1u);
-    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<type::Vector>());
+    EXPECT_TRUE(ctor->Parameters()[0]->Type()->Is<core::type::Vector>());
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec4F32_Error_ScalarArgumentTypeMismatch) {
@@ -1778,9 +1782,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec4F32_Success_Scalar) {
@@ -1790,9 +1794,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec4F16_Success_Scalar) {
@@ -1804,9 +1808,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F16>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F16>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec4U32_Success_Scalar) {
@@ -1816,9 +1820,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::U32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::U32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec4I32_Success_Scalar) {
@@ -1828,9 +1832,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::I32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::I32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec4Bool_Success_Scalar) {
@@ -1840,9 +1844,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::Bool>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::Bool>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec4_Success_Vec2ScalarScalar) {
@@ -1852,9 +1856,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec4_Success_ScalarVec2Scalar) {
@@ -1864,9 +1868,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec4_Success_ScalarScalarVec2) {
@@ -1876,9 +1880,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec4_Success_Vec2AndVec2) {
@@ -1888,9 +1892,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec4_Success_Vec3AndScalar) {
@@ -1900,9 +1904,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec4_Success_ScalarAndVec3) {
@@ -1912,9 +1916,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec4_Success_Identity) {
@@ -1924,9 +1928,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vec4_Success_Vec4TypeConversion) {
@@ -1936,9 +1940,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, NestedVectorConstructors_InnerError) {
@@ -1958,9 +1962,9 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     ASSERT_NE(TypeOf(tc), nullptr);
-    ASSERT_TRUE(TypeOf(tc)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(tc)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_EQ(TypeOf(tc)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(tc)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(tc)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_EQ(TypeOf(tc)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, Vector_Alias_Argument_Error) {
@@ -2043,21 +2047,21 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(vec2_bool)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec2_i32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec2_u32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec2_f32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec2_f16)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(vec2_bool)->As<type::Vector>()->type()->Is<type::Bool>());
-    EXPECT_TRUE(TypeOf(vec2_i32)->As<type::Vector>()->type()->Is<type::I32>());
-    EXPECT_TRUE(TypeOf(vec2_u32)->As<type::Vector>()->type()->Is<type::U32>());
-    EXPECT_TRUE(TypeOf(vec2_f32)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(vec2_f16)->As<type::Vector>()->type()->Is<type::F16>());
-    EXPECT_EQ(TypeOf(vec2_bool)->As<type::Vector>()->Width(), 2u);
-    EXPECT_EQ(TypeOf(vec2_i32)->As<type::Vector>()->Width(), 2u);
-    EXPECT_EQ(TypeOf(vec2_u32)->As<type::Vector>()->Width(), 2u);
-    EXPECT_EQ(TypeOf(vec2_f32)->As<type::Vector>()->Width(), 2u);
-    EXPECT_EQ(TypeOf(vec2_f16)->As<type::Vector>()->Width(), 2u);
+    ASSERT_TRUE(TypeOf(vec2_bool)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec2_i32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec2_u32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec2_f32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec2_f16)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(vec2_bool)->As<core::type::Vector>()->type()->Is<core::type::Bool>());
+    EXPECT_TRUE(TypeOf(vec2_i32)->As<core::type::Vector>()->type()->Is<core::type::I32>());
+    EXPECT_TRUE(TypeOf(vec2_u32)->As<core::type::Vector>()->type()->Is<core::type::U32>());
+    EXPECT_TRUE(TypeOf(vec2_f32)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(vec2_f16)->As<core::type::Vector>()->type()->Is<core::type::F16>());
+    EXPECT_EQ(TypeOf(vec2_bool)->As<core::type::Vector>()->Width(), 2u);
+    EXPECT_EQ(TypeOf(vec2_i32)->As<core::type::Vector>()->Width(), 2u);
+    EXPECT_EQ(TypeOf(vec2_u32)->As<core::type::Vector>()->Width(), 2u);
+    EXPECT_EQ(TypeOf(vec2_f32)->As<core::type::Vector>()->Width(), 2u);
+    EXPECT_EQ(TypeOf(vec2_f16)->As<core::type::Vector>()->Width(), 2u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, InferVec2ElementTypeFromVec2) {
@@ -2072,21 +2076,21 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(vec2_bool)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec2_i32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec2_u32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec2_f32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec2_f16)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(vec2_bool)->As<type::Vector>()->type()->Is<type::Bool>());
-    EXPECT_TRUE(TypeOf(vec2_i32)->As<type::Vector>()->type()->Is<type::I32>());
-    EXPECT_TRUE(TypeOf(vec2_u32)->As<type::Vector>()->type()->Is<type::U32>());
-    EXPECT_TRUE(TypeOf(vec2_f32)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(vec2_f16)->As<type::Vector>()->type()->Is<type::F16>());
-    EXPECT_EQ(TypeOf(vec2_bool)->As<type::Vector>()->Width(), 2u);
-    EXPECT_EQ(TypeOf(vec2_i32)->As<type::Vector>()->Width(), 2u);
-    EXPECT_EQ(TypeOf(vec2_u32)->As<type::Vector>()->Width(), 2u);
-    EXPECT_EQ(TypeOf(vec2_f32)->As<type::Vector>()->Width(), 2u);
-    EXPECT_EQ(TypeOf(vec2_f16)->As<type::Vector>()->Width(), 2u);
+    ASSERT_TRUE(TypeOf(vec2_bool)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec2_i32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec2_u32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec2_f32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec2_f16)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(vec2_bool)->As<core::type::Vector>()->type()->Is<core::type::Bool>());
+    EXPECT_TRUE(TypeOf(vec2_i32)->As<core::type::Vector>()->type()->Is<core::type::I32>());
+    EXPECT_TRUE(TypeOf(vec2_u32)->As<core::type::Vector>()->type()->Is<core::type::U32>());
+    EXPECT_TRUE(TypeOf(vec2_f32)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(vec2_f16)->As<core::type::Vector>()->type()->Is<core::type::F16>());
+    EXPECT_EQ(TypeOf(vec2_bool)->As<core::type::Vector>()->Width(), 2u);
+    EXPECT_EQ(TypeOf(vec2_i32)->As<core::type::Vector>()->Width(), 2u);
+    EXPECT_EQ(TypeOf(vec2_u32)->As<core::type::Vector>()->Width(), 2u);
+    EXPECT_EQ(TypeOf(vec2_f32)->As<core::type::Vector>()->Width(), 2u);
+    EXPECT_EQ(TypeOf(vec2_f16)->As<core::type::Vector>()->Width(), 2u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, InferVec3ElementTypeFromScalars) {
@@ -2101,21 +2105,21 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(vec3_bool)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec3_i32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec3_u32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec3_f32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec3_f16)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(vec3_bool)->As<type::Vector>()->type()->Is<type::Bool>());
-    EXPECT_TRUE(TypeOf(vec3_i32)->As<type::Vector>()->type()->Is<type::I32>());
-    EXPECT_TRUE(TypeOf(vec3_u32)->As<type::Vector>()->type()->Is<type::U32>());
-    EXPECT_TRUE(TypeOf(vec3_f32)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(vec3_f16)->As<type::Vector>()->type()->Is<type::F16>());
-    EXPECT_EQ(TypeOf(vec3_bool)->As<type::Vector>()->Width(), 3u);
-    EXPECT_EQ(TypeOf(vec3_i32)->As<type::Vector>()->Width(), 3u);
-    EXPECT_EQ(TypeOf(vec3_u32)->As<type::Vector>()->Width(), 3u);
-    EXPECT_EQ(TypeOf(vec3_f32)->As<type::Vector>()->Width(), 3u);
-    EXPECT_EQ(TypeOf(vec3_f16)->As<type::Vector>()->Width(), 3u);
+    ASSERT_TRUE(TypeOf(vec3_bool)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec3_i32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec3_u32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec3_f32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec3_f16)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(vec3_bool)->As<core::type::Vector>()->type()->Is<core::type::Bool>());
+    EXPECT_TRUE(TypeOf(vec3_i32)->As<core::type::Vector>()->type()->Is<core::type::I32>());
+    EXPECT_TRUE(TypeOf(vec3_u32)->As<core::type::Vector>()->type()->Is<core::type::U32>());
+    EXPECT_TRUE(TypeOf(vec3_f32)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(vec3_f16)->As<core::type::Vector>()->type()->Is<core::type::F16>());
+    EXPECT_EQ(TypeOf(vec3_bool)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_EQ(TypeOf(vec3_i32)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_EQ(TypeOf(vec3_u32)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_EQ(TypeOf(vec3_f32)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_EQ(TypeOf(vec3_f16)->As<core::type::Vector>()->Width(), 3u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, InferVec3ElementTypeFromVec3) {
@@ -2130,21 +2134,21 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(vec3_bool)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec3_i32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec3_u32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec3_f32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec3_f16)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(vec3_bool)->As<type::Vector>()->type()->Is<type::Bool>());
-    EXPECT_TRUE(TypeOf(vec3_i32)->As<type::Vector>()->type()->Is<type::I32>());
-    EXPECT_TRUE(TypeOf(vec3_u32)->As<type::Vector>()->type()->Is<type::U32>());
-    EXPECT_TRUE(TypeOf(vec3_f32)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(vec3_f16)->As<type::Vector>()->type()->Is<type::F16>());
-    EXPECT_EQ(TypeOf(vec3_bool)->As<type::Vector>()->Width(), 3u);
-    EXPECT_EQ(TypeOf(vec3_i32)->As<type::Vector>()->Width(), 3u);
-    EXPECT_EQ(TypeOf(vec3_u32)->As<type::Vector>()->Width(), 3u);
-    EXPECT_EQ(TypeOf(vec3_f32)->As<type::Vector>()->Width(), 3u);
-    EXPECT_EQ(TypeOf(vec3_f16)->As<type::Vector>()->Width(), 3u);
+    ASSERT_TRUE(TypeOf(vec3_bool)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec3_i32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec3_u32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec3_f32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec3_f16)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(vec3_bool)->As<core::type::Vector>()->type()->Is<core::type::Bool>());
+    EXPECT_TRUE(TypeOf(vec3_i32)->As<core::type::Vector>()->type()->Is<core::type::I32>());
+    EXPECT_TRUE(TypeOf(vec3_u32)->As<core::type::Vector>()->type()->Is<core::type::U32>());
+    EXPECT_TRUE(TypeOf(vec3_f32)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(vec3_f16)->As<core::type::Vector>()->type()->Is<core::type::F16>());
+    EXPECT_EQ(TypeOf(vec3_bool)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_EQ(TypeOf(vec3_i32)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_EQ(TypeOf(vec3_u32)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_EQ(TypeOf(vec3_f32)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_EQ(TypeOf(vec3_f16)->As<core::type::Vector>()->Width(), 3u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, InferVec3ElementTypeFromScalarAndVec2) {
@@ -2159,21 +2163,21 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(vec3_bool)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec3_i32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec3_u32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec3_f32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec3_f16)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(vec3_bool)->As<type::Vector>()->type()->Is<type::Bool>());
-    EXPECT_TRUE(TypeOf(vec3_i32)->As<type::Vector>()->type()->Is<type::I32>());
-    EXPECT_TRUE(TypeOf(vec3_u32)->As<type::Vector>()->type()->Is<type::U32>());
-    EXPECT_TRUE(TypeOf(vec3_f32)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(vec3_f16)->As<type::Vector>()->type()->Is<type::F16>());
-    EXPECT_EQ(TypeOf(vec3_bool)->As<type::Vector>()->Width(), 3u);
-    EXPECT_EQ(TypeOf(vec3_i32)->As<type::Vector>()->Width(), 3u);
-    EXPECT_EQ(TypeOf(vec3_u32)->As<type::Vector>()->Width(), 3u);
-    EXPECT_EQ(TypeOf(vec3_f32)->As<type::Vector>()->Width(), 3u);
-    EXPECT_EQ(TypeOf(vec3_f16)->As<type::Vector>()->Width(), 3u);
+    ASSERT_TRUE(TypeOf(vec3_bool)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec3_i32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec3_u32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec3_f32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec3_f16)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(vec3_bool)->As<core::type::Vector>()->type()->Is<core::type::Bool>());
+    EXPECT_TRUE(TypeOf(vec3_i32)->As<core::type::Vector>()->type()->Is<core::type::I32>());
+    EXPECT_TRUE(TypeOf(vec3_u32)->As<core::type::Vector>()->type()->Is<core::type::U32>());
+    EXPECT_TRUE(TypeOf(vec3_f32)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(vec3_f16)->As<core::type::Vector>()->type()->Is<core::type::F16>());
+    EXPECT_EQ(TypeOf(vec3_bool)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_EQ(TypeOf(vec3_i32)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_EQ(TypeOf(vec3_u32)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_EQ(TypeOf(vec3_f32)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_EQ(TypeOf(vec3_f16)->As<core::type::Vector>()->Width(), 3u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, InferVec4ElementTypeFromScalars) {
@@ -2188,21 +2192,21 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(vec4_bool)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec4_i32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec4_u32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec4_f32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec4_f16)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(vec4_bool)->As<type::Vector>()->type()->Is<type::Bool>());
-    EXPECT_TRUE(TypeOf(vec4_i32)->As<type::Vector>()->type()->Is<type::I32>());
-    EXPECT_TRUE(TypeOf(vec4_u32)->As<type::Vector>()->type()->Is<type::U32>());
-    EXPECT_TRUE(TypeOf(vec4_f32)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(vec4_f16)->As<type::Vector>()->type()->Is<type::F16>());
-    EXPECT_EQ(TypeOf(vec4_bool)->As<type::Vector>()->Width(), 4u);
-    EXPECT_EQ(TypeOf(vec4_i32)->As<type::Vector>()->Width(), 4u);
-    EXPECT_EQ(TypeOf(vec4_u32)->As<type::Vector>()->Width(), 4u);
-    EXPECT_EQ(TypeOf(vec4_f32)->As<type::Vector>()->Width(), 4u);
-    EXPECT_EQ(TypeOf(vec4_f16)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(vec4_bool)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec4_i32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec4_u32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec4_f32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec4_f16)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(vec4_bool)->As<core::type::Vector>()->type()->Is<core::type::Bool>());
+    EXPECT_TRUE(TypeOf(vec4_i32)->As<core::type::Vector>()->type()->Is<core::type::I32>());
+    EXPECT_TRUE(TypeOf(vec4_u32)->As<core::type::Vector>()->type()->Is<core::type::U32>());
+    EXPECT_TRUE(TypeOf(vec4_f32)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(vec4_f16)->As<core::type::Vector>()->type()->Is<core::type::F16>());
+    EXPECT_EQ(TypeOf(vec4_bool)->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(vec4_i32)->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(vec4_u32)->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(vec4_f32)->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(vec4_f16)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, InferVec4ElementTypeFromVec4) {
@@ -2217,21 +2221,21 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(vec4_bool)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec4_i32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec4_u32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec4_f32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec4_f16)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(vec4_bool)->As<type::Vector>()->type()->Is<type::Bool>());
-    EXPECT_TRUE(TypeOf(vec4_i32)->As<type::Vector>()->type()->Is<type::I32>());
-    EXPECT_TRUE(TypeOf(vec4_u32)->As<type::Vector>()->type()->Is<type::U32>());
-    EXPECT_TRUE(TypeOf(vec4_f32)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(vec4_f16)->As<type::Vector>()->type()->Is<type::F16>());
-    EXPECT_EQ(TypeOf(vec4_bool)->As<type::Vector>()->Width(), 4u);
-    EXPECT_EQ(TypeOf(vec4_i32)->As<type::Vector>()->Width(), 4u);
-    EXPECT_EQ(TypeOf(vec4_u32)->As<type::Vector>()->Width(), 4u);
-    EXPECT_EQ(TypeOf(vec4_f32)->As<type::Vector>()->Width(), 4u);
-    EXPECT_EQ(TypeOf(vec4_f16)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(vec4_bool)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec4_i32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec4_u32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec4_f32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec4_f16)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(vec4_bool)->As<core::type::Vector>()->type()->Is<core::type::Bool>());
+    EXPECT_TRUE(TypeOf(vec4_i32)->As<core::type::Vector>()->type()->Is<core::type::I32>());
+    EXPECT_TRUE(TypeOf(vec4_u32)->As<core::type::Vector>()->type()->Is<core::type::U32>());
+    EXPECT_TRUE(TypeOf(vec4_f32)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(vec4_f16)->As<core::type::Vector>()->type()->Is<core::type::F16>());
+    EXPECT_EQ(TypeOf(vec4_bool)->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(vec4_i32)->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(vec4_u32)->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(vec4_f32)->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(vec4_f16)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, InferVec4ElementTypeFromScalarAndVec3) {
@@ -2246,21 +2250,21 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(vec4_bool)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec4_i32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec4_u32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec4_f32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec4_f16)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(vec4_bool)->As<type::Vector>()->type()->Is<type::Bool>());
-    EXPECT_TRUE(TypeOf(vec4_i32)->As<type::Vector>()->type()->Is<type::I32>());
-    EXPECT_TRUE(TypeOf(vec4_u32)->As<type::Vector>()->type()->Is<type::U32>());
-    EXPECT_TRUE(TypeOf(vec4_f32)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(vec4_f16)->As<type::Vector>()->type()->Is<type::F16>());
-    EXPECT_EQ(TypeOf(vec4_bool)->As<type::Vector>()->Width(), 4u);
-    EXPECT_EQ(TypeOf(vec4_i32)->As<type::Vector>()->Width(), 4u);
-    EXPECT_EQ(TypeOf(vec4_u32)->As<type::Vector>()->Width(), 4u);
-    EXPECT_EQ(TypeOf(vec4_f32)->As<type::Vector>()->Width(), 4u);
-    EXPECT_EQ(TypeOf(vec4_f16)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(vec4_bool)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec4_i32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec4_u32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec4_f32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec4_f16)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(vec4_bool)->As<core::type::Vector>()->type()->Is<core::type::Bool>());
+    EXPECT_TRUE(TypeOf(vec4_i32)->As<core::type::Vector>()->type()->Is<core::type::I32>());
+    EXPECT_TRUE(TypeOf(vec4_u32)->As<core::type::Vector>()->type()->Is<core::type::U32>());
+    EXPECT_TRUE(TypeOf(vec4_f32)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(vec4_f16)->As<core::type::Vector>()->type()->Is<core::type::F16>());
+    EXPECT_EQ(TypeOf(vec4_bool)->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(vec4_i32)->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(vec4_u32)->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(vec4_f32)->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(vec4_f16)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, InferVec4ElementTypeFromVec2AndVec2) {
@@ -2276,21 +2280,21 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(vec4_bool)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec4_i32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec4_u32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec4_f32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(vec4_f16)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(vec4_bool)->As<type::Vector>()->type()->Is<type::Bool>());
-    EXPECT_TRUE(TypeOf(vec4_i32)->As<type::Vector>()->type()->Is<type::I32>());
-    EXPECT_TRUE(TypeOf(vec4_u32)->As<type::Vector>()->type()->Is<type::U32>());
-    EXPECT_TRUE(TypeOf(vec4_f32)->As<type::Vector>()->type()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(vec4_f16)->As<type::Vector>()->type()->Is<type::F16>());
-    EXPECT_EQ(TypeOf(vec4_bool)->As<type::Vector>()->Width(), 4u);
-    EXPECT_EQ(TypeOf(vec4_i32)->As<type::Vector>()->Width(), 4u);
-    EXPECT_EQ(TypeOf(vec4_u32)->As<type::Vector>()->Width(), 4u);
-    EXPECT_EQ(TypeOf(vec4_f32)->As<type::Vector>()->Width(), 4u);
-    EXPECT_EQ(TypeOf(vec4_f16)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(vec4_bool)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec4_i32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec4_u32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec4_f32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(vec4_f16)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(vec4_bool)->As<core::type::Vector>()->type()->Is<core::type::Bool>());
+    EXPECT_TRUE(TypeOf(vec4_i32)->As<core::type::Vector>()->type()->Is<core::type::I32>());
+    EXPECT_TRUE(TypeOf(vec4_u32)->As<core::type::Vector>()->type()->Is<core::type::U32>());
+    EXPECT_TRUE(TypeOf(vec4_f32)->As<core::type::Vector>()->type()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(vec4_f16)->As<core::type::Vector>()->type()->Is<core::type::F16>());
+    EXPECT_EQ(TypeOf(vec4_bool)->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(vec4_i32)->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(vec4_u32)->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(vec4_f32)->As<core::type::Vector>()->Width(), 4u);
+    EXPECT_EQ(TypeOf(vec4_f16)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, InferVecNoArgs) {
@@ -2304,15 +2308,15 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(v2)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(v3)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(v4)->Is<type::Vector>());
-    EXPECT_TRUE(TypeOf(v2)->As<type::Vector>()->type()->Is<type::AbstractInt>());
-    EXPECT_TRUE(TypeOf(v3)->As<type::Vector>()->type()->Is<type::AbstractInt>());
-    EXPECT_TRUE(TypeOf(v4)->As<type::Vector>()->type()->Is<type::AbstractInt>());
-    EXPECT_EQ(TypeOf(v2)->As<type::Vector>()->Width(), 2u);
-    EXPECT_EQ(TypeOf(v3)->As<type::Vector>()->Width(), 3u);
-    EXPECT_EQ(TypeOf(v4)->As<type::Vector>()->Width(), 4u);
+    ASSERT_TRUE(TypeOf(v2)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(v3)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(v4)->Is<core::type::Vector>());
+    EXPECT_TRUE(TypeOf(v2)->As<core::type::Vector>()->type()->Is<core::type::AbstractInt>());
+    EXPECT_TRUE(TypeOf(v3)->As<core::type::Vector>()->type()->Is<core::type::AbstractInt>());
+    EXPECT_TRUE(TypeOf(v4)->As<core::type::Vector>()->type()->Is<core::type::AbstractInt>());
+    EXPECT_EQ(TypeOf(v2)->As<core::type::Vector>()->Width(), 2u);
+    EXPECT_EQ(TypeOf(v3)->As<core::type::Vector>()->Width(), 3u);
+    EXPECT_EQ(TypeOf(v4)->As<core::type::Vector>()->Width(), 4u);
 }
 
 TEST_F(ResolverValueConstructorValidationTest, CannotInferVec2ElementTypeFromScalarsMismatch) {
@@ -3151,7 +3155,7 @@
 
 TEST_F(ResolverValueConstructorValidationTest, NonConstructibleType_Sampler) {
     WrapInFunction(
-        Assign(Phony(), Call(Source{{12, 34}}, ty.sampler(type::SamplerKind::kSampler))));
+        Assign(Phony(), Call(Source{{12, 34}}, ty.sampler(core::type::SamplerKind::kSampler))));
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(), "12:34 error: type is not constructible");
diff --git a/src/tint/lang/wgsl/resolver/variable_test.cc b/src/tint/lang/wgsl/resolver/variable_test.cc
index 837b296..34c96e9 100644
--- a/src/tint/lang/wgsl/resolver/variable_test.cc
+++ b/src/tint/lang/wgsl/resolver/variable_test.cc
@@ -69,21 +69,21 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     // `var` declarations are always of reference type
-    ASSERT_TRUE(TypeOf(i)->Is<type::Reference>());
-    ASSERT_TRUE(TypeOf(u)->Is<type::Reference>());
-    ASSERT_TRUE(TypeOf(f)->Is<type::Reference>());
-    ASSERT_TRUE(TypeOf(h)->Is<type::Reference>());
-    ASSERT_TRUE(TypeOf(b)->Is<type::Reference>());
-    ASSERT_TRUE(TypeOf(s)->Is<type::Reference>());
-    ASSERT_TRUE(TypeOf(a)->Is<type::Reference>());
+    ASSERT_TRUE(TypeOf(i)->Is<core::type::Reference>());
+    ASSERT_TRUE(TypeOf(u)->Is<core::type::Reference>());
+    ASSERT_TRUE(TypeOf(f)->Is<core::type::Reference>());
+    ASSERT_TRUE(TypeOf(h)->Is<core::type::Reference>());
+    ASSERT_TRUE(TypeOf(b)->Is<core::type::Reference>());
+    ASSERT_TRUE(TypeOf(s)->Is<core::type::Reference>());
+    ASSERT_TRUE(TypeOf(a)->Is<core::type::Reference>());
 
-    EXPECT_TRUE(TypeOf(i)->As<type::Reference>()->StoreType()->Is<type::I32>());
-    EXPECT_TRUE(TypeOf(u)->As<type::Reference>()->StoreType()->Is<type::U32>());
-    EXPECT_TRUE(TypeOf(f)->As<type::Reference>()->StoreType()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(h)->As<type::Reference>()->StoreType()->Is<type::F16>());
-    EXPECT_TRUE(TypeOf(b)->As<type::Reference>()->StoreType()->Is<type::Bool>());
-    EXPECT_TRUE(TypeOf(s)->As<type::Reference>()->StoreType()->Is<type::Struct>());
-    EXPECT_TRUE(TypeOf(a)->As<type::Reference>()->StoreType()->Is<type::Struct>());
+    EXPECT_TRUE(TypeOf(i)->As<core::type::Reference>()->StoreType()->Is<core::type::I32>());
+    EXPECT_TRUE(TypeOf(u)->As<core::type::Reference>()->StoreType()->Is<core::type::U32>());
+    EXPECT_TRUE(TypeOf(f)->As<core::type::Reference>()->StoreType()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(h)->As<core::type::Reference>()->StoreType()->Is<core::type::F16>());
+    EXPECT_TRUE(TypeOf(b)->As<core::type::Reference>()->StoreType()->Is<core::type::Bool>());
+    EXPECT_TRUE(TypeOf(s)->As<core::type::Reference>()->StoreType()->Is<core::type::Struct>());
+    EXPECT_TRUE(TypeOf(a)->As<core::type::Reference>()->StoreType()->Is<core::type::Struct>());
 
     EXPECT_EQ(Sem().Get(i)->Initializer(), nullptr);
     EXPECT_EQ(Sem().Get(u)->Initializer(), nullptr);
@@ -142,28 +142,28 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     // `var` declarations are always of reference type
-    ASSERT_TRUE(TypeOf(i)->Is<type::Reference>());
-    ASSERT_TRUE(TypeOf(u)->Is<type::Reference>());
-    ASSERT_TRUE(TypeOf(f)->Is<type::Reference>());
-    ASSERT_TRUE(TypeOf(h)->Is<type::Reference>());
-    ASSERT_TRUE(TypeOf(b)->Is<type::Reference>());
-    ASSERT_TRUE(TypeOf(s)->Is<type::Reference>());
-    ASSERT_TRUE(TypeOf(a)->Is<type::Reference>());
+    ASSERT_TRUE(TypeOf(i)->Is<core::type::Reference>());
+    ASSERT_TRUE(TypeOf(u)->Is<core::type::Reference>());
+    ASSERT_TRUE(TypeOf(f)->Is<core::type::Reference>());
+    ASSERT_TRUE(TypeOf(h)->Is<core::type::Reference>());
+    ASSERT_TRUE(TypeOf(b)->Is<core::type::Reference>());
+    ASSERT_TRUE(TypeOf(s)->Is<core::type::Reference>());
+    ASSERT_TRUE(TypeOf(a)->Is<core::type::Reference>());
 
-    EXPECT_EQ(TypeOf(i)->As<type::Reference>()->Access(), core::Access::kReadWrite);
-    EXPECT_EQ(TypeOf(u)->As<type::Reference>()->Access(), core::Access::kReadWrite);
-    EXPECT_EQ(TypeOf(f)->As<type::Reference>()->Access(), core::Access::kReadWrite);
-    EXPECT_EQ(TypeOf(b)->As<type::Reference>()->Access(), core::Access::kReadWrite);
-    EXPECT_EQ(TypeOf(s)->As<type::Reference>()->Access(), core::Access::kReadWrite);
-    EXPECT_EQ(TypeOf(a)->As<type::Reference>()->Access(), core::Access::kReadWrite);
+    EXPECT_EQ(TypeOf(i)->As<core::type::Reference>()->Access(), core::Access::kReadWrite);
+    EXPECT_EQ(TypeOf(u)->As<core::type::Reference>()->Access(), core::Access::kReadWrite);
+    EXPECT_EQ(TypeOf(f)->As<core::type::Reference>()->Access(), core::Access::kReadWrite);
+    EXPECT_EQ(TypeOf(b)->As<core::type::Reference>()->Access(), core::Access::kReadWrite);
+    EXPECT_EQ(TypeOf(s)->As<core::type::Reference>()->Access(), core::Access::kReadWrite);
+    EXPECT_EQ(TypeOf(a)->As<core::type::Reference>()->Access(), core::Access::kReadWrite);
 
-    EXPECT_TRUE(TypeOf(i)->As<type::Reference>()->StoreType()->Is<type::I32>());
-    EXPECT_TRUE(TypeOf(u)->As<type::Reference>()->StoreType()->Is<type::U32>());
-    EXPECT_TRUE(TypeOf(f)->As<type::Reference>()->StoreType()->Is<type::F32>());
-    EXPECT_TRUE(TypeOf(h)->As<type::Reference>()->StoreType()->Is<type::F16>());
-    EXPECT_TRUE(TypeOf(b)->As<type::Reference>()->StoreType()->Is<type::Bool>());
-    EXPECT_TRUE(TypeOf(s)->As<type::Reference>()->StoreType()->Is<type::Struct>());
-    EXPECT_TRUE(TypeOf(a)->As<type::Reference>()->StoreType()->Is<type::Struct>());
+    EXPECT_TRUE(TypeOf(i)->As<core::type::Reference>()->StoreType()->Is<core::type::I32>());
+    EXPECT_TRUE(TypeOf(u)->As<core::type::Reference>()->StoreType()->Is<core::type::U32>());
+    EXPECT_TRUE(TypeOf(f)->As<core::type::Reference>()->StoreType()->Is<core::type::F32>());
+    EXPECT_TRUE(TypeOf(h)->As<core::type::Reference>()->StoreType()->Is<core::type::F16>());
+    EXPECT_TRUE(TypeOf(b)->As<core::type::Reference>()->StoreType()->Is<core::type::Bool>());
+    EXPECT_TRUE(TypeOf(s)->As<core::type::Reference>()->StoreType()->Is<core::type::Struct>());
+    EXPECT_TRUE(TypeOf(a)->As<core::type::Reference>()->StoreType()->Is<core::type::Struct>());
 
     EXPECT_EQ(Sem().Get(i)->Initializer()->Declaration(), i_c);
     EXPECT_EQ(Sem().Get(u)->Initializer()->Declaration(), u_c);
@@ -440,15 +440,15 @@
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
     // `let` declarations are always of the storage type
-    ASSERT_TRUE(TypeOf(i)->Is<type::I32>());
-    ASSERT_TRUE(TypeOf(u)->Is<type::U32>());
-    ASSERT_TRUE(TypeOf(f)->Is<type::F32>());
-    ASSERT_TRUE(TypeOf(h)->Is<type::F16>());
-    ASSERT_TRUE(TypeOf(b)->Is<type::Bool>());
-    ASSERT_TRUE(TypeOf(s)->Is<type::Struct>());
-    ASSERT_TRUE(TypeOf(a)->Is<type::Struct>());
-    ASSERT_TRUE(TypeOf(p)->Is<type::Pointer>());
-    ASSERT_TRUE(TypeOf(p)->As<type::Pointer>()->StoreType()->Is<type::I32>());
+    ASSERT_TRUE(TypeOf(i)->Is<core::type::I32>());
+    ASSERT_TRUE(TypeOf(u)->Is<core::type::U32>());
+    ASSERT_TRUE(TypeOf(f)->Is<core::type::F32>());
+    ASSERT_TRUE(TypeOf(h)->Is<core::type::F16>());
+    ASSERT_TRUE(TypeOf(b)->Is<core::type::Bool>());
+    ASSERT_TRUE(TypeOf(s)->Is<core::type::Struct>());
+    ASSERT_TRUE(TypeOf(a)->Is<core::type::Struct>());
+    ASSERT_TRUE(TypeOf(p)->Is<core::type::Pointer>());
+    ASSERT_TRUE(TypeOf(p)->As<core::type::Pointer>()->StoreType()->Is<core::type::I32>());
 
     EXPECT_EQ(Sem().Get(i)->Initializer()->Declaration(), i_c);
     EXPECT_EQ(Sem().Get(u)->Initializer()->Declaration(), u_c);
@@ -483,11 +483,11 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(expr)->Is<type::Reference>());
-    ASSERT_TRUE(TypeOf(ptr)->Is<type::Pointer>());
+    ASSERT_TRUE(TypeOf(expr)->Is<core::type::Reference>());
+    ASSERT_TRUE(TypeOf(ptr)->Is<core::type::Pointer>());
 
-    EXPECT_EQ(TypeOf(expr)->As<type::Reference>()->Access(), core::Access::kReadWrite);
-    EXPECT_EQ(TypeOf(ptr)->As<type::Pointer>()->Access(), core::Access::kReadWrite);
+    EXPECT_EQ(TypeOf(expr)->As<core::type::Reference>()->Access(), core::Access::kReadWrite);
+    EXPECT_EQ(TypeOf(ptr)->As<core::type::Pointer>()->Access(), core::Access::kReadWrite);
 }
 
 TEST_F(ResolverVariableTest, LocalLet_ShadowsAlias) {
@@ -918,14 +918,14 @@
     EXPECT_EQ(Sem().Get(c_mf32)->Declaration(), c_mf32);
     EXPECT_EQ(Sem().Get(c_s)->Declaration(), c_s);
 
-    ASSERT_TRUE(TypeOf(c_i32)->Is<type::I32>());
-    ASSERT_TRUE(TypeOf(c_u32)->Is<type::U32>());
-    ASSERT_TRUE(TypeOf(c_f32)->Is<type::F32>());
-    ASSERT_TRUE(TypeOf(c_vi32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(c_vu32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(c_vf32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(c_mf32)->Is<type::Matrix>());
-    ASSERT_TRUE(TypeOf(c_s)->Is<type::Struct>());
+    ASSERT_TRUE(TypeOf(c_i32)->Is<core::type::I32>());
+    ASSERT_TRUE(TypeOf(c_u32)->Is<core::type::U32>());
+    ASSERT_TRUE(TypeOf(c_f32)->Is<core::type::F32>());
+    ASSERT_TRUE(TypeOf(c_vi32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(c_vu32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(c_vf32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(c_mf32)->Is<core::type::Matrix>());
+    ASSERT_TRUE(TypeOf(c_s)->Is<core::type::Struct>());
 
     EXPECT_TRUE(Sem().Get(c_i32)->ConstantValue()->AllZero());
     EXPECT_TRUE(Sem().Get(c_u32)->ConstantValue()->AllZero());
@@ -976,19 +976,19 @@
     EXPECT_EQ(Sem().Get(c_maf32)->Declaration(), c_maf32);
     EXPECT_EQ(Sem().Get(c_s)->Declaration(), c_s);
 
-    ASSERT_TRUE(TypeOf(c_i32)->Is<type::I32>());
-    ASSERT_TRUE(TypeOf(c_u32)->Is<type::U32>());
-    ASSERT_TRUE(TypeOf(c_f32)->Is<type::F32>());
-    ASSERT_TRUE(TypeOf(c_ai)->Is<type::AbstractInt>());
-    ASSERT_TRUE(TypeOf(c_af)->Is<type::AbstractFloat>());
-    ASSERT_TRUE(TypeOf(c_vi32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(c_vu32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(c_vf32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(c_vai)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(c_vaf)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(c_mf32)->Is<type::Matrix>());
-    ASSERT_TRUE(TypeOf(c_maf32)->Is<type::Matrix>());
-    ASSERT_TRUE(TypeOf(c_s)->Is<type::Struct>());
+    ASSERT_TRUE(TypeOf(c_i32)->Is<core::type::I32>());
+    ASSERT_TRUE(TypeOf(c_u32)->Is<core::type::U32>());
+    ASSERT_TRUE(TypeOf(c_f32)->Is<core::type::F32>());
+    ASSERT_TRUE(TypeOf(c_ai)->Is<core::type::AbstractInt>());
+    ASSERT_TRUE(TypeOf(c_af)->Is<core::type::AbstractFloat>());
+    ASSERT_TRUE(TypeOf(c_vi32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(c_vu32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(c_vf32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(c_vai)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(c_vaf)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(c_mf32)->Is<core::type::Matrix>());
+    ASSERT_TRUE(TypeOf(c_maf32)->Is<core::type::Matrix>());
+    ASSERT_TRUE(TypeOf(c_s)->Is<core::type::Struct>());
 
     EXPECT_TRUE(Sem().Get(c_i32)->ConstantValue()->AllZero());
     EXPECT_TRUE(Sem().Get(c_u32)->ConstantValue()->AllZero());
@@ -1014,7 +1014,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(c)->Is<type::I32>());
+    ASSERT_TRUE(TypeOf(c)->Is<core::type::I32>());
 
     EXPECT_EQ(Sem().Get(c)->ConstantValue()->ValueAs<i32>(), 42_i);
 }
@@ -1026,7 +1026,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(c)->Is<type::I32>());
+    ASSERT_TRUE(TypeOf(c)->Is<core::type::I32>());
 
     EXPECT_EQ(Sem().Get(c)->ConstantValue()->ValueAs<i32>(), 3_i);
 }
@@ -1044,22 +1044,22 @@
         GlobalVar("ub", ty.Of(buf), core::AddressSpace::kUniform, Binding(0_a), Group(0_a));
     auto* storage =
         GlobalVar("sb", ty.Of(buf), core::AddressSpace::kStorage, Binding(1_a), Group(0_a));
-    auto* handle =
-        GlobalVar("h", ty.depth_texture(type::TextureDimension::k2d), Binding(2_a), Group(0_a));
+    auto* handle = GlobalVar("h", ty.depth_texture(core::type::TextureDimension::k2d), Binding(2_a),
+                             Group(0_a));
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(private_)->Is<type::Reference>());
-    ASSERT_TRUE(TypeOf(workgroup)->Is<type::Reference>());
-    ASSERT_TRUE(TypeOf(uniform)->Is<type::Reference>());
-    ASSERT_TRUE(TypeOf(storage)->Is<type::Reference>());
-    ASSERT_TRUE(TypeOf(handle)->Is<type::Reference>());
+    ASSERT_TRUE(TypeOf(private_)->Is<core::type::Reference>());
+    ASSERT_TRUE(TypeOf(workgroup)->Is<core::type::Reference>());
+    ASSERT_TRUE(TypeOf(uniform)->Is<core::type::Reference>());
+    ASSERT_TRUE(TypeOf(storage)->Is<core::type::Reference>());
+    ASSERT_TRUE(TypeOf(handle)->Is<core::type::Reference>());
 
-    EXPECT_EQ(TypeOf(private_)->As<type::Reference>()->Access(), core::Access::kReadWrite);
-    EXPECT_EQ(TypeOf(workgroup)->As<type::Reference>()->Access(), core::Access::kReadWrite);
-    EXPECT_EQ(TypeOf(uniform)->As<type::Reference>()->Access(), core::Access::kRead);
-    EXPECT_EQ(TypeOf(storage)->As<type::Reference>()->Access(), core::Access::kRead);
-    EXPECT_EQ(TypeOf(handle)->As<type::Reference>()->Access(), core::Access::kRead);
+    EXPECT_EQ(TypeOf(private_)->As<core::type::Reference>()->Access(), core::Access::kReadWrite);
+    EXPECT_EQ(TypeOf(workgroup)->As<core::type::Reference>()->Access(), core::Access::kReadWrite);
+    EXPECT_EQ(TypeOf(uniform)->As<core::type::Reference>()->Access(), core::Access::kRead);
+    EXPECT_EQ(TypeOf(storage)->As<core::type::Reference>()->Access(), core::Access::kRead);
+    EXPECT_EQ(TypeOf(handle)->As<core::type::Reference>()->Access(), core::Access::kRead);
 }
 
 TEST_F(ResolverVariableTest, GlobalVar_ExplicitAddressSpace) {
@@ -1071,9 +1071,9 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(storage)->Is<type::Reference>());
+    ASSERT_TRUE(TypeOf(storage)->Is<core::type::Reference>());
 
-    EXPECT_EQ(TypeOf(storage)->As<type::Reference>()->Access(), core::Access::kReadWrite);
+    EXPECT_EQ(TypeOf(storage)->As<core::type::Reference>()->Access(), core::Access::kReadWrite);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1098,13 +1098,13 @@
     EXPECT_EQ(Sem().Get(c_vf32)->Declaration(), c_vf32);
     EXPECT_EQ(Sem().Get(c_mf32)->Declaration(), c_mf32);
 
-    ASSERT_TRUE(TypeOf(c_i32)->Is<type::I32>());
-    ASSERT_TRUE(TypeOf(c_u32)->Is<type::U32>());
-    ASSERT_TRUE(TypeOf(c_f32)->Is<type::F32>());
-    ASSERT_TRUE(TypeOf(c_vi32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(c_vu32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(c_vf32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(c_mf32)->Is<type::Matrix>());
+    ASSERT_TRUE(TypeOf(c_i32)->Is<core::type::I32>());
+    ASSERT_TRUE(TypeOf(c_u32)->Is<core::type::U32>());
+    ASSERT_TRUE(TypeOf(c_f32)->Is<core::type::F32>());
+    ASSERT_TRUE(TypeOf(c_vi32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(c_vu32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(c_vf32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(c_mf32)->Is<core::type::Matrix>());
 
     EXPECT_TRUE(Sem().Get(c_i32)->ConstantValue()->AllZero());
     EXPECT_TRUE(Sem().Get(c_u32)->ConstantValue()->AllZero());
@@ -1147,18 +1147,18 @@
     EXPECT_EQ(Sem().Get(c_mf32)->Declaration(), c_mf32);
     EXPECT_EQ(Sem().Get(c_maf32)->Declaration(), c_maf32);
 
-    ASSERT_TRUE(TypeOf(c_i32)->Is<type::I32>());
-    ASSERT_TRUE(TypeOf(c_u32)->Is<type::U32>());
-    ASSERT_TRUE(TypeOf(c_f32)->Is<type::F32>());
-    ASSERT_TRUE(TypeOf(c_ai)->Is<type::AbstractInt>());
-    ASSERT_TRUE(TypeOf(c_af)->Is<type::AbstractFloat>());
-    ASSERT_TRUE(TypeOf(c_vi32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(c_vu32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(c_vf32)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(c_vai)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(c_vaf)->Is<type::Vector>());
-    ASSERT_TRUE(TypeOf(c_mf32)->Is<type::Matrix>());
-    ASSERT_TRUE(TypeOf(c_maf32)->Is<type::Matrix>());
+    ASSERT_TRUE(TypeOf(c_i32)->Is<core::type::I32>());
+    ASSERT_TRUE(TypeOf(c_u32)->Is<core::type::U32>());
+    ASSERT_TRUE(TypeOf(c_f32)->Is<core::type::F32>());
+    ASSERT_TRUE(TypeOf(c_ai)->Is<core::type::AbstractInt>());
+    ASSERT_TRUE(TypeOf(c_af)->Is<core::type::AbstractFloat>());
+    ASSERT_TRUE(TypeOf(c_vi32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(c_vu32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(c_vf32)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(c_vai)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(c_vaf)->Is<core::type::Vector>());
+    ASSERT_TRUE(TypeOf(c_mf32)->Is<core::type::Matrix>());
+    ASSERT_TRUE(TypeOf(c_maf32)->Is<core::type::Matrix>());
 
     EXPECT_TRUE(Sem().Get(c_i32)->ConstantValue()->AllZero());
     EXPECT_TRUE(Sem().Get(c_u32)->ConstantValue()->AllZero());
@@ -1181,7 +1181,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(c)->Is<type::I32>());
+    ASSERT_TRUE(TypeOf(c)->Is<core::type::I32>());
 
     EXPECT_EQ(Sem().Get(c)->ConstantValue()->ValueAs<i32>(), 42_i);
 }
@@ -1191,7 +1191,7 @@
 
     ASSERT_TRUE(r()->Resolve()) << r()->error();
 
-    ASSERT_TRUE(TypeOf(c)->Is<type::I32>());
+    ASSERT_TRUE(TypeOf(c)->Is<core::type::I32>());
 
     EXPECT_EQ(Sem().Get(c)->ConstantValue()->ValueAs<i32>(), 3_i);
 }
diff --git a/src/tint/lang/wgsl/resolver/variable_validation_test.cc b/src/tint/lang/wgsl/resolver/variable_validation_test.cc
index 20e50e8..c7abf4e 100644
--- a/src/tint/lang/wgsl/resolver/variable_validation_test.cc
+++ b/src/tint/lang/wgsl/resolver/variable_validation_test.cc
@@ -144,7 +144,7 @@
 TEST_F(ResolverVariableValidationTest, LetTypeNotConstructible) {
     // @group(0) @binding(0) var t1 : texture_2d<f32>;
     // let t2 : t1;
-    auto* t1 = GlobalVar("t1", ty.sampled_texture(type::TextureDimension::k2d, ty.f32()),
+    auto* t1 = GlobalVar("t1", ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()),
                          Group(0_a), Binding(0_a));
     auto* t2 = Let(Source{{56, 78}}, "t2", Expr(t1));
     WrapInFunction(t2);
@@ -367,7 +367,7 @@
     // fn foo() {
     //   var v = s;
     // }
-    GlobalVar("s", ty.sampler(type::SamplerKind::kSampler), Group(0_a), Binding(0_a));
+    GlobalVar("s", ty.sampler(core::type::SamplerKind::kSampler), Group(0_a), Binding(0_a));
     auto* v = Var(Source{{12, 34}}, "v", Expr("s"));
     WrapInFunction(v);
 
diff --git a/src/tint/lang/wgsl/sem/accessor_expression.cc b/src/tint/lang/wgsl/sem/accessor_expression.cc
index a0e3218..5872d3a 100644
--- a/src/tint/lang/wgsl/sem/accessor_expression.cc
+++ b/src/tint/lang/wgsl/sem/accessor_expression.cc
@@ -23,7 +23,7 @@
 namespace tint::sem {
 
 AccessorExpression::AccessorExpression(const ast::AccessorExpression* declaration,
-                                       const type::Type* type,
+                                       const core::type::Type* type,
                                        core::EvaluationStage stage,
                                        const ValueExpression* object,
                                        const Statement* statement,
diff --git a/src/tint/lang/wgsl/sem/accessor_expression.h b/src/tint/lang/wgsl/sem/accessor_expression.h
index b89db50..b7090a4 100644
--- a/src/tint/lang/wgsl/sem/accessor_expression.h
+++ b/src/tint/lang/wgsl/sem/accessor_expression.h
@@ -48,7 +48,7 @@
     /// @param has_side_effects whether this expression may have side effects
     /// @param root_ident the (optional) root identifier for this expression
     AccessorExpression(const ast::AccessorExpression* declaration,
-                       const type::Type* type,
+                       const core::type::Type* type,
                        core::EvaluationStage stage,
                        const ValueExpression* object,
                        const Statement* statement,
diff --git a/src/tint/lang/wgsl/sem/array_count.cc b/src/tint/lang/wgsl/sem/array_count.cc
index 407d6b2..84aaafb 100644
--- a/src/tint/lang/wgsl/sem/array_count.cc
+++ b/src/tint/lang/wgsl/sem/array_count.cc
@@ -37,7 +37,7 @@
     return variable->Declaration()->name->symbol.Name();
 }
 
-type::ArrayCount* NamedOverrideArrayCount::Clone(type::CloneContext&) const {
+core::type::ArrayCount* NamedOverrideArrayCount::Clone(core::type::CloneContext&) const {
     TINT_UNREACHABLE() << "Named override array count clone not available";
     return nullptr;
 }
@@ -58,7 +58,7 @@
     return "[unnamed override-expression]";
 }
 
-type::ArrayCount* UnnamedOverrideArrayCount::Clone(type::CloneContext&) const {
+core::type::ArrayCount* UnnamedOverrideArrayCount::Clone(core::type::CloneContext&) const {
     TINT_UNREACHABLE() << "Unnamed override array count clone not available";
     return nullptr;
 }
diff --git a/src/tint/lang/wgsl/sem/array_count.h b/src/tint/lang/wgsl/sem/array_count.h
index 82f8f51..87bf5ac 100644
--- a/src/tint/lang/wgsl/sem/array_count.h
+++ b/src/tint/lang/wgsl/sem/array_count.h
@@ -29,7 +29,8 @@
 /// override N : i32;
 /// type arr = array<i32, N>
 /// ```
-class NamedOverrideArrayCount final : public Castable<NamedOverrideArrayCount, type::ArrayCount> {
+class NamedOverrideArrayCount final
+    : public Castable<NamedOverrideArrayCount, core::type::ArrayCount> {
   public:
     /// Constructor
     /// @param var the `override` variable
@@ -38,14 +39,14 @@
 
     /// @param other the other node
     /// @returns true if this array count is equal @p other
-    bool Equals(const type::UniqueNode& other) const override;
+    bool Equals(const core::type::UniqueNode& other) const override;
 
     /// @returns the friendly name for this array count
     std::string FriendlyName() const override;
 
     /// @param ctx the clone context
     /// @returns a clone of this type
-    type::ArrayCount* Clone(type::CloneContext& ctx) const override;
+    core::type::ArrayCount* Clone(core::type::CloneContext& ctx) const override;
 
     /// The `override` variable.
     const GlobalVariable* variable;
@@ -58,7 +59,7 @@
 /// type arr = array<i32, N*2>
 /// ```
 class UnnamedOverrideArrayCount final
-    : public Castable<UnnamedOverrideArrayCount, type::ArrayCount> {
+    : public Castable<UnnamedOverrideArrayCount, core::type::ArrayCount> {
   public:
     /// Constructor
     /// @param e the override expression
@@ -67,14 +68,14 @@
 
     /// @param other the other node
     /// @returns true if this array count is equal @p other
-    bool Equals(const type::UniqueNode& other) const override;
+    bool Equals(const core::type::UniqueNode& other) const override;
 
     /// @returns the friendly name for this array count
     std::string FriendlyName() const override;
 
     /// @param ctx the clone context
     /// @returns a clone of this type
-    type::ArrayCount* Clone(type::CloneContext& ctx) const override;
+    core::type::ArrayCount* Clone(core::type::CloneContext& ctx) const override;
 
     /// The unnamed override expression.
     /// Note: Each AST expression gets a unique semantic expression node, so two equivalent AST
diff --git a/src/tint/lang/wgsl/sem/builtin.cc b/src/tint/lang/wgsl/sem/builtin.cc
index 73908c4..ece6ded 100644
--- a/src/tint/lang/wgsl/sem/builtin.cc
+++ b/src/tint/lang/wgsl/sem/builtin.cc
@@ -31,7 +31,7 @@
 }
 
 Builtin::Builtin(core::Function type,
-                 const type::Type* return_type,
+                 const core::type::Type* return_type,
                  VectorRef<Parameter*> parameters,
                  core::EvaluationStage eval_stage,
                  PipelineStageSet supported_stages,
diff --git a/src/tint/lang/wgsl/sem/builtin.h b/src/tint/lang/wgsl/sem/builtin.h
index 82773d5..64ee5c2 100644
--- a/src/tint/lang/wgsl/sem/builtin.h
+++ b/src/tint/lang/wgsl/sem/builtin.h
@@ -38,7 +38,7 @@
     /// @param is_deprecated true if the particular overload is considered deprecated
     /// @param must_use true if the builtin was annotated with `@must_use`
     Builtin(core::Function type,
-            const type::Type* return_type,
+            const core::type::Type* return_type,
             VectorRef<Parameter*> parameters,
             core::EvaluationStage eval_stage,
             PipelineStageSet supported_stages,
diff --git a/src/tint/lang/wgsl/sem/builtin_enum_expression.h b/src/tint/lang/wgsl/sem/builtin_enum_expression.h
index fb56aea..06cb2ef 100644
--- a/src/tint/lang/wgsl/sem/builtin_enum_expression.h
+++ b/src/tint/lang/wgsl/sem/builtin_enum_expression.h
@@ -18,9 +18,9 @@
 #include "src/tint/lang/wgsl/sem/expression.h"
 
 // Forward declarations
-namespace tint::type {
+namespace tint::core::type {
 class Type;
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 namespace tint::sem {
 
diff --git a/src/tint/lang/wgsl/sem/call_target.cc b/src/tint/lang/wgsl/sem/call_target.cc
index 08f709a..a2923c1 100644
--- a/src/tint/lang/wgsl/sem/call_target.cc
+++ b/src/tint/lang/wgsl/sem/call_target.cc
@@ -26,7 +26,7 @@
 CallTarget::CallTarget(core::EvaluationStage stage, bool must_use)
     : stage_(stage), must_use_(must_use) {}
 
-CallTarget::CallTarget(const type::Type* return_type,
+CallTarget::CallTarget(const core::type::Type* return_type,
                        VectorRef<Parameter*> parameters,
                        core::EvaluationStage stage,
                        bool must_use)
@@ -43,7 +43,7 @@
 
 CallTargetSignature::CallTargetSignature() = default;
 
-CallTargetSignature::CallTargetSignature(const type::Type* ret_ty,
+CallTargetSignature::CallTargetSignature(const core::type::Type* ret_ty,
                                          VectorRef<const sem::Parameter*> params)
     : return_type(ret_ty), parameters(std::move(params)) {}
 CallTargetSignature::CallTargetSignature(const CallTargetSignature&) = default;
diff --git a/src/tint/lang/wgsl/sem/call_target.h b/src/tint/lang/wgsl/sem/call_target.h
index 075b644..1b97aa7 100644
--- a/src/tint/lang/wgsl/sem/call_target.h
+++ b/src/tint/lang/wgsl/sem/call_target.h
@@ -33,7 +33,7 @@
     /// Constructor
     /// @param ret_ty the call target return type
     /// @param params the call target parameters
-    CallTargetSignature(const type::Type* ret_ty, VectorRef<const Parameter*> params);
+    CallTargetSignature(const core::type::Type* ret_ty, VectorRef<const Parameter*> params);
 
     /// Copy constructor
     CallTargetSignature(const CallTargetSignature&);
@@ -42,7 +42,7 @@
     ~CallTargetSignature();
 
     /// The type of the call target return value
-    const type::Type* return_type = nullptr;
+    const core::type::Type* return_type = nullptr;
     /// The parameters of the call target
     tint::Vector<const sem::Parameter*, 8> parameters;
 
@@ -81,7 +81,7 @@
     /// @param stage the earliest evaluation stage for a call to this target
     /// @param must_use the result of the call target must be used, i.e. it cannot be used as a call
     /// statement.
-    CallTarget(const type::Type* return_type,
+    CallTarget(const core::type::Type* return_type,
                VectorRef<Parameter*> parameters,
                core::EvaluationStage stage,
                bool must_use);
@@ -94,10 +94,10 @@
 
     /// Sets the call target's return type
     /// @param ty the parameter
-    void SetReturnType(const type::Type* ty) { signature_.return_type = ty; }
+    void SetReturnType(const core::type::Type* ty) { signature_.return_type = ty; }
 
     /// @return the return type of the call target
-    const type::Type* ReturnType() const { return signature_.return_type; }
+    const core::type::Type* ReturnType() const { return signature_.return_type; }
 
     /// Adds a parameter to the call target
     /// @param parameter the parameter
diff --git a/src/tint/lang/wgsl/sem/function.cc b/src/tint/lang/wgsl/sem/function.cc
index bde4a9d..1d1b9e3 100644
--- a/src/tint/lang/wgsl/sem/function.cc
+++ b/src/tint/lang/wgsl/sem/function.cc
@@ -98,11 +98,11 @@
 }
 
 Function::VariableBindings Function::TransitivelyReferencedSamplerVariables() const {
-    return TransitivelyReferencedSamplerVariablesImpl(type::SamplerKind::kSampler);
+    return TransitivelyReferencedSamplerVariablesImpl(core::type::SamplerKind::kSampler);
 }
 
 Function::VariableBindings Function::TransitivelyReferencedComparisonSamplerVariables() const {
-    return TransitivelyReferencedSamplerVariablesImpl(type::SamplerKind::kComparisonSampler);
+    return TransitivelyReferencedSamplerVariablesImpl(core::type::SamplerKind::kComparisonSampler);
 }
 
 Function::VariableBindings Function::TransitivelyReferencedSampledTextureVariables() const {
@@ -137,12 +137,12 @@
 }
 
 Function::VariableBindings Function::TransitivelyReferencedSamplerVariablesImpl(
-    type::SamplerKind kind) const {
+    core::type::SamplerKind kind) const {
     VariableBindings ret;
 
     for (auto* global : TransitivelyReferencedGlobals()) {
         auto* unwrapped_type = global->Type()->UnwrapRef();
-        auto* sampler = unwrapped_type->As<type::Sampler>();
+        auto* sampler = unwrapped_type->As<core::type::Sampler>();
         if (sampler == nullptr || sampler->kind() != kind) {
             continue;
         }
@@ -160,13 +160,13 @@
 
     for (auto* global : TransitivelyReferencedGlobals()) {
         auto* unwrapped_type = global->Type()->UnwrapRef();
-        auto* texture = unwrapped_type->As<type::Texture>();
+        auto* texture = unwrapped_type->As<core::type::Texture>();
         if (texture == nullptr) {
             continue;
         }
 
-        auto is_multisampled = texture->Is<type::MultisampledTexture>();
-        auto is_sampled = texture->Is<type::SampledTexture>();
+        auto is_multisampled = texture->Is<core::type::MultisampledTexture>();
+        auto is_sampled = texture->Is<core::type::SampledTexture>();
 
         if ((multisampled && !is_multisampled) || (!multisampled && !is_sampled)) {
             continue;
diff --git a/src/tint/lang/wgsl/sem/function.h b/src/tint/lang/wgsl/sem/function.h
index 10af0f0..5638dbd 100644
--- a/src/tint/lang/wgsl/sem/function.h
+++ b/src/tint/lang/wgsl/sem/function.h
@@ -279,7 +279,7 @@
     Function(const Function&) = delete;
     Function(Function&&) = delete;
 
-    VariableBindings TransitivelyReferencedSamplerVariablesImpl(type::SamplerKind kind) const;
+    VariableBindings TransitivelyReferencedSamplerVariablesImpl(core::type::SamplerKind kind) const;
     VariableBindings TransitivelyReferencedSampledTextureVariablesImpl(bool multisampled) const;
 
     const ast::Function* const declaration_;
diff --git a/src/tint/lang/wgsl/sem/index_accessor_expression.cc b/src/tint/lang/wgsl/sem/index_accessor_expression.cc
index 1386780..1e3712d 100644
--- a/src/tint/lang/wgsl/sem/index_accessor_expression.cc
+++ b/src/tint/lang/wgsl/sem/index_accessor_expression.cc
@@ -23,7 +23,7 @@
 namespace tint::sem {
 
 IndexAccessorExpression::IndexAccessorExpression(const ast::IndexAccessorExpression* declaration,
-                                                 const type::Type* type,
+                                                 const core::type::Type* type,
                                                  core::EvaluationStage stage,
                                                  const ValueExpression* object,
                                                  const ValueExpression* index,
diff --git a/src/tint/lang/wgsl/sem/index_accessor_expression.h b/src/tint/lang/wgsl/sem/index_accessor_expression.h
index fb9dfc0..b91b4d8 100644
--- a/src/tint/lang/wgsl/sem/index_accessor_expression.h
+++ b/src/tint/lang/wgsl/sem/index_accessor_expression.h
@@ -36,7 +36,7 @@
     /// @param has_side_effects whether this expression may have side effects
     /// @param root_ident the (optional) root identifier for this expression
     IndexAccessorExpression(const ast::IndexAccessorExpression* declaration,
-                            const type::Type* type,
+                            const core::type::Type* type,
                             core::EvaluationStage stage,
                             const ValueExpression* object,
                             const ValueExpression* index,
diff --git a/src/tint/lang/wgsl/sem/info.h b/src/tint/lang/wgsl/sem/info.h
index 009cf6a..3cdbc9a 100644
--- a/src/tint/lang/wgsl/sem/info.h
+++ b/src/tint/lang/wgsl/sem/info.h
@@ -32,10 +32,10 @@
 class Module;
 class ValueExpression;
 }  // namespace tint::sem
-namespace tint::type {
+namespace tint::core::type {
 class Node;
 class Type;
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 namespace tint::sem {
 
diff --git a/src/tint/lang/wgsl/sem/load.cc b/src/tint/lang/wgsl/sem/load.cc
index 85eea03..60eb221 100644
--- a/src/tint/lang/wgsl/sem/load.cc
+++ b/src/tint/lang/wgsl/sem/load.cc
@@ -29,7 +29,7 @@
            /* has_side_effects */ ref->HasSideEffects(),
            /* root_ident */ ref->RootIdentifier()),
       reference_(ref) {
-    TINT_ASSERT(ref->Type()->Is<type::Reference>());
+    TINT_ASSERT(ref->Type()->Is<core::type::Reference>());
 }
 
 Load::~Load() = default;
diff --git a/src/tint/lang/wgsl/sem/load.h b/src/tint/lang/wgsl/sem/load.h
index 705f4b1..ba8f488 100644
--- a/src/tint/lang/wgsl/sem/load.h
+++ b/src/tint/lang/wgsl/sem/load.h
@@ -37,8 +37,8 @@
     const ValueExpression* Reference() const { return reference_; }
 
     /// @returns the type of the loaded reference.
-    const type::Reference* ReferenceType() const {
-        return static_cast<const type::Reference*>(reference_->Type());
+    const core::type::Reference* ReferenceType() const {
+        return static_cast<const core::type::Reference*>(reference_->Type());
     }
 
   private:
diff --git a/src/tint/lang/wgsl/sem/materialize.cc b/src/tint/lang/wgsl/sem/materialize.cc
index 2f3769c..c372e6d 100644
--- a/src/tint/lang/wgsl/sem/materialize.cc
+++ b/src/tint/lang/wgsl/sem/materialize.cc
@@ -19,7 +19,7 @@
 namespace tint::sem {
 Materialize::Materialize(const ValueExpression* expr,
                          const Statement* statement,
-                         const type::Type* type,
+                         const core::type::Type* type,
                          const core::constant::Value* constant)
     : Base(/* declaration */ expr->Declaration(),
            /* type */ type,
diff --git a/src/tint/lang/wgsl/sem/materialize.h b/src/tint/lang/wgsl/sem/materialize.h
index af8389f..319eb8f 100644
--- a/src/tint/lang/wgsl/sem/materialize.h
+++ b/src/tint/lang/wgsl/sem/materialize.h
@@ -34,7 +34,7 @@
     /// @param constant the constant value of this expression or nullptr
     Materialize(const ValueExpression* expr,
                 const Statement* statement,
-                const type::Type* type,
+                const core::type::Type* type,
                 const core::constant::Value* constant);
 
     /// Destructor
diff --git a/src/tint/lang/wgsl/sem/member_accessor_expression.cc b/src/tint/lang/wgsl/sem/member_accessor_expression.cc
index 7fdf91d..4051e66 100644
--- a/src/tint/lang/wgsl/sem/member_accessor_expression.cc
+++ b/src/tint/lang/wgsl/sem/member_accessor_expression.cc
@@ -24,7 +24,7 @@
 namespace tint::sem {
 
 MemberAccessorExpression::MemberAccessorExpression(const ast::MemberAccessorExpression* declaration,
-                                                   const type::Type* type,
+                                                   const core::type::Type* type,
                                                    core::EvaluationStage stage,
                                                    const Statement* statement,
                                                    const core::constant::Value* constant,
@@ -36,11 +36,11 @@
 MemberAccessorExpression::~MemberAccessorExpression() = default;
 
 StructMemberAccess::StructMemberAccess(const ast::MemberAccessorExpression* declaration,
-                                       const type::Type* type,
+                                       const core::type::Type* type,
                                        const Statement* statement,
                                        const core::constant::Value* constant,
                                        const ValueExpression* object,
-                                       const type::StructMember* member,
+                                       const core::type::StructMember* member,
                                        bool has_side_effects,
                                        const Variable* root_ident /* = nullptr */)
     : Base(declaration,
@@ -56,7 +56,7 @@
 StructMemberAccess::~StructMemberAccess() = default;
 
 Swizzle::Swizzle(const ast::MemberAccessorExpression* declaration,
-                 const type::Type* type,
+                 const core::type::Type* type,
                  const Statement* statement,
                  const core::constant::Value* constant,
                  const ValueExpression* object,
diff --git a/src/tint/lang/wgsl/sem/member_accessor_expression.h b/src/tint/lang/wgsl/sem/member_accessor_expression.h
index e7b6a20..a84496a 100644
--- a/src/tint/lang/wgsl/sem/member_accessor_expression.h
+++ b/src/tint/lang/wgsl/sem/member_accessor_expression.h
@@ -22,9 +22,9 @@
 namespace tint::ast {
 class MemberAccessorExpression;
 }  // namespace tint::ast
-namespace tint::type {
+namespace tint::core::type {
 class StructMember;
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 namespace tint::sem {
 
@@ -46,7 +46,7 @@
     /// @param has_side_effects whether this expression may have side effects
     /// @param root_ident the (optional) root identifier for this expression
     MemberAccessorExpression(const ast::MemberAccessorExpression* declaration,
-                             const type::Type* type,
+                             const core::type::Type* type,
                              core::EvaluationStage stage,
                              const Statement* statement,
                              const core::constant::Value* constant,
@@ -70,11 +70,11 @@
     /// @param has_side_effects whether this expression may have side effects
     /// @param root_ident the (optional) root identifier for this expression
     StructMemberAccess(const ast::MemberAccessorExpression* declaration,
-                       const type::Type* type,
+                       const core::type::Type* type,
                        const Statement* statement,
                        const core::constant::Value* constant,
                        const ValueExpression* object,
-                       const type::StructMember* member,
+                       const core::type::StructMember* member,
                        bool has_side_effects,
                        const Variable* root_ident = nullptr);
 
@@ -82,10 +82,10 @@
     ~StructMemberAccess() override;
 
     /// @returns the structure member
-    type::StructMember const* Member() const { return member_; }
+    core::type::StructMember const* Member() const { return member_; }
 
   private:
-    type::StructMember const* const member_;
+    core::type::StructMember const* const member_;
 };
 
 /// Swizzle holds the semantic information for a ast::MemberAccessorExpression
@@ -102,7 +102,7 @@
     /// @param has_side_effects whether this expression may have side effects
     /// @param root_ident the (optional) root identifier for this expression
     Swizzle(const ast::MemberAccessorExpression* declaration,
-            const type::Type* type,
+            const core::type::Type* type,
             const Statement* statement,
             const core::constant::Value* constant,
             const ValueExpression* object,
diff --git a/src/tint/lang/wgsl/sem/struct.cc b/src/tint/lang/wgsl/sem/struct.cc
index 07d79f8..ed82c54 100644
--- a/src/tint/lang/wgsl/sem/struct.cc
+++ b/src/tint/lang/wgsl/sem/struct.cc
@@ -35,12 +35,12 @@
 
 StructMember::StructMember(const ast::StructMember* declaration,
                            Symbol name,
-                           const type::Type* type,
+                           const core::type::Type* type,
                            uint32_t index,
                            uint32_t offset,
                            uint32_t align,
                            uint32_t size,
-                           const type::StructMemberAttributes& attributes)
+                           const core::type::StructMemberAttributes& attributes)
     : Base(name, type, index, offset, align, size, attributes), declaration_(declaration) {
     TINT_ASSERT(declaration != nullptr);
 }
diff --git a/src/tint/lang/wgsl/sem/struct.h b/src/tint/lang/wgsl/sem/struct.h
index 1a483c5..77472aa 100644
--- a/src/tint/lang/wgsl/sem/struct.h
+++ b/src/tint/lang/wgsl/sem/struct.h
@@ -31,15 +31,15 @@
 namespace tint::sem {
 class StructMember;
 }  // namespace tint::sem
-namespace tint::type {
+namespace tint::core::type {
 class StructMember;
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 namespace tint::sem {
 
 /// Struct holds the semantic information for structures.
-/// Unlike type::Struct, sem::Struct has an AST declaration node.
-class Struct final : public Castable<Struct, type::Struct> {
+/// Unlike core::type::Struct, sem::Struct has an AST declaration node.
+class Struct final : public Castable<Struct, core::type::Struct> {
   public:
     /// Constructor
     /// @param declaration the AST structure declaration
@@ -71,8 +71,8 @@
 };
 
 /// StructMember holds the semantic information for structure members.
-/// Unlike type::StructMember, sem::StructMember has an AST declaration node.
-class StructMember final : public Castable<StructMember, type::StructMember> {
+/// Unlike core::type::StructMember, sem::StructMember has an AST declaration node.
+class StructMember final : public Castable<StructMember, core::type::StructMember> {
   public:
     /// Constructor
     /// @param declaration the AST declaration node
@@ -85,12 +85,12 @@
     /// @param attributes the optional attributes
     StructMember(const ast::StructMember* declaration,
                  Symbol name,
-                 const type::Type* type,
+                 const core::type::Type* type,
                  uint32_t index,
                  uint32_t offset,
                  uint32_t align,
                  uint32_t size,
-                 const type::StructMemberAttributes& attributes);
+                 const core::type::StructMemberAttributes& attributes);
 
     /// Destructor
     ~StructMember() override;
diff --git a/src/tint/lang/wgsl/sem/struct_test.cc b/src/tint/lang/wgsl/sem/struct_test.cc
index f6c3340..7b6c01a 100644
--- a/src/tint/lang/wgsl/sem/struct_test.cc
+++ b/src/tint/lang/wgsl/sem/struct_test.cc
@@ -44,7 +44,7 @@
 
     EXPECT_TRUE(a->Equals(*a));
     EXPECT_FALSE(a->Equals(*b));
-    EXPECT_FALSE(a->Equals(type::Void{}));
+    EXPECT_FALSE(a->Equals(core::type::Void{}));
 }
 
 TEST_F(SemStructTest, FriendlyName) {
diff --git a/src/tint/lang/wgsl/sem/type_expression.cc b/src/tint/lang/wgsl/sem/type_expression.cc
index aeab271..702c609 100644
--- a/src/tint/lang/wgsl/sem/type_expression.cc
+++ b/src/tint/lang/wgsl/sem/type_expression.cc
@@ -20,7 +20,7 @@
 
 TypeExpression::TypeExpression(const ast::Expression* declaration,
                                const Statement* statement,
-                               const type::Type* type)
+                               const core::type::Type* type)
     : Base(declaration, statement), type_(type) {}
 
 TypeExpression::~TypeExpression() = default;
diff --git a/src/tint/lang/wgsl/sem/type_expression.h b/src/tint/lang/wgsl/sem/type_expression.h
index 6850f8a..c8f9563 100644
--- a/src/tint/lang/wgsl/sem/type_expression.h
+++ b/src/tint/lang/wgsl/sem/type_expression.h
@@ -18,9 +18,9 @@
 #include "src/tint/lang/wgsl/sem/expression.h"
 
 // Forward declarations
-namespace tint::type {
+namespace tint::core::type {
 class Type;
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 namespace tint::sem {
 
@@ -33,16 +33,16 @@
     /// @param type the type that this expression resolved to
     TypeExpression(const ast::Expression* declaration,
                    const Statement* statement,
-                   const type::Type* type);
+                   const core::type::Type* type);
 
     /// Destructor
     ~TypeExpression() override;
 
     /// @return the type that the expression resolved to
-    const type::Type* Type() const { return type_; }
+    const core::type::Type* Type() const { return type_; }
 
   private:
-    type::Type const* const type_;
+    core::type::Type const* const type_;
 };
 
 }  // namespace tint::sem
diff --git a/src/tint/lang/wgsl/sem/type_mappings.h b/src/tint/lang/wgsl/sem/type_mappings.h
index 92c97e6..d8f3cc2 100644
--- a/src/tint/lang/wgsl/sem/type_mappings.h
+++ b/src/tint/lang/wgsl/sem/type_mappings.h
@@ -64,10 +64,10 @@
 class Variable;
 class WhileStatement;
 }  // namespace tint::sem
-namespace tint::type {
+namespace tint::core::type {
 class Array;
 class Type;
-}  // namespace tint::type
+}  // namespace tint::core::type
 
 namespace tint::sem {
 
@@ -88,7 +88,7 @@
     Struct* operator()(ast::Struct*);
     StructMember* operator()(ast::StructMember*);
     SwitchStatement* operator()(ast::SwitchStatement*);
-    type::Type* operator()(ast::TypeDecl*);
+    core::type::Type* operator()(ast::TypeDecl*);
     ValueExpression* operator()(ast::AccessorExpression*);
     ValueExpression* operator()(ast::BinaryExpression*);
     ValueExpression* operator()(ast::BitcastExpression*);
diff --git a/src/tint/lang/wgsl/sem/value_constructor.cc b/src/tint/lang/wgsl/sem/value_constructor.cc
index d7d1b11..db27756 100644
--- a/src/tint/lang/wgsl/sem/value_constructor.cc
+++ b/src/tint/lang/wgsl/sem/value_constructor.cc
@@ -20,7 +20,7 @@
 
 namespace tint::sem {
 
-ValueConstructor::ValueConstructor(const type::Type* type,
+ValueConstructor::ValueConstructor(const core::type::Type* type,
                                    VectorRef<Parameter*> parameters,
                                    core::EvaluationStage stage)
     : Base(type, std::move(parameters), stage, /* must_use */ true) {}
diff --git a/src/tint/lang/wgsl/sem/value_constructor.h b/src/tint/lang/wgsl/sem/value_constructor.h
index b6917fa..e39a219 100644
--- a/src/tint/lang/wgsl/sem/value_constructor.h
+++ b/src/tint/lang/wgsl/sem/value_constructor.h
@@ -27,7 +27,7 @@
     /// @param type the type that's being constructed
     /// @param parameters the constructor parameters
     /// @param stage the earliest evaluation stage for the expression
-    ValueConstructor(const type::Type* type,
+    ValueConstructor(const core::type::Type* type,
                      VectorRef<Parameter*> parameters,
                      core::EvaluationStage stage);
 
diff --git a/src/tint/lang/wgsl/sem/value_conversion.cc b/src/tint/lang/wgsl/sem/value_conversion.cc
index a47c9e5..a0f95a9 100644
--- a/src/tint/lang/wgsl/sem/value_conversion.cc
+++ b/src/tint/lang/wgsl/sem/value_conversion.cc
@@ -18,7 +18,7 @@
 
 namespace tint::sem {
 
-ValueConversion::ValueConversion(const type::Type* type,
+ValueConversion::ValueConversion(const core::type::Type* type,
                                  sem::Parameter* parameter,
                                  core::EvaluationStage stage)
     : Base(type, tint::Vector<sem::Parameter*, 1>{parameter}, stage, /* must_use */ true) {}
diff --git a/src/tint/lang/wgsl/sem/value_conversion.h b/src/tint/lang/wgsl/sem/value_conversion.h
index 8d7884b..84fb00b 100644
--- a/src/tint/lang/wgsl/sem/value_conversion.h
+++ b/src/tint/lang/wgsl/sem/value_conversion.h
@@ -26,16 +26,18 @@
     /// @param type the target type of the cast
     /// @param parameter the type cast parameter
     /// @param stage the earliest evaluation stage for the expression
-    ValueConversion(const type::Type* type, sem::Parameter* parameter, core::EvaluationStage stage);
+    ValueConversion(const core::type::Type* type,
+                    sem::Parameter* parameter,
+                    core::EvaluationStage stage);
 
     /// Destructor
     ~ValueConversion() override;
 
     /// @returns the cast source type
-    const type::Type* Source() const { return Parameters()[0]->Type(); }
+    const core::type::Type* Source() const { return Parameters()[0]->Type(); }
 
     /// @returns the cast target type
-    const type::Type* Target() const { return ReturnType(); }
+    const core::type::Type* Target() const { return ReturnType(); }
 };
 
 }  // namespace tint::sem
diff --git a/src/tint/lang/wgsl/sem/value_expression.cc b/src/tint/lang/wgsl/sem/value_expression.cc
index a5cb212..0e05199 100644
--- a/src/tint/lang/wgsl/sem/value_expression.cc
+++ b/src/tint/lang/wgsl/sem/value_expression.cc
@@ -25,7 +25,7 @@
 namespace tint::sem {
 
 ValueExpression::ValueExpression(const ast::Expression* declaration,
-                                 const type::Type* type,
+                                 const core::type::Type* type,
                                  core::EvaluationStage stage,
                                  const Statement* statement,
                                  const core::constant::Value* constant,
diff --git a/src/tint/lang/wgsl/sem/value_expression.h b/src/tint/lang/wgsl/sem/value_expression.h
index 4d3fad2..00d76b1 100644
--- a/src/tint/lang/wgsl/sem/value_expression.h
+++ b/src/tint/lang/wgsl/sem/value_expression.h
@@ -40,7 +40,7 @@
     /// @param has_side_effects true if this expression may have side-effects
     /// @param root_ident the (optional) root identifier for this expression
     ValueExpression(const ast::Expression* declaration,
-                    const type::Type* type,
+                    const core::type::Type* type,
                     core::EvaluationStage stage,
                     const Statement* statement,
                     const core::constant::Value* constant,
@@ -51,7 +51,7 @@
     ~ValueExpression() override;
 
     /// @return the resolved type of the expression
-    const type::Type* Type() const { return type_; }
+    const core::type::Type* Type() const { return type_; }
 
     /// @return the earliest evaluation stage for the expression
     core::EvaluationStage Stage() const { return stage_; }
@@ -89,7 +89,7 @@
     const Variable* root_identifier_;
 
   private:
-    const type::Type* const type_;
+    const core::type::Type* const type_;
     const core::EvaluationStage stage_;
     const core::constant::Value* const constant_;
     sem::Behaviors behaviors_{sem::Behavior::kNext};
diff --git a/src/tint/lang/wgsl/sem/value_expression_test.cc b/src/tint/lang/wgsl/sem/value_expression_test.cc
index 0999006..0c81147 100644
--- a/src/tint/lang/wgsl/sem/value_expression_test.cc
+++ b/src/tint/lang/wgsl/sem/value_expression_test.cc
@@ -25,9 +25,9 @@
 
 class MockConstant : public core::constant::Value {
   public:
-    explicit MockConstant(const type::Type* ty) : type(ty) {}
+    explicit MockConstant(const core::type::Type* ty) : type(ty) {}
     ~MockConstant() override {}
-    const type::Type* Type() const override { return type; }
+    const core::type::Type* Type() const override { return type; }
     const core::constant::Value* Index(size_t) const override { return {}; }
     size_t NumElements() const override { return 0; }
     bool AllZero() const override { return {}; }
@@ -39,14 +39,14 @@
     std::variant<std::monostate, AInt, AFloat> InternalValue() const override { return {}; }
 
   private:
-    const type::Type* type;
+    const core::type::Type* type;
 };
 
 using ValueExpressionTest = TestHelper;
 
 TEST_F(ValueExpressionTest, UnwrapMaterialize) {
-    MockConstant c(create<type::I32>());
-    auto* a = create<ValueExpression>(/* declaration */ nullptr, create<type::I32>(),
+    MockConstant c(create<core::type::I32>());
+    auto* a = create<ValueExpression>(/* declaration */ nullptr, create<core::type::I32>(),
                                       core::EvaluationStage::kRuntime, /* statement */ nullptr,
                                       /* constant_value */ nullptr,
                                       /* has_side_effects */ false, /* root_ident */ nullptr);
diff --git a/src/tint/lang/wgsl/sem/variable.cc b/src/tint/lang/wgsl/sem/variable.cc
index 97240d4..bfff38f 100644
--- a/src/tint/lang/wgsl/sem/variable.cc
+++ b/src/tint/lang/wgsl/sem/variable.cc
@@ -29,7 +29,7 @@
 
 namespace tint::sem {
 Variable::Variable(const ast::Variable* declaration,
-                   const type::Type* type,
+                   const core::type::Type* type,
                    core::EvaluationStage stage,
                    core::AddressSpace address_space,
                    core::Access access,
@@ -44,7 +44,7 @@
 Variable::~Variable() = default;
 
 LocalVariable::LocalVariable(const ast::Variable* declaration,
-                             const type::Type* type,
+                             const core::type::Type* type,
                              core::EvaluationStage stage,
                              core::AddressSpace address_space,
                              core::Access access,
@@ -56,7 +56,7 @@
 LocalVariable::~LocalVariable() = default;
 
 GlobalVariable::GlobalVariable(const ast::Variable* declaration,
-                               const type::Type* type,
+                               const core::type::Type* type,
                                core::EvaluationStage stage,
                                core::AddressSpace address_space,
                                core::Access access,
@@ -73,7 +73,7 @@
 
 Parameter::Parameter(const ast::Parameter* declaration,
                      uint32_t index,
-                     const type::Type* type,
+                     const core::type::Type* type,
                      core::AddressSpace address_space,
                      core::Access access,
                      const core::ParameterUsage usage /* = ParameterUsage::kNone */,
@@ -100,7 +100,7 @@
            /* has_side_effects */ false),
       variable_(variable) {
     auto* type = variable->Type();
-    if (type->Is<type::Pointer>() && variable->Initializer()) {
+    if (type->Is<core::type::Pointer>() && variable->Initializer()) {
         root_identifier_ = variable->Initializer()->RootIdentifier();
     } else {
         root_identifier_ = variable;
diff --git a/src/tint/lang/wgsl/sem/variable.h b/src/tint/lang/wgsl/sem/variable.h
index 9e127de..7b0f33d 100644
--- a/src/tint/lang/wgsl/sem/variable.h
+++ b/src/tint/lang/wgsl/sem/variable.h
@@ -55,7 +55,7 @@
     /// @param access the variable access control type
     /// @param constant_value the constant value for the variable. May be null
     Variable(const ast::Variable* declaration,
-             const type::Type* type,
+             const core::type::Type* type,
              core::EvaluationStage stage,
              core::AddressSpace address_space,
              core::Access access,
@@ -68,7 +68,7 @@
     const ast::Variable* Declaration() const { return declaration_; }
 
     /// @returns the canonical type for the variable
-    const type::Type* Type() const { return type_; }
+    const core::type::Type* Type() const { return type_; }
 
     /// @returns the evaluation stage for an expression of this variable type
     core::EvaluationStage Stage() const { return stage_; }
@@ -98,7 +98,7 @@
 
   private:
     const ast::Variable* const declaration_;
-    const type::Type* const type_;
+    const core::type::Type* const type_;
     const core::EvaluationStage stage_;
     const core::AddressSpace address_space_;
     const core::Access access_;
@@ -119,7 +119,7 @@
     /// @param statement the statement that declared this local variable
     /// @param constant_value the constant value for the variable. May be null
     LocalVariable(const ast::Variable* declaration,
-                  const type::Type* type,
+                  const core::type::Type* type,
                   core::EvaluationStage stage,
                   core::AddressSpace address_space,
                   core::Access access,
@@ -161,7 +161,7 @@
     /// Note, a GlobalVariable generally doesn't have a `location` in WGSL, as it isn't allowed by
     /// the spec. The location maybe attached by transforms such as CanonicalizeEntryPointIO.
     GlobalVariable(const ast::Variable* declaration,
-                   const type::Type* type,
+                   const core::type::Type* type,
                    core::EvaluationStage stage,
                    core::AddressSpace address_space,
                    core::Access access,
@@ -210,7 +210,7 @@
     /// @param location the location value, if set
     Parameter(const ast::Parameter* declaration,
               uint32_t index,
-              const type::Type* type,
+              const core::type::Type* type,
               core::AddressSpace address_space,
               core::Access access,
               const core::ParameterUsage usage = core::ParameterUsage::kNone,
diff --git a/src/tint/lang/wgsl/writer/ast_printer/global_decl_test.cc b/src/tint/lang/wgsl/writer/ast_printer/global_decl_test.cc
index 381afcb..dafff0e 100644
--- a/src/tint/lang/wgsl/writer/ast_printer/global_decl_test.cc
+++ b/src/tint/lang/wgsl/writer/ast_printer/global_decl_test.cc
@@ -108,7 +108,7 @@
 }
 
 TEST_F(WgslASTPrinterTest, Emit_Global_Sampler) {
-    GlobalVar("s", ty.sampler(type::SamplerKind::kSampler), Group(0_a), Binding(0_a));
+    GlobalVar("s", ty.sampler(core::type::SamplerKind::kSampler), Group(0_a), Binding(0_a));
 
     ASTPrinter& gen = Build();
 
@@ -119,7 +119,7 @@
 }
 
 TEST_F(WgslASTPrinterTest, Emit_Global_Texture) {
-    auto st = ty.sampled_texture(type::TextureDimension::k1d, ty.f32());
+    auto st = ty.sampled_texture(core::type::TextureDimension::k1d, ty.f32());
     GlobalVar("t", st, Group(0_a), Binding(0_a));
 
     ASTPrinter& gen = Build();
diff --git a/src/tint/lang/wgsl/writer/ast_printer/type_test.cc b/src/tint/lang/wgsl/writer/ast_printer/type_test.cc
index cca9f8b4..ccee176 100644
--- a/src/tint/lang/wgsl/writer/ast_printer/type_test.cc
+++ b/src/tint/lang/wgsl/writer/ast_printer/type_test.cc
@@ -401,7 +401,7 @@
 }
 
 struct TextureData {
-    type::TextureDimension dim;
+    core::type::TextureDimension dim;
     const char* name;
 };
 inline std::ostream& operator<<(std::ostream& out, TextureData data) {
@@ -425,10 +425,11 @@
 INSTANTIATE_TEST_SUITE_P(
     WgslASTPrinterTest,
     WgslGenerator_DepthTextureTest,
-    testing::Values(TextureData{type::TextureDimension::k2d, "texture_depth_2d"},
-                    TextureData{type::TextureDimension::k2dArray, "texture_depth_2d_array"},
-                    TextureData{type::TextureDimension::kCube, "texture_depth_cube"},
-                    TextureData{type::TextureDimension::kCubeArray, "texture_depth_cube_array"}));
+    testing::Values(TextureData{core::type::TextureDimension::k2d, "texture_depth_2d"},
+                    TextureData{core::type::TextureDimension::k2dArray, "texture_depth_2d_array"},
+                    TextureData{core::type::TextureDimension::kCube, "texture_depth_cube"},
+                    TextureData{core::type::TextureDimension::kCubeArray,
+                                "texture_depth_cube_array"}));
 
 using WgslGenerator_SampledTextureTest = TestParamHelper<TextureData>;
 TEST_P(WgslGenerator_SampledTextureTest, EmitType_SampledTexture_F32) {
@@ -475,12 +476,12 @@
 INSTANTIATE_TEST_SUITE_P(
     WgslASTPrinterTest,
     WgslGenerator_SampledTextureTest,
-    testing::Values(TextureData{type::TextureDimension::k1d, "texture_1d"},
-                    TextureData{type::TextureDimension::k2d, "texture_2d"},
-                    TextureData{type::TextureDimension::k2dArray, "texture_2d_array"},
-                    TextureData{type::TextureDimension::k3d, "texture_3d"},
-                    TextureData{type::TextureDimension::kCube, "texture_cube"},
-                    TextureData{type::TextureDimension::kCubeArray, "texture_cube_array"}));
+    testing::Values(TextureData{core::type::TextureDimension::k1d, "texture_1d"},
+                    TextureData{core::type::TextureDimension::k2d, "texture_2d"},
+                    TextureData{core::type::TextureDimension::k2dArray, "texture_2d_array"},
+                    TextureData{core::type::TextureDimension::k3d, "texture_3d"},
+                    TextureData{core::type::TextureDimension::kCube, "texture_cube"},
+                    TextureData{core::type::TextureDimension::kCubeArray, "texture_cube_array"}));
 
 using WgslGenerator_MultiampledTextureTest = TestParamHelper<TextureData>;
 TEST_P(WgslGenerator_MultiampledTextureTest, EmitType_MultisampledTexture_F32) {
@@ -526,12 +527,12 @@
 }
 INSTANTIATE_TEST_SUITE_P(WgslASTPrinterTest,
                          WgslGenerator_MultiampledTextureTest,
-                         testing::Values(TextureData{type::TextureDimension::k2d,
+                         testing::Values(TextureData{core::type::TextureDimension::k2d,
                                                      "texture_multisampled_2d"}));
 
 struct StorageTextureData {
     core::TexelFormat fmt;
-    type::TextureDimension dim;
+    core::type::TextureDimension dim;
     core::Access access;
     const char* name;
 };
@@ -557,13 +558,13 @@
     WgslASTPrinterTest,
     WgslGenerator_StorageTextureTest,
     testing::Values(
-        StorageTextureData{core::TexelFormat::kRgba8Sint, type::TextureDimension::k1d,
+        StorageTextureData{core::TexelFormat::kRgba8Sint, core::type::TextureDimension::k1d,
                            core::Access::kWrite, "texture_storage_1d<rgba8sint, write>"},
-        StorageTextureData{core::TexelFormat::kRgba8Sint, type::TextureDimension::k2d,
+        StorageTextureData{core::TexelFormat::kRgba8Sint, core::type::TextureDimension::k2d,
                            core::Access::kWrite, "texture_storage_2d<rgba8sint, write>"},
-        StorageTextureData{core::TexelFormat::kRgba8Sint, type::TextureDimension::k2dArray,
+        StorageTextureData{core::TexelFormat::kRgba8Sint, core::type::TextureDimension::k2dArray,
                            core::Access::kWrite, "texture_storage_2d_array<rgba8sint, write>"},
-        StorageTextureData{core::TexelFormat::kRgba8Sint, type::TextureDimension::k3d,
+        StorageTextureData{core::TexelFormat::kRgba8Sint, core::type::TextureDimension::k3d,
                            core::Access::kWrite, "texture_storage_3d<rgba8sint, write>"}));
 
 struct ImageFormatData {
@@ -607,7 +608,7 @@
                     ImageFormatData{core::TexelFormat::kRgba32Float, "rgba32float"}));
 
 TEST_F(WgslASTPrinterTest, EmitType_Sampler) {
-    auto sampler = ty.sampler(type::SamplerKind::kSampler);
+    auto sampler = ty.sampler(core::type::SamplerKind::kSampler);
     auto type = Alias("make_type_reachable", sampler)->type;
 
     ASTPrinter& gen = Build();
@@ -619,7 +620,7 @@
 }
 
 TEST_F(WgslASTPrinterTest, EmitType_SamplerComparison) {
-    auto sampler = ty.sampler(type::SamplerKind::kComparisonSampler);
+    auto sampler = ty.sampler(core::type::SamplerKind::kComparisonSampler);
     auto type = Alias("make_type_reachable", sampler)->type;
 
     ASTPrinter& gen = Build();
diff --git a/src/tint/lang/wgsl/writer/ast_printer/variable_test.cc b/src/tint/lang/wgsl/writer/ast_printer/variable_test.cc
index 9b78de5..83cb95d 100644
--- a/src/tint/lang/wgsl/writer/ast_printer/variable_test.cc
+++ b/src/tint/lang/wgsl/writer/ast_printer/variable_test.cc
@@ -73,7 +73,8 @@
 }
 
 TEST_F(WgslASTPrinterTest, EmitVariable_Decorated) {
-    auto* v = GlobalVar("a", ty.sampler(type::SamplerKind::kSampler), Group(1_a), Binding(2_a));
+    auto* v =
+        GlobalVar("a", ty.sampler(core::type::SamplerKind::kSampler), Group(1_a), Binding(2_a));
 
     ASTPrinter& gen = Build();
 
diff --git a/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc b/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc
index 129dc84..5b4fbc3 100644
--- a/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc
+++ b/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc
@@ -177,7 +177,7 @@
     Hashset<core::Extension, 4> enables_;
 
     /// Map of struct to output program name.
-    Hashmap<const type::Struct*, Symbol, 8> structs_;
+    Hashmap<const core::type::Struct*, Symbol, 8> structs_;
 
     /// True if 'diagnostic(off, derivative_uniformity)' has been emitted
     bool disabled_derivative_uniformity_ = false;
@@ -512,7 +512,7 @@
 
     void Var(ir::Var* var) {
         auto* val = var->Result();
-        auto* ptr = As<type::Pointer>(val->Type());
+        auto* ptr = As<core::type::Pointer>(val->Type());
         auto ty = Type(ptr->StoreType());
         Symbol name = NameFor(var->Result());
         Bind(var->Result(), name, PtrKind::kRef);
@@ -585,7 +585,7 @@
                 }
 
                 auto* expr = b.Call(c->Func(), std::move(args));
-                if (!call->HasResults() || call->Result()->Type()->Is<type::Void>()) {
+                if (!call->HasResults() || call->Result()->Type()->Is<core::type::Void>()) {
                     Append(b.CallStmt(expr));
                     return;
                 }
@@ -633,19 +633,19 @@
         for (auto* index : a->Indices()) {
             tint::Switch(
                 obj_ty,
-                [&](const type::Vector* vec) {
+                [&](const core::type::Vector* vec) {
                     TINT_DEFER(obj_ty = vec->type());
                     expr = VectorMemberAccess(expr, index);
                 },
-                [&](const type::Matrix* mat) {
+                [&](const core::type::Matrix* mat) {
                     obj_ty = mat->ColumnType();
                     expr = b.IndexAccessor(expr, Expr(index));
                 },
-                [&](const type::Array* arr) {
+                [&](const core::type::Array* arr) {
                     obj_ty = arr->ElemType();
                     expr = b.IndexAccessor(expr, Expr(index));
                 },
-                [&](const type::Struct* s) {
+                [&](const core::type::Struct* s) {
                     if (auto* c = index->As<ir::Constant>()) {
                         auto i = c->Value()->ValueAs<uint32_t>();
                         TINT_ASSERT_OR_RETURN(i < s->Members().Length());
@@ -679,7 +679,8 @@
     void Binary(ir::Binary* e) {
         if (e->Kind() == ir::Binary::Kind::kEqual) {
             auto* rhs = e->RHS()->As<ir::Constant>();
-            if (rhs && rhs->Type()->Is<type::Bool>() && rhs->Value()->ValueAs<bool>() == false) {
+            if (rhs && rhs->Type()->Is<core::type::Bool>() &&
+                rhs->Value()->ValueAs<bool>() == false) {
                 // expr == false
                 Bind(e->Result(), b.Not(Expr(e->LHS())));
                 return;
@@ -790,7 +791,7 @@
             return b.Expr("<error>");
         }
 
-        if (value->Type()->Is<type::Pointer>()) {
+        if (value->Type()->Is<core::type::Pointer>()) {
             return ToPtrKind(expr, got_ptr_kind, want_ptr_kind);
         }
 
@@ -819,18 +820,18 @@
         };
         return tint::Switch(
             c->Type(),  //
-            [&](const type::I32*) { return b.Expr(c->ValueAs<i32>()); },
-            [&](const type::U32*) { return b.Expr(c->ValueAs<u32>()); },
-            [&](const type::F32*) { return b.Expr(c->ValueAs<f32>()); },
-            [&](const type::F16*) {
+            [&](const core::type::I32*) { return b.Expr(c->ValueAs<i32>()); },
+            [&](const core::type::U32*) { return b.Expr(c->ValueAs<u32>()); },
+            [&](const core::type::F32*) { return b.Expr(c->ValueAs<f32>()); },
+            [&](const core::type::F16*) {
                 Enable(core::Extension::kF16);
                 return b.Expr(c->ValueAs<f16>());
             },
-            [&](const type::Bool*) { return b.Expr(c->ValueAs<bool>()); },
-            [&](const type::Array*) { return composite(/* can_splat */ false); },
-            [&](const type::Vector*) { return composite(/* can_splat */ true); },
-            [&](const type::Matrix*) { return composite(/* can_splat */ false); },
-            [&](const type::Struct*) { return composite(/* can_splat */ false); },
+            [&](const core::type::Bool*) { return b.Expr(c->ValueAs<bool>()); },
+            [&](const core::type::Array*) { return composite(/* can_splat */ false); },
+            [&](const core::type::Vector*) { return composite(/* can_splat */ true); },
+            [&](const core::type::Matrix*) { return composite(/* can_splat */ false); },
+            [&](const core::type::Struct*) { return composite(/* can_splat */ false); },
             [&](Default) {
                 UNHANDLED_CASE(c->Type());
                 return b.Expr("<error>");
@@ -856,22 +857,22 @@
     /// @param ty the type::Type
     /// @return an ast::Type from @p ty.
     /// @note May be a semantically-invalid placeholder type on error.
-    ast::Type Type(const type::Type* ty) {
+    ast::Type Type(const core::type::Type* ty) {
         return tint::Switch(
-            ty,                                              //
-            [&](const type::Void*) { return ast::Type{}; },  //
-            [&](const type::I32*) { return b.ty.i32(); },    //
-            [&](const type::U32*) { return b.ty.u32(); },    //
-            [&](const type::F16*) {
+            ty,                                                    //
+            [&](const core::type::Void*) { return ast::Type{}; },  //
+            [&](const core::type::I32*) { return b.ty.i32(); },    //
+            [&](const core::type::U32*) { return b.ty.u32(); },    //
+            [&](const core::type::F16*) {
                 Enable(core::Extension::kF16);
                 return b.ty.f16();
             },
-            [&](const type::F32*) { return b.ty.f32(); },  //
-            [&](const type::Bool*) { return b.ty.bool_(); },
-            [&](const type::Matrix* m) {
+            [&](const core::type::F32*) { return b.ty.f32(); },  //
+            [&](const core::type::Bool*) { return b.ty.bool_(); },
+            [&](const core::type::Matrix* m) {
                 return b.ty.mat(Type(m->type()), m->columns(), m->rows());
             },
-            [&](const type::Vector* v) {
+            [&](const core::type::Vector* v) {
                 auto el = Type(v->type());
                 if (v->Packed()) {
                     TINT_ASSERT(v->Width() == 3u);
@@ -880,42 +881,42 @@
                     return b.ty.vec(el, v->Width());
                 }
             },
-            [&](const type::Array* a) {
+            [&](const core::type::Array* a) {
                 auto el = Type(a->ElemType());
                 Vector<const ast::Attribute*, 1> attrs;
                 if (!a->IsStrideImplicit()) {
                     attrs.Push(b.Stride(a->Stride()));
                 }
-                if (a->Count()->Is<type::RuntimeArrayCount>()) {
+                if (a->Count()->Is<core::type::RuntimeArrayCount>()) {
                     return b.ty.array(el, std::move(attrs));
                 }
                 auto count = a->ConstantCount();
                 if (TINT_UNLIKELY(!count)) {
-                    TINT_ICE() << type::Array::kErrExpectedConstantCount;
+                    TINT_ICE() << core::type::Array::kErrExpectedConstantCount;
                     return b.ty.array(el, u32(1), std::move(attrs));
                 }
                 return b.ty.array(el, u32(count.value()), std::move(attrs));
             },
-            [&](const type::Struct* s) { return Struct(s); },
-            [&](const type::Atomic* a) { return b.ty.atomic(Type(a->Type())); },
-            [&](const type::DepthTexture* t) { return b.ty.depth_texture(t->dim()); },
-            [&](const type::DepthMultisampledTexture* t) {
+            [&](const core::type::Struct* s) { return Struct(s); },
+            [&](const core::type::Atomic* a) { return b.ty.atomic(Type(a->Type())); },
+            [&](const core::type::DepthTexture* t) { return b.ty.depth_texture(t->dim()); },
+            [&](const core::type::DepthMultisampledTexture* t) {
                 return b.ty.depth_multisampled_texture(t->dim());
             },
-            [&](const type::ExternalTexture*) { return b.ty.external_texture(); },
-            [&](const type::MultisampledTexture* t) {
+            [&](const core::type::ExternalTexture*) { return b.ty.external_texture(); },
+            [&](const core::type::MultisampledTexture* t) {
                 auto el = Type(t->type());
                 return b.ty.multisampled_texture(t->dim(), el);
             },
-            [&](const type::SampledTexture* t) {
+            [&](const core::type::SampledTexture* t) {
                 auto el = Type(t->type());
                 return b.ty.sampled_texture(t->dim(), el);
             },
-            [&](const type::StorageTexture* t) {
+            [&](const core::type::StorageTexture* t) {
                 return b.ty.storage_texture(t->dim(), t->texel_format(), t->access());
             },
-            [&](const type::Sampler* s) { return b.ty.sampler(s->kind()); },
-            [&](const type::Pointer* p) {
+            [&](const core::type::Sampler* s) { return b.ty.sampler(s->kind()); },
+            [&](const core::type::Pointer* p) {
                 // Note: type::Pointer always has an inferred access, but WGSL only allows an
                 // explicit access in the 'storage' address space.
                 auto el = Type(p->StoreType());
@@ -925,7 +926,7 @@
                                   : core::Access::kUndefined;
                 return b.ty.ptr(address_space, el, access);
             },
-            [&](const type::Reference*) {
+            [&](const core::type::Reference*) {
                 TINT_ICE() << "reference types should never appear in the IR";
                 return b.ty.i32();
             },
@@ -935,9 +936,9 @@
             });
     }
 
-    ast::Type Struct(const type::Struct* s) {
+    ast::Type Struct(const core::type::Struct* s) {
         auto n = structs_.GetOrCreate(s, [&] {
-            auto members = tint::Transform<8>(s->Members(), [&](const type::StructMember* m) {
+            auto members = tint::Transform<8>(s->Members(), [&](const core::type::StructMember* m) {
                 auto ty = Type(m->Type());
                 const auto& ir_attrs = m->Attributes();
                 Vector<const ast::Attribute*, 4> ast_attrs;
@@ -1015,7 +1016,7 @@
                 return;
             }
         } else {
-            if (value->Type()->Is<type::Pointer>()) {
+            if (value->Type()->Is<core::type::Pointer>()) {
                 expr = ToPtrKind(expr, ptr_kind, PtrKind::kPtr);
             }
             auto mod_name = mod.NameOf(value);
@@ -1057,7 +1058,7 @@
             return false;
         }
         auto* result = i->Result();
-        if (!result->Type()->Is<type::Bool>()) {
+        if (!result->Type()->Is<core::type::Bool>()) {
             return false;  // Wrong result type
         }
         if (i->Exits().Count() != 2) {
@@ -1113,7 +1114,7 @@
 
     bool IsConstant(ir::Value* val, bool value) {
         if (auto* c = val->As<ir::Constant>()) {
-            if (c->Type()->Is<type::Bool>()) {
+            if (c->Type()->Is<core::type::Bool>()) {
                 return c->Value()->ValueAs<bool>() == value;
             }
         }
diff --git a/src/tint/lang/wgsl/writer/ir_to_program/rename_conflicts.cc b/src/tint/lang/wgsl/writer/ir_to_program/rename_conflicts.cc
index eadae08..cb57213 100644
--- a/src/tint/lang/wgsl/writer/ir_to_program/rename_conflicts.cc
+++ b/src/tint/lang/wgsl/writer/ir_to_program/rename_conflicts.cc
@@ -77,7 +77,7 @@
 
   private:
     /// Map of identifier to declaration.
-    /// The declarations may be one of an ir::Value or type::Struct.
+    /// The declarations may be one of an ir::Value or core::type::Struct.
     using Scope = Hashmap<std::string_view, CastableBase*, 8>;
 
     /// The IR module.
@@ -91,10 +91,10 @@
     void RegisterModuleScopeDecls() {
         // Declare all the user types
         for (auto* ty : ir->Types()) {
-            if (auto* str = ty->As<type::Struct>()) {
+            if (auto* str = ty->As<core::type::Struct>()) {
                 auto name = str->Name().NameView();
                 if (!IsBuiltinStruct(str)) {
-                    Declare(scopes.Front(), const_cast<type::Struct*>(str), name);
+                    Declare(scopes.Front(), const_cast<core::type::Struct*>(str), name);
                 }
             }
         }
@@ -192,30 +192,30 @@
     }
 
     /// Ensures that the type @p type can be resolved given its identifier(s)
-    void EnsureResolvable(const type::Type* type) {
+    void EnsureResolvable(const core::type::Type* type) {
         while (type) {
             type = tint::Switch(
                 type,  //
-                [&](const type::Scalar* s) {
+                [&](const core::type::Scalar* s) {
                     EnsureResolvesTo(s->FriendlyName(), nullptr);
                     return nullptr;
                 },
-                [&](const type::Vector* v) {
+                [&](const core::type::Vector* v) {
                     EnsureResolvesTo("vec" + tint::ToString(v->Width()), nullptr);
                     return v->type();
                 },
-                [&](const type::Matrix* m) {
+                [&](const core::type::Matrix* m) {
                     EnsureResolvesTo(
                         "mat" + tint::ToString(m->columns()) + "x" + tint::ToString(m->rows()),
                         nullptr);
                     return m->type();
                 },
-                [&](const type::Pointer* p) {
+                [&](const core::type::Pointer* p) {
                     EnsureResolvesTo(tint::ToString(p->Access()), nullptr);
                     EnsureResolvesTo(tint::ToString(p->AddressSpace()), nullptr);
                     return p->StoreType();
                 },
-                [&](const type::Struct* s) {
+                [&](const core::type::Struct* s) {
                     auto name = s->Name().NameView();
                     if (IsBuiltinStruct(s)) {
                         EnsureResolvesTo(name, nullptr);
@@ -260,14 +260,14 @@
         Switch(
             thing,  //
             [&](ir::Value* value) { ir->SetName(value, new_name); },
-            [&](type::Struct* str) { str->SetName(new_name); },
+            [&](core::type::Struct* str) { str->SetName(new_name); },
             [&](Default) {
                 TINT_ICE() << "unhandled type for renaming: " << thing->TypeInfo().name;
             });
     }
 
     /// @return true if @p s is a builtin (non-user declared) structure.
-    bool IsBuiltinStruct(const type::Struct* s) {
+    bool IsBuiltinStruct(const core::type::Struct* s) {
         // TODO(bclayton): Need to do better than this.
         return tint::HasPrefix(s->Name().NameView(), "_");
     }
diff --git a/src/tint/lang/wgsl/writer/ir_to_program/rename_conflicts_test.cc b/src/tint/lang/wgsl/writer/ir_to_program/rename_conflicts_test.cc
index 97a62d5..02d7fed 100644
--- a/src/tint/lang/wgsl/writer/ir_to_program/rename_conflicts_test.cc
+++ b/src/tint/lang/wgsl/writer/ir_to_program/rename_conflicts_test.cc
@@ -62,7 +62,7 @@
     /// The test IR builder.
     ir::Builder b{mod};
     /// The type manager.
-    type::Manager& ty{mod.Types()};
+    core::type::Manager& ty{mod.Types()};
 };
 
 TEST_F(IRToProgramRenameConflictsTest, NoModify_SingleNamedRootBlockVar) {
diff --git a/src/tint/tint.natvis b/src/tint/tint.natvis
index 5af1320..47198c0 100644
--- a/src/tint/tint.natvis
+++ b/src/tint/tint.natvis
@@ -231,23 +231,23 @@
 	<!-- sem -->
 	<!--=================================================================-->
 
-	<Type Name="tint::type::AbstractInt">
+	<Type Name="tint::core::type::AbstractInt">
 		<DisplayString>AbstractInt</DisplayString>
 	</Type>
 
-	<Type Name="tint::type::AbstractFloat">
+	<Type Name="tint::core::type::AbstractFloat">
 		<DisplayString>AbstractFloat</DisplayString>
 	</Type>
 
-	<Type Name="tint::type::Bool">
+	<Type Name="tint::core::type::Bool">
 		<DisplayString>bool</DisplayString>
 	</Type>
 
-	<Type Name="tint::type::F32">
+	<Type Name="tint::core::type::F32">
 		<DisplayString>f32</DisplayString>
 	</Type>
 
-	<Type Name="tint::type::Vector">
+	<Type Name="tint::core::type::Vector">
 		<DisplayString>vec{width_}&lt;{*subtype_}&gt;</DisplayString>
 	</Type>
 
diff --git a/src/tint/utils/templates/intrinsic_table_data.tmpl.inc b/src/tint/utils/templates/intrinsic_table_data.tmpl.inc
index b1c8b1e..fe3f9da 100644
--- a/src/tint/utils/templates/intrinsic_table_data.tmpl.inc
+++ b/src/tint/utils/templates/intrinsic_table_data.tmpl.inc
@@ -39,7 +39,7 @@
 using TemplateNumberInfo = tint::core::intrinsic::TemplateNumberInfo;
 using TemplateTypeIndex = tint::core::intrinsic::TemplateTypeIndex;
 using TemplateTypeInfo = tint::core::intrinsic::TemplateTypeInfo;
-using Type = tint::type::Type;
+using Type = tint::core::type::Type;
 using TypeMatcher = tint::core::intrinsic::TypeMatcher;
 using TypeMatcherIndex = tint::core::intrinsic::TypeMatcherIndex;
 using TypeMatcherIndicesIndex = tint::core::intrinsic::TypeMatcherIndicesIndex;