diff --git a/src/tint/lang/core/ir/binary/decode.cc b/src/tint/lang/core/ir/binary/decode.cc
index ca40071..14d7285 100644
--- a/src/tint/lang/core/ir/binary/decode.cc
+++ b/src/tint/lang/core/ir/binary/decode.cc
@@ -315,6 +315,8 @@
                 return CreateTypeMatrix(type_in.matrix());
             case pb::Type::KindCase::kPointer:
                 return CreateTypePointer(type_in.pointer());
+            case pb::Type::KindCase::kStruct:
+                return CreateTypeStruct(type_in.struct_());
             case pb::Type::KindCase::kArray:
                 return CreateTypeArray(type_in.array());
             case pb::Type::KindCase::kAtomic:
@@ -366,6 +368,55 @@
         return mod_out_.Types().ptr(address_space, store_ty, access);
     }
 
+    const type::Struct* CreateTypeStruct(const pb::TypeStruct& struct_in) {
+        Vector<const core::type::StructMember*, 8> members_out;
+        uint32_t offset = 0;
+        for (auto& member_in : struct_in.member()) {
+            auto symbol = mod_out_.symbols.Register(member_in.name());
+            auto* type = Type(member_in.type());
+            auto index = static_cast<uint32_t>(members_out.Length());
+            auto align = member_in.align();
+            auto size = member_in.size();
+            core::type::StructMemberAttributes attributes_out{};
+            if (member_in.has_attributes()) {
+                auto& attributes_in = member_in.attributes();
+                if (attributes_in.has_location()) {
+                    attributes_out.location = attributes_in.location();
+                }
+                if (attributes_in.has_index()) {
+                    attributes_out.index = attributes_in.index();
+                }
+                if (attributes_in.has_color()) {
+                    attributes_out.color = attributes_in.color();
+                }
+                if (attributes_in.has_builtin()) {
+                    attributes_out.builtin = BuiltinValue(attributes_in.builtin());
+                }
+                if (attributes_in.has_interpolation()) {
+                    auto& interpolation_in = attributes_in.interpolation();
+                    attributes_out.interpolation = core::Interpolation{
+                        InterpolationType(interpolation_in.type()),
+                        InterpolationSampling::kUndefined,
+                    };
+                    if (interpolation_in.has_sampling()) {
+                        attributes_out.interpolation->sampling =
+                            InterpolationSampling(interpolation_in.sampling());
+                    }
+                }
+                if (attributes_in.has_invariant()) {
+                    attributes_out.invariant = attributes_in.invariant();
+                }
+            }
+            offset = RoundUp(align, offset);
+            auto* member_out = mod_out_.Types().Get<core::type::StructMember>(
+                symbol, type, index, offset, align, size, std::move(attributes_out));
+            offset += size;
+            members_out.Push(member_out);
+        }
+        auto name = mod_out_.symbols.Register(struct_in.name());
+        return mod_out_.Types().Struct(name, std::move(members_out));
+    }
+
     const type::Array* CreateTypeArray(const pb::TypeArray& array_in) {
         auto* element = Type(array_in.element());
         uint32_t stride = static_cast<uint32_t>(array_in.stride());
@@ -576,6 +627,75 @@
                 return core::ir::BinaryOp::kAdd;
         }
     }
