diff --git a/src/dawn/native/ShaderModule.cpp b/src/dawn/native/ShaderModule.cpp
index d473d89..b05f1b8 100644
--- a/src/dawn/native/ShaderModule.cpp
+++ b/src/dawn/native/ShaderModule.cpp
@@ -157,11 +157,12 @@
 ResultOrError<wgpu::TextureComponentType> TintComponentTypeToTextureComponentType(
     tint::inspector::ComponentType type) {
     switch (type) {
-        case tint::inspector::ComponentType::kFloat:
+        case tint::inspector::ComponentType::kF32:
+        case tint::inspector::ComponentType::kF16:
             return wgpu::TextureComponentType::Float;
-        case tint::inspector::ComponentType::kSInt:
+        case tint::inspector::ComponentType::kI32:
             return wgpu::TextureComponentType::Sint;
-        case tint::inspector::ComponentType::kUInt:
+        case tint::inspector::ComponentType::kU32:
             return wgpu::TextureComponentType::Uint;
         case tint::inspector::ComponentType::kUnknown:
             return DAWN_VALIDATION_ERROR("Attempted to convert 'Unknown' component type from Tint");
@@ -172,11 +173,12 @@
 ResultOrError<VertexFormatBaseType> TintComponentTypeToVertexFormatBaseType(
     tint::inspector::ComponentType type) {
     switch (type) {
-        case tint::inspector::ComponentType::kFloat:
+        case tint::inspector::ComponentType::kF32:
+        case tint::inspector::ComponentType::kF16:
             return VertexFormatBaseType::Float;
-        case tint::inspector::ComponentType::kSInt:
+        case tint::inspector::ComponentType::kI32:
             return VertexFormatBaseType::Sint;
-        case tint::inspector::ComponentType::kUInt:
+        case tint::inspector::ComponentType::kU32:
             return VertexFormatBaseType::Uint;
         case tint::inspector::ComponentType::kUnknown:
             return DAWN_VALIDATION_ERROR("Attempted to convert 'Unknown' component type from Tint");
@@ -213,12 +215,14 @@
 ResultOrError<InterStageComponentType> TintComponentTypeToInterStageComponentType(
     tint::inspector::ComponentType type) {
     switch (type) {
-        case tint::inspector::ComponentType::kFloat:
-            return InterStageComponentType::Float;
-        case tint::inspector::ComponentType::kSInt:
-            return InterStageComponentType::Sint;
-        case tint::inspector::ComponentType::kUInt:
-            return InterStageComponentType::Uint;
+        case tint::inspector::ComponentType::kF32:
+            return InterStageComponentType::F32;
+        case tint::inspector::ComponentType::kI32:
+            return InterStageComponentType::I32;
+        case tint::inspector::ComponentType::kU32:
+            return InterStageComponentType::U32;
+        case tint::inspector::ComponentType::kF16:
+            return InterStageComponentType::F16;
         case tint::inspector::ComponentType::kUnknown:
             return DAWN_VALIDATION_ERROR("Attempted to convert 'Unknown' component type from Tint");
     }
@@ -1042,7 +1046,7 @@
             continue;
         }
 
-        // Uint/sint can't be statically used with a sampler, so they any
+        // Uint/Sint can't be statically used with a sampler, so they any
         // texture bindings reflected must be float or depth textures. If
         // the shader uses a float/depth texture but the bind group layout
         // specifies a uint/sint texture binding,
diff --git a/src/dawn/native/ShaderModule.h b/src/dawn/native/ShaderModule.h
index 0c829f5..a1f34ac 100644
--- a/src/dawn/native/ShaderModule.h
+++ b/src/dawn/native/ShaderModule.h
@@ -60,9 +60,10 @@
 
 // Base component type of an inter-stage variable
 enum class InterStageComponentType {
-    Sint,
-    Uint,
-    Float,
+    I32,
+    U32,
+    F32,
+    F16,
 };
 
 enum class InterpolationType {
diff --git a/src/dawn/native/d3d12/AdapterD3D12.cpp b/src/dawn/native/d3d12/AdapterD3D12.cpp
index 0b9d284..b3b7bf4 100644
--- a/src/dawn/native/d3d12/AdapterD3D12.cpp
+++ b/src/dawn/native/d3d12/AdapterD3D12.cpp
@@ -381,6 +381,11 @@
         // Even this means that no vertex buffer view has been set in D3D12 backend.
         // https://crbug.com/dawn/1255
         D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_NOT_SET,
+
+        // When using f16 in vertex attributes the debug layer may report float16_t as type
+        // `unknown`, resulting in a CREATEINPUTLAYOUT_TYPE_MISMATCH warning.
+        // https://crbug.com/tint/1473
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH,
     };
 
     // Create a retrieval filter with a deny list to suppress messages.
diff --git a/src/dawn/native/webgpu_absl_format.cpp b/src/dawn/native/webgpu_absl_format.cpp
index 7df36ed..f313c3b 100644
--- a/src/dawn/native/webgpu_absl_format.cpp
+++ b/src/dawn/native/webgpu_absl_format.cpp
@@ -409,14 +409,17 @@
     const absl::FormatConversionSpec& spec,
     absl::FormatSink* s) {
     switch (value) {
-        case InterStageComponentType::Float:
-            s->Append("Float");
+        case InterStageComponentType::F32:
+            s->Append("f32");
             break;
-        case InterStageComponentType::Uint:
-            s->Append("Uint");
+        case InterStageComponentType::F16:
+            s->Append("f16");
             break;
-        case InterStageComponentType::Sint:
-            s->Append("Sint");
+        case InterStageComponentType::U32:
+            s->Append("u32");
+            break;
+        case InterStageComponentType::I32:
+            s->Append("i32");
             break;
     }
     return {true};
diff --git a/src/dawn/tests/end2end/ShaderF16Tests.cpp b/src/dawn/tests/end2end/ShaderF16Tests.cpp
index 42c881b..6722df9 100644
--- a/src/dawn/tests/end2end/ShaderF16Tests.cpp
+++ b/src/dawn/tests/end2end/ShaderF16Tests.cpp
@@ -19,12 +19,30 @@
 #include "dawn/utils/WGPUHelpers.h"
 
 namespace {
+
+constexpr uint32_t kRTSize = 16;
+constexpr wgpu::TextureFormat kFormat = wgpu::TextureFormat::RGBA8Unorm;
+
 using RequireShaderF16Feature = bool;
 DAWN_TEST_PARAM_STRUCT(ShaderF16TestsParams, RequireShaderF16Feature);
 
 }  // anonymous namespace
 
 class ShaderF16Tests : public DawnTestWithParams<ShaderF16TestsParams> {
+  public:
+    wgpu::Texture CreateDefault2DTexture() {
+        wgpu::TextureDescriptor descriptor;
+        descriptor.dimension = wgpu::TextureDimension::e2D;
+        descriptor.size.width = kRTSize;
+        descriptor.size.height = kRTSize;
+        descriptor.size.depthOrArrayLayers = 1;
+        descriptor.sampleCount = 1;
+        descriptor.format = kFormat;
+        descriptor.mipLevelCount = 1;
+        descriptor.usage = wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc;
+        return device.CreateTexture(&descriptor);
+    }
+
   protected:
     std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
         mIsShaderF16SupportedOnAdapter = SupportsFeatures({wgpu::FeatureName::ShaderF16});
@@ -58,6 +76,8 @@
     bool mUseDxcEnabledOrNonD3D12 = false;
 };
 
+// Test simple f16 arithmetic within shader with enable directive. The result should be as expect if
+// device enable f16 extension, otherwise a shader creation error should be caught.
 TEST_P(ShaderF16Tests, BasicShaderF16FeaturesTest) {
     const char* computeShader = R"(
         enable f16;
@@ -118,6 +138,308 @@
     EXPECT_BUFFER_U32_RANGE_EQ(expected, bufferOut, 0, 1);
 }
 
+// Test that fragment shader use f16 vector type as render target output.
+TEST_P(ShaderF16Tests, RenderPipelineIOF16_RenderTarget) {
+    // Skip if device don't support f16 extension.
+    DAWN_TEST_UNSUPPORTED_IF(!device.HasFeature(wgpu::FeatureName::ShaderF16));
+
+    const char* shader = R"(
+enable f16;
+
+@vertex
+fn VSMain(@builtin(vertex_index) VertexIndex : u32) -> @builtin(position) vec4<f32> {
+    var pos = array<vec2<f32>, 3>(
+        vec2<f32>(-1.0,  1.0),
+        vec2<f32>( 1.0, -1.0),
+        vec2<f32>(-1.0, -1.0));
+
+    return vec4<f32>(pos[VertexIndex], 0.0, 1.0);
+}
+
+@fragment
+fn FSMain() -> @location(0) vec4<f16> {
+    // Paint it blue
+    return vec4<f16>(0.0, 0.0, 1.0, 1.0);
+})";
+
+    wgpu::ShaderModule shaderModule = utils::CreateShaderModule(device, shader);
+
+    // Create render pipeline.
+    wgpu::RenderPipeline pipeline;
+    {
+        utils::ComboRenderPipelineDescriptor descriptor;
+
+        descriptor.vertex.module = shaderModule;
+        descriptor.vertex.entryPoint = "VSMain";
+
+        descriptor.cFragment.module = shaderModule;
+        descriptor.cFragment.entryPoint = "FSMain";
+        descriptor.primitive.topology = wgpu::PrimitiveTopology::TriangleList;
+        descriptor.cTargets[0].format = kFormat;
+
+        pipeline = device.CreateRenderPipeline(&descriptor);
+    }
+
+    wgpu::Texture renderTarget = CreateDefault2DTexture();
+
+    wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+
+    {
+        // In the render pass we clear renderTarget to red and draw a blue triangle in the
+        // bottom left of renderTarget1.
+        utils::ComboRenderPassDescriptor renderPass({renderTarget.CreateView()});
+        renderPass.cColorAttachments[0].clearValue = {1.0f, 0.0f, 0.0f, 1.0f};
+
+        wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass);
+        pass.SetPipeline(pipeline);
+        pass.Draw(3);
+        pass.End();
+    }
+
+    wgpu::CommandBuffer commands = encoder.Finish();
+    queue.Submit(1, &commands);
+
+    // Validate that bottom left of render target is drawed to blue while upper right is still red
+    EXPECT_PIXEL_RGBA8_EQ(utils::RGBA8::kBlue, renderTarget, 1, kRTSize - 1);
+    EXPECT_PIXEL_RGBA8_EQ(utils::RGBA8::kRed, renderTarget, kRTSize - 1, 1);
+}
+
+// Test using f16 types as vertex shader (user-defined) output and fragment shader
+// (user-defined) input.
+TEST_P(ShaderF16Tests, RenderPipelineIOF16_InterstageVariable) {
+    // Skip if device don't support f16 extension.
+    DAWN_TEST_UNSUPPORTED_IF(!device.HasFeature(wgpu::FeatureName::ShaderF16));
+
+    const char* shader = R"(
+enable f16;
+
+struct VSOutput{
+    @builtin(position)
+    pos: vec4<f32>,
+    @location(3)
+    color_vsout: vec4<f16>,
+}
+
+@vertex
+fn VSMain(@builtin(vertex_index) VertexIndex : u32) -> VSOutput {
+    var pos = array<vec2<f32>, 3>(
+        vec2<f32>(-1.0,  1.0),
+        vec2<f32>( 1.0, -1.0),
+        vec2<f32>(-1.0, -1.0));
+
+    // Blue
+    var color = vec4<f16>(0.0h, 0.0h, 1.0h, 1.0h);
+
+    var result: VSOutput;
+    result.pos = vec4<f32>(pos[VertexIndex], 0.0, 1.0);
+    result.color_vsout = color;
+
+    return result;
+}
+
+struct FSInput{
+    @location(3)
+    color_fsin: vec4<f16>,
+}
+
+@fragment
+fn FSMain(fsInput: FSInput) -> @location(0) vec4<f32> {
+    // Paint it with given color
+    return vec4<f32>(fsInput.color_fsin);
+})";
+
+    wgpu::ShaderModule shaderModule = utils::CreateShaderModule(device, shader);
+
+    // Create render pipeline.
+    wgpu::RenderPipeline pipeline;
+    {
+        utils::ComboRenderPipelineDescriptor descriptor;
+
+        descriptor.vertex.module = shaderModule;
+        descriptor.vertex.entryPoint = "VSMain";
+
+        descriptor.cFragment.module = shaderModule;
+        descriptor.cFragment.entryPoint = "FSMain";
+        descriptor.primitive.topology = wgpu::PrimitiveTopology::TriangleList;
+        descriptor.cTargets[0].format = kFormat;
+
+        pipeline = device.CreateRenderPipeline(&descriptor);
+    }
+
+    wgpu::Texture renderTarget = CreateDefault2DTexture();
+
+    wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+
+    {
+        // In the first render pass we clear renderTarget1 to red and draw a blue triangle in the
+        // bottom left of renderTarget1.
+        utils::ComboRenderPassDescriptor renderPass({renderTarget.CreateView()});
+        renderPass.cColorAttachments[0].clearValue = {1.0f, 0.0f, 0.0f, 1.0f};
+
+        wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass);
+        pass.SetPipeline(pipeline);
+        pass.Draw(3);
+        pass.End();
+    }
+
+    wgpu::CommandBuffer commands = encoder.Finish();
+    queue.Submit(1, &commands);
+
+    // Validate that bottom left of render target is drawed to blue while upper right is still red
+    EXPECT_PIXEL_RGBA8_EQ(utils::RGBA8::kBlue, renderTarget, 1, kRTSize - 1);
+    EXPECT_PIXEL_RGBA8_EQ(utils::RGBA8::kRed, renderTarget, kRTSize - 1, 1);
+}
+
+// Test using f16 types as vertex shader user-defined input (vertex attributes), draw points of
+// different color given as vertex attributes.
+TEST_P(ShaderF16Tests, RenderPipelineIOF16_VertexAttribute) {
+    // Skip if device don't support f16 extension.
+    DAWN_TEST_UNSUPPORTED_IF(!device.HasFeature(wgpu::FeatureName::ShaderF16));
+
+    const char* shader = R"(
+enable f16;
+
+struct VSInput {
+    // position / 2.0
+    @location(0) pos_half : vec2<f16>,
+    // color / 4.0
+    @location(1) color_quarter : vec4<f16>,
+}
+
+struct VSOutput {
+    @builtin(position) pos : vec4<f32>,
+    @location(0) color : vec4<f32>,
+}
+
+@vertex
+fn VSMain(in: VSInput) -> VSOutput {
+    return VSOutput(vec4<f32>(vec2<f32>(in.pos_half * 2.0h), 0.0, 1.0), vec4<f32>(in.color_quarter * 4.0h));
+}
+
+@fragment
+fn FSMain(@location(0) color : vec4<f32>) -> @location(0) vec4<f32> {
+    return color;
+})";
+
+    wgpu::ShaderModule shaderModule = utils::CreateShaderModule(device, shader);
+
+    constexpr uint32_t kPointCount = 8;
+
+    // Position (divided by 2.0) for points on horizontal line
+    std::vector<float> positionData;
+    constexpr float xStep = 2.0 / kPointCount;
+    constexpr float xBias = -1.0 + xStep / 2.0f;
+    for (uint32_t i = 0; i < kPointCount; i++) {
+        // X position, divided by 2.0
+        positionData.push_back((xBias + xStep * i) / 2.0f);
+        // Y position (0.0f) divided by 2.0
+        positionData.push_back(0.0f);
+    }
+
+    // Expected color for each point
+    using RGBA8 = utils::RGBA8;
+    std::vector<RGBA8> colors = {
+        RGBA8::kBlack,
+        RGBA8::kRed,
+        RGBA8::kGreen,
+        RGBA8::kBlue,
+        RGBA8::kYellow,
+        RGBA8::kWhite,
+        RGBA8(96, 192, 176, 255),
+        RGBA8(184, 108, 184, 255),
+    };
+
+    ASSERT(colors.size() == kPointCount);
+    // Color (divided by 4.0) for each point
+    std::vector<float> colorData;
+    for (RGBA8& color : colors) {
+        colorData.push_back(color.r / 255.0 / 4.0);
+        colorData.push_back(color.g / 255.0 / 4.0);
+        colorData.push_back(color.b / 255.0 / 4.0);
+        colorData.push_back(color.a / 255.0 / 4.0);
+    }
+
+    // Store the data as float32x2 and float32x4 in vertex buffer, which should be convert to
+    // corresponding WGSL type vec2<f16> and vec4<f16> by driver.
+    // Buffer for pos_half
+    wgpu::Buffer vertexBufferPos = utils::CreateBufferFromData(
+        device, positionData.data(), 2 * kPointCount * sizeof(float), wgpu::BufferUsage::Vertex);
+    // Buffer for color_quarter
+    wgpu::Buffer vertexBufferColor = utils::CreateBufferFromData(
+        device, colorData.data(), 4 * kPointCount * sizeof(float), wgpu::BufferUsage::Vertex);
+
+    // Create render pipeline.
+    wgpu::RenderPipeline pipeline;
+    {
+        utils::ComboRenderPipelineDescriptor descriptor;
+
+        descriptor.vertex.module = shaderModule;
+        descriptor.vertex.entryPoint = "VSMain";
+        descriptor.vertex.bufferCount = 2;
+        // Interprete the vertex buffer data as Float32x2 and Float32x4, and the result should be
+        // converted to vec2<f16> and vec4<f16>
+        descriptor.cAttributes[0].format = wgpu::VertexFormat::Float32x2;
+        descriptor.cAttributes[0].offset = 0;
+        descriptor.cAttributes[0].shaderLocation = 0;
+        descriptor.cBuffers[0].stepMode = wgpu::VertexStepMode::Vertex;
+        descriptor.cBuffers[0].arrayStride = 8;
+        descriptor.cBuffers[0].attributeCount = 1;
+        descriptor.cBuffers[0].attributes = &descriptor.cAttributes[0];
+        descriptor.cAttributes[1].format = wgpu::VertexFormat::Float32x4;
+        descriptor.cAttributes[1].offset = 0;
+        descriptor.cAttributes[1].shaderLocation = 1;
+        descriptor.cBuffers[1].stepMode = wgpu::VertexStepMode::Vertex;
+        descriptor.cBuffers[1].arrayStride = 16;
+        descriptor.cBuffers[1].attributeCount = 1;
+        descriptor.cBuffers[1].attributes = &descriptor.cAttributes[1];
+
+        descriptor.cFragment.module = shaderModule;
+        descriptor.cFragment.entryPoint = "FSMain";
+        descriptor.primitive.topology = wgpu::PrimitiveTopology::PointList;
+        descriptor.cTargets[0].format = kFormat;
+
+        pipeline = device.CreateRenderPipeline(&descriptor);
+    }
+
+    // Create a render target of horizontal line
+    wgpu::Texture renderTarget;
+    {
+        wgpu::TextureDescriptor descriptor;
+        descriptor.dimension = wgpu::TextureDimension::e2D;
+        descriptor.size.width = kPointCount;
+        descriptor.size.height = 1;
+        descriptor.size.depthOrArrayLayers = 1;
+        descriptor.sampleCount = 1;
+        descriptor.format = kFormat;
+        descriptor.mipLevelCount = 1;
+        descriptor.usage = wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc;
+        renderTarget = device.CreateTexture(&descriptor);
+    }
+
+    wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+
+    {
+        // Clear renderTarget to zero and draw points.
+        utils::ComboRenderPassDescriptor renderPass({renderTarget.CreateView()});
+        renderPass.cColorAttachments[0].clearValue = {0.0f, 0.0f, 0.0f, 0.0f};
+
+        wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass);
+        pass.SetPipeline(pipeline);
+        pass.SetVertexBuffer(0, vertexBufferPos);
+        pass.SetVertexBuffer(1, vertexBufferColor);
+        pass.Draw(kPointCount);
+        pass.End();
+    }
+
+    wgpu::CommandBuffer commands = encoder.Finish();
+    queue.Submit(1, &commands);
+
+    // Validate the color of each point
+    for (uint32_t i = 0; i < kPointCount; i++) {
+        EXPECT_PIXEL_RGBA8_EQ(colors[i], renderTarget, i, 0);
+    }
+}
+
 // DawnTestBase::CreateDeviceImpl always disable disallow_unsafe_apis toggle.
 DAWN_INSTANTIATE_TEST_P(ShaderF16Tests,
                         {
diff --git a/src/dawn/tests/unittests/validation/RenderPipelineValidationTests.cpp b/src/dawn/tests/unittests/validation/RenderPipelineValidationTests.cpp
index 927f05b..7e8a19f 100644
--- a/src/dawn/tests/unittests/validation/RenderPipelineValidationTests.cpp
+++ b/src/dawn/tests/unittests/validation/RenderPipelineValidationTests.cpp
@@ -24,6 +24,26 @@
 
 class RenderPipelineValidationTest : public ValidationTest {
   protected:
+    WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override {
+        // Disabled disallowing unsafe APIs so we can test ShaderF16 feature.
+        const char* forceDisabledToggle[] = {"disallow_unsafe_apis"};
+
+        wgpu::DeviceDescriptor descriptor;
+        wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::ShaderF16};
+        descriptor.requiredFeatures = requiredFeatures;
+        descriptor.requiredFeaturesCount = 1;
+
+        wgpu::DawnTogglesDeviceDescriptor togglesDesc;
+        descriptor.nextInChain = &togglesDesc;
+
+        togglesDesc.forceEnabledToggles = nullptr;
+        togglesDesc.forceEnabledTogglesCount = 0;
+        togglesDesc.forceDisabledToggles = forceDisabledToggle;
+        togglesDesc.forceDisabledTogglesCount = 1;
+
+        return dawnAdapter.CreateDevice(&descriptor);
+    }
+
     void SetUp() override {
         ValidationTest::SetUp();
 
@@ -326,30 +346,53 @@
 
 // Tests that the format of the color state descriptor must match the output of the fragment shader.
 TEST_F(RenderPipelineValidationTest, FragmentOutputFormatCompatibility) {
-    std::array<const char*, 3> kScalarTypes = {{"f32", "i32", "u32"}};
-    std::array<wgpu::TextureFormat, 3> kColorFormats = {{wgpu::TextureFormat::RGBA8Unorm,
-                                                         wgpu::TextureFormat::RGBA8Sint,
-                                                         wgpu::TextureFormat::RGBA8Uint}};
+    std::vector<std::vector<std::string>> kScalarTypeLists = {// Float scalar types
+                                                              {"f32", "f16"},
+                                                              // Sint scalar type
+                                                              {"i32"},
+                                                              // Uint scalar type
+                                                              {"u32"}};
 
-    for (size_t i = 0; i < kScalarTypes.size(); ++i) {
-        utils::ComboRenderPipelineDescriptor descriptor;
-        descriptor.vertex.module = vsModule;
-        std::ostringstream stream;
-        stream << R"(
+    std::vector<std::vector<wgpu::TextureFormat>> kColorFormatLists = {
+        // Float color formats
+        {wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureFormat::RGBA16Float,
+         wgpu::TextureFormat::RGBA32Float},
+        // Sint color formats
+        {wgpu::TextureFormat::RGBA8Sint, wgpu::TextureFormat::RGBA16Sint,
+         wgpu::TextureFormat::RGBA32Sint},
+        // Uint color formats
+        {wgpu::TextureFormat::RGBA8Uint, wgpu::TextureFormat::RGBA16Uint,
+         wgpu::TextureFormat::RGBA32Uint}};
+
+    for (size_t i = 0; i < kScalarTypeLists.size(); ++i) {
+        for (const std::string& scalarType : kScalarTypeLists[i]) {
+            utils::ComboRenderPipelineDescriptor descriptor;
+            descriptor.vertex.module = vsModule;
+            std::ostringstream stream;
+
+            // Enable f16 extension if needed.
+            if (scalarType == "f16") {
+                stream << "enable f16;\n\n";
+            }
+            stream << R"(
             @fragment fn main() -> @location(0) vec4<)"
-               << kScalarTypes[i] << R"(> {
+                   << scalarType << R"(> {
                 var result : vec4<)"
-               << kScalarTypes[i] << R"(>;
+                   << scalarType << R"(>;
                 return result;
             })";
-        descriptor.cFragment.module = utils::CreateShaderModule(device, stream.str().c_str());
 
-        for (size_t j = 0; j < kColorFormats.size(); ++j) {
-            descriptor.cTargets[0].format = kColorFormats[j];
-            if (i == j) {
-                device.CreateRenderPipeline(&descriptor);
-            } else {
-                ASSERT_DEVICE_ERROR(device.CreateRenderPipeline(&descriptor));
+            descriptor.cFragment.module = utils::CreateShaderModule(device, stream.str().c_str());
+
+            for (size_t j = 0; j < kColorFormatLists.size(); ++j) {
+                for (wgpu::TextureFormat textureFormat : kColorFormatLists[j]) {
+                    descriptor.cTargets[0].format = textureFormat;
+                    if (i == j) {
+                        device.CreateRenderPipeline(&descriptor);
+                    } else {
+                        ASSERT_DEVICE_ERROR(device.CreateRenderPipeline(&descriptor));
+                    }
+                }
             }
         }
     }
@@ -1446,12 +1489,13 @@
 // Tests that creating render pipeline should fail when the type of a vertex stage output variable
 // doesn't match the type of the fragment stage input variable at the same location.
 TEST_F(InterStageVariableMatchingValidationTest, DifferentTypeAtSameLocation) {
-    constexpr std::array<const char*, 12> kTypes = {{"f32", "vec2<f32>", "vec3<f32>", "vec4<f32>",
+    constexpr std::array<const char*, 16> kTypes = {{"f32", "vec2<f32>", "vec3<f32>", "vec4<f32>",
+                                                     "f16", "vec2<f16>", "vec3<f16>", "vec4<f16>",
                                                      "i32", "vec2<i32>", "vec3<i32>", "vec4<i32>",
                                                      "u32", "vec2<u32>", "vec3<u32>", "vec4<u32>"}};
 
-    std::array<wgpu::ShaderModule, 12> vertexModules;
-    std::array<wgpu::ShaderModule, 12> fragmentModules;
+    std::array<wgpu::ShaderModule, 16> vertexModules;
+    std::array<wgpu::ShaderModule, 16> fragmentModules;
     for (uint32_t i = 0; i < kTypes.size(); ++i) {
         std::string interfaceDeclaration;
         {
@@ -1460,9 +1504,12 @@
                     << std::endl;
             interfaceDeclaration = sstream.str();
         }
+
+        std::string extensionDeclaration = "enable f16;\n\n";
+
         {
             std::ostringstream vertexStream;
-            vertexStream << interfaceDeclaration << R"(
+            vertexStream << extensionDeclaration << interfaceDeclaration << R"(
                     @builtin(position) pos: vec4<f32>,
                 }
                 @vertex fn main() -> A {
@@ -1474,7 +1521,7 @@
         }
         {
             std::ostringstream fragmentStream;
-            fragmentStream << interfaceDeclaration << R"(
+            fragmentStream << extensionDeclaration << interfaceDeclaration << R"(
                 }
                 @fragment fn main(fragmentIn: A) -> @location(0) vec4<f32> {
                     return vec4<f32>(0.0, 0.0, 0.0, 1.0);
diff --git a/src/tint/inspector/entry_point.h b/src/tint/inspector/entry_point.h
index 4a4706b..eabe601 100644
--- a/src/tint/inspector/entry_point.h
+++ b/src/tint/inspector/entry_point.h
@@ -30,9 +30,10 @@
 /// Base component type of a stage variable.
 enum class ComponentType {
     kUnknown = -1,
-    kFloat,
-    kUInt,
-    kSInt,
+    kF32,
+    kU32,
+    kI32,
+    kF16,
 };
 
 /// Composition of components of a stage variable.
diff --git a/src/tint/inspector/inspector.cc b/src/tint/inspector/inspector.cc
index ea5b3ed..b893ed1 100644
--- a/src/tint/inspector/inspector.cc
+++ b/src/tint/inspector/inspector.cc
@@ -69,41 +69,48 @@
 }
 
 std::tuple<ComponentType, CompositionType> CalculateComponentAndComposition(const sem::Type* type) {
-    if (type->is_float_scalar()) {
-        return {ComponentType::kFloat, CompositionType::kScalar};
-    } else if (type->is_float_vector()) {
-        auto* vec = type->As<sem::Vector>();
-        if (vec->Width() == 2) {
-            return {ComponentType::kFloat, CompositionType::kVec2};
-        } else if (vec->Width() == 3) {
-            return {ComponentType::kFloat, CompositionType::kVec3};
-        } else if (vec->Width() == 4) {
-            return {ComponentType::kFloat, CompositionType::kVec4};
+    // entry point in/out variables must of numeric scalar or vector types.
+    TINT_ASSERT(Inspector, type->is_numeric_scalar_or_vector());
+
+    ComponentType componentType = Switch(
+        sem::Type::DeepestElementOf(type),  //
+        [&](const sem::F32*) { return ComponentType::kF32; },
+        [&](const sem::F16*) { return ComponentType::kF16; },
+        [&](const sem::I32*) { return ComponentType::kI32; },
+        [&](const sem::U32*) { return ComponentType::kU32; },
+        [&](Default) {
+            tint::diag::List diagnostics;
+            TINT_UNREACHABLE(Inspector, diagnostics) << "unhandled component type";
+            return ComponentType::kUnknown;
+        });
+
+    CompositionType compositionType;
+    if (auto* vec = type->As<sem::Vector>()) {
+        switch (vec->Width()) {
+            case 2: {
+                compositionType = CompositionType::kVec2;
+                break;
+            }
+            case 3: {
+                compositionType = CompositionType::kVec3;
+                break;
+            }
+            case 4: {
+                compositionType = CompositionType::kVec4;
+                break;
+            }
+            default: {
+                tint::diag::List diagnostics;
+                TINT_UNREACHABLE(Inspector, diagnostics) << "unhandled composition type";
+                compositionType = CompositionType::kUnknown;
+                break;
+            }
         }
-    } else if (type->is_unsigned_integer_scalar()) {
-        return {ComponentType::kUInt, CompositionType::kScalar};
-    } else if (type->is_unsigned_integer_vector()) {
-        auto* vec = type->As<sem::Vector>();
-        if (vec->Width() == 2) {
-            return {ComponentType::kUInt, CompositionType::kVec2};
-        } else if (vec->Width() == 3) {
-            return {ComponentType::kUInt, CompositionType::kVec3};
-        } else if (vec->Width() == 4) {
-            return {ComponentType::kUInt, CompositionType::kVec4};
-        }
-    } else if (type->is_signed_integer_scalar()) {
-        return {ComponentType::kSInt, CompositionType::kScalar};
-    } else if (type->is_signed_integer_vector()) {
-        auto* vec = type->As<sem::Vector>();
-        if (vec->Width() == 2) {
-            return {ComponentType::kSInt, CompositionType::kVec2};
-        } else if (vec->Width() == 3) {
-            return {ComponentType::kSInt, CompositionType::kVec3};
-        } else if (vec->Width() == 4) {
-            return {ComponentType::kSInt, CompositionType::kVec4};
-        }
+    } else {
+        compositionType = CompositionType::kScalar;
     }
-    return {ComponentType::kUnknown, CompositionType::kUnknown};
+
+    return {componentType, compositionType};
 }
 
 std::tuple<InterpolationType, InterpolationSampling> CalculateInterpolationData(
diff --git a/src/tint/inspector/inspector_test.cc b/src/tint/inspector/inspector_test.cc
index 83302e2..78cfb5a 100644
--- a/src/tint/inspector/inspector_test.cc
+++ b/src/tint/inspector/inspector_test.cc
@@ -287,6 +287,10 @@
     std::tie(component, composition) = GetParam();
     std::function<const ast::Type*()> tint_type = GetTypeFunction(component, composition);
 
+    if (component == ComponentType::kF16) {
+        Enable(ast::Extension::kF16);
+    }
+
     auto* in_var = Param("in_var", tint_type(),
                          utils::Vector{
                              Location(0_u),
@@ -323,9 +327,10 @@
 }
 INSTANTIATE_TEST_SUITE_P(InspectorGetEntryPointTest,
                          InspectorGetEntryPointComponentAndCompositionTest,
-                         testing::Combine(testing::Values(ComponentType::kFloat,
-                                                          ComponentType::kSInt,
-                                                          ComponentType::kUInt),
+                         testing::Combine(testing::Values(ComponentType::kF32,
+                                                          ComponentType::kI32,
+                                                          ComponentType::kU32,
+                                                          ComponentType::kF16),
                                           testing::Values(CompositionType::kScalar,
                                                           CompositionType::kVec2,
                                                           CompositionType::kVec3,
@@ -369,23 +374,23 @@
     EXPECT_TRUE(result[0].input_variables[0].has_location_attribute);
     EXPECT_EQ(0u, result[0].input_variables[0].location_attribute);
     EXPECT_EQ(InterpolationType::kFlat, result[0].input_variables[0].interpolation_type);
-    EXPECT_EQ(ComponentType::kUInt, result[0].input_variables[0].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[0].input_variables[0].component_type);
     EXPECT_EQ("in_var1", result[0].input_variables[1].name);
     EXPECT_TRUE(result[0].input_variables[1].has_location_attribute);
     EXPECT_EQ(1u, result[0].input_variables[1].location_attribute);
     EXPECT_EQ(InterpolationType::kFlat, result[0].input_variables[1].interpolation_type);
-    EXPECT_EQ(ComponentType::kUInt, result[0].input_variables[1].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[0].input_variables[1].component_type);
     EXPECT_EQ("in_var4", result[0].input_variables[2].name);
     EXPECT_TRUE(result[0].input_variables[2].has_location_attribute);
     EXPECT_EQ(4u, result[0].input_variables[2].location_attribute);
     EXPECT_EQ(InterpolationType::kFlat, result[0].input_variables[2].interpolation_type);
-    EXPECT_EQ(ComponentType::kUInt, result[0].input_variables[2].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[0].input_variables[2].component_type);
 
     ASSERT_EQ(1u, result[0].output_variables.size());
     EXPECT_EQ("<retval>", result[0].output_variables[0].name);
     EXPECT_TRUE(result[0].output_variables[0].has_location_attribute);
     EXPECT_EQ(0u, result[0].output_variables[0].location_attribute);
-    EXPECT_EQ(ComponentType::kUInt, result[0].output_variables[0].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[0].output_variables[0].component_type);
 }
 
 TEST_F(InspectorGetEntryPointTest, MultipleEntryPointsInOutVariables) {
@@ -433,26 +438,26 @@
     EXPECT_TRUE(result[0].input_variables[0].has_location_attribute);
     EXPECT_EQ(0u, result[0].input_variables[0].location_attribute);
     EXPECT_EQ(InterpolationType::kFlat, result[0].input_variables[0].interpolation_type);
-    EXPECT_EQ(ComponentType::kUInt, result[0].input_variables[0].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[0].input_variables[0].component_type);
 
     ASSERT_EQ(1u, result[0].output_variables.size());
     EXPECT_EQ("<retval>", result[0].output_variables[0].name);
     EXPECT_TRUE(result[0].output_variables[0].has_location_attribute);
     EXPECT_EQ(0u, result[0].output_variables[0].location_attribute);
-    EXPECT_EQ(ComponentType::kUInt, result[0].output_variables[0].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[0].output_variables[0].component_type);
 
     ASSERT_EQ(1u, result[1].input_variables.size());
     EXPECT_EQ("in_var_bar", result[1].input_variables[0].name);
     EXPECT_TRUE(result[1].input_variables[0].has_location_attribute);
     EXPECT_EQ(0u, result[1].input_variables[0].location_attribute);
     EXPECT_EQ(InterpolationType::kFlat, result[1].input_variables[0].interpolation_type);
-    EXPECT_EQ(ComponentType::kUInt, result[1].input_variables[0].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[1].input_variables[0].component_type);
 
     ASSERT_EQ(1u, result[1].output_variables.size());
     EXPECT_EQ("<retval>", result[1].output_variables[0].name);
     EXPECT_TRUE(result[1].output_variables[0].has_location_attribute);
     EXPECT_EQ(1u, result[1].output_variables[0].location_attribute);
-    EXPECT_EQ(ComponentType::kUInt, result[1].output_variables[0].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[1].output_variables[0].component_type);
 }
 
 TEST_F(InspectorGetEntryPointTest, BuiltInsNotStageVariables) {
@@ -485,7 +490,7 @@
     EXPECT_EQ("in_var1", result[0].input_variables[0].name);
     EXPECT_TRUE(result[0].input_variables[0].has_location_attribute);
     EXPECT_EQ(0u, result[0].input_variables[0].location_attribute);
-    EXPECT_EQ(ComponentType::kFloat, result[0].input_variables[0].component_type);
+    EXPECT_EQ(ComponentType::kF32, result[0].input_variables[0].component_type);
 
     ASSERT_EQ(0u, result[0].output_variables.size());
 }
@@ -517,21 +522,21 @@
     EXPECT_EQ("param.a", result[0].input_variables[0].name);
     EXPECT_TRUE(result[0].input_variables[0].has_location_attribute);
     EXPECT_EQ(0u, result[0].input_variables[0].location_attribute);
-    EXPECT_EQ(ComponentType::kUInt, result[0].input_variables[0].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[0].input_variables[0].component_type);
     EXPECT_EQ("param.b", result[0].input_variables[1].name);
     EXPECT_TRUE(result[0].input_variables[1].has_location_attribute);
     EXPECT_EQ(1u, result[0].input_variables[1].location_attribute);
-    EXPECT_EQ(ComponentType::kUInt, result[0].input_variables[1].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[0].input_variables[1].component_type);
 
     ASSERT_EQ(2u, result[0].output_variables.size());
     EXPECT_EQ("<retval>.a", result[0].output_variables[0].name);
     EXPECT_TRUE(result[0].output_variables[0].has_location_attribute);
     EXPECT_EQ(0u, result[0].output_variables[0].location_attribute);
-    EXPECT_EQ(ComponentType::kUInt, result[0].output_variables[0].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[0].output_variables[0].component_type);
     EXPECT_EQ("<retval>.b", result[0].output_variables[1].name);
     EXPECT_TRUE(result[0].output_variables[1].has_location_attribute);
     EXPECT_EQ(1u, result[0].output_variables[1].location_attribute);
-    EXPECT_EQ(ComponentType::kUInt, result[0].output_variables[1].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[0].output_variables[1].component_type);
 }
 
 TEST_F(InspectorGetEntryPointTest, MultipleEntryPointsInOutSharedStruct) {
@@ -563,21 +568,21 @@
     EXPECT_EQ("<retval>.a", result[0].output_variables[0].name);
     EXPECT_TRUE(result[0].output_variables[0].has_location_attribute);
     EXPECT_EQ(0u, result[0].output_variables[0].location_attribute);
-    EXPECT_EQ(ComponentType::kUInt, result[0].output_variables[0].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[0].output_variables[0].component_type);
     EXPECT_EQ("<retval>.b", result[0].output_variables[1].name);
     EXPECT_TRUE(result[0].output_variables[1].has_location_attribute);
     EXPECT_EQ(1u, result[0].output_variables[1].location_attribute);
-    EXPECT_EQ(ComponentType::kUInt, result[0].output_variables[1].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[0].output_variables[1].component_type);
 
     ASSERT_EQ(2u, result[1].input_variables.size());
     EXPECT_EQ("param.a", result[1].input_variables[0].name);
     EXPECT_TRUE(result[1].input_variables[0].has_location_attribute);
     EXPECT_EQ(0u, result[1].input_variables[0].location_attribute);
-    EXPECT_EQ(ComponentType::kUInt, result[1].input_variables[0].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[1].input_variables[0].component_type);
     EXPECT_EQ("param.b", result[1].input_variables[1].name);
     EXPECT_TRUE(result[1].input_variables[1].has_location_attribute);
     EXPECT_EQ(1u, result[1].input_variables[1].location_attribute);
-    EXPECT_EQ(ComponentType::kUInt, result[1].input_variables[1].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[1].input_variables[1].component_type);
 
     ASSERT_EQ(0u, result[1].output_variables.size());
 }
@@ -615,33 +620,33 @@
     EXPECT_EQ("param_a.a", result[0].input_variables[0].name);
     EXPECT_TRUE(result[0].input_variables[0].has_location_attribute);
     EXPECT_EQ(0u, result[0].input_variables[0].location_attribute);
-    EXPECT_EQ(ComponentType::kUInt, result[0].input_variables[0].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[0].input_variables[0].component_type);
     EXPECT_EQ("param_a.b", result[0].input_variables[1].name);
     EXPECT_TRUE(result[0].input_variables[1].has_location_attribute);
     EXPECT_EQ(1u, result[0].input_variables[1].location_attribute);
-    EXPECT_EQ(ComponentType::kUInt, result[0].input_variables[1].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[0].input_variables[1].component_type);
     EXPECT_EQ("param_b.a", result[0].input_variables[2].name);
     EXPECT_TRUE(result[0].input_variables[2].has_location_attribute);
     EXPECT_EQ(2u, result[0].input_variables[2].location_attribute);
-    EXPECT_EQ(ComponentType::kUInt, result[0].input_variables[2].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[0].input_variables[2].component_type);
     EXPECT_EQ("param_c", result[0].input_variables[3].name);
     EXPECT_TRUE(result[0].input_variables[3].has_location_attribute);
     EXPECT_EQ(3u, result[0].input_variables[3].location_attribute);
-    EXPECT_EQ(ComponentType::kFloat, result[0].input_variables[3].component_type);
+    EXPECT_EQ(ComponentType::kF32, result[0].input_variables[3].component_type);
     EXPECT_EQ("param_d", result[0].input_variables[4].name);
     EXPECT_TRUE(result[0].input_variables[4].has_location_attribute);
     EXPECT_EQ(4u, result[0].input_variables[4].location_attribute);
-    EXPECT_EQ(ComponentType::kFloat, result[0].input_variables[4].component_type);
+    EXPECT_EQ(ComponentType::kF32, result[0].input_variables[4].component_type);
 
     ASSERT_EQ(2u, result[0].output_variables.size());
     EXPECT_EQ("<retval>.a", result[0].output_variables[0].name);
     EXPECT_TRUE(result[0].output_variables[0].has_location_attribute);
     EXPECT_EQ(0u, result[0].output_variables[0].location_attribute);
-    EXPECT_EQ(ComponentType::kUInt, result[0].output_variables[0].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[0].output_variables[0].component_type);
     EXPECT_EQ("<retval>.b", result[0].output_variables[1].name);
     EXPECT_TRUE(result[0].output_variables[1].has_location_attribute);
     EXPECT_EQ(1u, result[0].output_variables[1].location_attribute);
-    EXPECT_EQ(ComponentType::kUInt, result[0].output_variables[1].component_type);
+    EXPECT_EQ(ComponentType::kU32, result[0].output_variables[1].component_type);
 }
 
 TEST_F(InspectorGetEntryPointTest, OverrideUnreferenced) {
diff --git a/src/tint/inspector/test_inspector_builder.cc b/src/tint/inspector/test_inspector_builder.cc
index 79122dc..97ae097 100644
--- a/src/tint/inspector/test_inspector_builder.cc
+++ b/src/tint/inspector/test_inspector_builder.cc
@@ -307,15 +307,18 @@
                                                                     CompositionType composition) {
     std::function<const ast::Type*()> func;
     switch (component) {
-        case ComponentType::kFloat:
+        case ComponentType::kF32:
             func = [this]() -> const ast::Type* { return ty.f32(); };
             break;
-        case ComponentType::kSInt:
+        case ComponentType::kI32:
             func = [this]() -> const ast::Type* { return ty.i32(); };
             break;
-        case ComponentType::kUInt:
+        case ComponentType::kU32:
             func = [this]() -> const ast::Type* { return ty.u32(); };
             break;
+        case ComponentType::kF16:
+            func = [this]() -> const ast::Type* { return ty.f16(); };
+            break;
         case ComponentType::kUnknown:
             return []() -> const ast::Type* { return nullptr; };
     }
diff --git a/src/tint/resolver/entry_point_validation_test.cc b/src/tint/resolver/entry_point_validation_test.cc
index 79b41d7..cd49ded 100644
--- a/src/tint/resolver/entry_point_validation_test.cc
+++ b/src/tint/resolver/entry_point_validation_test.cc
@@ -606,17 +606,14 @@
     ParamsFor<alias<i32>>(true),    //
     ParamsFor<alias<u32>>(true),    //
     ParamsFor<alias<bool>>(false),  //
-    // Currently entry point IO of f16 types are not implemented yet.
-    // TODO(tint:1473, tint:1502): Change f16 and vecN<f16> cases to valid after f16 is supported in
-    // entry point IO.
-    ParamsFor<f16>(false),          //
-    ParamsFor<vec2<f16>>(false),    //
-    ParamsFor<vec3<f16>>(false),    //
-    ParamsFor<vec4<f16>>(false),    //
+    ParamsFor<f16>(true),           //
+    ParamsFor<vec2<f16>>(true),     //
+    ParamsFor<vec3<f16>>(true),     //
+    ParamsFor<vec4<f16>>(true),     //
     ParamsFor<mat2x2<f16>>(false),  //
     ParamsFor<mat3x3<f16>>(false),  //
     ParamsFor<mat4x4<f16>>(false),  //
-    ParamsFor<alias<f16>>(false),   //
+    ParamsFor<alias<f16>>(true),    //
 };
 
 TEST_P(TypeValidationTest, BareInputs) {
diff --git a/src/tint/resolver/validator.cc b/src/tint/resolver/validator.cc
index 8da1726..558217d 100644
--- a/src/tint/resolver/validator.cc
+++ b/src/tint/resolver/validator.cc
@@ -1068,13 +1068,6 @@
                                                      ParamOrRetType param_or_ret,
                                                      bool is_struct_member,
                                                      std::optional<uint32_t> location) {
-        // Temporally forbid using f16 types in entry point IO.
-        // TODO(tint:1473, tint:1502): Remove this error after f16 is supported in entry point IO.
-        if (Is<sem::F16>(sem::Type::DeepestElementOf(ty))) {
-            AddError("entry point IO of f16 types is not implemented yet", source);
-            return false;
-        }
-
         // Scan attributes for pipeline IO attributes.
         // Check for overlap with attributes that have been seen previously.
         const ast::Attribute* pipeline_io_attribute = nullptr;
diff --git a/src/tint/transform/vertex_pulling.cc b/src/tint/transform/vertex_pulling.cc
index 0196002..e213ac6 100644
--- a/src/tint/transform/vertex_pulling.cc
+++ b/src/tint/transform/vertex_pulling.cc
@@ -41,6 +41,7 @@
     kU32,
     kI32,
     kF32,
+    kF16,
 };
 
 /// The data type of a vertex format.
@@ -138,6 +139,7 @@
 bool IsTypeCompatible(AttributeWGSLType wgslType, VertexFormatType vertexFormatType) {
     switch (wgslType.base_type) {
         case BaseWGSLType::kF32:
+        case BaseWGSLType::kF16:
             return (vertexFormatType.base_type == VertexDataType::kFloat);
         case BaseWGSLType::kU32:
             return (vertexFormatType.base_type == VertexDataType::kUInt);
@@ -149,19 +151,26 @@
 }
 
 AttributeWGSLType WGSLTypeOf(const sem::Type* ty) {
-    if (ty->Is<sem::I32>()) {
-        return {BaseWGSLType::kI32, 1};
-    }
-    if (ty->Is<sem::U32>()) {
-        return {BaseWGSLType::kU32, 1};
-    }
-    if (ty->Is<sem::F32>()) {
-        return {BaseWGSLType::kF32, 1};
-    }
-    if (auto* vec = ty->As<sem::Vector>()) {
-        return {WGSLTypeOf(vec->type()).base_type, vec->Width()};
-    }
-    return {BaseWGSLType::kInvalid, 0};
+    return Switch(
+        ty,
+        [](const sem::I32*) -> AttributeWGSLType {
+            return {BaseWGSLType::kI32, 1};
+        },
+        [](const sem::U32*) -> AttributeWGSLType {
+            return {BaseWGSLType::kU32, 1};
+        },
+        [](const sem::F32*) -> AttributeWGSLType {
+            return {BaseWGSLType::kF32, 1};
+        },
+        [](const sem::F16*) -> AttributeWGSLType {
+            return {BaseWGSLType::kF16, 1};
+        },
+        [](const sem::Vector* vec) -> AttributeWGSLType {
+            return {WGSLTypeOf(vec->type()).base_type, vec->Width()};
+        },
+        [](Default) -> AttributeWGSLType {
+            return {BaseWGSLType::kInvalid, 0};
+        });
 }
 
 VertexFormatType VertexFormatTypeOf(VertexFormat format) {
@@ -378,9 +387,22 @@
 
                 // Load the attribute value according to vertex format and convert the element type
                 // of result to match target WGSL variable. The result of `Fetch` should be of WGSL
-                // types `f32`, `i32`, `u32`, and their vectors.
+                // types `f32`, `i32`, `u32`, and their vectors, while WGSL variable can be of
+                // `f16`.
                 auto* fetch = Fetch(buffer_array_base, attribute_desc.offset, buffer_idx,
                                     attribute_desc.format);
+                // Convert the fetched scalar/vector if WGSL variable is of `f16` types
+                if (var_dt.base_type == BaseWGSLType::kF16) {
+                    // The type of the same element number of base type of target WGSL variable
+                    const ast::Type* loaded_data_target_type;
+                    if (fmt_dt.width == 1) {
+                        loaded_data_target_type = b.ty.f16();
+                    } else {
+                        loaded_data_target_type = b.ty.vec(b.ty.f16(), fmt_dt.width);
+                    }
+
+                    fetch = b.Construct(loaded_data_target_type, fetch);
+                }
 
                 // The attribute value may not be of the desired vector width. If it is not, we'll
                 // need to either reduce the width with a swizzle, or append 0's and / or a 1.
diff --git a/src/tint/transform/vertex_pulling_test.cc b/src/tint/transform/vertex_pulling_test.cc
index 54c348e..a6dc2d2 100644
--- a/src/tint/transform/vertex_pulling_test.cc
+++ b/src/tint/transform/vertex_pulling_test.cc
@@ -736,6 +736,63 @@
     EXPECT_EQ(expect, str(got));
 }
 
+TEST_F(VertexPullingTest, FloatVectorAttributes_F16) {
+    auto* src = R"(
+enable f16;
+
+@vertex
+fn main(@location(0) var_a : vec2<f16>,
+        @location(1) var_b : vec3<f16>,
+        @location(2) var_c : vec4<f16>
+        ) -> @builtin(position) vec4<f32> {
+  return vec4<f32>();
+}
+)";
+
+    auto* expect = R"(
+enable f16;
+
+struct TintVertexData {
+  tint_vertex_data : array<u32>,
+}
+
+@binding(0) @group(4) var<storage, read> tint_pulling_vertex_buffer_0 : TintVertexData;
+
+@binding(1) @group(4) var<storage, read> tint_pulling_vertex_buffer_1 : TintVertexData;
+
+@binding(2) @group(4) var<storage, read> tint_pulling_vertex_buffer_2 : TintVertexData;
+
+@vertex
+fn main(@builtin(vertex_index) tint_pulling_vertex_index : u32) -> @builtin(position) vec4<f32> {
+  var var_a : vec2<f16>;
+  var var_b : vec3<f16>;
+  var var_c : vec4<f16>;
+  {
+    let buffer_array_base_0 = (tint_pulling_vertex_index * 2u);
+    var_a = vec2<f16>(vec2<f32>(bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[buffer_array_base_0]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 1u)])));
+    let buffer_array_base_1 = (tint_pulling_vertex_index * 3u);
+    var_b = vec3<f16>(vec3<f32>(bitcast<f32>(tint_pulling_vertex_buffer_1.tint_vertex_data[buffer_array_base_1]), bitcast<f32>(tint_pulling_vertex_buffer_1.tint_vertex_data[(buffer_array_base_1 + 1u)]), bitcast<f32>(tint_pulling_vertex_buffer_1.tint_vertex_data[(buffer_array_base_1 + 2u)])));
+    let buffer_array_base_2 = (tint_pulling_vertex_index * 4u);
+    var_c = vec4<f16>(vec4<f32>(unpack2x16float(tint_pulling_vertex_buffer_2.tint_vertex_data[buffer_array_base_2]), unpack2x16float(tint_pulling_vertex_buffer_2.tint_vertex_data[(buffer_array_base_2 + 1u)])));
+  }
+  return vec4<f32>();
+}
+)";
+
+    VertexPulling::Config cfg;
+    cfg.vertex_state = {{
+        {8, VertexStepMode::kVertex, {{VertexFormat::kFloat32x2, 0, 0}}},
+        {12, VertexStepMode::kVertex, {{VertexFormat::kFloat32x3, 0, 1}}},
+        {16, VertexStepMode::kVertex, {{VertexFormat::kFloat16x4, 0, 2}}},
+    }};
+
+    DataMap data;
+    data.Add<VertexPulling::Config>(cfg);
+    auto got = Run<VertexPulling>(src, data);
+
+    EXPECT_EQ(expect, str(got));
+}
+
 TEST_F(VertexPullingTest, AttemptSymbolCollision) {
     auto* src = R"(
 @vertex
@@ -1019,6 +1076,104 @@
     EXPECT_EQ(expect, str(got));
 }
 
+TEST_F(VertexPullingTest, FormatsAligned_Float_F16) {
+    auto* src = R"(
+enable f16;
+
+@vertex
+fn main(
+    @location(0) unorm8x2 : vec2<f16>,
+    @location(1) unorm8x4 : vec4<f16>,
+    @location(2) snorm8x2 : vec2<f16>,
+    @location(3) snorm8x4 : vec4<f16>,
+    @location(4) unorm16x2 : vec2<f16>,
+    @location(5) unorm16x4 : vec4<f16>,
+    @location(6) snorm16x2 : vec2<f16>,
+    @location(7) snorm16x4 : vec4<f16>,
+    @location(8) float16x2 : vec2<f16>,
+    @location(9) float16x4 : vec4<f16>,
+    @location(10) float32 : f16,
+    @location(11) float32x2 : vec2<f16>,
+    @location(12) float32x3 : vec3<f16>,
+    @location(13) float32x4 : vec4<f16>,
+  ) -> @builtin(position) vec4<f32> {
+  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+}
+)";
+
+    auto* expect = R"(
+enable f16;
+
+struct TintVertexData {
+  tint_vertex_data : array<u32>,
+}
+
+@binding(0) @group(4) var<storage, read> tint_pulling_vertex_buffer_0 : TintVertexData;
+
+@vertex
+fn main(@builtin(vertex_index) tint_pulling_vertex_index : u32) -> @builtin(position) vec4<f32> {
+  var unorm8x2 : vec2<f16>;
+  var unorm8x4 : vec4<f16>;
+  var snorm8x2 : vec2<f16>;
+  var snorm8x4 : vec4<f16>;
+  var unorm16x2 : vec2<f16>;
+  var unorm16x4 : vec4<f16>;
+  var snorm16x2 : vec2<f16>;
+  var snorm16x4 : vec4<f16>;
+  var float16x2 : vec2<f16>;
+  var float16x4 : vec4<f16>;
+  var float32 : f16;
+  var float32x2 : vec2<f16>;
+  var float32x3 : vec3<f16>;
+  var float32x4 : vec4<f16>;
+  {
+    let buffer_array_base_0 = (tint_pulling_vertex_index * 64u);
+    unorm8x2 = vec2<f16>(unpack4x8unorm((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] & 65535u)).xy);
+    unorm8x4 = vec4<f16>(unpack4x8unorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]));
+    snorm8x2 = vec2<f16>(unpack4x8snorm((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] & 65535u)).xy);
+    snorm8x4 = vec4<f16>(unpack4x8snorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]));
+    unorm16x2 = vec2<f16>(unpack2x16unorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]));
+    unorm16x4 = vec4<f16>(vec4<f32>(unpack2x16unorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), unpack2x16unorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)])));
+    snorm16x2 = vec2<f16>(unpack2x16snorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]));
+    snorm16x4 = vec4<f16>(vec4<f32>(unpack2x16snorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), unpack2x16snorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)])));
+    float16x2 = vec2<f16>(unpack2x16float(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]));
+    float16x4 = vec4<f16>(vec4<f32>(unpack2x16float(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), unpack2x16float(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)])));
+    float32 = f16(bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]));
+    float32x2 = vec2<f16>(vec2<f32>(bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)])));
+    float32x3 = vec3<f16>(vec3<f32>(bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 18u)])));
+    float32x4 = vec4<f16>(vec4<f32>(bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 18u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 19u)])));
+  }
+  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+}
+)";
+
+    VertexPulling::Config cfg;
+    cfg.vertex_state = {{{256,
+                          VertexStepMode::kVertex,
+                          {
+                              {VertexFormat::kUnorm8x2, 64, 0},
+                              {VertexFormat::kUnorm8x4, 64, 1},
+                              {VertexFormat::kSnorm8x2, 64, 2},
+                              {VertexFormat::kSnorm8x4, 64, 3},
+                              {VertexFormat::kUnorm16x2, 64, 4},
+                              {VertexFormat::kUnorm16x4, 64, 5},
+                              {VertexFormat::kSnorm16x2, 64, 6},
+                              {VertexFormat::kSnorm16x4, 64, 7},
+                              {VertexFormat::kFloat16x2, 64, 8},
+                              {VertexFormat::kFloat16x4, 64, 9},
+                              {VertexFormat::kFloat32, 64, 10},
+                              {VertexFormat::kFloat32x2, 64, 11},
+                              {VertexFormat::kFloat32x3, 64, 12},
+                              {VertexFormat::kFloat32x4, 64, 13},
+                          }}}};
+
+    DataMap data;
+    data.Add<VertexPulling::Config>(cfg);
+    auto got = Run<VertexPulling>(src, data);
+
+    EXPECT_EQ(expect, str(got));
+}
+
 TEST_F(VertexPullingTest, FormatsUnaligned_SInt) {
     auto* src = R"(
 @vertex
@@ -1253,6 +1408,104 @@
     EXPECT_EQ(expect, str(got));
 }
 
