Add a ClampFragDepth transform.

Add clamping of the @builtin(frag_depth) output of fragment shaders using
two push constantsprovided by the outside environment. For example the
following code:

  @fragment fn main() -> @builtin(frag_depth) f32 {
      return 0.0;
  }

Is transformed to:

  enable chromium_experimental_push_constant;

  struct FragDepthClampArgs {
    min : f32,
    max : f32,
  }

  var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;

  fn clamp_frag_depth(v : f32) -> f32 {
    return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
  }

  @fragment
  fn main() -> @builtin(frag_depth) f32 {
    return clamp_frag_depth(0.0);
  }

Fixed: tint:1620
Change-Id: Id403c4813fb2698aa87630abc30d26f02d53634a
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/104980
Reviewed-by: Ben Clayton <bclayton@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: Corentin Wallez <cwallez@chromium.org>

src/tint/BUILD.gn

@@ -482,8 +482,11 @@ libtint_source_set("libtint_core_all_src") {
     "transform/builtin_polyfill.h",
     "transform/calculate_array_length.cc",
     "transform/calculate_array_length.h",
+    "transform/calculate_array_length.h",
     "transform/canonicalize_entry_point_io.cc",
     "transform/canonicalize_entry_point_io.h",
+    "transform/clamp_frag_depth.cc",
+    "transform/clamp_frag_depth.h",
     "transform/combine_samplers.cc",
     "transform/combine_samplers.h",
     "transform/decompose_memory_access.cc",
@@ -1191,6 +1194,7 @@ if (tint_build_unittests) {
       "transform/builtin_polyfill_test.cc",
       "transform/calculate_array_length_test.cc",
       "transform/canonicalize_entry_point_io_test.cc",
+      "transform/clamp_frag_depth_test.cc",
       "transform/combine_samplers_test.cc",
       "transform/decompose_memory_access_test.cc",
       "transform/decompose_strided_array_test.cc",

src/tint/CMakeLists.txt

@@ -394,6 +394,8 @@ set(TINT_LIB_SRCS
   transform/builtin_polyfill.h
   transform/calculate_array_length.cc
   transform/calculate_array_length.h
+  transform/clamp_frag_depth.cc
+  transform/clamp_frag_depth.h
   transform/canonicalize_entry_point_io.cc
   transform/canonicalize_entry_point_io.h
   transform/combine_samplers.cc
@@ -1105,6 +1107,7 @@ if(TINT_BUILD_TESTS)
       transform/binding_remapper_test.cc
       transform/builtin_polyfill_test.cc
       transform/calculate_array_length_test.cc
+      transform/clamp_frag_depth_test.cc
       transform/canonicalize_entry_point_io_test.cc
       transform/combine_samplers_test.cc
       transform/decompose_memory_access_test.cc

src/tint/transform/clamp_frag_depth.cc

@@ -0,0 +1,202 @@
+// Copyright 2022 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/transform/clamp_frag_depth.h"
+
+ #include <utility>
+
+#include "src/tint/ast/attribute.h"
+#include "src/tint/ast/builtin_attribute.h"
+#include "src/tint/ast/builtin_value.h"
+#include "src/tint/ast/function.h"
+#include "src/tint/ast/module.h"
+#include "src/tint/ast/struct.h"
+#include "src/tint/ast/type.h"
+#include "src/tint/program_builder.h"
+#include "src/tint/sem/function.h"
+#include "src/tint/sem/statement.h"
+#include "src/tint/sem/struct.h"
+#include "src/tint/utils/scoped_assignment.h"
+#include "src/tint/utils/vector.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::transform::ClampFragDepth);
+
+namespace tint::transform {
+
+namespace {
+
+bool ContainsFragDepth(utils::VectorRef<const ast::Attribute*> attributes) {
+    for (auto* attribute : attributes) {
+        if (auto* builtin_attribute = attribute->As<ast::BuiltinAttribute>()) {
+            if (builtin_attribute->builtin == ast::BuiltinValue::kFragDepth) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+bool ReturnsFragDepthAsValue(const ast::Function* fn) {
+    return ContainsFragDepth(fn->return_type_attributes);
+}
+
+bool ReturnsFragDepthInStruct(const sem::Info& sem, const ast::Function* fn) {
+    if (auto* struct_ty = sem.Get(fn)->ReturnType()->As<sem::Struct>()) {
+        for (auto* member : struct_ty->Members()) {
+            if (ContainsFragDepth(member->Declaration()->attributes)) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+}  // anonymous namespace
+
+ClampFragDepth::ClampFragDepth() = default;
+ClampFragDepth::~ClampFragDepth() = default;
+
+bool ClampFragDepth::ShouldRun(const Program* program, const DataMap&) const {
+    auto& sem = program->Sem();
+
+    for (auto* fn : program->AST().Functions()) {
+        if (fn->PipelineStage() == ast::PipelineStage::kFragment &&
+            (ReturnsFragDepthAsValue(fn) || ReturnsFragDepthInStruct(sem, fn))) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void ClampFragDepth::Run(CloneContext& ctx, const DataMap&, DataMap&) const {
+    // Abort on any use of push constants in the module.
+    for (auto* global : ctx.src->AST().GlobalVariables()) {
+        if (auto* var = global->As<ast::Var>()) {
+            if (var->declared_address_space == ast::AddressSpace::kPushConstant) {
+                TINT_ICE(Transform, ctx.dst->Diagnostics())
+                    << "ClampFragDepth doesn't know how to handle module that already use push "
+                       "constants.";
+                return;
+            }
+        }
+    }
+
+    auto& b = *ctx.dst;
+    auto& sem = ctx.src->Sem();
+    auto& sym = ctx.src->Symbols();
+
+    // At least one entry-point needs clamping. Add the following to the module:
+    //
+    //   enable chromium_experimental_push_constant;
+    //
+    //   struct FragDepthClampArgs {
+    //       min : f32,
+    //       max : f32,
+    //   }
+    //   var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
+    //
+    //   fn clamp_frag_depth(v : f32) -> f32 {
+    //       return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
+    //   }
+    b.Enable(ast::Extension::kChromiumExperimentalPushConstant);
+
+    b.Structure(b.Symbols().New("FragDepthClampArgs"),
+                utils::Vector{b.Member("min", b.ty.f32()), b.Member("max", b.ty.f32())});
+
+    auto args_sym = b.Symbols().New("frag_depth_clamp_args");
+    b.GlobalVar(args_sym, b.ty.type_name("FragDepthClampArgs"), ast::AddressSpace::kPushConstant);
+
+    auto base_fn_sym = b.Symbols().New("clamp_frag_depth");
+    b.Func(base_fn_sym, utils::Vector{b.Param("v", b.ty.f32())}, b.ty.f32(),
+           utils::Vector{b.Return(b.Call("clamp", "v", b.MemberAccessor(args_sym, "min"),
+                                         b.MemberAccessor(args_sym, "max")))});
+
+    // If true, the currently cloned function returns frag depth directly as a scalar
+    bool returns_frag_depth_as_value = false;
+
+    // If valid, the currently cloned function returns frag depth in a struct
+    // The symbol is the name of the helper function to apply the depth clamping.
+    Symbol returns_frag_depth_as_struct_helper;
+
+    // Map of io struct to helper function to return the structure with the depth clamping applied.
+    utils::Hashmap<const ast::Struct*, Symbol, 4u> io_structs_clamp_helpers;
+
+    // Register a callback that will be called for each visted AST function.
+    // This call wraps the cloning of the function's statements, and will assign to
+    // `returns_frag_depth_as_value` or `returns_frag_depth_as_struct_helper` if the function's
+    // return value requires depth clamping.
+    ctx.ReplaceAll([&](const ast::Function* fn) {
+        if (fn->PipelineStage() != ast::PipelineStage::kFragment) {
+            return ctx.CloneWithoutTransform(fn);
+        }
+
+        if (ReturnsFragDepthAsValue(fn)) {
+            TINT_SCOPED_ASSIGNMENT(returns_frag_depth_as_value, true);
+            return ctx.CloneWithoutTransform(fn);
+        }
+
+        if (ReturnsFragDepthInStruct(sem, fn)) {
+            // At most once per I/O struct, add the conversion function:
+            //
+            //   fn clamp_frag_depth_S(s : S) -> S {
+            //       return S(s.first, s.second, clamp_frag_depth(s.frag_depth), s.last);
+            //   }
+            auto* struct_ty = sem.Get(fn)->ReturnType()->As<sem::Struct>()->Declaration();
+            auto helper = io_structs_clamp_helpers.GetOrCreate(struct_ty, [&] {
+                auto* return_ty = fn->return_type;
+                auto fn_sym = b.Symbols().New("clamp_frag_depth_" +
+                                              sym.NameFor(return_ty->As<ast::TypeName>()->name));
+
+                utils::Vector<const ast::Expression*, 8u> constructor_args;
+                for (auto* member : struct_ty->members) {
+                    const ast::Expression* arg = b.MemberAccessor("s", ctx.Clone(member->symbol));
+                    if (ContainsFragDepth(member->attributes)) {
+                        arg = b.Call(base_fn_sym, arg);
+                    }
+                    constructor_args.Push(arg);
+                }
+                utils::Vector params{b.Param("s", ctx.Clone(return_ty))};
+                utils::Vector body{
+                    b.Return(b.Construct(ctx.Clone(return_ty), std::move(constructor_args))),
+                };
+                b.Func(fn_sym, params, ctx.Clone(return_ty), body);
+                return fn_sym;
+            });
+
+            TINT_SCOPED_ASSIGNMENT(returns_frag_depth_as_struct_helper, helper);
+            return ctx.CloneWithoutTransform(fn);
+        }
+
+        return ctx.CloneWithoutTransform(fn);
+    });
+
+    // Replace the return statements `return expr` with `return clamp_frag_depth(expr)`.
+    ctx.ReplaceAll([&](const ast::ReturnStatement* stmt) -> const ast::ReturnStatement* {
+        if (returns_frag_depth_as_value) {
+            return b.Return(stmt->source, b.Call(base_fn_sym, ctx.Clone(stmt->value)));
+        }
+        if (returns_frag_depth_as_struct_helper.IsValid()) {
+            return b.Return(stmt->source,
+                            b.Call(returns_frag_depth_as_struct_helper, ctx.Clone(stmt->value)));
+        }
+        return nullptr;
+    });
+
+    ctx.Clone();
+}
+
+}  // namespace tint::transform

src/tint/transform/clamp_frag_depth.h

@@ -0,0 +1,81 @@
+// Copyright 2022 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_TRANSFORM_CLAMP_FRAG_DEPTH_H_
+#define SRC_TINT_TRANSFORM_CLAMP_FRAG_DEPTH_H_
+
+#include "src/tint/transform/transform.h"
+
+// Forward declarations
+namespace tint {
+class CloneContext;
+}  // namespace tint
+
+namespace tint::transform {
+
+/// Add clamping of the `@builtin(frag_depth)` output of fragment shaders using two push constants
+/// provided by the outside environment. For example the following code:
+///
+/// ```
+///   @fragment fn main() -> @builtin(frag_depth) f32 {
+///       return 0.0;
+///   }
+/// ```
+///
+/// Is transformed to:
+///
+/// ```
+///   enable chromium_experimental_push_constant;
+///
+///   struct FragDepthClampArgs {
+///     min : f32,
+///     max : f32,
+///   }
+///
+///   var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
+///
+///   fn clamp_frag_depth(v : f32) -> f32 {
+///     return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
+///   }
+///
+///   @fragment
+///   fn main() -> @builtin(frag_depth) f32 {
+///     return clamp_frag_depth(0.0);
+///   }
+/// ```
+class ClampFragDepth final : public Castable<ClampFragDepth, Transform> {
+  public:
+    /// Constructor
+    ClampFragDepth();
+    /// Destructor
+    ~ClampFragDepth() override;
+
+    /// @param program the program to inspect
+    /// @param data optional extra transform-specific input data
+    /// @returns true if this transform should be run for the given program
+    bool ShouldRun(const Program* program, const DataMap& data = {}) const override;
+
+  protected:
+    /// Runs the transform using the CloneContext built for transforming a
+    /// program. Run() is responsible for calling Clone() on the CloneContext.
+    /// @param ctx the CloneContext primed with the input program and
+    /// ProgramBuilder
+    /// @param inputs optional extra transform-specific input data
+    /// @param outputs optional extra transform-specific output data
+    void Run(CloneContext& ctx, const DataMap& inputs, DataMap& outputs) const override;
+};
+
+}  // namespace tint::transform
+
+#endif  // SRC_TINT_TRANSFORM_CLAMP_FRAG_DEPTH_H_

src/tint/transform/clamp_frag_depth_test.cc

@@ -0,0 +1,381 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/transform/clamp_frag_depth.h"
+
+#include "src/tint/transform/test_helper.h"
+
+namespace tint::transform {
+namespace {
+
+using ClampFragDepthTest = TransformTest;
+
+TEST_F(ClampFragDepthTest, ShouldRunEmptyModule) {
+    auto* src = R"()";
+
+    EXPECT_FALSE(ShouldRun<ClampFragDepth>(src));
+}
+
+TEST_F(ClampFragDepthTest, ShouldRunNoFragmentShader) {
+    auto* src = R"(
+        fn f() -> f32 {
+            return 0.0;
+        }
+
+        @compute @workgroup_size(1) fn cs() {
+        }
+
+        @vertex fn vs() -> @builtin(position) vec4<f32> {
+            return vec4<f32>();
+        }
+    )";
+
+    EXPECT_FALSE(ShouldRun<ClampFragDepth>(src));
+}
+
+TEST_F(ClampFragDepthTest, ShouldRunFragmentShaderNoReturnType) {
+    auto* src = R"(
+        @fragment fn main() {
+        }
+    )";
+
+    EXPECT_FALSE(ShouldRun<ClampFragDepth>(src));
+}
+
+TEST_F(ClampFragDepthTest, ShouldRunFragmentShaderNoFragDepth) {
+    auto* src = R"(
+        @fragment fn main() -> @location(0) f32 {
+            return 0.0;
+        }
+
+        struct S {
+            @location(0) a : f32,
+            @builtin(sample_mask) b : u32,
+        }
+        @fragment fn main2() -> S {
+            return S();
+        }
+    )";
+
+    EXPECT_FALSE(ShouldRun<ClampFragDepth>(src));
+}
+
+TEST_F(ClampFragDepthTest, ShouldRunFragDepthAsDirectReturn) {
+    auto* src = R"(
+        @fragment fn main() -> @builtin(frag_depth) f32 {
+            return 0.0;
+        }
+    )";
+
+    EXPECT_TRUE(ShouldRun<ClampFragDepth>(src));
+}
+
+TEST_F(ClampFragDepthTest, ShouldRunFragDepthInStruct) {
+    auto* src = R"(
+        struct S {
+            @location(0) a : f32,
+            @builtin(frag_depth) b : f32,
+            @location(1) c : f32,
+        }
+        @fragment fn main() -> S {
+            return S();
+        }
+    )";
+
+    EXPECT_TRUE(ShouldRun<ClampFragDepth>(src));
+}
+
+TEST_F(ClampFragDepthTest, SingleReturnOfFragDepth) {
+    auto* src = R"(
+        @fragment fn main() -> @builtin(frag_depth) f32 {
+            return 0.0;
+        }
+    )";
+
+    auto* expect = R"(
+enable chromium_experimental_push_constant;
+
+struct FragDepthClampArgs {
+  min : f32,
+  max : f32,
+}
+
+var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
+
+fn clamp_frag_depth(v : f32) -> f32 {
+  return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
+}
+
+@fragment
+fn main() -> @builtin(frag_depth) f32 {
+  return clamp_frag_depth(0.0);
+}
+)";
+
+    auto got = Run<ClampFragDepth>(src);
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(ClampFragDepthTest, MultipleReturnOfFragDepth) {
+    auto* src = R"(
+        @fragment fn main() -> @builtin(frag_depth) f32 {
+            if (false) {
+                return 1.0;
+            }
+            return 0.0;
+        }
+    )";
+
+    auto* expect = R"(
+enable chromium_experimental_push_constant;
+
+struct FragDepthClampArgs {
+  min : f32,
+  max : f32,
+}
+
+var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
+
+fn clamp_frag_depth(v : f32) -> f32 {
+  return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
+}
+
+@fragment
+fn main() -> @builtin(frag_depth) f32 {
+  if (false) {
+    return clamp_frag_depth(1.0);
+  }
+  return clamp_frag_depth(0.0);
+}
+)";
+
+    auto got = Run<ClampFragDepth>(src);
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(ClampFragDepthTest, OtherFunctionWithoutFragDepth) {
+    auto* src = R"(
+        @fragment fn main() -> @builtin(frag_depth) f32 {
+            return 0.0;
+        }
+        @fragment fn friend() -> @location(0) f32 {
+            return 0.0;
+        }
+    )";
+
+    auto* expect = R"(
+enable chromium_experimental_push_constant;
+
+struct FragDepthClampArgs {
+  min : f32,
+  max : f32,
+}
+
+var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
+
+fn clamp_frag_depth(v : f32) -> f32 {
+  return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
+}
+
+@fragment
+fn main() -> @builtin(frag_depth) f32 {
+  return clamp_frag_depth(0.0);
+}
+
+@fragment
+fn friend() -> @location(0) f32 {
+  return 0.0;
+}
+)";
+
+    auto got = Run<ClampFragDepth>(src);
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(ClampFragDepthTest, SimpleReturnOfStruct) {
+    auto* src = R"(
+        struct S {
+            @builtin(frag_depth) frag_depth : f32,
+        }
+
+        @fragment fn main() -> S {
+            return S(0.0);
+        }
+    )";
+
+    auto* expect = R"(
+enable chromium_experimental_push_constant;
+
+struct FragDepthClampArgs {
+  min : f32,
+  max : f32,
+}
+
+var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
+
+fn clamp_frag_depth(v : f32) -> f32 {
+  return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
+}
+
+struct S {
+  @builtin(frag_depth)
+  frag_depth : f32,
+}
+
+fn clamp_frag_depth_S(s : S) -> S {
+  return S(clamp_frag_depth(s.frag_depth));
+}
+
+@fragment
+fn main() -> S {
+  return clamp_frag_depth_S(S(0.0));
+}
+)";
+
+    auto got = Run<ClampFragDepth>(src);
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(ClampFragDepthTest, MixOfFunctionReturningStruct) {
+    auto* src = R"(
+        struct S {
+            @builtin(frag_depth) frag_depth : f32,
+        }
+        struct S2 {
+            @builtin(frag_depth) frag_depth : f32,
+        }
+
+        @fragment fn returnS() -> S {
+            return S(0.0);
+        }
+        @fragment fn againReturnS() -> S {
+            return S(0.0);
+        }
+        @fragment fn returnS2() -> S2 {
+            return S2(0.0);
+        }
+    )";
+
+    // clamp_frag_depth_S is emitted only once.
+    // S2 gets its own clamping function.
+    auto* expect = R"(
+enable chromium_experimental_push_constant;
+
+struct FragDepthClampArgs {
+  min : f32,
+  max : f32,
+}
+
+var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
+
+fn clamp_frag_depth(v : f32) -> f32 {
+  return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
+}
+
+struct S {
+  @builtin(frag_depth)
+  frag_depth : f32,
+}
+
+struct S2 {
+  @builtin(frag_depth)
+  frag_depth : f32,
+}
+
+fn clamp_frag_depth_S(s : S) -> S {
+  return S(clamp_frag_depth(s.frag_depth));
+}
+
+@fragment
+fn returnS() -> S {
+  return clamp_frag_depth_S(S(0.0));
+}
+
+@fragment
+fn againReturnS() -> S {
+  return clamp_frag_depth_S(S(0.0));
+}
+
+fn clamp_frag_depth_S2(s : S2) -> S2 {
+  return S2(clamp_frag_depth(s.frag_depth));
+}
+
+@fragment
+fn returnS2() -> S2 {
+  return clamp_frag_depth_S2(S2(0.0));
+}
+)";
+
+    auto got = Run<ClampFragDepth>(src);
+    EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(ClampFragDepthTest, ComplexIOStruct) {
+    auto* src = R"(
+        struct S {
+            @location(0) blou : vec4<f32>,
+            @location(1) bi : vec4<f32>,
+            @builtin(frag_depth) frag_depth : f32,
+            @location(2) boul : i32,
+            @builtin(sample_mask) ga : u32,
+        }
+
+        @fragment fn main() -> S {
+            return S(vec4<f32>(), vec4<f32>(), 0.0, 1, 0u);
+        }
+    )";
+
+    auto* expect = R"(
+enable chromium_experimental_push_constant;
+
+struct FragDepthClampArgs {
+  min : f32,
+  max : f32,
+}
+
+var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
+
+fn clamp_frag_depth(v : f32) -> f32 {
+  return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
+}
+
+struct S {
+  @location(0)
+  blou : vec4<f32>,
+  @location(1)
+  bi : vec4<f32>,
+  @builtin(frag_depth)
+  frag_depth : f32,
+  @location(2)
+  boul : i32,
+  @builtin(sample_mask)
+  ga : u32,
+}
+
+fn clamp_frag_depth_S(s : S) -> S {
+  return S(s.blou, s.bi, clamp_frag_depth(s.frag_depth), s.boul, s.ga);
+}
+
+@fragment
+fn main() -> S {
+  return clamp_frag_depth_S(S(vec4<f32>(), vec4<f32>(), 0.0, 1, 0u));
+}
+)";
+
+    auto got = Run<ClampFragDepth>(src);
+    EXPECT_EQ(expect, str(got));
+}
+
+}  // namespace
+}  // namespace tint::transform