+
+    core::InterpolationType InterpolationType(pb::InterpolationType in) {
+        switch (in) {
+            case pb::InterpolationType::flat:
+                return core::InterpolationType::kFlat;
+            case pb::InterpolationType::linear:
+                return core::InterpolationType::kLinear;
+            case pb::InterpolationType::perspective:
+                return core::InterpolationType::kPerspective;
+            default:
+                break;
+        }
+        TINT_ICE() << "invalid InterpolationType: " << in;
+        return core::InterpolationType::kFlat;
+    }
+
+    core::InterpolationSampling InterpolationSampling(pb::InterpolationSampling in) {
+        switch (in) {
+            case pb::InterpolationSampling::center:
+                return core::InterpolationSampling::kCenter;
+            case pb::InterpolationSampling::centroid:
+                return core::InterpolationSampling::kCentroid;
+            case pb::InterpolationSampling::sample:
+                return core::InterpolationSampling::kSample;
+            default:
+                break;
+        }
+        TINT_ICE() << "invalid InterpolationSampling: " << in;
+        return core::InterpolationSampling::kCenter;
+    }
+
+    core::BuiltinValue BuiltinValue(pb::BuiltinValue in) {
+        switch (in) {
+            case pb::BuiltinValue::point_size:
+                return core::BuiltinValue::kPointSize;
+            case pb::BuiltinValue::frag_depth:
+                return core::BuiltinValue::kFragDepth;
+            case pb::BuiltinValue::front_facing:
+                return core::BuiltinValue::kFrontFacing;
+            case pb::BuiltinValue::global_invocation_id:
+                return core::BuiltinValue::kGlobalInvocationId;
+            case pb::BuiltinValue::instance_index:
+                return core::BuiltinValue::kInstanceIndex;
+            case pb::BuiltinValue::local_invocation_id:
+                return core::BuiltinValue::kLocalInvocationId;
+            case pb::BuiltinValue::local_invocation_index:
+                return core::BuiltinValue::kLocalInvocationIndex;
+            case pb::BuiltinValue::num_workgroups:
+                return core::BuiltinValue::kNumWorkgroups;
+            case pb::BuiltinValue::position:
+                return core::BuiltinValue::kPosition;
+            case pb::BuiltinValue::sample_index:
+                return core::BuiltinValue::kSampleIndex;
+            case pb::BuiltinValue::sample_mask:
+                return core::BuiltinValue::kSampleMask;
+            case pb::BuiltinValue::subgroup_invocation_id:
+                return core::BuiltinValue::kSubgroupInvocationId;
+            case pb::BuiltinValue::subgroup_size:
+                return core::BuiltinValue::kSubgroupSize;
+            case pb::BuiltinValue::vertex_index:
+                return core::BuiltinValue::kVertexIndex;
+            case pb::BuiltinValue::workgroup_id:
+                return core::BuiltinValue::kWorkgroupId;
+            default:
+                break;
+        }
+        TINT_ICE() << "invalid BuiltinValue: " << in;
+        return core::BuiltinValue::kPointSize;
+    }
 };
 
 }  // namespace
diff --git a/src/tint/lang/core/ir/binary/encode.cc b/src/tint/lang/core/ir/binary/encode.cc
index ab18fe9..be11d5b 100644
--- a/src/tint/lang/core/ir/binary/encode.cc
+++ b/src/tint/lang/core/ir/binary/encode.cc
@@ -29,6 +29,8 @@
 
 #include <utility>
 
+#include "src/tint/lang/core/builtin_fn.h"
+#include "src/tint/lang/core/builtin_value.h"
 #include "src/tint/lang/core/constant/composite.h"
 #include "src/tint/lang/core/constant/scalar.h"
 #include "src/tint/lang/core/constant/splat.h"
@@ -240,6 +242,7 @@
                 [&](const core::type::Vector* v) { TypeVector(*type_out.mutable_vector(), v); },
                 [&](const core::type::Matrix* m) { TypeMatrix(*type_out.mutable_matrix(), m); },
                 [&](const core::type::Pointer* m) { TypePointer(*type_out.mutable_pointer(), m); },
+                [&](const core::type::Struct* s) { TypeStruct(*type_out.mutable_struct_(), s); },
                 [&](const core::type::Array* m) { TypeArray(*type_out.mutable_array(), m); },
                 TINT_ICE_ON_NO_MATCH);
 
@@ -265,6 +268,42 @@
         pointer_out.set_access(Access(pointer_in->Access()));
     }
 
+    void TypeStruct(pb::TypeStruct& struct_out, const core::type::Struct* struct_in) {
+        struct_out.set_name(struct_in->Name().Name());
+        for (auto* member_in : struct_in->Members()) {
+            auto& member_out = *struct_out.add_member();
+            member_out.set_name(member_in->Name().Name());
+            member_out.set_type(Type(member_in->Type()));
+            member_out.set_size(member_in->Size());
+            member_out.set_align(member_in->Align());
+
+            auto& attrs_in = member_in->Attributes();
+            if (attrs_in.location) {
+                member_out.mutable_attributes()->set_location(*attrs_in.location);
+            }
+            if (attrs_in.index) {
+                member_out.mutable_attributes()->set_index(*attrs_in.index);
+            }
+            if (attrs_in.color) {
+                member_out.mutable_attributes()->set_color(*attrs_in.color);
+            }
+            if (attrs_in.builtin) {
+                member_out.mutable_attributes()->set_builtin(BuiltinValue(*attrs_in.builtin));
+            }
+            if (auto& interpolation_in = attrs_in.interpolation) {
+                auto& interpolation_out = *member_out.mutable_attributes()->mutable_interpolation();
+                interpolation_out.set_type(InterpolationType(interpolation_in->type));
+                if (interpolation_in->sampling != InterpolationSampling::kUndefined) {
+                    interpolation_out.set_sampling(
+                        InterpolationSampling(interpolation_in->sampling));
+                }
+            }
+            if (attrs_in.invariant) {
+                member_out.mutable_attributes()->set_invariant(true);
+            }
+        }
+    }
+
     void TypeArray(pb::TypeArray& array_out, const core::type::Array* array_in) {
         array_out.set_element(Type(array_in->ElemType()));
         array_out.set_stride(array_in->Stride());
@@ -458,6 +497,75 @@
         TINT_ICE() << "invalid BinaryOp: " << in;
         return pb::BinaryOp::add_;
     }