+TEST_F(VertexPullingTest, FormatsUnaligned_Float_F16) {
+    auto* src = R"(
+enable f16;
+
+@vertex
+fn main(
+    @location(0) unorm8x2 : vec2<f16>,
+    @location(1) unorm8x4 : vec4<f16>,
+    @location(2) snorm8x2 : vec2<f16>,
+    @location(3) snorm8x4 : vec4<f16>,
+    @location(4) unorm16x2 : vec2<f16>,
+    @location(5) unorm16x4 : vec4<f16>,
+    @location(6) snorm16x2 : vec2<f16>,
+    @location(7) snorm16x4 : vec4<f16>,
+    @location(8) float16x2 : vec2<f16>,
+    @location(9) float16x4 : vec4<f16>,
+    @location(10) float32 : f16,
+    @location(11) float32x2 : vec2<f16>,
+    @location(12) float32x3 : vec3<f16>,
+    @location(13) float32x4 : vec4<f16>,
+  ) -> @builtin(position) vec4<f32> {
+  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+}
+)";
+
+    auto* expect = R"(
+enable f16;
+
+struct TintVertexData {
+  tint_vertex_data : array<u32>,
+}
+
+@binding(0) @group(4) var<storage, read> tint_pulling_vertex_buffer_0 : TintVertexData;
+
+@vertex
+fn main(@builtin(vertex_index) tint_pulling_vertex_index : u32) -> @builtin(position) vec4<f32> {
+  var unorm8x2 : vec2<f16>;
+  var unorm8x4 : vec4<f16>;
+  var snorm8x2 : vec2<f16>;
+  var snorm8x4 : vec4<f16>;
+  var unorm16x2 : vec2<f16>;
+  var unorm16x4 : vec4<f16>;
+  var snorm16x2 : vec2<f16>;
+  var snorm16x4 : vec4<f16>;
+  var float16x2 : vec2<f16>;
+  var float16x4 : vec4<f16>;
+  var float32 : f16;
+  var float32x2 : vec2<f16>;
+  var float32x3 : vec3<f16>;
+  var float32x4 : vec4<f16>;
+  {
+    let buffer_array_base_0 = (tint_pulling_vertex_index * 64u);
+    unorm8x2 = vec2<f16>(unpack4x8unorm((((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] << 8u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 15u)] >> 24u)) & 65535u)).xy);
+    unorm8x4 = vec4<f16>(unpack4x8unorm(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 15u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] << 8u))));
+    snorm8x2 = vec2<f16>(unpack4x8snorm((((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] << 8u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 15u)] >> 24u)) & 65535u)).xy);
+    snorm8x4 = vec4<f16>(unpack4x8snorm(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 15u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] << 8u))));
+    unorm16x2 = vec2<f16>(unpack2x16unorm(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 15u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] << 8u))));
+    unorm16x4 = vec4<f16>(vec4<f32>(unpack2x16unorm(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 15u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] << 8u))), unpack2x16unorm(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)] << 8u)))));
+    snorm16x2 = vec2<f16>(unpack2x16snorm(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 15u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] << 8u))));
+    snorm16x4 = vec4<f16>(vec4<f32>(unpack2x16snorm(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 15u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] << 8u))), unpack2x16snorm(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)] << 8u)))));
+    float16x2 = vec2<f16>(unpack2x16float(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 15u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] << 8u))));
+    float16x4 = vec4<f16>(vec4<f32>(unpack2x16float(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 15u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] << 8u))), unpack2x16float(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)] << 8u)))));
+    float32 = f16(bitcast<f32>(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 15u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] << 8u))));
+    float32x2 = vec2<f16>(vec2<f32>(bitcast<f32>(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 15u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] << 8u))), bitcast<f32>(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)] << 8u)))));
+    float32x3 = vec3<f16>(vec3<f32>(bitcast<f32>(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 15u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] << 8u))), bitcast<f32>(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)] << 8u))), bitcast<f32>(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 18u)] << 8u)))));
+    float32x4 = vec4<f16>(vec4<f32>(bitcast<f32>(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 15u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] << 8u))), bitcast<f32>(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)] << 8u))), bitcast<f32>(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 18u)] << 8u))), bitcast<f32>(((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 18u)] >> 24u) | (tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 19u)] << 8u)))));
+  }
+  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+}
+)";
+
+    VertexPulling::Config cfg;
+    cfg.vertex_state = {{{256,
+                          VertexStepMode::kVertex,
+                          {
+                              {VertexFormat::kUnorm8x2, 63, 0},
+                              {VertexFormat::kUnorm8x4, 63, 1},
+                              {VertexFormat::kSnorm8x2, 63, 2},
+                              {VertexFormat::kSnorm8x4, 63, 3},
+                              {VertexFormat::kUnorm16x2, 63, 4},
+                              {VertexFormat::kUnorm16x4, 63, 5},
+                              {VertexFormat::kSnorm16x2, 63, 6},
+                              {VertexFormat::kSnorm16x4, 63, 7},
+                              {VertexFormat::kFloat16x2, 63, 8},
+                              {VertexFormat::kFloat16x4, 63, 9},
+                              {VertexFormat::kFloat32, 63, 10},
+                              {VertexFormat::kFloat32x2, 63, 11},
+                              {VertexFormat::kFloat32x3, 63, 12},
+                              {VertexFormat::kFloat32x4, 63, 13},
+                          }}}};
+
+    DataMap data;
+    data.Add<VertexPulling::Config>(cfg);
+    auto got = Run<VertexPulling>(src, data);
+
+    EXPECT_EQ(expect, str(got));
+}
+
 TEST_F(VertexPullingTest, FormatsWithVectorsResized_Padding_SInt) {
     auto* src = R"(
 @vertex
@@ -1511,6 +1764,112 @@
     EXPECT_EQ(expect, str(got));
 }
 
