diff --git a/src/transform/robustness.cc b/src/transform/robustness.cc
index 66964f8..5a71cf6 100644
--- a/src/transform/robustness.cc
+++ b/src/transform/robustness.cc
@@ -18,6 +18,7 @@
 #include <utility>
 
 #include "src/program_builder.h"
+#include "src/sem/block_statement.h"
 #include "src/sem/call.h"
 #include "src/sem/expression.h"
 #include "src/sem/statement.h"
@@ -27,113 +28,180 @@
 namespace tint {
 namespace transform {
 
+/// State holds the current transform state
+struct Robustness::State {
+  /// The clone context
+  CloneContext& ctx;
+
+  /// Applies the transformation state to `ctx`.
+  void Transform() {
+    ctx.ReplaceAll(
+        [&](ast::ArrayAccessorExpression* expr) { return Transform(expr); });
+    ctx.ReplaceAll([&](ast::CallExpression* expr) { return Transform(expr); });
+  }
+
+  /// Apply bounds clamping to array, vector and matrix indexing
+  /// @param expr the array, vector or matrix index expression
+  /// @return the clamped replacement expression, or nullptr if `expr` should be
+  /// cloned without changes.
+  ast::ArrayAccessorExpression* Transform(ast::ArrayAccessorExpression* expr) {
+    auto* ret_type = ctx.src->Sem().Get(expr->array())->Type()->UnwrapRef();
+    if (!ret_type->IsAnyOf<sem::Array, sem::Matrix, sem::Vector>()) {
+      return nullptr;
+    }
+
+    ProgramBuilder& b = *ctx.dst;
+    using u32 = ProgramBuilder::u32;
+
+    uint32_t size = 0;
+    bool is_vec = ret_type->Is<sem::Vector>();
+    bool is_arr = ret_type->Is<sem::Array>();
+    if (is_vec || is_arr) {
+      size = is_vec ? ret_type->As<sem::Vector>()->size()
+                    : ret_type->As<sem::Array>()->Count();
+    } else {
+      // The row accessor would have been an embedded array accessor and already
+      // handled, so we just need to do columns here.
+      size = ret_type->As<sem::Matrix>()->columns();
+    }
+
+    auto* const old_idx = expr->idx_expr();
+    b.SetSource(ctx.Clone(old_idx->source()));
+
+    ast::Expression* new_idx = nullptr;
+
+    if (size == 0) {
+      if (!is_arr) {
+        b.Diagnostics().add_error(diag::System::Transform,
+                                  "invalid 0 sized non-array", expr->source());
+        return nullptr;
+      }
+      // Runtime sized array
+      auto* arr = ctx.Clone(expr->array());
+      auto* arr_len = b.Call("arrayLength", b.AddressOf(arr));
+      auto* limit = b.Sub(arr_len, b.Expr(1u));
+      new_idx = b.Call("min", b.Construct<u32>(ctx.Clone(old_idx)), limit);
+    } else if (auto* c = old_idx->As<ast::ScalarConstructorExpression>()) {
+      // Scalar constructor we can re-write the value to be within bounds.
+      auto* lit = c->literal();
+      if (auto* sint = lit->As<ast::SintLiteral>()) {
+        int32_t max = static_cast<int32_t>(size) - 1;
+        new_idx = b.Expr(std::max(std::min(sint->value(), max), 0));
+      } else if (auto* uint = lit->As<ast::UintLiteral>()) {
+        new_idx = b.Expr(std::min(uint->value(), size - 1));
+      } else {
+        b.Diagnostics().add_error(
+            diag::System::Transform,
+            "unknown scalar constructor type for accessor", expr->source());
+        return nullptr;
+      }
+    } else {
+      auto* cloned_idx = ctx.Clone(old_idx);
+      new_idx = b.Call("min", b.Construct<u32>(cloned_idx), b.Expr(size - 1));
+    }
+
+    // Clone arguments outside of create() call to have deterministic ordering
+    auto src = ctx.Clone(expr->source());
+    auto* arr = ctx.Clone(expr->array());
+    return b.IndexAccessor(src, arr, new_idx);
+  }
+
+  /// @param type intrinsic type
+  /// @returns true if the given intrinsic is a texture function that requires
+  /// argument clamping,
+  bool TextureIntrinsicNeedsClamping(sem::IntrinsicType type) {
+    return type == sem::IntrinsicType::kTextureLoad ||
+           type == sem::IntrinsicType::kTextureStore;
+  }
+
+  /// Apply bounds clamping to the coordinates, array index and level arguments
+  /// of the `textureLoad()` and `textureStore()` intrinsics.
+  /// @param expr the intrinsic call expression
+  /// @return the clamped replacement call expression, or nullptr if `expr`
+  /// should be cloned without changes.
+  ast::CallExpression* Transform(ast::CallExpression* expr) {
+    auto* call = ctx.src->Sem().Get(expr);
+    auto* call_target = call->Target();
+    auto* intrinsic = call_target->As<sem::Intrinsic>();
+    if (!intrinsic || !TextureIntrinsicNeedsClamping(intrinsic->Type())) {
+      return nullptr;  // No transform, just clone.
+    }
+
+    ProgramBuilder& b = *ctx.dst;
+
+    // Indices of the mandatory texture and coords parameters, and the optional
+    // array and level parameters.
+    auto texture_idx =
+        sem::IndexOf(intrinsic->Parameters(), sem::ParameterUsage::kTexture);
+    auto coords_idx =
+        sem::IndexOf(intrinsic->Parameters(), sem::ParameterUsage::kCoords);
+    auto array_idx =
+        sem::IndexOf(intrinsic->Parameters(), sem::ParameterUsage::kArrayIndex);
+    auto level_idx =
+        sem::IndexOf(intrinsic->Parameters(), sem::ParameterUsage::kLevel);
+
+    auto* texture_arg = expr->params()[texture_idx];
+    auto* coords_arg = expr->params()[coords_idx];
+    auto* coords_ty = intrinsic->Parameters()[coords_idx].type;
+
+    // If the level is provided, then we need to clamp this. As the level is
+    // used by textureDimensions() and the texture[Load|Store]() calls, we need
+    // to clamp both usages.
+    // TODO(bclayton): We probably want to place this into a let so that the
+    // calculation can be reused. This is fiddly to get right.
+    std::function<ast::Expression*()> level_arg;
+    if (level_idx >= 0) {
+      level_arg = [&] {
+        auto* arg = expr->params()[level_idx];
+        auto* num_levels = b.Call("textureNumLevels", ctx.Clone(texture_arg));
+        auto* zero = b.Expr(0);
+        auto* max = ctx.dst->Sub(num_levels, 1);
+        auto* clamped = b.Call("clamp", ctx.Clone(arg), zero, max);
+        return clamped;
+      };
+    }
+
+    // Clamp the coordinates argument
+    {
+      auto* texture_dims =
+          level_arg
+              ? b.Call("textureDimensions", ctx.Clone(texture_arg), level_arg())
+              : b.Call("textureDimensions", ctx.Clone(texture_arg));
+      auto* zero = b.Construct(CreateASTTypeFor(&ctx, coords_ty));
+      auto* max = ctx.dst->Sub(
+          texture_dims, b.Construct(CreateASTTypeFor(&ctx, coords_ty), 1));
+      auto* clamped_coords = b.Call("clamp", ctx.Clone(coords_arg), zero, max);
+      ctx.Replace(coords_arg, clamped_coords);
+    }
+
+    // Clamp the array_index argument, if provided
+    if (array_idx >= 0) {
+      auto* arg = expr->params()[array_idx];
+      auto* num_layers = b.Call("textureNumLayers", ctx.Clone(texture_arg));
+      auto* zero = b.Expr(0);
+      auto* max = ctx.dst->Sub(num_layers, 1);
+      auto* clamped = b.Call("clamp", ctx.Clone(arg), zero, max);
+      ctx.Replace(arg, clamped);
+    }
+
+    // Clamp the level argument, if provided
+    if (level_idx >= 0) {
+      auto* arg = expr->params()[level_idx];
+      ctx.Replace(arg, level_arg ? level_arg() : ctx.dst->Expr(0));
+    }
+
+    return nullptr;  // Clone, which will use the argument replacements above.
+  }
+};
+
 Robustness::Robustness() = default;
 Robustness::~Robustness() = default;
 
 void Robustness::Run(CloneContext& ctx, const DataMap&, DataMap&) {
-  ctx.ReplaceAll([&](ast::ArrayAccessorExpression* expr) {
-    return Transform(expr, &ctx);
-  });
-  ctx.ReplaceAll(
-      [&](ast::CallExpression* expr) { return Transform(expr, &ctx); });
+  State state{ctx};
+  state.Transform();
   ctx.Clone();
 }
 
-// Apply bounds clamping to array, vector and matrix indexing
-ast::ArrayAccessorExpression* Robustness::Transform(
-    ast::ArrayAccessorExpression* expr,
-    CloneContext* ctx) {
-  auto* ret_type = ctx->src->Sem().Get(expr->array())->Type()->UnwrapRef();
-  if (!ret_type->IsAnyOf<sem::Array, sem::Matrix, sem::Vector>()) {
-    return nullptr;
-  }
-
-  ProgramBuilder& b = *ctx->dst;
-  using u32 = ProgramBuilder::u32;
-
-  uint32_t size = 0;
-  bool is_vec = ret_type->Is<sem::Vector>();
-  bool is_arr = ret_type->Is<sem::Array>();
-  if (is_vec || is_arr) {
-    size = is_vec ? ret_type->As<sem::Vector>()->size()
-                  : ret_type->As<sem::Array>()->Count();
-  } else {
-    // The row accessor would have been an embedded array accessor and already
-    // handled, so we just need to do columns here.
-    size = ret_type->As<sem::Matrix>()->columns();
-  }
-
-  auto* const old_idx = expr->idx_expr();
-  b.SetSource(ctx->Clone(old_idx->source()));
-
-  ast::Expression* new_idx = nullptr;
-
-  if (size == 0) {
-    if (!is_arr) {
-      b.Diagnostics().add_error(diag::System::Transform,
-                                "invalid 0 sized non-array", expr->source());
-      return nullptr;
-    }
-    // Runtime sized array
-    auto* arr = ctx->Clone(expr->array());
-    auto* arr_len = b.Call("arrayLength", b.AddressOf(arr));
-    auto* limit = b.Sub(arr_len, b.Expr(1u));
-    new_idx = b.Call("min", b.Construct<u32>(ctx->Clone(old_idx)), limit);
-  } else if (auto* c = old_idx->As<ast::ScalarConstructorExpression>()) {
-    // Scalar constructor we can re-write the value to be within bounds.
-    auto* lit = c->literal();
-    if (auto* sint = lit->As<ast::SintLiteral>()) {
-      int32_t max = static_cast<int32_t>(size) - 1;
-      new_idx = b.Expr(std::max(std::min(sint->value(), max), 0));
-    } else if (auto* uint = lit->As<ast::UintLiteral>()) {
-      new_idx = b.Expr(std::min(uint->value(), size - 1));
-    } else {
-      b.Diagnostics().add_error(diag::System::Transform,
-                                "unknown scalar constructor type for accessor",
-                                expr->source());
-      return nullptr;
-    }
-  } else {
-    auto* cloned_idx = ctx->Clone(old_idx);
-    new_idx = b.Call("min", b.Construct<u32>(cloned_idx), b.Expr(size - 1));
-  }
-
-  // Clone arguments outside of create() call to have deterministic ordering
-  auto src = ctx->Clone(expr->source());
-  auto* arr = ctx->Clone(expr->array());
-  return b.IndexAccessor(src, arr, new_idx);
-}
-
-// Apply bounds clamping textureLoad() and textureStore() coordinates
-ast::CallExpression* Robustness::Transform(ast::CallExpression* expr,
-                                           CloneContext* ctx) {
-  auto* call = ctx->src->Sem().Get(expr);
-  auto* call_target = call->Target();
-  auto* intrinsic = call_target->As<sem::Intrinsic>();
-  if (!intrinsic || (intrinsic->Type() != sem::IntrinsicType::kTextureLoad &&
-                     intrinsic->Type() != sem::IntrinsicType::kTextureStore)) {
-    return nullptr;  // No transform, just clone.
-  }
-
-  // Index of the texture and coords parameters for the intrinsic overload
-  auto texture_idx =
-      sem::IndexOf(intrinsic->Parameters(), sem::ParameterUsage::kTexture);
-  auto coords_idx =
-      sem::IndexOf(intrinsic->Parameters(), sem::ParameterUsage::kCoords);
-
-  auto* texture_arg = expr->params()[texture_idx];
-  auto* coords_arg = expr->params()[coords_idx];
-  auto* coords_ty = intrinsic->Parameters()[coords_idx].type;
-
-  ProgramBuilder& b = *ctx->dst;
-  auto* texture_dims = b.Call("textureDimensions", ctx->Clone(texture_arg));
-  auto* zero_dims = b.Construct(CreateASTTypeFor(ctx, coords_ty));
-  auto* clamped_coords =
-      b.Call("clamp", ctx->Clone(coords_arg), zero_dims, texture_dims);
-
-  ctx->Replace(coords_arg, clamped_coords);
-  return nullptr;  // Clone, which will use the coords replacement above.
-}
-
 }  // namespace transform
 }  // namespace tint