+
+    pb::InterpolationType InterpolationType(core::InterpolationType in) {
+        switch (in) {
+            case core::InterpolationType::kFlat:
+                return pb::InterpolationType::flat;
+            case core::InterpolationType::kLinear:
+                return pb::InterpolationType::linear;
+            case core::InterpolationType::kPerspective:
+                return pb::InterpolationType::perspective;
+            default:
+                break;
+        }
+        TINT_ICE() << "invalid InterpolationType: " << in;
+        return pb::InterpolationType::flat;
+    }
+
+    pb::InterpolationSampling InterpolationSampling(core::InterpolationSampling in) {
+        switch (in) {
+            case core::InterpolationSampling::kCenter:
+                return pb::InterpolationSampling::center;
+            case core::InterpolationSampling::kCentroid:
+                return pb::InterpolationSampling::centroid;
+            case core::InterpolationSampling::kSample:
+                return pb::InterpolationSampling::sample;
+            default:
+                break;
+        }
+        TINT_ICE() << "invalid InterpolationSampling: " << in;
+        return pb::InterpolationSampling::center;
+    }
+
+    pb::BuiltinValue BuiltinValue(core::BuiltinValue in) {
+        switch (in) {
+            case core::BuiltinValue::kPointSize:
+                return pb::BuiltinValue::point_size;
+            case core::BuiltinValue::kFragDepth:
+                return pb::BuiltinValue::frag_depth;
+            case core::BuiltinValue::kFrontFacing:
+                return pb::BuiltinValue::front_facing;
+            case core::BuiltinValue::kGlobalInvocationId:
+                return pb::BuiltinValue::global_invocation_id;
+            case core::BuiltinValue::kInstanceIndex:
+                return pb::BuiltinValue::instance_index;
+            case core::BuiltinValue::kLocalInvocationId:
+                return pb::BuiltinValue::local_invocation_id;
+            case core::BuiltinValue::kLocalInvocationIndex:
+                return pb::BuiltinValue::local_invocation_index;
+            case core::BuiltinValue::kNumWorkgroups:
+                return pb::BuiltinValue::num_workgroups;
+            case core::BuiltinValue::kPosition:
+                return pb::BuiltinValue::position;
+            case core::BuiltinValue::kSampleIndex:
+                return pb::BuiltinValue::sample_index;
+            case core::BuiltinValue::kSampleMask:
+                return pb::BuiltinValue::sample_mask;
+            case core::BuiltinValue::kSubgroupInvocationId:
+                return pb::BuiltinValue::subgroup_invocation_id;
+            case core::BuiltinValue::kSubgroupSize:
+                return pb::BuiltinValue::subgroup_size;
+            case core::BuiltinValue::kVertexIndex:
+                return pb::BuiltinValue::vertex_index;
+            case core::BuiltinValue::kWorkgroupId:
+                return pb::BuiltinValue::workgroup_id;
+            default:
+                break;
+        }
+        TINT_ICE() << "invalid BuiltinValue: " << in;
+        return pb::BuiltinValue::point_size;
+    }
 };
 
 }  // namespace
diff --git a/src/tint/lang/core/ir/binary/ir.proto b/src/tint/lang/core/ir/binary/ir.proto
index fff8d02..fc272de 100644
--- a/src/tint/lang/core/ir/binary/ir.proto
+++ b/src/tint/lang/core/ir/binary/ir.proto
@@ -48,7 +48,8 @@
         TypeMatrix matrix = 3;
         TypeArray array = 4;
         TypePointer pointer = 5;
-        uint32 atomic = 6;  // Module.types
+        TypeStruct struct = 6;
+        uint32 atomic = 7;  // Module.types
         // TODO: textures, samplers
     }
 }
@@ -86,6 +87,19 @@
     AccessControl access = 3;
 }
 