+TEST_F(VertexPullingTest, FormatsWithVectorsResized_Padding_Float_F16) {
+    auto* src = R"(
+enable f16;
+
+@vertex
+fn main(
+    @location(0)  vec3_unorm8x2 :  vec3<f16>,
+    @location(1)  vec4_unorm8x2 :  vec4<f16>,
+    @location(2)  vec3_snorm8x2 :  vec3<f16>,
+    @location(3)  vec4_snorm8x2 :  vec4<f16>,
+    @location(4)  vec3_unorm16x2 : vec3<f16>,
+    @location(5)  vec4_unorm16x2 : vec4<f16>,
+    @location(6)  vec3_snorm16x2 : vec3<f16>,
+    @location(7)  vec4_snorm16x2 : vec4<f16>,
+    @location(8)  vec3_float16x2 : vec3<f16>,
+    @location(9)  vec4_float16x2 : vec4<f16>,
+    @location(10) vec2_float32 :   vec2<f16>,
+    @location(11) vec3_float32 :   vec3<f16>,
+    @location(12) vec4_float32 :   vec4<f16>,
+    @location(13) vec3_float32x2 : vec3<f16>,
+    @location(14) vec4_float32x2 : vec4<f16>,
+    @location(15) vec4_float32x3 : vec4<f16>,
+  ) -> @builtin(position) vec4<f32> {
+  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+}
+)";
+
+    auto* expect = R"(
+enable f16;
+
+struct TintVertexData {
+  tint_vertex_data : array<u32>,
+}
+
+@binding(0) @group(4) var<storage, read> tint_pulling_vertex_buffer_0 : TintVertexData;
+
+@vertex
+fn main(@builtin(vertex_index) tint_pulling_vertex_index : u32) -> @builtin(position) vec4<f32> {
+  var vec3_unorm8x2 : vec3<f16>;
+  var vec4_unorm8x2 : vec4<f16>;
+  var vec3_snorm8x2 : vec3<f16>;
+  var vec4_snorm8x2 : vec4<f16>;
+  var vec3_unorm16x2 : vec3<f16>;
+  var vec4_unorm16x2 : vec4<f16>;
+  var vec3_snorm16x2 : vec3<f16>;
+  var vec4_snorm16x2 : vec4<f16>;
+  var vec3_float16x2 : vec3<f16>;
+  var vec4_float16x2 : vec4<f16>;
+  var vec2_float32 : vec2<f16>;
+  var vec3_float32 : vec3<f16>;
+  var vec4_float32 : vec4<f16>;
+  var vec3_float32x2 : vec3<f16>;
+  var vec4_float32x2 : vec4<f16>;
+  var vec4_float32x3 : vec4<f16>;
+  {
+    let buffer_array_base_0 = (tint_pulling_vertex_index * 64u);
+    vec3_unorm8x2 = vec3<f16>(vec2<f16>(unpack4x8unorm((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] & 65535u)).xy), 0.0);
+    vec4_unorm8x2 = vec4<f16>(vec2<f16>(unpack4x8unorm((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] & 65535u)).xy), 0.0, 1.0);
+    vec3_snorm8x2 = vec3<f16>(vec2<f16>(unpack4x8snorm((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] & 65535u)).xy), 0.0);
+    vec4_snorm8x2 = vec4<f16>(vec2<f16>(unpack4x8snorm((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] & 65535u)).xy), 0.0, 1.0);
+    vec3_unorm16x2 = vec3<f16>(vec2<f16>(unpack2x16unorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])), 0.0);
+    vec4_unorm16x2 = vec4<f16>(vec2<f16>(unpack2x16unorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])), 0.0, 1.0);
+    vec3_snorm16x2 = vec3<f16>(vec2<f16>(unpack2x16snorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])), 0.0);
+    vec4_snorm16x2 = vec4<f16>(vec2<f16>(unpack2x16snorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])), 0.0, 1.0);
+    vec3_float16x2 = vec3<f16>(vec2<f16>(unpack2x16float(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])), 0.0);
+    vec4_float16x2 = vec4<f16>(vec2<f16>(unpack2x16float(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])), 0.0, 1.0);
+    vec2_float32 = vec2<f16>(f16(bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])), 0.0);
+    vec3_float32 = vec3<f16>(f16(bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])), 0.0, 0.0);
+    vec4_float32 = vec4<f16>(f16(bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])), 0.0, 0.0, 1.0);
+    vec3_float32x2 = vec3<f16>(vec2<f16>(vec2<f32>(bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]))), 0.0);
+    vec4_float32x2 = vec4<f16>(vec2<f16>(vec2<f32>(bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]))), 0.0, 1.0);
+    vec4_float32x3 = vec4<f16>(vec3<f16>(vec3<f32>(bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 18u)]))), 1.0);
+  }
+  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+}
+)";
+
+    VertexPulling::Config cfg;
+    cfg.vertex_state = {{{256,
+                          VertexStepMode::kVertex,
+                          {
+                              {VertexFormat::kUnorm8x2, 64, 0},
+                              {VertexFormat::kUnorm8x2, 64, 1},
+                              {VertexFormat::kSnorm8x2, 64, 2},
+                              {VertexFormat::kSnorm8x2, 64, 3},
+                              {VertexFormat::kUnorm16x2, 64, 4},
+                              {VertexFormat::kUnorm16x2, 64, 5},
+                              {VertexFormat::kSnorm16x2, 64, 6},
+                              {VertexFormat::kSnorm16x2, 64, 7},
+                              {VertexFormat::kFloat16x2, 64, 8},
+                              {VertexFormat::kFloat16x2, 64, 9},
+                              {VertexFormat::kFloat32, 64, 10},
+                              {VertexFormat::kFloat32, 64, 11},
+                              {VertexFormat::kFloat32, 64, 12},
+                              {VertexFormat::kFloat32x2, 64, 13},
+                              {VertexFormat::kFloat32x2, 64, 14},
+                              {VertexFormat::kFloat32x3, 64, 15},
+                          }}}};
+
+    DataMap data;
+    data.Add<VertexPulling::Config>(cfg);
+    auto got = Run<VertexPulling>(src, data);
+
+    EXPECT_EQ(expect, str(got));
+}
+
 TEST_F(VertexPullingTest, FormatsWithVectorsResized_Shrinking_SInt) {
     auto* src = R"(
 @vertex
@@ -1829,5 +2188,139 @@
     EXPECT_EQ(expect, str(got));
 }
 
+TEST_F(VertexPullingTest, FormatsWithVectorsResized_Shrinking_Float_F16) {
+    auto* src = R"(
+enable f16;
+
+@vertex
+fn main(
+    @location(0)  sclr_unorm8x2  :      f16 ,
+    @location(1)  sclr_unorm8x4  :      f16 ,
+    @location(2)  vec2_unorm8x4  : vec2<f16>,
+    @location(3)  vec3_unorm8x4  : vec3<f16>,
+    @location(4)  sclr_snorm8x2  :      f16 ,
+    @location(5)  sclr_snorm8x4  :      f16 ,
+    @location(6)  vec2_snorm8x4  : vec2<f16>,
+    @location(7)  vec3_snorm8x4  : vec3<f16>,
+    @location(8)  sclr_unorm16x2 :      f16 ,
+    @location(9)  sclr_unorm16x4 :      f16 ,
+    @location(10) vec2_unorm16x4 : vec2<f16>,
+    @location(11) vec3_unorm16x4 : vec3<f16>,
+    @location(12) sclr_snorm16x2 :      f16 ,
+    @location(13) sclr_snorm16x4 :      f16 ,
+    @location(14) vec2_snorm16x4 : vec2<f16>,
+    @location(15) vec3_snorm16x4 : vec3<f16>,
+    @location(16) sclr_float16x2 :      f16 ,
+    @location(17) sclr_float16x4 :      f16 ,
+    @location(18) vec2_float16x4 : vec2<f16>,
+    @location(19) vec3_float16x4 : vec3<f16>,
+    @location(20) sclr_float32x2 :      f16 ,
+    @location(21) sclr_float32x3 :      f16 ,
+    @location(22) vec2_float32x3 : vec2<f16>,
+    @location(23) sclr_float32x4 :      f16 ,
+    @location(24) vec2_float32x4 : vec2<f16>,
+    @location(25) vec3_float32x4 : vec3<f16>,
+  ) -> @builtin(position) vec4<f32> {
+  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+}
+)";
+
+    auto* expect = R"(
+enable f16;
+
+struct TintVertexData {
+  tint_vertex_data : array<u32>,
+}
+
+@binding(0) @group(4) var<storage, read> tint_pulling_vertex_buffer_0 : TintVertexData;
+
+@vertex
+fn main(@builtin(vertex_index) tint_pulling_vertex_index : u32) -> @builtin(position) vec4<f32> {
+  var sclr_unorm8x2 : f16;
+  var sclr_unorm8x4 : f16;
+  var vec2_unorm8x4 : vec2<f16>;
+  var vec3_unorm8x4 : vec3<f16>;
+  var sclr_snorm8x2 : f16;
+  var sclr_snorm8x4 : f16;
+  var vec2_snorm8x4 : vec2<f16>;
+  var vec3_snorm8x4 : vec3<f16>;
+  var sclr_unorm16x2 : f16;
+  var sclr_unorm16x4 : f16;
+  var vec2_unorm16x4 : vec2<f16>;
+  var vec3_unorm16x4 : vec3<f16>;
+  var sclr_snorm16x2 : f16;
+  var sclr_snorm16x4 : f16;
+  var vec2_snorm16x4 : vec2<f16>;
+  var vec3_snorm16x4 : vec3<f16>;
+  var sclr_float16x2 : f16;
+  var sclr_float16x4 : f16;
+  var vec2_float16x4 : vec2<f16>;
+  var vec3_float16x4 : vec3<f16>;
+  var sclr_float32x2 : f16;
+  var sclr_float32x3 : f16;
+  var vec2_float32x3 : vec2<f16>;
+  var sclr_float32x4 : f16;
+  var vec2_float32x4 : vec2<f16>;
+  var vec3_float32x4 : vec3<f16>;
+  {
+    let buffer_array_base_0 = (tint_pulling_vertex_index * 64u);
+    sclr_unorm8x2 = vec2<f16>(unpack4x8unorm((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] & 65535u)).xy).x;
+    sclr_unorm8x4 = vec4<f16>(unpack4x8unorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])).x;
+    vec2_unorm8x4 = vec4<f16>(unpack4x8unorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])).xy;
+    vec3_unorm8x4 = vec4<f16>(unpack4x8unorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])).xyz;
+    sclr_snorm8x2 = vec2<f16>(unpack4x8snorm((tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)] & 65535u)).xy).x;
+    sclr_snorm8x4 = vec4<f16>(unpack4x8snorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])).x;
+    vec2_snorm8x4 = vec4<f16>(unpack4x8snorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])).xy;
+    vec3_snorm8x4 = vec4<f16>(unpack4x8snorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])).xyz;
+    sclr_unorm16x2 = vec2<f16>(unpack2x16unorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])).x;
+    sclr_unorm16x4 = vec4<f16>(vec4<f32>(unpack2x16unorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), unpack2x16unorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]))).x;
+    vec2_unorm16x4 = vec4<f16>(vec4<f32>(unpack2x16unorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), unpack2x16unorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]))).xy;
+    vec3_unorm16x4 = vec4<f16>(vec4<f32>(unpack2x16unorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), unpack2x16unorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]))).xyz;
+    sclr_snorm16x2 = vec2<f16>(unpack2x16snorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])).x;
+    sclr_snorm16x4 = vec4<f16>(vec4<f32>(unpack2x16snorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), unpack2x16snorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]))).x;
+    vec2_snorm16x4 = vec4<f16>(vec4<f32>(unpack2x16snorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), unpack2x16snorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]))).xy;
+    vec3_snorm16x4 = vec4<f16>(vec4<f32>(unpack2x16snorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), unpack2x16snorm(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]))).xyz;
+    sclr_float16x2 = vec2<f16>(unpack2x16float(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)])).x;
+    sclr_float16x4 = vec4<f16>(vec4<f32>(unpack2x16float(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), unpack2x16float(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]))).x;
+    vec2_float16x4 = vec4<f16>(vec4<f32>(unpack2x16float(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), unpack2x16float(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]))).xy;
+    vec3_float16x4 = vec4<f16>(vec4<f32>(unpack2x16float(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), unpack2x16float(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]))).xyz;
+    sclr_float32x2 = vec2<f16>(vec2<f32>(bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]))).x;
+    sclr_float32x3 = vec3<f16>(vec3<f32>(bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 18u)]))).x;
+    vec2_float32x3 = vec3<f16>(vec3<f32>(bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 18u)]))).xy;
+    sclr_float32x4 = vec4<f16>(vec4<f32>(bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 18u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 19u)]))).x;
+    vec2_float32x4 = vec4<f16>(vec4<f32>(bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 18u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 19u)]))).xy;
+    vec3_float32x4 = vec4<f16>(vec4<f32>(bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 16u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 17u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 18u)]), bitcast<f32>(tint_pulling_vertex_buffer_0.tint_vertex_data[(buffer_array_base_0 + 19u)]))).xyz;
+  }
+  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+}
+)";
+
+    VertexPulling::Config cfg;
+    cfg.vertex_state = {
+        {{256,
+          VertexStepMode::kVertex,
+          {
+              {VertexFormat::kUnorm8x2, 64, 0},   {VertexFormat::kUnorm8x4, 64, 1},
+              {VertexFormat::kUnorm8x4, 64, 2},   {VertexFormat::kUnorm8x4, 64, 3},
+              {VertexFormat::kSnorm8x2, 64, 4},   {VertexFormat::kSnorm8x4, 64, 5},
+              {VertexFormat::kSnorm8x4, 64, 6},   {VertexFormat::kSnorm8x4, 64, 7},
+              {VertexFormat::kUnorm16x2, 64, 8},  {VertexFormat::kUnorm16x4, 64, 9},
+              {VertexFormat::kUnorm16x4, 64, 10}, {VertexFormat::kUnorm16x4, 64, 11},
+              {VertexFormat::kSnorm16x2, 64, 12}, {VertexFormat::kSnorm16x4, 64, 13},
+              {VertexFormat::kSnorm16x4, 64, 14}, {VertexFormat::kSnorm16x4, 64, 15},
+              {VertexFormat::kFloat16x2, 64, 16}, {VertexFormat::kFloat16x4, 64, 17},
+              {VertexFormat::kFloat16x4, 64, 18}, {VertexFormat::kFloat16x4, 64, 19},
+              {VertexFormat::kFloat32x2, 64, 20}, {VertexFormat::kFloat32x3, 64, 21},
+              {VertexFormat::kFloat32x3, 64, 22}, {VertexFormat::kFloat32x4, 64, 23},
+              {VertexFormat::kFloat32x4, 64, 24}, {VertexFormat::kFloat32x4, 64, 25},
+          }}}};
+
+    DataMap data;
+    data.Add<VertexPulling::Config>(cfg);
+    auto got = Run<VertexPulling>(src, data);
+
+    EXPECT_EQ(expect, str(got));
+}
+
 }  // namespace
 }  // namespace tint::transform