diff --git a/src/transform/robustness.h b/src/transform/robustness.h
index 998b855..a4478f1 100644
--- a/src/transform/robustness.h
+++ b/src/transform/robustness.h
@@ -49,9 +49,7 @@
   void Run(CloneContext& ctx, const DataMap& inputs, DataMap& outputs) override;
 
  private:
-  ast::ArrayAccessorExpression* Transform(ast::ArrayAccessorExpression* expr,
-                                          CloneContext* ctx);
-  ast::CallExpression* Transform(ast::CallExpression* expr, CloneContext* ctx);
+  struct State;
 };
 
 using BoundArrayAccessors = Robustness;
diff --git a/src/transform/robustness_test.cc b/src/transform/robustness_test.cc
index 357b0b2..f5e2f3f 100644
--- a/src/transform/robustness_test.cc
+++ b/src/transform/robustness_test.cc
@@ -571,39 +571,83 @@
   FAIL();
 }
 
-// Clamp textureLoad() coord values
-TEST_F(RobustnessTest, TextureLoad_TextureCoord_Clamp) {
+// Clamp textureLoad() coord, array_index and level values
+TEST_F(RobustnessTest, TextureLoad_Clamp) {
   auto* src = R"(
-[[group(0), binding(0)]] var tex1d : texture_1d<f32>;
-
-[[group(0), binding(1)]] var tex2d : texture_2d<f32>;
-
-[[group(0), binding(2)]] var tex3d : texture_3d<f32>;
-
-[[group(0), binding(3)]] var tex2d_arr : texture_storage_2d_array<rgba8sint, read>;
+[[group(0), binding(0)]] var tex_1d : texture_1d<f32>;
+[[group(0), binding(0)]] var tex_2d : texture_2d<f32>;
+[[group(0), binding(0)]] var tex_2d_arr : texture_2d_array<f32>;
+[[group(0), binding(0)]] var tex_3d : texture_3d<f32>;
+[[group(0), binding(0)]] var tex_ms_2d : texture_multisampled_2d<f32>;
+[[group(0), binding(0)]] var tex_depth_2d : texture_depth_2d;
+[[group(0), binding(0)]] var tex_depth_2d_arr : texture_depth_2d_array;
+[[group(0), binding(0)]] var tex_storage_1d : texture_storage_1d<rgba8sint, read>;
+[[group(0), binding(0)]] var tex_storage_2d : texture_storage_2d<rgba8sint, read>;
+[[group(0), binding(0)]] var tex_storage_2d_arr : texture_storage_2d_array<rgba8sint, read>;
+[[group(0), binding(0)]] var tex_storage_3d : texture_storage_3d<rgba8sint, read>;
+[[group(0), binding(0)]] var tex_external : texture_external;
 
 fn f() {
-  ignore(textureLoad(tex1d, 10, 100));
-  ignore(textureLoad(tex2d, vec2<i32>(10, 20), 100));
-  ignore(textureLoad(tex3d, vec3<i32>(10, 20, 30), 100));
-  ignore(textureLoad(tex2d_arr, vec2<i32>(10, 20), 100));
+  var array_idx : i32;
+  var level_idx : i32;
+  var sample_idx : i32;
+
+  ignore(textureLoad(tex_1d, 1, level_idx));
+  ignore(textureLoad(tex_2d, vec2<i32>(1, 2), level_idx));
+  ignore(textureLoad(tex_2d_arr, vec2<i32>(1, 2), array_idx, level_idx));
+  ignore(textureLoad(tex_3d, vec3<i32>(1, 2, 3), level_idx));
+  ignore(textureLoad(tex_ms_2d, vec2<i32>(1, 2), sample_idx));
+  ignore(textureLoad(tex_depth_2d, vec2<i32>(1, 2), level_idx));
+  ignore(textureLoad(tex_depth_2d_arr, vec2<i32>(1, 2), array_idx, level_idx));
+  ignore(textureLoad(tex_storage_1d, 1));
+  ignore(textureLoad(tex_storage_2d, vec2<i32>(1, 2)));
+  ignore(textureLoad(tex_storage_2d_arr, vec2<i32>(1, 2), array_idx));
+  ignore(textureLoad(tex_storage_3d, vec3<i32>(1, 2, 3)));
+  ignore(textureLoad(tex_external, vec2<i32>(1, 2)));
 }
 )";
 
   auto* expect = R"(
-[[group(0), binding(0)]] var tex1d : texture_1d<f32>;
+[[group(0), binding(0)]] var tex_1d : texture_1d<f32>;
 
-[[group(0), binding(1)]] var tex2d : texture_2d<f32>;
+[[group(0), binding(0)]] var tex_2d : texture_2d<f32>;
 
-[[group(0), binding(2)]] var tex3d : texture_3d<f32>;
+[[group(0), binding(0)]] var tex_2d_arr : texture_2d_array<f32>;
 
-[[group(0), binding(3)]] var tex2d_arr : texture_storage_2d_array<rgba8sint, read>;
+[[group(0), binding(0)]] var tex_3d : texture_3d<f32>;
+
+[[group(0), binding(0)]] var tex_ms_2d : texture_multisampled_2d<f32>;
+
+[[group(0), binding(0)]] var tex_depth_2d : texture_depth_2d;
+
+[[group(0), binding(0)]] var tex_depth_2d_arr : texture_depth_2d_array;
+
+[[group(0), binding(0)]] var tex_storage_1d : texture_storage_1d<rgba8sint, read>;
+
+[[group(0), binding(0)]] var tex_storage_2d : texture_storage_2d<rgba8sint, read>;
+
+[[group(0), binding(0)]] var tex_storage_2d_arr : texture_storage_2d_array<rgba8sint, read>;
+
+[[group(0), binding(0)]] var tex_storage_3d : texture_storage_3d<rgba8sint, read>;
+
+[[group(0), binding(0)]] var tex_external : external_texture;
 
 fn f() {
-  ignore(textureLoad(tex1d, clamp(10, i32(), textureDimensions(tex1d)), 100));
-  ignore(textureLoad(tex2d, clamp(vec2<i32>(10, 20), vec2<i32>(), textureDimensions(tex2d)), 100));
-  ignore(textureLoad(tex3d, clamp(vec3<i32>(10, 20, 30), vec3<i32>(), textureDimensions(tex3d)), 100));
-  ignore(textureLoad(tex2d_arr, clamp(vec2<i32>(10, 20), vec2<i32>(), textureDimensions(tex2d_arr)), 100));
+  var array_idx : i32;
+  var level_idx : i32;
+  var sample_idx : i32;
+  ignore(textureLoad(tex_1d, clamp(1, i32(), (textureDimensions(tex_1d, clamp(level_idx, 0, (textureNumLevels(tex_1d) - 1))) - i32(1))), clamp(level_idx, 0, (textureNumLevels(tex_1d) - 1))));
+  ignore(textureLoad(tex_2d, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_2d, clamp(level_idx, 0, (textureNumLevels(tex_2d) - 1))) - vec2<i32>(1))), clamp(level_idx, 0, (textureNumLevels(tex_2d) - 1))));
+  ignore(textureLoad(tex_2d_arr, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_2d_arr, clamp(level_idx, 0, (textureNumLevels(tex_2d_arr) - 1))) - vec2<i32>(1))), clamp(array_idx, 0, (textureNumLayers(tex_2d_arr) - 1)), clamp(level_idx, 0, (textureNumLevels(tex_2d_arr) - 1))));
+  ignore(textureLoad(tex_3d, clamp(vec3<i32>(1, 2, 3), vec3<i32>(), (textureDimensions(tex_3d, clamp(level_idx, 0, (textureNumLevels(tex_3d) - 1))) - vec3<i32>(1))), clamp(level_idx, 0, (textureNumLevels(tex_3d) - 1))));
+  ignore(textureLoad(tex_ms_2d, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_ms_2d) - vec2<i32>(1))), sample_idx));
+  ignore(textureLoad(tex_depth_2d, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_depth_2d, clamp(level_idx, 0, (textureNumLevels(tex_depth_2d) - 1))) - vec2<i32>(1))), clamp(level_idx, 0, (textureNumLevels(tex_depth_2d) - 1))));
+  ignore(textureLoad(tex_depth_2d_arr, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_depth_2d_arr, clamp(level_idx, 0, (textureNumLevels(tex_depth_2d_arr) - 1))) - vec2<i32>(1))), clamp(array_idx, 0, (textureNumLayers(tex_depth_2d_arr) - 1)), clamp(level_idx, 0, (textureNumLevels(tex_depth_2d_arr) - 1))));
+  ignore(textureLoad(tex_storage_1d, clamp(1, i32(), (textureDimensions(tex_storage_1d) - i32(1)))));
+  ignore(textureLoad(tex_storage_2d, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_storage_2d) - vec2<i32>(1)))));
+  ignore(textureLoad(tex_storage_2d_arr, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_storage_2d_arr) - vec2<i32>(1))), clamp(array_idx, 0, (textureNumLayers(tex_storage_2d_arr) - 1))));
+  ignore(textureLoad(tex_storage_3d, clamp(vec3<i32>(1, 2, 3), vec3<i32>(), (textureDimensions(tex_storage_3d) - vec3<i32>(1)))));
+  ignore(textureLoad(tex_external, clamp(vec2<i32>(1, 2), vec2<i32>(), (textureDimensions(tex_external) - vec2<i32>(1)))));
 }
 )";
 