+message TypeStruct {
+    string name = 1;
+    repeated TypeStructMember member = 2;
+}
+
+message TypeStructMember {
+    string name = 1;
+    uint32 type = 2;
+    uint32 size = 3;
+    uint32 align = 4;
+    optional AttributesStructMember attributes = 5;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Values
 ////////////////////////////////////////////////////////////////////////////////
@@ -244,6 +258,23 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// Attributes
+////////////////////////////////////////////////////////////////////////////////
+message AttributesStructMember {
+    optional uint32 location = 1;
+    optional uint32 index = 2;
+    optional uint32 color = 3;
+    optional BuiltinValue builtin = 4;
+    optional AttributesInterpolation interpolation = 5;
+    optional bool invariant = 6;
+}
+
+message AttributesInterpolation {
+    InterpolationType type = 1;
+    optional InterpolationSampling sampling = 2;
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // Enums
 ////////////////////////////////////////////////////////////////////////////////
 enum AddressSpace {
@@ -286,3 +317,151 @@
     shift_left = 14;
     shift_right = 15;
 }
+
+enum InterpolationType {
+    flat = 0;
+    linear = 1;
+    perspective = 2;
+}
+
+enum InterpolationSampling {
+    center = 0;
+    centroid = 1;
+    sample = 2;
+}
+
+enum BuiltinValue {
+    point_size = 0;
+    frag_depth = 1;
+    front_facing = 2;
+    global_invocation_id = 3;
+    instance_index = 4;
+    local_invocation_id = 5;
+    local_invocation_index = 6;
+    num_workgroups = 7;
+    position = 8;
+    sample_index = 9;
+    sample_mask = 10;
+    subgroup_invocation_id = 11;
+    subgroup_size = 12;
+    vertex_index = 13;
+    workgroup_id = 14;
+}
+
+enum BuiltinFn {
+    abs = 0;
+    acos = 1;
+    acosh = 2;
+    all = 3;
+    any = 4;
+    array_length = 5;
+    asin = 6;
+    asinh = 7;
+    atan = 8;
+    atan2 = 9;
+    atanh = 10;
+    ceil = 11;
+    clamp = 12;
+    cos = 13;
+    cosh = 14;
+    count_leading_zeros = 15;
+    count_one_bits = 16;
+    count_trailing_zeros = 17;
+    cross = 18;
+    degrees = 19;
+    determinant = 20;
+    distance = 21;
+    dot = 22;
+    dot4i8_packed = 23;
+    dot4u8_packed = 24;
+    dpdx = 25;
+    dpdx_coarse = 26;
+    dpdx_fine = 27;
+    dpdy = 28;
+    dpdy_coarse = 29;
+    dpdy_fine = 30;
+    exp = 31;
+    exp2 = 32;
+    extract_bits = 33;
+    face_forward = 34;
+    first_leading_bit = 35;
+    first_trailing_bit = 36;
+    floor = 37;
+    fma = 38;
+    fract = 39;
+    frexp = 40;
+    fwidth = 41;
+    fwidth_coarse = 42;
+    fwidth_fine = 43;
+    insert_bits = 44;
+    inverse_sqrt = 45;
+    ldexp = 46;
+    length = 47;
+    log = 48;
+    log2 = 49;
+    max = 50;
+    min = 51;
+    mix = 52;
+    modf = 53;
+    normalize = 54;
+    pack2x16_float = 55;
+    pack2x16_snorm = 56;
+    pack2x16_unorm = 57;
+    pack4x8_snorm = 58;
+    pack4x8_unorm = 59;
+    pow = 60;
+    quantize_to_f16 = 61;
+    radians = 62;
+    reflect = 63;
+    refract = 64;
+    reverse_bits = 65;
+    round = 66;
+    saturate = 67;
+    select = 68;
+    sign = 69;
+    sin = 70;
+    sinh = 71;
+    smoothstep = 72;
+    sqrt = 73;
+    step = 74;
+    storage_barrier = 75;
+    tan = 76;
+    tanh = 77;
+    transpose = 78;
+    trunc = 79;
+    unpack2x16_float = 80;
+    unpack2x16_snorm = 81;
+    unpack2x16_unorm = 82;
+    unpack4x8_snorm = 83;
+    unpack4x8_unorm = 84;
+    workgroup_barrier = 85;
+    texture_barrier = 86;
+    texture_dimensions = 87;
+    texture_gather = 88;
+    texture_gather_compare = 89;
+    texture_num_layers = 90;
+    texture_num_levels = 91;
+    texture_num_samples = 92;
+    texture_sample = 93;
+    texture_sample_bias = 94;
+    texture_sample_compare = 95;
+    texture_sample_compare_level = 96;
+    texture_sample_grad = 97;
+    texture_sample_level = 98;
+    texture_sample_base_clamp_to_edge = 99;
+    texture_store = 100;
+    texture_load = 101;
+    atomic_load = 102;
+    atomic_store = 103;
+    atomic_add = 104;
+    atomic_sub = 105;
+    atomic_max = 106;
+    atomic_min = 107;
+    atomic_and = 108;
+    atomic_or = 109;
+    atomic_xor = 110;
+    atomic_exchange = 111;
+    atomic_compare_exchange_weak = 112;
+    subgroup_ballot = 113;
+    subgroup_broadcast = 114;
+}
diff --git a/src/tint/lang/core/ir/binary/roundtrip_test.cc b/src/tint/lang/core/ir/binary/roundtrip_test.cc
index 57ade4e..120eff7 100644
--- a/src/tint/lang/core/ir/binary/roundtrip_test.cc
+++ b/src/tint/lang/core/ir/binary/roundtrip_test.cc
@@ -87,6 +87,7 @@
     });
     RUN_TEST();
 }