diff --git a/test/tint/shader_io/fragment_input_locations_f16.wgsl b/test/tint/shader_io/fragment_input_locations_f16.wgsl
new file mode 100644
index 0000000..9cb4caf
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_locations_f16.wgsl
@@ -0,0 +1,18 @@
+enable f16;
+
+@fragment
+fn main(
+  @location(0) @interpolate(flat) loc0 : i32,
+  @location(1) @interpolate(flat) loc1 : u32,
+  @location(2) loc2 : f32,
+  @location(3) loc3 : vec4<f32>,
+  @location(4) loc4 : f16,
+  @location(5) loc5 : vec3<f16>,
+) {
+  let i : i32 = loc0;
+  let u : u32 = loc1;
+  let f : f32 = loc2;
+  let v : vec4<f32> = loc3;
+  let x : f16 = loc4;
+  let y : vec3<f16> = loc5;
+}
diff --git a/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.dxc.hlsl b/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.dxc.hlsl
new file mode 100644
index 0000000..44d85fb
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.dxc.hlsl
@@ -0,0 +1,22 @@
+struct tint_symbol_1 {
+  nointerpolation int loc0 : TEXCOORD0;
+  nointerpolation uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+  float16_t loc4 : TEXCOORD4;
+  vector<float16_t, 3> loc5 : TEXCOORD5;
+};
+
+void main_inner(int loc0, uint loc1, float loc2, float4 loc3, float16_t loc4, vector<float16_t, 3> loc5) {
+  const int i = loc0;
+  const uint u = loc1;
+  const float f = loc2;
+  const float4 v = loc3;
+  const float16_t x = loc4;
+  const vector<float16_t, 3> y = loc5;
+}
+
+void main(tint_symbol_1 tint_symbol) {
+  main_inner(tint_symbol.loc0, tint_symbol.loc1, tint_symbol.loc2, tint_symbol.loc3, tint_symbol.loc4, tint_symbol.loc5);
+  return;
+}
diff --git a/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.fxc.hlsl b/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.fxc.hlsl
new file mode 100644
index 0000000..faa74b5
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.fxc.hlsl
@@ -0,0 +1,27 @@
+SKIP: FAILED
+
+struct tint_symbol_1 {
+  nointerpolation int loc0 : TEXCOORD0;
+  nointerpolation uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+  float16_t loc4 : TEXCOORD4;
+  vector<float16_t, 3> loc5 : TEXCOORD5;
+};
+
+void main_inner(int loc0, uint loc1, float loc2, float4 loc3, float16_t loc4, vector<float16_t, 3> loc5) {
+  const int i = loc0;
+  const uint u = loc1;
+  const float f = loc2;
+  const float4 v = loc3;
+  const float16_t x = loc4;
+  const vector<float16_t, 3> y = loc5;
+}
+
+void main(tint_symbol_1 tint_symbol) {
+  main_inner(tint_symbol.loc0, tint_symbol.loc1, tint_symbol.loc2, tint_symbol.loc3, tint_symbol.loc4, tint_symbol.loc5);
+  return;
+}
+FXC validation failure:
+D:\Projects\RampUp\dawn\test\tint\shader_io\Shader@0x0000020BD1D24AC0(6,3-11): error X3000: unrecognized identifier 'float16_t'
+
diff --git a/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.glsl b/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.glsl
new file mode 100644
index 0000000..514ba55
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.glsl
@@ -0,0 +1,23 @@
+#version 310 es
+#extension GL_AMD_gpu_shader_half_float : require
+precision mediump float;
+
+layout(location = 0) flat in int loc0_1;
+layout(location = 1) flat in uint loc1_1;
+layout(location = 2) in float loc2_1;
+layout(location = 3) in vec4 loc3_1;
+layout(location = 4) in float16_t loc4_1;
+layout(location = 5) in f16vec3 loc5_1;
+void tint_symbol(int loc0, uint loc1, float loc2, vec4 loc3, float16_t loc4, f16vec3 loc5) {
+  int i = loc0;
+  uint u = loc1;
+  float f = loc2;
+  vec4 v = loc3;
+  float16_t x = loc4;
+  f16vec3 y = loc5;
+}
+
+void main() {
+  tint_symbol(loc0_1, loc1_1, loc2_1, loc3_1, loc4_1, loc5_1);
+  return;
+}
diff --git a/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.msl b/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.msl
new file mode 100644
index 0000000..6399fd7
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.msl
@@ -0,0 +1,26 @@
+#include <metal_stdlib>
+
+using namespace metal;
+struct tint_symbol_2 {
+  int loc0 [[user(locn0)]] [[flat]];
+  uint loc1 [[user(locn1)]] [[flat]];
+  float loc2 [[user(locn2)]];
+  float4 loc3 [[user(locn3)]];
+  half loc4 [[user(locn4)]];
+  half3 loc5 [[user(locn5)]];
+};
+
+void tint_symbol_inner(int loc0, uint loc1, float loc2, float4 loc3, half loc4, half3 loc5) {
+  int const i = loc0;
+  uint const u = loc1;
+  float const f = loc2;
+  float4 const v = loc3;
+  half const x = loc4;
+  half3 const y = loc5;
+}
+
+fragment void tint_symbol(tint_symbol_2 tint_symbol_1 [[stage_in]]) {
+  tint_symbol_inner(tint_symbol_1.loc0, tint_symbol_1.loc1, tint_symbol_1.loc2, tint_symbol_1.loc3, tint_symbol_1.loc4, tint_symbol_1.loc5);
+  return;
+}
+
diff --git a/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.spvasm b/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.spvasm
new file mode 100644
index 0000000..761fb61
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.spvasm
@@ -0,0 +1,77 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 39
+; Schema: 0
+               OpCapability Shader
+               OpCapability Float16
+               OpCapability UniformAndStorageBuffer16BitAccess
+               OpCapability StorageBuffer16BitAccess
+               OpCapability StorageInputOutput16
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %main "main" %loc0_1 %loc1_1 %loc2_1 %loc3_1 %loc4_1 %loc5_1
+               OpExecutionMode %main OriginUpperLeft
+               OpName %loc0_1 "loc0_1"
+               OpName %loc1_1 "loc1_1"
+               OpName %loc2_1 "loc2_1"
+               OpName %loc3_1 "loc3_1"
+               OpName %loc4_1 "loc4_1"
+               OpName %loc5_1 "loc5_1"
+               OpName %main_inner "main_inner"
+               OpName %loc0 "loc0"
+               OpName %loc1 "loc1"
+               OpName %loc2 "loc2"
+               OpName %loc3 "loc3"
+               OpName %loc4 "loc4"
+               OpName %loc5 "loc5"
+               OpName %main "main"
+               OpDecorate %loc0_1 Location 0
+               OpDecorate %loc0_1 Flat
+               OpDecorate %loc1_1 Location 1
+               OpDecorate %loc1_1 Flat
+               OpDecorate %loc2_1 Location 2
+               OpDecorate %loc3_1 Location 3
+               OpDecorate %loc4_1 Location 4
+               OpDecorate %loc5_1 Location 5
+        %int = OpTypeInt 32 1
+%_ptr_Input_int = OpTypePointer Input %int
+     %loc0_1 = OpVariable %_ptr_Input_int Input
+       %uint = OpTypeInt 32 0
+%_ptr_Input_uint = OpTypePointer Input %uint
+     %loc1_1 = OpVariable %_ptr_Input_uint Input
+      %float = OpTypeFloat 32
+%_ptr_Input_float = OpTypePointer Input %float
+     %loc2_1 = OpVariable %_ptr_Input_float Input
+    %v4float = OpTypeVector %float 4
+%_ptr_Input_v4float = OpTypePointer Input %v4float
+     %loc3_1 = OpVariable %_ptr_Input_v4float Input
+       %half = OpTypeFloat 16
+%_ptr_Input_half = OpTypePointer Input %half
+     %loc4_1 = OpVariable %_ptr_Input_half Input
+     %v3half = OpTypeVector %half 3
+%_ptr_Input_v3half = OpTypePointer Input %v3half
+     %loc5_1 = OpVariable %_ptr_Input_v3half Input
+       %void = OpTypeVoid
+         %19 = OpTypeFunction %void %int %uint %float %v4float %half %v3half
+         %29 = OpTypeFunction %void
+ %main_inner = OpFunction %void None %19
+       %loc0 = OpFunctionParameter %int
+       %loc1 = OpFunctionParameter %uint
+       %loc2 = OpFunctionParameter %float
+       %loc3 = OpFunctionParameter %v4float
+       %loc4 = OpFunctionParameter %half
+       %loc5 = OpFunctionParameter %v3half
+         %28 = OpLabel
+               OpReturn
+               OpFunctionEnd
+       %main = OpFunction %void None %29
+         %31 = OpLabel
+         %33 = OpLoad %int %loc0_1
+         %34 = OpLoad %uint %loc1_1
+         %35 = OpLoad %float %loc2_1
+         %36 = OpLoad %v4float %loc3_1
+         %37 = OpLoad %half %loc4_1
+         %38 = OpLoad %v3half %loc5_1
+         %32 = OpFunctionCall %void %main_inner %33 %34 %35 %36 %37 %38
+               OpReturn
+               OpFunctionEnd
diff --git a/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.wgsl b/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.wgsl
new file mode 100644
index 0000000..9be6ff7
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_locations_f16.wgsl.expected.wgsl
@@ -0,0 +1,11 @@
+enable f16;
+
+@fragment
+fn main(@location(0) @interpolate(flat) loc0 : i32, @location(1) @interpolate(flat) loc1 : u32, @location(2) loc2 : f32, @location(3) loc3 : vec4<f32>, @location(4) loc4 : f16, @location(5) loc5 : vec3<f16>) {
+  let i : i32 = loc0;
+  let u : u32 = loc1;
+  let f : f32 = loc2;
+  let v : vec4<f32> = loc3;
+  let x : f16 = loc4;
+  let y : vec3<f16> = loc5;
+}
diff --git a/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl b/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl
new file mode 100644
index 0000000..e89a938
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl
@@ -0,0 +1,20 @@
+enable f16;
+
+struct FragmentInputs {
+  @location(0) @interpolate(flat) loc0 : i32,
+  @location(1) @interpolate(flat) loc1 : u32,
+  @location(2) loc2 : f32,
+  @location(3) loc3 : vec4<f32>,
+  @location(4) loc4 : f16,
+  @location(5) loc5 : vec3<f16>,
+};
+
+@fragment
+fn main(inputs : FragmentInputs) {
+  let i : i32 = inputs.loc0;
+  let u : u32 = inputs.loc1;
+  let f : f32 = inputs.loc2;
+  let v : vec4<f32> = inputs.loc3;
+  let x : f16 = inputs.loc4;
+  let y : vec3<f16> = inputs.loc5;
+}
diff --git a/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.dxc.hlsl b/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.dxc.hlsl
new file mode 100644
index 0000000..15a56ef
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.dxc.hlsl
@@ -0,0 +1,31 @@
+struct FragmentInputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  float4 loc3;
+  float16_t loc4;
+  vector<float16_t, 3> loc5;
+};
+struct tint_symbol_1 {
+  nointerpolation int loc0 : TEXCOORD0;
+  nointerpolation uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+  float16_t loc4 : TEXCOORD4;
+  vector<float16_t, 3> loc5 : TEXCOORD5;
+};
+
+void main_inner(FragmentInputs inputs) {
+  const int i = inputs.loc0;
+  const uint u = inputs.loc1;
+  const float f = inputs.loc2;
+  const float4 v = inputs.loc3;
+  const float16_t x = inputs.loc4;
+  const vector<float16_t, 3> y = inputs.loc5;
+}
+
+void main(tint_symbol_1 tint_symbol) {
+  const FragmentInputs tint_symbol_2 = {tint_symbol.loc0, tint_symbol.loc1, tint_symbol.loc2, tint_symbol.loc3, tint_symbol.loc4, tint_symbol.loc5};
+  main_inner(tint_symbol_2);
+  return;
+}
diff --git a/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.fxc.hlsl b/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.fxc.hlsl
new file mode 100644
index 0000000..d3aa003
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.fxc.hlsl
@@ -0,0 +1,36 @@
+SKIP: FAILED
+
+struct FragmentInputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  float4 loc3;
+  float16_t loc4;
+  vector<float16_t, 3> loc5;
+};
+struct tint_symbol_1 {
+  nointerpolation int loc0 : TEXCOORD0;
+  nointerpolation uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+  float16_t loc4 : TEXCOORD4;
+  vector<float16_t, 3> loc5 : TEXCOORD5;
+};
+
+void main_inner(FragmentInputs inputs) {
+  const int i = inputs.loc0;
+  const uint u = inputs.loc1;
+  const float f = inputs.loc2;
+  const float4 v = inputs.loc3;
+  const float16_t x = inputs.loc4;
+  const vector<float16_t, 3> y = inputs.loc5;
+}
+
+void main(tint_symbol_1 tint_symbol) {
+  const FragmentInputs tint_symbol_2 = {tint_symbol.loc0, tint_symbol.loc1, tint_symbol.loc2, tint_symbol.loc3, tint_symbol.loc4, tint_symbol.loc5};
+  main_inner(tint_symbol_2);
+  return;
+}
+FXC validation failure:
+D:\Projects\RampUp\dawn\test\tint\shader_io\Shader@0x000001A7231510D0(6,3-11): error X3000: unrecognized identifier 'float16_t'
+
diff --git a/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.glsl b/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.glsl
new file mode 100644
index 0000000..30e9734
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.glsl
@@ -0,0 +1,33 @@
+#version 310 es
+#extension GL_AMD_gpu_shader_half_float : require
+precision mediump float;
+
+layout(location = 0) flat in int loc0_1;
+layout(location = 1) flat in uint loc1_1;
+layout(location = 2) in float loc2_1;
+layout(location = 3) in vec4 loc3_1;
+layout(location = 4) in float16_t loc4_1;
+layout(location = 5) in f16vec3 loc5_1;
+struct FragmentInputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  vec4 loc3;
+  float16_t loc4;
+  f16vec3 loc5;
+};
+
+void tint_symbol(FragmentInputs inputs) {
+  int i = inputs.loc0;
+  uint u = inputs.loc1;
+  float f = inputs.loc2;
+  vec4 v = inputs.loc3;
+  float16_t x = inputs.loc4;
+  f16vec3 y = inputs.loc5;
+}
+
+void main() {
+  FragmentInputs tint_symbol_1 = FragmentInputs(loc0_1, loc1_1, loc2_1, loc3_1, loc4_1, loc5_1);
+  tint_symbol(tint_symbol_1);
+  return;
+}
diff --git a/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.msl b/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.msl
new file mode 100644
index 0000000..0e8299d
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.msl
@@ -0,0 +1,36 @@
+#include <metal_stdlib>
+
+using namespace metal;
+struct FragmentInputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  float4 loc3;
+  half loc4;
+  half3 loc5;
+};
+
+struct tint_symbol_2 {
+  int loc0 [[user(locn0)]] [[flat]];
+  uint loc1 [[user(locn1)]] [[flat]];
+  float loc2 [[user(locn2)]];
+  float4 loc3 [[user(locn3)]];
+  half loc4 [[user(locn4)]];
+  half3 loc5 [[user(locn5)]];
+};
+
+void tint_symbol_inner(FragmentInputs inputs) {
+  int const i = inputs.loc0;
+  uint const u = inputs.loc1;
+  float const f = inputs.loc2;
+  float4 const v = inputs.loc3;
+  half const x = inputs.loc4;
+  half3 const y = inputs.loc5;
+}
+
+fragment void tint_symbol(tint_symbol_2 tint_symbol_1 [[stage_in]]) {
+  FragmentInputs const tint_symbol_3 = {.loc0=tint_symbol_1.loc0, .loc1=tint_symbol_1.loc1, .loc2=tint_symbol_1.loc2, .loc3=tint_symbol_1.loc3, .loc4=tint_symbol_1.loc4, .loc5=tint_symbol_1.loc5};
+  tint_symbol_inner(tint_symbol_3);
+  return;
+}
+
diff --git a/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.spvasm b/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.spvasm
new file mode 100644
index 0000000..b7af99f
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.spvasm
@@ -0,0 +1,88 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 42
+; Schema: 0
+               OpCapability Shader
+               OpCapability Float16
+               OpCapability UniformAndStorageBuffer16BitAccess
+               OpCapability StorageBuffer16BitAccess
+               OpCapability StorageInputOutput16
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %main "main" %loc0_1 %loc1_1 %loc2_1 %loc3_1 %loc4_1 %loc5_1
+               OpExecutionMode %main OriginUpperLeft
+               OpName %loc0_1 "loc0_1"
+               OpName %loc1_1 "loc1_1"
+               OpName %loc2_1 "loc2_1"
+               OpName %loc3_1 "loc3_1"
+               OpName %loc4_1 "loc4_1"
+               OpName %loc5_1 "loc5_1"
+               OpName %FragmentInputs "FragmentInputs"
+               OpMemberName %FragmentInputs 0 "loc0"
+               OpMemberName %FragmentInputs 1 "loc1"
+               OpMemberName %FragmentInputs 2 "loc2"
+               OpMemberName %FragmentInputs 3 "loc3"
+               OpMemberName %FragmentInputs 4 "loc4"
+               OpMemberName %FragmentInputs 5 "loc5"
+               OpName %main_inner "main_inner"
+               OpName %inputs "inputs"
+               OpName %main "main"
+               OpDecorate %loc0_1 Location 0
+               OpDecorate %loc0_1 Flat
+               OpDecorate %loc1_1 Location 1
+               OpDecorate %loc1_1 Flat
+               OpDecorate %loc2_1 Location 2
+               OpDecorate %loc3_1 Location 3
+               OpDecorate %loc4_1 Location 4
+               OpDecorate %loc5_1 Location 5
+               OpMemberDecorate %FragmentInputs 0 Offset 0
+               OpMemberDecorate %FragmentInputs 1 Offset 4
+               OpMemberDecorate %FragmentInputs 2 Offset 8
+               OpMemberDecorate %FragmentInputs 3 Offset 16
+               OpMemberDecorate %FragmentInputs 4 Offset 32
+               OpMemberDecorate %FragmentInputs 5 Offset 40
+        %int = OpTypeInt 32 1
+%_ptr_Input_int = OpTypePointer Input %int
+     %loc0_1 = OpVariable %_ptr_Input_int Input
+       %uint = OpTypeInt 32 0
+%_ptr_Input_uint = OpTypePointer Input %uint
+     %loc1_1 = OpVariable %_ptr_Input_uint Input
+      %float = OpTypeFloat 32
+%_ptr_Input_float = OpTypePointer Input %float
+     %loc2_1 = OpVariable %_ptr_Input_float Input
+    %v4float = OpTypeVector %float 4
+%_ptr_Input_v4float = OpTypePointer Input %v4float
+     %loc3_1 = OpVariable %_ptr_Input_v4float Input
+       %half = OpTypeFloat 16
+%_ptr_Input_half = OpTypePointer Input %half
+     %loc4_1 = OpVariable %_ptr_Input_half Input
+     %v3half = OpTypeVector %half 3
+%_ptr_Input_v3half = OpTypePointer Input %v3half
+     %loc5_1 = OpVariable %_ptr_Input_v3half Input
+       %void = OpTypeVoid
+%FragmentInputs = OpTypeStruct %int %uint %float %v4float %half %v3half
+         %19 = OpTypeFunction %void %FragmentInputs
+         %31 = OpTypeFunction %void
+ %main_inner = OpFunction %void None %19
+     %inputs = OpFunctionParameter %FragmentInputs
+         %24 = OpLabel
+         %25 = OpCompositeExtract %int %inputs 0
+         %26 = OpCompositeExtract %uint %inputs 1
+         %27 = OpCompositeExtract %float %inputs 2
+         %28 = OpCompositeExtract %v4float %inputs 3
+         %29 = OpCompositeExtract %half %inputs 4
+         %30 = OpCompositeExtract %v3half %inputs 5
+               OpReturn
+               OpFunctionEnd
+       %main = OpFunction %void None %31
+         %33 = OpLabel
+         %35 = OpLoad %int %loc0_1
+         %36 = OpLoad %uint %loc1_1
+         %37 = OpLoad %float %loc2_1
+         %38 = OpLoad %v4float %loc3_1
+         %39 = OpLoad %half %loc4_1
+         %40 = OpLoad %v3half %loc5_1
+         %41 = OpCompositeConstruct %FragmentInputs %35 %36 %37 %38 %39 %40
+         %34 = OpFunctionCall %void %main_inner %41
+               OpReturn
+               OpFunctionEnd
diff --git a/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.wgsl b/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.wgsl
new file mode 100644
index 0000000..1f267cf
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_locations_struct_f16.wgsl.expected.wgsl
@@ -0,0 +1,26 @@
+enable f16;
+
+struct FragmentInputs {
+  @location(0) @interpolate(flat)
+  loc0 : i32,
+  @location(1) @interpolate(flat)
+  loc1 : u32,
+  @location(2)
+  loc2 : f32,
+  @location(3)
+  loc3 : vec4<f32>,
+  @location(4)
+  loc4 : f16,
+  @location(5)
+  loc5 : vec3<f16>,
+}
+
+@fragment
+fn main(inputs : FragmentInputs) {
+  let i : i32 = inputs.loc0;
+  let u : u32 = inputs.loc1;
+  let f : f32 = inputs.loc2;
+  let v : vec4<f32> = inputs.loc3;
+  let x : f16 = inputs.loc4;
+  let y : vec3<f16> = inputs.loc5;
+}
diff --git a/test/tint/shader_io/fragment_input_mixed_f16.wgsl b/test/tint/shader_io/fragment_input_mixed_f16.wgsl
new file mode 100644
index 0000000..3eb88b1
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_mixed_f16.wgsl
@@ -0,0 +1,33 @@
+enable f16;
+
+struct FragmentInputs0 {
+  @builtin(position) position : vec4<f32>,
+  @location(0) @interpolate(flat) loc0 : i32,
+};
+struct FragmentInputs1 {
+  @location(3) loc3 : vec4<f32>,
+  @location(5) loc5 : vec3<f16>,
+  @builtin(sample_mask) sample_mask : u32,
+};
+
+@fragment
+fn main(
+  inputs0 : FragmentInputs0,
+  @builtin(front_facing) front_facing : bool,
+  @location(1) @interpolate(flat) loc1 : u32,
+  @builtin(sample_index) sample_index : u32,
+  inputs1 : FragmentInputs1,
+  @location(2) loc2 : f32,
+  @location(4) loc4 : f16,
+) {
+  if (front_facing) {
+    let foo : vec4<f32> = inputs0.position;
+    let bar : u32 = sample_index + inputs1.sample_mask;
+    let i : i32 = inputs0.loc0;
+    let u : u32 = loc1;
+    let f : f32 = loc2;
+    let v : vec4<f32> = inputs1.loc3;
+    let x : f16 = loc4;
+    let y : vec3<f16> = inputs1.loc5;
+  }
+}
diff --git a/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.dxc.hlsl b/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.dxc.hlsl
new file mode 100644
index 0000000..f8de307
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.dxc.hlsl
@@ -0,0 +1,41 @@
+struct FragmentInputs0 {
+  float4 position;
+  int loc0;
+};
+struct FragmentInputs1 {
+  float4 loc3;
+  vector<float16_t, 3> loc5;
+  uint sample_mask;
+};
+struct tint_symbol_1 {
+  nointerpolation int loc0 : TEXCOORD0;
+  nointerpolation uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+  float16_t loc4 : TEXCOORD4;
+  vector<float16_t, 3> loc5 : TEXCOORD5;
+  float4 position : SV_Position;
+  bool front_facing : SV_IsFrontFace;
+  uint sample_index : SV_SampleIndex;
+  uint sample_mask : SV_Coverage;
+};
+
+void main_inner(FragmentInputs0 inputs0, bool front_facing, uint loc1, uint sample_index, FragmentInputs1 inputs1, float loc2, float16_t loc4) {
+  if (front_facing) {
+    const float4 foo = inputs0.position;
+    const uint bar = (sample_index + inputs1.sample_mask);
+    const int i = inputs0.loc0;
+    const uint u = loc1;
+    const float f = loc2;
+    const float4 v = inputs1.loc3;
+    const float16_t x = loc4;
+    const vector<float16_t, 3> y = inputs1.loc5;
+  }
+}
+
+void main(tint_symbol_1 tint_symbol) {
+  const FragmentInputs0 tint_symbol_2 = {tint_symbol.position, tint_symbol.loc0};
+  const FragmentInputs1 tint_symbol_3 = {tint_symbol.loc3, tint_symbol.loc5, tint_symbol.sample_mask};
+  main_inner(tint_symbol_2, tint_symbol.front_facing, tint_symbol.loc1, tint_symbol.sample_index, tint_symbol_3, tint_symbol.loc2, tint_symbol.loc4);
+  return;
+}
diff --git a/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.fxc.hlsl b/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.fxc.hlsl
new file mode 100644
index 0000000..e1f2d63
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.fxc.hlsl
@@ -0,0 +1,46 @@
+SKIP: FAILED
+
+struct FragmentInputs0 {
+  float4 position;
+  int loc0;
+};
+struct FragmentInputs1 {
+  float4 loc3;
+  vector<float16_t, 3> loc5;
+  uint sample_mask;
+};
+struct tint_symbol_1 {
+  nointerpolation int loc0 : TEXCOORD0;
+  nointerpolation uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+  float16_t loc4 : TEXCOORD4;
+  vector<float16_t, 3> loc5 : TEXCOORD5;
+  float4 position : SV_Position;
+  bool front_facing : SV_IsFrontFace;
+  uint sample_index : SV_SampleIndex;
+  uint sample_mask : SV_Coverage;
+};
+
+void main_inner(FragmentInputs0 inputs0, bool front_facing, uint loc1, uint sample_index, FragmentInputs1 inputs1, float loc2, float16_t loc4) {
+  if (front_facing) {
+    const float4 foo = inputs0.position;
+    const uint bar = (sample_index + inputs1.sample_mask);
+    const int i = inputs0.loc0;
+    const uint u = loc1;
+    const float f = loc2;
+    const float4 v = inputs1.loc3;
+    const float16_t x = loc4;
+    const vector<float16_t, 3> y = inputs1.loc5;
+  }
+}
+
+void main(tint_symbol_1 tint_symbol) {
+  const FragmentInputs0 tint_symbol_2 = {tint_symbol.position, tint_symbol.loc0};
+  const FragmentInputs1 tint_symbol_3 = {tint_symbol.loc3, tint_symbol.loc5, tint_symbol.sample_mask};
+  main_inner(tint_symbol_2, tint_symbol.front_facing, tint_symbol.loc1, tint_symbol.sample_index, tint_symbol_3, tint_symbol.loc2, tint_symbol.loc4);
+  return;
+}
+FXC validation failure:
+D:\Projects\RampUp\dawn\test\tint\shader_io\Shader@0x000001E6355E01A0(7,10-18): error X3000: syntax error: unexpected token 'float16_t'
+
diff --git a/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.glsl b/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.glsl
new file mode 100644
index 0000000..2226a6a
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.glsl
@@ -0,0 +1,41 @@
+#version 310 es
+#extension GL_OES_sample_variables : require
+#extension GL_AMD_gpu_shader_half_float : require
+precision mediump float;
+
+layout(location = 0) flat in int loc0_1;
+layout(location = 1) flat in uint loc1_1;
+layout(location = 3) in vec4 loc3_1;
+layout(location = 5) in f16vec3 loc5_1;
+layout(location = 2) in float loc2_1;
+layout(location = 4) in float16_t loc4_1;
+struct FragmentInputs0 {
+  vec4 position;
+  int loc0;
+};
+
+struct FragmentInputs1 {
+  vec4 loc3;
+  f16vec3 loc5;
+  uint sample_mask;
+};
+
+void tint_symbol(FragmentInputs0 inputs0, bool front_facing, uint loc1, uint sample_index, FragmentInputs1 inputs1, float loc2, float16_t loc4) {
+  if (front_facing) {
+    vec4 foo = inputs0.position;
+    uint bar = (sample_index + inputs1.sample_mask);
+    int i = inputs0.loc0;
+    uint u = loc1;
+    float f = loc2;
+    vec4 v = inputs1.loc3;
+    float16_t x = loc4;
+    f16vec3 y = inputs1.loc5;
+  }
+}
+
+void main() {
+  FragmentInputs0 tint_symbol_1 = FragmentInputs0(gl_FragCoord, loc0_1);
+  FragmentInputs1 tint_symbol_2 = FragmentInputs1(loc3_1, loc5_1, uint(gl_SampleMaskIn[0]));
+  tint_symbol(tint_symbol_1, gl_FrontFacing, loc1_1, uint(gl_SampleID), tint_symbol_2, loc2_1, loc4_1);
+  return;
+}
diff --git a/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.msl b/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.msl
new file mode 100644
index 0000000..fc4df0d
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.msl
@@ -0,0 +1,43 @@
+#include <metal_stdlib>
+
+using namespace metal;
+struct FragmentInputs0 {
+  float4 position;
+  int loc0;
+};
+
+struct FragmentInputs1 {
+  float4 loc3;
+  half3 loc5;
+  uint sample_mask;
+};
+
+struct tint_symbol_2 {
+  int loc0 [[user(locn0)]] [[flat]];
+  uint loc1 [[user(locn1)]] [[flat]];
+  float loc2 [[user(locn2)]];
+  float4 loc3 [[user(locn3)]];
+  half loc4 [[user(locn4)]];
+  half3 loc5 [[user(locn5)]];
+};
+
+void tint_symbol_inner(FragmentInputs0 inputs0, bool front_facing, uint loc1, uint sample_index, FragmentInputs1 inputs1, float loc2, half loc4) {
+  if (front_facing) {
+    float4 const foo = inputs0.position;
+    uint const bar = (sample_index + inputs1.sample_mask);
+    int const i = inputs0.loc0;
+    uint const u = loc1;
+    float const f = loc2;
+    float4 const v = inputs1.loc3;
+    half const x = loc4;
+    half3 const y = inputs1.loc5;
+  }
+}
+
+fragment void tint_symbol(float4 position [[position]], bool front_facing [[front_facing]], uint sample_index [[sample_id]], uint sample_mask [[sample_mask]], tint_symbol_2 tint_symbol_1 [[stage_in]]) {
+  FragmentInputs0 const tint_symbol_3 = {.position=position, .loc0=tint_symbol_1.loc0};
+  FragmentInputs1 const tint_symbol_4 = {.loc3=tint_symbol_1.loc3, .loc5=tint_symbol_1.loc5, .sample_mask=sample_mask};
+  tint_symbol_inner(tint_symbol_3, front_facing, tint_symbol_1.loc1, sample_index, tint_symbol_4, tint_symbol_1.loc2, tint_symbol_1.loc4);
+  return;
+}
+
diff --git a/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.spvasm b/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.spvasm
new file mode 100644
index 0000000..b565b14
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.spvasm
@@ -0,0 +1,133 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 67
+; Schema: 0
+               OpCapability Shader
+               OpCapability Float16
+               OpCapability UniformAndStorageBuffer16BitAccess
+               OpCapability StorageBuffer16BitAccess
+               OpCapability StorageInputOutput16
+               OpCapability SampleRateShading
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %main "main" %position_1 %loc0_1 %front_facing_1 %loc1_1 %sample_index_1 %loc3_1 %loc5_1 %sample_mask_1 %loc2_1 %loc4_1
+               OpExecutionMode %main OriginUpperLeft
+               OpName %position_1 "position_1"
+               OpName %loc0_1 "loc0_1"
+               OpName %front_facing_1 "front_facing_1"
+               OpName %loc1_1 "loc1_1"
+               OpName %sample_index_1 "sample_index_1"
+               OpName %loc3_1 "loc3_1"
+               OpName %loc5_1 "loc5_1"
+               OpName %sample_mask_1 "sample_mask_1"
+               OpName %loc2_1 "loc2_1"
+               OpName %loc4_1 "loc4_1"
+               OpName %FragmentInputs0 "FragmentInputs0"
+               OpMemberName %FragmentInputs0 0 "position"
+               OpMemberName %FragmentInputs0 1 "loc0"
+               OpName %FragmentInputs1 "FragmentInputs1"
+               OpMemberName %FragmentInputs1 0 "loc3"
+               OpMemberName %FragmentInputs1 1 "loc5"
+               OpMemberName %FragmentInputs1 2 "sample_mask"
+               OpName %main_inner "main_inner"
+               OpName %inputs0 "inputs0"
+               OpName %front_facing "front_facing"
+               OpName %loc1 "loc1"
+               OpName %sample_index "sample_index"
+               OpName %inputs1 "inputs1"
+               OpName %loc2 "loc2"
+               OpName %loc4 "loc4"
+               OpName %main "main"
+               OpDecorate %position_1 BuiltIn FragCoord
+               OpDecorate %loc0_1 Location 0
+               OpDecorate %loc0_1 Flat
+               OpDecorate %front_facing_1 BuiltIn FrontFacing
+               OpDecorate %loc1_1 Location 1
+               OpDecorate %loc1_1 Flat
+               OpDecorate %sample_index_1 BuiltIn SampleId
+               OpDecorate %sample_index_1 Flat
+               OpDecorate %loc3_1 Location 3
+               OpDecorate %loc5_1 Location 5
+               OpDecorate %_arr_uint_uint_1 ArrayStride 4
+               OpDecorate %sample_mask_1 BuiltIn SampleMask
+               OpDecorate %sample_mask_1 Flat
+               OpDecorate %loc2_1 Location 2
+               OpDecorate %loc4_1 Location 4
+               OpMemberDecorate %FragmentInputs0 0 Offset 0
+               OpMemberDecorate %FragmentInputs0 1 Offset 16
+               OpMemberDecorate %FragmentInputs1 0 Offset 0
+               OpMemberDecorate %FragmentInputs1 1 Offset 16
+               OpMemberDecorate %FragmentInputs1 2 Offset 24
+      %float = OpTypeFloat 32
+    %v4float = OpTypeVector %float 4
+%_ptr_Input_v4float = OpTypePointer Input %v4float
+ %position_1 = OpVariable %_ptr_Input_v4float Input
+        %int = OpTypeInt 32 1
+%_ptr_Input_int = OpTypePointer Input %int
+     %loc0_1 = OpVariable %_ptr_Input_int Input
+       %bool = OpTypeBool
+%_ptr_Input_bool = OpTypePointer Input %bool
+%front_facing_1 = OpVariable %_ptr_Input_bool Input
+       %uint = OpTypeInt 32 0
+%_ptr_Input_uint = OpTypePointer Input %uint
+     %loc1_1 = OpVariable %_ptr_Input_uint Input
+%sample_index_1 = OpVariable %_ptr_Input_uint Input
+     %loc3_1 = OpVariable %_ptr_Input_v4float Input
+       %half = OpTypeFloat 16
+     %v3half = OpTypeVector %half 3
+%_ptr_Input_v3half = OpTypePointer Input %v3half
+     %loc5_1 = OpVariable %_ptr_Input_v3half Input
+     %uint_1 = OpConstant %uint 1
+%_arr_uint_uint_1 = OpTypeArray %uint %uint_1
+%_ptr_Input__arr_uint_uint_1 = OpTypePointer Input %_arr_uint_uint_1
+%sample_mask_1 = OpVariable %_ptr_Input__arr_uint_uint_1 Input
+%_ptr_Input_float = OpTypePointer Input %float
+     %loc2_1 = OpVariable %_ptr_Input_float Input
+%_ptr_Input_half = OpTypePointer Input %half
+     %loc4_1 = OpVariable %_ptr_Input_half Input
+       %void = OpTypeVoid
+%FragmentInputs0 = OpTypeStruct %v4float %int
+%FragmentInputs1 = OpTypeStruct %v4float %v3half %uint
+         %28 = OpTypeFunction %void %FragmentInputs0 %bool %uint %uint %FragmentInputs1 %float %half
+         %49 = OpTypeFunction %void
+         %61 = OpConstantNull %int
+ %main_inner = OpFunction %void None %28
+    %inputs0 = OpFunctionParameter %FragmentInputs0
+%front_facing = OpFunctionParameter %bool
+       %loc1 = OpFunctionParameter %uint
+%sample_index = OpFunctionParameter %uint
+    %inputs1 = OpFunctionParameter %FragmentInputs1
+       %loc2 = OpFunctionParameter %float
+       %loc4 = OpFunctionParameter %half
+         %40 = OpLabel
+               OpSelectionMerge %41 None
+               OpBranchConditional %front_facing %42 %41
+         %42 = OpLabel
+         %43 = OpCompositeExtract %v4float %inputs0 0
+         %44 = OpCompositeExtract %uint %inputs1 2
+         %45 = OpIAdd %uint %sample_index %44
+         %46 = OpCompositeExtract %int %inputs0 1
+         %47 = OpCompositeExtract %v4float %inputs1 0
+         %48 = OpCompositeExtract %v3half %inputs1 1
+               OpBranch %41
+         %41 = OpLabel
+               OpReturn
+               OpFunctionEnd
+       %main = OpFunction %void None %49
+         %51 = OpLabel
+         %53 = OpLoad %v4float %position_1
+         %54 = OpLoad %int %loc0_1
+         %55 = OpCompositeConstruct %FragmentInputs0 %53 %54
+         %56 = OpLoad %bool %front_facing_1
+         %57 = OpLoad %uint %loc1_1
+         %58 = OpLoad %uint %sample_index_1
+         %59 = OpLoad %v4float %loc3_1
+         %60 = OpLoad %v3half %loc5_1
+         %62 = OpAccessChain %_ptr_Input_uint %sample_mask_1 %61
+         %63 = OpLoad %uint %62
+         %64 = OpCompositeConstruct %FragmentInputs1 %59 %60 %63
+         %65 = OpLoad %float %loc2_1
+         %66 = OpLoad %half %loc4_1
+         %52 = OpFunctionCall %void %main_inner %55 %56 %57 %58 %64 %65 %66
+               OpReturn
+               OpFunctionEnd
diff --git a/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.wgsl b/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.wgsl
new file mode 100644
index 0000000..c446f71
--- /dev/null
+++ b/test/tint/shader_io/fragment_input_mixed_f16.wgsl.expected.wgsl
@@ -0,0 +1,31 @@
+enable f16;
+
+struct FragmentInputs0 {
+  @builtin(position)
+  position : vec4<f32>,
+  @location(0) @interpolate(flat)
+  loc0 : i32,
+}
+
+struct FragmentInputs1 {
+  @location(3)
+  loc3 : vec4<f32>,
+  @location(5)
+  loc5 : vec3<f16>,
+  @builtin(sample_mask)
+  sample_mask : u32,
+}
+
+@fragment
+fn main(inputs0 : FragmentInputs0, @builtin(front_facing) front_facing : bool, @location(1) @interpolate(flat) loc1 : u32, @builtin(sample_index) sample_index : u32, inputs1 : FragmentInputs1, @location(2) loc2 : f32, @location(4) loc4 : f16) {
+  if (front_facing) {
+    let foo : vec4<f32> = inputs0.position;
+    let bar : u32 = (sample_index + inputs1.sample_mask);
+    let i : i32 = inputs0.loc0;
+    let u : u32 = loc1;
+    let f : f32 = loc2;
+    let v : vec4<f32> = inputs1.loc3;
+    let x : f16 = loc4;
+    let y : vec3<f16> = inputs1.loc5;
+  }
+}
diff --git a/test/tint/shader_io/fragment_output_locations_f16.wgsl b/test/tint/shader_io/fragment_output_locations_f16.wgsl
new file mode 100644
index 0000000..62f7392
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_locations_f16.wgsl
@@ -0,0 +1,31 @@
+enable f16;
+
+@fragment
+fn main0() -> @location(0) i32 {
+  return 1;
+}
+
+@fragment
+fn main1() -> @location(1) u32 {
+  return 1u;
+}
+
+@fragment
+fn main2() -> @location(2) f32 {
+  return 1.0;
+}
+
+@fragment
+fn main3() -> @location(3) vec4<f32> {
+  return vec4<f32>(1.0, 2.0, 3.0, 4.0);
+}
+
+@fragment
+fn main4() -> @location(4) f16 {
+  return 2.25h;
+}
+
+@fragment
+fn main5() -> @location(5) vec3<f16> {
+  return vec3<f16>(3.0h, 5.0h, 8.0h);
+}
diff --git a/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.dxc.hlsl b/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.dxc.hlsl
new file mode 100644
index 0000000..d8826de
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.dxc.hlsl
@@ -0,0 +1,89 @@
+struct tint_symbol {
+  int value : SV_Target0;
+};
+
+int main0_inner() {
+  return 1;
+}
+
+tint_symbol main0() {
+  const int inner_result = main0_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
+
+struct tint_symbol_1 {
+  uint value : SV_Target1;
+};
+
+uint main1_inner() {
+  return 1u;
+}
+
+tint_symbol_1 main1() {
+  const uint inner_result_1 = main1_inner();
+  tint_symbol_1 wrapper_result_1 = (tint_symbol_1)0;
+  wrapper_result_1.value = inner_result_1;
+  return wrapper_result_1;
+}
+
+struct tint_symbol_2 {
+  float value : SV_Target2;
+};
+
+float main2_inner() {
+  return 1.0f;
+}
+
+tint_symbol_2 main2() {
+  const float inner_result_2 = main2_inner();
+  tint_symbol_2 wrapper_result_2 = (tint_symbol_2)0;
+  wrapper_result_2.value = inner_result_2;
+  return wrapper_result_2;
+}
+
+struct tint_symbol_3 {
+  float4 value : SV_Target3;
+};
+
+float4 main3_inner() {
+  return float4(1.0f, 2.0f, 3.0f, 4.0f);
+}
+
+tint_symbol_3 main3() {
+  const float4 inner_result_3 = main3_inner();
+  tint_symbol_3 wrapper_result_3 = (tint_symbol_3)0;
+  wrapper_result_3.value = inner_result_3;
+  return wrapper_result_3;
+}
+
+struct tint_symbol_4 {
+  float16_t value : SV_Target4;
+};
+
+float16_t main4_inner() {
+  return float16_t(2.25h);
+}
+
+tint_symbol_4 main4() {
+  const float16_t inner_result_4 = main4_inner();
+  tint_symbol_4 wrapper_result_4 = (tint_symbol_4)0;
+  wrapper_result_4.value = inner_result_4;
+  return wrapper_result_4;
+}
+
+struct tint_symbol_5 {
+  vector<float16_t, 3> value : SV_Target5;
+};
+
+vector<float16_t, 3> main5_inner() {
+  return vector<float16_t, 3>(float16_t(3.0h), float16_t(5.0h), float16_t(8.0h));
+}
+
+tint_symbol_5 main5() {
+  const vector<float16_t, 3> inner_result_5 = main5_inner();
+  tint_symbol_5 wrapper_result_5 = (tint_symbol_5)0;
+  wrapper_result_5.value = inner_result_5;
+  return wrapper_result_5;
+}
diff --git a/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.fxc.hlsl b/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.fxc.hlsl
new file mode 100644
index 0000000..6172c1c
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.fxc.hlsl
@@ -0,0 +1,94 @@
+SKIP: FAILED
+
+struct tint_symbol {
+  int value : SV_Target0;
+};
+
+int main0_inner() {
+  return 1;
+}
+
+tint_symbol main0() {
+  const int inner_result = main0_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
+
+struct tint_symbol_1 {
+  uint value : SV_Target1;
+};
+
+uint main1_inner() {
+  return 1u;
+}
+
+tint_symbol_1 main1() {
+  const uint inner_result_1 = main1_inner();
+  tint_symbol_1 wrapper_result_1 = (tint_symbol_1)0;
+  wrapper_result_1.value = inner_result_1;
+  return wrapper_result_1;
+}
+
+struct tint_symbol_2 {
+  float value : SV_Target2;
+};
+
+float main2_inner() {
+  return 1.0f;
+}
+
+tint_symbol_2 main2() {
+  const float inner_result_2 = main2_inner();
+  tint_symbol_2 wrapper_result_2 = (tint_symbol_2)0;
+  wrapper_result_2.value = inner_result_2;
+  return wrapper_result_2;
+}
+
+struct tint_symbol_3 {
+  float4 value : SV_Target3;
+};
+
+float4 main3_inner() {
+  return float4(1.0f, 2.0f, 3.0f, 4.0f);
+}
+
+tint_symbol_3 main3() {
+  const float4 inner_result_3 = main3_inner();
+  tint_symbol_3 wrapper_result_3 = (tint_symbol_3)0;
+  wrapper_result_3.value = inner_result_3;
+  return wrapper_result_3;
+}
+
+struct tint_symbol_4 {
+  float16_t value : SV_Target4;
+};
+
+float16_t main4_inner() {
+  return float16_t(2.25h);
+}
+
+tint_symbol_4 main4() {
+  const float16_t inner_result_4 = main4_inner();
+  tint_symbol_4 wrapper_result_4 = (tint_symbol_4)0;
+  wrapper_result_4.value = inner_result_4;
+  return wrapper_result_4;
+}
+
+struct tint_symbol_5 {
+  vector<float16_t, 3> value : SV_Target5;
+};
+
+vector<float16_t, 3> main5_inner() {
+  return vector<float16_t, 3>(float16_t(3.0h), float16_t(5.0h), float16_t(8.0h));
+}
+
+tint_symbol_5 main5() {
+  const vector<float16_t, 3> inner_result_5 = main5_inner();
+  tint_symbol_5 wrapper_result_5 = (tint_symbol_5)0;
+  wrapper_result_5.value = inner_result_5;
+  return wrapper_result_5;
+}
+FXC validation failure:
+D:\Projects\RampUp\dawn\test\tint\shader_io\Shader@0x0000023E506E30B0(62,3-11): error X3000: unrecognized identifier 'float16_t'
+
diff --git a/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.glsl b/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.glsl
new file mode 100644
index 0000000..1ecbe7d
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.glsl
@@ -0,0 +1,84 @@
+#version 310 es
+#extension GL_AMD_gpu_shader_half_float : require
+precision mediump float;
+
+layout(location = 0) out int value;
+int main0() {
+  return 1;
+}
+
+void main() {
+  int inner_result = main0();
+  value = inner_result;
+  return;
+}
+#version 310 es
+#extension GL_AMD_gpu_shader_half_float : require
+precision mediump float;
+
+layout(location = 1) out uint value;
+uint main1() {
+  return 1u;
+}
+
+void main() {
+  uint inner_result = main1();
+  value = inner_result;
+  return;
+}
+#version 310 es
+#extension GL_AMD_gpu_shader_half_float : require
+precision mediump float;
+
+layout(location = 2) out float value;
+float main2() {
+  return 1.0f;
+}
+
+void main() {
+  float inner_result = main2();
+  value = inner_result;
+  return;
+}
+#version 310 es
+#extension GL_AMD_gpu_shader_half_float : require
+precision mediump float;
+
+layout(location = 3) out vec4 value;
+vec4 main3() {
+  return vec4(1.0f, 2.0f, 3.0f, 4.0f);
+}
+
+void main() {
+  vec4 inner_result = main3();
+  value = inner_result;
+  return;
+}
+#version 310 es
+#extension GL_AMD_gpu_shader_half_float : require
+precision mediump float;
+
+layout(location = 4) out float16_t value;
+float16_t main4() {
+  return 2.25hf;
+}
+
+void main() {
+  float16_t inner_result = main4();
+  value = inner_result;
+  return;
+}
+#version 310 es
+#extension GL_AMD_gpu_shader_half_float : require
+precision mediump float;
+
+layout(location = 5) out f16vec3 value;
+f16vec3 main5() {
+  return f16vec3(3.0hf, 5.0hf, 8.0hf);
+}
+
+void main() {
+  f16vec3 inner_result = main5();
+  value = inner_result;
+  return;
+}
diff --git a/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.msl b/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.msl
new file mode 100644
index 0000000..803717b
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.msl
@@ -0,0 +1,93 @@
+#include <metal_stdlib>
+
+using namespace metal;
+struct tint_symbol {
+  int value [[color(0)]];
+};
+
+int main0_inner() {
+  return 1;
+}
+
+fragment tint_symbol main0() {
+  int const inner_result = main0_inner();
+  tint_symbol wrapper_result = {};
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
+
+struct tint_symbol_1 {
+  uint value [[color(1)]];
+};
+
+uint main1_inner() {
+  return 1u;
+}
+
+fragment tint_symbol_1 main1() {
+  uint const inner_result_1 = main1_inner();
+  tint_symbol_1 wrapper_result_1 = {};
+  wrapper_result_1.value = inner_result_1;
+  return wrapper_result_1;
+}
+
+struct tint_symbol_2 {
+  float value [[color(2)]];
+};
+
+float main2_inner() {
+  return 1.0f;
+}
+
+fragment tint_symbol_2 main2() {
+  float const inner_result_2 = main2_inner();
+  tint_symbol_2 wrapper_result_2 = {};
+  wrapper_result_2.value = inner_result_2;
+  return wrapper_result_2;
+}
+
+struct tint_symbol_3 {
+  float4 value [[color(3)]];
+};
+
+float4 main3_inner() {
+  return float4(1.0f, 2.0f, 3.0f, 4.0f);
+}
+
+fragment tint_symbol_3 main3() {
+  float4 const inner_result_3 = main3_inner();
+  tint_symbol_3 wrapper_result_3 = {};
+  wrapper_result_3.value = inner_result_3;
+  return wrapper_result_3;
+}
+
+struct tint_symbol_4 {
+  half value [[color(4)]];
+};
+
+half main4_inner() {
+  return 2.25h;
+}
+
+fragment tint_symbol_4 main4() {
+  half const inner_result_4 = main4_inner();
+  tint_symbol_4 wrapper_result_4 = {};
+  wrapper_result_4.value = inner_result_4;
+  return wrapper_result_4;
+}
+
+struct tint_symbol_5 {
+  half3 value [[color(5)]];
+};
+
+half3 main5_inner() {
+  return half3(3.0h, 5.0h, 8.0h);
+}
+
+fragment tint_symbol_5 main5() {
+  half3 const inner_result_5 = main5_inner();
+  tint_symbol_5 wrapper_result_5 = {};
+  wrapper_result_5.value = inner_result_5;
+  return wrapper_result_5;
+}
+
diff --git a/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.spvasm b/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.spvasm
new file mode 100644
index 0000000..b6e3d74
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.spvasm
@@ -0,0 +1,151 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 75
+; Schema: 0
+               OpCapability Shader
+               OpCapability Float16
+               OpCapability UniformAndStorageBuffer16BitAccess
+               OpCapability StorageBuffer16BitAccess
+               OpCapability StorageInputOutput16
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %main0 "main0" %value
+               OpEntryPoint Fragment %main1 "main1" %value_1
+               OpEntryPoint Fragment %main2 "main2" %value_2
+               OpEntryPoint Fragment %main3 "main3" %value_3
+               OpEntryPoint Fragment %main4 "main4" %value_4
+               OpEntryPoint Fragment %main5 "main5" %value_5
+               OpExecutionMode %main0 OriginUpperLeft
+               OpExecutionMode %main1 OriginUpperLeft
+               OpExecutionMode %main2 OriginUpperLeft
+               OpExecutionMode %main3 OriginUpperLeft
+               OpExecutionMode %main4 OriginUpperLeft
+               OpExecutionMode %main5 OriginUpperLeft
+               OpName %value "value"
+               OpName %value_1 "value_1"
+               OpName %value_2 "value_2"
+               OpName %value_3 "value_3"
+               OpName %value_4 "value_4"
+               OpName %value_5 "value_5"
+               OpName %main0_inner "main0_inner"
+               OpName %main0 "main0"
+               OpName %main1_inner "main1_inner"
+               OpName %main1 "main1"
+               OpName %main2_inner "main2_inner"
+               OpName %main2 "main2"
+               OpName %main3_inner "main3_inner"
+               OpName %main3 "main3"
+               OpName %main4_inner "main4_inner"
+               OpName %main4 "main4"
+               OpName %main5_inner "main5_inner"
+               OpName %main5 "main5"
+               OpDecorate %value Location 0
+               OpDecorate %value_1 Location 1
+               OpDecorate %value_2 Location 2
+               OpDecorate %value_3 Location 3
+               OpDecorate %value_4 Location 4
+               OpDecorate %value_5 Location 5
+        %int = OpTypeInt 32 1
+%_ptr_Output_int = OpTypePointer Output %int
+          %4 = OpConstantNull %int
+      %value = OpVariable %_ptr_Output_int Output %4
+       %uint = OpTypeInt 32 0
+%_ptr_Output_uint = OpTypePointer Output %uint
+          %8 = OpConstantNull %uint
+    %value_1 = OpVariable %_ptr_Output_uint Output %8
+      %float = OpTypeFloat 32
+%_ptr_Output_float = OpTypePointer Output %float
+         %12 = OpConstantNull %float
+    %value_2 = OpVariable %_ptr_Output_float Output %12
+    %v4float = OpTypeVector %float 4
+%_ptr_Output_v4float = OpTypePointer Output %v4float
+         %16 = OpConstantNull %v4float
+    %value_3 = OpVariable %_ptr_Output_v4float Output %16
+       %half = OpTypeFloat 16
+%_ptr_Output_half = OpTypePointer Output %half
+         %20 = OpConstantNull %half
+    %value_4 = OpVariable %_ptr_Output_half Output %20
+     %v3half = OpTypeVector %half 3
+%_ptr_Output_v3half = OpTypePointer Output %v3half
+         %24 = OpConstantNull %v3half
+    %value_5 = OpVariable %_ptr_Output_v3half Output %24
+         %25 = OpTypeFunction %int
+      %int_1 = OpConstant %int 1
+       %void = OpTypeVoid
+         %29 = OpTypeFunction %void
+         %34 = OpTypeFunction %uint
+     %uint_1 = OpConstant %uint 1
+         %41 = OpTypeFunction %float
+    %float_1 = OpConstant %float 1
+         %48 = OpTypeFunction %v4float
+    %float_2 = OpConstant %float 2
+    %float_3 = OpConstant %float 3
+    %float_4 = OpConstant %float 4
+         %54 = OpConstantComposite %v4float %float_1 %float_2 %float_3 %float_4
+         %58 = OpTypeFunction %half
+%half_0x1_2p_1 = OpConstant %half 0x1.2p+1
+         %65 = OpTypeFunction %v3half
+%half_0x1_8p_1 = OpConstant %half 0x1.8p+1
+%half_0x1_4p_2 = OpConstant %half 0x1.4p+2
+%half_0x1p_3 = OpConstant %half 0x1p+3
+         %71 = OpConstantComposite %v3half %half_0x1_8p_1 %half_0x1_4p_2 %half_0x1p_3
+%main0_inner = OpFunction %int None %25
+         %27 = OpLabel
+               OpReturnValue %int_1
+               OpFunctionEnd
+      %main0 = OpFunction %void None %29
+         %32 = OpLabel
+         %33 = OpFunctionCall %int %main0_inner
+               OpStore %value %33
+               OpReturn
+               OpFunctionEnd
+%main1_inner = OpFunction %uint None %34
+         %36 = OpLabel
+               OpReturnValue %uint_1
+               OpFunctionEnd
+      %main1 = OpFunction %void None %29
+         %39 = OpLabel
+         %40 = OpFunctionCall %uint %main1_inner
+               OpStore %value_1 %40
+               OpReturn
+               OpFunctionEnd
+%main2_inner = OpFunction %float None %41
+         %43 = OpLabel
+               OpReturnValue %float_1
+               OpFunctionEnd
+      %main2 = OpFunction %void None %29
+         %46 = OpLabel
+         %47 = OpFunctionCall %float %main2_inner
+               OpStore %value_2 %47
+               OpReturn
+               OpFunctionEnd
+%main3_inner = OpFunction %v4float None %48
+         %50 = OpLabel
+               OpReturnValue %54
+               OpFunctionEnd
+      %main3 = OpFunction %void None %29
+         %56 = OpLabel
+         %57 = OpFunctionCall %v4float %main3_inner
+               OpStore %value_3 %57
+               OpReturn
+               OpFunctionEnd
+%main4_inner = OpFunction %half None %58
+         %60 = OpLabel
+               OpReturnValue %half_0x1_2p_1
+               OpFunctionEnd
+      %main4 = OpFunction %void None %29
+         %63 = OpLabel
+         %64 = OpFunctionCall %half %main4_inner
+               OpStore %value_4 %64
+               OpReturn
+               OpFunctionEnd
+%main5_inner = OpFunction %v3half None %65
+         %67 = OpLabel
+               OpReturnValue %71
+               OpFunctionEnd
+      %main5 = OpFunction %void None %29
+         %73 = OpLabel
+         %74 = OpFunctionCall %v3half %main5_inner
+               OpStore %value_5 %74
+               OpReturn
+               OpFunctionEnd
diff --git a/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.wgsl b/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.wgsl
new file mode 100644
index 0000000..62f7392
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_locations_f16.wgsl.expected.wgsl
@@ -0,0 +1,31 @@
+enable f16;
+
+@fragment
+fn main0() -> @location(0) i32 {
+  return 1;
+}
+
+@fragment
+fn main1() -> @location(1) u32 {
+  return 1u;
+}
+
+@fragment
+fn main2() -> @location(2) f32 {
+  return 1.0;
+}
+
+@fragment
+fn main3() -> @location(3) vec4<f32> {
+  return vec4<f32>(1.0, 2.0, 3.0, 4.0);
+}
+
+@fragment
+fn main4() -> @location(4) f16 {
+  return 2.25h;
+}
+
+@fragment
+fn main5() -> @location(5) vec3<f16> {
+  return vec3<f16>(3.0h, 5.0h, 8.0h);
+}
diff --git a/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl b/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl
new file mode 100644
index 0000000..871c4ad
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl
@@ -0,0 +1,15 @@
+enable f16;
+
+struct FragmentOutputs {
+  @location(0) loc0 : i32,
+  @location(1) loc1 : u32,
+  @location(2) loc2 : f32,
+  @location(3) loc3 : vec4<f32>,
+  @location(4) loc4 : f16,
+  @location(5) loc5 : vec3<f16>,
+};
+
+@fragment
+fn main() -> FragmentOutputs {
+  return FragmentOutputs(1, 1u, 1.0, vec4<f32>(1.0, 2.0, 3.0, 4.0), 2.25h, vec3<f16>(3.0h, 5.0h, 8.0h));
+}
diff --git a/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.dxc.hlsl b/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.dxc.hlsl
new file mode 100644
index 0000000..b3a78ae
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.dxc.hlsl
@@ -0,0 +1,33 @@
+struct FragmentOutputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  float4 loc3;
+  float16_t loc4;
+  vector<float16_t, 3> loc5;
+};
+struct tint_symbol {
+  int loc0 : SV_Target0;
+  uint loc1 : SV_Target1;
+  float loc2 : SV_Target2;
+  float4 loc3 : SV_Target3;
+  float16_t loc4 : SV_Target4;
+  vector<float16_t, 3> loc5 : SV_Target5;
+};
+
+FragmentOutputs main_inner() {
+  const FragmentOutputs tint_symbol_1 = {1, 1u, 1.0f, float4(1.0f, 2.0f, 3.0f, 4.0f), float16_t(2.25h), vector<float16_t, 3>(float16_t(3.0h), float16_t(5.0h), float16_t(8.0h))};
+  return tint_symbol_1;
+}
+
+tint_symbol main() {
+  const FragmentOutputs inner_result = main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.loc0 = inner_result.loc0;
+  wrapper_result.loc1 = inner_result.loc1;
+  wrapper_result.loc2 = inner_result.loc2;
+  wrapper_result.loc3 = inner_result.loc3;
+  wrapper_result.loc4 = inner_result.loc4;
+  wrapper_result.loc5 = inner_result.loc5;
+  return wrapper_result;
+}
diff --git a/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.fxc.hlsl b/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.fxc.hlsl
new file mode 100644
index 0000000..29537be
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.fxc.hlsl
@@ -0,0 +1,38 @@
+SKIP: FAILED
+
+struct FragmentOutputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  float4 loc3;
+  float16_t loc4;
+  vector<float16_t, 3> loc5;
+};
+struct tint_symbol {
+  int loc0 : SV_Target0;
+  uint loc1 : SV_Target1;
+  float loc2 : SV_Target2;
+  float4 loc3 : SV_Target3;
+  float16_t loc4 : SV_Target4;
+  vector<float16_t, 3> loc5 : SV_Target5;
+};
+
+FragmentOutputs main_inner() {
+  const FragmentOutputs tint_symbol_1 = {1, 1u, 1.0f, float4(1.0f, 2.0f, 3.0f, 4.0f), float16_t(2.25h), vector<float16_t, 3>(float16_t(3.0h), float16_t(5.0h), float16_t(8.0h))};
+  return tint_symbol_1;
+}
+
+tint_symbol main() {
+  const FragmentOutputs inner_result = main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.loc0 = inner_result.loc0;
+  wrapper_result.loc1 = inner_result.loc1;
+  wrapper_result.loc2 = inner_result.loc2;
+  wrapper_result.loc3 = inner_result.loc3;
+  wrapper_result.loc4 = inner_result.loc4;
+  wrapper_result.loc5 = inner_result.loc5;
+  return wrapper_result;
+}
+FXC validation failure:
+D:\Projects\RampUp\dawn\test\tint\shader_io\Shader@0x00000289AB322DE0(6,3-11): error X3000: unrecognized identifier 'float16_t'
+
diff --git a/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.glsl b/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.glsl
new file mode 100644
index 0000000..db79208
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.glsl
@@ -0,0 +1,34 @@
+#version 310 es
+#extension GL_AMD_gpu_shader_half_float : require
+precision mediump float;
+
+layout(location = 0) out int loc0_1;
+layout(location = 1) out uint loc1_1;
+layout(location = 2) out float loc2_1;
+layout(location = 3) out vec4 loc3_1;
+layout(location = 4) out float16_t loc4_1;
+layout(location = 5) out f16vec3 loc5_1;
+struct FragmentOutputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  vec4 loc3;
+  float16_t loc4;
+  f16vec3 loc5;
+};
+
+FragmentOutputs tint_symbol() {
+  FragmentOutputs tint_symbol_1 = FragmentOutputs(1, 1u, 1.0f, vec4(1.0f, 2.0f, 3.0f, 4.0f), 2.25hf, f16vec3(3.0hf, 5.0hf, 8.0hf));
+  return tint_symbol_1;
+}
+
+void main() {
+  FragmentOutputs inner_result = tint_symbol();
+  loc0_1 = inner_result.loc0;
+  loc1_1 = inner_result.loc1;
+  loc2_1 = inner_result.loc2;
+  loc3_1 = inner_result.loc3;
+  loc4_1 = inner_result.loc4;
+  loc5_1 = inner_result.loc5;
+  return;
+}
diff --git a/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.msl b/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.msl
new file mode 100644
index 0000000..efb99f6
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.msl
@@ -0,0 +1,38 @@
+#include <metal_stdlib>
+
+using namespace metal;
+struct FragmentOutputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  float4 loc3;
+  half loc4;
+  half3 loc5;
+};
+
+struct tint_symbol_1 {
+  int loc0 [[color(0)]];
+  uint loc1 [[color(1)]];
+  float loc2 [[color(2)]];
+  float4 loc3 [[color(3)]];
+  half loc4 [[color(4)]];
+  half3 loc5 [[color(5)]];
+};
+
+FragmentOutputs tint_symbol_inner() {
+  FragmentOutputs const tint_symbol_2 = FragmentOutputs{.loc0=1, .loc1=1u, .loc2=1.0f, .loc3=float4(1.0f, 2.0f, 3.0f, 4.0f), .loc4=2.25h, .loc5=half3(3.0h, 5.0h, 8.0h)};
+  return tint_symbol_2;
+}
+
+fragment tint_symbol_1 tint_symbol() {
+  FragmentOutputs const inner_result = tint_symbol_inner();
+  tint_symbol_1 wrapper_result = {};
+  wrapper_result.loc0 = inner_result.loc0;
+  wrapper_result.loc1 = inner_result.loc1;
+  wrapper_result.loc2 = inner_result.loc2;
+  wrapper_result.loc3 = inner_result.loc3;
+  wrapper_result.loc4 = inner_result.loc4;
+  wrapper_result.loc5 = inner_result.loc5;
+  return wrapper_result;
+}
+
diff --git a/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.spvasm b/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.spvasm
new file mode 100644
index 0000000..b68a17b
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.spvasm
@@ -0,0 +1,102 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 53
+; Schema: 0
+               OpCapability Shader
+               OpCapability Float16
+               OpCapability UniformAndStorageBuffer16BitAccess
+               OpCapability StorageBuffer16BitAccess
+               OpCapability StorageInputOutput16
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %main "main" %loc0_1 %loc1_1 %loc2_1 %loc3_1 %loc4_1 %loc5_1
+               OpExecutionMode %main OriginUpperLeft
+               OpName %loc0_1 "loc0_1"
+               OpName %loc1_1 "loc1_1"
+               OpName %loc2_1 "loc2_1"
+               OpName %loc3_1 "loc3_1"
+               OpName %loc4_1 "loc4_1"
+               OpName %loc5_1 "loc5_1"
+               OpName %FragmentOutputs "FragmentOutputs"
+               OpMemberName %FragmentOutputs 0 "loc0"
+               OpMemberName %FragmentOutputs 1 "loc1"
+               OpMemberName %FragmentOutputs 2 "loc2"
+               OpMemberName %FragmentOutputs 3 "loc3"
+               OpMemberName %FragmentOutputs 4 "loc4"
+               OpMemberName %FragmentOutputs 5 "loc5"
+               OpName %main_inner "main_inner"
+               OpName %main "main"
+               OpDecorate %loc0_1 Location 0
+               OpDecorate %loc1_1 Location 1
+               OpDecorate %loc2_1 Location 2
+               OpDecorate %loc3_1 Location 3
+               OpDecorate %loc4_1 Location 4
+               OpDecorate %loc5_1 Location 5
+               OpMemberDecorate %FragmentOutputs 0 Offset 0
+               OpMemberDecorate %FragmentOutputs 1 Offset 4
+               OpMemberDecorate %FragmentOutputs 2 Offset 8
+               OpMemberDecorate %FragmentOutputs 3 Offset 16
+               OpMemberDecorate %FragmentOutputs 4 Offset 32
+               OpMemberDecorate %FragmentOutputs 5 Offset 40
+        %int = OpTypeInt 32 1
+%_ptr_Output_int = OpTypePointer Output %int
+          %4 = OpConstantNull %int
+     %loc0_1 = OpVariable %_ptr_Output_int Output %4
+       %uint = OpTypeInt 32 0
+%_ptr_Output_uint = OpTypePointer Output %uint
+          %8 = OpConstantNull %uint
+     %loc1_1 = OpVariable %_ptr_Output_uint Output %8
+      %float = OpTypeFloat 32
+%_ptr_Output_float = OpTypePointer Output %float
+         %12 = OpConstantNull %float
+     %loc2_1 = OpVariable %_ptr_Output_float Output %12
+    %v4float = OpTypeVector %float 4
+%_ptr_Output_v4float = OpTypePointer Output %v4float
+         %16 = OpConstantNull %v4float
+     %loc3_1 = OpVariable %_ptr_Output_v4float Output %16
+       %half = OpTypeFloat 16
+%_ptr_Output_half = OpTypePointer Output %half
+         %20 = OpConstantNull %half
+     %loc4_1 = OpVariable %_ptr_Output_half Output %20
+     %v3half = OpTypeVector %half 3
+%_ptr_Output_v3half = OpTypePointer Output %v3half
+         %24 = OpConstantNull %v3half
+     %loc5_1 = OpVariable %_ptr_Output_v3half Output %24
+%FragmentOutputs = OpTypeStruct %int %uint %float %v4float %half %v3half
+         %25 = OpTypeFunction %FragmentOutputs
+      %int_1 = OpConstant %int 1
+     %uint_1 = OpConstant %uint 1
+    %float_1 = OpConstant %float 1
+    %float_2 = OpConstant %float 2
+    %float_3 = OpConstant %float 3
+    %float_4 = OpConstant %float 4
+         %35 = OpConstantComposite %v4float %float_1 %float_2 %float_3 %float_4
+%half_0x1_2p_1 = OpConstant %half 0x1.2p+1
+%half_0x1_8p_1 = OpConstant %half 0x1.8p+1
+%half_0x1_4p_2 = OpConstant %half 0x1.4p+2
+%half_0x1p_3 = OpConstant %half 0x1p+3
+         %40 = OpConstantComposite %v3half %half_0x1_8p_1 %half_0x1_4p_2 %half_0x1p_3
+         %41 = OpConstantComposite %FragmentOutputs %int_1 %uint_1 %float_1 %35 %half_0x1_2p_1 %40
+       %void = OpTypeVoid
+         %42 = OpTypeFunction %void
+ %main_inner = OpFunction %FragmentOutputs None %25
+         %28 = OpLabel
+               OpReturnValue %41
+               OpFunctionEnd
+       %main = OpFunction %void None %42
+         %45 = OpLabel
+         %46 = OpFunctionCall %FragmentOutputs %main_inner
+         %47 = OpCompositeExtract %int %46 0
+               OpStore %loc0_1 %47
+         %48 = OpCompositeExtract %uint %46 1
+               OpStore %loc1_1 %48
+         %49 = OpCompositeExtract %float %46 2
+               OpStore %loc2_1 %49
+         %50 = OpCompositeExtract %v4float %46 3
+               OpStore %loc3_1 %50
+         %51 = OpCompositeExtract %half %46 4
+               OpStore %loc4_1 %51
+         %52 = OpCompositeExtract %v3half %46 5
+               OpStore %loc5_1 %52
+               OpReturn
+               OpFunctionEnd
diff --git a/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.wgsl b/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.wgsl
new file mode 100644
index 0000000..8621a02
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_locations_struct_f16.wgsl.expected.wgsl
@@ -0,0 +1,21 @@
+enable f16;
+
+struct FragmentOutputs {
+  @location(0)
+  loc0 : i32,
+  @location(1)
+  loc1 : u32,
+  @location(2)
+  loc2 : f32,
+  @location(3)
+  loc3 : vec4<f32>,
+  @location(4)
+  loc4 : f16,
+  @location(5)
+  loc5 : vec3<f16>,
+}
+
+@fragment
+fn main() -> FragmentOutputs {
+  return FragmentOutputs(1, 1u, 1.0, vec4<f32>(1.0, 2.0, 3.0, 4.0), 2.25h, vec3<f16>(3.0h, 5.0h, 8.0h));
+}
diff --git a/test/tint/shader_io/fragment_output_mixed_f16.wgsl b/test/tint/shader_io/fragment_output_mixed_f16.wgsl
new file mode 100644
index 0000000..6de63b3
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_mixed_f16.wgsl
@@ -0,0 +1,17 @@
+enable f16;
+
+struct FragmentOutputs {
+  @location(0) loc0 : i32,
+  @builtin(frag_depth) frag_depth : f32,
+  @location(1) loc1 : u32,
+  @location(2) loc2 : f32,
+  @builtin(sample_mask) sample_mask : u32,
+  @location(3) loc3 : vec4<f32>,
+  @location(4) loc4 : f16,
+  @location(5) loc5 : vec3<f16>,
+};
+
+@fragment
+fn main() -> FragmentOutputs {
+  return FragmentOutputs(1, 2.0, 1u, 1.0, 2u, vec4<f32>(1.0, 2.0, 3.0, 4.0), 2.25h, vec3<f16>(3.0h, 5.0h, 8.0h));
+}
diff --git a/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.dxc.hlsl b/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.dxc.hlsl
new file mode 100644
index 0000000..ca07eba
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.dxc.hlsl
@@ -0,0 +1,39 @@
+struct FragmentOutputs {
+  int loc0;
+  float frag_depth;
+  uint loc1;
+  float loc2;
+  uint sample_mask;
+  float4 loc3;
+  float16_t loc4;
+  vector<float16_t, 3> loc5;
+};
+struct tint_symbol {
+  int loc0 : SV_Target0;
+  uint loc1 : SV_Target1;
+  float loc2 : SV_Target2;
+  float4 loc3 : SV_Target3;
+  float16_t loc4 : SV_Target4;
+  vector<float16_t, 3> loc5 : SV_Target5;
+  float frag_depth : SV_Depth;
+  uint sample_mask : SV_Coverage;
+};
+
+FragmentOutputs main_inner() {
+  const FragmentOutputs tint_symbol_1 = {1, 2.0f, 1u, 1.0f, 2u, float4(1.0f, 2.0f, 3.0f, 4.0f), float16_t(2.25h), vector<float16_t, 3>(float16_t(3.0h), float16_t(5.0h), float16_t(8.0h))};
+  return tint_symbol_1;
+}
+
+tint_symbol main() {
+  const FragmentOutputs inner_result = main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.loc0 = inner_result.loc0;
+  wrapper_result.frag_depth = inner_result.frag_depth;
+  wrapper_result.loc1 = inner_result.loc1;
+  wrapper_result.loc2 = inner_result.loc2;
+  wrapper_result.sample_mask = inner_result.sample_mask;
+  wrapper_result.loc3 = inner_result.loc3;
+  wrapper_result.loc4 = inner_result.loc4;
+  wrapper_result.loc5 = inner_result.loc5;
+  return wrapper_result;
+}
diff --git a/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.fxc.hlsl b/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.fxc.hlsl
new file mode 100644
index 0000000..0c99d7f
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.fxc.hlsl
@@ -0,0 +1,44 @@
+SKIP: FAILED
+
+struct FragmentOutputs {
+  int loc0;
+  float frag_depth;
+  uint loc1;
+  float loc2;
+  uint sample_mask;
+  float4 loc3;
+  float16_t loc4;
+  vector<float16_t, 3> loc5;
+};
+struct tint_symbol {
+  int loc0 : SV_Target0;
+  uint loc1 : SV_Target1;
+  float loc2 : SV_Target2;
+  float4 loc3 : SV_Target3;
+  float16_t loc4 : SV_Target4;
+  vector<float16_t, 3> loc5 : SV_Target5;
+  float frag_depth : SV_Depth;
+  uint sample_mask : SV_Coverage;
+};
+
+FragmentOutputs main_inner() {
+  const FragmentOutputs tint_symbol_1 = {1, 2.0f, 1u, 1.0f, 2u, float4(1.0f, 2.0f, 3.0f, 4.0f), float16_t(2.25h), vector<float16_t, 3>(float16_t(3.0h), float16_t(5.0h), float16_t(8.0h))};
+  return tint_symbol_1;
+}
+
+tint_symbol main() {
+  const FragmentOutputs inner_result = main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.loc0 = inner_result.loc0;
+  wrapper_result.frag_depth = inner_result.frag_depth;
+  wrapper_result.loc1 = inner_result.loc1;
+  wrapper_result.loc2 = inner_result.loc2;
+  wrapper_result.sample_mask = inner_result.sample_mask;
+  wrapper_result.loc3 = inner_result.loc3;
+  wrapper_result.loc4 = inner_result.loc4;
+  wrapper_result.loc5 = inner_result.loc5;
+  return wrapper_result;
+}
+FXC validation failure:
+D:\Projects\RampUp\dawn\test\tint\shader_io\Shader@0x000002135B880A00(8,3-11): error X3000: unrecognized identifier 'float16_t'
+
diff --git a/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.glsl b/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.glsl
new file mode 100644
index 0000000..f635012
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.glsl
@@ -0,0 +1,39 @@
+#version 310 es
+#extension GL_OES_sample_variables : require
+#extension GL_AMD_gpu_shader_half_float : require
+precision mediump float;
+
+layout(location = 0) out int loc0_1;
+layout(location = 1) out uint loc1_1;
+layout(location = 2) out float loc2_1;
+layout(location = 3) out vec4 loc3_1;
+layout(location = 4) out float16_t loc4_1;
+layout(location = 5) out f16vec3 loc5_1;
+struct FragmentOutputs {
+  int loc0;
+  float frag_depth;
+  uint loc1;
+  float loc2;
+  uint sample_mask;
+  vec4 loc3;
+  float16_t loc4;
+  f16vec3 loc5;
+};
+
+FragmentOutputs tint_symbol() {
+  FragmentOutputs tint_symbol_1 = FragmentOutputs(1, 2.0f, 1u, 1.0f, 2u, vec4(1.0f, 2.0f, 3.0f, 4.0f), 2.25hf, f16vec3(3.0hf, 5.0hf, 8.0hf));
+  return tint_symbol_1;
+}
+
+void main() {
+  FragmentOutputs inner_result = tint_symbol();
+  loc0_1 = inner_result.loc0;
+  gl_FragDepth = inner_result.frag_depth;
+  loc1_1 = inner_result.loc1;
+  loc2_1 = inner_result.loc2;
+  gl_SampleMask[0] = int(inner_result.sample_mask);
+  loc3_1 = inner_result.loc3;
+  loc4_1 = inner_result.loc4;
+  loc5_1 = inner_result.loc5;
+  return;
+}
diff --git a/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.msl b/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.msl
new file mode 100644
index 0000000..59e81a5
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.msl
@@ -0,0 +1,44 @@
+#include <metal_stdlib>
+
+using namespace metal;
+struct FragmentOutputs {
+  int loc0;
+  float frag_depth;
+  uint loc1;
+  float loc2;
+  uint sample_mask;
+  float4 loc3;
+  half loc4;
+  half3 loc5;
+};
+
+struct tint_symbol_1 {
+  int loc0 [[color(0)]];
+  uint loc1 [[color(1)]];
+  float loc2 [[color(2)]];
+  float4 loc3 [[color(3)]];
+  half loc4 [[color(4)]];
+  half3 loc5 [[color(5)]];
+  float frag_depth [[depth(any)]];
+  uint sample_mask [[sample_mask]];
+};
+
+FragmentOutputs tint_symbol_inner() {
+  FragmentOutputs const tint_symbol_2 = FragmentOutputs{.loc0=1, .frag_depth=2.0f, .loc1=1u, .loc2=1.0f, .sample_mask=2u, .loc3=float4(1.0f, 2.0f, 3.0f, 4.0f), .loc4=2.25h, .loc5=half3(3.0h, 5.0h, 8.0h)};
+  return tint_symbol_2;
+}
+
+fragment tint_symbol_1 tint_symbol() {
+  FragmentOutputs const inner_result = tint_symbol_inner();
+  tint_symbol_1 wrapper_result = {};
+  wrapper_result.loc0 = inner_result.loc0;
+  wrapper_result.frag_depth = inner_result.frag_depth;
+  wrapper_result.loc1 = inner_result.loc1;
+  wrapper_result.loc2 = inner_result.loc2;
+  wrapper_result.sample_mask = inner_result.sample_mask;
+  wrapper_result.loc3 = inner_result.loc3;
+  wrapper_result.loc4 = inner_result.loc4;
+  wrapper_result.loc5 = inner_result.loc5;
+  return wrapper_result;
+}
+
diff --git a/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.spvasm b/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.spvasm
new file mode 100644
index 0000000..6c6f8d2
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.spvasm
@@ -0,0 +1,123 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 62
+; Schema: 0
+               OpCapability Shader
+               OpCapability Float16
+               OpCapability UniformAndStorageBuffer16BitAccess
+               OpCapability StorageBuffer16BitAccess
+               OpCapability StorageInputOutput16
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %main "main" %loc0_1 %frag_depth_1 %loc1_1 %loc2_1 %sample_mask_1 %loc3_1 %loc4_1 %loc5_1
+               OpExecutionMode %main OriginUpperLeft
+               OpExecutionMode %main DepthReplacing
+               OpName %loc0_1 "loc0_1"
+               OpName %frag_depth_1 "frag_depth_1"
+               OpName %loc1_1 "loc1_1"
+               OpName %loc2_1 "loc2_1"
+               OpName %sample_mask_1 "sample_mask_1"
+               OpName %loc3_1 "loc3_1"
+               OpName %loc4_1 "loc4_1"
+               OpName %loc5_1 "loc5_1"
+               OpName %FragmentOutputs "FragmentOutputs"
+               OpMemberName %FragmentOutputs 0 "loc0"
+               OpMemberName %FragmentOutputs 1 "frag_depth"
+               OpMemberName %FragmentOutputs 2 "loc1"
+               OpMemberName %FragmentOutputs 3 "loc2"
+               OpMemberName %FragmentOutputs 4 "sample_mask"
+               OpMemberName %FragmentOutputs 5 "loc3"
+               OpMemberName %FragmentOutputs 6 "loc4"
+               OpMemberName %FragmentOutputs 7 "loc5"
+               OpName %main_inner "main_inner"
+               OpName %main "main"
+               OpDecorate %loc0_1 Location 0
+               OpDecorate %frag_depth_1 BuiltIn FragDepth
+               OpDecorate %loc1_1 Location 1
+               OpDecorate %loc2_1 Location 2
+               OpDecorate %_arr_uint_uint_1 ArrayStride 4
+               OpDecorate %sample_mask_1 BuiltIn SampleMask
+               OpDecorate %loc3_1 Location 3
+               OpDecorate %loc4_1 Location 4
+               OpDecorate %loc5_1 Location 5
+               OpMemberDecorate %FragmentOutputs 0 Offset 0
+               OpMemberDecorate %FragmentOutputs 1 Offset 4
+               OpMemberDecorate %FragmentOutputs 2 Offset 8
+               OpMemberDecorate %FragmentOutputs 3 Offset 12
+               OpMemberDecorate %FragmentOutputs 4 Offset 16
+               OpMemberDecorate %FragmentOutputs 5 Offset 32
+               OpMemberDecorate %FragmentOutputs 6 Offset 48
+               OpMemberDecorate %FragmentOutputs 7 Offset 56
+        %int = OpTypeInt 32 1
+%_ptr_Output_int = OpTypePointer Output %int
+          %4 = OpConstantNull %int
+     %loc0_1 = OpVariable %_ptr_Output_int Output %4
+      %float = OpTypeFloat 32
+%_ptr_Output_float = OpTypePointer Output %float
+          %8 = OpConstantNull %float
+%frag_depth_1 = OpVariable %_ptr_Output_float Output %8
+       %uint = OpTypeInt 32 0
+%_ptr_Output_uint = OpTypePointer Output %uint
+         %12 = OpConstantNull %uint
+     %loc1_1 = OpVariable %_ptr_Output_uint Output %12
+     %loc2_1 = OpVariable %_ptr_Output_float Output %8
+     %uint_1 = OpConstant %uint 1
+%_arr_uint_uint_1 = OpTypeArray %uint %uint_1
+%_ptr_Output__arr_uint_uint_1 = OpTypePointer Output %_arr_uint_uint_1
+         %18 = OpConstantNull %_arr_uint_uint_1
+%sample_mask_1 = OpVariable %_ptr_Output__arr_uint_uint_1 Output %18
+    %v4float = OpTypeVector %float 4
+%_ptr_Output_v4float = OpTypePointer Output %v4float
+         %22 = OpConstantNull %v4float
+     %loc3_1 = OpVariable %_ptr_Output_v4float Output %22
+       %half = OpTypeFloat 16
+%_ptr_Output_half = OpTypePointer Output %half
+         %26 = OpConstantNull %half
+     %loc4_1 = OpVariable %_ptr_Output_half Output %26
+     %v3half = OpTypeVector %half 3
+%_ptr_Output_v3half = OpTypePointer Output %v3half
+         %30 = OpConstantNull %v3half
+     %loc5_1 = OpVariable %_ptr_Output_v3half Output %30
+%FragmentOutputs = OpTypeStruct %int %float %uint %float %uint %v4float %half %v3half
+         %31 = OpTypeFunction %FragmentOutputs
+      %int_1 = OpConstant %int 1
+    %float_2 = OpConstant %float 2
+    %float_1 = OpConstant %float 1
+     %uint_2 = OpConstant %uint 2
+    %float_3 = OpConstant %float 3
+    %float_4 = OpConstant %float 4
+         %41 = OpConstantComposite %v4float %float_1 %float_2 %float_3 %float_4
+%half_0x1_2p_1 = OpConstant %half 0x1.2p+1
+%half_0x1_8p_1 = OpConstant %half 0x1.8p+1
+%half_0x1_4p_2 = OpConstant %half 0x1.4p+2
+%half_0x1p_3 = OpConstant %half 0x1p+3
+         %46 = OpConstantComposite %v3half %half_0x1_8p_1 %half_0x1_4p_2 %half_0x1p_3
+         %47 = OpConstantComposite %FragmentOutputs %int_1 %float_2 %uint_1 %float_1 %uint_2 %41 %half_0x1_2p_1 %46
+       %void = OpTypeVoid
+         %48 = OpTypeFunction %void
+ %main_inner = OpFunction %FragmentOutputs None %31
+         %34 = OpLabel
+               OpReturnValue %47
+               OpFunctionEnd
+       %main = OpFunction %void None %48
+         %51 = OpLabel
+         %52 = OpFunctionCall %FragmentOutputs %main_inner
+         %53 = OpCompositeExtract %int %52 0
+               OpStore %loc0_1 %53
+         %54 = OpCompositeExtract %float %52 1
+               OpStore %frag_depth_1 %54
+         %55 = OpCompositeExtract %uint %52 2
+               OpStore %loc1_1 %55
+         %56 = OpCompositeExtract %float %52 3
+               OpStore %loc2_1 %56
+         %57 = OpAccessChain %_ptr_Output_uint %sample_mask_1 %4
+         %58 = OpCompositeExtract %uint %52 4
+               OpStore %57 %58
+         %59 = OpCompositeExtract %v4float %52 5
+               OpStore %loc3_1 %59
+         %60 = OpCompositeExtract %half %52 6
+               OpStore %loc4_1 %60
+         %61 = OpCompositeExtract %v3half %52 7
+               OpStore %loc5_1 %61
+               OpReturn
+               OpFunctionEnd
diff --git a/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.wgsl b/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.wgsl
new file mode 100644
index 0000000..4245861
--- /dev/null
+++ b/test/tint/shader_io/fragment_output_mixed_f16.wgsl.expected.wgsl
@@ -0,0 +1,25 @@
+enable f16;
+
+struct FragmentOutputs {
+  @location(0)
+  loc0 : i32,
+  @builtin(frag_depth)
+  frag_depth : f32,
+  @location(1)
+  loc1 : u32,
+  @location(2)
+  loc2 : f32,
+  @builtin(sample_mask)
+  sample_mask : u32,
+  @location(3)
+  loc3 : vec4<f32>,
+  @location(4)
+  loc4 : f16,
+  @location(5)
+  loc5 : vec3<f16>,
+}
+
+@fragment
+fn main() -> FragmentOutputs {
+  return FragmentOutputs(1, 2.0, 1u, 1.0, 2u, vec4<f32>(1.0, 2.0, 3.0, 4.0), 2.25h, vec3<f16>(3.0h, 5.0h, 8.0h));
+}
diff --git a/test/tint/shader_io/shared_struct_different_stages_f16.wgsl b/test/tint/shader_io/shared_struct_different_stages_f16.wgsl
new file mode 100644
index 0000000..eaafdf8
--- /dev/null
+++ b/test/tint/shader_io/shared_struct_different_stages_f16.wgsl
@@ -0,0 +1,18 @@
+enable f16;
+
+struct Interface {
+  @location(1) col1 : f32,
+  @location(2) col2 : f16,
+  @builtin(position) pos : vec4<f32>,
+};
+
+@vertex
+fn vert_main() -> Interface {
+  return Interface(0.4, 0.6h, vec4<f32>());
+}
+
+@fragment
+fn frag_main(colors : Interface) {
+  let r : f32 = colors.col1;
+  let g : f16 = colors.col2;
+}
diff --git a/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.dxc.hlsl b/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.dxc.hlsl
new file mode 100644
index 0000000..d33f3d2
--- /dev/null
+++ b/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.dxc.hlsl
@@ -0,0 +1,41 @@
+struct Interface {
+  float col1;
+  float16_t col2;
+  float4 pos;
+};
+struct tint_symbol {
+  float col1 : TEXCOORD1;
+  float16_t col2 : TEXCOORD2;
+  float4 pos : SV_Position;
+};
+
+Interface vert_main_inner() {
+  const Interface tint_symbol_3 = {0.400000006f, float16_t(0.599609375h), (0.0f).xxxx};
+  return tint_symbol_3;
+}
+
+tint_symbol vert_main() {
+  const Interface inner_result = vert_main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.col1 = inner_result.col1;
+  wrapper_result.col2 = inner_result.col2;
+  wrapper_result.pos = inner_result.pos;
+  return wrapper_result;
+}
+
+struct tint_symbol_2 {
+  float col1 : TEXCOORD1;
+  float16_t col2 : TEXCOORD2;
+  float4 pos : SV_Position;
+};
+
+void frag_main_inner(Interface colors) {
+  const float r = colors.col1;
+  const float16_t g = colors.col2;
+}
+
+void frag_main(tint_symbol_2 tint_symbol_1) {
+  const Interface tint_symbol_4 = {tint_symbol_1.col1, tint_symbol_1.col2, tint_symbol_1.pos};
+  frag_main_inner(tint_symbol_4);
+  return;
+}
diff --git a/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.fxc.hlsl b/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.fxc.hlsl
new file mode 100644
index 0000000..b91e9d2
--- /dev/null
+++ b/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.fxc.hlsl
@@ -0,0 +1,46 @@
+SKIP: FAILED
+
+struct Interface {
+  float col1;
+  float16_t col2;
+  float4 pos;
+};
+struct tint_symbol {
+  float col1 : TEXCOORD1;
+  float16_t col2 : TEXCOORD2;
+  float4 pos : SV_Position;
+};
+
+Interface vert_main_inner() {
+  const Interface tint_symbol_3 = {0.400000006f, float16_t(0.599609375h), (0.0f).xxxx};
+  return tint_symbol_3;
+}
+
+tint_symbol vert_main() {
+  const Interface inner_result = vert_main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.col1 = inner_result.col1;
+  wrapper_result.col2 = inner_result.col2;
+  wrapper_result.pos = inner_result.pos;
+  return wrapper_result;
+}
+
+struct tint_symbol_2 {
+  float col1 : TEXCOORD1;
+  float16_t col2 : TEXCOORD2;
+  float4 pos : SV_Position;
+};
+
+void frag_main_inner(Interface colors) {
+  const float r = colors.col1;
+  const float16_t g = colors.col2;
+}
+
+void frag_main(tint_symbol_2 tint_symbol_1) {
+  const Interface tint_symbol_4 = {tint_symbol_1.col1, tint_symbol_1.col2, tint_symbol_1.pos};
+  frag_main_inner(tint_symbol_4);
+  return;
+}
+FXC validation failure:
+D:\Projects\RampUp\dawn\test\tint\shader_io\Shader@0x0000019F5A370630(3,3-11): error X3000: unrecognized identifier 'float16_t'
+
diff --git a/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.glsl b/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.glsl
new file mode 100644
index 0000000..2386543
--- /dev/null
+++ b/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.glsl
@@ -0,0 +1,48 @@
+#version 310 es
+#extension GL_AMD_gpu_shader_half_float : require
+
+layout(location = 1) out float col1_1;
+layout(location = 2) out float16_t col2_1;
+struct Interface {
+  float col1;
+  float16_t col2;
+  vec4 pos;
+};
+
+Interface vert_main() {
+  Interface tint_symbol = Interface(0.400000006f, 0.599609375hf, vec4(0.0f));
+  return tint_symbol;
+}
+
+void main() {
+  gl_PointSize = 1.0;
+  Interface inner_result = vert_main();
+  col1_1 = inner_result.col1;
+  col2_1 = inner_result.col2;
+  gl_Position = inner_result.pos;
+  gl_Position.y = -(gl_Position.y);
+  gl_Position.z = ((2.0f * gl_Position.z) - gl_Position.w);
+  return;
+}
+#version 310 es
+#extension GL_AMD_gpu_shader_half_float : require
+precision mediump float;
+
+layout(location = 1) in float col1_1;
+layout(location = 2) in float16_t col2_1;
+struct Interface {
+  float col1;
+  float16_t col2;
+  vec4 pos;
+};
+
+void frag_main(Interface colors) {
+  float r = colors.col1;
+  float16_t g = colors.col2;
+}
+
+void main() {
+  Interface tint_symbol = Interface(col1_1, col2_1, gl_FragCoord);
+  frag_main(tint_symbol);
+  return;
+}
diff --git a/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.msl b/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.msl
new file mode 100644
index 0000000..5bccb63
--- /dev/null
+++ b/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.msl
@@ -0,0 +1,45 @@
+#include <metal_stdlib>
+
+using namespace metal;
+struct Interface {
+  float col1;
+  half col2;
+  float4 pos;
+};
+
+struct tint_symbol {
+  float col1 [[user(locn1)]];
+  half col2 [[user(locn2)]];
+  float4 pos [[position]];
+};
+
+Interface vert_main_inner() {
+  Interface const tint_symbol_3 = Interface{.col1=0.400000006f, .col2=0.599609375h, .pos=float4(0.0f)};
+  return tint_symbol_3;
+}
+
+vertex tint_symbol vert_main() {
+  Interface const inner_result = vert_main_inner();
+  tint_symbol wrapper_result = {};
+  wrapper_result.col1 = inner_result.col1;
+  wrapper_result.col2 = inner_result.col2;
+  wrapper_result.pos = inner_result.pos;
+  return wrapper_result;
+}
+
+struct tint_symbol_2 {
+  float col1 [[user(locn1)]];
+  half col2 [[user(locn2)]];
+};
+
+void frag_main_inner(Interface colors) {
+  float const r = colors.col1;
+  half const g = colors.col2;
+}
+
+fragment void frag_main(float4 pos [[position]], tint_symbol_2 tint_symbol_1 [[stage_in]]) {
+  Interface const tint_symbol_4 = {.col1=tint_symbol_1.col1, .col2=tint_symbol_1.col2, .pos=pos};
+  frag_main_inner(tint_symbol_4);
+  return;
+}
+
diff --git a/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.spvasm b/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.spvasm
new file mode 100644
index 0000000..9260b6f
--- /dev/null
+++ b/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.spvasm
@@ -0,0 +1,100 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 49
+; Schema: 0
+               OpCapability Shader
+               OpCapability Float16
+               OpCapability UniformAndStorageBuffer16BitAccess
+               OpCapability StorageBuffer16BitAccess
+               OpCapability StorageInputOutput16
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Vertex %vert_main "vert_main" %col1_1 %col2_1 %pos_1 %vertex_point_size
+               OpEntryPoint Fragment %frag_main "frag_main" %col1_2 %col2_2 %pos_2
+               OpExecutionMode %frag_main OriginUpperLeft
+               OpName %col1_1 "col1_1"
+               OpName %col2_1 "col2_1"
+               OpName %pos_1 "pos_1"
+               OpName %vertex_point_size "vertex_point_size"
+               OpName %col1_2 "col1_2"
+               OpName %col2_2 "col2_2"
+               OpName %pos_2 "pos_2"
+               OpName %Interface "Interface"
+               OpMemberName %Interface 0 "col1"
+               OpMemberName %Interface 1 "col2"
+               OpMemberName %Interface 2 "pos"
+               OpName %vert_main_inner "vert_main_inner"
+               OpName %vert_main "vert_main"
+               OpName %frag_main_inner "frag_main_inner"
+               OpName %colors "colors"
+               OpName %frag_main "frag_main"
+               OpDecorate %col1_1 Location 1
+               OpDecorate %col2_1 Location 2
+               OpDecorate %pos_1 BuiltIn Position
+               OpDecorate %vertex_point_size BuiltIn PointSize
+               OpDecorate %col1_2 Location 1
+               OpDecorate %col2_2 Location 2
+               OpDecorate %pos_2 BuiltIn FragCoord
+               OpMemberDecorate %Interface 0 Offset 0
+               OpMemberDecorate %Interface 1 Offset 4
+               OpMemberDecorate %Interface 2 Offset 16
+      %float = OpTypeFloat 32
+%_ptr_Output_float = OpTypePointer Output %float
+          %4 = OpConstantNull %float
+     %col1_1 = OpVariable %_ptr_Output_float Output %4
+       %half = OpTypeFloat 16
+%_ptr_Output_half = OpTypePointer Output %half
+          %8 = OpConstantNull %half
+     %col2_1 = OpVariable %_ptr_Output_half Output %8
+    %v4float = OpTypeVector %float 4
+%_ptr_Output_v4float = OpTypePointer Output %v4float
+         %12 = OpConstantNull %v4float
+      %pos_1 = OpVariable %_ptr_Output_v4float Output %12
+%vertex_point_size = OpVariable %_ptr_Output_float Output %4
+%_ptr_Input_float = OpTypePointer Input %float
+     %col1_2 = OpVariable %_ptr_Input_float Input
+%_ptr_Input_half = OpTypePointer Input %half
+     %col2_2 = OpVariable %_ptr_Input_half Input
+%_ptr_Input_v4float = OpTypePointer Input %v4float
+      %pos_2 = OpVariable %_ptr_Input_v4float Input
+  %Interface = OpTypeStruct %float %half %v4float
+         %20 = OpTypeFunction %Interface
+%float_0_400000006 = OpConstant %float 0.400000006
+%half_0x1_33pn1 = OpConstant %half 0x1.33p-1
+         %26 = OpConstantComposite %Interface %float_0_400000006 %half_0x1_33pn1 %12
+       %void = OpTypeVoid
+         %27 = OpTypeFunction %void
+    %float_1 = OpConstant %float 1
+         %36 = OpTypeFunction %void %Interface
+%vert_main_inner = OpFunction %Interface None %20
+         %23 = OpLabel
+               OpReturnValue %26
+               OpFunctionEnd
+  %vert_main = OpFunction %void None %27
+         %30 = OpLabel
+         %31 = OpFunctionCall %Interface %vert_main_inner
+         %32 = OpCompositeExtract %float %31 0
+               OpStore %col1_1 %32
+         %33 = OpCompositeExtract %half %31 1
+               OpStore %col2_1 %33
+         %34 = OpCompositeExtract %v4float %31 2
+               OpStore %pos_1 %34
+               OpStore %vertex_point_size %float_1
+               OpReturn
+               OpFunctionEnd
+%frag_main_inner = OpFunction %void None %36
+     %colors = OpFunctionParameter %Interface
+         %39 = OpLabel
+         %40 = OpCompositeExtract %float %colors 0
+         %41 = OpCompositeExtract %half %colors 1
+               OpReturn
+               OpFunctionEnd
+  %frag_main = OpFunction %void None %27
+         %43 = OpLabel
+         %45 = OpLoad %float %col1_2
+         %46 = OpLoad %half %col2_2
+         %47 = OpLoad %v4float %pos_2
+         %48 = OpCompositeConstruct %Interface %45 %46 %47
+         %44 = OpFunctionCall %void %frag_main_inner %48
+               OpReturn
+               OpFunctionEnd
diff --git a/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.wgsl b/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.wgsl
new file mode 100644
index 0000000..44c3dc6
--- /dev/null
+++ b/test/tint/shader_io/shared_struct_different_stages_f16.wgsl.expected.wgsl
@@ -0,0 +1,21 @@
+enable f16;
+
+struct Interface {
+  @location(1)
+  col1 : f32,
+  @location(2)
+  col2 : f16,
+  @builtin(position)
+  pos : vec4<f32>,
+}
+
+@vertex
+fn vert_main() -> Interface {
+  return Interface(0.4, 0.599609375h, vec4<f32>());
+}
+
+@fragment
+fn frag_main(colors : Interface) {
+  let r : f32 = colors.col1;
+  let g : f16 = colors.col2;
+}
diff --git a/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl b/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl
new file mode 100644
index 0000000..43b3231
--- /dev/null
+++ b/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl
@@ -0,0 +1,22 @@
+enable f16;
+
+struct S {
+  @align(64) @location(0) f : f32,
+  @size(32) @location(1) @interpolate(flat) u : u32,
+  @align(128) @builtin(position) v : vec4<f32>,
+  @align(32) @location(2) x : f16,
+  @align(64) @location(3) y : vec3<f16>,
+};
+
+@group(0) @binding(0)
+var<storage, read_write> output : S;
+
+@fragment
+fn frag_main(input : S) {
+  let f : f32 = input.f;
+  let u : u32 = input.u;
+  let v : vec4<f32> = input.v;
+  let x : f16 = input.x;
+  let y : vec3<f16> = input.y;
+  output = input;
+}
diff --git a/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.dxc.hlsl b/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.dxc.hlsl
new file mode 100644
index 0000000..614cc72
--- /dev/null
+++ b/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.dxc.hlsl
@@ -0,0 +1,40 @@
+struct S {
+  float f;
+  uint u;
+  float4 v;
+  float16_t x;
+  vector<float16_t, 3> y;
+};
+
+RWByteAddressBuffer output : register(u0, space0);
+
+struct tint_symbol_1 {
+  float f : TEXCOORD0;
+  nointerpolation uint u : TEXCOORD1;
+  float16_t x : TEXCOORD2;
+  vector<float16_t, 3> y : TEXCOORD3;
+  float4 v : SV_Position;
+};
+
+void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, S value) {
+  buffer.Store((offset + 0u), asuint(value.f));
+  buffer.Store((offset + 4u), asuint(value.u));
+  buffer.Store4((offset + 128u), asuint(value.v));
+  buffer.Store<float16_t>((offset + 160u), value.x);
+  buffer.Store<vector<float16_t, 3> >((offset + 192u), value.y);
+}
+
+void frag_main_inner(S input) {
+  const float f = input.f;
+  const uint u = input.u;
+  const float4 v = input.v;
+  const float16_t x = input.x;
+  const vector<float16_t, 3> y = input.y;
+  tint_symbol_2(output, 0u, input);
+}
+
+void frag_main(tint_symbol_1 tint_symbol) {
+  const S tint_symbol_8 = {tint_symbol.f, tint_symbol.u, tint_symbol.v, tint_symbol.x, tint_symbol.y};
+  frag_main_inner(tint_symbol_8);
+  return;
+}
diff --git a/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.fxc.hlsl b/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.fxc.hlsl
new file mode 100644
index 0000000..10c2dfe
--- /dev/null
+++ b/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.fxc.hlsl
@@ -0,0 +1,45 @@
+SKIP: FAILED
+
+struct S {
+  float f;
+  uint u;
+  float4 v;
+  float16_t x;
+  vector<float16_t, 3> y;
+};
+
+RWByteAddressBuffer output : register(u0, space0);
+
+struct tint_symbol_1 {
+  float f : TEXCOORD0;
+  nointerpolation uint u : TEXCOORD1;
+  float16_t x : TEXCOORD2;
+  vector<float16_t, 3> y : TEXCOORD3;
+  float4 v : SV_Position;
+};
+
+void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, S value) {
+  buffer.Store((offset + 0u), asuint(value.f));
+  buffer.Store((offset + 4u), asuint(value.u));
+  buffer.Store4((offset + 128u), asuint(value.v));
+  buffer.Store<float16_t>((offset + 160u), value.x);
+  buffer.Store<vector<float16_t, 3> >((offset + 192u), value.y);
+}
+
+void frag_main_inner(S input) {
+  const float f = input.f;
+  const uint u = input.u;
+  const float4 v = input.v;
+  const float16_t x = input.x;
+  const vector<float16_t, 3> y = input.y;
+  tint_symbol_2(output, 0u, input);
+}
+
+void frag_main(tint_symbol_1 tint_symbol) {
+  const S tint_symbol_8 = {tint_symbol.f, tint_symbol.u, tint_symbol.v, tint_symbol.x, tint_symbol.y};
+  frag_main_inner(tint_symbol_8);
+  return;
+}
+FXC validation failure:
+D:\Projects\RampUp\dawn\test\tint\shader_io\Shader@0x00000223CE4E5B80(5,3-11): error X3000: unrecognized identifier 'float16_t'
+
diff --git a/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.glsl b/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.glsl
new file mode 100644
index 0000000..ad5e592
--- /dev/null
+++ b/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.glsl
@@ -0,0 +1,89 @@
+#version 310 es
+#extension GL_AMD_gpu_shader_half_float : require
+precision mediump float;
+
+layout(location = 0) in float f_1;
+layout(location = 1) flat in uint u_1;
+layout(location = 2) in float16_t x_1;
+layout(location = 3) in f16vec3 y_1;
+struct S {
+  float f;
+  uint u;
+  uint pad;
+  uint pad_1;
+  uint pad_2;
+  uint pad_3;
+  uint pad_4;
+  uint pad_5;
+  uint pad_6;
+  uint pad_7;
+  uint pad_8;
+  uint pad_9;
+  uint pad_10;
+  uint pad_11;
+  uint pad_12;
+  uint pad_13;
+  uint pad_14;
+  uint pad_15;
+  uint pad_16;
+  uint pad_17;
+  uint pad_18;
+  uint pad_19;
+  uint pad_20;
+  uint pad_21;
+  uint pad_22;
+  uint pad_23;
+  uint pad_24;
+  uint pad_25;
+  uint pad_26;
+  uint pad_27;
+  uint pad_28;
+  uint pad_29;
+  vec4 v;
+  uint pad_30;
+  uint pad_31;
+  uint pad_32;
+  uint pad_33;
+  float16_t x;
+  uint pad_34;
+  uint pad_35;
+  uint pad_36;
+  uint pad_37;
+  uint pad_38;
+  uint pad_39;
+  uint pad_40;
+  f16vec3 y;
+  uint pad_41;
+  uint pad_42;
+  uint pad_43;
+  uint pad_44;
+  uint pad_45;
+  uint pad_46;
+  uint pad_47;
+  uint pad_48;
+  uint pad_49;
+  uint pad_50;
+  uint pad_51;
+  uint pad_52;
+  uint pad_53;
+  uint pad_54;
+};
+
+layout(binding = 0, std430) buffer tint_symbol_block_ssbo {
+  S inner;
+} tint_symbol;
+
+void frag_main(S tint_symbol_1) {
+  float f = tint_symbol_1.f;
+  uint u = tint_symbol_1.u;
+  vec4 v = tint_symbol_1.v;
+  float16_t x = tint_symbol_1.x;
+  f16vec3 y = tint_symbol_1.y;
+  tint_symbol.inner = tint_symbol_1;
+}
+
+void main() {
+  S tint_symbol_2 = S(f_1, u_1, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, gl_FragCoord, 0u, 0u, 0u, 0u, x_1, 0u, 0u, 0u, 0u, 0u, 0u, 0u, y_1, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u);
+  frag_main(tint_symbol_2);
+  return;
+}
diff --git a/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.msl b/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.msl
new file mode 100644
index 0000000..ad33a2a
--- /dev/null
+++ b/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.msl
@@ -0,0 +1,50 @@
+#include <metal_stdlib>
+
+using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
+struct S {
+  /* 0x0000 */ float f;
+  /* 0x0004 */ uint u;
+  /* 0x0008 */ tint_array<int8_t, 120> tint_pad;
+  /* 0x0080 */ float4 v;
+  /* 0x0090 */ tint_array<int8_t, 16> tint_pad_1;
+  /* 0x00a0 */ half x;
+  /* 0x00a2 */ tint_array<int8_t, 30> tint_pad_2;
+  /* 0x00c0 */ packed_half3 y;
+  /* 0x00c6 */ tint_array<int8_t, 58> tint_pad_3;
+};
+
+struct tint_symbol_1 {
+  float f [[user(locn0)]];
+  uint u [[user(locn1)]] [[flat]];
+  half x [[user(locn2)]];
+  half3 y [[user(locn3)]];
+};
+
+void frag_main_inner(S input, device S* const tint_symbol_3) {
+  float const f = input.f;
+  uint const u = input.u;
+  float4 const v = input.v;
+  half const x = input.x;
+  half3 const y = half3(input.y);
+  *(tint_symbol_3) = input;
+}
+
+fragment void frag_main(device S* tint_symbol_4 [[buffer(0)]], float4 v [[position]], tint_symbol_1 tint_symbol [[stage_in]]) {
+  S const tint_symbol_2 = {.f=tint_symbol.f, .u=tint_symbol.u, .v=v, .x=tint_symbol.x, .y=tint_symbol.y};
+  frag_main_inner(tint_symbol_2, tint_symbol_4);
+  return;
+}
+
diff --git a/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.spvasm b/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.spvasm
new file mode 100644
index 0000000..52ab2f6
--- /dev/null
+++ b/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.spvasm
@@ -0,0 +1,92 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 43
+; Schema: 0
+               OpCapability Shader
+               OpCapability Float16
+               OpCapability UniformAndStorageBuffer16BitAccess
+               OpCapability StorageBuffer16BitAccess
+               OpCapability StorageInputOutput16
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %frag_main "frag_main" %f_1 %u_1 %v_1 %x_1 %y_1
+               OpExecutionMode %frag_main OriginUpperLeft
+               OpName %f_1 "f_1"
+               OpName %u_1 "u_1"
+               OpName %v_1 "v_1"
+               OpName %x_1 "x_1"
+               OpName %y_1 "y_1"
+               OpName %output_block "output_block"
+               OpMemberName %output_block 0 "inner"
+               OpName %S "S"
+               OpMemberName %S 0 "f"
+               OpMemberName %S 1 "u"
+               OpMemberName %S 2 "v"
+               OpMemberName %S 3 "x"
+               OpMemberName %S 4 "y"
+               OpName %output "output"
+               OpName %frag_main_inner "frag_main_inner"
+               OpName %input "input"
+               OpName %frag_main "frag_main"
+               OpDecorate %f_1 Location 0
+               OpDecorate %u_1 Location 1
+               OpDecorate %u_1 Flat
+               OpDecorate %v_1 BuiltIn FragCoord
+               OpDecorate %x_1 Location 2
+               OpDecorate %y_1 Location 3
+               OpDecorate %output_block Block
+               OpMemberDecorate %output_block 0 Offset 0
+               OpMemberDecorate %S 0 Offset 0
+               OpMemberDecorate %S 1 Offset 4
+               OpMemberDecorate %S 2 Offset 128
+               OpMemberDecorate %S 3 Offset 160
+               OpMemberDecorate %S 4 Offset 192
+               OpDecorate %output DescriptorSet 0
+               OpDecorate %output Binding 0
+      %float = OpTypeFloat 32
+%_ptr_Input_float = OpTypePointer Input %float
+        %f_1 = OpVariable %_ptr_Input_float Input
+       %uint = OpTypeInt 32 0
+%_ptr_Input_uint = OpTypePointer Input %uint
+        %u_1 = OpVariable %_ptr_Input_uint Input
+    %v4float = OpTypeVector %float 4
+%_ptr_Input_v4float = OpTypePointer Input %v4float
+        %v_1 = OpVariable %_ptr_Input_v4float Input
+       %half = OpTypeFloat 16
+%_ptr_Input_half = OpTypePointer Input %half
+        %x_1 = OpVariable %_ptr_Input_half Input
+     %v3half = OpTypeVector %half 3
+%_ptr_Input_v3half = OpTypePointer Input %v3half
+        %y_1 = OpVariable %_ptr_Input_v3half Input
+          %S = OpTypeStruct %float %uint %v4float %half %v3half
+%output_block = OpTypeStruct %S
+%_ptr_StorageBuffer_output_block = OpTypePointer StorageBuffer %output_block
+     %output = OpVariable %_ptr_StorageBuffer_output_block StorageBuffer
+       %void = OpTypeVoid
+         %20 = OpTypeFunction %void %S
+     %uint_0 = OpConstant %uint 0
+%_ptr_StorageBuffer_S = OpTypePointer StorageBuffer %S
+         %33 = OpTypeFunction %void
+%frag_main_inner = OpFunction %void None %20
+      %input = OpFunctionParameter %S
+         %24 = OpLabel
+         %25 = OpCompositeExtract %float %input 0
+         %26 = OpCompositeExtract %uint %input 1
+         %27 = OpCompositeExtract %v4float %input 2
+         %28 = OpCompositeExtract %half %input 3
+         %29 = OpCompositeExtract %v3half %input 4
+         %32 = OpAccessChain %_ptr_StorageBuffer_S %output %uint_0
+               OpStore %32 %input
+               OpReturn
+               OpFunctionEnd
+  %frag_main = OpFunction %void None %33
+         %35 = OpLabel
+         %37 = OpLoad %float %f_1
+         %38 = OpLoad %uint %u_1
+         %39 = OpLoad %v4float %v_1
+         %40 = OpLoad %half %x_1
+         %41 = OpLoad %v3half %y_1
+         %42 = OpCompositeConstruct %S %37 %38 %39 %40 %41
+         %36 = OpFunctionCall %void %frag_main_inner %42
+               OpReturn
+               OpFunctionEnd
diff --git a/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.wgsl b/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.wgsl
new file mode 100644
index 0000000..f1bbc34
--- /dev/null
+++ b/test/tint/shader_io/shared_struct_storage_buffer_f16.wgsl.expected.wgsl
@@ -0,0 +1,26 @@
+enable f16;
+
+struct S {
+  @align(64) @location(0)
+  f : f32,
+  @size(32) @location(1) @interpolate(flat)
+  u : u32,
+  @align(128) @builtin(position)
+  v : vec4<f32>,
+  @align(32) @location(2)
+  x : f16,
+  @align(64) @location(3)
+  y : vec3<f16>,
+}
+
+@group(0) @binding(0) var<storage, read_write> output : S;
+
+@fragment
+fn frag_main(input : S) {
+  let f : f32 = input.f;
+  let u : u32 = input.u;
+  let v : vec4<f32> = input.v;
+  let x : f16 = input.x;
+  let y : vec3<f16> = input.y;
+  output = input;
+}
diff --git a/test/tint/shader_io/vertex_input_locations_f16.wgsl b/test/tint/shader_io/vertex_input_locations_f16.wgsl
new file mode 100644
index 0000000..231bc4e5
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_locations_f16.wgsl
@@ -0,0 +1,19 @@
+enable f16;
+
+@vertex
+fn main(
+  @location(0) loc0 : i32,
+  @location(1) loc1 : u32,
+  @location(2) loc2 : f32,
+  @location(3) loc3 : vec4<f32>,
+  @location(4) loc4 : f16,
+  @location(5) loc5 : vec3<f16>,
+) -> @builtin(position) vec4<f32> {
+  let i : i32 = loc0;
+  let u : u32 = loc1;
+  let f : f32 = loc2;
+  let v : vec4<f32> = loc3;
+  let x : f16 = loc4;
+  let y : vec3<f16> = loc5;
+  return vec4<f32>();
+}
diff --git a/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.dxc.hlsl b/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.dxc.hlsl
new file mode 100644
index 0000000..6962a01
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.dxc.hlsl
@@ -0,0 +1,28 @@
+struct tint_symbol_1 {
+  int loc0 : TEXCOORD0;
+  uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+  float16_t loc4 : TEXCOORD4;
+  vector<float16_t, 3> loc5 : TEXCOORD5;
+};
+struct tint_symbol_2 {
+  float4 value : SV_Position;
+};
+
+float4 main_inner(int loc0, uint loc1, float loc2, float4 loc3, float16_t loc4, vector<float16_t, 3> loc5) {
+  const int i = loc0;
+  const uint u = loc1;
+  const float f = loc2;
+  const float4 v = loc3;
+  const float16_t x = loc4;
+  const vector<float16_t, 3> y = loc5;
+  return (0.0f).xxxx;
+}
+
+tint_symbol_2 main(tint_symbol_1 tint_symbol) {
+  const float4 inner_result = main_inner(tint_symbol.loc0, tint_symbol.loc1, tint_symbol.loc2, tint_symbol.loc3, tint_symbol.loc4, tint_symbol.loc5);
+  tint_symbol_2 wrapper_result = (tint_symbol_2)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
diff --git a/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.fxc.hlsl b/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.fxc.hlsl
new file mode 100644
index 0000000..622d2fb
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.fxc.hlsl
@@ -0,0 +1,33 @@
+SKIP: FAILED
+
+struct tint_symbol_1 {
+  int loc0 : TEXCOORD0;
+  uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+  float16_t loc4 : TEXCOORD4;
+  vector<float16_t, 3> loc5 : TEXCOORD5;
+};
+struct tint_symbol_2 {
+  float4 value : SV_Position;
+};
+
+float4 main_inner(int loc0, uint loc1, float loc2, float4 loc3, float16_t loc4, vector<float16_t, 3> loc5) {
+  const int i = loc0;
+  const uint u = loc1;
+  const float f = loc2;
+  const float4 v = loc3;
+  const float16_t x = loc4;
+  const vector<float16_t, 3> y = loc5;
+  return (0.0f).xxxx;
+}
+
+tint_symbol_2 main(tint_symbol_1 tint_symbol) {
+  const float4 inner_result = main_inner(tint_symbol.loc0, tint_symbol.loc1, tint_symbol.loc2, tint_symbol.loc3, tint_symbol.loc4, tint_symbol.loc5);
+  tint_symbol_2 wrapper_result = (tint_symbol_2)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
+FXC validation failure:
+D:\Projects\RampUp\dawn\test\tint\shader_io\Shader@0x0000016E3C1012A0(6,3-11): error X3000: unrecognized identifier 'float16_t'
+
diff --git a/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.glsl b/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.glsl
new file mode 100644
index 0000000..7b5aff3
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.glsl
@@ -0,0 +1,27 @@
+#version 310 es
+#extension GL_AMD_gpu_shader_half_float : require
+
+layout(location = 0) in int loc0_1;
+layout(location = 1) in uint loc1_1;
+layout(location = 2) in float loc2_1;
+layout(location = 3) in vec4 loc3_1;
+layout(location = 4) in float16_t loc4_1;
+layout(location = 5) in f16vec3 loc5_1;
+vec4 tint_symbol(int loc0, uint loc1, float loc2, vec4 loc3, float16_t loc4, f16vec3 loc5) {
+  int i = loc0;
+  uint u = loc1;
+  float f = loc2;
+  vec4 v = loc3;
+  float16_t x = loc4;
+  f16vec3 y = loc5;
+  return vec4(0.0f);
+}
+
+void main() {
+  gl_PointSize = 1.0;
+  vec4 inner_result = tint_symbol(loc0_1, loc1_1, loc2_1, loc3_1, loc4_1, loc5_1);
+  gl_Position = inner_result;
+  gl_Position.y = -(gl_Position.y);
+  gl_Position.z = ((2.0f * gl_Position.z) - gl_Position.w);
+  return;
+}
diff --git a/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.msl b/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.msl
new file mode 100644
index 0000000..7c07f6a
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.msl
@@ -0,0 +1,33 @@
+#include <metal_stdlib>
+
+using namespace metal;
+struct tint_symbol_2 {
+  int loc0 [[attribute(0)]];
+  uint loc1 [[attribute(1)]];
+  float loc2 [[attribute(2)]];
+  float4 loc3 [[attribute(3)]];
+  half loc4 [[attribute(4)]];
+  half3 loc5 [[attribute(5)]];
+};
+
+struct tint_symbol_3 {
+  float4 value [[position]];
+};
+
+float4 tint_symbol_inner(int loc0, uint loc1, float loc2, float4 loc3, half loc4, half3 loc5) {
+  int const i = loc0;
+  uint const u = loc1;
+  float const f = loc2;
+  float4 const v = loc3;
+  half const x = loc4;
+  half3 const y = loc5;
+  return float4(0.0f);
+}
+
+vertex tint_symbol_3 tint_symbol(tint_symbol_2 tint_symbol_1 [[stage_in]]) {
+  float4 const inner_result = tint_symbol_inner(tint_symbol_1.loc0, tint_symbol_1.loc1, tint_symbol_1.loc2, tint_symbol_1.loc3, tint_symbol_1.loc4, tint_symbol_1.loc5);
+  tint_symbol_3 wrapper_result = {};
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
+
diff --git a/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.spvasm b/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.spvasm
new file mode 100644
index 0000000..bf24647
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.spvasm
@@ -0,0 +1,87 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 46
+; Schema: 0
+               OpCapability Shader
+               OpCapability Float16
+               OpCapability UniformAndStorageBuffer16BitAccess
+               OpCapability StorageBuffer16BitAccess
+               OpCapability StorageInputOutput16
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Vertex %main "main" %loc0_1 %loc1_1 %loc2_1 %loc3_1 %loc4_1 %loc5_1 %value %vertex_point_size
+               OpName %loc0_1 "loc0_1"
+               OpName %loc1_1 "loc1_1"
+               OpName %loc2_1 "loc2_1"
+               OpName %loc3_1 "loc3_1"
+               OpName %loc4_1 "loc4_1"
+               OpName %loc5_1 "loc5_1"
+               OpName %value "value"
+               OpName %vertex_point_size "vertex_point_size"
+               OpName %main_inner "main_inner"
+               OpName %loc0 "loc0"
+               OpName %loc1 "loc1"
+               OpName %loc2 "loc2"
+               OpName %loc3 "loc3"
+               OpName %loc4 "loc4"
+               OpName %loc5 "loc5"
+               OpName %main "main"
+               OpDecorate %loc0_1 Location 0
+               OpDecorate %loc1_1 Location 1
+               OpDecorate %loc2_1 Location 2
+               OpDecorate %loc3_1 Location 3
+               OpDecorate %loc4_1 Location 4
+               OpDecorate %loc5_1 Location 5
+               OpDecorate %value BuiltIn Position
+               OpDecorate %vertex_point_size BuiltIn PointSize
+        %int = OpTypeInt 32 1
+%_ptr_Input_int = OpTypePointer Input %int
+     %loc0_1 = OpVariable %_ptr_Input_int Input
+       %uint = OpTypeInt 32 0
+%_ptr_Input_uint = OpTypePointer Input %uint
+     %loc1_1 = OpVariable %_ptr_Input_uint Input
+      %float = OpTypeFloat 32
+%_ptr_Input_float = OpTypePointer Input %float
+     %loc2_1 = OpVariable %_ptr_Input_float Input
+    %v4float = OpTypeVector %float 4
+%_ptr_Input_v4float = OpTypePointer Input %v4float
+     %loc3_1 = OpVariable %_ptr_Input_v4float Input
+       %half = OpTypeFloat 16
+%_ptr_Input_half = OpTypePointer Input %half
+     %loc4_1 = OpVariable %_ptr_Input_half Input
+     %v3half = OpTypeVector %half 3
+%_ptr_Input_v3half = OpTypePointer Input %v3half
+     %loc5_1 = OpVariable %_ptr_Input_v3half Input
+%_ptr_Output_v4float = OpTypePointer Output %v4float
+         %21 = OpConstantNull %v4float
+      %value = OpVariable %_ptr_Output_v4float Output %21
+%_ptr_Output_float = OpTypePointer Output %float
+         %24 = OpConstantNull %float
+%vertex_point_size = OpVariable %_ptr_Output_float Output %24
+         %25 = OpTypeFunction %v4float %int %uint %float %v4float %half %v3half
+       %void = OpTypeVoid
+         %34 = OpTypeFunction %void
+    %float_1 = OpConstant %float 1
+ %main_inner = OpFunction %v4float None %25
+       %loc0 = OpFunctionParameter %int
+       %loc1 = OpFunctionParameter %uint
+       %loc2 = OpFunctionParameter %float
+       %loc3 = OpFunctionParameter %v4float
+       %loc4 = OpFunctionParameter %half
+       %loc5 = OpFunctionParameter %v3half
+         %33 = OpLabel
+               OpReturnValue %21
+               OpFunctionEnd
+       %main = OpFunction %void None %34
+         %37 = OpLabel
+         %39 = OpLoad %int %loc0_1
+         %40 = OpLoad %uint %loc1_1
+         %41 = OpLoad %float %loc2_1
+         %42 = OpLoad %v4float %loc3_1
+         %43 = OpLoad %half %loc4_1
+         %44 = OpLoad %v3half %loc5_1
+         %38 = OpFunctionCall %v4float %main_inner %39 %40 %41 %42 %43 %44
+               OpStore %value %38
+               OpStore %vertex_point_size %float_1
+               OpReturn
+               OpFunctionEnd
diff --git a/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.wgsl b/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.wgsl
new file mode 100644
index 0000000..8a4c606
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_locations_f16.wgsl.expected.wgsl
@@ -0,0 +1,12 @@
+enable f16;
+
+@vertex
+fn main(@location(0) loc0 : i32, @location(1) loc1 : u32, @location(2) loc2 : f32, @location(3) loc3 : vec4<f32>, @location(4) loc4 : f16, @location(5) loc5 : vec3<f16>) -> @builtin(position) vec4<f32> {
+  let i : i32 = loc0;
+  let u : u32 = loc1;
+  let f : f32 = loc2;
+  let v : vec4<f32> = loc3;
+  let x : f16 = loc4;
+  let y : vec3<f16> = loc5;
+  return vec4<f32>();
+}
diff --git a/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl b/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl
new file mode 100644
index 0000000..5c85329
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl
@@ -0,0 +1,21 @@
+enable f16;
+
+struct VertexInputs {
+  @location(0) loc0 : i32,
+  @location(1) loc1 : u32,
+  @location(2) loc2 : f32,
+  @location(3) loc3 : vec4<f32>,
+  @location(4) loc4 : f16,
+  @location(5) loc5 : vec3<f16>,
+};
+
+@vertex
+fn main(inputs : VertexInputs) -> @builtin(position) vec4<f32> {
+  let i : i32 = inputs.loc0;
+  let u : u32 = inputs.loc1;
+  let f : f32 = inputs.loc2;
+  let v : vec4<f32> = inputs.loc3;
+  let x : f16 = inputs.loc4;
+  let y : vec3<f16> = inputs.loc5;
+  return vec4<f32>();
+}
diff --git a/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.dxc.hlsl b/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.dxc.hlsl
new file mode 100644
index 0000000..dcb2c0d
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.dxc.hlsl
@@ -0,0 +1,37 @@
+struct VertexInputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  float4 loc3;
+  float16_t loc4;
+  vector<float16_t, 3> loc5;
+};
+struct tint_symbol_1 {
+  int loc0 : TEXCOORD0;
+  uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+  float16_t loc4 : TEXCOORD4;
+  vector<float16_t, 3> loc5 : TEXCOORD5;
+};
+struct tint_symbol_2 {
+  float4 value : SV_Position;
+};
+
+float4 main_inner(VertexInputs inputs) {
+  const int i = inputs.loc0;
+  const uint u = inputs.loc1;
+  const float f = inputs.loc2;
+  const float4 v = inputs.loc3;
+  const float16_t x = inputs.loc4;
+  const vector<float16_t, 3> y = inputs.loc5;
+  return (0.0f).xxxx;
+}
+
+tint_symbol_2 main(tint_symbol_1 tint_symbol) {
+  const VertexInputs tint_symbol_3 = {tint_symbol.loc0, tint_symbol.loc1, tint_symbol.loc2, tint_symbol.loc3, tint_symbol.loc4, tint_symbol.loc5};
+  const float4 inner_result = main_inner(tint_symbol_3);
+  tint_symbol_2 wrapper_result = (tint_symbol_2)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
diff --git a/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.fxc.hlsl b/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.fxc.hlsl
new file mode 100644
index 0000000..fcb2564
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.fxc.hlsl
@@ -0,0 +1,42 @@
+SKIP: FAILED
+
+struct VertexInputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  float4 loc3;
+  float16_t loc4;
+  vector<float16_t, 3> loc5;
+};
+struct tint_symbol_1 {
+  int loc0 : TEXCOORD0;
+  uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+  float16_t loc4 : TEXCOORD4;
+  vector<float16_t, 3> loc5 : TEXCOORD5;
+};
+struct tint_symbol_2 {
+  float4 value : SV_Position;
+};
+
+float4 main_inner(VertexInputs inputs) {
+  const int i = inputs.loc0;
+  const uint u = inputs.loc1;
+  const float f = inputs.loc2;
+  const float4 v = inputs.loc3;
+  const float16_t x = inputs.loc4;
+  const vector<float16_t, 3> y = inputs.loc5;
+  return (0.0f).xxxx;
+}
+
+tint_symbol_2 main(tint_symbol_1 tint_symbol) {
+  const VertexInputs tint_symbol_3 = {tint_symbol.loc0, tint_symbol.loc1, tint_symbol.loc2, tint_symbol.loc3, tint_symbol.loc4, tint_symbol.loc5};
+  const float4 inner_result = main_inner(tint_symbol_3);
+  tint_symbol_2 wrapper_result = (tint_symbol_2)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
+FXC validation failure:
+D:\Projects\RampUp\dawn\test\tint\shader_io\Shader@0x0000014EC0050950(6,3-11): error X3000: unrecognized identifier 'float16_t'
+
diff --git a/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.glsl b/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.glsl
new file mode 100644
index 0000000..a1f168b
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.glsl
@@ -0,0 +1,37 @@
+#version 310 es
+#extension GL_AMD_gpu_shader_half_float : require
+
+layout(location = 0) in int loc0_1;
+layout(location = 1) in uint loc1_1;
+layout(location = 2) in float loc2_1;
+layout(location = 3) in vec4 loc3_1;
+layout(location = 4) in float16_t loc4_1;
+layout(location = 5) in f16vec3 loc5_1;
+struct VertexInputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  vec4 loc3;
+  float16_t loc4;
+  f16vec3 loc5;
+};
+
+vec4 tint_symbol(VertexInputs inputs) {
+  int i = inputs.loc0;
+  uint u = inputs.loc1;
+  float f = inputs.loc2;
+  vec4 v = inputs.loc3;
+  float16_t x = inputs.loc4;
+  f16vec3 y = inputs.loc5;
+  return vec4(0.0f);
+}
+
+void main() {
+  gl_PointSize = 1.0;
+  VertexInputs tint_symbol_1 = VertexInputs(loc0_1, loc1_1, loc2_1, loc3_1, loc4_1, loc5_1);
+  vec4 inner_result = tint_symbol(tint_symbol_1);
+  gl_Position = inner_result;
+  gl_Position.y = -(gl_Position.y);
+  gl_Position.z = ((2.0f * gl_Position.z) - gl_Position.w);
+  return;
+}
diff --git a/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.msl b/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.msl
new file mode 100644
index 0000000..31a38fa
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.msl
@@ -0,0 +1,43 @@
+#include <metal_stdlib>
+
+using namespace metal;
+struct VertexInputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  float4 loc3;
+  half loc4;
+  half3 loc5;
+};
+
+struct tint_symbol_2 {
+  int loc0 [[attribute(0)]];
+  uint loc1 [[attribute(1)]];
+  float loc2 [[attribute(2)]];
+  float4 loc3 [[attribute(3)]];
+  half loc4 [[attribute(4)]];
+  half3 loc5 [[attribute(5)]];
+};
+
+struct tint_symbol_3 {
+  float4 value [[position]];
+};
+
+float4 tint_symbol_inner(VertexInputs inputs) {
+  int const i = inputs.loc0;
+  uint const u = inputs.loc1;
+  float const f = inputs.loc2;
+  float4 const v = inputs.loc3;
+  half const x = inputs.loc4;
+  half3 const y = inputs.loc5;
+  return float4(0.0f);
+}
+
+vertex tint_symbol_3 tint_symbol(tint_symbol_2 tint_symbol_1 [[stage_in]]) {
+  VertexInputs const tint_symbol_4 = {.loc0=tint_symbol_1.loc0, .loc1=tint_symbol_1.loc1, .loc2=tint_symbol_1.loc2, .loc3=tint_symbol_1.loc3, .loc4=tint_symbol_1.loc4, .loc5=tint_symbol_1.loc5};
+  float4 const inner_result = tint_symbol_inner(tint_symbol_4);
+  tint_symbol_3 wrapper_result = {};
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
+
diff --git a/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.spvasm b/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.spvasm
new file mode 100644
index 0000000..a9c083c
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.spvasm
@@ -0,0 +1,98 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 49
+; Schema: 0
+               OpCapability Shader
+               OpCapability Float16
+               OpCapability UniformAndStorageBuffer16BitAccess
+               OpCapability StorageBuffer16BitAccess
+               OpCapability StorageInputOutput16
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Vertex %main "main" %loc0_1 %loc1_1 %loc2_1 %loc3_1 %loc4_1 %loc5_1 %value %vertex_point_size
+               OpName %loc0_1 "loc0_1"
+               OpName %loc1_1 "loc1_1"
+               OpName %loc2_1 "loc2_1"
+               OpName %loc3_1 "loc3_1"
+               OpName %loc4_1 "loc4_1"
+               OpName %loc5_1 "loc5_1"
+               OpName %value "value"
+               OpName %vertex_point_size "vertex_point_size"
+               OpName %VertexInputs "VertexInputs"
+               OpMemberName %VertexInputs 0 "loc0"
+               OpMemberName %VertexInputs 1 "loc1"
+               OpMemberName %VertexInputs 2 "loc2"
+               OpMemberName %VertexInputs 3 "loc3"
+               OpMemberName %VertexInputs 4 "loc4"
+               OpMemberName %VertexInputs 5 "loc5"
+               OpName %main_inner "main_inner"
+               OpName %inputs "inputs"
+               OpName %main "main"
+               OpDecorate %loc0_1 Location 0
+               OpDecorate %loc1_1 Location 1
+               OpDecorate %loc2_1 Location 2
+               OpDecorate %loc3_1 Location 3
+               OpDecorate %loc4_1 Location 4
+               OpDecorate %loc5_1 Location 5
+               OpDecorate %value BuiltIn Position
+               OpDecorate %vertex_point_size BuiltIn PointSize
+               OpMemberDecorate %VertexInputs 0 Offset 0
+               OpMemberDecorate %VertexInputs 1 Offset 4
+               OpMemberDecorate %VertexInputs 2 Offset 8
+               OpMemberDecorate %VertexInputs 3 Offset 16
+               OpMemberDecorate %VertexInputs 4 Offset 32
+               OpMemberDecorate %VertexInputs 5 Offset 40
+        %int = OpTypeInt 32 1
+%_ptr_Input_int = OpTypePointer Input %int
+     %loc0_1 = OpVariable %_ptr_Input_int Input
+       %uint = OpTypeInt 32 0
+%_ptr_Input_uint = OpTypePointer Input %uint
+     %loc1_1 = OpVariable %_ptr_Input_uint Input
+      %float = OpTypeFloat 32
+%_ptr_Input_float = OpTypePointer Input %float
+     %loc2_1 = OpVariable %_ptr_Input_float Input
+    %v4float = OpTypeVector %float 4
+%_ptr_Input_v4float = OpTypePointer Input %v4float
+     %loc3_1 = OpVariable %_ptr_Input_v4float Input
+       %half = OpTypeFloat 16
+%_ptr_Input_half = OpTypePointer Input %half
+     %loc4_1 = OpVariable %_ptr_Input_half Input
+     %v3half = OpTypeVector %half 3
+%_ptr_Input_v3half = OpTypePointer Input %v3half
+     %loc5_1 = OpVariable %_ptr_Input_v3half Input
+%_ptr_Output_v4float = OpTypePointer Output %v4float
+         %21 = OpConstantNull %v4float
+      %value = OpVariable %_ptr_Output_v4float Output %21
+%_ptr_Output_float = OpTypePointer Output %float
+         %24 = OpConstantNull %float
+%vertex_point_size = OpVariable %_ptr_Output_float Output %24
+%VertexInputs = OpTypeStruct %int %uint %float %v4float %half %v3half
+         %25 = OpTypeFunction %v4float %VertexInputs
+       %void = OpTypeVoid
+         %36 = OpTypeFunction %void
+    %float_1 = OpConstant %float 1
+ %main_inner = OpFunction %v4float None %25
+     %inputs = OpFunctionParameter %VertexInputs
+         %29 = OpLabel
+         %30 = OpCompositeExtract %int %inputs 0
+         %31 = OpCompositeExtract %uint %inputs 1
+         %32 = OpCompositeExtract %float %inputs 2
+         %33 = OpCompositeExtract %v4float %inputs 3
+         %34 = OpCompositeExtract %half %inputs 4
+         %35 = OpCompositeExtract %v3half %inputs 5
+               OpReturnValue %21
+               OpFunctionEnd
+       %main = OpFunction %void None %36
+         %39 = OpLabel
+         %41 = OpLoad %int %loc0_1
+         %42 = OpLoad %uint %loc1_1
+         %43 = OpLoad %float %loc2_1
+         %44 = OpLoad %v4float %loc3_1
+         %45 = OpLoad %half %loc4_1
+         %46 = OpLoad %v3half %loc5_1
+         %47 = OpCompositeConstruct %VertexInputs %41 %42 %43 %44 %45 %46
+         %40 = OpFunctionCall %v4float %main_inner %47
+               OpStore %value %40
+               OpStore %vertex_point_size %float_1
+               OpReturn
+               OpFunctionEnd
diff --git a/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.wgsl b/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.wgsl
new file mode 100644
index 0000000..784cbc9
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_locations_struct_f16.wgsl.expected.wgsl
@@ -0,0 +1,27 @@
+enable f16;
+
+struct VertexInputs {
+  @location(0)
+  loc0 : i32,
+  @location(1)
+  loc1 : u32,
+  @location(2)
+  loc2 : f32,
+  @location(3)
+  loc3 : vec4<f32>,
+  @location(4)
+  loc4 : f16,
+  @location(5)
+  loc5 : vec3<f16>,
+}
+
+@vertex
+fn main(inputs : VertexInputs) -> @builtin(position) vec4<f32> {
+  let i : i32 = inputs.loc0;
+  let u : u32 = inputs.loc1;
+  let f : f32 = inputs.loc2;
+  let v : vec4<f32> = inputs.loc3;
+  let x : f16 = inputs.loc4;
+  let y : vec3<f16> = inputs.loc5;
+  return vec4<f32>();
+}
diff --git a/test/tint/shader_io/vertex_input_mixed_f16.wgsl b/test/tint/shader_io/vertex_input_mixed_f16.wgsl
new file mode 100644
index 0000000..d7963a2
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_mixed_f16.wgsl
@@ -0,0 +1,29 @@
+enable f16;
+
+struct VertexInputs0 {
+  @builtin(vertex_index) vertex_index : u32,
+  @location(0) loc0 : i32,
+};
+struct VertexInputs1 {
+  @location(2) loc2 : f32,
+  @location(3) loc3 : vec4<f32>,
+  @location(5) loc5 : vec3<f16>,
+};
+
+@vertex
+fn main(
+  inputs0 : VertexInputs0,
+  @location(1) loc1 : u32,
+  @builtin(instance_index) instance_index : u32,
+  inputs1 : VertexInputs1,
+  @location(4) loc4 : f16,
+) -> @builtin(position) vec4<f32> {
+  let foo : u32 = inputs0.vertex_index + instance_index;
+  let i : i32 = inputs0.loc0;
+  let u : u32 = loc1;
+  let f : f32 = inputs1.loc2;
+  let v : vec4<f32> = inputs1.loc3;
+  let x : f16 = loc4;
+  let y : vec3<f16> = inputs1.loc5;
+  return vec4<f32>();
+}
diff --git a/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.dxc.hlsl b/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.dxc.hlsl
new file mode 100644
index 0000000..dfac345
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.dxc.hlsl
@@ -0,0 +1,42 @@
+struct VertexInputs0 {
+  uint vertex_index;
+  int loc0;
+};
+struct VertexInputs1 {
+  float loc2;
+  float4 loc3;
+  vector<float16_t, 3> loc5;
+};
+struct tint_symbol_1 {
+  int loc0 : TEXCOORD0;
+  uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+  float16_t loc4 : TEXCOORD4;
+  vector<float16_t, 3> loc5 : TEXCOORD5;
+  uint vertex_index : SV_VertexID;
+  uint instance_index : SV_InstanceID;
+};
+struct tint_symbol_2 {
+  float4 value : SV_Position;
+};
+
+float4 main_inner(VertexInputs0 inputs0, uint loc1, uint instance_index, VertexInputs1 inputs1, float16_t loc4) {
+  const uint foo = (inputs0.vertex_index + instance_index);
+  const int i = inputs0.loc0;
+  const uint u = loc1;
+  const float f = inputs1.loc2;
+  const float4 v = inputs1.loc3;
+  const float16_t x = loc4;
+  const vector<float16_t, 3> y = inputs1.loc5;
+  return (0.0f).xxxx;
+}
+
+tint_symbol_2 main(tint_symbol_1 tint_symbol) {
+  const VertexInputs0 tint_symbol_3 = {tint_symbol.vertex_index, tint_symbol.loc0};
+  const VertexInputs1 tint_symbol_4 = {tint_symbol.loc2, tint_symbol.loc3, tint_symbol.loc5};
+  const float4 inner_result = main_inner(tint_symbol_3, tint_symbol.loc1, tint_symbol.instance_index, tint_symbol_4, tint_symbol.loc4);
+  tint_symbol_2 wrapper_result = (tint_symbol_2)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
diff --git a/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.fxc.hlsl b/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.fxc.hlsl
new file mode 100644
index 0000000..d5ef1cf
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.fxc.hlsl
@@ -0,0 +1,47 @@
+SKIP: FAILED
+
+struct VertexInputs0 {
+  uint vertex_index;
+  int loc0;
+};
+struct VertexInputs1 {
+  float loc2;
+  float4 loc3;
+  vector<float16_t, 3> loc5;
+};
+struct tint_symbol_1 {
+  int loc0 : TEXCOORD0;
+  uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+  float16_t loc4 : TEXCOORD4;
+  vector<float16_t, 3> loc5 : TEXCOORD5;
+  uint vertex_index : SV_VertexID;
+  uint instance_index : SV_InstanceID;
+};
+struct tint_symbol_2 {
+  float4 value : SV_Position;
+};
+
+float4 main_inner(VertexInputs0 inputs0, uint loc1, uint instance_index, VertexInputs1 inputs1, float16_t loc4) {
+  const uint foo = (inputs0.vertex_index + instance_index);
+  const int i = inputs0.loc0;
+  const uint u = loc1;
+  const float f = inputs1.loc2;
+  const float4 v = inputs1.loc3;
+  const float16_t x = loc4;
+  const vector<float16_t, 3> y = inputs1.loc5;
+  return (0.0f).xxxx;
+}
+
+tint_symbol_2 main(tint_symbol_1 tint_symbol) {
+  const VertexInputs0 tint_symbol_3 = {tint_symbol.vertex_index, tint_symbol.loc0};
+  const VertexInputs1 tint_symbol_4 = {tint_symbol.loc2, tint_symbol.loc3, tint_symbol.loc5};
+  const float4 inner_result = main_inner(tint_symbol_3, tint_symbol.loc1, tint_symbol.instance_index, tint_symbol_4, tint_symbol.loc4);
+  tint_symbol_2 wrapper_result = (tint_symbol_2)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
+FXC validation failure:
+D:\Projects\RampUp\dawn\test\tint\shader_io\Shader@0x0000026E46098A20(8,10-18): error X3000: syntax error: unexpected token 'float16_t'
+
diff --git a/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.glsl b/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.glsl
new file mode 100644
index 0000000..8d16b68
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.glsl
@@ -0,0 +1,41 @@
+#version 310 es
+#extension GL_AMD_gpu_shader_half_float : require
+
+layout(location = 0) in int loc0_1;
+layout(location = 1) in uint loc1_1;
+layout(location = 2) in float loc2_1;
+layout(location = 3) in vec4 loc3_1;
+layout(location = 5) in f16vec3 loc5_1;
+layout(location = 4) in float16_t loc4_1;
+struct VertexInputs0 {
+  uint vertex_index;
+  int loc0;
+};
+
+struct VertexInputs1 {
+  float loc2;
+  vec4 loc3;
+  f16vec3 loc5;
+};
+
+vec4 tint_symbol(VertexInputs0 inputs0, uint loc1, uint instance_index, VertexInputs1 inputs1, float16_t loc4) {
+  uint foo = (inputs0.vertex_index + instance_index);
+  int i = inputs0.loc0;
+  uint u = loc1;
+  float f = inputs1.loc2;
+  vec4 v = inputs1.loc3;
+  float16_t x = loc4;
+  f16vec3 y = inputs1.loc5;
+  return vec4(0.0f);
+}
+
+void main() {
+  gl_PointSize = 1.0;
+  VertexInputs0 tint_symbol_1 = VertexInputs0(uint(gl_VertexID), loc0_1);
+  VertexInputs1 tint_symbol_2 = VertexInputs1(loc2_1, loc3_1, loc5_1);
+  vec4 inner_result = tint_symbol(tint_symbol_1, loc1_1, uint(gl_InstanceID), tint_symbol_2, loc4_1);
+  gl_Position = inner_result;
+  gl_Position.y = -(gl_Position.y);
+  gl_Position.z = ((2.0f * gl_Position.z) - gl_Position.w);
+  return;
+}
diff --git a/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.msl b/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.msl
new file mode 100644
index 0000000..0140da6
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.msl
@@ -0,0 +1,47 @@
+#include <metal_stdlib>
+
+using namespace metal;
+struct VertexInputs0 {
+  uint vertex_index;
+  int loc0;
+};
+
+struct VertexInputs1 {
+  float loc2;
+  float4 loc3;
+  half3 loc5;
+};
+
+struct tint_symbol_2 {
+  int loc0 [[attribute(0)]];
+  uint loc1 [[attribute(1)]];
+  float loc2 [[attribute(2)]];
+  float4 loc3 [[attribute(3)]];
+  half loc4 [[attribute(4)]];
+  half3 loc5 [[attribute(5)]];
+};
+
+struct tint_symbol_3 {
+  float4 value [[position]];
+};
+
+float4 tint_symbol_inner(VertexInputs0 inputs0, uint loc1, uint instance_index, VertexInputs1 inputs1, half loc4) {
+  uint const foo = (inputs0.vertex_index + instance_index);
+  int const i = inputs0.loc0;
+  uint const u = loc1;
+  float const f = inputs1.loc2;
+  float4 const v = inputs1.loc3;
+  half const x = loc4;
+  half3 const y = inputs1.loc5;
+  return float4(0.0f);
+}
+
+vertex tint_symbol_3 tint_symbol(uint vertex_index [[vertex_id]], uint instance_index [[instance_id]], tint_symbol_2 tint_symbol_1 [[stage_in]]) {
+  VertexInputs0 const tint_symbol_4 = {.vertex_index=vertex_index, .loc0=tint_symbol_1.loc0};
+  VertexInputs1 const tint_symbol_5 = {.loc2=tint_symbol_1.loc2, .loc3=tint_symbol_1.loc3, .loc5=tint_symbol_1.loc5};
+  float4 const inner_result = tint_symbol_inner(tint_symbol_4, tint_symbol_1.loc1, instance_index, tint_symbol_5, tint_symbol_1.loc4);
+  tint_symbol_3 wrapper_result = {};
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
+
diff --git a/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.spvasm b/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.spvasm
new file mode 100644
index 0000000..1627483
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.spvasm
@@ -0,0 +1,115 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 59
+; Schema: 0
+               OpCapability Shader
+               OpCapability Float16
+               OpCapability UniformAndStorageBuffer16BitAccess
+               OpCapability StorageBuffer16BitAccess
+               OpCapability StorageInputOutput16
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Vertex %main "main" %vertex_index_1 %loc0_1 %loc1_1 %instance_index_1 %loc2_1 %loc3_1 %loc5_1 %loc4_1 %value %vertex_point_size
+               OpName %vertex_index_1 "vertex_index_1"
+               OpName %loc0_1 "loc0_1"
+               OpName %loc1_1 "loc1_1"
+               OpName %instance_index_1 "instance_index_1"
+               OpName %loc2_1 "loc2_1"
+               OpName %loc3_1 "loc3_1"
+               OpName %loc5_1 "loc5_1"
+               OpName %loc4_1 "loc4_1"
+               OpName %value "value"
+               OpName %vertex_point_size "vertex_point_size"
+               OpName %VertexInputs0 "VertexInputs0"
+               OpMemberName %VertexInputs0 0 "vertex_index"
+               OpMemberName %VertexInputs0 1 "loc0"
+               OpName %VertexInputs1 "VertexInputs1"
+               OpMemberName %VertexInputs1 0 "loc2"
+               OpMemberName %VertexInputs1 1 "loc3"
+               OpMemberName %VertexInputs1 2 "loc5"
+               OpName %main_inner "main_inner"
+               OpName %inputs0 "inputs0"
+               OpName %loc1 "loc1"
+               OpName %instance_index "instance_index"
+               OpName %inputs1 "inputs1"
+               OpName %loc4 "loc4"
+               OpName %main "main"
+               OpDecorate %vertex_index_1 BuiltIn VertexIndex
+               OpDecorate %loc0_1 Location 0
+               OpDecorate %loc1_1 Location 1
+               OpDecorate %instance_index_1 BuiltIn InstanceIndex
+               OpDecorate %loc2_1 Location 2
+               OpDecorate %loc3_1 Location 3
+               OpDecorate %loc5_1 Location 5
+               OpDecorate %loc4_1 Location 4
+               OpDecorate %value BuiltIn Position
+               OpDecorate %vertex_point_size BuiltIn PointSize
+               OpMemberDecorate %VertexInputs0 0 Offset 0
+               OpMemberDecorate %VertexInputs0 1 Offset 4
+               OpMemberDecorate %VertexInputs1 0 Offset 0
+               OpMemberDecorate %VertexInputs1 1 Offset 16
+               OpMemberDecorate %VertexInputs1 2 Offset 32
+       %uint = OpTypeInt 32 0
+%_ptr_Input_uint = OpTypePointer Input %uint
+%vertex_index_1 = OpVariable %_ptr_Input_uint Input
+        %int = OpTypeInt 32 1
+%_ptr_Input_int = OpTypePointer Input %int
+     %loc0_1 = OpVariable %_ptr_Input_int Input
+     %loc1_1 = OpVariable %_ptr_Input_uint Input
+%instance_index_1 = OpVariable %_ptr_Input_uint Input
+      %float = OpTypeFloat 32
+%_ptr_Input_float = OpTypePointer Input %float
+     %loc2_1 = OpVariable %_ptr_Input_float Input
+    %v4float = OpTypeVector %float 4
+%_ptr_Input_v4float = OpTypePointer Input %v4float
+     %loc3_1 = OpVariable %_ptr_Input_v4float Input
+       %half = OpTypeFloat 16
+     %v3half = OpTypeVector %half 3
+%_ptr_Input_v3half = OpTypePointer Input %v3half
+     %loc5_1 = OpVariable %_ptr_Input_v3half Input
+%_ptr_Input_half = OpTypePointer Input %half
+     %loc4_1 = OpVariable %_ptr_Input_half Input
+%_ptr_Output_v4float = OpTypePointer Output %v4float
+         %23 = OpConstantNull %v4float
+      %value = OpVariable %_ptr_Output_v4float Output %23
+%_ptr_Output_float = OpTypePointer Output %float
+         %26 = OpConstantNull %float
+%vertex_point_size = OpVariable %_ptr_Output_float Output %26
+%VertexInputs0 = OpTypeStruct %uint %int
+%VertexInputs1 = OpTypeStruct %float %v4float %v3half
+         %27 = OpTypeFunction %v4float %VertexInputs0 %uint %uint %VertexInputs1 %half
+       %void = OpTypeVoid
+         %43 = OpTypeFunction %void
+    %float_1 = OpConstant %float 1
+ %main_inner = OpFunction %v4float None %27
+    %inputs0 = OpFunctionParameter %VertexInputs0
+       %loc1 = OpFunctionParameter %uint
+%instance_index = OpFunctionParameter %uint
+    %inputs1 = OpFunctionParameter %VertexInputs1
+       %loc4 = OpFunctionParameter %half
+         %36 = OpLabel
+         %37 = OpCompositeExtract %uint %inputs0 0
+         %38 = OpIAdd %uint %37 %instance_index
+         %39 = OpCompositeExtract %int %inputs0 1
+         %40 = OpCompositeExtract %float %inputs1 0
+         %41 = OpCompositeExtract %v4float %inputs1 1
+         %42 = OpCompositeExtract %v3half %inputs1 2
+               OpReturnValue %23
+               OpFunctionEnd
+       %main = OpFunction %void None %43
+         %46 = OpLabel
+         %48 = OpLoad %uint %vertex_index_1
+         %49 = OpLoad %int %loc0_1
+         %50 = OpCompositeConstruct %VertexInputs0 %48 %49
+         %51 = OpLoad %uint %loc1_1
+         %52 = OpLoad %uint %instance_index_1
+         %53 = OpLoad %float %loc2_1
+         %54 = OpLoad %v4float %loc3_1
+         %55 = OpLoad %v3half %loc5_1
+         %56 = OpCompositeConstruct %VertexInputs1 %53 %54 %55
+         %57 = OpLoad %half %loc4_1
+         %47 = OpFunctionCall %v4float %main_inner %50 %51 %52 %56 %57
+               OpStore %value %47
+               OpStore %vertex_point_size %float_1
+               OpReturn
+               OpFunctionEnd
diff --git a/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.wgsl b/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.wgsl
new file mode 100644
index 0000000..c87b17e
--- /dev/null
+++ b/test/tint/shader_io/vertex_input_mixed_f16.wgsl.expected.wgsl
@@ -0,0 +1,29 @@
+enable f16;
+
+struct VertexInputs0 {
+  @builtin(vertex_index)
+  vertex_index : u32,
+  @location(0)
+  loc0 : i32,
+}
+
+struct VertexInputs1 {
+  @location(2)
+  loc2 : f32,
+  @location(3)
+  loc3 : vec4<f32>,
+  @location(5)
+  loc5 : vec3<f16>,
+}
+
+@vertex
+fn main(inputs0 : VertexInputs0, @location(1) loc1 : u32, @builtin(instance_index) instance_index : u32, inputs1 : VertexInputs1, @location(4) loc4 : f16) -> @builtin(position) vec4<f32> {
+  let foo : u32 = (inputs0.vertex_index + instance_index);
+  let i : i32 = inputs0.loc0;
+  let u : u32 = loc1;
+  let f : f32 = inputs1.loc2;
+  let v : vec4<f32> = inputs1.loc3;
+  let x : f16 = loc4;
+  let y : vec3<f16> = inputs1.loc5;
+  return vec4<f32>();
+}
diff --git a/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl b/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl
new file mode 100644
index 0000000..6c9f91c
--- /dev/null
+++ b/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl
@@ -0,0 +1,16 @@
+enable f16;
+
+struct VertexOutputs {
+  @location(0) @interpolate(flat) loc0 : i32,
+  @location(1) @interpolate(flat) loc1 : u32,
+  @location(2) loc2 : f32,
+  @location(3) loc3 : vec4<f32>,
+  @builtin(position) position : vec4<f32>,
+  @location(4) loc4 : f16,
+  @location(5) loc5 : vec3<f16>,
+};
+
+@vertex
+fn main() -> VertexOutputs {
+  return VertexOutputs(1, 1u, 1.0, vec4<f32>(1.0, 2.0, 3.0, 4.0), vec4<f32>(), 2.25h, vec3<f16>(3.0h, 5.0h, 8.0h));
+}
diff --git a/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.dxc.hlsl b/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.dxc.hlsl
new file mode 100644
index 0000000..32c2611
--- /dev/null
+++ b/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.dxc.hlsl
@@ -0,0 +1,36 @@
+struct VertexOutputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  float4 loc3;
+  float4 position;
+  float16_t loc4;
+  vector<float16_t, 3> loc5;
+};
+struct tint_symbol {
+  nointerpolation int loc0 : TEXCOORD0;
+  nointerpolation uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+  float16_t loc4 : TEXCOORD4;
+  vector<float16_t, 3> loc5 : TEXCOORD5;
+  float4 position : SV_Position;
+};
+
+VertexOutputs main_inner() {
+  const VertexOutputs tint_symbol_1 = {1, 1u, 1.0f, float4(1.0f, 2.0f, 3.0f, 4.0f), (0.0f).xxxx, float16_t(2.25h), vector<float16_t, 3>(float16_t(3.0h), float16_t(5.0h), float16_t(8.0h))};
+  return tint_symbol_1;
+}
+
+tint_symbol main() {
+  const VertexOutputs inner_result = main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.loc0 = inner_result.loc0;
+  wrapper_result.loc1 = inner_result.loc1;
+  wrapper_result.loc2 = inner_result.loc2;
+  wrapper_result.loc3 = inner_result.loc3;
+  wrapper_result.position = inner_result.position;
+  wrapper_result.loc4 = inner_result.loc4;
+  wrapper_result.loc5 = inner_result.loc5;
+  return wrapper_result;
+}
diff --git a/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.fxc.hlsl b/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.fxc.hlsl
new file mode 100644
index 0000000..8d3722d
--- /dev/null
+++ b/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.fxc.hlsl
@@ -0,0 +1,41 @@
+SKIP: FAILED
+
+struct VertexOutputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  float4 loc3;
+  float4 position;
+  float16_t loc4;
+  vector<float16_t, 3> loc5;
+};
+struct tint_symbol {
+  nointerpolation int loc0 : TEXCOORD0;
+  nointerpolation uint loc1 : TEXCOORD1;
+  float loc2 : TEXCOORD2;
+  float4 loc3 : TEXCOORD3;
+  float16_t loc4 : TEXCOORD4;
+  vector<float16_t, 3> loc5 : TEXCOORD5;
+  float4 position : SV_Position;
+};
+
+VertexOutputs main_inner() {
+  const VertexOutputs tint_symbol_1 = {1, 1u, 1.0f, float4(1.0f, 2.0f, 3.0f, 4.0f), (0.0f).xxxx, float16_t(2.25h), vector<float16_t, 3>(float16_t(3.0h), float16_t(5.0h), float16_t(8.0h))};
+  return tint_symbol_1;
+}
+
+tint_symbol main() {
+  const VertexOutputs inner_result = main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.loc0 = inner_result.loc0;
+  wrapper_result.loc1 = inner_result.loc1;
+  wrapper_result.loc2 = inner_result.loc2;
+  wrapper_result.loc3 = inner_result.loc3;
+  wrapper_result.position = inner_result.position;
+  wrapper_result.loc4 = inner_result.loc4;
+  wrapper_result.loc5 = inner_result.loc5;
+  return wrapper_result;
+}
+FXC validation failure:
+D:\Projects\RampUp\dawn\test\tint\shader_io\Shader@0x000002CD4C6B4280(7,3-11): error X3000: unrecognized identifier 'float16_t'
+
diff --git a/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.glsl b/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.glsl
new file mode 100644
index 0000000..22881f0
--- /dev/null
+++ b/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.glsl
@@ -0,0 +1,38 @@
+#version 310 es
+#extension GL_AMD_gpu_shader_half_float : require
+
+layout(location = 0) flat out int loc0_1;
+layout(location = 1) flat out uint loc1_1;
+layout(location = 2) out float loc2_1;
+layout(location = 3) out vec4 loc3_1;
+layout(location = 4) out float16_t loc4_1;
+layout(location = 5) out f16vec3 loc5_1;
+struct VertexOutputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  vec4 loc3;
+  vec4 position;
+  float16_t loc4;
+  f16vec3 loc5;
+};
+
+VertexOutputs tint_symbol() {
+  VertexOutputs tint_symbol_1 = VertexOutputs(1, 1u, 1.0f, vec4(1.0f, 2.0f, 3.0f, 4.0f), vec4(0.0f), 2.25hf, f16vec3(3.0hf, 5.0hf, 8.0hf));
+  return tint_symbol_1;
+}
+
+void main() {
+  gl_PointSize = 1.0;
+  VertexOutputs inner_result = tint_symbol();
+  loc0_1 = inner_result.loc0;
+  loc1_1 = inner_result.loc1;
+  loc2_1 = inner_result.loc2;
+  loc3_1 = inner_result.loc3;
+  gl_Position = inner_result.position;
+  loc4_1 = inner_result.loc4;
+  loc5_1 = inner_result.loc5;
+  gl_Position.y = -(gl_Position.y);
+  gl_Position.z = ((2.0f * gl_Position.z) - gl_Position.w);
+  return;
+}
diff --git a/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.msl b/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.msl
new file mode 100644
index 0000000..707636a
--- /dev/null
+++ b/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.msl
@@ -0,0 +1,41 @@
+#include <metal_stdlib>
+
+using namespace metal;
+struct VertexOutputs {
+  int loc0;
+  uint loc1;
+  float loc2;
+  float4 loc3;
+  float4 position;
+  half loc4;
+  half3 loc5;
+};
+
+struct tint_symbol_1 {
+  int loc0 [[user(locn0)]] [[flat]];
+  uint loc1 [[user(locn1)]] [[flat]];
+  float loc2 [[user(locn2)]];
+  float4 loc3 [[user(locn3)]];
+  half loc4 [[user(locn4)]];
+  half3 loc5 [[user(locn5)]];
+  float4 position [[position]];
+};
+
+VertexOutputs tint_symbol_inner() {
+  VertexOutputs const tint_symbol_2 = VertexOutputs{.loc0=1, .loc1=1u, .loc2=1.0f, .loc3=float4(1.0f, 2.0f, 3.0f, 4.0f), .position=float4(0.0f), .loc4=2.25h, .loc5=half3(3.0h, 5.0h, 8.0h)};
+  return tint_symbol_2;
+}
+
+vertex tint_symbol_1 tint_symbol() {
+  VertexOutputs const inner_result = tint_symbol_inner();
+  tint_symbol_1 wrapper_result = {};
+  wrapper_result.loc0 = inner_result.loc0;
+  wrapper_result.loc1 = inner_result.loc1;
+  wrapper_result.loc2 = inner_result.loc2;
+  wrapper_result.loc3 = inner_result.loc3;
+  wrapper_result.position = inner_result.position;
+  wrapper_result.loc4 = inner_result.loc4;
+  wrapper_result.loc5 = inner_result.loc5;
+  return wrapper_result;
+}
+
diff --git a/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.spvasm b/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.spvasm
new file mode 100644
index 0000000..79fd125
--- /dev/null
+++ b/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.spvasm
@@ -0,0 +1,114 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 56
+; Schema: 0
+               OpCapability Shader
+               OpCapability Float16
+               OpCapability UniformAndStorageBuffer16BitAccess
+               OpCapability StorageBuffer16BitAccess
+               OpCapability StorageInputOutput16
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Vertex %main "main" %loc0_1 %loc1_1 %loc2_1 %loc3_1 %position_1 %loc4_1 %loc5_1 %vertex_point_size
+               OpName %loc0_1 "loc0_1"
+               OpName %loc1_1 "loc1_1"
+               OpName %loc2_1 "loc2_1"
+               OpName %loc3_1 "loc3_1"
+               OpName %position_1 "position_1"
+               OpName %loc4_1 "loc4_1"
+               OpName %loc5_1 "loc5_1"
+               OpName %vertex_point_size "vertex_point_size"
+               OpName %VertexOutputs "VertexOutputs"
+               OpMemberName %VertexOutputs 0 "loc0"
+               OpMemberName %VertexOutputs 1 "loc1"
+               OpMemberName %VertexOutputs 2 "loc2"
+               OpMemberName %VertexOutputs 3 "loc3"
+               OpMemberName %VertexOutputs 4 "position"
+               OpMemberName %VertexOutputs 5 "loc4"
+               OpMemberName %VertexOutputs 6 "loc5"
+               OpName %main_inner "main_inner"
+               OpName %main "main"
+               OpDecorate %loc0_1 Location 0
+               OpDecorate %loc0_1 Flat
+               OpDecorate %loc1_1 Location 1
+               OpDecorate %loc1_1 Flat
+               OpDecorate %loc2_1 Location 2
+               OpDecorate %loc3_1 Location 3
+               OpDecorate %position_1 BuiltIn Position
+               OpDecorate %loc4_1 Location 4
+               OpDecorate %loc5_1 Location 5
+               OpDecorate %vertex_point_size BuiltIn PointSize
+               OpMemberDecorate %VertexOutputs 0 Offset 0
+               OpMemberDecorate %VertexOutputs 1 Offset 4
+               OpMemberDecorate %VertexOutputs 2 Offset 8
+               OpMemberDecorate %VertexOutputs 3 Offset 16
+               OpMemberDecorate %VertexOutputs 4 Offset 32
+               OpMemberDecorate %VertexOutputs 5 Offset 48
+               OpMemberDecorate %VertexOutputs 6 Offset 56
+        %int = OpTypeInt 32 1
+%_ptr_Output_int = OpTypePointer Output %int
+          %4 = OpConstantNull %int
+     %loc0_1 = OpVariable %_ptr_Output_int Output %4
+       %uint = OpTypeInt 32 0
+%_ptr_Output_uint = OpTypePointer Output %uint
+          %8 = OpConstantNull %uint
+     %loc1_1 = OpVariable %_ptr_Output_uint Output %8
+      %float = OpTypeFloat 32
+%_ptr_Output_float = OpTypePointer Output %float
+         %12 = OpConstantNull %float
+     %loc2_1 = OpVariable %_ptr_Output_float Output %12
+    %v4float = OpTypeVector %float 4
+%_ptr_Output_v4float = OpTypePointer Output %v4float
+         %16 = OpConstantNull %v4float
+     %loc3_1 = OpVariable %_ptr_Output_v4float Output %16
+ %position_1 = OpVariable %_ptr_Output_v4float Output %16
+       %half = OpTypeFloat 16
+%_ptr_Output_half = OpTypePointer Output %half
+         %21 = OpConstantNull %half
+     %loc4_1 = OpVariable %_ptr_Output_half Output %21
+     %v3half = OpTypeVector %half 3
+%_ptr_Output_v3half = OpTypePointer Output %v3half
+         %25 = OpConstantNull %v3half
+     %loc5_1 = OpVariable %_ptr_Output_v3half Output %25
+%vertex_point_size = OpVariable %_ptr_Output_float Output %12
+%VertexOutputs = OpTypeStruct %int %uint %float %v4float %v4float %half %v3half
+         %27 = OpTypeFunction %VertexOutputs
+      %int_1 = OpConstant %int 1
+     %uint_1 = OpConstant %uint 1
+    %float_1 = OpConstant %float 1
+    %float_2 = OpConstant %float 2
+    %float_3 = OpConstant %float 3
+    %float_4 = OpConstant %float 4
+         %37 = OpConstantComposite %v4float %float_1 %float_2 %float_3 %float_4
+%half_0x1_2p_1 = OpConstant %half 0x1.2p+1
+%half_0x1_8p_1 = OpConstant %half 0x1.8p+1
+%half_0x1_4p_2 = OpConstant %half 0x1.4p+2
+%half_0x1p_3 = OpConstant %half 0x1p+3
+         %42 = OpConstantComposite %v3half %half_0x1_8p_1 %half_0x1_4p_2 %half_0x1p_3
+         %43 = OpConstantComposite %VertexOutputs %int_1 %uint_1 %float_1 %37 %16 %half_0x1_2p_1 %42
+       %void = OpTypeVoid
+         %44 = OpTypeFunction %void
+ %main_inner = OpFunction %VertexOutputs None %27
+         %30 = OpLabel
+               OpReturnValue %43
+               OpFunctionEnd
+       %main = OpFunction %void None %44
+         %47 = OpLabel
+         %48 = OpFunctionCall %VertexOutputs %main_inner
+         %49 = OpCompositeExtract %int %48 0
+               OpStore %loc0_1 %49
+         %50 = OpCompositeExtract %uint %48 1
+               OpStore %loc1_1 %50
+         %51 = OpCompositeExtract %float %48 2
+               OpStore %loc2_1 %51
+         %52 = OpCompositeExtract %v4float %48 3
+               OpStore %loc3_1 %52
+         %53 = OpCompositeExtract %v4float %48 4
+               OpStore %position_1 %53
+         %54 = OpCompositeExtract %half %48 5
+               OpStore %loc4_1 %54
+         %55 = OpCompositeExtract %v3half %48 6
+               OpStore %loc5_1 %55
+               OpStore %vertex_point_size %float_1
+               OpReturn
+               OpFunctionEnd
diff --git a/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.wgsl b/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.wgsl
new file mode 100644
index 0000000..46dc3f5
--- /dev/null
+++ b/test/tint/shader_io/vertex_output_locations_struct_f16.wgsl.expected.wgsl
@@ -0,0 +1,23 @@
+enable f16;
+
+struct VertexOutputs {
+  @location(0) @interpolate(flat)
+  loc0 : i32,
+  @location(1) @interpolate(flat)
+  loc1 : u32,
+  @location(2)
+  loc2 : f32,
+  @location(3)
+  loc3 : vec4<f32>,
+  @builtin(position)
+  position : vec4<f32>,
+  @location(4)
+  loc4 : f16,
+  @location(5)
+  loc5 : vec3<f16>,
+}
+
+@vertex
+fn main() -> VertexOutputs {
+  return VertexOutputs(1, 1u, 1.0, vec4<f32>(1.0, 2.0, 3.0, 4.0), vec4<f32>(), 2.25h, vec3<f16>(3.0h, 5.0h, 8.0h));
+}