@@ -612,22 +656,22 @@
   EXPECT_EQ(expect, str(got));
 }
 
-// Clamp textureStore() coord values
-TEST_F(RobustnessTest, TextureStore_TextureCoord_Clamp) {
+// Clamp textureStore() coord, array_index and level values
+TEST_F(RobustnessTest, TextureStore_Clamp) {
   auto* src = R"(
 [[group(0), binding(0)]] var tex1d : texture_storage_1d<rgba8sint, write>;
 
 [[group(0), binding(1)]] var tex2d : texture_storage_2d<rgba8sint, write>;
 
-[[group(0), binding(2)]] var tex3d : texture_storage_3d<rgba8sint, write>;
+[[group(0), binding(2)]] var tex2d_arr : texture_storage_2d_array<rgba8sint, write>;
 
-[[group(0), binding(3)]] var tex2d_arr : texture_storage_2d_array<rgba8sint, write>;
+[[group(0), binding(3)]] var tex3d : texture_storage_3d<rgba8sint, write>;
 
 fn f() {
   textureStore(tex1d, 10, vec4<i32>());
   textureStore(tex2d, vec2<i32>(10, 20), vec4<i32>());
-  textureStore(tex3d, vec3<i32>(10, 20, 30), vec4<i32>());
   textureStore(tex2d_arr, vec2<i32>(10, 20), 50, vec4<i32>());
+  textureStore(tex3d, vec3<i32>(10, 20, 30), vec4<i32>());
 }
 )";
 
@@ -636,15 +680,15 @@
 
 [[group(0), binding(1)]] var tex2d : texture_storage_2d<rgba8sint, write>;
 
-[[group(0), binding(2)]] var tex3d : texture_storage_3d<rgba8sint, write>;
+[[group(0), binding(2)]] var tex2d_arr : texture_storage_2d_array<rgba8sint, write>;
 
-[[group(0), binding(3)]] var tex2d_arr : texture_storage_2d_array<rgba8sint, write>;
+[[group(0), binding(3)]] var tex3d : texture_storage_3d<rgba8sint, write>;
 
 fn f() {
-  textureStore(tex1d, clamp(10, i32(), textureDimensions(tex1d)), vec4<i32>());
-  textureStore(tex2d, clamp(vec2<i32>(10, 20), vec2<i32>(), textureDimensions(tex2d)), vec4<i32>());
-  textureStore(tex3d, clamp(vec3<i32>(10, 20, 30), vec3<i32>(), textureDimensions(tex3d)), vec4<i32>());
-  textureStore(tex2d_arr, clamp(vec2<i32>(10, 20), vec2<i32>(), textureDimensions(tex2d_arr)), 50, vec4<i32>());
+  textureStore(tex1d, clamp(10, i32(), (textureDimensions(tex1d) - i32(1))), vec4<i32>());
+  textureStore(tex2d, clamp(vec2<i32>(10, 20), vec2<i32>(), (textureDimensions(tex2d) - vec2<i32>(1))), vec4<i32>());
+  textureStore(tex2d_arr, clamp(vec2<i32>(10, 20), vec2<i32>(), (textureDimensions(tex2d_arr) - vec2<i32>(1))), clamp(50, 0, (textureNumLayers(tex2d_arr) - 1)), vec4<i32>());
+  textureStore(tex3d, clamp(vec3<i32>(10, 20, 30), vec3<i32>(), (textureDimensions(tex3d) - vec3<i32>(1))), vec4<i32>());
 }
 )";