+
 ////////////////////////////////////////////////////////////////////////////////
 // Functions
 ////////////////////////////////////////////////////////////////////////////////
@@ -123,6 +124,115 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// Types
+////////////////////////////////////////////////////////////////////////////////
+TEST_F(IRBinaryRoundtripTest, bool) {
+    b.Append(b.ir.root_block, [&] { b.Var<private_, bool>(); });
+    RUN_TEST();
+}
+
+TEST_F(IRBinaryRoundtripTest, i32) {
+    b.Append(b.ir.root_block, [&] { b.Var<private_, i32>(); });
+    RUN_TEST();
+}
+
+TEST_F(IRBinaryRoundtripTest, u32) {
+    b.Append(b.ir.root_block, [&] { b.Var<private_, u32>(); });
+    RUN_TEST();
+}
+
+TEST_F(IRBinaryRoundtripTest, f32) {
+    b.Append(b.ir.root_block, [&] { b.Var<private_, f32>(); });
+    RUN_TEST();
+}
+
+TEST_F(IRBinaryRoundtripTest, f16) {
+    b.Append(b.ir.root_block, [&] { b.Var<private_, f16>(); });
+    RUN_TEST();
+}
+
+TEST_F(IRBinaryRoundtripTest, vec2_f32) {
+    b.Append(b.ir.root_block, [&] { b.Var<private_, vec2<f32>>(); });
+    RUN_TEST();
+}
+
+TEST_F(IRBinaryRoundtripTest, vec3_i32) {
+    b.Append(b.ir.root_block, [&] { b.Var<private_, vec3<i32>>(); });
+    RUN_TEST();
+}
+
+TEST_F(IRBinaryRoundtripTest, vec4_bool) {
+    b.Append(b.ir.root_block, [&] { b.Var<private_, vec4<bool>>(); });
+    RUN_TEST();
+}
+
+TEST_F(IRBinaryRoundtripTest, mat4x2_f32) {
+    b.Append(b.ir.root_block, [&] { b.Var<private_, vec4<mat4x2<f32>>>(); });
+    RUN_TEST();
+}
+
+TEST_F(IRBinaryRoundtripTest, mat2x4_f16) {
+    b.Append(b.ir.root_block, [&] { b.Var<private_, vec4<mat2x4<f16>>>(); });
+    RUN_TEST();
+}
+
+TEST_F(IRBinaryRoundtripTest, ptr_function_f32_read_write) {
+    auto p = b.FunctionParam<ptr<function, f32, read_write>>("p");
+    auto* fn = b.Function("Function", ty.void_());
+    fn->SetParams({p});
+    b.Append(fn->Block(), [&] { b.Return(fn); });
+    RUN_TEST();
+}
+
+TEST_F(IRBinaryRoundtripTest, ptr_workgroup_i32_read) {
+    auto p = b.FunctionParam<ptr<workgroup, i32, read>>("p");
+    auto* fn = b.Function("Function", ty.void_());
+    fn->SetParams({p});
+    b.Append(fn->Block(), [&] { b.Return(fn); });
+    RUN_TEST();
+}
+
+TEST_F(IRBinaryRoundtripTest, struct) {
+    Vector members{
+        ty.Get<core::type::StructMember>(b.ir.symbols.New("a"), ty.i32(), /* index */ 0u,
+                                         /* offset */ 0u, /* align */ 4u, /* size */ 4u,
+                                         type::StructMemberAttributes{}),
+        ty.Get<core::type::StructMember>(b.ir.symbols.New("b"), ty.f32(), /* index */ 1u,
+                                         /* offset */ 4u, /* align */ 4u, /* size */ 32u,
+                                         type::StructMemberAttributes{}),
+        ty.Get<core::type::StructMember>(b.ir.symbols.New("c"), ty.u32(), /* index */ 2u,
+                                         /* offset */ 36u, /* align */ 4u, /* size */ 4u,
+                                         type::StructMemberAttributes{}),
+        ty.Get<core::type::StructMember>(b.ir.symbols.New("d"), ty.u32(), /* index */ 3u,
+                                         /* offset */ 64u, /* align */ 32u, /* size */ 4u,
+                                         type::StructMemberAttributes{}),
+    };
+    auto* S = ty.Struct(b.ir.symbols.New("S"), std::move(members));
+    b.Append(b.ir.root_block, [&] { b.Var(ty.ptr<function, read_write>(S)); });
+    RUN_TEST();
+}
+
+TEST_F(IRBinaryRoundtripTest, StructMemberAttributes) {
+    type::StructMemberAttributes attrs{};
+    attrs.location = 1;
+    attrs.index = 2;
+    attrs.color = 3;
+    attrs.builtin = core::BuiltinValue::kFragDepth;
+    attrs.interpolation = core::Interpolation{
+        core::InterpolationType::kLinear,
+        core::InterpolationSampling::kCentroid,
+    };
+    attrs.invariant = true;
+    Vector members{
+        ty.Get<core::type::StructMember>(b.ir.symbols.New("a"), ty.i32(), /* index */ 0u,
+                                         /* offset */ 0u, /* align */ 4u, /* size */ 4u, attrs),
+    };
+    auto* S = ty.Struct(b.ir.symbols.New("S"), std::move(members));
+    b.Append(b.ir.root_block, [&] { b.Var(ty.ptr<function, read_write>(S)); });
+    RUN_TEST();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // Instructions
 ////////////////////////////////////////////////////////////////////////////////
 TEST_F(IRBinaryRoundtripTest, Return) {
diff --git a/src/tint/lang/core/type/manager.cc b/src/tint/lang/core/type/manager.cc
index a3473ca..50c1a39 100644
--- a/src/tint/lang/core/type/manager.cc
+++ b/src/tint/lang/core/type/manager.cc
@@ -192,8 +192,18 @@
     return Get<core::type::Pointer>(address_space, subtype, access);
 }
 
+core::type::Struct* Manager::Struct(Symbol name, VectorRef<const StructMember*> members) {
+    uint32_t max_align = 0u;
+    for (const auto& m : members) {
+        max_align = std::max(max_align, m->Align());
+    }
+    uint32_t size = members.Back()->Offset() + members.Back()->Size();
+    return Get<core::type::Struct>(name, std::move(members), max_align,
+                                   tint::RoundUp(max_align, size), size);
+}
+
 core::type::Struct* Manager::Struct(Symbol name, VectorRef<StructMemberDesc> md) {
-    tint::Vector<const core::type::StructMember*, 4> members;
+    tint::Vector<const StructMember*, 4> members;
     uint32_t current_size = 0u;
     uint32_t max_align = 0u;
     for (const auto& m : md) {
@@ -205,8 +215,8 @@
         current_size = offset + m.type->Size();
         max_align = std::max(max_align, align);
     }
-    return Get<core::type::Struct>(name, members, max_align, tint::RoundUp(max_align, current_size),
-                                   current_size);
+    return Get<core::type::Struct>(name, std::move(members), max_align,
+                                   tint::RoundUp(max_align, current_size), current_size);
 }
 
 }  // namespace tint::core::type
diff --git a/src/tint/lang/core/type/manager.h b/src/tint/lang/core/type/manager.h
index 8f361da..d88e084 100644
--- a/src/tint/lang/core/type/manager.h
+++ b/src/tint/lang/core/type/manager.h
@@ -451,6 +451,12 @@
 
     /// Create a new structure declaration.
     /// @param name the name of the structure
+    /// @param members the list of structure members
+    /// @returns the structure type
+    core::type::Struct* Struct(Symbol name, VectorRef<const StructMember*> 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
     core::type::Struct* Struct(Symbol name, VectorRef<StructMemberDesc> members);