diff --git a/src/BUILD.gn b/src/BUILD.gn
index 3084e1f..c12abeb 100644
--- a/src/BUILD.gn
+++ b/src/BUILD.gn
@@ -437,6 +437,8 @@
     "transform/calculate_array_length.h",
     "transform/canonicalize_entry_point_io.cc",
     "transform/canonicalize_entry_point_io.h",
+    "transform/combine_samplers.cc",
+    "transform/combine_samplers.h",
     "transform/decompose_memory_access.cc",
     "transform/decompose_memory_access.h",
     "transform/decompose_strided_matrix.cc",
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index db5071f..23efeb4 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -303,6 +303,8 @@
   transform/binding_remapper.h
   transform/calculate_array_length.cc
   transform/calculate_array_length.h
+  transform/combine_samplers.cc
+  transform/combine_samplers.h
   transform/canonicalize_entry_point_io.cc
   transform/canonicalize_entry_point_io.h
   transform/decompose_memory_access.cc
@@ -976,6 +978,7 @@
       transform/binding_remapper_test.cc
       transform/calculate_array_length_test.cc
       transform/canonicalize_entry_point_io_test.cc
+      transform/combine_samplers_test.cc
       transform/decompose_memory_access_test.cc
       transform/decompose_strided_matrix_test.cc
       transform/external_texture_transform_test.cc
diff --git a/src/transform/combine_samplers.cc b/src/transform/combine_samplers.cc
new file mode 100644
index 0000000..ce20657
--- /dev/null
+++ b/src/transform/combine_samplers.cc
@@ -0,0 +1,312 @@
+// 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/transform/combine_samplers.h"
+
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "src/sem/function.h"
+#include "src/sem/statement.h"
+
+#include "src/utils/map.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::transform::CombineSamplers);
+TINT_INSTANTIATE_TYPEINFO(tint::transform::CombineSamplers::BindingInfo);
+
+namespace {
+
+bool IsGlobal(const tint::sem::VariablePair& pair) {
+  return pair.first->Is<tint::sem::GlobalVariable>() &&
+         (!pair.second || pair.second->Is<tint::sem::GlobalVariable>());
+}
+
+}  // namespace
+
+namespace tint {
+namespace transform {
+
+CombineSamplers::BindingInfo::BindingInfo(const BindingMap& map)
+    : binding_map(map) {}
+CombineSamplers::BindingInfo::BindingInfo(const BindingInfo& other) = default;
+CombineSamplers::BindingInfo::~BindingInfo() = default;
+
+/// The PIMPL state for the CombineSamplers transform
+struct CombineSamplers::State {
+  /// The clone context
+  CloneContext& ctx;
+
+  /// The binding info
+  const BindingInfo* binding_info;
+
+  /// Map from a texture/sampler pair to the corresponding combined sampler
+  /// variable
+  using CombinedTextureSamplerMap =
+      std::unordered_map<sem::VariablePair, const ast::Variable*>;
+
+  /// Use sem::BindingPoint without scope.
+  using BindingPoint = sem::BindingPoint;
+
+  /// A map of all global texture/sampler variable pairs to the global
+  /// combined sampler variable that will replace it.
+  CombinedTextureSamplerMap global_combined_texture_samplers_;
+
+  /// A map of all texture/sampler variable pairs that contain a function
+  /// parameter to the combined sampler function paramter that will replace it.
+  std::unordered_map<const sem::Function*, CombinedTextureSamplerMap>
+      function_combined_texture_samplers_;
+
+  /// Placeholder global samplers used when a function contains texture-only
+  /// references (one comparison sampler, one regular). These are also used as
+  /// temporary sampler parameters to the texture intrinsics to satsify the WGSL
+  /// resolver, but are then ignored and removed by the GLSL writer.
+  const ast::Variable* placeholder_samplers_[2] = {};
+
+  /// Group and binding decorations used by all combined sampler globals.
+  /// Group 0 and binding 0 are used, with collisions disabled.
+  /// @returns the newly-created decoration list
+  ast::DecorationList Decorations() const {
+    auto decorations = ctx.dst->GroupAndBinding(0, 0);
+    decorations.push_back(
+        ctx.dst->Disable(ast::DisabledValidation::kBindingPointCollision));
+    return decorations;
+  }
+
+  /// Constructor
+  /// @param context the clone context
+  /// @param info the binding map information
+  State(CloneContext& context, const BindingInfo* info)
+      : ctx(context), binding_info(info) {}
+
+  /// Creates a combined sampler global variables.
+  /// (Note this is actually a Texture node at the AST level, but it will be
+  /// written as the corresponding sampler (eg., sampler2D) on GLSL output.)
+  /// @param texture_var the texture (global) variable
+  /// @param sampler_var the sampler (global) variable
+  /// @param name the default name to use (may be overridden by map lookup)
+  /// @returns the newly-created global variable
+  const ast::Variable* CreateCombinedGlobal(const sem::Variable* texture_var,
+                                            const sem::Variable* sampler_var,
+                                            std::string name) {
+    SamplerTexturePair bp_pair;
+    bp_pair.texture_binding_point =
+        texture_var->As<sem::GlobalVariable>()->BindingPoint();
+    bp_pair.sampler_binding_point =
+        sampler_var ? sampler_var->As<sem::GlobalVariable>()->BindingPoint()
+                    : BindingPoint();
+    auto it = binding_info->binding_map.find(bp_pair);
+    if (it != binding_info->binding_map.end()) {
+      name = it->second;
+    }
+    const ast::Type* type = CreateASTTypeFor(ctx, texture_var->Type());
+    Symbol symbol = ctx.dst->Symbols().New(name);
+    return ctx.dst->Global(symbol, type, Decorations());
+  }
+
+  /// Creates placeholder global sampler variables.
+  /// @param kind the sampler kind to create for
+  /// @returns the newly-created global variable
+  const ast::Variable* CreatePlaceholder(ast::SamplerKind kind) {
+    const ast::Type* type = ctx.dst->ty.sampler(kind);
+    const char* name = kind == ast::SamplerKind::kComparisonSampler
+                           ? "placeholder_comparison_sampler"
+                           : "placeholder_sampler";
+    Symbol symbol = ctx.dst->Symbols().New(name);
+    return ctx.dst->Global(symbol, type, Decorations());
+  }
+
+  /// Performs the transformation
+  void Run() {
+    auto& sem = ctx.src->Sem();
+
+    // Remove all texture and sampler global variables. These will be replaced
+    // by combined samplers.
+    for (auto* var : ctx.src->AST().GlobalVariables()) {
+      if (sem.Get(var->type)->IsAnyOf<sem::Texture, sem::Sampler>()) {
+        ctx.Remove(ctx.src->AST().GlobalDeclarations(), var);
+      }
+    }
+
+    // Rewrite all function signatures to use combined samplers, and remove
+    // separate textures & samplers. Create new combined globals where found.
+    ctx.ReplaceAll([&](const ast::Function* src) -> const ast::Function* {
+      if (auto* func = sem.Get(src)) {
+        auto pairs = func->TextureSamplerPairs();
+        if (pairs.empty()) {
+          return nullptr;
+        }
+        ast::VariableList params;
+        for (auto pair : func->TextureSamplerPairs()) {
+          const sem::Variable* texture_var = pair.first;
+          const sem::Variable* sampler_var = pair.second;
+          std::string name =
+              ctx.src->Symbols().NameFor(texture_var->Declaration()->symbol);
+          if (sampler_var) {
+            name += "_" + ctx.src->Symbols().NameFor(
+                              sampler_var->Declaration()->symbol);
+          }
+          if (IsGlobal(pair)) {
+            // Both texture and sampler are global; add a new global variable
+            // to represent the combined sampler (if not already created).
+            utils::GetOrCreate(global_combined_texture_samplers_, pair, [&] {
+              return CreateCombinedGlobal(texture_var, sampler_var, name);
+            });
+          } else {
+            // Either texture or sampler (or both) is a function parameter;
+            // add a new function parameter to represent the combined sampler.
+            const ast::Type* type = CreateASTTypeFor(ctx, texture_var->Type());
+            const ast::Variable* var =
+                ctx.dst->Param(ctx.dst->Symbols().New(name), type);
+            params.push_back(var);
+            function_combined_texture_samplers_[func][pair] = var;
+          }
+        }
+        // Filter out separate textures and samplers from the original
+        // function signature.
+        for (auto* var : src->params) {
+          if (!sem.Get(var->type)->IsAnyOf<sem::Texture, sem::Sampler>()) {
+            params.push_back(ctx.Clone(var));
+          }
+        }
+        // Create a new function signature that differs only in the parameter
+        // list.
+        auto symbol = ctx.Clone(src->symbol);
+        auto* return_type = ctx.Clone(src->return_type);
+        auto* body = ctx.Clone(src->body);
+        auto decorations = ctx.Clone(src->decorations);
+        auto return_type_decorations = ctx.Clone(src->return_type_decorations);
+        return ctx.dst->create<ast::Function>(
+            symbol, params, return_type, body, std::move(decorations),
+            std::move(return_type_decorations));
+      }
+      return nullptr;
+    });
+
+    // Replace all function call expressions containing texture or
+    // sampler parameters to use the current function's combined samplers or
+    // the combined global samplers, as appropriate.
+    ctx.ReplaceAll([&](const ast::CallExpression* expr)
+                       -> const ast::Expression* {
+      if (auto* call = sem.Get(expr)) {
+        ast::ExpressionList args;
+        // Replace all texture intrinsic calls.
+        if (auto* intrinsic = call->Target()->As<sem::Intrinsic>()) {
+          const auto& signature = intrinsic->Signature();
+          int sampler_index = signature.IndexOf(sem::ParameterUsage::kSampler);
+          int texture_index = signature.IndexOf(sem::ParameterUsage::kTexture);
+          if (texture_index == -1) {
+            return nullptr;
+          }
+          const sem::Expression* texture = call->Arguments()[texture_index];
+          const sem::Expression* sampler =
+              sampler_index != -1 ? call->Arguments()[sampler_index] : nullptr;
+          auto* texture_var = texture->As<sem::VariableUser>()->Variable();
+          auto* sampler_var =
+              sampler ? sampler->As<sem::VariableUser>()->Variable() : nullptr;
+          sem::VariablePair new_pair(texture_var, sampler_var);
+          for (auto* arg : expr->args) {
+            auto* type = ctx.src->TypeOf(arg)->UnwrapRef();
+            if (type->Is<sem::Texture>()) {
+              const ast::Variable* var =
+                  IsGlobal(new_pair)
+                      ? global_combined_texture_samplers_[new_pair]
+                      : function_combined_texture_samplers_
+                            [call->Stmt()->Function()][new_pair];
+              args.push_back(ctx.dst->Expr(var->symbol));
+            } else if (auto* sampler_type = type->As<sem::Sampler>()) {
+              ast::SamplerKind kind = sampler_type->kind();
+              int index = (kind == ast::SamplerKind::kSampler) ? 0 : 1;
+              const ast::Variable*& p = placeholder_samplers_[index];
+              if (!p) {
+                p = CreatePlaceholder(kind);
+              }
+              args.push_back(ctx.dst->Expr(p->symbol));
+            } else {
+              args.push_back(ctx.Clone(arg));
+            }
+          }
+          return ctx.dst->Call(ctx.Clone(expr->target.name), args);
+        }
+        // Replace all function calls.
+        if (auto* callee = call->Target()->As<sem::Function>()) {
+          for (auto pair : callee->TextureSamplerPairs()) {
+            // Global pairs used by the callee do not require a function
+            // parameter at the call site.
+            if (IsGlobal(pair)) {
+              continue;
+            }
+            const sem::Variable* texture_var = pair.first;
+            const sem::Variable* sampler_var = pair.second;
+            if (auto* param = texture_var->As<sem::Parameter>()) {
+              const sem::Expression* texture =
+                  call->Arguments()[param->Index()];
+              texture_var = texture->As<sem::VariableUser>()->Variable();
+            }
+            if (sampler_var) {
+              if (auto* param = sampler_var->As<sem::Parameter>()) {
+                const sem::Expression* sampler =
+                    call->Arguments()[param->Index()];
+                sampler_var = sampler->As<sem::VariableUser>()->Variable();
+              }
+            }
+            sem::VariablePair new_pair(texture_var, sampler_var);
+            // If both texture and sampler are (now) global, pass that
+            // global variable to the callee. Otherwise use the caller's
+            // function parameter for this pair.
+            const ast::Variable* var =
+                IsGlobal(new_pair) ? global_combined_texture_samplers_[new_pair]
+                                   : function_combined_texture_samplers_
+                                         [call->Stmt()->Function()][new_pair];
+            auto* arg = ctx.dst->Expr(var->symbol);
+            args.push_back(arg);
+          }
+          // Append all of the remaining non-texture and non-sampler
+          // parameters.
+          for (auto* arg : expr->args) {
+            if (!ctx.src->TypeOf(arg)
+                     ->UnwrapRef()
+                     ->IsAnyOf<sem::Texture, sem::Sampler>()) {
+              args.push_back(ctx.Clone(arg));
+            }
+          }
+          return ctx.dst->Call(ctx.Clone(expr->target.name), args);
+        }
+      }
+      return nullptr;
+    });
+
+    ctx.Clone();
+  }
+};
+
+CombineSamplers::CombineSamplers() = default;
+
+CombineSamplers::~CombineSamplers() = default;
+
+void CombineSamplers::Run(CloneContext& ctx, const DataMap& inputs, DataMap&) {
+  auto* binding_info = inputs.Get<BindingInfo>();
+  if (!binding_info) {
+    ctx.dst->Diagnostics().add_error(
+        diag::System::Transform,
+        "missing transform data for " + std::string(TypeInfo().name));
+    return;
+  }
+
+  State(ctx, binding_info).Run();
+}
+
+}  // namespace transform
+}  // namespace tint
diff --git a/src/transform/combine_samplers.h b/src/transform/combine_samplers.h
new file mode 100644
index 0000000..ce83373
--- /dev/null
+++ b/src/transform/combine_samplers.h
@@ -0,0 +1,104 @@
+// 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_TRANSFORM_COMBINE_SAMPLERS_H_
+#define SRC_TRANSFORM_COMBINE_SAMPLERS_H_
+
+#include <string>
+#include <unordered_map>
+
+#include "src/sem/sampler_texture_pair.h"
+#include "src/transform/transform.h"
+
+namespace tint {
+namespace transform {
+
+/// This transform converts all separate texture/sampler refences in a
+/// program into combined texture/samplers. This is required for GLSL,
+/// which does not support separate texture/samplers.
+///
+/// It utilizes the texture/sampler information collected by the
+/// Resolver and stored on each sem::Function. For each function, all
+/// separate texture/sampler parameters in the function signature are
+/// removed. For each unique pair, if both texture and sampler are
+/// global variables, the function passes the corresponding combined
+/// global stored in global_combined_texture_samplers_ at the call
+/// site. Otherwise, either the texture or sampler must be a function
+/// parameter. In this case, a new parameter is added to the function
+/// signature. All separate texture/sampler parameters are removed.
+///
+/// All texture intrinsic callsites are modified to pass the combined
+/// texture/sampler as the first argument, and separate texture/sampler
+/// arugments are removed.
+///
+/// Note that the sampler may be null, indicating that only a texture
+/// reference was required (e.g., textureLoad). In this case, a
+/// placeholder global sampler is used at the AST level. This will be
+/// combined with the original texture to give a combined global, and
+/// the placeholder removed (ignored) by the GLSL writer.
+///
+/// Note that the combined samplers are actually represented by a
+/// Texture node at the AST level, since this contains all the
+/// information needed to represent a combined sampler in GLSL
+/// (dimensionality, component type, etc). The GLSL writer outputs such
+/// (Tint) Textures as (GLSL) Samplers.
+class CombineSamplers : public Castable<CombineSamplers, Transform> {
+ public:
+  /// A pair of binding points.
+  using SamplerTexturePair = sem::SamplerTexturePair;
+
+  /// A map from a sampler/texture pair to a named global.
+  using BindingMap = std::unordered_map<SamplerTexturePair, std::string>;
+
+  /// The client-provided mapping from separate texture and sampler binding
+  /// points to combined sampler binding point.
+  struct BindingInfo : public Castable<Data, transform::Data> {
+    /// Constructor
+    /// @param map the map of all (texture, sampler) -> (combined) pairs
+    explicit BindingInfo(const BindingMap& map);
+
+    /// Copy constructor
+    /// @param other the other BindingInfo to copy
+    BindingInfo(const BindingInfo& other);
+
+    /// Destructor
+    ~BindingInfo() override;
+
+    /// A map of bindings from (texture, sampler) -> combined sampler.
+    BindingMap binding_map;
+  };
+
+  /// Constructor
+  CombineSamplers();
+
+  /// Destructor
+  ~CombineSamplers() override;
+
+ protected:
+  /// The PIMPL state for this transform
+  struct State;
+
+  /// 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) override;
+};
+
+}  // namespace transform
+}  // namespace tint
+
+#endif  // SRC_TRANSFORM_COMBINE_SAMPLERS_H_
diff --git a/src/transform/combine_samplers_test.cc b/src/transform/combine_samplers_test.cc
new file mode 100644
index 0000000..60f836c
--- /dev/null
+++ b/src/transform/combine_samplers_test.cc
@@ -0,0 +1,656 @@
+// 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/transform/combine_samplers.h"
+
+#include <memory>
+#include <utility>
+
+#include "src/transform/test_helper.h"
+
+namespace tint {
+namespace transform {
+namespace {
+
+using CombineSamplersTest = TransformTest;
+
+TEST_F(CombineSamplersTest, EmptyModule) {
+  auto* src = "";
+  auto* expect = "";
+
+  DataMap data;
+  data.Add<CombineSamplers::BindingInfo>(CombineSamplers::BindingMap());
+  auto got = Run<CombineSamplers>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(CombineSamplersTest, SimplePair) {
+  auto* src = R"(
+@group(0) @binding(0) var t : texture_2d<f32>;
+
+@group(0) @binding(1) var s : sampler;
+
+fn main() -> vec4<f32> {
+  return textureSample(t, s, vec2<f32>(1.0, 2.0));
+}
+)";
+  auto* expect = R"(
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var t_s : texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var placeholder_sampler : sampler;
+
+fn main() -> vec4<f32> {
+  return textureSample(t_s, placeholder_sampler, vec2<f32>(1.0, 2.0));
+}
+)";
+
+  DataMap data;
+  data.Add<CombineSamplers::BindingInfo>(CombineSamplers::BindingMap());
+  auto got = Run<CombineSamplers>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(CombineSamplersTest, SimplePairInAFunction) {
+  auto* src = R"(
+@group(0) @binding(0) var t : texture_2d<f32>;
+
+@group(0) @binding(1) var s : sampler;
+
+fn sample(t : texture_2d<f32>, s : sampler, coords : vec2<f32>) -> vec4<f32> {
+  return textureSample(t, s, coords);
+}
+
+fn main() -> vec4<f32> {
+  return sample(t, s, vec2<f32>(1.0, 2.0));
+}
+)";
+  auto* expect = R"(
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var placeholder_sampler : sampler;
+
+fn sample(t_s : texture_2d<f32>, coords : vec2<f32>) -> vec4<f32> {
+  return textureSample(t_s, placeholder_sampler, coords);
+}
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var t_s_1 : texture_2d<f32>;
+
+fn main() -> vec4<f32> {
+  return sample(t_s_1, vec2<f32>(1.0, 2.0));
+}
+)";
+
+  DataMap data;
+  data.Add<CombineSamplers::BindingInfo>(CombineSamplers::BindingMap());
+  auto got = Run<CombineSamplers>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(CombineSamplersTest, SimplePairRename) {
+  auto* src = R"(
+@group(0) @binding(1) var t : texture_2d<f32>;
+
+@group(2) @binding(3) var s : sampler;
+
+fn main() -> vec4<f32> {
+  return textureSample(t, s, vec2<f32>(1.0, 2.0));
+}
+)";
+  auto* expect = R"(
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var fuzzy : texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var placeholder_sampler : sampler;
+
+fn main() -> vec4<f32> {
+  return textureSample(fuzzy, placeholder_sampler, vec2<f32>(1.0, 2.0));
+}
+)";
+
+  DataMap data;
+  CombineSamplers::BindingMap map;
+  sem::SamplerTexturePair pair;
+  pair.texture_binding_point.group = 0;
+  pair.texture_binding_point.binding = 1;
+  pair.sampler_binding_point.group = 2;
+  pair.sampler_binding_point.binding = 3;
+  map[pair] = "fuzzy";
+  data.Add<CombineSamplers::BindingInfo>(map);
+  auto got = Run<CombineSamplers>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(CombineSamplersTest, SimplePairRenameMiss) {
+  auto* src = R"(
+@group(0) @binding(1) var t : texture_2d<f32>;
+
+@group(2) @binding(3) var s : sampler;
+
+fn main() -> vec4<f32> {
+  return textureSample(t, s, vec2<f32>(1.0, 2.0));
+}
+)";
+  auto* expect = R"(
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var t_s : texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var placeholder_sampler : sampler;
+
+fn main() -> vec4<f32> {
+  return textureSample(t_s, placeholder_sampler, vec2<f32>(1.0, 2.0));
+}
+)";
+
+  DataMap data;
+  CombineSamplers::BindingMap map;
+  sem::SamplerTexturePair pair;
+  pair.texture_binding_point.group = 3;
+  pair.texture_binding_point.binding = 2;
+  pair.sampler_binding_point.group = 1;
+  pair.sampler_binding_point.binding = 0;
+  map[pair] = "fuzzy";
+  data.Add<CombineSamplers::BindingInfo>(map);
+  auto got = Run<CombineSamplers>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(CombineSamplersTest, AliasedTypes) {
+  auto* src = R"(
+
+type Tex2d = texture_2d<f32>;
+
+@group(0) @binding(0) var t : Tex2d;
+
+@group(0) @binding(1) var s : sampler;
+
+fn sample(t : Tex2d, s : sampler, coords : vec2<f32>) -> vec4<f32> {
+  return textureSample(t, s, coords);
+}
+
+fn main() -> vec4<f32> {
+  return sample(t, s, vec2<f32>(1.0, 2.0));
+}
+)";
+  auto* expect = R"(
+type Tex2d = texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var placeholder_sampler : sampler;
+
+fn sample(t_s : texture_2d<f32>, coords : vec2<f32>) -> vec4<f32> {
+  return textureSample(t_s, placeholder_sampler, coords);
+}
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var t_s_1 : texture_2d<f32>;
+
+fn main() -> vec4<f32> {
+  return sample(t_s_1, vec2<f32>(1.0, 2.0));
+}
+)";
+
+  DataMap data;
+  data.Add<CombineSamplers::BindingInfo>(CombineSamplers::BindingMap());
+  auto got = Run<CombineSamplers>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(CombineSamplersTest, SimplePairInTwoFunctions) {
+  auto* src = R"(
+@group(0) @binding(0) var t : texture_2d<f32>;
+
+@group(0) @binding(1) var s : sampler;
+
+fn g(t : texture_2d<f32>, s : sampler, coords : vec2<f32>) -> vec4<f32> {
+  return textureSample(t, s, coords);
+}
+
+fn f(t : texture_2d<f32>, s : sampler, coords : vec2<f32>) -> vec4<f32> {
+  return g(t, s, coords);
+}
+
+fn main() -> vec4<f32> {
+  return f(t, s, vec2<f32>(1.0, 2.0));
+}
+)";
+  auto* expect = R"(
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var placeholder_sampler : sampler;
+
+fn g(t_s : texture_2d<f32>, coords : vec2<f32>) -> vec4<f32> {
+  return textureSample(t_s, placeholder_sampler, coords);
+}
+
+fn f(t_s_1 : texture_2d<f32>, coords : vec2<f32>) -> vec4<f32> {
+  return g(t_s_1, coords);
+}
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var t_s_2 : texture_2d<f32>;
+
+fn main() -> vec4<f32> {
+  return f(t_s_2, vec2<f32>(1.0, 2.0));
+}
+)";
+
+  DataMap data;
+  data.Add<CombineSamplers::BindingInfo>(CombineSamplers::BindingMap());
+  auto got = Run<CombineSamplers>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(CombineSamplersTest, TwoFunctionsGenerateSamePair) {
+  auto* src = R"(
+@group(1) @binding(0) var tex : texture_2d<f32>;
+
+@group(1) @binding(1) var samp : sampler;
+
+fn f() -> vec4<f32> {
+  return textureSample(tex, samp, vec2<f32>(1.0, 2.0));
+}
+
+fn g() -> vec4<f32> {
+  return textureSample(tex, samp, vec2<f32>(3.0, 4.0));
+}
+
+fn main() -> vec4<f32> {
+  return f() + g();
+}
+)";
+  auto* expect = R"(
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex_samp : texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var placeholder_sampler : sampler;
+
+fn f() -> vec4<f32> {
+  return textureSample(tex_samp, placeholder_sampler, vec2<f32>(1.0, 2.0));
+}
+
+fn g() -> vec4<f32> {
+  return textureSample(tex_samp, placeholder_sampler, vec2<f32>(3.0, 4.0));
+}
+
+fn main() -> vec4<f32> {
+  return (f() + g());
+}
+)";
+
+  DataMap data;
+  data.Add<CombineSamplers::BindingInfo>(CombineSamplers::BindingMap());
+  auto got = Run<CombineSamplers>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(CombineSamplersTest, ThreeTexturesThreeSamplers) {
+  auto* src = R"(
+@group(0) @binding(0) var tex1 : texture_2d<f32>;
+@group(0) @binding(1) var tex2 : texture_2d<f32>;
+@group(0) @binding(2) var tex3 : texture_2d<f32>;
+
+@group(1) @binding(0) var samp1 : sampler;
+@group(1) @binding(1) var samp2: sampler;
+@group(1) @binding(2) var samp3: sampler;
+
+fn sample(t : texture_2d<f32>, s : sampler) -> vec4<f32> {
+  return textureSample(t, s, vec2<f32>(1.0, 2.0));
+}
+
+fn main() -> vec4<f32> {
+  return sample(tex1, samp1)
+       + sample(tex1, samp2)
+       + sample(tex1, samp3)
+       + sample(tex2, samp1)
+       + sample(tex2, samp2)
+       + sample(tex2, samp3)
+       + sample(tex3, samp1)
+       + sample(tex3, samp2)
+       + sample(tex3, samp3);
+}
+)";
+  auto* expect = R"(
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var placeholder_sampler : sampler;
+
+fn sample(t_s : texture_2d<f32>) -> vec4<f32> {
+  return textureSample(t_s, placeholder_sampler, vec2<f32>(1.0, 2.0));
+}
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex1_samp1 : texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex1_samp2 : texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex1_samp3 : texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex2_samp1 : texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex2_samp2 : texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex2_samp3 : texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex3_samp1 : texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex3_samp2 : texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex3_samp3 : texture_2d<f32>;
+
+fn main() -> vec4<f32> {
+  return ((((((((sample(tex1_samp1) + sample(tex1_samp2)) + sample(tex1_samp3)) + sample(tex2_samp1)) + sample(tex2_samp2)) + sample(tex2_samp3)) + sample(tex3_samp1)) + sample(tex3_samp2)) + sample(tex3_samp3));
+}
+)";
+
+  DataMap data;
+  data.Add<CombineSamplers::BindingInfo>(CombineSamplers::BindingMap());
+  auto got = Run<CombineSamplers>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(CombineSamplersTest, TwoFunctionsTwoTexturesDiamond) {
+  auto* src = R"(
+@group(0) @binding(0) var tex1 : texture_2d<f32>;
+
+@group(0) @binding(1) var tex2 : texture_2d<f32>;
+
+@group(0) @binding(2) var samp : sampler;
+
+fn sample(t : texture_2d<f32>, s : sampler, coords : vec2<f32>) -> vec4<f32> {
+  return textureSample(t, s, coords);
+}
+
+fn f(t1 : texture_2d<f32>, t2 : texture_2d<f32>, s : sampler, coords : vec2<f32>) -> vec4<f32> {
+  return sample(t1, s, coords) + sample(t2, s, coords);
+}
+
+fn main() -> vec4<f32> {
+  return f(tex1, tex2, samp, vec2<f32>(1.0, 2.0));
+}
+)";
+  auto* expect = R"(
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var placeholder_sampler : sampler;
+
+fn sample(t_s : texture_2d<f32>, coords : vec2<f32>) -> vec4<f32> {
+  return textureSample(t_s, placeholder_sampler, coords);
+}
+
+fn f(t1_s : texture_2d<f32>, t2_s : texture_2d<f32>, coords : vec2<f32>) -> vec4<f32> {
+  return (sample(t1_s, coords) + sample(t2_s, coords));
+}
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex1_samp : texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex2_samp : texture_2d<f32>;
+
+fn main() -> vec4<f32> {
+  return f(tex1_samp, tex2_samp, vec2<f32>(1.0, 2.0));
+}
+)";
+
+  DataMap data;
+  data.Add<CombineSamplers::BindingInfo>(CombineSamplers::BindingMap());
+  auto got = Run<CombineSamplers>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(CombineSamplersTest, TwoFunctionsTwoSamplersDiamond) {
+  auto* src = R"(
+@group(0) @binding(0) var tex : texture_2d<f32>;
+
+@group(0) @binding(1) var samp1 : sampler;
+
+@group(0) @binding(2) var samp2 : sampler;
+
+fn sample(t : texture_2d<f32>, s : sampler, coords : vec2<f32>) -> vec4<f32> {
+  return textureSample(t, s, coords);
+}
+
+fn f(t : texture_2d<f32>, s1 : sampler, s2 : sampler, coords : vec2<f32>) -> vec4<f32> {
+  return sample(t, s1, coords) + sample(t, s2, coords);
+}
+
+fn main() -> vec4<f32> {
+  return f(tex, samp1, samp2, vec2<f32>(1.0, 2.0));
+}
+)";
+  auto* expect = R"(
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var placeholder_sampler : sampler;
+
+fn sample(t_s : texture_2d<f32>, coords : vec2<f32>) -> vec4<f32> {
+  return textureSample(t_s, placeholder_sampler, coords);
+}
+
+fn f(t_s1 : texture_2d<f32>, t_s2 : texture_2d<f32>, coords : vec2<f32>) -> vec4<f32> {
+  return (sample(t_s1, coords) + sample(t_s2, coords));
+}
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex_samp1 : texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex_samp2 : texture_2d<f32>;
+
+fn main() -> vec4<f32> {
+  return f(tex_samp1, tex_samp2, vec2<f32>(1.0, 2.0));
+}
+)";
+
+  DataMap data;
+  data.Add<CombineSamplers::BindingInfo>(CombineSamplers::BindingMap());
+  auto got = Run<CombineSamplers>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(CombineSamplersTest, GlobalTextureLocalSampler) {
+  auto* src = R"(
+@group(0) @binding(0) var tex : texture_2d<f32>;
+
+@group(0) @binding(1) var samp1 : sampler;
+
+@group(0) @binding(2) var samp2 : sampler;
+
+fn f(s1 : sampler, s2 : sampler, coords : vec2<f32>) -> vec4<f32> {
+  return textureSample(tex, s1, coords) + textureSample(tex, s2, coords);
+}
+
+fn main() -> vec4<f32> {
+  return f(samp1, samp2, vec2<f32>(1.0, 2.0));
+}
+)";
+  auto* expect = R"(
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var placeholder_sampler : sampler;
+
+fn f(tex_s1 : texture_2d<f32>, tex_s2 : texture_2d<f32>, coords : vec2<f32>) -> vec4<f32> {
+  return (textureSample(tex_s1, placeholder_sampler, coords) + textureSample(tex_s2, placeholder_sampler, coords));
+}
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex_samp1 : texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex_samp2 : texture_2d<f32>;
+
+fn main() -> vec4<f32> {
+  return f(tex_samp1, tex_samp2, vec2<f32>(1.0, 2.0));
+}
+)";
+
+  DataMap data;
+  data.Add<CombineSamplers::BindingInfo>(CombineSamplers::BindingMap());
+  auto got = Run<CombineSamplers>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(CombineSamplersTest, LocalTextureGlobalSampler) {
+  auto* src = R"(
+@group(0) @binding(0) var tex1 : texture_2d<f32>;
+
+@group(0) @binding(1) var tex2 : texture_2d<f32>;
+
+@group(0) @binding(2) var samp : sampler;
+
+fn f(t1 : texture_2d<f32>, t2 : texture_2d<f32>, coords : vec2<f32>) -> vec4<f32> {
+  return textureSample(t1, samp, coords) + textureSample(t2, samp, coords);
+}
+
+fn main() -> vec4<f32> {
+  return f(tex1, tex2, vec2<f32>(1.0, 2.0));
+}
+)";
+  auto* expect = R"(
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var placeholder_sampler : sampler;
+
+fn f(t1_samp : texture_2d<f32>, t2_samp : texture_2d<f32>, coords : vec2<f32>) -> vec4<f32> {
+  return (textureSample(t1_samp, placeholder_sampler, coords) + textureSample(t2_samp, placeholder_sampler, coords));
+}
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex1_samp : texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex2_samp : texture_2d<f32>;
+
+fn main() -> vec4<f32> {
+  return f(tex1_samp, tex2_samp, vec2<f32>(1.0, 2.0));
+}
+)";
+
+  DataMap data;
+  data.Add<CombineSamplers::BindingInfo>(CombineSamplers::BindingMap());
+  auto got = Run<CombineSamplers>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(CombineSamplersTest, TextureLoadNoSampler) {
+  auto* src = R"(
+@group(0) @binding(0) var tex : texture_2d<f32>;
+
+fn f(t : texture_2d<f32>, coords : vec2<i32>) -> vec4<f32> {
+  return textureLoad(t, coords, 0);
+}
+
+fn main() -> vec4<f32> {
+  return f(tex, vec2<i32>(1, 2));
+}
+)";
+  auto* expect = R"(
+fn f(t_1 : texture_2d<f32>, coords : vec2<i32>) -> vec4<f32> {
+  return textureLoad(t_1, coords, 0);
+}
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex_1 : texture_2d<f32>;
+
+fn main() -> vec4<f32> {
+  return f(tex_1, vec2<i32>(1, 2));
+}
+)";
+
+  DataMap data;
+  data.Add<CombineSamplers::BindingInfo>(CombineSamplers::BindingMap());
+  auto got = Run<CombineSamplers>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(CombineSamplersTest, TextureSampleCompare) {
+  auto* src = R"(
+@group(0) @binding(0) var tex : texture_depth_2d;
+
+@group(0) @binding(1) var samp : sampler_comparison;
+
+fn main() -> vec4<f32> {
+  return vec4<f32>(textureSampleCompare(tex, samp, vec2<f32>(1.0, 2.0), 0.5));
+}
+)";
+  auto* expect = R"(
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex_samp : texture_depth_2d;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var placeholder_comparison_sampler : sampler_comparison;
+
+fn main() -> vec4<f32> {
+  return vec4<f32>(textureSampleCompare(tex_samp, placeholder_comparison_sampler, vec2<f32>(1.0, 2.0), 0.5));
+}
+)";
+
+  DataMap data;
+  data.Add<CombineSamplers::BindingInfo>(CombineSamplers::BindingMap());
+  auto got = Run<CombineSamplers>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(CombineSamplersTest, TextureSampleCompareInAFunction) {
+  auto* src = R"(
+@group(0) @binding(0) var tex : texture_depth_2d;
+
+@group(0) @binding(1) var samp : sampler_comparison;
+
+fn f(t : texture_depth_2d, s : sampler_comparison, coords : vec2<f32>) -> f32 {
+  return textureSampleCompare(t, s, coords, 5.0f);
+}
+
+fn main() -> vec4<f32> {
+  return vec4<f32>(f(tex, samp, vec2<f32>(1.0, 2.0)));
+}
+)";
+  auto* expect = R"(
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var placeholder_comparison_sampler : sampler_comparison;
+
+fn f(t_s : texture_depth_2d, coords : vec2<f32>) -> f32 {
+  return textureSampleCompare(t_s, placeholder_comparison_sampler, coords, 5.0);
+}
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex_samp : texture_depth_2d;
+
+fn main() -> vec4<f32> {
+  return vec4<f32>(f(tex_samp, vec2<f32>(1.0, 2.0)));
+}
+)";
+
+  DataMap data;
+  data.Add<CombineSamplers::BindingInfo>(CombineSamplers::BindingMap());
+  auto got = Run<CombineSamplers>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(CombineSamplersTest, BindingPointCollision) {
+  auto* src = R"(
+@group(1) @binding(0) var tex : texture_2d<f32>;
+
+@group(1) @binding(1) var samp : sampler;
+
+@group(0) @binding(0) var<uniform> gcoords : vec2<f32>;
+
+fn main() -> vec4<f32> {
+  return textureSample(tex, samp, gcoords);
+}
+)";
+  auto* expect = R"(
+@group(0) @binding(0) var<uniform> gcoords : vec2<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var tex_samp : texture_2d<f32>;
+
+@group(0) @binding(0) @internal(disable_validation__binding_point_collision) var placeholder_sampler : sampler;
+
+fn main() -> vec4<f32> {
+  return textureSample(tex_samp, placeholder_sampler, gcoords);
+}
+)";
+
+  DataMap data;
+  data.Add<CombineSamplers::BindingInfo>(CombineSamplers::BindingMap());
+  auto got = Run<CombineSamplers>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+}  // namespace
+}  // namespace transform
+}  // namespace tint
diff --git a/src/transform/glsl.cc b/src/transform/glsl.cc
index e2419cd..8f51bee 100644
--- a/src/transform/glsl.cc
+++ b/src/transform/glsl.cc
@@ -19,8 +19,10 @@
 #include "src/program_builder.h"
 #include "src/transform/add_empty_entry_point.h"
 #include "src/transform/add_spirv_block_decoration.h"
+#include "src/transform/binding_remapper.h"
 #include "src/transform/calculate_array_length.h"
 #include "src/transform/canonicalize_entry_point_io.h"
+#include "src/transform/combine_samplers.h"
 #include "src/transform/decompose_memory_access.h"
 #include "src/transform/external_texture_transform.h"
 #include "src/transform/fold_trivial_single_use_lets.h"
@@ -73,6 +75,20 @@
     data.Add<SingleEntryPoint::Config>(cfg->entry_point);
   }
   manager.Add<RemovePhonies>();
+  manager.Add<CombineSamplers>();
+  if (auto* binding_info = inputs.Get<CombineSamplers::BindingInfo>()) {
+    data.Add<CombineSamplers::BindingInfo>(*binding_info);
+  } else {
+    data.Add<CombineSamplers::BindingInfo>(CombineSamplers::BindingMap());
+  }
+  manager.Add<BindingRemapper>();
+  if (auto* remappings = inputs.Get<BindingRemapper::Remappings>()) {
+    data.Add<BindingRemapper::Remappings>(*remappings);
+  } else {
+    BindingRemapper::BindingPoints bp;
+    BindingRemapper::AccessControls ac;
+    data.Add<BindingRemapper::Remappings>(bp, ac, /* mayCollide */ true);
+  }
   manager.Add<CalculateArrayLength>();
   manager.Add<ExternalTextureTransform>();
 
diff --git a/src/writer/glsl/generator.cc b/src/writer/glsl/generator.cc
index 101b7ba..7cd6d03 100644
--- a/src/writer/glsl/generator.cc
+++ b/src/writer/glsl/generator.cc
@@ -14,6 +14,8 @@
 
 #include "src/writer/glsl/generator.h"
 
+#include "src/transform/binding_remapper.h"
+#include "src/transform/combine_samplers.h"
 #include "src/transform/glsl.h"
 #include "src/writer/glsl/generator_impl.h"
 
@@ -21,17 +23,25 @@
 namespace writer {
 namespace glsl {
 
+Options::Options() = default;
+Options::~Options() = default;
+Options::Options(const Options&) = default;
+
 Result::Result() = default;
 Result::~Result() = default;
 Result::Result(const Result&) = default;
 
 Result Generate(const Program* program,
-                const Options&,
+                const Options& options,
                 const std::string& entry_point) {
   Result result;
 
   // Run the GLSL sanitizer.
   transform::DataMap data;
+  data.Add<transform::BindingRemapper::Remappings>(options.binding_points,
+                                                   options.access_controls,
+                                                   options.allow_collisions);
+  data.Add<transform::CombineSamplers::BindingInfo>(options.binding_map);
   data.Add<transform::Glsl::Config>(entry_point);
   transform::Glsl sanitizer;
   auto output = sanitizer.Run(program, data);
diff --git a/src/writer/glsl/generator.h b/src/writer/glsl/generator.h
index 6dad736..b47a5b2 100644
--- a/src/writer/glsl/generator.h
+++ b/src/writer/glsl/generator.h
@@ -17,10 +17,14 @@
 
 #include <memory>
 #include <string>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 
+#include "src/ast/access.h"
 #include "src/ast/pipeline_stage.h"
+#include "src/sem/binding_point.h"
+#include "src/sem/sampler_texture_pair.h"
 #include "src/writer/text.h"
 
 namespace tint {
@@ -34,8 +38,35 @@
 // Forward declarations
 class GeneratorImpl;
 
+using BindingMap = std::unordered_map<sem::SamplerTexturePair, std::string>;
+
 /// Configuration options used for generating GLSL.
-struct Options {};
+struct Options {
+  /// Constructor
+  Options();
+
+  /// Destructor
+  ~Options();
+
+  /// Copy constructor
+  Options(const Options&);
+
+  /// A map of SamplerTexturePair to combined sampler names for the
+  /// CombineSamplers transform
+  BindingMap binding_map;
+
+  /// A map of old binding point to new binding point for the BindingRemapper
+  /// transform
+  std::unordered_map<sem::BindingPoint, sem::BindingPoint> binding_points;
+
+  /// A map of old binding point to new access control for the BindingRemapper
+  /// transform
+  std::unordered_map<sem::BindingPoint, ast::Access> access_controls;
+
+  /// If true, then validation will be disabled for binding point collisions
+  /// generated by the BindingRemapper transform
+  bool allow_collisions = false;
+};
 
 /// The result produced when generating GLSL.
 struct Result {
diff --git a/src/writer/glsl/generator_impl_intrinsic_texture_test.cc b/src/writer/glsl/generator_impl_intrinsic_texture_test.cc
index 56e6104..6026c49 100644
--- a/src/writer/glsl/generator_impl_intrinsic_texture_test.cc
+++ b/src/writer/glsl/generator_impl_intrinsic_texture_test.cc
@@ -64,41 +64,41 @@
     case ValidTextureOverload::kDimensionsStorageWO3d:
       return {"imageSize"};
     case ValidTextureOverload::kGather2dF32:
-      return R"(textureGather(tint_symbol, vec2(1.0f, 2.0f), 0))";
+      return R"(textureGather(tint_symbol_sampler, vec2(1.0f, 2.0f), 0))";
     case ValidTextureOverload::kGather2dOffsetF32:
-      return R"(textureGatherOffset(tint_symbol, vec2(1.0f, 2.0f), ivec2(3, 4), 0))";
+      return R"(textureGatherOffset(tint_symbol_sampler, vec2(1.0f, 2.0f), ivec2(3, 4), 0))";
     case ValidTextureOverload::kGather2dArrayF32:
-      return R"(textureGather(tint_symbol, vec3(1.0f, 2.0f, float(3)), 0))";
+      return R"(textureGather(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), 0))";
     case ValidTextureOverload::kGather2dArrayOffsetF32:
-      return R"(textureGatherOffset(tint_symbol, vec3(1.0f, 2.0f, float(3)), ivec2(4, 5), 0))";
+      return R"(textureGatherOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), ivec2(4, 5), 0))";
     case ValidTextureOverload::kGatherCubeF32:
-      return R"(textureGather(tint_symbol, vec3(1.0f, 2.0f, 3.0f), 0))";
+      return R"(textureGather(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), 0))";
     case ValidTextureOverload::kGatherCubeArrayF32:
-      return R"(textureGather(tint_symbol, vec4(1.0f, 2.0f, 3.0f, float(4)), 0))";
+      return R"(textureGather(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), 0))";
     case ValidTextureOverload::kGatherDepth2dF32:
-      return R"(textureGather(tint_symbol, vec2(1.0f, 2.0f)))";
+      return R"(textureGather(tint_symbol_sampler, vec2(1.0f, 2.0f)))";
     case ValidTextureOverload::kGatherDepth2dOffsetF32:
-      return R"(textureGatherOffset(tint_symbol, vec2(1.0f, 2.0f), ivec2(3, 4)))";
+      return R"(textureGatherOffset(tint_symbol_sampler, vec2(1.0f, 2.0f), ivec2(3, 4)))";
     case ValidTextureOverload::kGatherDepth2dArrayF32:
-      return R"(textureGather(tint_symbol, vec3(1.0f, 2.0f, float(3))))";
+      return R"(textureGather(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3))))";
     case ValidTextureOverload::kGatherDepth2dArrayOffsetF32:
-      return R"(textureGatherOffset(tint_symbol, vec3(1.0f, 2.0f, float(3)), ivec2(4, 5)))";
+      return R"(textureGatherOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), ivec2(4, 5)))";
     case ValidTextureOverload::kGatherDepthCubeF32:
-      return R"(textureGather(tint_symbol, vec3(1.0f, 2.0f, 3.0f)))";
+      return R"(textureGather(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f)))";
     case ValidTextureOverload::kGatherDepthCubeArrayF32:
-      return R"(textureGather(tint_symbol, vec4(1.0f, 2.0f, 3.0f, float(4))))";
+      return R"(textureGather(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4))))";
     case ValidTextureOverload::kGatherCompareDepth2dF32:
-      return R"(textureGather(tint_symbol, vec2(1.0f, 2.0f), 3.0f))";
+      return R"(textureGather(tint_symbol_sampler, vec2(1.0f, 2.0f), 3.0f))";
     case ValidTextureOverload::kGatherCompareDepth2dOffsetF32:
-      return R"(textureGatherOffset(tint_symbol, vec2(1.0f, 2.0f), 3.0f, ivec2(4, 5)))";
+      return R"(textureGatherOffset(tint_symbol_sampler, vec2(1.0f, 2.0f), 3.0f, ivec2(4, 5)))";
     case ValidTextureOverload::kGatherCompareDepth2dArrayF32:
-      return R"(textureGather(tint_symbol, vec3(1.0f, 2.0f, float(3)), 4.0f))";
+      return R"(textureGather(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), 4.0f))";
     case ValidTextureOverload::kGatherCompareDepth2dArrayOffsetF32:
-      return R"(textureGatherOffset(tint_symbol, vec3(1.0f, 2.0f, float(3)), 4.0f, ivec2(5, 6)))";
+      return R"(textureGatherOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), 4.0f, ivec2(5, 6)))";
     case ValidTextureOverload::kGatherCompareDepthCubeF32:
-      return R"(textureGather(tint_symbol, vec3(1.0f, 2.0f, 3.0f), 4.0f))";
+      return R"(textureGather(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), 4.0f))";
     case ValidTextureOverload::kGatherCompareDepthCubeArrayF32:
-      return R"(textureGather(tint_symbol, vec4(1.0f, 2.0f, 3.0f, float(4)), 5.0f))";
+      return R"(textureGather(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), 5.0f))";
     case ValidTextureOverload::kNumLayers2dArray:
     case ValidTextureOverload::kNumLayersDepth2dArray:
     case ValidTextureOverload::kNumLayersCubeArray:
@@ -118,151 +118,151 @@
     case ValidTextureOverload::kNumSamplesMultisampled2d:
       return {"textureSamples"};
     case ValidTextureOverload::kSample1dF32:
-      return R"(texture(tint_symbol, 1.0f);)";
+      return R"(texture(tint_symbol_sampler, 1.0f);)";
     case ValidTextureOverload::kSample2dF32:
-      return R"(texture(tint_symbol, vec2(1.0f, 2.0f));)";
+      return R"(texture(tint_symbol_sampler, vec2(1.0f, 2.0f));)";
     case ValidTextureOverload::kSample2dOffsetF32:
-      return R"(textureOffset(tint_symbol, vec2(1.0f, 2.0f), ivec2(3, 4));)";
+      return R"(textureOffset(tint_symbol_sampler, vec2(1.0f, 2.0f), ivec2(3, 4));)";
     case ValidTextureOverload::kSample2dArrayF32:
-      return R"(texture(tint_symbol, vec3(1.0f, 2.0f, float(3)));)";
+      return R"(texture(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)));)";
     case ValidTextureOverload::kSample2dArrayOffsetF32:
-      return R"(textureOffset(tint_symbol, vec3(1.0f, 2.0f, float(3)), ivec2(4, 5));)";
+      return R"(textureOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), ivec2(4, 5));)";
     case ValidTextureOverload::kSample3dF32:
-      return R"(texture(tint_symbol, vec3(1.0f, 2.0f, 3.0f));)";
+      return R"(texture(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f));)";
     case ValidTextureOverload::kSample3dOffsetF32:
-      return R"(textureOffset(tint_symbol, vec3(1.0f, 2.0f, 3.0f), ivec3(4, 5, 6));)";
+      return R"(textureOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), ivec3(4, 5, 6));)";
     case ValidTextureOverload::kSampleCubeF32:
-      return R"(texture(tint_symbol, vec3(1.0f, 2.0f, 3.0f));)";
+      return R"(texture(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f));)";
     case ValidTextureOverload::kSampleCubeArrayF32:
-      return R"(texture(tint_symbol, vec4(1.0f, 2.0f, 3.0f, float(4)));)";
+      return R"(texture(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4)));)";
     case ValidTextureOverload::kSampleDepth2dF32:
-      return R"(texture(tint_symbol, vec2(1.0f, 2.0f)).x;)";
+      return R"(texture(tint_symbol_sampler, vec2(1.0f, 2.0f)).x;)";
     case ValidTextureOverload::kSampleDepth2dOffsetF32:
-      return R"(textureOffset(tint_symbol, vec2(1.0f, 2.0f), ivec2(3, 4)).x;)";
+      return R"(textureOffset(tint_symbol_sampler, vec2(1.0f, 2.0f), ivec2(3, 4)).x;)";
     case ValidTextureOverload::kSampleDepth2dArrayF32:
-      return R"(texture(tint_symbol, vec3(1.0f, 2.0f, float(3))).x;)";
+      return R"(texture(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3))).x;)";
     case ValidTextureOverload::kSampleDepth2dArrayOffsetF32:
-      return R"(textureOffset(tint_symbol, vec3(1.0f, 2.0f, float(3)), ivec2(4, 5)).x;)";
+      return R"(textureOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), ivec2(4, 5)).x;)";
     case ValidTextureOverload::kSampleDepthCubeF32:
-      return R"(texture(tint_symbol, vec3(1.0f, 2.0f, 3.0f)).x;)";
+      return R"(texture(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f)).x;)";
     case ValidTextureOverload::kSampleDepthCubeArrayF32:
-      return R"(texture(tint_symbol, vec4(1.0f, 2.0f, 3.0f, float(4))).x;)";
+      return R"(texture(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4))).x;)";
     case ValidTextureOverload::kSampleBias2dF32:
-      return R"(texture(tint_symbol, vec2(1.0f, 2.0f), 3.0f);)";
+      return R"(texture(tint_symbol_sampler, vec2(1.0f, 2.0f), 3.0f);)";
     case ValidTextureOverload::kSampleBias2dOffsetF32:
-      return R"(textureOffset(tint_symbol, vec2(1.0f, 2.0f), ivec2(4, 5), 3.0f);)";
+      return R"(textureOffset(tint_symbol_sampler, vec2(1.0f, 2.0f), ivec2(4, 5), 3.0f);)";
     case ValidTextureOverload::kSampleBias2dArrayF32:
-      return R"(texture(tint_symbol, vec3(1.0f, 2.0f, float(4)), 3.0f);)";
+      return R"(texture(tint_symbol_sampler, vec3(1.0f, 2.0f, float(4)), 3.0f);)";
     case ValidTextureOverload::kSampleBias2dArrayOffsetF32:
-      return R"(textureOffset(tint_symbol, vec3(1.0f, 2.0f, float(3)), ivec2(5, 6), 4.0f);)";
+      return R"(textureOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), ivec2(5, 6), 4.0f);)";
     case ValidTextureOverload::kSampleBias3dF32:
-      return R"(texture(tint_symbol, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
+      return R"(texture(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
     case ValidTextureOverload::kSampleBias3dOffsetF32:
-      return R"(textureOffset(tint_symbol, vec3(1.0f, 2.0f, 3.0f), ivec3(5, 6, 7), 4.0f);)";
+      return R"(textureOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), ivec3(5, 6, 7), 4.0f);)";
     case ValidTextureOverload::kSampleBiasCubeF32:
-      return R"(texture(tint_symbol, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
+      return R"(texture(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
     case ValidTextureOverload::kSampleBiasCubeArrayF32:
-      return R"(texture(tint_symbol, vec4(1.0f, 2.0f, 3.0f, float(3)), 4.0f);)";
+      return R"(texture(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(3)), 4.0f);)";
     case ValidTextureOverload::kSampleLevel2dF32:
-      return R"(textureLod(tint_symbol, vec2(1.0f, 2.0f), 3.0f);)";
+      return R"(textureLod(tint_symbol_sampler, vec2(1.0f, 2.0f), 3.0f);)";
     case ValidTextureOverload::kSampleLevel2dOffsetF32:
-      return R"(textureLodOffset(tint_symbol, vec2(1.0f, 2.0f), 3.0f, ivec2(4, 5));)";
+      return R"(textureLodOffset(tint_symbol_sampler, vec2(1.0f, 2.0f), 3.0f, ivec2(4, 5));)";
     case ValidTextureOverload::kSampleLevel2dArrayF32:
-      return R"(textureLod(tint_symbol, vec3(1.0f, 2.0f, float(3)), 4.0f);)";
+      return R"(textureLod(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), 4.0f);)";
     case ValidTextureOverload::kSampleLevel2dArrayOffsetF32:
-      return R"(textureLodOffset(tint_symbol, vec3(1.0f, 2.0f, float(3)), 4.0f, ivec2(5, 6));)";
+      return R"(textureLodOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), 4.0f, ivec2(5, 6));)";
     case ValidTextureOverload::kSampleLevel3dF32:
-      return R"(textureLod(tint_symbol, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
+      return R"(textureLod(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
     case ValidTextureOverload::kSampleLevel3dOffsetF32:
-      return R"(textureLodOffset(tint_symbol, vec3(1.0f, 2.0f, 3.0f), 4.0f, ivec3(5, 6, 7));)";
+      return R"(textureLodOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), 4.0f, ivec3(5, 6, 7));)";
     case ValidTextureOverload::kSampleLevelCubeF32:
-      return R"(textureLod(tint_symbol, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
+      return R"(textureLod(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
     case ValidTextureOverload::kSampleLevelCubeArrayF32:
-      return R"(textureLod(tint_symbol, vec4(1.0f, 2.0f, 3.0f, float(4)), 5.0f);)";
+      return R"(textureLod(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), 5.0f);)";
     case ValidTextureOverload::kSampleLevelDepth2dF32:
-      return R"(textureLod(tint_symbol, vec2(1.0f, 2.0f), 3).x;)";
+      return R"(textureLod(tint_symbol_sampler, vec2(1.0f, 2.0f), 3).x;)";
     case ValidTextureOverload::kSampleLevelDepth2dOffsetF32:
-      return R"(textureLodOffset(tint_symbol, vec2(1.0f, 2.0f), 3, ivec2(4, 5)).x;)";
+      return R"(textureLodOffset(tint_symbol_sampler, vec2(1.0f, 2.0f), 3, ivec2(4, 5)).x;)";
     case ValidTextureOverload::kSampleLevelDepth2dArrayF32:
-      return R"(textureLod(tint_symbol, vec3(1.0f, 2.0f, float(3)), 4).x;)";
+      return R"(textureLod(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), 4).x;)";
     case ValidTextureOverload::kSampleLevelDepth2dArrayOffsetF32:
-      return R"(textureLodOffset(tint_symbol, vec3(1.0f, 2.0f, float(3)), 4, ivec2(5, 6)).x;)";
+      return R"(textureLodOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), 4, ivec2(5, 6)).x;)";
     case ValidTextureOverload::kSampleLevelDepthCubeF32:
-      return R"(textureLod(tint_symbol, vec3(1.0f, 2.0f, 3.0f), 4).x;)";
+      return R"(textureLod(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), 4).x;)";
     case ValidTextureOverload::kSampleLevelDepthCubeArrayF32:
-      return R"(textureLod(tint_symbol, vec4(1.0f, 2.0f, 3.0f, float(4)), 5).x;)";
+      return R"(textureLod(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), 5).x;)";
     case ValidTextureOverload::kSampleGrad2dF32:
-      return R"(textureGrad(tint_symbol, vec2(1.0f, 2.0f), vec2(3.0f, 4.0f), vec2(5.0f, 6.0f));)";
+      return R"(textureGrad(tint_symbol_sampler, vec2(1.0f, 2.0f), vec2(3.0f, 4.0f), vec2(5.0f, 6.0f));)";
     case ValidTextureOverload::kSampleGrad2dOffsetF32:
-      return R"(textureGradOffset(tint_symbol, vec2(1.0f, 2.0f), vec2(3.0f, 4.0f), vec2(5.0f, 6.0f), ivec2(7, 7));)";
+      return R"(textureGradOffset(tint_symbol_sampler, vec2(1.0f, 2.0f), vec2(3.0f, 4.0f), vec2(5.0f, 6.0f), ivec2(7, 7));)";
     case ValidTextureOverload::kSampleGrad2dArrayF32:
-      return R"(textureGrad(tint_symbol, vec3(1.0f, 2.0f, float(3)), vec2(4.0f, 5.0f), vec2(6.0f, 7.0f));)";
+      return R"(textureGrad(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), vec2(4.0f, 5.0f), vec2(6.0f, 7.0f));)";
     case ValidTextureOverload::kSampleGrad2dArrayOffsetF32:
-      return R"(textureGradOffset(tint_symbol, vec3(1.0f, 2.0f, float(3)), vec2(4.0f, 5.0f), vec2(6.0f, 7.0f), ivec2(6, 7));)";
+      return R"(textureGradOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(3)), vec2(4.0f, 5.0f), vec2(6.0f, 7.0f), ivec2(6, 7));)";
     case ValidTextureOverload::kSampleGrad3dF32:
-      return R"(textureGrad(tint_symbol, vec3(1.0f, 2.0f, 3.0f), vec3(4.0f, 5.0f, 6.0f), vec3(7.0f, 8.0f, 9.0f));)";
+      return R"(textureGrad(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), vec3(4.0f, 5.0f, 6.0f), vec3(7.0f, 8.0f, 9.0f));)";
     case ValidTextureOverload::kSampleGrad3dOffsetF32:
-      return R"(textureGradOffset(tint_symbol, vec3(1.0f, 2.0f, 3.0f), vec3(4.0f, 5.0f, 6.0f), vec3(7.0f, 8.0f, 9.0f), ivec3(0, 1, 2));)";
+      return R"(textureGradOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), vec3(4.0f, 5.0f, 6.0f), vec3(7.0f, 8.0f, 9.0f), ivec3(0, 1, 2));)";
     case ValidTextureOverload::kSampleGradCubeF32:
-      return R"(textureGrad(tint_symbol, vec3(1.0f, 2.0f, 3.0f), vec3(4.0f, 5.0f, 6.0f), vec3(7.0f, 8.0f, 9.0f));)";
+      return R"(textureGrad(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), vec3(4.0f, 5.0f, 6.0f), vec3(7.0f, 8.0f, 9.0f));)";
     case ValidTextureOverload::kSampleGradCubeArrayF32:
-      return R"(textureGrad(tint_symbol, vec4(1.0f, 2.0f, 3.0f, float(4)), vec3(5.0f, 6.0f, 7.0f), vec3(8.0f, 9.0f, 10.0f));)";
+      return R"(textureGrad(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), vec3(5.0f, 6.0f, 7.0f), vec3(8.0f, 9.0f, 10.0f));)";
     case ValidTextureOverload::kSampleCompareDepth2dF32:
-      return R"(texture(tint_symbol, vec2(1.0f, 2.0f), 3.0f);)";
+      return R"(texture(tint_symbol_sampler, vec2(1.0f, 2.0f), 3.0f);)";
     case ValidTextureOverload::kSampleCompareDepth2dOffsetF32:
-      return R"(textureOffset(tint_symbol, vec2(1.0f, 2.0f), 3.0f, ivec2(4, 5));)";
+      return R"(textureOffset(tint_symbol_sampler, vec2(1.0f, 2.0f), 3.0f, ivec2(4, 5));)";
     case ValidTextureOverload::kSampleCompareDepth2dArrayF32:
-      return R"(texture(tint_symbol, vec3(1.0f, 2.0f, float(4)), 3.0f);)";
+      return R"(texture(tint_symbol_sampler, vec3(1.0f, 2.0f, float(4)), 3.0f);)";
     case ValidTextureOverload::kSampleCompareDepth2dArrayOffsetF32:
-      return R"(textureOffset(tint_symbol, vec3(1.0f, 2.0f, float(4)), 3.0f, ivec2(5, 6));)";
+      return R"(textureOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(4)), 3.0f, ivec2(5, 6));)";
     case ValidTextureOverload::kSampleCompareDepthCubeF32:
-      return R"(texture(tint_symbol, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
+      return R"(texture(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
     case ValidTextureOverload::kSampleCompareDepthCubeArrayF32:
-      return R"(texture(tint_symbol, vec4(1.0f, 2.0f, 3.0f, float(4)), 5.0f);)";
+      return R"(texture(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), 5.0f);)";
     case ValidTextureOverload::kSampleCompareLevelDepth2dF32:
-      return R"(texture(tint_symbol, vec2(1.0f, 2.0f), 3.0f);)";
+      return R"(texture(tint_symbol_sampler, vec2(1.0f, 2.0f), 3.0f);)";
     case ValidTextureOverload::kSampleCompareLevelDepth2dOffsetF32:
-      return R"(textureOffset(tint_symbol, vec2(1.0f, 2.0f), 3.0f, ivec2(4, 5));)";
+      return R"(textureOffset(tint_symbol_sampler, vec2(1.0f, 2.0f), 3.0f, ivec2(4, 5));)";
     case ValidTextureOverload::kSampleCompareLevelDepth2dArrayF32:
-      return R"(texture(tint_symbol, vec3(1.0f, 2.0f, float(4)), 3.0f);)";
+      return R"(texture(tint_symbol_sampler, vec3(1.0f, 2.0f, float(4)), 3.0f);)";
     case ValidTextureOverload::kSampleCompareLevelDepth2dArrayOffsetF32:
-      return R"(textureOffset(tint_symbol, vec3(1.0f, 2.0f, float(4)), 3.0f, ivec2(5, 6));)";
+      return R"(textureOffset(tint_symbol_sampler, vec3(1.0f, 2.0f, float(4)), 3.0f, ivec2(5, 6));)";
     case ValidTextureOverload::kSampleCompareLevelDepthCubeF32:
-      return R"(texture(tint_symbol, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
+      return R"(texture(tint_symbol_sampler, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
     case ValidTextureOverload::kSampleCompareLevelDepthCubeArrayF32:
-      return R"(texture(tint_symbol, vec4(1.0f, 2.0f, 3.0f, float(4)), 5.0f);)";
+      return R"(texture(tint_symbol_sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), 5.0f);)";
     case ValidTextureOverload::kLoad1dLevelF32:
     case ValidTextureOverload::kLoad1dLevelU32:
     case ValidTextureOverload::kLoad1dLevelI32:
-      return R"(texelFetch(tint_symbol, 1, 3);)";
+      return R"(texelFetch(tint_symbol_2, 1, 3);)";
     case ValidTextureOverload::kLoad2dLevelF32:
     case ValidTextureOverload::kLoad2dLevelU32:
     case ValidTextureOverload::kLoad2dLevelI32:
-      return R"(texelFetch(tint_symbol, ivec2(1, 2), 3);)";
+      return R"(texelFetch(tint_symbol_2, ivec2(1, 2), 3);)";
     case ValidTextureOverload::kLoad2dArrayLevelF32:
     case ValidTextureOverload::kLoad2dArrayLevelU32:
     case ValidTextureOverload::kLoad2dArrayLevelI32:
     case ValidTextureOverload::kLoad3dLevelF32:
     case ValidTextureOverload::kLoad3dLevelU32:
     case ValidTextureOverload::kLoad3dLevelI32:
-      return R"(texelFetch(tint_symbol, ivec3(1, 2, 3), 4);)";
+      return R"(texelFetch(tint_symbol_2, ivec3(1, 2, 3), 4);)";
     case ValidTextureOverload::kLoadDepthMultisampled2dF32:
     case ValidTextureOverload::kLoadMultisampled2dF32:
     case ValidTextureOverload::kLoadMultisampled2dU32:
     case ValidTextureOverload::kLoadMultisampled2dI32:
-      return R"(texelFetch(tint_symbol, ivec2(1, 2), 3);)";
+      return R"(texelFetch(tint_symbol_2, ivec2(1, 2), 3);)";
     case ValidTextureOverload::kLoadDepth2dLevelF32:
-      return R"(texelFetch(tint_symbol, ivec2(1, 2), 3).x;)";
+      return R"(texelFetch(tint_symbol_2, ivec2(1, 2), 3).x;)";
     case ValidTextureOverload::kLoadDepth2dArrayLevelF32:
-      return R"(texelFetch(tint_symbol, ivec3(1, 2, 3), 4).x;)";
+      return R"(texelFetch(tint_symbol_2, ivec3(1, 2, 3), 4).x;)";
     case ValidTextureOverload::kStoreWO1dRgba32float:
-      return R"(imageStore(tint_symbol, 1, vec4(2.0f, 3.0f, 4.0f, 5.0f));)";
+      return R"(imageStore(tint_symbol_2, 1, vec4(2.0f, 3.0f, 4.0f, 5.0f));)";
     case ValidTextureOverload::kStoreWO2dRgba32float:
-      return R"(imageStore(tint_symbol, ivec2(1, 2), vec4(3.0f, 4.0f, 5.0f, 6.0f));)";
+      return R"(imageStore(tint_symbol_2, ivec2(1, 2), vec4(3.0f, 4.0f, 5.0f, 6.0f));)";
     case ValidTextureOverload::kStoreWO2dArrayRgba32float:
-      return R"(imageStore(tint_symbol, ivec3(1, 2, 3), vec4(4.0f, 5.0f, 6.0f, 7.0f));)";
+      return R"(imageStore(tint_symbol_2, ivec3(1, 2, 3), vec4(4.0f, 5.0f, 6.0f, 7.0f));)";
     case ValidTextureOverload::kStoreWO3dRgba32float:
-      return R"(imageStore(tint_symbol, ivec3(1, 2, 3), vec4(4.0f, 5.0f, 6.0f, 7.0f));)";
+      return R"(imageStore(tint_symbol_2, ivec3(1, 2, 3), vec4(4.0f, 5.0f, 6.0f, 7.0f));)";
   }
   return "<unmatched texture overload>";
 }  // NOLINT - Ignore the length of this function
diff --git a/test/BUILD.gn b/test/BUILD.gn
index 88d6554..b14707a 100644
--- a/test/BUILD.gn
+++ b/test/BUILD.gn
@@ -307,6 +307,7 @@
     "../src/transform/binding_remapper_test.cc",
     "../src/transform/calculate_array_length_test.cc",
     "../src/transform/canonicalize_entry_point_io_test.cc",
+    "../src/transform/combine_samplers_test.cc",
     "../src/transform/decompose_memory_access_test.cc",
     "../src/transform/decompose_strided_matrix_test.cc",
     "../src/transform/external_texture_transform_test.cc",
diff --git a/test/bug/dawn/947.wgsl.expected.glsl b/test/bug/dawn/947.wgsl.expected.glsl
index 3bea768..366a25d 100644
--- a/test/bug/dawn/947.wgsl.expected.glsl
+++ b/test/bug/dawn/947.wgsl.expected.glsl
@@ -80,10 +80,6 @@
   vec2 texcoords;
   vec4 position;
 };
-
-
-uniform highp sampler2D myTexture;
-
 struct tint_symbol_5 {
   vec2 texcoord;
 };
@@ -91,12 +87,15 @@
   vec4 value;
 };
 
+uniform highp sampler2D myTexture_mySampler;
+
+
 vec4 fs_main_inner(vec2 texcoord) {
   vec2 clampedTexcoord = clamp(texcoord, vec2(0.0f, 0.0f), vec2(1.0f, 1.0f));
   if (!(all(equal(clampedTexcoord, texcoord)))) {
     discard;
   }
-  vec4 srcColor = texture(myTexture, texcoord);
+  vec4 srcColor = texture(myTexture_mySampler, texcoord);
   return srcColor;
 }
 
diff --git a/test/bug/fxc/gradient_in_varying_loop/1112.wgsl.expected.glsl b/test/bug/fxc/gradient_in_varying_loop/1112.wgsl.expected.glsl
index 26706cf..119cf25 100644
--- a/test/bug/fxc/gradient_in_varying_loop/1112.wgsl.expected.glsl
+++ b/test/bug/fxc/gradient_in_varying_loop/1112.wgsl.expected.glsl
@@ -1,10 +1,6 @@
 #version 310 es
 precision mediump float;
 
-
-uniform highp sampler2D randomTexture;
-uniform highp sampler2D depthTexture;
-
 struct tint_symbol_2 {
   vec2 vUV;
 };
@@ -12,8 +8,12 @@
   vec4 value;
 };
 
+uniform highp sampler2D randomTexture_Sampler;
+uniform highp sampler2D depthTexture_Sampler;
+
+
 vec4 tint_symbol_inner(vec2 vUV) {
-  vec3 random = texture(randomTexture, vUV).rgb;
+  vec3 random = texture(randomTexture_Sampler, vUV).rgb;
   int i = 0;
   while (true) {
     if ((i < 1)) {
@@ -37,7 +37,7 @@
       i = (i + 1);
       continue;
     }
-    float sampleDepth = texture(depthTexture, offset.xy).r;
+    float sampleDepth = texture(depthTexture_Sampler, offset.xy).r;
     i = (i + 1);
   }
   return vec4(1.0f);
diff --git a/test/bug/tint/1046.wgsl.expected.glsl b/test/bug/tint/1046.wgsl.expected.glsl
index 06f4b1a..4d73089 100644
--- a/test/bug/tint/1046.wgsl.expected.glsl
+++ b/test/bug/tint/1046.wgsl.expected.glsl
@@ -25,8 +25,6 @@
   PointLight values[];
 } pointLights;
 
-uniform highp sampler2D myTexture;
-
 struct FragmentInput {
   vec4 position;
   vec4 view_position;
@@ -80,7 +78,7 @@
 
 
 Error parsing GLSL shader:
-ERROR: 0:66: 'color' : redefinition 
+ERROR: 0:64: 'color' : redefinition 
 ERROR: 1 compilation errors.  No code generated.
 
 
diff --git a/test/bug/tint/413.spvasm.expected.glsl b/test/bug/tint/413.spvasm.expected.glsl
index 5bc6dd6..893d989 100644
--- a/test/bug/tint/413.spvasm.expected.glsl
+++ b/test/bug/tint/413.spvasm.expected.glsl
@@ -1,16 +1,16 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D Src;
-uniform highp writeonly uimage2D Dst;
+uniform highp usampler2D Src_1;
+uniform highp writeonly uimage2D Dst_1;
 
 void main_1() {
   uvec4 srcValue = uvec4(0u, 0u, 0u, 0u);
-  uvec4 x_18 = texelFetch(Src, ivec2(0, 0), 0);
+  uvec4 x_18 = texelFetch(Src_1, ivec2(0, 0), 0);
   srcValue = x_18;
   uint x_22 = srcValue.x;
   srcValue.x = (x_22 + uint(1));
-  imageStore(Dst, ivec2(0, 0), srcValue);
+  imageStore(Dst_1, ivec2(0, 0), srcValue);
   return;
 }
 
diff --git a/test/bug/tint/453.wgsl.expected.glsl b/test/bug/tint/453.wgsl.expected.glsl
index 2cb6a7a..a4d01a2 100644
--- a/test/bug/tint/453.wgsl.expected.glsl
+++ b/test/bug/tint/453.wgsl.expected.glsl
@@ -1,17 +1,17 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D Src;
-uniform highp writeonly uimage2D Dst;
+uniform highp usampler2D Src_1;
+uniform highp writeonly uimage2D Dst_1;
 
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 void tint_symbol() {
   uvec4 srcValue = uvec4(0u, 0u, 0u, 0u);
-  uvec4 x_22 = texelFetch(Src, ivec2(0, 0), 0);
+  uvec4 x_22 = texelFetch(Src_1, ivec2(0, 0), 0);
   srcValue = x_22;
   uint x_24 = srcValue.x;
   uint x_25 = (x_24 + 1u);
-  imageStore(Dst, ivec2(0, 0), srcValue.xxxx);
+  imageStore(Dst_1, ivec2(0, 0), srcValue.xxxx);
   return;
 }
 void main() {
diff --git a/test/bug/tint/534.wgsl.expected.glsl b/test/bug/tint/534.wgsl.expected.glsl
index 44c9721..bda0d8c 100644
--- a/test/bug/tint/534.wgsl.expected.glsl
+++ b/test/bug/tint/534.wgsl.expected.glsl
@@ -8,8 +8,6 @@
   uint channelCount;
 };
 
-uniform highp sampler2D src;
-uniform highp sampler2D dst;
 layout (binding = 2) buffer OutputBuf_1 {
   uint result[];
 } tint_symbol;
@@ -28,15 +26,18 @@
   uvec3 GlobalInvocationID;
 };
 
+uniform highp sampler2D src_1;
+uniform highp sampler2D dst_1;
+
 void tint_symbol_1_inner(uvec3 GlobalInvocationID) {
-  ivec2 size = textureSize(src, 0);
+  ivec2 size = textureSize(src_1, 0);
   ivec2 dstTexCoord = ivec2(GlobalInvocationID.xy);
   ivec2 srcTexCoord = dstTexCoord;
   if ((uniforms.dstTextureFlipY == 1u)) {
     srcTexCoord.y = ((size.y - dstTexCoord.y) - 1);
   }
-  vec4 srcColor = texelFetch(src, srcTexCoord, 0);
-  vec4 dstColor = texelFetch(dst, dstTexCoord, 0);
+  vec4 srcColor = texelFetch(src_1, srcTexCoord, 0);
+  vec4 dstColor = texelFetch(dst_1, dstTexCoord, 0);
   bool success = true;
   uvec4 srcColorBits = uvec4(0u, 0u, 0u, 0u);
   uvec4 dstColorBits = uvec4(dstColor);
diff --git a/test/bug/tint/757.wgsl.expected.glsl b/test/bug/tint/757.wgsl.expected.glsl
index 33da240..a7edd5f 100644
--- a/test/bug/tint/757.wgsl.expected.glsl
+++ b/test/bug/tint/757.wgsl.expected.glsl
@@ -5,8 +5,6 @@
   int level;
 };
 
-uniform highp sampler2DArray myTexture;
-
 layout (binding = 3) buffer Result_1 {
   float values[];
 } result;
@@ -15,10 +13,12 @@
   uvec3 GlobalInvocationID;
 };
 
+uniform highp sampler2DArray myTexture_1;
+
 void tint_symbol_inner(uvec3 GlobalInvocationID) {
   uint flatIndex = ((((2u * 2u) * GlobalInvocationID.z) + (2u * GlobalInvocationID.y)) + GlobalInvocationID.x);
   flatIndex = (flatIndex * 1u);
-  vec4 texel = texelFetch(myTexture, ivec3(ivec2(GlobalInvocationID.xy), 0), 0);
+  vec4 texel = texelFetch(myTexture_1, ivec3(ivec2(GlobalInvocationID.xy), 0), 0);
   {
     for(uint i = 0u; (i < 1u); i = (i + 1u)) {
       result.values[(flatIndex + i)] = texel.r;
diff --git a/test/bug/tint/827.wgsl.expected.glsl b/test/bug/tint/827.wgsl.expected.glsl
index cea22b9..24a3fb0 100644
--- a/test/bug/tint/827.wgsl.expected.glsl
+++ b/test/bug/tint/827.wgsl.expected.glsl
@@ -3,7 +3,6 @@
 
 
 const uint width = 128u;
-uniform highp sampler2D tex;
 layout (binding = 1) buffer Result_1 {
   float values[];
 } result;
@@ -12,8 +11,10 @@
   uvec3 GlobalInvocationId;
 };
 
+uniform highp sampler2D tex_1;
+
 void tint_symbol_inner(uvec3 GlobalInvocationId) {
-  result.values[((GlobalInvocationId.y * width) + GlobalInvocationId.x)] = texelFetch(tex, ivec2(int(GlobalInvocationId.x), int(GlobalInvocationId.y)), 0).x;
+  result.values[((GlobalInvocationId.y * width) + GlobalInvocationId.x)] = texelFetch(tex_1, ivec2(int(GlobalInvocationId.x), int(GlobalInvocationId.y)), 0).x;
 }
 
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
diff --git a/test/bug/tint/913.wgsl.expected.glsl b/test/bug/tint/913.wgsl.expected.glsl
index d70e652..dbfc10e 100644
--- a/test/bug/tint/913.wgsl.expected.glsl
+++ b/test/bug/tint/913.wgsl.expected.glsl
@@ -9,8 +9,6 @@
   uvec2 copySize;
 };
 
-uniform highp sampler2D src;
-uniform highp sampler2D dst;
 layout (binding = 2) buffer OutputBuf_1 {
   uint result[];
 } tint_symbol;
@@ -30,9 +28,12 @@
   uvec3 GlobalInvocationID;
 };
 
+uniform highp sampler2D src_1;
+uniform highp sampler2D dst_1;
+
 void tint_symbol_1_inner(uvec3 GlobalInvocationID) {
-  ivec2 srcSize = textureSize(src, 0);
-  ivec2 dstSize = textureSize(dst, 0);
+  ivec2 srcSize = textureSize(src_1, 0);
+  ivec2 dstSize = textureSize(dst_1, 0);
   uvec2 dstTexCoord = uvec2(GlobalInvocationID.xy);
   vec4 nonCoveredColor = vec4(0.0f, 1.0f, 0.0f, 1.0f);
   bool success = true;
@@ -51,7 +52,7 @@
   if ((tint_tmp)) {
     bool tint_tmp_3 = success;
     if (tint_tmp_3) {
-      tint_tmp_3 = all(equal(texelFetch(dst, ivec2(dstTexCoord), 0), nonCoveredColor));
+      tint_tmp_3 = all(equal(texelFetch(dst_1, ivec2(dstTexCoord), 0), nonCoveredColor));
     }
     success = (tint_tmp_3);
   } else {
@@ -59,8 +60,8 @@
     if ((uniforms.dstTextureFlipY == 1u)) {
       srcTexCoord.y = ((uint(srcSize.y) - srcTexCoord.y) - 1u);
     }
-    vec4 srcColor = texelFetch(src, ivec2(srcTexCoord), 0);
-    vec4 dstColor = texelFetch(dst, ivec2(dstTexCoord), 0);
+    vec4 srcColor = texelFetch(src_1, ivec2(srcTexCoord), 0);
+    vec4 dstColor = texelFetch(dst_1, ivec2(dstTexCoord), 0);
     if ((uniforms.channelCount == 2u)) {
       bool tint_tmp_5 = success;
       if (tint_tmp_5) {
diff --git a/test/bug/tint/942.wgsl.expected.glsl b/test/bug/tint/942.wgsl.expected.glsl
index 50c0e13..9f74c1d 100644
--- a/test/bug/tint/942.wgsl.expected.glsl
+++ b/test/bug/tint/942.wgsl.expected.glsl
@@ -6,13 +6,10 @@
   uint blockDim;
 };
 
-
 layout (binding = 1) uniform Params_1 {
   uint filterDim;
   uint blockDim;
 } params;
-uniform highp sampler2D inputTex;
-uniform highp writeonly image2D outputTex;
 
 struct Flip {
   uint value;
@@ -29,6 +26,11 @@
   uvec3 WorkGroupID;
 };
 
+uniform highp sampler2D inputTex_1;
+uniform highp sampler2D inputTex_samp;
+uniform highp writeonly image2D outputTex_1;
+
+
 void tint_symbol_inner(uvec3 WorkGroupID, uvec3 LocalInvocationID, uint local_invocation_index) {
   {
     for(uint idx = local_invocation_index; (idx < 1024u); idx = (idx + 64u)) {
@@ -39,7 +41,7 @@
   }
   memoryBarrierShared();
   uint filterOffset = ((params.filterDim - 1u) / 2u);
-  ivec2 dims = textureSize(inputTex, 0);
+  ivec2 dims = textureSize(inputTex_1, 0);
   ivec2 baseIndex = (ivec2(((WorkGroupID.xy * uvec2(params.blockDim, 4u)) + (LocalInvocationID.xy * uvec2(4u, 1u)))) - ivec2(int(filterOffset), 0));
   {
     for(uint r = 0u; (r < 4u); r = (r + 1u)) {
@@ -49,7 +51,7 @@
           if ((flip.value != 0u)) {
             loadIndex = loadIndex.yx;
           }
-          tile[r][((4u * LocalInvocationID.x) + c)] = textureLod(inputTex, ((vec2(loadIndex) + vec2(0.25f, 0.25f)) / vec2(dims)), 0.0f).rgb;
+          tile[r][((4u * LocalInvocationID.x) + c)] = textureLod(inputTex_samp, ((vec2(loadIndex) + vec2(0.25f, 0.25f)) / vec2(dims)), 0.0f).rgb;
         }
       }
     }
@@ -80,7 +82,7 @@
                 acc = (acc + ((1.0f / float(params.filterDim)) * tile[r][i]));
               }
             }
-            imageStore(outputTex, writeIndex, vec4(acc, 1.0f));
+            imageStore(outputTex_1, writeIndex, vec4(acc, 1.0f));
           }
         }
       }
diff --git a/test/bug/tint/948.wgsl.expected.glsl b/test/bug/tint/948.wgsl.expected.glsl
index 37c2202..31dc5e1 100644
--- a/test/bug/tint/948.wgsl.expected.glsl
+++ b/test/bug/tint/948.wgsl.expected.glsl
@@ -26,35 +26,33 @@
   float spriteCount;
   vec3 colorMul;
 } x_20;
-uniform highp sampler2D frameMapTexture;
-
 vec2 tUV = vec2(0.0f, 0.0f);
-uniform highp sampler2D tileMapsTexture0;
-
-uniform highp sampler2D tileMapsTexture1;
-uniform highp sampler2D animationMapTexture;
-
 float mt = 0.0f;
-uniform highp sampler2D spriteSheetTexture;
-
 vec4 glFragColor = vec4(0.0f, 0.0f, 0.0f, 0.0f);
 vec2 tileID_1 = vec2(0.0f, 0.0f);
 vec2 levelUnits = vec2(0.0f, 0.0f);
 vec2 stageUnits_1 = vec2(0.0f, 0.0f);
 vec3 vPosition = vec3(0.0f, 0.0f, 0.0f);
 vec2 vUV = vec2(0.0f, 0.0f);
+uniform highp sampler2D frameMapTexture_frameMapSampler;
+
 
 mat4 getFrameData_f1_(inout float frameID) {
   float fX = 0.0f;
   float x_15 = frameID;
   float x_25 = x_20.spriteCount;
   fX = (x_15 / x_25);
-  vec4 x_40 = texture(frameMapTexture, vec2(fX, 0.0f), 0.0f);
-  vec4 x_47 = texture(frameMapTexture, vec2(fX, 0.25f), 0.0f);
-  vec4 x_54 = texture(frameMapTexture, vec2(fX, 0.5f), 0.0f);
+  vec4 x_40 = texture(frameMapTexture_frameMapSampler, vec2(fX, 0.0f), 0.0f);
+  vec4 x_47 = texture(frameMapTexture_frameMapSampler, vec2(fX, 0.25f), 0.0f);
+  vec4 x_54 = texture(frameMapTexture_frameMapSampler, vec2(fX, 0.5f), 0.0f);
   return mat4(vec4(x_40.x, x_40.y, x_40.z, x_40.w), vec4(x_47.x, x_47.y, x_47.z, x_47.w), vec4(x_54.x, x_54.y, x_54.z, x_54.w), vec4(vec4(0.0f, 0.0f, 0.0f, 0.0f).x, vec4(0.0f, 0.0f, 0.0f, 0.0f).y, vec4(0.0f, 0.0f, 0.0f, 0.0f).z, vec4(0.0f, 0.0f, 0.0f, 0.0f).w));
 }
 
+uniform highp sampler2D tileMapsTexture1_tileMapsSampler;
+uniform highp sampler2D tileMapsTexture0_tileMapsSampler;
+uniform highp sampler2D animationMapTexture_animationMapSampler;
+uniform highp sampler2D spriteSheetTexture_spriteSheetSampler;
+
 void main_1() {
   vec4 color = vec4(0.0f, 0.0f, 0.0f, 0.0f);
   vec2 tileUV = vec2(0.0f, 0.0f);
@@ -92,14 +90,14 @@
         case 1: {
           vec2 x_150 = tileID;
           vec2 x_154 = x_20.stageSize;
-          vec4 x_156 = texture(tileMapsTexture1, ((x_150 + vec2(0.5f, 0.5f)) / x_154), 0.0f);
+          vec4 x_156 = texture(tileMapsTexture1_tileMapsSampler, ((x_150 + vec2(0.5f, 0.5f)) / x_154), 0.0f);
           frameID_1 = x_156.x;
           break;
         }
         case 0: {
           vec2 x_136 = tileID;
           vec2 x_140 = x_20.stageSize;
-          vec4 x_142 = texture(tileMapsTexture0, ((x_136 + vec2(0.5f, 0.5f)) / x_140), 0.0f);
+          vec4 x_142 = texture(tileMapsTexture0_tileMapsSampler, ((x_136 + vec2(0.5f, 0.5f)) / x_140), 0.0f);
           frameID_1 = x_142.x;
           break;
         }
@@ -109,7 +107,7 @@
       }
       float x_166 = frameID_1;
       float x_169 = x_20.spriteCount;
-      vec4 x_172 = texture(animationMapTexture, vec2(((x_166 + 0.5f) / x_169), 0.0f), 0.0f);
+      vec4 x_172 = texture(animationMapTexture_animationMapSampler, vec2(((x_166 + 0.5f) / x_169), 0.0f), 0.0f);
       animationData = x_172;
       float x_174 = animationData.y;
       if ((x_174 > 0.0f)) {
@@ -127,7 +125,7 @@
             }
             float x_208 = frameID_1;
             float x_211 = x_20.spriteCount;
-            vec4 x_217 = texture(animationMapTexture, vec2(((x_208 + 0.5f) / x_211), (0.125f * f)), 0.0f);
+            vec4 x_217 = texture(animationMapTexture_animationMapSampler, vec2(((x_208 + 0.5f) / x_211), (0.125f * f)), 0.0f);
             animationData = x_217;
           }
         }
@@ -149,10 +147,10 @@
         tileUV = vec2(x_252.y, x_252.x);
       }
       if ((i == 0)) {
-        vec4 x_268 = texture(spriteSheetTexture, ((tileUV * frameSize) + offset_1));
+        vec4 x_268 = texture(spriteSheetTexture_spriteSheetSampler, ((tileUV * frameSize) + offset_1));
         color = x_268;
       } else {
-        vec4 x_279 = texture(spriteSheetTexture, ((tileUV * frameSize) + offset_1));
+        vec4 x_279 = texture(spriteSheetTexture_spriteSheetSampler, ((tileUV * frameSize) + offset_1));
         nc = x_279;
         float x_283 = color.w;
         float x_285 = nc.w;
@@ -229,9 +227,9 @@
 
 
 Error parsing GLSL shader:
-ERROR: 0:76: 'frac' : no matching overloaded function found 
-ERROR: 0:76: 'assign' :  cannot convert from ' const float' to ' temp mediump 2-component vector of float'
-ERROR: 0:76: '' : compilation terminated 
+ERROR: 0:74: 'frac' : no matching overloaded function found 
+ERROR: 0:74: 'assign' :  cannot convert from ' const float' to ' temp mediump 2-component vector of float'
+ERROR: 0:74: '' : compilation terminated 
 ERROR: 3 compilation errors.  No code generated.
 
 
diff --git a/test/bug/tint/949.wgsl.expected.glsl b/test/bug/tint/949.wgsl.expected.glsl
index b5ee178..2467cbb 100644
--- a/test/bug/tint/949.wgsl.expected.glsl
+++ b/test/bug/tint/949.wgsl.expected.glsl
@@ -30,8 +30,6 @@
 
 float u_Float = 0.0f;
 vec3 u_Color = vec3(0.0f, 0.0f, 0.0f);
-uniform highp sampler2D TextureSamplerTexture;
-
 vec2 vMainuv = vec2(0.0f, 0.0f);
 layout (binding = 6) uniform LeftOver_1 {
   mat4 u_World;
@@ -48,8 +46,6 @@
 bool tint_symbol = false;
 vec2 v_uv = vec2(0.0f, 0.0f);
 vec4 v_output2 = vec4(0.0f, 0.0f, 0.0f, 0.0f);
-uniform highp sampler2D TextureSampler1Texture;
-
 layout (binding = 5) uniform Light0_1 {
   vec4 vLightData;
   vec4 vLightDiffuse;
@@ -178,6 +174,10 @@
   return result;
 }
 
+uniform highp sampler2D TextureSamplerTexture_TextureSamplerSampler;
+uniform highp sampler2D TextureSampler1Texture_TextureSampler1Sampler;
+
+
 void main_1() {
   vec4 tempTextureRead = vec4(0.0f, 0.0f, 0.0f, 0.0f);
   vec3 rgb = vec3(0.0f, 0.0f, 0.0f);
@@ -234,7 +234,7 @@
   vec3 output3 = vec3(0.0f, 0.0f, 0.0f);
   u_Float = 100.0f;
   u_Color = vec3(0.5f, 0.5f, 0.5f);
-  vec4 x_262 = texture(TextureSamplerTexture, vMainuv);
+  vec4 x_262 = texture(TextureSamplerTexture_TextureSamplerSampler, vMainuv);
   tempTextureRead = x_262;
   vec4 x_264 = tempTextureRead;
   float x_273 = x_269.textureInfoName;
@@ -282,7 +282,7 @@
   i = 0;
   {
     for(; (i < 15); i = (i + 1)) {
-      vec4 x_397 = texture(TextureSamplerTexture, (v_uv + vCurrOffset));
+      vec4 x_397 = texture(TextureSamplerTexture_TextureSamplerSampler, (v_uv + vCurrOffset));
       currSampledHeight = x_397.w;
       if ((currSampledHeight > currRayHeight)) {
         delta1 = (currSampledHeight - currRayHeight);
@@ -300,7 +300,7 @@
   }
   parallaxOcclusion_0 = vCurrOffset;
   uvOffset = parallaxOcclusion_0;
-  vec4 x_452 = texture(TextureSamplerTexture, (v_uv + uvOffset));
+  vec4 x_452 = texture(TextureSamplerTexture_TextureSamplerSampler, (v_uv + uvOffset));
   float x_454 = x_269.u_bumpStrength;
   param_8 = TBN;
   param_9 = vec3(x_452.x, x_452.y, x_452.z);
@@ -308,7 +308,7 @@
   vec3 x_461 = perturbNormal_mf33_vf3_f1_(param_8, param_9, param_10);
   output4 = vec4(x_461.x, x_461.y, x_461.z, output4.w);
   output6 = (v_uv + uvOffset);
-  vec4 x_475 = texture(TextureSampler1Texture, output6);
+  vec4 x_475 = texture(TextureSampler1Texture_TextureSampler1Sampler, output6);
   tempTextureRead1 = x_475;
   vec4 x_477 = tempTextureRead1;
   rgb1 = vec3(x_477.x, x_477.y, x_477.z);
@@ -397,9 +397,9 @@
 
 
 Error parsing GLSL shader:
-ERROR: 0:73: 'ddx' : no matching overloaded function found 
-ERROR: 0:73: 'assign' :  cannot convert from ' const float' to ' temp mediump 3-component vector of float'
-ERROR: 0:73: '' : compilation terminated 
+ERROR: 0:69: 'ddx' : no matching overloaded function found 
+ERROR: 0:69: 'assign' :  cannot convert from ' const float' to ' temp mediump 3-component vector of float'
+ERROR: 0:69: '' : compilation terminated 
 ERROR: 3 compilation errors.  No code generated.
 
 
diff --git a/test/bug/tint/959.wgsl.expected.glsl b/test/bug/tint/959.wgsl.expected.glsl
index 6cc913a..df69308 100644
--- a/test/bug/tint/959.wgsl.expected.glsl
+++ b/test/bug/tint/959.wgsl.expected.glsl
@@ -53,38 +53,6 @@
 layout (binding = 1) uniform S_16 {
   float a;
 } b15;
-uniform highp sampler2D t0;
-uniform highp sampler2D t1;
-uniform highp sampler2D t2;
-uniform highp sampler2D t3;
-uniform highp sampler2D t4;
-uniform highp sampler2D t5;
-uniform highp sampler2D t6;
-uniform highp sampler2D t7;
-uniform highp sampler2D t8;
-uniform highp sampler2D t9;
-uniform highp sampler2D t10;
-uniform highp sampler2D t11;
-uniform highp sampler2D t12;
-uniform highp sampler2D t13;
-uniform highp sampler2D t14;
-uniform highp sampler2D t15;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 
 void tint_symbol() {
   return;
diff --git a/test/bug/tint/978.wgsl.expected.glsl b/test/bug/tint/978.wgsl.expected.glsl
index fad4bfc..e35f95e 100644
--- a/test/bug/tint/978.wgsl.expected.glsl
+++ b/test/bug/tint/978.wgsl.expected.glsl
@@ -7,10 +7,6 @@
 struct FragmentOutput {
   vec4 color;
 };
-
-uniform highp sampler2D depthMap;
-
-
 struct tint_symbol_3 {
   vec2 vUv;
 };
@@ -18,8 +14,11 @@
   vec4 color;
 };
 
+uniform highp sampler2D depthMap_texSampler;
+
+
 FragmentOutput tint_symbol_inner(FragmentInput fIn) {
-  float tint_symbol_1 = texture(depthMap, fIn.vUv).x;
+  float tint_symbol_1 = texture(depthMap_texSampler, fIn.vUv).x;
   vec3 color = vec3(tint_symbol_1, tint_symbol_1, tint_symbol_1);
   FragmentOutput fOut = FragmentOutput(vec4(0.0f, 0.0f, 0.0f, 0.0f));
   fOut.color = vec4(color, 1.0f);
diff --git a/test/intrinsics/gen/ignore/2a6ac2.wgsl.expected.glsl b/test/intrinsics/gen/ignore/2a6ac2.wgsl.expected.glsl
index 09337ec..7de1a90 100644
--- a/test/intrinsics/gen/ignore/2a6ac2.wgsl.expected.glsl
+++ b/test/intrinsics/gen/ignore/2a6ac2.wgsl.expected.glsl
@@ -1,81 +1,33 @@
+SKIP: FAILED
+
 intrinsics/gen/ignore/2a6ac2.wgsl:29:3 warning: use of deprecated intrinsic
   ignore(arg_0);
   ^^^^^^
 
-#version 310 es
-precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+@group(1) @binding(0) var arg_0 : texture_depth_multisampled_2d;
 
-void ignore_2a6ac2() {
-  arg_0;
+fn ignore_2a6ac2() {
+  ignore(arg_0);
 }
 
-struct tint_symbol {
-  vec4 value;
-};
-
-vec4 vertex_main_inner() {
+@stage(vertex)
+fn vertex_main() -> @builtin(position) vec4<f32> {
   ignore_2a6ac2();
-  return vec4(0.0f, 0.0f, 0.0f, 0.0f);
+  return vec4<f32>();
 }
 
-tint_symbol vertex_main() {
-  vec4 inner_result = vertex_main_inner();
-  tint_symbol wrapper_result = tint_symbol(vec4(0.0f, 0.0f, 0.0f, 0.0f));
-  wrapper_result.value = inner_result;
-  return wrapper_result;
-}
-void main() {
-  tint_symbol outputs;
-  outputs = vertex_main();
-  gl_Position = outputs.value;
-  gl_Position.y = -gl_Position.y;
-}
-
-
-#version 310 es
-precision mediump float;
-
-uniform highp sampler2DMS arg_0;
-
-void ignore_2a6ac2() {
-  arg_0;
-}
-
-struct tint_symbol {
-  vec4 value;
-};
-
-void fragment_main() {
+@stage(fragment)
+fn fragment_main() {
   ignore_2a6ac2();
-  return;
-}
-void main() {
-  fragment_main();
 }
 
-
-#version 310 es
-precision mediump float;
-
-uniform highp sampler2DMS arg_0;
-
-void ignore_2a6ac2() {
-  arg_0;
-}
-
-struct tint_symbol {
-  vec4 value;
-};
-
-layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
-void compute_main() {
+@stage(compute) @workgroup_size(1)
+fn compute_main() {
   ignore_2a6ac2();
-  return;
-}
-void main() {
-  compute_main();
 }
 
+Failed to generate: intrinsics/gen/ignore/2a6ac2.wgsl:29:10 error: unknown identifier: 'arg_0'
+  ignore(arg_0);
+         ^^^^^
 
diff --git a/test/intrinsics/gen/ignore/5016e5.wgsl.expected.glsl b/test/intrinsics/gen/ignore/5016e5.wgsl.expected.glsl
index 91b05a1..a58dca4 100644
--- a/test/intrinsics/gen/ignore/5016e5.wgsl.expected.glsl
+++ b/test/intrinsics/gen/ignore/5016e5.wgsl.expected.glsl
@@ -4,101 +4,30 @@
   ignore(arg_0);
   ^^^^^^
 
-#version 310 es
-precision mediump float;
 
+@group(1) @binding(0) var arg_0 : sampler;
 
-
-void ignore_5016e5() {
-  arg_0;
+fn ignore_5016e5() {
+  ignore(arg_0);
 }
 
-struct tint_symbol {
-  vec4 value;
-};
-
-vec4 vertex_main_inner() {
+@stage(vertex)
+fn vertex_main() -> @builtin(position) vec4<f32> {
   ignore_5016e5();
-  return vec4(0.0f, 0.0f, 0.0f, 0.0f);
+  return vec4<f32>();
 }
 
-tint_symbol vertex_main() {
-  vec4 inner_result = vertex_main_inner();
-  tint_symbol wrapper_result = tint_symbol(vec4(0.0f, 0.0f, 0.0f, 0.0f));
-  wrapper_result.value = inner_result;
-  return wrapper_result;
-}
-void main() {
-  tint_symbol outputs;
-  outputs = vertex_main();
-  gl_Position = outputs.value;
-  gl_Position.y = -gl_Position.y;
-}
-
-
-Error parsing GLSL shader:
-ERROR: 0:7: 'arg_0' : undeclared identifier 
-ERROR: 0:7: '' : compilation terminated 
-ERROR: 2 compilation errors.  No code generated.
-
-
-
-#version 310 es
-precision mediump float;
-
-
-
-void ignore_5016e5() {
-  arg_0;
-}
-
-struct tint_symbol {
-  vec4 value;
-};
-
-void fragment_main() {
+@stage(fragment)
+fn fragment_main() {
   ignore_5016e5();
-  return;
-}
-void main() {
-  fragment_main();
 }
 
-
-Error parsing GLSL shader:
-ERROR: 0:7: 'arg_0' : undeclared identifier 
-ERROR: 0:7: '' : compilation terminated 
-ERROR: 2 compilation errors.  No code generated.
-
-
-
-#version 310 es
-precision mediump float;
-
-
-
-void ignore_5016e5() {
-  arg_0;
-}
-
-struct tint_symbol {
-  vec4 value;
-};
-
-layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
-void compute_main() {
+@stage(compute) @workgroup_size(1)
+fn compute_main() {
   ignore_5016e5();
-  return;
-}
-void main() {
-  compute_main();
 }
 
-
-Error parsing GLSL shader:
-ERROR: 0:7: 'arg_0' : undeclared identifier 
-ERROR: 0:7: '' : compilation terminated 
-ERROR: 2 compilation errors.  No code generated.
-
-
+Failed to generate: intrinsics/gen/ignore/5016e5.wgsl:29:10 error: unknown identifier: 'arg_0'
+  ignore(arg_0);
+         ^^^^^
 
diff --git a/test/intrinsics/gen/ignore/509355.wgsl.expected.glsl b/test/intrinsics/gen/ignore/509355.wgsl.expected.glsl
index 11d4922..38db376 100644
--- a/test/intrinsics/gen/ignore/509355.wgsl.expected.glsl
+++ b/test/intrinsics/gen/ignore/509355.wgsl.expected.glsl
@@ -1,81 +1,33 @@
+SKIP: FAILED
+
 intrinsics/gen/ignore/509355.wgsl:29:3 warning: use of deprecated intrinsic
   ignore(arg_0);
   ^^^^^^
 
-#version 310 es
-precision mediump float;
 
-uniform highp samplerCube arg_0;
+@group(1) @binding(0) var arg_0 : texture_depth_cube;
 
-void ignore_509355() {
-  arg_0;
+fn ignore_509355() {
+  ignore(arg_0);
 }
 
-struct tint_symbol {
-  vec4 value;
-};
-
-vec4 vertex_main_inner() {
+@stage(vertex)
+fn vertex_main() -> @builtin(position) vec4<f32> {
   ignore_509355();
-  return vec4(0.0f, 0.0f, 0.0f, 0.0f);
+  return vec4<f32>();
 }
 
-tint_symbol vertex_main() {
-  vec4 inner_result = vertex_main_inner();
-  tint_symbol wrapper_result = tint_symbol(vec4(0.0f, 0.0f, 0.0f, 0.0f));
-  wrapper_result.value = inner_result;
-  return wrapper_result;
-}
-void main() {
-  tint_symbol outputs;
-  outputs = vertex_main();
-  gl_Position = outputs.value;
-  gl_Position.y = -gl_Position.y;
-}
-
-
-#version 310 es
-precision mediump float;
-
-uniform highp samplerCube arg_0;
-
-void ignore_509355() {
-  arg_0;
-}
-
-struct tint_symbol {
-  vec4 value;
-};
-
-void fragment_main() {
+@stage(fragment)
+fn fragment_main() {
   ignore_509355();
-  return;
-}
-void main() {
-  fragment_main();
 }
 
-
-#version 310 es
-precision mediump float;
-
-uniform highp samplerCube arg_0;
-
-void ignore_509355() {
-  arg_0;
-}
-
-struct tint_symbol {
-  vec4 value;
-};
-
-layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
-void compute_main() {
+@stage(compute) @workgroup_size(1)
+fn compute_main() {
   ignore_509355();
-  return;
-}
-void main() {
-  compute_main();
 }
 
+Failed to generate: intrinsics/gen/ignore/509355.wgsl:29:10 error: unknown identifier: 'arg_0'
+  ignore(arg_0);
+         ^^^^^
 
diff --git a/test/intrinsics/gen/ignore/5c9edf.wgsl.expected.glsl b/test/intrinsics/gen/ignore/5c9edf.wgsl.expected.glsl
index 8f79e31..a00047e 100644
--- a/test/intrinsics/gen/ignore/5c9edf.wgsl.expected.glsl
+++ b/test/intrinsics/gen/ignore/5c9edf.wgsl.expected.glsl
@@ -1,81 +1,33 @@
+SKIP: FAILED
+
 intrinsics/gen/ignore/5c9edf.wgsl:29:3 warning: use of deprecated intrinsic
   ignore(arg_0);
   ^^^^^^
 
-#version 310 es
-precision mediump float;
 
-uniform highp sampler2D arg_0;
+@group(1) @binding(0) var arg_0 : texture_external;
 
-void ignore_5c9edf() {
-  arg_0;
+fn ignore_5c9edf() {
+  ignore(arg_0);
 }
 
-struct tint_symbol {
-  vec4 value;
-};
-
-vec4 vertex_main_inner() {
+@stage(vertex)
+fn vertex_main() -> @builtin(position) vec4<f32> {
   ignore_5c9edf();
-  return vec4(0.0f, 0.0f, 0.0f, 0.0f);
+  return vec4<f32>();
 }
 
-tint_symbol vertex_main() {
-  vec4 inner_result = vertex_main_inner();
-  tint_symbol wrapper_result = tint_symbol(vec4(0.0f, 0.0f, 0.0f, 0.0f));
-  wrapper_result.value = inner_result;
-  return wrapper_result;
-}
-void main() {
-  tint_symbol outputs;
-  outputs = vertex_main();
-  gl_Position = outputs.value;
-  gl_Position.y = -gl_Position.y;
-}
-
-
-#version 310 es
-precision mediump float;
-
-uniform highp sampler2D arg_0;
-
-void ignore_5c9edf() {
-  arg_0;
-}
-
-struct tint_symbol {
-  vec4 value;
-};
-
-void fragment_main() {
+@stage(fragment)
+fn fragment_main() {
   ignore_5c9edf();
-  return;
-}
-void main() {
-  fragment_main();
 }
 
-
-#version 310 es
-precision mediump float;
-
-uniform highp sampler2D arg_0;
-
-void ignore_5c9edf() {
-  arg_0;
-}
-
-struct tint_symbol {
-  vec4 value;
-};
-
-layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
-void compute_main() {
+@stage(compute) @workgroup_size(1)
+fn compute_main() {
   ignore_5c9edf();
-  return;
-}
-void main() {
-  compute_main();
 }
 
+Failed to generate: intrinsics/gen/ignore/5c9edf.wgsl:29:10 error: unknown identifier: 'arg_0'
+  ignore(arg_0);
+         ^^^^^
 
diff --git a/test/intrinsics/gen/ignore/ad88be.wgsl.expected.glsl b/test/intrinsics/gen/ignore/ad88be.wgsl.expected.glsl
index b8116d6..af97009 100644
--- a/test/intrinsics/gen/ignore/ad88be.wgsl.expected.glsl
+++ b/test/intrinsics/gen/ignore/ad88be.wgsl.expected.glsl
@@ -4,101 +4,30 @@
   ignore(arg_0);
   ^^^^^^
 
-#version 310 es
-precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+@group(1) @binding(0) var arg_0 : texture_depth_cube_array;
 
-void ignore_ad88be() {
-  arg_0;
+fn ignore_ad88be() {
+  ignore(arg_0);
 }
 
-struct tint_symbol {
-  vec4 value;
-};
-
-vec4 vertex_main_inner() {
+@stage(vertex)
+fn vertex_main() -> @builtin(position) vec4<f32> {
   ignore_ad88be();
-  return vec4(0.0f, 0.0f, 0.0f, 0.0f);
+  return vec4<f32>();
 }
 
-tint_symbol vertex_main() {
-  vec4 inner_result = vertex_main_inner();
-  tint_symbol wrapper_result = tint_symbol(vec4(0.0f, 0.0f, 0.0f, 0.0f));
-  wrapper_result.value = inner_result;
-  return wrapper_result;
-}
-void main() {
-  tint_symbol outputs;
-  outputs = vertex_main();
-  gl_Position = outputs.value;
-  gl_Position.y = -gl_Position.y;
-}
-
-
-Error parsing GLSL shader:
-ERROR: 0:4: 'samplerCubeArray' : Reserved word. 
-ERROR: 0:4: '' : compilation terminated 
-ERROR: 2 compilation errors.  No code generated.
-
-
-
-#version 310 es
-precision mediump float;
-
-uniform highp samplerCubeArray arg_0;
-
-void ignore_ad88be() {
-  arg_0;
-}
-
-struct tint_symbol {
-  vec4 value;
-};
-
-void fragment_main() {
+@stage(fragment)
+fn fragment_main() {
   ignore_ad88be();
-  return;
-}
-void main() {
-  fragment_main();
 }
 
-
-Error parsing GLSL shader:
-ERROR: 0:4: 'samplerCubeArray' : Reserved word. 
-ERROR: 0:4: '' : compilation terminated 
-ERROR: 2 compilation errors.  No code generated.
-
-
-
-#version 310 es
-precision mediump float;
-
-uniform highp samplerCubeArray arg_0;
-
-void ignore_ad88be() {
-  arg_0;
-}
-
-struct tint_symbol {
-  vec4 value;
-};
-
-layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
-void compute_main() {
+@stage(compute) @workgroup_size(1)
+fn compute_main() {
   ignore_ad88be();
-  return;
-}
-void main() {
-  compute_main();
 }
 
-
-Error parsing GLSL shader:
-ERROR: 0:4: 'samplerCubeArray' : Reserved word. 
-ERROR: 0:4: '' : compilation terminated 
-ERROR: 2 compilation errors.  No code generated.
-
-
+Failed to generate: intrinsics/gen/ignore/ad88be.wgsl:29:10 error: unknown identifier: 'arg_0'
+  ignore(arg_0);
+         ^^^^^
 
diff --git a/test/intrinsics/gen/ignore/b469af.wgsl.expected.glsl b/test/intrinsics/gen/ignore/b469af.wgsl.expected.glsl
index 6c593b9..0f7685f 100644
--- a/test/intrinsics/gen/ignore/b469af.wgsl.expected.glsl
+++ b/test/intrinsics/gen/ignore/b469af.wgsl.expected.glsl
@@ -4,101 +4,30 @@
   ignore(arg_0);
   ^^^^^^
 
-#version 310 es
-precision mediump float;
 
+@group(1) @binding(0) var arg_0 : sampler_comparison;
 
-
-void ignore_b469af() {
-  arg_0;
+fn ignore_b469af() {
+  ignore(arg_0);
 }
 
-struct tint_symbol {
-  vec4 value;
-};
-
-vec4 vertex_main_inner() {
+@stage(vertex)
+fn vertex_main() -> @builtin(position) vec4<f32> {
   ignore_b469af();
-  return vec4(0.0f, 0.0f, 0.0f, 0.0f);
+  return vec4<f32>();
 }
 
-tint_symbol vertex_main() {
-  vec4 inner_result = vertex_main_inner();
-  tint_symbol wrapper_result = tint_symbol(vec4(0.0f, 0.0f, 0.0f, 0.0f));
-  wrapper_result.value = inner_result;
-  return wrapper_result;
-}
-void main() {
-  tint_symbol outputs;
-  outputs = vertex_main();
-  gl_Position = outputs.value;
-  gl_Position.y = -gl_Position.y;
-}
-
-
-Error parsing GLSL shader:
-ERROR: 0:7: 'arg_0' : undeclared identifier 
-ERROR: 0:7: '' : compilation terminated 
-ERROR: 2 compilation errors.  No code generated.
-
-
-
-#version 310 es
-precision mediump float;
-
-
-
-void ignore_b469af() {
-  arg_0;
-}
-
-struct tint_symbol {
-  vec4 value;
-};
-
-void fragment_main() {
+@stage(fragment)
+fn fragment_main() {
   ignore_b469af();
-  return;
-}
-void main() {
-  fragment_main();
 }
 
-
-Error parsing GLSL shader:
-ERROR: 0:7: 'arg_0' : undeclared identifier 
-ERROR: 0:7: '' : compilation terminated 
-ERROR: 2 compilation errors.  No code generated.
-
-
-
-#version 310 es
-precision mediump float;
-
-
-
-void ignore_b469af() {
-  arg_0;
-}
-
-struct tint_symbol {
-  vec4 value;
-};
-
-layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
-void compute_main() {
+@stage(compute) @workgroup_size(1)
+fn compute_main() {
   ignore_b469af();
-  return;
-}
-void main() {
-  compute_main();
 }
 
-
-Error parsing GLSL shader:
-ERROR: 0:7: 'arg_0' : undeclared identifier 
-ERROR: 0:7: '' : compilation terminated 
-ERROR: 2 compilation errors.  No code generated.
-
-
+Failed to generate: intrinsics/gen/ignore/b469af.wgsl:29:10 error: unknown identifier: 'arg_0'
+  ignore(arg_0);
+         ^^^^^
 
diff --git a/test/intrinsics/gen/ignore/c8a0ee.wgsl.expected.glsl b/test/intrinsics/gen/ignore/c8a0ee.wgsl.expected.glsl
index 69ecc99..2ba2d46 100644
--- a/test/intrinsics/gen/ignore/c8a0ee.wgsl.expected.glsl
+++ b/test/intrinsics/gen/ignore/c8a0ee.wgsl.expected.glsl
@@ -1,81 +1,33 @@
+SKIP: FAILED
+
 intrinsics/gen/ignore/c8a0ee.wgsl:29:3 warning: use of deprecated intrinsic
   ignore(arg_0);
   ^^^^^^
 
-#version 310 es
-precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+@group(1) @binding(0) var arg_0 : texture_depth_2d_array;
 
-void ignore_c8a0ee() {
-  arg_0;
+fn ignore_c8a0ee() {
+  ignore(arg_0);
 }
 
-struct tint_symbol {
-  vec4 value;
-};
-
-vec4 vertex_main_inner() {
+@stage(vertex)
+fn vertex_main() -> @builtin(position) vec4<f32> {
   ignore_c8a0ee();
-  return vec4(0.0f, 0.0f, 0.0f, 0.0f);
+  return vec4<f32>();
 }
 
-tint_symbol vertex_main() {
-  vec4 inner_result = vertex_main_inner();
-  tint_symbol wrapper_result = tint_symbol(vec4(0.0f, 0.0f, 0.0f, 0.0f));
-  wrapper_result.value = inner_result;
-  return wrapper_result;
-}
-void main() {
-  tint_symbol outputs;
-  outputs = vertex_main();
-  gl_Position = outputs.value;
-  gl_Position.y = -gl_Position.y;
-}
-
-
-#version 310 es
-precision mediump float;
-
-uniform highp sampler2DArray arg_0;
-
-void ignore_c8a0ee() {
-  arg_0;
-}
-
-struct tint_symbol {
-  vec4 value;
-};
-
-void fragment_main() {
+@stage(fragment)
+fn fragment_main() {
   ignore_c8a0ee();
-  return;
-}
-void main() {
-  fragment_main();
 }
 
-
-#version 310 es
-precision mediump float;
-
-uniform highp sampler2DArray arg_0;
-
-void ignore_c8a0ee() {
-  arg_0;
-}
-
-struct tint_symbol {
-  vec4 value;
-};
-
-layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
-void compute_main() {
+@stage(compute) @workgroup_size(1)
+fn compute_main() {
   ignore_c8a0ee();
-  return;
-}
-void main() {
-  compute_main();
 }
 
+Failed to generate: intrinsics/gen/ignore/c8a0ee.wgsl:29:10 error: unknown identifier: 'arg_0'
+  ignore(arg_0);
+         ^^^^^
 
diff --git a/test/intrinsics/gen/ignore/e0187b.wgsl.expected.glsl b/test/intrinsics/gen/ignore/e0187b.wgsl.expected.glsl
index e209270..00748d4 100644
--- a/test/intrinsics/gen/ignore/e0187b.wgsl.expected.glsl
+++ b/test/intrinsics/gen/ignore/e0187b.wgsl.expected.glsl
@@ -1,81 +1,33 @@
+SKIP: FAILED
+
 intrinsics/gen/ignore/e0187b.wgsl:29:3 warning: use of deprecated intrinsic
   ignore(arg_0);
   ^^^^^^
 
-#version 310 es
-precision mediump float;
 
-uniform highp sampler2D arg_0;
+@group(1) @binding(0) var arg_0 : texture_depth_2d;
 
-void ignore_e0187b() {
-  arg_0;
+fn ignore_e0187b() {
+  ignore(arg_0);
 }
 
-struct tint_symbol {
-  vec4 value;
-};
-
-vec4 vertex_main_inner() {
+@stage(vertex)
+fn vertex_main() -> @builtin(position) vec4<f32> {
   ignore_e0187b();
-  return vec4(0.0f, 0.0f, 0.0f, 0.0f);
+  return vec4<f32>();
 }
 
-tint_symbol vertex_main() {
-  vec4 inner_result = vertex_main_inner();
-  tint_symbol wrapper_result = tint_symbol(vec4(0.0f, 0.0f, 0.0f, 0.0f));
-  wrapper_result.value = inner_result;
-  return wrapper_result;
-}
-void main() {
-  tint_symbol outputs;
-  outputs = vertex_main();
-  gl_Position = outputs.value;
-  gl_Position.y = -gl_Position.y;
-}
-
-
-#version 310 es
-precision mediump float;
-
-uniform highp sampler2D arg_0;
-
-void ignore_e0187b() {
-  arg_0;
-}
-
-struct tint_symbol {
-  vec4 value;
-};
-
-void fragment_main() {
+@stage(fragment)
+fn fragment_main() {
   ignore_e0187b();
-  return;
-}
-void main() {
-  fragment_main();
 }
 
-
-#version 310 es
-precision mediump float;
-
-uniform highp sampler2D arg_0;
-
-void ignore_e0187b() {
-  arg_0;
-}
-
-struct tint_symbol {
-  vec4 value;
-};
-
-layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
-void compute_main() {
+@stage(compute) @workgroup_size(1)
+fn compute_main() {
   ignore_e0187b();
-  return;
-}
-void main() {
-  compute_main();
 }
 
+Failed to generate: intrinsics/gen/ignore/e0187b.wgsl:29:10 error: unknown identifier: 'arg_0'
+  ignore(arg_0);
+         ^^^^^
 
diff --git a/test/intrinsics/gen/textureDimensions/002b2a.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/002b2a.wgsl.expected.glsl
index 9b03989..f0e4606 100644
--- a/test/intrinsics/gen/textureDimensions/002b2a.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/002b2a.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler1D arg_0;
+uniform highp sampler1D arg_0_1;
 
 void textureDimensions_002b2a() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler1D arg_0;
+uniform highp sampler1D arg_0_1;
 
 void textureDimensions_002b2a() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler1D arg_0;
+uniform highp sampler1D arg_0_1;
 
 void textureDimensions_002b2a() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/012b82.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/012b82.wgsl.expected.glsl
index d7e382b..12cbfac 100644
--- a/test/intrinsics/gen/textureDimensions/012b82.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/012b82.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureDimensions_012b82() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureDimensions_012b82() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureDimensions_012b82() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/08753d.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/08753d.wgsl.expected.glsl
index 7b6ddd3..4dddbd1 100644
--- a/test/intrinsics/gen/textureDimensions/08753d.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/08753d.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureDimensions_08753d() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureDimensions_08753d() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureDimensions_08753d() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/0c4772.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/0c4772.wgsl.expected.glsl
index 47ea770..7801d7b 100644
--- a/test/intrinsics/gen/textureDimensions/0c4772.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/0c4772.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_0c4772() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_0c4772() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_0c4772() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/0cce40.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/0cce40.wgsl.expected.glsl
index b38c86f..94b8cb7 100644
--- a/test/intrinsics/gen/textureDimensions/0cce40.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/0cce40.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureDimensions_0cce40() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureDimensions_0cce40() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureDimensions_0cce40() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/0cf2ff.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/0cf2ff.wgsl.expected.glsl
index 3aa1e44..3d88177 100644
--- a/test/intrinsics/gen/textureDimensions/0cf2ff.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/0cf2ff.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureDimensions_0cf2ff() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureDimensions_0cf2ff() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureDimensions_0cf2ff() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/0d8b7e.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/0d8b7e.wgsl.expected.glsl
index 063525f..b4c615b 100644
--- a/test/intrinsics/gen/textureDimensions/0d8b7e.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/0d8b7e.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureDimensions_0d8b7e() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureDimensions_0d8b7e() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureDimensions_0d8b7e() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/0e32ee.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/0e32ee.wgsl.expected.glsl
index 7cca22f..4145cbe 100644
--- a/test/intrinsics/gen/textureDimensions/0e32ee.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/0e32ee.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureDimensions_0e32ee() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureDimensions_0e32ee() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureDimensions_0e32ee() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/0f3c50.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/0f3c50.wgsl.expected.glsl
index deb60b0..0c302bb 100644
--- a/test/intrinsics/gen/textureDimensions/0f3c50.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/0f3c50.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_0;
+uniform highp isampler2DArray arg_0_1;
 
 void textureDimensions_0f3c50() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_0;
+uniform highp isampler2DArray arg_0_1;
 
 void textureDimensions_0f3c50() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_0;
+uniform highp isampler2DArray arg_0_1;
 
 void textureDimensions_0f3c50() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/1191a5.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/1191a5.wgsl.expected.glsl
index 5acdae3..00c30af 100644
--- a/test/intrinsics/gen/textureDimensions/1191a5.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/1191a5.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_0;
+uniform highp usampler2D arg_0_1;
 
 void textureDimensions_1191a5() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_0;
+uniform highp usampler2D arg_0_1;
 
 void textureDimensions_1191a5() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_0;
+uniform highp usampler2D arg_0_1;
 
 void textureDimensions_1191a5() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/12c9bb.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/12c9bb.wgsl.expected.glsl
index 8ae5eda..e082710 100644
--- a/test/intrinsics/gen/textureDimensions/12c9bb.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/12c9bb.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureDimensions_12c9bb() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureDimensions_12c9bb() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureDimensions_12c9bb() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/147998.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/147998.wgsl.expected.glsl
index 436e19f..65b3a35 100644
--- a/test/intrinsics/gen/textureDimensions/147998.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/147998.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_147998() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_147998() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_147998() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/16036c.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/16036c.wgsl.expected.glsl
index 47bfbb9..eee836b 100644
--- a/test/intrinsics/gen/textureDimensions/16036c.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/16036c.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureDimensions_16036c() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureDimensions_16036c() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureDimensions_16036c() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/1b71f0.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/1b71f0.wgsl.expected.glsl
index 140fb96..c2a963f 100644
--- a/test/intrinsics/gen/textureDimensions/1b71f0.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/1b71f0.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureDimensions_1b71f0() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureDimensions_1b71f0() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureDimensions_1b71f0() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/1d6c26.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/1d6c26.wgsl.expected.glsl
index d07e8bd..2cd5a29 100644
--- a/test/intrinsics/gen/textureDimensions/1d6c26.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/1d6c26.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_1d6c26() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_1d6c26() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_1d6c26() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/1e9e39.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/1e9e39.wgsl.expected.glsl
index 01f35bb..73f9123 100644
--- a/test/intrinsics/gen/textureDimensions/1e9e39.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/1e9e39.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_1e9e39() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_1e9e39() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_1e9e39() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/1f20c5.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/1f20c5.wgsl.expected.glsl
index 98e26b9..eb97808 100644
--- a/test/intrinsics/gen/textureDimensions/1f20c5.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/1f20c5.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_0;
+uniform highp usampler2DArray arg_0_1;
 
 void textureDimensions_1f20c5() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_0;
+uniform highp usampler2DArray arg_0_1;
 
 void textureDimensions_1f20c5() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_0;
+uniform highp usampler2DArray arg_0_1;
 
 void textureDimensions_1f20c5() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/214dd4.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/214dd4.wgsl.expected.glsl
index c5d4bd9..4789569 100644
--- a/test/intrinsics/gen/textureDimensions/214dd4.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/214dd4.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureDimensions_214dd4() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureDimensions_214dd4() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureDimensions_214dd4() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/221f22.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/221f22.wgsl.expected.glsl
index 997fdbf..f34e49a 100644
--- a/test/intrinsics/gen/textureDimensions/221f22.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/221f22.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCubeArray arg_0;
+uniform highp isamplerCubeArray arg_0_1;
 
 void textureDimensions_221f22() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCubeArray arg_0;
+uniform highp isamplerCubeArray arg_0_1;
 
 void textureDimensions_221f22() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCubeArray arg_0;
+uniform highp isamplerCubeArray arg_0_1;
 
 void textureDimensions_221f22() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/267788.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/267788.wgsl.expected.glsl
index 2a38ed1..1563989 100644
--- a/test/intrinsics/gen/textureDimensions/267788.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/267788.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_0;
+uniform highp usampler2DArray arg_0_1;
 
 void textureDimensions_267788() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_0;
+uniform highp usampler2DArray arg_0_1;
 
 void textureDimensions_267788() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_0;
+uniform highp usampler2DArray arg_0_1;
 
 void textureDimensions_267788() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/26bdfa.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/26bdfa.wgsl.expected.glsl
index c11a1ba..88fb909 100644
--- a/test/intrinsics/gen/textureDimensions/26bdfa.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/26bdfa.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_1;
 
 void textureDimensions_26bdfa() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_1;
 
 void textureDimensions_26bdfa() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_1;
 
 void textureDimensions_26bdfa() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/26ef6c.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/26ef6c.wgsl.expected.glsl
index bff5392..22fc691 100644
--- a/test/intrinsics/gen/textureDimensions/26ef6c.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/26ef6c.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureDimensions_26ef6c() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureDimensions_26ef6c() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureDimensions_26ef6c() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/2ad087.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/2ad087.wgsl.expected.glsl
index 63a9d19..30f6172 100644
--- a/test/intrinsics/gen/textureDimensions/2ad087.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/2ad087.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureDimensions_2ad087() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureDimensions_2ad087() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureDimensions_2ad087() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/2efa05.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/2efa05.wgsl.expected.glsl
index 7fb5c3a..8f88fda 100644
--- a/test/intrinsics/gen/textureDimensions/2efa05.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/2efa05.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler3D arg_0;
+uniform highp usampler3D arg_0_1;
 
 void textureDimensions_2efa05() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler3D arg_0;
+uniform highp usampler3D arg_0_1;
 
 void textureDimensions_2efa05() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler3D arg_0;
+uniform highp usampler3D arg_0_1;
 
 void textureDimensions_2efa05() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/2f289f.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/2f289f.wgsl.expected.glsl
index 41213b9..e298288 100644
--- a/test/intrinsics/gen/textureDimensions/2f289f.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/2f289f.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureDimensions_2f289f() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureDimensions_2f289f() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureDimensions_2f289f() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/2fe1cc.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/2fe1cc.wgsl.expected.glsl
index 44c41df..90e48b0 100644
--- a/test/intrinsics/gen/textureDimensions/2fe1cc.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/2fe1cc.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureDimensions_2fe1cc() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureDimensions_2fe1cc() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureDimensions_2fe1cc() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/318ecc.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/318ecc.wgsl.expected.glsl
index 5bb035e..ce0aa37 100644
--- a/test/intrinsics/gen/textureDimensions/318ecc.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/318ecc.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureDimensions_318ecc() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureDimensions_318ecc() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureDimensions_318ecc() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/340d06.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/340d06.wgsl.expected.glsl
index ae0b0d1..f84cf9f 100644
--- a/test/intrinsics/gen/textureDimensions/340d06.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/340d06.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureDimensions_340d06() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureDimensions_340d06() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureDimensions_340d06() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/398e30.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/398e30.wgsl.expected.glsl
index f01ccff..89d737d 100644
--- a/test/intrinsics/gen/textureDimensions/398e30.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/398e30.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureDimensions_398e30() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureDimensions_398e30() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureDimensions_398e30() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/3a94ea.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/3a94ea.wgsl.expected.glsl
index 9e61b93..8ac7567 100644
--- a/test/intrinsics/gen/textureDimensions/3a94ea.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/3a94ea.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureDimensions_3a94ea() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureDimensions_3a94ea() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureDimensions_3a94ea() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/3aca08.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/3aca08.wgsl.expected.glsl
index 838aa42..8ec6e78 100644
--- a/test/intrinsics/gen/textureDimensions/3aca08.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/3aca08.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_3aca08() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_3aca08() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_3aca08() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/3c5ad8.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/3c5ad8.wgsl.expected.glsl
index e46b1a4..56d7055 100644
--- a/test/intrinsics/gen/textureDimensions/3c5ad8.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/3c5ad8.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureDimensions_3c5ad8() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureDimensions_3c5ad8() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureDimensions_3c5ad8() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/4152a6.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/4152a6.wgsl.expected.glsl
index c155b41..5176f09 100644
--- a/test/intrinsics/gen/textureDimensions/4152a6.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/4152a6.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCubeArray arg_0;
+uniform highp usamplerCubeArray arg_0_1;
 
 void textureDimensions_4152a6() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCubeArray arg_0;
+uniform highp usamplerCubeArray arg_0_1;
 
 void textureDimensions_4152a6() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCubeArray arg_0;
+uniform highp usamplerCubeArray arg_0_1;
 
 void textureDimensions_4152a6() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/423f99.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/423f99.wgsl.expected.glsl
index 074ff26..fbf1d02 100644
--- a/test/intrinsics/gen/textureDimensions/423f99.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/423f99.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler1D arg_0;
+uniform highp isampler1D arg_0_1;
 
 void textureDimensions_423f99() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler1D arg_0;
+uniform highp isampler1D arg_0_1;
 
 void textureDimensions_423f99() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler1D arg_0;
+uniform highp isampler1D arg_0_1;
 
 void textureDimensions_423f99() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/4267ee.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/4267ee.wgsl.expected.glsl
index 58078cc..618a9a8 100644
--- a/test/intrinsics/gen/textureDimensions/4267ee.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/4267ee.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_4267ee() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_4267ee() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_4267ee() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/42d4e6.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/42d4e6.wgsl.expected.glsl
index 91753ec..162868b 100644
--- a/test/intrinsics/gen/textureDimensions/42d4e6.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/42d4e6.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_42d4e6() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_42d4e6() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_42d4e6() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/48cb89.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/48cb89.wgsl.expected.glsl
index ba67ed6..6552d59 100644
--- a/test/intrinsics/gen/textureDimensions/48cb89.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/48cb89.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_48cb89() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_48cb89() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_48cb89() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/49d274.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/49d274.wgsl.expected.glsl
index fe5fe75..0c1669a 100644
--- a/test/intrinsics/gen/textureDimensions/49d274.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/49d274.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureDimensions_49d274() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureDimensions_49d274() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureDimensions_49d274() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/4df9a8.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/4df9a8.wgsl.expected.glsl
index 82d1974..a621b08 100644
--- a/test/intrinsics/gen/textureDimensions/4df9a8.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/4df9a8.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureDimensions_4df9a8() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureDimensions_4df9a8() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureDimensions_4df9a8() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/50a9ee.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/50a9ee.wgsl.expected.glsl
index 412ba50..1745af4 100644
--- a/test/intrinsics/gen/textureDimensions/50a9ee.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/50a9ee.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureDimensions_50a9ee() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureDimensions_50a9ee() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureDimensions_50a9ee() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/52045c.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/52045c.wgsl.expected.glsl
index e7a1937..709d104 100644
--- a/test/intrinsics/gen/textureDimensions/52045c.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/52045c.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler1D arg_0;
+uniform highp isampler1D arg_0_1;
 
 void textureDimensions_52045c() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler1D arg_0;
+uniform highp isampler1D arg_0_1;
 
 void textureDimensions_52045c() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler1D arg_0;
+uniform highp isampler1D arg_0_1;
 
 void textureDimensions_52045c() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/55b23e.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/55b23e.wgsl.expected.glsl
index 446361a..7e42c6a 100644
--- a/test/intrinsics/gen/textureDimensions/55b23e.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/55b23e.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_55b23e() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_55b23e() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_55b23e() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/579629.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/579629.wgsl.expected.glsl
index e708085..b8af02f 100644
--- a/test/intrinsics/gen/textureDimensions/579629.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/579629.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DMS arg_0;
+uniform highp usampler2DMS arg_0_1;
 
 void textureDimensions_579629() {
-  ivec2 res = textureSize(arg_0);
+  ivec2 res = textureSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DMS arg_0;
+uniform highp usampler2DMS arg_0_1;
 
 void textureDimensions_579629() {
-  ivec2 res = textureSize(arg_0);
+  ivec2 res = textureSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DMS arg_0;
+uniform highp usampler2DMS arg_0_1;
 
 void textureDimensions_579629() {
-  ivec2 res = textureSize(arg_0);
+  ivec2 res = textureSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/57da0b.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/57da0b.wgsl.expected.glsl
index ae3e70d..4a21363 100644
--- a/test/intrinsics/gen/textureDimensions/57da0b.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/57da0b.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureDimensions_57da0b() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureDimensions_57da0b() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureDimensions_57da0b() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/57e28f.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/57e28f.wgsl.expected.glsl
index bbc2d40..1619887 100644
--- a/test/intrinsics/gen/textureDimensions/57e28f.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/57e28f.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureDimensions_57e28f() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureDimensions_57e28f() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureDimensions_57e28f() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/58a515.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/58a515.wgsl.expected.glsl
index dcbe2db..7c3e45e 100644
--- a/test/intrinsics/gen/textureDimensions/58a515.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/58a515.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_58a515() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_58a515() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_58a515() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/5985f3.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/5985f3.wgsl.expected.glsl
index f947c8a..96f1e2c 100644
--- a/test/intrinsics/gen/textureDimensions/5985f3.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/5985f3.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureDimensions_5985f3() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureDimensions_5985f3() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureDimensions_5985f3() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/5caa5e.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/5caa5e.wgsl.expected.glsl
index 9cc48d7..6c878f6 100644
--- a/test/intrinsics/gen/textureDimensions/5caa5e.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/5caa5e.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureDimensions_5caa5e() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureDimensions_5caa5e() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureDimensions_5caa5e() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/5e295d.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/5e295d.wgsl.expected.glsl
index 4d1c04c..5cb0394 100644
--- a/test/intrinsics/gen/textureDimensions/5e295d.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/5e295d.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureDimensions_5e295d() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureDimensions_5e295d() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureDimensions_5e295d() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/60bf54.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/60bf54.wgsl.expected.glsl
index b197f2c..3b3f72f 100644
--- a/test/intrinsics/gen/textureDimensions/60bf54.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/60bf54.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureDimensions_60bf54() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureDimensions_60bf54() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureDimensions_60bf54() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/63f3cf.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/63f3cf.wgsl.expected.glsl
index 1432692..723e36a 100644
--- a/test/intrinsics/gen/textureDimensions/63f3cf.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/63f3cf.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_63f3cf() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_63f3cf() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_63f3cf() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/68105c.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/68105c.wgsl.expected.glsl
index 46638eb..e5d5a1b 100644
--- a/test/intrinsics/gen/textureDimensions/68105c.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/68105c.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureDimensions_68105c() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureDimensions_68105c() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureDimensions_68105c() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/686ef2.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/686ef2.wgsl.expected.glsl
index 8a5b705..f2855b4 100644
--- a/test/intrinsics/gen/textureDimensions/686ef2.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/686ef2.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCube arg_0;
+uniform highp isamplerCube arg_0_1;
 
 void textureDimensions_686ef2() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCube arg_0;
+uniform highp isamplerCube arg_0_1;
 
 void textureDimensions_686ef2() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCube arg_0;
+uniform highp isamplerCube arg_0_1;
 
 void textureDimensions_686ef2() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/6adac6.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/6adac6.wgsl.expected.glsl
index d658f91..f1509d1 100644
--- a/test/intrinsics/gen/textureDimensions/6adac6.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/6adac6.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureDimensions_6adac6() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureDimensions_6adac6() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureDimensions_6adac6() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/6ec1b4.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/6ec1b4.wgsl.expected.glsl
index 27faa07..42379c2 100644
--- a/test/intrinsics/gen/textureDimensions/6ec1b4.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/6ec1b4.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler3D arg_0;
+uniform highp usampler3D arg_0_1;
 
 void textureDimensions_6ec1b4() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler3D arg_0;
+uniform highp usampler3D arg_0_1;
 
 void textureDimensions_6ec1b4() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler3D arg_0;
+uniform highp usampler3D arg_0_1;
 
 void textureDimensions_6ec1b4() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/6f0d79.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/6f0d79.wgsl.expected.glsl
index 733c81b..95a369b 100644
--- a/test/intrinsics/gen/textureDimensions/6f0d79.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/6f0d79.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_6f0d79() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_6f0d79() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_6f0d79() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/702c53.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/702c53.wgsl.expected.glsl
index c64e9bd..873c7c7 100644
--- a/test/intrinsics/gen/textureDimensions/702c53.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/702c53.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_702c53() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_702c53() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_702c53() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/72e5d6.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/72e5d6.wgsl.expected.glsl
index 3a7fd3f..f6ef9e2 100644
--- a/test/intrinsics/gen/textureDimensions/72e5d6.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/72e5d6.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureDimensions_72e5d6() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureDimensions_72e5d6() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureDimensions_72e5d6() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/79df87.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/79df87.wgsl.expected.glsl
index 4ed8cd6..c658710 100644
--- a/test/intrinsics/gen/textureDimensions/79df87.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/79df87.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler1D arg_0;
+uniform highp usampler1D arg_0_1;
 
 void textureDimensions_79df87() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler1D arg_0;
+uniform highp usampler1D arg_0_1;
 
 void textureDimensions_79df87() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler1D arg_0;
+uniform highp usampler1D arg_0_1;
 
 void textureDimensions_79df87() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/7bf826.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/7bf826.wgsl.expected.glsl
index f27df22..35866ee 100644
--- a/test/intrinsics/gen/textureDimensions/7bf826.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/7bf826.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureDimensions_7bf826() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureDimensions_7bf826() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureDimensions_7bf826() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/7f5c2e.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/7f5c2e.wgsl.expected.glsl
index e96b1a9..2139896 100644
--- a/test/intrinsics/gen/textureDimensions/7f5c2e.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/7f5c2e.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureDimensions_7f5c2e() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureDimensions_7f5c2e() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureDimensions_7f5c2e() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/8028f3.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/8028f3.wgsl.expected.glsl
index bcf1d43..a9d7b4f 100644
--- a/test/intrinsics/gen/textureDimensions/8028f3.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/8028f3.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_8028f3() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_8028f3() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_8028f3() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/811679.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/811679.wgsl.expected.glsl
index 91597d0..bd3900d 100644
--- a/test/intrinsics/gen/textureDimensions/811679.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/811679.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureDimensions_811679() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureDimensions_811679() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureDimensions_811679() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/820596.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/820596.wgsl.expected.glsl
index 335d6e5..507a0d4 100644
--- a/test/intrinsics/gen/textureDimensions/820596.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/820596.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureDimensions_820596() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureDimensions_820596() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureDimensions_820596() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/83ee5a.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/83ee5a.wgsl.expected.glsl
index dc556cb..a1f321c 100644
--- a/test/intrinsics/gen/textureDimensions/83ee5a.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/83ee5a.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureDimensions_83ee5a() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureDimensions_83ee5a() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureDimensions_83ee5a() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/85d556.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/85d556.wgsl.expected.glsl
index 2ec3bea..2ae2c9d 100644
--- a/test/intrinsics/gen/textureDimensions/85d556.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/85d556.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureDimensions_85d556() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureDimensions_85d556() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureDimensions_85d556() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/88ad17.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/88ad17.wgsl.expected.glsl
index cffced6..eeece9c 100644
--- a/test/intrinsics/gen/textureDimensions/88ad17.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/88ad17.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCube arg_0;
+uniform highp usamplerCube arg_0_1;
 
 void textureDimensions_88ad17() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCube arg_0;
+uniform highp usamplerCube arg_0_1;
 
 void textureDimensions_88ad17() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCube arg_0;
+uniform highp usamplerCube arg_0_1;
 
 void textureDimensions_88ad17() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/8aa4c4.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/8aa4c4.wgsl.expected.glsl
index d0d8f5e..4afb1ea 100644
--- a/test/intrinsics/gen/textureDimensions/8aa4c4.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/8aa4c4.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_1;
 
 void textureDimensions_8aa4c4() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_1;
 
 void textureDimensions_8aa4c4() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_1;
 
 void textureDimensions_8aa4c4() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/8deb5e.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/8deb5e.wgsl.expected.glsl
index a695efb..c10bbd3 100644
--- a/test/intrinsics/gen/textureDimensions/8deb5e.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/8deb5e.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler3D arg_0;
+uniform highp isampler3D arg_0_1;
 
 void textureDimensions_8deb5e() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler3D arg_0;
+uniform highp isampler3D arg_0_1;
 
 void textureDimensions_8deb5e() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler3D arg_0;
+uniform highp isampler3D arg_0_1;
 
 void textureDimensions_8deb5e() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/8f20bf.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/8f20bf.wgsl.expected.glsl
index 6cef100..ed5bffa 100644
--- a/test/intrinsics/gen/textureDimensions/8f20bf.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/8f20bf.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureDimensions_8f20bf() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureDimensions_8f20bf() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureDimensions_8f20bf() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/8fca0f.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/8fca0f.wgsl.expected.glsl
index eba0cd1..25d5e6f 100644
--- a/test/intrinsics/gen/textureDimensions/8fca0f.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/8fca0f.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_8fca0f() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_8fca0f() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_8fca0f() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/90340b.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/90340b.wgsl.expected.glsl
index d74cc02..5fd0bb1 100644
--- a/test/intrinsics/gen/textureDimensions/90340b.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/90340b.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureDimensions_90340b() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureDimensions_90340b() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureDimensions_90340b() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/9042ab.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/9042ab.wgsl.expected.glsl
index c1d0dbd..3a03145 100644
--- a/test/intrinsics/gen/textureDimensions/9042ab.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/9042ab.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureDimensions_9042ab() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureDimensions_9042ab() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureDimensions_9042ab() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/9393b0.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/9393b0.wgsl.expected.glsl
index 9e76a57..31c65e8 100644
--- a/test/intrinsics/gen/textureDimensions/9393b0.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/9393b0.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureDimensions_9393b0() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureDimensions_9393b0() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureDimensions_9393b0() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/939fdb.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/939fdb.wgsl.expected.glsl
index 9b8ac54..a5f727a 100644
--- a/test/intrinsics/gen/textureDimensions/939fdb.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/939fdb.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureDimensions_939fdb() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureDimensions_939fdb() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureDimensions_939fdb() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/962dcd.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/962dcd.wgsl.expected.glsl
index 80879c8..030a7f8 100644
--- a/test/intrinsics/gen/textureDimensions/962dcd.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/962dcd.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCube arg_0;
+uniform highp isamplerCube arg_0_1;
 
 void textureDimensions_962dcd() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCube arg_0;
+uniform highp isamplerCube arg_0_1;
 
 void textureDimensions_962dcd() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCube arg_0;
+uniform highp isamplerCube arg_0_1;
 
 void textureDimensions_962dcd() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/9abfe5.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/9abfe5.wgsl.expected.glsl
index a89ff64..9d4a2d6 100644
--- a/test/intrinsics/gen/textureDimensions/9abfe5.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/9abfe5.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_9abfe5() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_9abfe5() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_9abfe5() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/9c9c57.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/9c9c57.wgsl.expected.glsl
index a261813..ee080fe 100644
--- a/test/intrinsics/gen/textureDimensions/9c9c57.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/9c9c57.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_0;
+uniform highp isampler2DArray arg_0_1;
 
 void textureDimensions_9c9c57() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_0;
+uniform highp isampler2DArray arg_0_1;
 
 void textureDimensions_9c9c57() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_0;
+uniform highp isampler2DArray arg_0_1;
 
 void textureDimensions_9c9c57() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/9da9e2.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/9da9e2.wgsl.expected.glsl
index 29d3e31..755e8ff 100644
--- a/test/intrinsics/gen/textureDimensions/9da9e2.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/9da9e2.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureDimensions_9da9e2() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureDimensions_9da9e2() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureDimensions_9da9e2() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/9eb8d8.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/9eb8d8.wgsl.expected.glsl
index 6989fd9..2fa2f62 100644
--- a/test/intrinsics/gen/textureDimensions/9eb8d8.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/9eb8d8.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureDimensions_9eb8d8() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureDimensions_9eb8d8() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureDimensions_9eb8d8() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/9f8e46.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/9f8e46.wgsl.expected.glsl
index 47bc890..fc5577b 100644
--- a/test/intrinsics/gen/textureDimensions/9f8e46.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/9f8e46.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureDimensions_9f8e46() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureDimensions_9f8e46() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureDimensions_9f8e46() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/a01845.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/a01845.wgsl.expected.glsl
index e839b90..18a2339 100644
--- a/test/intrinsics/gen/textureDimensions/a01845.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/a01845.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureDimensions_a01845() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureDimensions_a01845() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureDimensions_a01845() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/a7d565.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/a7d565.wgsl.expected.glsl
index 72208ea..3b9e347 100644
--- a/test/intrinsics/gen/textureDimensions/a7d565.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/a7d565.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler1D arg_0;
+uniform highp usampler1D arg_0_1;
 
 void textureDimensions_a7d565() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler1D arg_0;
+uniform highp usampler1D arg_0_1;
 
 void textureDimensions_a7d565() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler1D arg_0;
+uniform highp usampler1D arg_0_1;
 
 void textureDimensions_a7d565() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/a863f2.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/a863f2.wgsl.expected.glsl
index 7dbc256..cabacd5 100644
--- a/test/intrinsics/gen/textureDimensions/a863f2.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/a863f2.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_a863f2() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_a863f2() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_a863f2() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/a9c9c1.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/a9c9c1.wgsl.expected.glsl
index 0d0101f..8cb9404 100644
--- a/test/intrinsics/gen/textureDimensions/a9c9c1.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/a9c9c1.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureDimensions_a9c9c1() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureDimensions_a9c9c1() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureDimensions_a9c9c1() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/b0e16d.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/b0e16d.wgsl.expected.glsl
index 45b35df..f03fc04 100644
--- a/test/intrinsics/gen/textureDimensions/b0e16d.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/b0e16d.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_0;
+uniform highp isampler2D arg_0_1;
 
 void textureDimensions_b0e16d() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_0;
+uniform highp isampler2D arg_0_1;
 
 void textureDimensions_b0e16d() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_0;
+uniform highp isampler2D arg_0_1;
 
 void textureDimensions_b0e16d() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/b3c954.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/b3c954.wgsl.expected.glsl
index b88a82b..983e3ca 100644
--- a/test/intrinsics/gen/textureDimensions/b3c954.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/b3c954.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCube arg_0;
+uniform highp usamplerCube arg_0_1;
 
 void textureDimensions_b3c954() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCube arg_0;
+uniform highp usamplerCube arg_0_1;
 
 void textureDimensions_b3c954() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCube arg_0;
+uniform highp usamplerCube arg_0_1;
 
 void textureDimensions_b3c954() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/b3e407.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/b3e407.wgsl.expected.glsl
index 992dfcb..5a83f5a 100644
--- a/test/intrinsics/gen/textureDimensions/b3e407.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/b3e407.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler1D arg_0;
+uniform highp sampler1D arg_0_1;
 
 void textureDimensions_b3e407() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler1D arg_0;
+uniform highp sampler1D arg_0_1;
 
 void textureDimensions_b3e407() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler1D arg_0;
+uniform highp sampler1D arg_0_1;
 
 void textureDimensions_b3e407() {
-  int res = textureSize(arg_0, 0);
+  int res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/b91240.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/b91240.wgsl.expected.glsl
index e177092..595245a 100644
--- a/test/intrinsics/gen/textureDimensions/b91240.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/b91240.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_b91240() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_b91240() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_b91240() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/ba1481.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/ba1481.wgsl.expected.glsl
index b7eecc6..a63ec0b 100644
--- a/test/intrinsics/gen/textureDimensions/ba1481.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/ba1481.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureDimensions_ba1481() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureDimensions_ba1481() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureDimensions_ba1481() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/bb3dde.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/bb3dde.wgsl.expected.glsl
index 9c3370d..0aaf8a4 100644
--- a/test/intrinsics/gen/textureDimensions/bb3dde.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/bb3dde.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureDimensions_bb3dde() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureDimensions_bb3dde() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureDimensions_bb3dde() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/c30e75.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/c30e75.wgsl.expected.glsl
index d62618d..8d35883 100644
--- a/test/intrinsics/gen/textureDimensions/c30e75.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/c30e75.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureDimensions_c30e75() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureDimensions_c30e75() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureDimensions_c30e75() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/c7943d.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/c7943d.wgsl.expected.glsl
index bc6c6a2..3c6c9fc 100644
--- a/test/intrinsics/gen/textureDimensions/c7943d.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/c7943d.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureDimensions_c7943d() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureDimensions_c7943d() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureDimensions_c7943d() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/cc968c.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/cc968c.wgsl.expected.glsl
index cc7c50b..f214fad 100644
--- a/test/intrinsics/gen/textureDimensions/cc968c.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/cc968c.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureDimensions_cc968c() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureDimensions_cc968c() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureDimensions_cc968c() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/cccc8f.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/cccc8f.wgsl.expected.glsl
index 5171d34..8f3220f 100644
--- a/test/intrinsics/gen/textureDimensions/cccc8f.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/cccc8f.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_cccc8f() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_cccc8f() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureDimensions_cccc8f() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/cd76a7.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/cd76a7.wgsl.expected.glsl
index 4706335..9f25caa 100644
--- a/test/intrinsics/gen/textureDimensions/cd76a7.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/cd76a7.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_cd76a7() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_cd76a7() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_cd76a7() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/cdf473.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/cdf473.wgsl.expected.glsl
index 7a1789b..c7221d7 100644
--- a/test/intrinsics/gen/textureDimensions/cdf473.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/cdf473.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureDimensions_cdf473() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureDimensions_cdf473() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureDimensions_cdf473() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/cec841.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/cec841.wgsl.expected.glsl
index 5007544..9f1194f 100644
--- a/test/intrinsics/gen/textureDimensions/cec841.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/cec841.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureDimensions_cec841() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureDimensions_cec841() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureDimensions_cec841() {
-  ivec2 res = textureSize(arg_0, 0).xy;
+  ivec2 res = textureSize(arg_0_1, 0).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/cf7e43.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/cf7e43.wgsl.expected.glsl
index d2c9448..efe4df9 100644
--- a/test/intrinsics/gen/textureDimensions/cf7e43.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/cf7e43.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_cf7e43() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_cf7e43() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureDimensions_cf7e43() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/d125bc.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/d125bc.wgsl.expected.glsl
index 60444f2..cfe164c 100644
--- a/test/intrinsics/gen/textureDimensions/d125bc.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/d125bc.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureDimensions_d125bc() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureDimensions_d125bc() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureDimensions_d125bc() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/d83c45.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/d83c45.wgsl.expected.glsl
index 5c2fd79..b7f3106 100644
--- a/test/intrinsics/gen/textureDimensions/d83c45.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/d83c45.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCubeArray arg_0;
+uniform highp usamplerCubeArray arg_0_1;
 
 void textureDimensions_d83c45() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCubeArray arg_0;
+uniform highp usamplerCubeArray arg_0_1;
 
 void textureDimensions_d83c45() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCubeArray arg_0;
+uniform highp usamplerCubeArray arg_0_1;
 
 void textureDimensions_d83c45() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/daf7c0.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/daf7c0.wgsl.expected.glsl
index 9a6fa2a..d82ea38 100644
--- a/test/intrinsics/gen/textureDimensions/daf7c0.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/daf7c0.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DMS arg_0;
+uniform highp isampler2DMS arg_0_1;
 
 void textureDimensions_daf7c0() {
-  ivec2 res = textureSize(arg_0);
+  ivec2 res = textureSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DMS arg_0;
+uniform highp isampler2DMS arg_0_1;
 
 void textureDimensions_daf7c0() {
-  ivec2 res = textureSize(arg_0);
+  ivec2 res = textureSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DMS arg_0;
+uniform highp isampler2DMS arg_0_1;
 
 void textureDimensions_daf7c0() {
-  ivec2 res = textureSize(arg_0);
+  ivec2 res = textureSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/dc2dd0.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/dc2dd0.wgsl.expected.glsl
index 7e644be..0303408 100644
--- a/test/intrinsics/gen/textureDimensions/dc2dd0.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/dc2dd0.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureDimensions_dc2dd0() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureDimensions_dc2dd0() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureDimensions_dc2dd0() {
-  int res = imageSize(arg_0);
+  int res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/e927be.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/e927be.wgsl.expected.glsl
index f2b2190..d92c29c 100644
--- a/test/intrinsics/gen/textureDimensions/e927be.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/e927be.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCubeArray arg_0;
+uniform highp isamplerCubeArray arg_0_1;
 
 void textureDimensions_e927be() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCubeArray arg_0;
+uniform highp isamplerCubeArray arg_0_1;
 
 void textureDimensions_e927be() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCubeArray arg_0;
+uniform highp isamplerCubeArray arg_0_1;
 
 void textureDimensions_e927be() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/e9e96c.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/e9e96c.wgsl.expected.glsl
index 1d68700..d03330a 100644
--- a/test/intrinsics/gen/textureDimensions/e9e96c.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/e9e96c.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_e9e96c() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_e9e96c() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_e9e96c() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/ef5b89.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/ef5b89.wgsl.expected.glsl
index 1e0aa55..22e4adc 100644
--- a/test/intrinsics/gen/textureDimensions/ef5b89.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/ef5b89.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureDimensions_ef5b89() {
-  ivec2 res = textureSize(arg_0);
+  ivec2 res = textureSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureDimensions_ef5b89() {
-  ivec2 res = textureSize(arg_0);
+  ivec2 res = textureSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureDimensions_ef5b89() {
-  ivec2 res = textureSize(arg_0);
+  ivec2 res = textureSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/efc8a4.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/efc8a4.wgsl.expected.glsl
index ef095bb..48dc98f 100644
--- a/test/intrinsics/gen/textureDimensions/efc8a4.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/efc8a4.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler3D arg_0;
+uniform highp isampler3D arg_0_1;
 
 void textureDimensions_efc8a4() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler3D arg_0;
+uniform highp isampler3D arg_0_1;
 
 void textureDimensions_efc8a4() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler3D arg_0;
+uniform highp isampler3D arg_0_1;
 
 void textureDimensions_efc8a4() {
-  ivec3 res = textureSize(arg_0, 0);
+  ivec3 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/f60bdb.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/f60bdb.wgsl.expected.glsl
index c354540..67bd236 100644
--- a/test/intrinsics/gen/textureDimensions/f60bdb.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/f60bdb.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureDimensions_f60bdb() {
-  ivec2 res = textureSize(arg_0);
+  ivec2 res = textureSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureDimensions_f60bdb() {
-  ivec2 res = textureSize(arg_0);
+  ivec2 res = textureSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureDimensions_f60bdb() {
-  ivec2 res = textureSize(arg_0);
+  ivec2 res = textureSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/f7145b.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/f7145b.wgsl.expected.glsl
index f07f774..3a5deaf 100644
--- a/test/intrinsics/gen/textureDimensions/f7145b.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/f7145b.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_0;
+uniform highp usampler2D arg_0_1;
 
 void textureDimensions_f7145b() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_0;
+uniform highp usampler2D arg_0_1;
 
 void textureDimensions_f7145b() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_0;
+uniform highp usampler2D arg_0_1;
 
 void textureDimensions_f7145b() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/f931c7.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/f931c7.wgsl.expected.glsl
index 9ced198..f037d02 100644
--- a/test/intrinsics/gen/textureDimensions/f931c7.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/f931c7.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_f931c7() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_f931c7() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureDimensions_f931c7() {
-  ivec2 res = imageSize(arg_0);
+  ivec2 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/fa9859.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/fa9859.wgsl.expected.glsl
index f264bfc..24ba5d0 100644
--- a/test/intrinsics/gen/textureDimensions/fa9859.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/fa9859.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_0;
+uniform highp isampler2D arg_0_1;
 
 void textureDimensions_fa9859() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_0;
+uniform highp isampler2D arg_0_1;
 
 void textureDimensions_fa9859() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_0;
+uniform highp isampler2D arg_0_1;
 
 void textureDimensions_fa9859() {
-  ivec2 res = textureSize(arg_0, 0);
+  ivec2 res = textureSize(arg_0_1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/fb5670.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/fb5670.wgsl.expected.glsl
index ceb91ec..142e213 100644
--- a/test/intrinsics/gen/textureDimensions/fb5670.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/fb5670.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_fb5670() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_fb5670() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureDimensions_fb5670() {
-  ivec2 res = imageSize(arg_0).xy;
+  ivec2 res = imageSize(arg_0_1).xy;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureDimensions/fcac78.wgsl.expected.glsl b/test/intrinsics/gen/textureDimensions/fcac78.wgsl.expected.glsl
index 35f375d..563a1fd 100644
--- a/test/intrinsics/gen/textureDimensions/fcac78.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureDimensions/fcac78.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureDimensions_fcac78() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureDimensions_fcac78() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureDimensions_fcac78() {
-  ivec3 res = imageSize(arg_0);
+  ivec3 res = imageSize(arg_0_1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/01305f.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/01305f.wgsl.expected.glsl
index 7a031c7..538ccef 100644
--- a/test/intrinsics/gen/textureGather/01305f.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/01305f.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_1;
+uniform highp usampler2DArray arg_1_arg_2;
 
 
 void textureGather_01305f() {
-  uvec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, float(1)), 1);
+  uvec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_1;
+uniform highp usampler2DArray arg_1_arg_2;
 
 
 void textureGather_01305f() {
-  uvec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, float(1)), 1);
+  uvec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_1;
+uniform highp usampler2DArray arg_1_arg_2;
 
 
 void textureGather_01305f() {
-  uvec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, float(1)), 1);
+  uvec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/06030a.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/06030a.wgsl.expected.glsl
index a991654..6011ea7 100644
--- a/test/intrinsics/gen/textureGather/06030a.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/06030a.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_1;
+uniform highp sampler2DArray arg_1_arg_2;
 
 
 void textureGather_06030a() {
-  vec4 res = textureGatherOffset(arg_1, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
+  vec4 res = textureGatherOffset(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_1;
+uniform highp sampler2DArray arg_1_arg_2;
 
 
 void textureGather_06030a() {
-  vec4 res = textureGatherOffset(arg_1, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
+  vec4 res = textureGatherOffset(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_1;
+uniform highp sampler2DArray arg_1_arg_2;
 
 
 void textureGather_06030a() {
-  vec4 res = textureGatherOffset(arg_1, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
+  vec4 res = textureGatherOffset(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/10c554.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/10c554.wgsl.expected.glsl
index 46ae57f..1a7be7a 100644
--- a/test/intrinsics/gen/textureGather/10c554.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/10c554.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureGather_10c554() {
-  vec4 res = textureGather(arg_0, vec3(0.0f, 0.0f, 0.0f));
+  vec4 res = textureGather(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureGather_10c554() {
-  vec4 res = textureGather(arg_0, vec3(0.0f, 0.0f, 0.0f));
+  vec4 res = textureGather(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureGather_10c554() {
-  vec4 res = textureGather(arg_0, vec3(0.0f, 0.0f, 0.0f));
+  vec4 res = textureGather(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/15d79c.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/15d79c.wgsl.expected.glsl
index ab48779..31c0d21 100644
--- a/test/intrinsics/gen/textureGather/15d79c.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/15d79c.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_1;
+uniform highp sampler2D arg_1_arg_2;
 
 
 void textureGather_15d79c() {
-  vec4 res = textureGatherOffset(arg_1, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
+  vec4 res = textureGatherOffset(arg_1_arg_2, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_1;
+uniform highp sampler2D arg_1_arg_2;
 
 
 void textureGather_15d79c() {
-  vec4 res = textureGatherOffset(arg_1, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
+  vec4 res = textureGatherOffset(arg_1_arg_2, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_1;
+uniform highp sampler2D arg_1_arg_2;
 
 
 void textureGather_15d79c() {
-  vec4 res = textureGatherOffset(arg_1, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
+  vec4 res = textureGatherOffset(arg_1_arg_2, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/2e0ed5.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/2e0ed5.wgsl.expected.glsl
index 6bd8ee0..ebf283e 100644
--- a/test/intrinsics/gen/textureGather/2e0ed5.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/2e0ed5.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureGather_2e0ed5() {
-  vec4 res = textureGather(arg_0, vec2(0.0f, 0.0f));
+  vec4 res = textureGather(arg_0_arg_1, vec2(0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureGather_2e0ed5() {
-  vec4 res = textureGather(arg_0, vec2(0.0f, 0.0f));
+  vec4 res = textureGather(arg_0_arg_1, vec2(0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureGather_2e0ed5() {
-  vec4 res = textureGather(arg_0, vec2(0.0f, 0.0f));
+  vec4 res = textureGather(arg_0_arg_1, vec2(0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/3112e8.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/3112e8.wgsl.expected.glsl
index 426e0c7..054f212 100644
--- a/test/intrinsics/gen/textureGather/3112e8.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/3112e8.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_1;
+uniform highp samplerCubeArray arg_1_arg_2;
 
 
 void textureGather_3112e8() {
-  vec4 res = textureGather(arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
+  vec4 res = textureGather(arg_1_arg_2, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_1;
+uniform highp samplerCubeArray arg_1_arg_2;
 
 
 void textureGather_3112e8() {
-  vec4 res = textureGather(arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
+  vec4 res = textureGather(arg_1_arg_2, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_1;
+uniform highp samplerCubeArray arg_1_arg_2;
 
 
 void textureGather_3112e8() {
-  vec4 res = textureGather(arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
+  vec4 res = textureGather(arg_1_arg_2, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/3c527e.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/3c527e.wgsl.expected.glsl
index f21e631..d92418b 100644
--- a/test/intrinsics/gen/textureGather/3c527e.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/3c527e.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCubeArray arg_1;
+uniform highp usamplerCubeArray arg_1_arg_2;
 
 
 void textureGather_3c527e() {
-  uvec4 res = textureGather(arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
+  uvec4 res = textureGather(arg_1_arg_2, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCubeArray arg_1;
+uniform highp usamplerCubeArray arg_1_arg_2;
 
 
 void textureGather_3c527e() {
-  uvec4 res = textureGather(arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
+  uvec4 res = textureGather(arg_1_arg_2, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCubeArray arg_1;
+uniform highp usamplerCubeArray arg_1_arg_2;
 
 
 void textureGather_3c527e() {
-  uvec4 res = textureGather(arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
+  uvec4 res = textureGather(arg_1_arg_2, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/43025d.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/43025d.wgsl.expected.glsl
index 7e21d06..e6aafc5 100644
--- a/test/intrinsics/gen/textureGather/43025d.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/43025d.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureGather_43025d() {
-  vec4 res = textureGather(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)));
+  vec4 res = textureGather(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)));
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureGather_43025d() {
-  vec4 res = textureGather(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)));
+  vec4 res = textureGather(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)));
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureGather_43025d() {
-  vec4 res = textureGather(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)));
+  vec4 res = textureGather(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/4f2350.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/4f2350.wgsl.expected.glsl
index 8ee98e2..be595e8 100644
--- a/test/intrinsics/gen/textureGather/4f2350.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/4f2350.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_1;
+uniform highp isampler2DArray arg_1_arg_2;
 
 
 void textureGather_4f2350() {
-  ivec4 res = textureGatherOffset(arg_1, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
+  ivec4 res = textureGatherOffset(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_1;
+uniform highp isampler2DArray arg_1_arg_2;
 
 
 void textureGather_4f2350() {
-  ivec4 res = textureGatherOffset(arg_1, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
+  ivec4 res = textureGatherOffset(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_1;
+uniform highp isampler2DArray arg_1_arg_2;
 
 
 void textureGather_4f2350() {
-  ivec4 res = textureGatherOffset(arg_1, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
+  ivec4 res = textureGatherOffset(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/51cf0b.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/51cf0b.wgsl.expected.glsl
index 93de69e..96f60fe 100644
--- a/test/intrinsics/gen/textureGather/51cf0b.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/51cf0b.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_1;
+uniform highp isampler2DArray arg_1_arg_2;
 
 
 void textureGather_51cf0b() {
-  ivec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, float(1)), 1);
+  ivec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_1;
+uniform highp isampler2DArray arg_1_arg_2;
 
 
 void textureGather_51cf0b() {
-  ivec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, float(1)), 1);
+  ivec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_1;
+uniform highp isampler2DArray arg_1_arg_2;
 
 
 void textureGather_51cf0b() {
-  ivec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, float(1)), 1);
+  ivec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/53ece6.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/53ece6.wgsl.expected.glsl
index 3f90891..3609d3b 100644
--- a/test/intrinsics/gen/textureGather/53ece6.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/53ece6.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureGather_53ece6() {
-  vec4 res = textureGatherOffset(arg_0, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0));
+  vec4 res = textureGatherOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureGather_53ece6() {
-  vec4 res = textureGatherOffset(arg_0, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0));
+  vec4 res = textureGatherOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureGather_53ece6() {
-  vec4 res = textureGatherOffset(arg_0, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0));
+  vec4 res = textureGatherOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/57bfc6.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/57bfc6.wgsl.expected.glsl
index dafde3e..2248d18 100644
--- a/test/intrinsics/gen/textureGather/57bfc6.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/57bfc6.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_1;
+uniform highp samplerCube arg_1_arg_2;
 
 
 void textureGather_57bfc6() {
-  vec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, 0.0f), 1);
+  vec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_1;
+uniform highp samplerCube arg_1_arg_2;
 
 
 void textureGather_57bfc6() {
-  vec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, 0.0f), 1);
+  vec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_1;
+uniform highp samplerCube arg_1_arg_2;
 
 
 void textureGather_57bfc6() {
-  vec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, 0.0f), 1);
+  vec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/587ba3.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/587ba3.wgsl.expected.glsl
index c41e2bf..dd2da9d 100644
--- a/test/intrinsics/gen/textureGather/587ba3.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/587ba3.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_1;
+uniform highp isampler2D arg_1_arg_2;
 
 
 void textureGather_587ba3() {
-  ivec4 res = textureGather(arg_1, vec2(0.0f, 0.0f), 1);
+  ivec4 res = textureGather(arg_1_arg_2, vec2(0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_1;
+uniform highp isampler2D arg_1_arg_2;
 
 
 void textureGather_587ba3() {
-  ivec4 res = textureGather(arg_1, vec2(0.0f, 0.0f), 1);
+  ivec4 res = textureGather(arg_1_arg_2, vec2(0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_1;
+uniform highp isampler2D arg_1_arg_2;
 
 
 void textureGather_587ba3() {
-  ivec4 res = textureGather(arg_1, vec2(0.0f, 0.0f), 1);
+  ivec4 res = textureGather(arg_1_arg_2, vec2(0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/69e0fb.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/69e0fb.wgsl.expected.glsl
index c8ff55c..146affc 100644
--- a/test/intrinsics/gen/textureGather/69e0fb.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/69e0fb.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_1;
+uniform highp isampler2D arg_1_arg_2;
 
 
 void textureGather_69e0fb() {
-  ivec4 res = textureGatherOffset(arg_1, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
+  ivec4 res = textureGatherOffset(arg_1_arg_2, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_1;
+uniform highp isampler2D arg_1_arg_2;
 
 
 void textureGather_69e0fb() {
-  ivec4 res = textureGatherOffset(arg_1, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
+  ivec4 res = textureGatherOffset(arg_1_arg_2, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_1;
+uniform highp isampler2D arg_1_arg_2;
 
 
 void textureGather_69e0fb() {
-  ivec4 res = textureGatherOffset(arg_1, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
+  ivec4 res = textureGatherOffset(arg_1_arg_2, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/93003d.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/93003d.wgsl.expected.glsl
index 719be03..a3f0817 100644
--- a/test/intrinsics/gen/textureGather/93003d.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/93003d.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_1;
+uniform highp usampler2D arg_1_arg_2;
 
 
 void textureGather_93003d() {
-  uvec4 res = textureGatherOffset(arg_1, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
+  uvec4 res = textureGatherOffset(arg_1_arg_2, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_1;
+uniform highp usampler2D arg_1_arg_2;
 
 
 void textureGather_93003d() {
-  uvec4 res = textureGatherOffset(arg_1, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
+  uvec4 res = textureGatherOffset(arg_1_arg_2, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_1;
+uniform highp usampler2D arg_1_arg_2;
 
 
 void textureGather_93003d() {
-  uvec4 res = textureGatherOffset(arg_1, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
+  uvec4 res = textureGatherOffset(arg_1_arg_2, vec2(0.0f, 0.0f), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/9a6358.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/9a6358.wgsl.expected.glsl
index 023b148..7d074f9 100644
--- a/test/intrinsics/gen/textureGather/9a6358.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/9a6358.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureGather_9a6358() {
-  vec4 res = textureGather(arg_0, vec3(0.0f, 0.0f, float(1)));
+  vec4 res = textureGather(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)));
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureGather_9a6358() {
-  vec4 res = textureGather(arg_0, vec3(0.0f, 0.0f, float(1)));
+  vec4 res = textureGather(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)));
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureGather_9a6358() {
-  vec4 res = textureGather(arg_0, vec3(0.0f, 0.0f, float(1)));
+  vec4 res = textureGather(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/9efca2.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/9efca2.wgsl.expected.glsl
index b314556..3676bc6 100644
--- a/test/intrinsics/gen/textureGather/9efca2.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/9efca2.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_1;
+uniform highp sampler2DArray arg_1_arg_2;
 
 
 void textureGather_9efca2() {
-  vec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, float(1)), 1);
+  vec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_1;
+uniform highp sampler2DArray arg_1_arg_2;
 
 
 void textureGather_9efca2() {
-  vec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, float(1)), 1);
+  vec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_1;
+uniform highp sampler2DArray arg_1_arg_2;
 
 
 void textureGather_9efca2() {
-  vec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, float(1)), 1);
+  vec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/bd0b1e.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/bd0b1e.wgsl.expected.glsl
index 3398824..ca8732f 100644
--- a/test/intrinsics/gen/textureGather/bd0b1e.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/bd0b1e.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_1;
+uniform highp sampler2D arg_1_arg_2;
 
 
 void textureGather_bd0b1e() {
-  vec4 res = textureGather(arg_1, vec2(0.0f, 0.0f), 1);
+  vec4 res = textureGather(arg_1_arg_2, vec2(0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_1;
+uniform highp sampler2D arg_1_arg_2;
 
 
 void textureGather_bd0b1e() {
-  vec4 res = textureGather(arg_1, vec2(0.0f, 0.0f), 1);
+  vec4 res = textureGather(arg_1_arg_2, vec2(0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_1;
+uniform highp sampler2D arg_1_arg_2;
 
 
 void textureGather_bd0b1e() {
-  vec4 res = textureGather(arg_1, vec2(0.0f, 0.0f), 1);
+  vec4 res = textureGather(arg_1_arg_2, vec2(0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/c409ae.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/c409ae.wgsl.expected.glsl
index a6e5b88..223c9ab 100644
--- a/test/intrinsics/gen/textureGather/c409ae.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/c409ae.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureGather_c409ae() {
-  vec4 res = textureGatherOffset(arg_0, vec2(0.0f, 0.0f), ivec2(0, 0));
+  vec4 res = textureGatherOffset(arg_0_arg_1, vec2(0.0f, 0.0f), ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureGather_c409ae() {
-  vec4 res = textureGatherOffset(arg_0, vec2(0.0f, 0.0f), ivec2(0, 0));
+  vec4 res = textureGatherOffset(arg_0_arg_1, vec2(0.0f, 0.0f), ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureGather_c409ae() {
-  vec4 res = textureGatherOffset(arg_0, vec2(0.0f, 0.0f), ivec2(0, 0));
+  vec4 res = textureGatherOffset(arg_0_arg_1, vec2(0.0f, 0.0f), ivec2(0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/c55822.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/c55822.wgsl.expected.glsl
index 2da1a79..25791ee 100644
--- a/test/intrinsics/gen/textureGather/c55822.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/c55822.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCubeArray arg_1;
+uniform highp isamplerCubeArray arg_1_arg_2;
 
 
 void textureGather_c55822() {
-  ivec4 res = textureGather(arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
+  ivec4 res = textureGather(arg_1_arg_2, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCubeArray arg_1;
+uniform highp isamplerCubeArray arg_1_arg_2;
 
 
 void textureGather_c55822() {
-  ivec4 res = textureGather(arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
+  ivec4 res = textureGather(arg_1_arg_2, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCubeArray arg_1;
+uniform highp isamplerCubeArray arg_1_arg_2;
 
 
 void textureGather_c55822() {
-  ivec4 res = textureGather(arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
+  ivec4 res = textureGather(arg_1_arg_2, vec4(0.0f, 0.0f, 0.0f, float(1)), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/e1b67d.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/e1b67d.wgsl.expected.glsl
index 52b4950..75ad314 100644
--- a/test/intrinsics/gen/textureGather/e1b67d.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/e1b67d.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCube arg_1;
+uniform highp usamplerCube arg_1_arg_2;
 
 
 void textureGather_e1b67d() {
-  uvec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, 0.0f), 1);
+  uvec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCube arg_1;
+uniform highp usamplerCube arg_1_arg_2;
 
 
 void textureGather_e1b67d() {
-  uvec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, 0.0f), 1);
+  uvec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCube arg_1;
+uniform highp usamplerCube arg_1_arg_2;
 
 
 void textureGather_e1b67d() {
-  uvec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, 0.0f), 1);
+  uvec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/e9eff6.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/e9eff6.wgsl.expected.glsl
index 459a403..ebce328 100644
--- a/test/intrinsics/gen/textureGather/e9eff6.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/e9eff6.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_1;
+uniform highp usampler2D arg_1_arg_2;
 
 
 void textureGather_e9eff6() {
-  uvec4 res = textureGather(arg_1, vec2(0.0f, 0.0f), 1);
+  uvec4 res = textureGather(arg_1_arg_2, vec2(0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_1;
+uniform highp usampler2D arg_1_arg_2;
 
 
 void textureGather_e9eff6() {
-  uvec4 res = textureGather(arg_1, vec2(0.0f, 0.0f), 1);
+  uvec4 res = textureGather(arg_1_arg_2, vec2(0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_1;
+uniform highp usampler2D arg_1_arg_2;
 
 
 void textureGather_e9eff6() {
-  uvec4 res = textureGather(arg_1, vec2(0.0f, 0.0f), 1);
+  uvec4 res = textureGather(arg_1_arg_2, vec2(0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/f5f3ba.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/f5f3ba.wgsl.expected.glsl
index 78bb5d1..3086074 100644
--- a/test/intrinsics/gen/textureGather/f5f3ba.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/f5f3ba.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_1;
+uniform highp usampler2DArray arg_1_arg_2;
 
 
 void textureGather_f5f3ba() {
-  uvec4 res = textureGatherOffset(arg_1, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
+  uvec4 res = textureGatherOffset(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_1;
+uniform highp usampler2DArray arg_1_arg_2;
 
 
 void textureGather_f5f3ba() {
-  uvec4 res = textureGatherOffset(arg_1, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
+  uvec4 res = textureGatherOffset(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_1;
+uniform highp usampler2DArray arg_1_arg_2;
 
 
 void textureGather_f5f3ba() {
-  uvec4 res = textureGatherOffset(arg_1, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
+  uvec4 res = textureGatherOffset(arg_1_arg_2, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGather/f7995a.wgsl.expected.glsl b/test/intrinsics/gen/textureGather/f7995a.wgsl.expected.glsl
index 2329347..56f1bcf 100644
--- a/test/intrinsics/gen/textureGather/f7995a.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGather/f7995a.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCube arg_1;
+uniform highp isamplerCube arg_1_arg_2;
 
 
 void textureGather_f7995a() {
-  ivec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, 0.0f), 1);
+  ivec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCube arg_1;
+uniform highp isamplerCube arg_1_arg_2;
 
 
 void textureGather_f7995a() {
-  ivec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, 0.0f), 1);
+  ivec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCube arg_1;
+uniform highp isamplerCube arg_1_arg_2;
 
 
 void textureGather_f7995a() {
-  ivec4 res = textureGather(arg_1, vec3(0.0f, 0.0f, 0.0f), 1);
+  ivec4 res = textureGather(arg_1_arg_2, vec3(0.0f, 0.0f, 0.0f), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGatherCompare/182fd4.wgsl.expected.glsl b/test/intrinsics/gen/textureGatherCompare/182fd4.wgsl.expected.glsl
index 74797ec..734622c 100644
--- a/test/intrinsics/gen/textureGatherCompare/182fd4.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGatherCompare/182fd4.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureGatherCompare_182fd4() {
-  vec4 res = textureGather(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f);
+  vec4 res = textureGather(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
@@ -44,11 +44,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureGatherCompare_182fd4() {
-  vec4 res = textureGather(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f);
+  vec4 res = textureGather(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
@@ -75,11 +75,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureGatherCompare_182fd4() {
-  vec4 res = textureGather(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f);
+  vec4 res = textureGather(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGatherCompare/60d2d1.wgsl.expected.glsl b/test/intrinsics/gen/textureGatherCompare/60d2d1.wgsl.expected.glsl
index 816ba44..60d0a9a 100644
--- a/test/intrinsics/gen/textureGatherCompare/60d2d1.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGatherCompare/60d2d1.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureGatherCompare_60d2d1() {
-  vec4 res = textureGather(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
+  vec4 res = textureGather(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureGatherCompare_60d2d1() {
-  vec4 res = textureGather(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
+  vec4 res = textureGather(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureGatherCompare_60d2d1() {
-  vec4 res = textureGather(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
+  vec4 res = textureGather(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGatherCompare/6d9352.wgsl.expected.glsl b/test/intrinsics/gen/textureGatherCompare/6d9352.wgsl.expected.glsl
index de91a90..b56605b 100644
--- a/test/intrinsics/gen/textureGatherCompare/6d9352.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGatherCompare/6d9352.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureGatherCompare_6d9352() {
-  vec4 res = textureGather(arg_0, vec2(0.0f, 0.0f), 1.0f);
+  vec4 res = textureGather(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
@@ -44,11 +44,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureGatherCompare_6d9352() {
-  vec4 res = textureGather(arg_0, vec2(0.0f, 0.0f), 1.0f);
+  vec4 res = textureGather(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
@@ -75,11 +75,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureGatherCompare_6d9352() {
-  vec4 res = textureGather(arg_0, vec2(0.0f, 0.0f), 1.0f);
+  vec4 res = textureGather(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGatherCompare/6f1267.wgsl.expected.glsl b/test/intrinsics/gen/textureGatherCompare/6f1267.wgsl.expected.glsl
index a5296a6..605a4ec 100644
--- a/test/intrinsics/gen/textureGatherCompare/6f1267.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGatherCompare/6f1267.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureGatherCompare_6f1267() {
-  vec4 res = textureGatherOffset(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
+  vec4 res = textureGatherOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -44,11 +44,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureGatherCompare_6f1267() {
-  vec4 res = textureGatherOffset(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
+  vec4 res = textureGatherOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -75,11 +75,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureGatherCompare_6f1267() {
-  vec4 res = textureGatherOffset(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
+  vec4 res = textureGatherOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGatherCompare/783e65.wgsl.expected.glsl b/test/intrinsics/gen/textureGatherCompare/783e65.wgsl.expected.glsl
index 093a11d..f1f5eb4 100644
--- a/test/intrinsics/gen/textureGatherCompare/783e65.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGatherCompare/783e65.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureGatherCompare_783e65() {
-  vec4 res = textureGather(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f);
+  vec4 res = textureGather(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
@@ -44,11 +44,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureGatherCompare_783e65() {
-  vec4 res = textureGather(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f);
+  vec4 res = textureGather(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
@@ -75,11 +75,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureGatherCompare_783e65() {
-  vec4 res = textureGather(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f);
+  vec4 res = textureGather(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureGatherCompare/a5f587.wgsl.expected.glsl b/test/intrinsics/gen/textureGatherCompare/a5f587.wgsl.expected.glsl
index be3dfed..59811e6 100644
--- a/test/intrinsics/gen/textureGatherCompare/a5f587.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureGatherCompare/a5f587.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureGatherCompare_a5f587() {
-  vec4 res = textureGatherOffset(arg_0, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
+  vec4 res = textureGatherOffset(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -44,11 +44,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureGatherCompare_a5f587() {
-  vec4 res = textureGatherOffset(arg_0, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
+  vec4 res = textureGatherOffset(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -75,11 +75,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureGatherCompare_a5f587() {
-  vec4 res = textureGatherOffset(arg_0, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
+  vec4 res = textureGatherOffset(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/19cf87.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/19cf87.wgsl.expected.glsl
index 91845cb..70a25a7 100644
--- a/test/intrinsics/gen/textureLoad/19cf87.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/19cf87.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureLoad_19cf87() {
-  float res = texelFetch(arg_0, ivec2(0, 0), 0).x;
+  float res = texelFetch(arg_0_1, ivec2(0, 0), 0).x;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureLoad_19cf87() {
-  float res = texelFetch(arg_0, ivec2(0, 0), 0).x;
+  float res = texelFetch(arg_0_1, ivec2(0, 0), 0).x;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureLoad_19cf87() {
-  float res = texelFetch(arg_0, ivec2(0, 0), 0).x;
+  float res = texelFetch(arg_0_1, ivec2(0, 0), 0).x;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/1b8588.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/1b8588.wgsl.expected.glsl
index b2270fc..081c48c 100644
--- a/test/intrinsics/gen/textureLoad/1b8588.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/1b8588.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler1D arg_0;
+uniform highp usampler1D arg_0_1;
 
 void textureLoad_1b8588() {
-  uvec4 res = texelFetch(arg_0, 1, 0);
+  uvec4 res = texelFetch(arg_0_1, 1, 0);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler1D arg_0;
+uniform highp usampler1D arg_0_1;
 
 void textureLoad_1b8588() {
-  uvec4 res = texelFetch(arg_0, 1, 0);
+  uvec4 res = texelFetch(arg_0_1, 1, 0);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler1D arg_0;
+uniform highp usampler1D arg_0_1;
 
 void textureLoad_1b8588() {
-  uvec4 res = texelFetch(arg_0, 1, 0);
+  uvec4 res = texelFetch(arg_0_1, 1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/1f2016.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/1f2016.wgsl.expected.glsl
index ba2c43c..afc4f68 100644
--- a/test/intrinsics/gen/textureLoad/1f2016.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/1f2016.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_1;
 
 void textureLoad_1f2016() {
-  vec4 res = texelFetch(arg_0, ivec3(0, 0, 0), 0);
+  vec4 res = texelFetch(arg_0_1, ivec3(0, 0, 0), 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_1;
 
 void textureLoad_1f2016() {
-  vec4 res = texelFetch(arg_0, ivec3(0, 0, 0), 0);
+  vec4 res = texelFetch(arg_0_1, ivec3(0, 0, 0), 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_1;
 
 void textureLoad_1f2016() {
-  vec4 res = texelFetch(arg_0, ivec3(0, 0, 0), 0);
+  vec4 res = texelFetch(arg_0_1, ivec3(0, 0, 0), 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/484344.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/484344.wgsl.expected.glsl
index 23c97b7..9346a00 100644
--- a/test/intrinsics/gen/textureLoad/484344.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/484344.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureLoad_484344() {
-  vec4 res = texelFetch(arg_0, ivec2(0, 0), 0);
+  vec4 res = texelFetch(arg_0_1, ivec2(0, 0), 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureLoad_484344() {
-  vec4 res = texelFetch(arg_0, ivec2(0, 0), 0);
+  vec4 res = texelFetch(arg_0_1, ivec2(0, 0), 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureLoad_484344() {
-  vec4 res = texelFetch(arg_0, ivec2(0, 0), 0);
+  vec4 res = texelFetch(arg_0_1, ivec2(0, 0), 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/4fd803.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/4fd803.wgsl.expected.glsl
index 1912237..77702b8 100644
--- a/test/intrinsics/gen/textureLoad/4fd803.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/4fd803.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler3D arg_0;
+uniform highp isampler3D arg_0_1;
 
 void textureLoad_4fd803() {
-  ivec4 res = texelFetch(arg_0, ivec3(0, 0, 0), 0);
+  ivec4 res = texelFetch(arg_0_1, ivec3(0, 0, 0), 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler3D arg_0;
+uniform highp isampler3D arg_0_1;
 
 void textureLoad_4fd803() {
-  ivec4 res = texelFetch(arg_0, ivec3(0, 0, 0), 0);
+  ivec4 res = texelFetch(arg_0_1, ivec3(0, 0, 0), 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler3D arg_0;
+uniform highp isampler3D arg_0_1;
 
 void textureLoad_4fd803() {
-  ivec4 res = texelFetch(arg_0, ivec3(0, 0, 0), 0);
+  ivec4 res = texelFetch(arg_0_1, ivec3(0, 0, 0), 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/5a2f9d.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/5a2f9d.wgsl.expected.glsl
index ca2c53a..6d408cc 100644
--- a/test/intrinsics/gen/textureLoad/5a2f9d.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/5a2f9d.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler1D arg_0;
+uniform highp isampler1D arg_0_1;
 
 void textureLoad_5a2f9d() {
-  ivec4 res = texelFetch(arg_0, 1, 0);
+  ivec4 res = texelFetch(arg_0_1, 1, 0);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler1D arg_0;
+uniform highp isampler1D arg_0_1;
 
 void textureLoad_5a2f9d() {
-  ivec4 res = texelFetch(arg_0, 1, 0);
+  ivec4 res = texelFetch(arg_0_1, 1, 0);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler1D arg_0;
+uniform highp isampler1D arg_0_1;
 
 void textureLoad_5a2f9d() {
-  ivec4 res = texelFetch(arg_0, 1, 0);
+  ivec4 res = texelFetch(arg_0_1, 1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/6154d4.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/6154d4.wgsl.expected.glsl
index 996248d..85729bf 100644
--- a/test/intrinsics/gen/textureLoad/6154d4.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/6154d4.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_0;
+uniform highp usampler2D arg_0_1;
 
 void textureLoad_6154d4() {
-  uvec4 res = texelFetch(arg_0, ivec2(0, 0), 0);
+  uvec4 res = texelFetch(arg_0_1, ivec2(0, 0), 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_0;
+uniform highp usampler2D arg_0_1;
 
 void textureLoad_6154d4() {
-  uvec4 res = texelFetch(arg_0, ivec2(0, 0), 0);
+  uvec4 res = texelFetch(arg_0_1, ivec2(0, 0), 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_0;
+uniform highp usampler2D arg_0_1;
 
 void textureLoad_6154d4() {
-  uvec4 res = texelFetch(arg_0, ivec2(0, 0), 0);
+  uvec4 res = texelFetch(arg_0_1, ivec2(0, 0), 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/6273b1.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/6273b1.wgsl.expected.glsl
index 9063f24..68952ce 100644
--- a/test/intrinsics/gen/textureLoad/6273b1.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/6273b1.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureLoad_6273b1() {
-  float res = texelFetch(arg_0, ivec2(0, 0), 1).x;
+  float res = texelFetch(arg_0_1, ivec2(0, 0), 1).x;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureLoad_6273b1() {
-  float res = texelFetch(arg_0, ivec2(0, 0), 1).x;
+  float res = texelFetch(arg_0_1, ivec2(0, 0), 1).x;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureLoad_6273b1() {
-  float res = texelFetch(arg_0, ivec2(0, 0), 1).x;
+  float res = texelFetch(arg_0_1, ivec2(0, 0), 1).x;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/79e697.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/79e697.wgsl.expected.glsl
index 1c23ff0..b5ca742 100644
--- a/test/intrinsics/gen/textureLoad/79e697.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/79e697.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_0;
+uniform highp isampler2DArray arg_0_1;
 
 void textureLoad_79e697() {
-  ivec4 res = texelFetch(arg_0, ivec3(0, 0, 1), 0);
+  ivec4 res = texelFetch(arg_0_1, ivec3(0, 0, 1), 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_0;
+uniform highp isampler2DArray arg_0_1;
 
 void textureLoad_79e697() {
-  ivec4 res = texelFetch(arg_0, ivec3(0, 0, 1), 0);
+  ivec4 res = texelFetch(arg_0_1, ivec3(0, 0, 1), 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_0;
+uniform highp isampler2DArray arg_0_1;
 
 void textureLoad_79e697() {
-  ivec4 res = texelFetch(arg_0, ivec3(0, 0, 1), 0);
+  ivec4 res = texelFetch(arg_0_1, ivec3(0, 0, 1), 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/7c90e5.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/7c90e5.wgsl.expected.glsl
index 973acb9..c28793f 100644
--- a/test/intrinsics/gen/textureLoad/7c90e5.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/7c90e5.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_0;
+uniform highp usampler2DArray arg_0_1;
 
 void textureLoad_7c90e5() {
-  uvec4 res = texelFetch(arg_0, ivec3(0, 0, 1), 0);
+  uvec4 res = texelFetch(arg_0_1, ivec3(0, 0, 1), 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_0;
+uniform highp usampler2DArray arg_0_1;
 
 void textureLoad_7c90e5() {
-  uvec4 res = texelFetch(arg_0, ivec3(0, 0, 1), 0);
+  uvec4 res = texelFetch(arg_0_1, ivec3(0, 0, 1), 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_0;
+uniform highp usampler2DArray arg_0_1;
 
 void textureLoad_7c90e5() {
-  uvec4 res = texelFetch(arg_0, ivec3(0, 0, 1), 0);
+  uvec4 res = texelFetch(arg_0_1, ivec3(0, 0, 1), 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/81c381.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/81c381.wgsl.expected.glsl
index 23ae5de..d17526a 100644
--- a/test/intrinsics/gen/textureLoad/81c381.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/81c381.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler1D arg_0;
+uniform highp sampler1D arg_0_1;
 
 void textureLoad_81c381() {
-  vec4 res = texelFetch(arg_0, 1, 0);
+  vec4 res = texelFetch(arg_0_1, 1, 0);
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler1D arg_0;
+uniform highp sampler1D arg_0_1;
 
 void textureLoad_81c381() {
-  vec4 res = texelFetch(arg_0, 1, 0);
+  vec4 res = texelFetch(arg_0_1, 1, 0);
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler1D arg_0;
+uniform highp sampler1D arg_0_1;
 
 void textureLoad_81c381() {
-  vec4 res = texelFetch(arg_0, 1, 0);
+  vec4 res = texelFetch(arg_0_1, 1, 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/87be85.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/87be85.wgsl.expected.glsl
index 43a7c2f..edf24c7 100644
--- a/test/intrinsics/gen/textureLoad/87be85.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/87be85.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureLoad_87be85() {
-  vec4 res = texelFetch(arg_0, ivec3(0, 0, 1), 0);
+  vec4 res = texelFetch(arg_0_1, ivec3(0, 0, 1), 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureLoad_87be85() {
-  vec4 res = texelFetch(arg_0, ivec3(0, 0, 1), 0);
+  vec4 res = texelFetch(arg_0_1, ivec3(0, 0, 1), 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureLoad_87be85() {
-  vec4 res = texelFetch(arg_0, ivec3(0, 0, 1), 0);
+  vec4 res = texelFetch(arg_0_1, ivec3(0, 0, 1), 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/8acf41.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/8acf41.wgsl.expected.glsl
index 8d2fef5..41234eb 100644
--- a/test/intrinsics/gen/textureLoad/8acf41.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/8acf41.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureLoad_8acf41() {
-  vec4 res = texelFetch(arg_0, ivec2(0, 0), 0);
+  vec4 res = texelFetch(arg_0_1, ivec2(0, 0), 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureLoad_8acf41() {
-  vec4 res = texelFetch(arg_0, ivec2(0, 0), 0);
+  vec4 res = texelFetch(arg_0_1, ivec2(0, 0), 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureLoad_8acf41() {
-  vec4 res = texelFetch(arg_0, ivec2(0, 0), 0);
+  vec4 res = texelFetch(arg_0_1, ivec2(0, 0), 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/9b2667.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/9b2667.wgsl.expected.glsl
index 20e2df2..d0e0245 100644
--- a/test/intrinsics/gen/textureLoad/9b2667.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/9b2667.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureLoad_9b2667() {
-  float res = texelFetch(arg_0, ivec3(0, 0, 1), 0).x;
+  float res = texelFetch(arg_0_1, ivec3(0, 0, 1), 0).x;
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureLoad_9b2667() {
-  float res = texelFetch(arg_0, ivec3(0, 0, 1), 0).x;
+  float res = texelFetch(arg_0_1, ivec3(0, 0, 1), 0).x;
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureLoad_9b2667() {
-  float res = texelFetch(arg_0, ivec3(0, 0, 1), 0).x;
+  float res = texelFetch(arg_0_1, ivec3(0, 0, 1), 0).x;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/a583c9.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/a583c9.wgsl.expected.glsl
index cb434f5..16098ba 100644
--- a/test/intrinsics/gen/textureLoad/a583c9.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/a583c9.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureLoad_a583c9() {
-  vec4 res = texelFetch(arg_0, ivec2(0, 0), 1);
+  vec4 res = texelFetch(arg_0_1, ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureLoad_a583c9() {
-  vec4 res = texelFetch(arg_0, ivec2(0, 0), 1);
+  vec4 res = texelFetch(arg_0_1, ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureLoad_a583c9() {
-  vec4 res = texelFetch(arg_0, ivec2(0, 0), 1);
+  vec4 res = texelFetch(arg_0_1, ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/a9a9f5.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/a9a9f5.wgsl.expected.glsl
index b3e958c..81ff424 100644
--- a/test/intrinsics/gen/textureLoad/a9a9f5.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/a9a9f5.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler3D arg_0;
+uniform highp usampler3D arg_0_1;
 
 void textureLoad_a9a9f5() {
-  uvec4 res = texelFetch(arg_0, ivec3(0, 0, 0), 0);
+  uvec4 res = texelFetch(arg_0_1, ivec3(0, 0, 0), 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler3D arg_0;
+uniform highp usampler3D arg_0_1;
 
 void textureLoad_a9a9f5() {
-  uvec4 res = texelFetch(arg_0, ivec3(0, 0, 0), 0);
+  uvec4 res = texelFetch(arg_0_1, ivec3(0, 0, 0), 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler3D arg_0;
+uniform highp usampler3D arg_0_1;
 
 void textureLoad_a9a9f5() {
-  uvec4 res = texelFetch(arg_0, ivec3(0, 0, 0), 0);
+  uvec4 res = texelFetch(arg_0_1, ivec3(0, 0, 0), 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/c2a480.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/c2a480.wgsl.expected.glsl
index bef6376..5d3b644 100644
--- a/test/intrinsics/gen/textureLoad/c2a480.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/c2a480.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_0;
+uniform highp isampler2D arg_0_1;
 
 void textureLoad_c2a480() {
-  ivec4 res = texelFetch(arg_0, ivec2(0, 0), 0);
+  ivec4 res = texelFetch(arg_0_1, ivec2(0, 0), 0);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_0;
+uniform highp isampler2D arg_0_1;
 
 void textureLoad_c2a480() {
-  ivec4 res = texelFetch(arg_0, ivec2(0, 0), 0);
+  ivec4 res = texelFetch(arg_0_1, ivec2(0, 0), 0);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_0;
+uniform highp isampler2D arg_0_1;
 
 void textureLoad_c2a480() {
-  ivec4 res = texelFetch(arg_0, ivec2(0, 0), 0);
+  ivec4 res = texelFetch(arg_0_1, ivec2(0, 0), 0);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/c378ee.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/c378ee.wgsl.expected.glsl
index 57511b1..5677bfa 100644
--- a/test/intrinsics/gen/textureLoad/c378ee.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/c378ee.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DMS arg_0;
+uniform highp usampler2DMS arg_0_1;
 
 void textureLoad_c378ee() {
-  uvec4 res = texelFetch(arg_0, ivec2(0, 0), 1);
+  uvec4 res = texelFetch(arg_0_1, ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DMS arg_0;
+uniform highp usampler2DMS arg_0_1;
 
 void textureLoad_c378ee() {
-  uvec4 res = texelFetch(arg_0, ivec2(0, 0), 1);
+  uvec4 res = texelFetch(arg_0_1, ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DMS arg_0;
+uniform highp usampler2DMS arg_0_1;
 
 void textureLoad_c378ee() {
-  uvec4 res = texelFetch(arg_0, ivec2(0, 0), 1);
+  uvec4 res = texelFetch(arg_0_1, ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureLoad/e3d2cc.wgsl.expected.glsl b/test/intrinsics/gen/textureLoad/e3d2cc.wgsl.expected.glsl
index e5c4ee8..4b79410 100644
--- a/test/intrinsics/gen/textureLoad/e3d2cc.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureLoad/e3d2cc.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DMS arg_0;
+uniform highp isampler2DMS arg_0_1;
 
 void textureLoad_e3d2cc() {
-  ivec4 res = texelFetch(arg_0, ivec2(0, 0), 1);
+  ivec4 res = texelFetch(arg_0_1, ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DMS arg_0;
+uniform highp isampler2DMS arg_0_1;
 
 void textureLoad_e3d2cc() {
-  ivec4 res = texelFetch(arg_0, ivec2(0, 0), 1);
+  ivec4 res = texelFetch(arg_0_1, ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DMS arg_0;
+uniform highp isampler2DMS arg_0_1;
 
 void textureLoad_e3d2cc() {
-  ivec4 res = texelFetch(arg_0, ivec2(0, 0), 1);
+  ivec4 res = texelFetch(arg_0_1, ivec2(0, 0), 1);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/024820.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/024820.wgsl.expected.glsl
index b513151..e765223 100644
--- a/test/intrinsics/gen/textureNumLayers/024820.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/024820.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureNumLayers_024820() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureNumLayers_024820() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureNumLayers_024820() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/053df7.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/053df7.wgsl.expected.glsl
index 2319625..ab7bb78 100644
--- a/test/intrinsics/gen/textureNumLayers/053df7.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/053df7.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCubeArray arg_0;
+uniform highp usamplerCubeArray arg_0_1;
 
 void textureNumLayers_053df7() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCubeArray arg_0;
+uniform highp usamplerCubeArray arg_0_1;
 
 void textureNumLayers_053df7() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCubeArray arg_0;
+uniform highp usamplerCubeArray arg_0_1;
 
 void textureNumLayers_053df7() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/058cc3.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/058cc3.wgsl.expected.glsl
index f0f4f1c..299f4a1 100644
--- a/test/intrinsics/gen/textureNumLayers/058cc3.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/058cc3.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureNumLayers_058cc3() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureNumLayers_058cc3() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureNumLayers_058cc3() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/09d05d.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/09d05d.wgsl.expected.glsl
index 2cff982..18aac35 100644
--- a/test/intrinsics/gen/textureNumLayers/09d05d.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/09d05d.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_09d05d() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_09d05d() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_09d05d() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/13b4ce.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/13b4ce.wgsl.expected.glsl
index 1533617..52a278d 100644
--- a/test/intrinsics/gen/textureNumLayers/13b4ce.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/13b4ce.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureNumLayers_13b4ce() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureNumLayers_13b4ce() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureNumLayers_13b4ce() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/22e53b.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/22e53b.wgsl.expected.glsl
index 183d46f..2ec9677 100644
--- a/test/intrinsics/gen/textureNumLayers/22e53b.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/22e53b.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureNumLayers_22e53b() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureNumLayers_22e53b() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureNumLayers_22e53b() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/562013.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/562013.wgsl.expected.glsl
index 9fcdb8c..2cd483b 100644
--- a/test/intrinsics/gen/textureNumLayers/562013.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/562013.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_562013() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_562013() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_562013() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/5d59cd.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/5d59cd.wgsl.expected.glsl
index b7fff6a..17a02ff 100644
--- a/test/intrinsics/gen/textureNumLayers/5d59cd.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/5d59cd.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureNumLayers_5d59cd() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureNumLayers_5d59cd() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureNumLayers_5d59cd() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/68a65b.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/68a65b.wgsl.expected.glsl
index e62b6d7..b5f4054 100644
--- a/test/intrinsics/gen/textureNumLayers/68a65b.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/68a65b.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_68a65b() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_68a65b() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_68a65b() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/778bd1.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/778bd1.wgsl.expected.glsl
index 0fdca03..b8becf8 100644
--- a/test/intrinsics/gen/textureNumLayers/778bd1.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/778bd1.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureNumLayers_778bd1() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureNumLayers_778bd1() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureNumLayers_778bd1() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/7f1937.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/7f1937.wgsl.expected.glsl
index fe25334..32e291d 100644
--- a/test/intrinsics/gen/textureNumLayers/7f1937.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/7f1937.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_7f1937() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_7f1937() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_7f1937() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/85f980.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/85f980.wgsl.expected.glsl
index c7f5e15..71ec67e 100644
--- a/test/intrinsics/gen/textureNumLayers/85f980.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/85f980.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCubeArray arg_0;
+uniform highp isamplerCubeArray arg_0_1;
 
 void textureNumLayers_85f980() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCubeArray arg_0;
+uniform highp isamplerCubeArray arg_0_1;
 
 void textureNumLayers_85f980() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCubeArray arg_0;
+uniform highp isamplerCubeArray arg_0_1;
 
 void textureNumLayers_85f980() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/87953e.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/87953e.wgsl.expected.glsl
index a8374fd..05441b0 100644
--- a/test/intrinsics/gen/textureNumLayers/87953e.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/87953e.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_0;
+uniform highp usampler2DArray arg_0_1;
 
 void textureNumLayers_87953e() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_0;
+uniform highp usampler2DArray arg_0_1;
 
 void textureNumLayers_87953e() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_0;
+uniform highp usampler2DArray arg_0_1;
 
 void textureNumLayers_87953e() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/893e7c.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/893e7c.wgsl.expected.glsl
index 56a5821..03a4f6a 100644
--- a/test/intrinsics/gen/textureNumLayers/893e7c.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/893e7c.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_0;
+uniform highp isampler2DArray arg_0_1;
 
 void textureNumLayers_893e7c() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_0;
+uniform highp isampler2DArray arg_0_1;
 
 void textureNumLayers_893e7c() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_0;
+uniform highp isampler2DArray arg_0_1;
 
 void textureNumLayers_893e7c() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/9700fb.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/9700fb.wgsl.expected.glsl
index c1f8ea1..04cd196 100644
--- a/test/intrinsics/gen/textureNumLayers/9700fb.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/9700fb.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureNumLayers_9700fb() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureNumLayers_9700fb() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureNumLayers_9700fb() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/a216d2.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/a216d2.wgsl.expected.glsl
index e8e3b28..446bfad 100644
--- a/test/intrinsics/gen/textureNumLayers/a216d2.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/a216d2.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureNumLayers_a216d2() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureNumLayers_a216d2() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureNumLayers_a216d2() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/cd5dc8.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/cd5dc8.wgsl.expected.glsl
index a71b160..5cee038 100644
--- a/test/intrinsics/gen/textureNumLayers/cd5dc8.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/cd5dc8.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureNumLayers_cd5dc8() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureNumLayers_cd5dc8() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureNumLayers_cd5dc8() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/d5b228.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/d5b228.wgsl.expected.glsl
index a0123fd..6417e38 100644
--- a/test/intrinsics/gen/textureNumLayers/d5b228.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/d5b228.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_d5b228() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_d5b228() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_d5b228() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/e31be1.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/e31be1.wgsl.expected.glsl
index 3cc2e8a..6ca95ba 100644
--- a/test/intrinsics/gen/textureNumLayers/e31be1.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/e31be1.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_e31be1() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_e31be1() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureNumLayers_e31be1() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/e653c0.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/e653c0.wgsl.expected.glsl
index 9f60963..4717704 100644
--- a/test/intrinsics/gen/textureNumLayers/e653c0.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/e653c0.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureNumLayers_e653c0() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureNumLayers_e653c0() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureNumLayers_e653c0() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/ee942f.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/ee942f.wgsl.expected.glsl
index 11d5b50..c528db4 100644
--- a/test/intrinsics/gen/textureNumLayers/ee942f.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/ee942f.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureNumLayers_ee942f() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureNumLayers_ee942f() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureNumLayers_ee942f() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/f33005.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/f33005.wgsl.expected.glsl
index 32669d4..229f7fc 100644
--- a/test/intrinsics/gen/textureNumLayers/f33005.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/f33005.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureNumLayers_f33005() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureNumLayers_f33005() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureNumLayers_f33005() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/fcec98.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/fcec98.wgsl.expected.glsl
index d401fa8..3f98db4 100644
--- a/test/intrinsics/gen/textureNumLayers/fcec98.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/fcec98.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureNumLayers_fcec98() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureNumLayers_fcec98() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureNumLayers_fcec98() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLayers/ff5e89.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLayers/ff5e89.wgsl.expected.glsl
index 9dee14a..49db3b8 100644
--- a/test/intrinsics/gen/textureNumLayers/ff5e89.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLayers/ff5e89.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureNumLayers_ff5e89() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureNumLayers_ff5e89() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureNumLayers_ff5e89() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/076cb5.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/076cb5.wgsl.expected.glsl
index 60570af..ea3b6b6 100644
--- a/test/intrinsics/gen/textureNumLevels/076cb5.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/076cb5.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureNumLevels_076cb5() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureNumLevels_076cb5() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureNumLevels_076cb5() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/080d95.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/080d95.wgsl.expected.glsl
index d5825e7..ee124a8 100644
--- a/test/intrinsics/gen/textureNumLevels/080d95.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/080d95.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCube arg_0;
+uniform highp isamplerCube arg_0_1;
 
 void textureNumLevels_080d95() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCube arg_0;
+uniform highp isamplerCube arg_0_1;
 
 void textureNumLevels_080d95() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCube arg_0;
+uniform highp isamplerCube arg_0_1;
 
 void textureNumLevels_080d95() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/09ddd0.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/09ddd0.wgsl.expected.glsl
index 176fbde..d874ab2 100644
--- a/test/intrinsics/gen/textureNumLevels/09ddd0.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/09ddd0.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_0;
+uniform highp usampler2D arg_0_1;
 
 void textureNumLevels_09ddd0() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_0;
+uniform highp usampler2D arg_0_1;
 
 void textureNumLevels_09ddd0() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D arg_0;
+uniform highp usampler2D arg_0_1;
 
 void textureNumLevels_09ddd0() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/105988.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/105988.wgsl.expected.glsl
index 53a5318..9d2af6a 100644
--- a/test/intrinsics/gen/textureNumLevels/105988.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/105988.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureNumLevels_105988() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureNumLevels_105988() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureNumLevels_105988() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/1e6f3b.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/1e6f3b.wgsl.expected.glsl
index 2ffe003..50168b9 100644
--- a/test/intrinsics/gen/textureNumLevels/1e6f3b.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/1e6f3b.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler1D arg_0;
+uniform highp usampler1D arg_0_1;
 
 void textureNumLevels_1e6f3b() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler1D arg_0;
+uniform highp usampler1D arg_0_1;
 
 void textureNumLevels_1e6f3b() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler1D arg_0;
+uniform highp usampler1D arg_0_1;
 
 void textureNumLevels_1e6f3b() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/23f750.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/23f750.wgsl.expected.glsl
index 1430293..47e83b9 100644
--- a/test/intrinsics/gen/textureNumLevels/23f750.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/23f750.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_0;
+uniform highp isampler2D arg_0_1;
 
 void textureNumLevels_23f750() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_0;
+uniform highp isampler2D arg_0_1;
 
 void textureNumLevels_23f750() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D arg_0;
+uniform highp isampler2D arg_0_1;
 
 void textureNumLevels_23f750() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/2c3575.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/2c3575.wgsl.expected.glsl
index 2076d2e..7e64833 100644
--- a/test/intrinsics/gen/textureNumLevels/2c3575.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/2c3575.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureNumLevels_2c3575() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureNumLevels_2c3575() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureNumLevels_2c3575() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/32a0ae.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/32a0ae.wgsl.expected.glsl
index d990da4..31f9531 100644
--- a/test/intrinsics/gen/textureNumLevels/32a0ae.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/32a0ae.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler1D arg_0;
+uniform highp isampler1D arg_0_1;
 
 void textureNumLevels_32a0ae() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler1D arg_0;
+uniform highp isampler1D arg_0_1;
 
 void textureNumLevels_32a0ae() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler1D arg_0;
+uniform highp isampler1D arg_0_1;
 
 void textureNumLevels_32a0ae() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/5101cf.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/5101cf.wgsl.expected.glsl
index 2b4d3e7..abf90fc 100644
--- a/test/intrinsics/gen/textureNumLevels/5101cf.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/5101cf.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_0;
+uniform highp usampler2DArray arg_0_1;
 
 void textureNumLevels_5101cf() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_0;
+uniform highp usampler2DArray arg_0_1;
 
 void textureNumLevels_5101cf() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DArray arg_0;
+uniform highp usampler2DArray arg_0_1;
 
 void textureNumLevels_5101cf() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/51b5bb.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/51b5bb.wgsl.expected.glsl
index d5ad1f5..2cf1057 100644
--- a/test/intrinsics/gen/textureNumLevels/51b5bb.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/51b5bb.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler1D arg_0;
+uniform highp sampler1D arg_0_1;
 
 void textureNumLevels_51b5bb() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler1D arg_0;
+uniform highp sampler1D arg_0_1;
 
 void textureNumLevels_51b5bb() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler1D arg_0;
+uniform highp sampler1D arg_0_1;
 
 void textureNumLevels_51b5bb() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/897aaf.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/897aaf.wgsl.expected.glsl
index 30e557a..fe99bb1 100644
--- a/test/intrinsics/gen/textureNumLevels/897aaf.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/897aaf.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureNumLevels_897aaf() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureNumLevels_897aaf() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_1;
 
 void textureNumLevels_897aaf() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/9da7a5.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/9da7a5.wgsl.expected.glsl
index 7acaec0..7ab0aa2 100644
--- a/test/intrinsics/gen/textureNumLevels/9da7a5.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/9da7a5.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler3D arg_0;
+uniform highp isampler3D arg_0_1;
 
 void textureNumLevels_9da7a5() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler3D arg_0;
+uniform highp isampler3D arg_0_1;
 
 void textureNumLevels_9da7a5() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler3D arg_0;
+uniform highp isampler3D arg_0_1;
 
 void textureNumLevels_9da7a5() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/a91c03.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/a91c03.wgsl.expected.glsl
index c1d0c7c..c453ab6 100644
--- a/test/intrinsics/gen/textureNumLevels/a91c03.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/a91c03.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCubeArray arg_0;
+uniform highp isamplerCubeArray arg_0_1;
 
 void textureNumLevels_a91c03() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCubeArray arg_0;
+uniform highp isamplerCubeArray arg_0_1;
 
 void textureNumLevels_a91c03() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isamplerCubeArray arg_0;
+uniform highp isamplerCubeArray arg_0_1;
 
 void textureNumLevels_a91c03() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/aee7c8.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/aee7c8.wgsl.expected.glsl
index 415c35d..bf7c57e 100644
--- a/test/intrinsics/gen/textureNumLevels/aee7c8.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/aee7c8.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureNumLevels_aee7c8() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureNumLevels_aee7c8() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_1;
 
 void textureNumLevels_aee7c8() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/b1b12b.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/b1b12b.wgsl.expected.glsl
index 6579ed0..33cf33b 100644
--- a/test/intrinsics/gen/textureNumLevels/b1b12b.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/b1b12b.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureNumLevels_b1b12b() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureNumLevels_b1b12b() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureNumLevels_b1b12b() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/b4f5ea.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/b4f5ea.wgsl.expected.glsl
index f3319ec..16a6610 100644
--- a/test/intrinsics/gen/textureNumLevels/b4f5ea.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/b4f5ea.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler3D arg_0;
+uniform highp usampler3D arg_0_1;
 
 void textureNumLevels_b4f5ea() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler3D arg_0;
+uniform highp usampler3D arg_0_1;
 
 void textureNumLevels_b4f5ea() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler3D arg_0;
+uniform highp usampler3D arg_0_1;
 
 void textureNumLevels_b4f5ea() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/d004a9.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/d004a9.wgsl.expected.glsl
index b5b0626..f4fa651 100644
--- a/test/intrinsics/gen/textureNumLevels/d004a9.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/d004a9.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_0;
+uniform highp isampler2DArray arg_0_1;
 
 void textureNumLevels_d004a9() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_0;
+uniform highp isampler2DArray arg_0_1;
 
 void textureNumLevels_d004a9() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DArray arg_0;
+uniform highp isampler2DArray arg_0_1;
 
 void textureNumLevels_d004a9() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/dca09e.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/dca09e.wgsl.expected.glsl
index 3ec191d..8b967a8 100644
--- a/test/intrinsics/gen/textureNumLevels/dca09e.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/dca09e.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_1;
 
 void textureNumLevels_dca09e() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_1;
 
 void textureNumLevels_dca09e() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_1;
 
 void textureNumLevels_dca09e() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/e67231.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/e67231.wgsl.expected.glsl
index e11a569..d6103dd 100644
--- a/test/intrinsics/gen/textureNumLevels/e67231.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/e67231.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureNumLevels_e67231() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureNumLevels_e67231() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_1;
 
 void textureNumLevels_e67231() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/ed078b.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/ed078b.wgsl.expected.glsl
index 6dd5ced..744b130 100644
--- a/test/intrinsics/gen/textureNumLevels/ed078b.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/ed078b.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCube arg_0;
+uniform highp usamplerCube arg_0_1;
 
 void textureNumLevels_ed078b() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCube arg_0;
+uniform highp usamplerCube arg_0_1;
 
 void textureNumLevels_ed078b() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCube arg_0;
+uniform highp usamplerCube arg_0_1;
 
 void textureNumLevels_ed078b() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/f46ec6.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/f46ec6.wgsl.expected.glsl
index fb2037c..d022ea8 100644
--- a/test/intrinsics/gen/textureNumLevels/f46ec6.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/f46ec6.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCubeArray arg_0;
+uniform highp usamplerCubeArray arg_0_1;
 
 void textureNumLevels_f46ec6() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCubeArray arg_0;
+uniform highp usamplerCubeArray arg_0_1;
 
 void textureNumLevels_f46ec6() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usamplerCubeArray arg_0;
+uniform highp usamplerCubeArray arg_0_1;
 
 void textureNumLevels_f46ec6() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumLevels/f5828d.wgsl.expected.glsl b/test/intrinsics/gen/textureNumLevels/f5828d.wgsl.expected.glsl
index 73f917c..ae65de0 100644
--- a/test/intrinsics/gen/textureNumLevels/f5828d.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumLevels/f5828d.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureNumLevels_f5828d() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureNumLevels_f5828d() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_1;
 
 void textureNumLevels_f5828d() {
-  int res = textureQueryLevels(arg_0);;
+  int res = textureQueryLevels(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumSamples/2c6f14.wgsl.expected.glsl b/test/intrinsics/gen/textureNumSamples/2c6f14.wgsl.expected.glsl
index d21f842..d2507ab 100644
--- a/test/intrinsics/gen/textureNumSamples/2c6f14.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumSamples/2c6f14.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureNumSamples_2c6f14() {
-  int res = textureSamples(arg_0);;
+  int res = textureSamples(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureNumSamples_2c6f14() {
-  int res = textureSamples(arg_0);;
+  int res = textureSamples(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureNumSamples_2c6f14() {
-  int res = textureSamples(arg_0);;
+  int res = textureSamples(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumSamples/42f8bb.wgsl.expected.glsl b/test/intrinsics/gen/textureNumSamples/42f8bb.wgsl.expected.glsl
index fa23cef..7b0c519 100644
--- a/test/intrinsics/gen/textureNumSamples/42f8bb.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumSamples/42f8bb.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DMS arg_0;
+uniform highp usampler2DMS arg_0_1;
 
 void textureNumSamples_42f8bb() {
-  int res = textureSamples(arg_0);;
+  int res = textureSamples(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DMS arg_0;
+uniform highp usampler2DMS arg_0_1;
 
 void textureNumSamples_42f8bb() {
-  int res = textureSamples(arg_0);;
+  int res = textureSamples(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2DMS arg_0;
+uniform highp usampler2DMS arg_0_1;
 
 void textureNumSamples_42f8bb() {
-  int res = textureSamples(arg_0);;
+  int res = textureSamples(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumSamples/449d23.wgsl.expected.glsl b/test/intrinsics/gen/textureNumSamples/449d23.wgsl.expected.glsl
index 8b37690..a22589b 100644
--- a/test/intrinsics/gen/textureNumSamples/449d23.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumSamples/449d23.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DMS arg_0;
+uniform highp isampler2DMS arg_0_1;
 
 void textureNumSamples_449d23() {
-  int res = textureSamples(arg_0);;
+  int res = textureSamples(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DMS arg_0;
+uniform highp isampler2DMS arg_0_1;
 
 void textureNumSamples_449d23() {
-  int res = textureSamples(arg_0);;
+  int res = textureSamples(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2DMS arg_0;
+uniform highp isampler2DMS arg_0_1;
 
 void textureNumSamples_449d23() {
-  int res = textureSamples(arg_0);;
+  int res = textureSamples(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureNumSamples/a3c8a0.wgsl.expected.glsl b/test/intrinsics/gen/textureNumSamples/a3c8a0.wgsl.expected.glsl
index 2bc017d..1e13b72 100644
--- a/test/intrinsics/gen/textureNumSamples/a3c8a0.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureNumSamples/a3c8a0.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureNumSamples_a3c8a0() {
-  int res = textureSamples(arg_0);;
+  int res = textureSamples(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -43,10 +43,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureNumSamples_a3c8a0() {
-  int res = textureSamples(arg_0);;
+  int res = textureSamples(arg_0_1);;
 }
 
 struct tint_symbol {
@@ -73,10 +73,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureNumSamples_a3c8a0() {
-  int res = textureSamples(arg_0);;
+  int res = textureSamples(arg_0_1);;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSample/02aa9b.wgsl.expected.glsl b/test/intrinsics/gen/textureSample/02aa9b.wgsl.expected.glsl
index beb2323..3be69b9 100644
--- a/test/intrinsics/gen/textureSample/02aa9b.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSample/02aa9b.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSample_02aa9b() {
-  vec4 res = textureOffset(arg_0, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0));
+  vec4 res = textureOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0));
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSample/100dc0.wgsl.expected.glsl b/test/intrinsics/gen/textureSample/100dc0.wgsl.expected.glsl
index e4db7a3..1215f7d 100644
--- a/test/intrinsics/gen/textureSample/100dc0.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSample/100dc0.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_arg_1;
 
 
 void textureSample_100dc0() {
-  vec4 res = textureOffset(arg_0, vec3(0.0f, 0.0f, 0.0f), ivec3(0, 0, 0));
+  vec4 res = textureOffset(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), ivec3(0, 0, 0));
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSample/38bbb9.wgsl.expected.glsl b/test/intrinsics/gen/textureSample/38bbb9.wgsl.expected.glsl
index dda133e..e2a25d5 100644
--- a/test/intrinsics/gen/textureSample/38bbb9.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSample/38bbb9.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSample_38bbb9() {
-  float res = texture(arg_0, vec2(0.0f, 0.0f)).x;
+  float res = texture(arg_0_arg_1, vec2(0.0f, 0.0f)).x;
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSample/3b50bd.wgsl.expected.glsl b/test/intrinsics/gen/textureSample/3b50bd.wgsl.expected.glsl
index 838a5d9..d41bb79 100644
--- a/test/intrinsics/gen/textureSample/3b50bd.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSample/3b50bd.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_arg_1;
 
 
 void textureSample_3b50bd() {
-  vec4 res = texture(arg_0, vec3(0.0f, 0.0f, 0.0f));
+  vec4 res = texture(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f));
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSample/4dd1bf.wgsl.expected.glsl b/test/intrinsics/gen/textureSample/4dd1bf.wgsl.expected.glsl
index 38057f3..9ef770e 100644
--- a/test/intrinsics/gen/textureSample/4dd1bf.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSample/4dd1bf.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureSample_4dd1bf() {
-  vec4 res = texture(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)));
+  vec4 res = texture(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)));
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSample/51b514.wgsl.expected.glsl b/test/intrinsics/gen/textureSample/51b514.wgsl.expected.glsl
index 1251a2c..f55a6ad 100644
--- a/test/intrinsics/gen/textureSample/51b514.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSample/51b514.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSample_51b514() {
-  vec4 res = texture(arg_0, vec2(0.0f, 0.0f));
+  vec4 res = texture(arg_0_arg_1, vec2(0.0f, 0.0f));
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSample/667d76.wgsl.expected.glsl b/test/intrinsics/gen/textureSample/667d76.wgsl.expected.glsl
index a5776ac..8e0be0b 100644
--- a/test/intrinsics/gen/textureSample/667d76.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSample/667d76.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSample_667d76() {
-  float res = textureOffset(arg_0, vec2(0.0f, 0.0f), ivec2(0, 0)).x;
+  float res = textureOffset(arg_0_arg_1, vec2(0.0f, 0.0f), ivec2(0, 0)).x;
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSample/6717ca.wgsl.expected.glsl b/test/intrinsics/gen/textureSample/6717ca.wgsl.expected.glsl
index e73c688..06284d4 100644
--- a/test/intrinsics/gen/textureSample/6717ca.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSample/6717ca.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSample_6717ca() {
-  vec4 res = texture(arg_0, vec3(0.0f, 0.0f, float(1)));
+  vec4 res = texture(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)));
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSample/6e64fb.wgsl.expected.glsl b/test/intrinsics/gen/textureSample/6e64fb.wgsl.expected.glsl
index 9205cfd..0c8a04b 100644
--- a/test/intrinsics/gen/textureSample/6e64fb.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSample/6e64fb.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler1D arg_0;
+uniform highp sampler1D arg_0_arg_1;
 
 
 void textureSample_6e64fb() {
-  vec4 res = texture(arg_0, 1.0f);
+  vec4 res = texture(arg_0_arg_1, 1.0f);
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSample/7c3baa.wgsl.expected.glsl b/test/intrinsics/gen/textureSample/7c3baa.wgsl.expected.glsl
index b75e5db..78556ad 100644
--- a/test/intrinsics/gen/textureSample/7c3baa.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSample/7c3baa.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSample_7c3baa() {
-  vec4 res = textureOffset(arg_0, vec2(0.0f, 0.0f), ivec2(0, 0));
+  vec4 res = textureOffset(arg_0_arg_1, vec2(0.0f, 0.0f), ivec2(0, 0));
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSample/7e9ffd.wgsl.expected.glsl b/test/intrinsics/gen/textureSample/7e9ffd.wgsl.expected.glsl
index 95f9c54..e2e2ddd 100644
--- a/test/intrinsics/gen/textureSample/7e9ffd.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSample/7e9ffd.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSample_7e9ffd() {
-  float res = texture(arg_0, vec3(0.0f, 0.0f, float(1))).x;
+  float res = texture(arg_0_arg_1, vec3(0.0f, 0.0f, float(1))).x;
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSample/8522e7.wgsl.expected.glsl b/test/intrinsics/gen/textureSample/8522e7.wgsl.expected.glsl
index 073841b..116b359 100644
--- a/test/intrinsics/gen/textureSample/8522e7.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSample/8522e7.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSample_8522e7() {
-  float res = textureOffset(arg_0, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0)).x;
+  float res = textureOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0)).x;
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSample/c2f4e8.wgsl.expected.glsl b/test/intrinsics/gen/textureSample/c2f4e8.wgsl.expected.glsl
index 44ec2af..76d4a08 100644
--- a/test/intrinsics/gen/textureSample/c2f4e8.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSample/c2f4e8.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureSample_c2f4e8() {
-  float res = texture(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1))).x;
+  float res = texture(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1))).x;
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSample/e53267.wgsl.expected.glsl b/test/intrinsics/gen/textureSample/e53267.wgsl.expected.glsl
index 5eaee03..acb4c23 100644
--- a/test/intrinsics/gen/textureSample/e53267.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSample/e53267.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureSample_e53267() {
-  vec4 res = texture(arg_0, vec3(0.0f, 0.0f, 0.0f));
+  vec4 res = texture(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f));
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSample/ea7030.wgsl.expected.glsl b/test/intrinsics/gen/textureSample/ea7030.wgsl.expected.glsl
index e8c1b8a..8f10fda 100644
--- a/test/intrinsics/gen/textureSample/ea7030.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSample/ea7030.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureSample_ea7030() {
-  float res = texture(arg_0, vec3(0.0f, 0.0f, 0.0f)).x;
+  float res = texture(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f)).x;
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSampleBias/53b9f7.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleBias/53b9f7.wgsl.expected.glsl
index 2a26fea..326544d 100644
--- a/test/intrinsics/gen/textureSampleBias/53b9f7.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleBias/53b9f7.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureSampleBias_53b9f7() {
-  vec4 res = texture(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f);
+  vec4 res = texture(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f);
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSampleBias/65ac50.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleBias/65ac50.wgsl.expected.glsl
index ccf71c0..923d6d0 100644
--- a/test/intrinsics/gen/textureSampleBias/65ac50.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleBias/65ac50.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleBias_65ac50() {
-  vec4 res = textureOffset(arg_0, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1.0f);
+  vec4 res = textureOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), ivec2(0, 0), 1.0f);
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSampleBias/6a9113.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleBias/6a9113.wgsl.expected.glsl
index dfcb3df..8963a2b 100644
--- a/test/intrinsics/gen/textureSampleBias/6a9113.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleBias/6a9113.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleBias_6a9113() {
-  vec4 res = texture(arg_0, vec2(0.0f, 0.0f), 1.0f);
+  vec4 res = texture(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f);
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSampleBias/80e579.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleBias/80e579.wgsl.expected.glsl
index 77d67e6..0a16afa 100644
--- a/test/intrinsics/gen/textureSampleBias/80e579.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleBias/80e579.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleBias_80e579() {
-  vec4 res = texture(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f);
+  vec4 res = texture(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f);
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSampleBias/81c19a.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleBias/81c19a.wgsl.expected.glsl
index e9eaaf4..7acf4f6 100644
--- a/test/intrinsics/gen/textureSampleBias/81c19a.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleBias/81c19a.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleBias_81c19a() {
-  vec4 res = textureOffset(arg_0, vec2(0.0f, 0.0f), ivec2(0, 0), 1.0f);
+  vec4 res = textureOffset(arg_0_arg_1, vec2(0.0f, 0.0f), ivec2(0, 0), 1.0f);
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSampleBias/d3fa1b.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleBias/d3fa1b.wgsl.expected.glsl
index df9819b..1707cd8 100644
--- a/test/intrinsics/gen/textureSampleBias/d3fa1b.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleBias/d3fa1b.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_arg_1;
 
 
 void textureSampleBias_d3fa1b() {
-  vec4 res = texture(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f);
+  vec4 res = texture(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f);
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSampleBias/df91bb.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleBias/df91bb.wgsl.expected.glsl
index 25c3507..c643170 100644
--- a/test/intrinsics/gen/textureSampleBias/df91bb.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleBias/df91bb.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_arg_1;
 
 
 void textureSampleBias_df91bb() {
-  vec4 res = textureOffset(arg_0, vec3(0.0f, 0.0f, 0.0f), ivec3(0, 0, 0), 1.0f);
+  vec4 res = textureOffset(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), ivec3(0, 0, 0), 1.0f);
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSampleBias/eed7c4.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleBias/eed7c4.wgsl.expected.glsl
index 0cc5ca2..ab89f32 100644
--- a/test/intrinsics/gen/textureSampleBias/eed7c4.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleBias/eed7c4.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureSampleBias_eed7c4() {
-  vec4 res = texture(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
+  vec4 res = texture(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSampleCompare/25fcd1.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleCompare/25fcd1.wgsl.expected.glsl
index 52f9d18..7d60a48 100644
--- a/test/intrinsics/gen/textureSampleCompare/25fcd1.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleCompare/25fcd1.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleCompare_25fcd1() {
-  float res = textureOffset(arg_0, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
+  float res = textureOffset(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSampleCompare/3a5923.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleCompare/3a5923.wgsl.expected.glsl
index ac44077..3afff8b 100644
--- a/test/intrinsics/gen/textureSampleCompare/3a5923.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleCompare/3a5923.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleCompare_3a5923() {
-  float res = texture(arg_0, vec2(0.0f, 0.0f), 1.0f);
+  float res = texture(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f);
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSampleCompare/63fb83.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleCompare/63fb83.wgsl.expected.glsl
index 65767b4..49d1c57 100644
--- a/test/intrinsics/gen/textureSampleCompare/63fb83.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleCompare/63fb83.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureSampleCompare_63fb83() {
-  float res = texture(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f);
+  float res = texture(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f);
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSampleCompare/98b85c.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleCompare/98b85c.wgsl.expected.glsl
index c76e41e..feff3b4 100644
--- a/test/intrinsics/gen/textureSampleCompare/98b85c.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleCompare/98b85c.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleCompare_98b85c() {
-  float res = textureOffset(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
+  float res = textureOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSampleCompare/a3ca7e.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleCompare/a3ca7e.wgsl.expected.glsl
index 19e6bfd..924fac9 100644
--- a/test/intrinsics/gen/textureSampleCompare/a3ca7e.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleCompare/a3ca7e.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureSampleCompare_a3ca7e() {
-  float res = texture(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
+  float res = texture(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSampleCompare/dd431d.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleCompare/dd431d.wgsl.expected.glsl
index d613258..2642223 100644
--- a/test/intrinsics/gen/textureSampleCompare/dd431d.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleCompare/dd431d.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleCompare_dd431d() {
-  float res = texture(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f);
+  float res = texture(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f);
 }
 
 void fragment_main() {
diff --git a/test/intrinsics/gen/textureSampleCompareLevel/011a8f.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleCompareLevel/011a8f.wgsl.expected.glsl
index ac11422..d43ddb0 100644
--- a/test/intrinsics/gen/textureSampleCompareLevel/011a8f.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleCompareLevel/011a8f.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleCompareLevel_011a8f() {
-  float res = textureOffset(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
+  float res = textureOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleCompareLevel_011a8f() {
-  float res = textureOffset(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
+  float res = textureOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleCompareLevel_011a8f() {
-  float res = textureOffset(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
+  float res = textureOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleCompareLevel/1116ed.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleCompareLevel/1116ed.wgsl.expected.glsl
index 8a64730..25be187 100644
--- a/test/intrinsics/gen/textureSampleCompareLevel/1116ed.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleCompareLevel/1116ed.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleCompareLevel_1116ed() {
-  float res = texture(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f);
+  float res = texture(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleCompareLevel_1116ed() {
-  float res = texture(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f);
+  float res = texture(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleCompareLevel_1116ed() {
-  float res = texture(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f);
+  float res = texture(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleCompareLevel/1568e3.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleCompareLevel/1568e3.wgsl.expected.glsl
index d8e177c..683527d 100644
--- a/test/intrinsics/gen/textureSampleCompareLevel/1568e3.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleCompareLevel/1568e3.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureSampleCompareLevel_1568e3() {
-  float res = texture(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f);
+  float res = texture(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureSampleCompareLevel_1568e3() {
-  float res = texture(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f);
+  float res = texture(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureSampleCompareLevel_1568e3() {
-  float res = texture(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f);
+  float res = texture(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleCompareLevel/2ad2b1.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleCompareLevel/2ad2b1.wgsl.expected.glsl
index faaa290..91fc708 100644
--- a/test/intrinsics/gen/textureSampleCompareLevel/2ad2b1.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleCompareLevel/2ad2b1.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleCompareLevel_2ad2b1() {
-  float res = texture(arg_0, vec2(0.0f, 0.0f), 1.0f);
+  float res = texture(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleCompareLevel_2ad2b1() {
-  float res = texture(arg_0, vec2(0.0f, 0.0f), 1.0f);
+  float res = texture(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleCompareLevel_2ad2b1() {
-  float res = texture(arg_0, vec2(0.0f, 0.0f), 1.0f);
+  float res = texture(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleCompareLevel/4cf3a2.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleCompareLevel/4cf3a2.wgsl.expected.glsl
index 9ce58c5..5e33710 100644
--- a/test/intrinsics/gen/textureSampleCompareLevel/4cf3a2.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleCompareLevel/4cf3a2.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureSampleCompareLevel_4cf3a2() {
-  float res = texture(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
+  float res = texture(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureSampleCompareLevel_4cf3a2() {
-  float res = texture(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
+  float res = texture(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureSampleCompareLevel_4cf3a2() {
-  float res = texture(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
+  float res = texture(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleCompareLevel/f8121c.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleCompareLevel/f8121c.wgsl.expected.glsl
index 228b5dd..a869043 100644
--- a/test/intrinsics/gen/textureSampleCompareLevel/f8121c.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleCompareLevel/f8121c.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleCompareLevel_f8121c() {
-  float res = textureOffset(arg_0, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
+  float res = textureOffset(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleCompareLevel_f8121c() {
-  float res = textureOffset(arg_0, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
+  float res = textureOffset(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleCompareLevel_f8121c() {
-  float res = textureOffset(arg_0, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
+  float res = textureOffset(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleGrad/21402b.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleGrad/21402b.wgsl.expected.glsl
index de4d084..41227a4 100644
--- a/test/intrinsics/gen/textureSampleGrad/21402b.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleGrad/21402b.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_arg_1;
 
 
 void textureSampleGrad_21402b() {
-  vec4 res = textureGrad(arg_0, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
+  vec4 res = textureGrad(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_arg_1;
 
 
 void textureSampleGrad_21402b() {
-  vec4 res = textureGrad(arg_0, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
+  vec4 res = textureGrad(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_arg_1;
 
 
 void textureSampleGrad_21402b() {
-  vec4 res = textureGrad(arg_0, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
+  vec4 res = textureGrad(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleGrad/2ecd8f.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleGrad/2ecd8f.wgsl.expected.glsl
index 5193326..e447fd5 100644
--- a/test/intrinsics/gen/textureSampleGrad/2ecd8f.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleGrad/2ecd8f.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleGrad_2ecd8f() {
-  vec4 res = textureGrad(arg_0, vec3(0.0f, 0.0f, float(1)), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f));
+  vec4 res = textureGrad(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleGrad_2ecd8f() {
-  vec4 res = textureGrad(arg_0, vec3(0.0f, 0.0f, float(1)), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f));
+  vec4 res = textureGrad(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleGrad_2ecd8f() {
-  vec4 res = textureGrad(arg_0, vec3(0.0f, 0.0f, float(1)), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f));
+  vec4 res = textureGrad(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleGrad/468f88.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleGrad/468f88.wgsl.expected.glsl
index 1a2c90c..cebae2c 100644
--- a/test/intrinsics/gen/textureSampleGrad/468f88.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleGrad/468f88.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleGrad_468f88() {
-  vec4 res = textureGradOffset(arg_0, vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), ivec2(0, 0));
+  vec4 res = textureGradOffset(arg_0_arg_1, vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleGrad_468f88() {
-  vec4 res = textureGradOffset(arg_0, vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), ivec2(0, 0));
+  vec4 res = textureGradOffset(arg_0_arg_1, vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleGrad_468f88() {
-  vec4 res = textureGradOffset(arg_0, vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), ivec2(0, 0));
+  vec4 res = textureGradOffset(arg_0_arg_1, vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), ivec2(0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleGrad/521263.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleGrad/521263.wgsl.expected.glsl
index 9f76b21..12d0e00 100644
--- a/test/intrinsics/gen/textureSampleGrad/521263.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleGrad/521263.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleGrad_521263() {
-  vec4 res = textureGrad(arg_0, vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f));
+  vec4 res = textureGrad(arg_0_arg_1, vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleGrad_521263() {
-  vec4 res = textureGrad(arg_0, vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f));
+  vec4 res = textureGrad(arg_0_arg_1, vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleGrad_521263() {
-  vec4 res = textureGrad(arg_0, vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f));
+  vec4 res = textureGrad(arg_0_arg_1, vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleGrad/5312f4.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleGrad/5312f4.wgsl.expected.glsl
index e25e7db..7749e1e 100644
--- a/test/intrinsics/gen/textureSampleGrad/5312f4.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleGrad/5312f4.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureSampleGrad_5312f4() {
-  vec4 res = textureGrad(arg_0, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
+  vec4 res = textureGrad(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureSampleGrad_5312f4() {
-  vec4 res = textureGrad(arg_0, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
+  vec4 res = textureGrad(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureSampleGrad_5312f4() {
-  vec4 res = textureGrad(arg_0, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
+  vec4 res = textureGrad(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleGrad/872f00.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleGrad/872f00.wgsl.expected.glsl
index 627e86b..b4f339d 100644
--- a/test/intrinsics/gen/textureSampleGrad/872f00.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleGrad/872f00.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleGrad_872f00() {
-  vec4 res = textureGradOffset(arg_0, vec3(0.0f, 0.0f, float(1)), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), ivec2(0, 0));
+  vec4 res = textureGradOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleGrad_872f00() {
-  vec4 res = textureGradOffset(arg_0, vec3(0.0f, 0.0f, float(1)), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), ivec2(0, 0));
+  vec4 res = textureGradOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleGrad_872f00() {
-  vec4 res = textureGradOffset(arg_0, vec3(0.0f, 0.0f, float(1)), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), ivec2(0, 0));
+  vec4 res = textureGradOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), vec2(0.0f, 0.0f), vec2(0.0f, 0.0f), ivec2(0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleGrad/e383db.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleGrad/e383db.wgsl.expected.glsl
index 1f9fd0e..d6575ff 100644
--- a/test/intrinsics/gen/textureSampleGrad/e383db.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleGrad/e383db.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureSampleGrad_e383db() {
-  vec4 res = textureGrad(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
+  vec4 res = textureGrad(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureSampleGrad_e383db() {
-  vec4 res = textureGrad(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
+  vec4 res = textureGrad(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureSampleGrad_e383db() {
-  vec4 res = textureGrad(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
+  vec4 res = textureGrad(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleGrad/e9a2f7.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleGrad/e9a2f7.wgsl.expected.glsl
index 50c3d24..e5e3eef 100644
--- a/test/intrinsics/gen/textureSampleGrad/e9a2f7.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleGrad/e9a2f7.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_arg_1;
 
 
 void textureSampleGrad_e9a2f7() {
-  vec4 res = textureGradOffset(arg_0, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), ivec3(0, 0, 0));
+  vec4 res = textureGradOffset(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), ivec3(0, 0, 0));
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_arg_1;
 
 
 void textureSampleGrad_e9a2f7() {
-  vec4 res = textureGradOffset(arg_0, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), ivec3(0, 0, 0));
+  vec4 res = textureGradOffset(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), ivec3(0, 0, 0));
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_arg_1;
 
 
 void textureSampleGrad_e9a2f7() {
-  vec4 res = textureGradOffset(arg_0, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), ivec3(0, 0, 0));
+  vec4 res = textureGradOffset(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), ivec3(0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleLevel/02be59.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleLevel/02be59.wgsl.expected.glsl
index 2f99e42..99d6d87 100644
--- a/test/intrinsics/gen/textureSampleLevel/02be59.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleLevel/02be59.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleLevel_02be59() {
-  float res = textureLod(arg_0, vec2(0.0f, 0.0f), 0).x;
+  float res = textureLod(arg_0_arg_1, vec2(0.0f, 0.0f), 0).x;
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleLevel_02be59() {
-  float res = textureLod(arg_0, vec2(0.0f, 0.0f), 0).x;
+  float res = textureLod(arg_0_arg_1, vec2(0.0f, 0.0f), 0).x;
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleLevel_02be59() {
-  float res = textureLod(arg_0, vec2(0.0f, 0.0f), 0).x;
+  float res = textureLod(arg_0_arg_1, vec2(0.0f, 0.0f), 0).x;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleLevel/0bdd9a.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleLevel/0bdd9a.wgsl.expected.glsl
index e386347..703a317 100644
--- a/test/intrinsics/gen/textureSampleLevel/0bdd9a.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleLevel/0bdd9a.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureSampleLevel_0bdd9a() {
-  vec4 res = textureLod(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureSampleLevel_0bdd9a() {
-  vec4 res = textureLod(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureSampleLevel_0bdd9a() {
-  vec4 res = textureLod(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleLevel/1b0291.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleLevel/1b0291.wgsl.expected.glsl
index 47b1c7a..2b34745 100644
--- a/test/intrinsics/gen/textureSampleLevel/1b0291.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleLevel/1b0291.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureSampleLevel_1b0291() {
-  float res = textureLod(arg_0, vec3(0.0f, 0.0f, 0.0f), 0).x;
+  float res = textureLod(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 0).x;
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureSampleLevel_1b0291() {
-  float res = textureLod(arg_0, vec3(0.0f, 0.0f, 0.0f), 0).x;
+  float res = textureLod(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 0).x;
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureSampleLevel_1b0291() {
-  float res = textureLod(arg_0, vec3(0.0f, 0.0f, 0.0f), 0).x;
+  float res = textureLod(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 0).x;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleLevel/1bf73e.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleLevel/1bf73e.wgsl.expected.glsl
index a7334dc..bd90c62 100644
--- a/test/intrinsics/gen/textureSampleLevel/1bf73e.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleLevel/1bf73e.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleLevel_1bf73e() {
-  float res = textureLod(arg_0, vec3(0.0f, 0.0f, float(1)), 0).x;
+  float res = textureLod(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 0).x;
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleLevel_1bf73e() {
-  float res = textureLod(arg_0, vec3(0.0f, 0.0f, float(1)), 0).x;
+  float res = textureLod(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 0).x;
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleLevel_1bf73e() {
-  float res = textureLod(arg_0, vec3(0.0f, 0.0f, float(1)), 0).x;
+  float res = textureLod(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 0).x;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleLevel/302be4.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleLevel/302be4.wgsl.expected.glsl
index ed4cb3f..a66ae27 100644
--- a/test/intrinsics/gen/textureSampleLevel/302be4.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleLevel/302be4.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleLevel_302be4() {
-  vec4 res = textureLod(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleLevel_302be4() {
-  vec4 res = textureLod(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleLevel_302be4() {
-  vec4 res = textureLod(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleLevel/47daa4.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleLevel/47daa4.wgsl.expected.glsl
index 1ab5521..6c6a30c 100644
--- a/test/intrinsics/gen/textureSampleLevel/47daa4.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleLevel/47daa4.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleLevel_47daa4() {
-  float res = textureLodOffset(arg_0, vec2(0.0f, 0.0f), 0, ivec2(0, 0)).x;
+  float res = textureLodOffset(arg_0_arg_1, vec2(0.0f, 0.0f), 0, ivec2(0, 0)).x;
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleLevel_47daa4() {
-  float res = textureLodOffset(arg_0, vec2(0.0f, 0.0f), 0, ivec2(0, 0)).x;
+  float res = textureLodOffset(arg_0_arg_1, vec2(0.0f, 0.0f), 0, ivec2(0, 0)).x;
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleLevel_47daa4() {
-  float res = textureLodOffset(arg_0, vec2(0.0f, 0.0f), 0, ivec2(0, 0)).x;
+  float res = textureLodOffset(arg_0_arg_1, vec2(0.0f, 0.0f), 0, ivec2(0, 0)).x;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleLevel/690d95.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleLevel/690d95.wgsl.expected.glsl
index 8d561bb..e12972c 100644
--- a/test/intrinsics/gen/textureSampleLevel/690d95.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleLevel/690d95.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleLevel_690d95() {
-  vec4 res = textureLodOffset(arg_0, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
+  vec4 res = textureLodOffset(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleLevel_690d95() {
-  vec4 res = textureLodOffset(arg_0, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
+  vec4 res = textureLodOffset(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleLevel_690d95() {
-  vec4 res = textureLodOffset(arg_0, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
+  vec4 res = textureLodOffset(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleLevel/979816.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleLevel/979816.wgsl.expected.glsl
index 606f345..70dd619 100644
--- a/test/intrinsics/gen/textureSampleLevel/979816.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleLevel/979816.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleLevel_979816() {
-  vec4 res = textureLod(arg_0, vec2(0.0f, 0.0f), 0.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec2(0.0f, 0.0f), 0.0f);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleLevel_979816() {
-  vec4 res = textureLod(arg_0, vec2(0.0f, 0.0f), 0.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec2(0.0f, 0.0f), 0.0f);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleLevel_979816() {
-  vec4 res = textureLod(arg_0, vec2(0.0f, 0.0f), 0.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec2(0.0f, 0.0f), 0.0f);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleLevel/9bd37b.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleLevel/9bd37b.wgsl.expected.glsl
index 9efead9..4054927 100644
--- a/test/intrinsics/gen/textureSampleLevel/9bd37b.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleLevel/9bd37b.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_arg_1;
 
 
 void textureSampleLevel_9bd37b() {
-  vec4 res = textureLodOffset(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f, ivec3(0, 0, 0));
+  vec4 res = textureLodOffset(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f, ivec3(0, 0, 0));
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_arg_1;
 
 
 void textureSampleLevel_9bd37b() {
-  vec4 res = textureLodOffset(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f, ivec3(0, 0, 0));
+  vec4 res = textureLodOffset(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f, ivec3(0, 0, 0));
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_arg_1;
 
 
 void textureSampleLevel_9bd37b() {
-  vec4 res = textureLodOffset(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f, ivec3(0, 0, 0));
+  vec4 res = textureLodOffset(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f, ivec3(0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleLevel/a4af26.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleLevel/a4af26.wgsl.expected.glsl
index 59142f3..ece5be1 100644
--- a/test/intrinsics/gen/textureSampleLevel/a4af26.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleLevel/a4af26.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleLevel_a4af26() {
-  vec4 res = textureLodOffset(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
+  vec4 res = textureLodOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleLevel_a4af26() {
-  vec4 res = textureLodOffset(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
+  vec4 res = textureLodOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleLevel_a4af26() {
-  vec4 res = textureLodOffset(arg_0, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
+  vec4 res = textureLodOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 1.0f, ivec2(0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleLevel/abfcc0.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleLevel/abfcc0.wgsl.expected.glsl
index 446ff45..66ef007 100644
--- a/test/intrinsics/gen/textureSampleLevel/abfcc0.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleLevel/abfcc0.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_arg_1;
 
 
 void textureSampleLevel_abfcc0() {
-  vec4 res = textureLod(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_arg_1;
 
 
 void textureSampleLevel_abfcc0() {
-  vec4 res = textureLod(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D arg_0;
+uniform highp sampler3D arg_0_arg_1;
 
 
 void textureSampleLevel_abfcc0() {
-  vec4 res = textureLod(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleLevel/ae5e39.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleLevel/ae5e39.wgsl.expected.glsl
index ed66944..91c547a 100644
--- a/test/intrinsics/gen/textureSampleLevel/ae5e39.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleLevel/ae5e39.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureSampleLevel_ae5e39() {
-  float res = textureLod(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)), 0).x;
+  float res = textureLod(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 0).x;
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureSampleLevel_ae5e39() {
-  float res = textureLod(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)), 0).x;
+  float res = textureLod(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 0).x;
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray arg_0;
+uniform highp samplerCubeArray arg_0_arg_1;
 
 
 void textureSampleLevel_ae5e39() {
-  float res = textureLod(arg_0, vec4(0.0f, 0.0f, 0.0f, float(1)), 0).x;
+  float res = textureLod(arg_0_arg_1, vec4(0.0f, 0.0f, 0.0f, float(1)), 0).x;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleLevel/ba93b3.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleLevel/ba93b3.wgsl.expected.glsl
index 72dc47a..0c0ac10 100644
--- a/test/intrinsics/gen/textureSampleLevel/ba93b3.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleLevel/ba93b3.wgsl.expected.glsl
@@ -3,11 +3,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleLevel_ba93b3() {
-  float res = textureLodOffset(arg_0, vec3(0.0f, 0.0f, float(1)), 0, ivec2(0, 0)).x;
+  float res = textureLodOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 0, ivec2(0, 0)).x;
 }
 
 struct tint_symbol {
@@ -43,11 +43,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleLevel_ba93b3() {
-  float res = textureLodOffset(arg_0, vec3(0.0f, 0.0f, float(1)), 0, ivec2(0, 0)).x;
+  float res = textureLodOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 0, ivec2(0, 0)).x;
 }
 
 struct tint_symbol {
@@ -73,11 +73,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray arg_0;
+uniform highp sampler2DArray arg_0_arg_1;
 
 
 void textureSampleLevel_ba93b3() {
-  float res = textureLodOffset(arg_0, vec3(0.0f, 0.0f, float(1)), 0, ivec2(0, 0)).x;
+  float res = textureLodOffset(arg_0_arg_1, vec3(0.0f, 0.0f, float(1)), 0, ivec2(0, 0)).x;
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleLevel/c32df7.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleLevel/c32df7.wgsl.expected.glsl
index 538222d..c11197e 100644
--- a/test/intrinsics/gen/textureSampleLevel/c32df7.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleLevel/c32df7.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureSampleLevel_c32df7() {
-  vec4 res = textureLod(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureSampleLevel_c32df7() {
-  vec4 res = textureLod(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube arg_0;
+uniform highp samplerCube arg_0_arg_1;
 
 
 void textureSampleLevel_c32df7() {
-  vec4 res = textureLod(arg_0, vec3(0.0f, 0.0f, 0.0f), 1.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec3(0.0f, 0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureSampleLevel/c6aca6.wgsl.expected.glsl b/test/intrinsics/gen/textureSampleLevel/c6aca6.wgsl.expected.glsl
index 7f18f4d..56c4d64 100644
--- a/test/intrinsics/gen/textureSampleLevel/c6aca6.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureSampleLevel/c6aca6.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleLevel_c6aca6() {
-  vec4 res = textureLod(arg_0, vec2(0.0f, 0.0f), 1.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
@@ -34,11 +34,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleLevel_c6aca6() {
-  vec4 res = textureLod(arg_0, vec2(0.0f, 0.0f), 1.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
@@ -57,11 +57,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D arg_0;
+uniform highp sampler2D arg_0_arg_1;
 
 
 void textureSampleLevel_c6aca6() {
-  vec4 res = textureLod(arg_0, vec2(0.0f, 0.0f), 1.0f);
+  vec4 res = textureLod(arg_0_arg_1, vec2(0.0f, 0.0f), 1.0f);
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/05ce15.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/05ce15.wgsl.expected.glsl
index e6c280f..5bfbd5a 100644
--- a/test/intrinsics/gen/textureStore/05ce15.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/05ce15.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_05ce15() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_05ce15() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_05ce15() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/064c7f.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/064c7f.wgsl.expected.glsl
index 855a781..899d9ae 100644
--- a/test/intrinsics/gen/textureStore/064c7f.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/064c7f.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_064c7f() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_064c7f() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_064c7f() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/068641.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/068641.wgsl.expected.glsl
index f85a42f..3bc576d 100644
--- a/test/intrinsics/gen/textureStore/068641.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/068641.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureStore_068641() {
-  imageStore(arg_0, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureStore_068641() {
-  imageStore(arg_0, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureStore_068641() {
-  imageStore(arg_0, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/0af6b5.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/0af6b5.wgsl.expected.glsl
index ba01e20..10d2103 100644
--- a/test/intrinsics/gen/textureStore/0af6b5.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/0af6b5.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_0af6b5() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_0af6b5() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_0af6b5() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/0c3dff.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/0c3dff.wgsl.expected.glsl
index 4dd1937..38d3bf3 100644
--- a/test/intrinsics/gen/textureStore/0c3dff.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/0c3dff.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureStore_0c3dff() {
-  imageStore(arg_0, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureStore_0c3dff() {
-  imageStore(arg_0, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureStore_0c3dff() {
-  imageStore(arg_0, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/102722.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/102722.wgsl.expected.glsl
index 702ebf0..f80e662 100644
--- a/test/intrinsics/gen/textureStore/102722.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/102722.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureStore_102722() {
-  imageStore(arg_0, 1, uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, 1, uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureStore_102722() {
-  imageStore(arg_0, 1, uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, 1, uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureStore_102722() {
-  imageStore(arg_0, 1, uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, 1, uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/1bbd08.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/1bbd08.wgsl.expected.glsl
index 4921de7..9e86acc 100644
--- a/test/intrinsics/gen/textureStore/1bbd08.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/1bbd08.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_1bbd08() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_1bbd08() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_1bbd08() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/1c02e7.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/1c02e7.wgsl.expected.glsl
index 9405cf6..03a0d54 100644
--- a/test/intrinsics/gen/textureStore/1c02e7.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/1c02e7.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureStore_1c02e7() {
-  imageStore(arg_0, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureStore_1c02e7() {
-  imageStore(arg_0, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureStore_1c02e7() {
-  imageStore(arg_0, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/22d955.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/22d955.wgsl.expected.glsl
index 67110e6..4c3d0f4 100644
--- a/test/intrinsics/gen/textureStore/22d955.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/22d955.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureStore_22d955() {
-  imageStore(arg_0, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureStore_22d955() {
-  imageStore(arg_0, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureStore_22d955() {
-  imageStore(arg_0, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/26bf70.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/26bf70.wgsl.expected.glsl
index d958404..bb9a34a 100644
--- a/test/intrinsics/gen/textureStore/26bf70.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/26bf70.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureStore_26bf70() {
-  imageStore(arg_0, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureStore_26bf70() {
-  imageStore(arg_0, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureStore_26bf70() {
-  imageStore(arg_0, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/2796b4.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/2796b4.wgsl.expected.glsl
index 3bdbf59..9f508c4 100644
--- a/test/intrinsics/gen/textureStore/2796b4.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/2796b4.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureStore_2796b4() {
-  imageStore(arg_0, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureStore_2796b4() {
-  imageStore(arg_0, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureStore_2796b4() {
-  imageStore(arg_0, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/2ac6c7.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/2ac6c7.wgsl.expected.glsl
index 36b0c9c..2e783a8 100644
--- a/test/intrinsics/gen/textureStore/2ac6c7.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/2ac6c7.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_2ac6c7() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_2ac6c7() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_2ac6c7() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/2eb2a4.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/2eb2a4.wgsl.expected.glsl
index 98615c4..23b22b7 100644
--- a/test/intrinsics/gen/textureStore/2eb2a4.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/2eb2a4.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureStore_2eb2a4() {
-  imageStore(arg_0, 1, uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, 1, uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureStore_2eb2a4() {
-  imageStore(arg_0, 1, uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, 1, uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureStore_2eb2a4() {
-  imageStore(arg_0, 1, uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, 1, uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/2ed2a3.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/2ed2a3.wgsl.expected.glsl
index 9fdd038..67cb104 100644
--- a/test/intrinsics/gen/textureStore/2ed2a3.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/2ed2a3.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_2ed2a3() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_2ed2a3() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_2ed2a3() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/31745b.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/31745b.wgsl.expected.glsl
index d0b5b4b..0aa0ee9 100644
--- a/test/intrinsics/gen/textureStore/31745b.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/31745b.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureStore_31745b() {
-  imageStore(arg_0, ivec2(0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec2(0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureStore_31745b() {
-  imageStore(arg_0, ivec2(0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec2(0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureStore_31745b() {
-  imageStore(arg_0, ivec2(0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec2(0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/32f368.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/32f368.wgsl.expected.glsl
index b98026b..301de1e 100644
--- a/test/intrinsics/gen/textureStore/32f368.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/32f368.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_32f368() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_32f368() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_32f368() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/331aee.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/331aee.wgsl.expected.glsl
index 37a747f..ed5638d 100644
--- a/test/intrinsics/gen/textureStore/331aee.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/331aee.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_331aee() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_331aee() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_331aee() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/38e8d7.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/38e8d7.wgsl.expected.glsl
index a5590b5..ba1892a 100644
--- a/test/intrinsics/gen/textureStore/38e8d7.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/38e8d7.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureStore_38e8d7() {
-  imageStore(arg_0, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureStore_38e8d7() {
-  imageStore(arg_0, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureStore_38e8d7() {
-  imageStore(arg_0, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/3a52ac.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/3a52ac.wgsl.expected.glsl
index 9f1195f..096e97e 100644
--- a/test/intrinsics/gen/textureStore/3a52ac.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/3a52ac.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureStore_3a52ac() {
-  imageStore(arg_0, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureStore_3a52ac() {
-  imageStore(arg_0, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureStore_3a52ac() {
-  imageStore(arg_0, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/3bb7a1.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/3bb7a1.wgsl.expected.glsl
index 58922a1..bfd8d20 100644
--- a/test/intrinsics/gen/textureStore/3bb7a1.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/3bb7a1.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_3bb7a1() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_3bb7a1() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_3bb7a1() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/3bec15.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/3bec15.wgsl.expected.glsl
index c70bf98..3d4a533 100644
--- a/test/intrinsics/gen/textureStore/3bec15.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/3bec15.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureStore_3bec15() {
-  imageStore(arg_0, 1, uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, 1, uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureStore_3bec15() {
-  imageStore(arg_0, 1, uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, 1, uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureStore_3bec15() {
-  imageStore(arg_0, 1, uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, 1, uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/441ba8.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/441ba8.wgsl.expected.glsl
index 73726f3..eb5dba4 100644
--- a/test/intrinsics/gen/textureStore/441ba8.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/441ba8.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureStore_441ba8() {
-  imageStore(arg_0, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureStore_441ba8() {
-  imageStore(arg_0, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureStore_441ba8() {
-  imageStore(arg_0, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/4fc057.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/4fc057.wgsl.expected.glsl
index a76727c..1e09510 100644
--- a/test/intrinsics/gen/textureStore/4fc057.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/4fc057.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_4fc057() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_4fc057() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_4fc057() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/5a2f8f.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/5a2f8f.wgsl.expected.glsl
index af0a2c9..ff0494c 100644
--- a/test/intrinsics/gen/textureStore/5a2f8f.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/5a2f8f.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureStore_5a2f8f() {
-  imageStore(arg_0, 1, ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, 1, ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureStore_5a2f8f() {
-  imageStore(arg_0, 1, ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, 1, ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureStore_5a2f8f() {
-  imageStore(arg_0, 1, ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, 1, ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/60975f.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/60975f.wgsl.expected.glsl
index a07aa45..29940ba 100644
--- a/test/intrinsics/gen/textureStore/60975f.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/60975f.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_60975f() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_60975f() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_60975f() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/682fd6.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/682fd6.wgsl.expected.glsl
index 3f28a46..18fa4c4 100644
--- a/test/intrinsics/gen/textureStore/682fd6.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/682fd6.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureStore_682fd6() {
-  imageStore(arg_0, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureStore_682fd6() {
-  imageStore(arg_0, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureStore_682fd6() {
-  imageStore(arg_0, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/6b75c3.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/6b75c3.wgsl.expected.glsl
index 1c01bd6..3ee2e11 100644
--- a/test/intrinsics/gen/textureStore/6b75c3.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/6b75c3.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_6b75c3() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_6b75c3() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_6b75c3() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/6b80d2.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/6b80d2.wgsl.expected.glsl
index 673dc80..83d62c9 100644
--- a/test/intrinsics/gen/textureStore/6b80d2.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/6b80d2.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureStore_6b80d2() {
-  imageStore(arg_0, 1, ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, 1, ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureStore_6b80d2() {
-  imageStore(arg_0, 1, ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, 1, ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureStore_6b80d2() {
-  imageStore(arg_0, 1, ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, 1, ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/6cff2e.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/6cff2e.wgsl.expected.glsl
index 6df0230..d97f571 100644
--- a/test/intrinsics/gen/textureStore/6cff2e.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/6cff2e.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureStore_6cff2e() {
-  imageStore(arg_0, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureStore_6cff2e() {
-  imageStore(arg_0, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureStore_6cff2e() {
-  imageStore(arg_0, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/6da692.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/6da692.wgsl.expected.glsl
index a9230b0..6c3ab0b 100644
--- a/test/intrinsics/gen/textureStore/6da692.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/6da692.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureStore_6da692() {
-  imageStore(arg_0, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureStore_6da692() {
-  imageStore(arg_0, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureStore_6da692() {
-  imageStore(arg_0, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/731349.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/731349.wgsl.expected.glsl
index e2a352f..e44e117 100644
--- a/test/intrinsics/gen/textureStore/731349.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/731349.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_731349() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_731349() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_731349() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/752da6.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/752da6.wgsl.expected.glsl
index 544b0dc..ea0ad5a 100644
--- a/test/intrinsics/gen/textureStore/752da6.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/752da6.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureStore_752da6() {
-  imageStore(arg_0, ivec2(0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec2(0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureStore_752da6() {
-  imageStore(arg_0, ivec2(0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec2(0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureStore_752da6() {
-  imageStore(arg_0, ivec2(0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec2(0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/77c0ae.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/77c0ae.wgsl.expected.glsl
index 7e82124..7831765 100644
--- a/test/intrinsics/gen/textureStore/77c0ae.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/77c0ae.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureStore_77c0ae() {
-  imageStore(arg_0, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureStore_77c0ae() {
-  imageStore(arg_0, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2D arg_0;
+uniform highp writeonly uimage2D arg_0_1;
 
 void textureStore_77c0ae() {
-  imageStore(arg_0, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec2(0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/7cec8d.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/7cec8d.wgsl.expected.glsl
index 0ee1f4f..36cd1e3 100644
--- a/test/intrinsics/gen/textureStore/7cec8d.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/7cec8d.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureStore_7cec8d() {
-  imageStore(arg_0, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureStore_7cec8d() {
-  imageStore(arg_0, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureStore_7cec8d() {
-  imageStore(arg_0, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/7f7fae.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/7f7fae.wgsl.expected.glsl
index 5bb7ae0..a4db5c8 100644
--- a/test/intrinsics/gen/textureStore/7f7fae.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/7f7fae.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_7f7fae() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_7f7fae() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_7f7fae() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/804942.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/804942.wgsl.expected.glsl
index 2128124..9a7cdc4 100644
--- a/test/intrinsics/gen/textureStore/804942.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/804942.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureStore_804942() {
-  imageStore(arg_0, ivec2(0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec2(0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureStore_804942() {
-  imageStore(arg_0, ivec2(0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec2(0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureStore_804942() {
-  imageStore(arg_0, ivec2(0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec2(0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/805dae.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/805dae.wgsl.expected.glsl
index 3bcdd06..dc6358d 100644
--- a/test/intrinsics/gen/textureStore/805dae.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/805dae.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_805dae() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_805dae() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_805dae() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/83bcc1.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/83bcc1.wgsl.expected.glsl
index f1b7efa..39eff32 100644
--- a/test/intrinsics/gen/textureStore/83bcc1.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/83bcc1.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureStore_83bcc1() {
-  imageStore(arg_0, 1, uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, 1, uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureStore_83bcc1() {
-  imageStore(arg_0, 1, uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, 1, uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureStore_83bcc1() {
-  imageStore(arg_0, 1, uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, 1, uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/872747.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/872747.wgsl.expected.glsl
index c873a26..3bfd86a 100644
--- a/test/intrinsics/gen/textureStore/872747.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/872747.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_872747() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_872747() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_872747() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/8e0479.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/8e0479.wgsl.expected.glsl
index 9b6251a..355bf61 100644
--- a/test/intrinsics/gen/textureStore/8e0479.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/8e0479.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureStore_8e0479() {
-  imageStore(arg_0, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureStore_8e0479() {
-  imageStore(arg_0, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureStore_8e0479() {
-  imageStore(arg_0, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/8f71a1.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/8f71a1.wgsl.expected.glsl
index 28b3323..643f526 100644
--- a/test/intrinsics/gen/textureStore/8f71a1.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/8f71a1.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureStore_8f71a1() {
-  imageStore(arg_0, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureStore_8f71a1() {
-  imageStore(arg_0, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureStore_8f71a1() {
-  imageStore(arg_0, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/969534.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/969534.wgsl.expected.glsl
index ed57dd5..d0858ac 100644
--- a/test/intrinsics/gen/textureStore/969534.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/969534.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureStore_969534() {
-  imageStore(arg_0, 1, ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, 1, ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureStore_969534() {
-  imageStore(arg_0, 1, ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, 1, ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureStore_969534() {
-  imageStore(arg_0, 1, ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, 1, ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/9a3ecc.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/9a3ecc.wgsl.expected.glsl
index 91b696b..968517c 100644
--- a/test/intrinsics/gen/textureStore/9a3ecc.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/9a3ecc.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureStore_9a3ecc() {
-  imageStore(arg_0, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureStore_9a3ecc() {
-  imageStore(arg_0, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureStore_9a3ecc() {
-  imageStore(arg_0, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/9d9cd5.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/9d9cd5.wgsl.expected.glsl
index 4ed6d37..0295297 100644
--- a/test/intrinsics/gen/textureStore/9d9cd5.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/9d9cd5.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_9d9cd5() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_9d9cd5() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_9d9cd5() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/9e3ec5.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/9e3ec5.wgsl.expected.glsl
index 908f989..2ddff6c 100644
--- a/test/intrinsics/gen/textureStore/9e3ec5.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/9e3ec5.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureStore_9e3ec5() {
-  imageStore(arg_0, ivec2(0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec2(0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureStore_9e3ec5() {
-  imageStore(arg_0, ivec2(0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec2(0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureStore_9e3ec5() {
-  imageStore(arg_0, ivec2(0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec2(0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/ac67aa.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/ac67aa.wgsl.expected.glsl
index 0c8095c..a822d0e 100644
--- a/test/intrinsics/gen/textureStore/ac67aa.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/ac67aa.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureStore_ac67aa() {
-  imageStore(arg_0, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureStore_ac67aa() {
-  imageStore(arg_0, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureStore_ac67aa() {
-  imageStore(arg_0, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/b706b1.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/b706b1.wgsl.expected.glsl
index 650e715..fd83a70 100644
--- a/test/intrinsics/gen/textureStore/b706b1.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/b706b1.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureStore_b706b1() {
-  imageStore(arg_0, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureStore_b706b1() {
-  imageStore(arg_0, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureStore_b706b1() {
-  imageStore(arg_0, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/bbcb7f.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/bbcb7f.wgsl.expected.glsl
index 0bbca2b..d4a040a 100644
--- a/test/intrinsics/gen/textureStore/bbcb7f.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/bbcb7f.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureStore_bbcb7f() {
-  imageStore(arg_0, ivec2(0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec2(0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureStore_bbcb7f() {
-  imageStore(arg_0, ivec2(0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec2(0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2D arg_0;
+uniform highp writeonly iimage2D arg_0_1;
 
 void textureStore_bbcb7f() {
-  imageStore(arg_0, ivec2(0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec2(0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/be6e30.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/be6e30.wgsl.expected.glsl
index 3b1b5a4..be19406 100644
--- a/test/intrinsics/gen/textureStore/be6e30.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/be6e30.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_be6e30() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_be6e30() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D arg_0;
+uniform highp writeonly image2D arg_0_1;
 
 void textureStore_be6e30() {
-  imageStore(arg_0, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec2(0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/bf775c.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/bf775c.wgsl.expected.glsl
index 1324c36..2a45055 100644
--- a/test/intrinsics/gen/textureStore/bf775c.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/bf775c.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureStore_bf775c() {
-  imageStore(arg_0, 1, ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, 1, ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureStore_bf775c() {
-  imageStore(arg_0, 1, ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, 1, ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureStore_bf775c() {
-  imageStore(arg_0, 1, ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, 1, ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/c5af1e.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/c5af1e.wgsl.expected.glsl
index 9a3f2d0..3e8be5f 100644
--- a/test/intrinsics/gen/textureStore/c5af1e.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/c5af1e.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_c5af1e() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_c5af1e() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_c5af1e() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/c863be.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/c863be.wgsl.expected.glsl
index 351fecf..2a7f17a 100644
--- a/test/intrinsics/gen/textureStore/c863be.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/c863be.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_c863be() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_c863be() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray arg_0;
+uniform highp writeonly image2DArray arg_0_1;
 
 void textureStore_c863be() {
-  imageStore(arg_0, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 1), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/d73b5c.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/d73b5c.wgsl.expected.glsl
index 2c696c0..571a322 100644
--- a/test/intrinsics/gen/textureStore/d73b5c.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/d73b5c.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureStore_d73b5c() {
-  imageStore(arg_0, 1, ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, 1, ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureStore_d73b5c() {
-  imageStore(arg_0, 1, ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, 1, ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage1D arg_0;
+uniform highp writeonly iimage1D arg_0_1;
 
 void textureStore_d73b5c() {
-  imageStore(arg_0, 1, ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, 1, ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/dd7d81.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/dd7d81.wgsl.expected.glsl
index a8d92c3..b4b7f1d 100644
--- a/test/intrinsics/gen/textureStore/dd7d81.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/dd7d81.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_dd7d81() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_dd7d81() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_dd7d81() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/dde364.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/dde364.wgsl.expected.glsl
index 2c5aa6d..34d7d8d 100644
--- a/test/intrinsics/gen/textureStore/dde364.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/dde364.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureStore_dde364() {
-  imageStore(arg_0, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureStore_dde364() {
-  imageStore(arg_0, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage2DArray arg_0;
+uniform highp writeonly uimage2DArray arg_0_1;
 
 void textureStore_dde364() {
-  imageStore(arg_0, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 1), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/e885e8.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/e885e8.wgsl.expected.glsl
index 5db7f80..4411bc3 100644
--- a/test/intrinsics/gen/textureStore/e885e8.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/e885e8.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_e885e8() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_e885e8() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D arg_0;
+uniform highp writeonly image1D arg_0_1;
 
 void textureStore_e885e8() {
-  imageStore(arg_0, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, 1, vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/eb702f.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/eb702f.wgsl.expected.glsl
index fd4dfb3..77f4135 100644
--- a/test/intrinsics/gen/textureStore/eb702f.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/eb702f.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_eb702f() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_eb702f() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_eb702f() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/eb78b9.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/eb78b9.wgsl.expected.glsl
index 5cdcf91..dbbe8cb 100644
--- a/test/intrinsics/gen/textureStore/eb78b9.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/eb78b9.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureStore_eb78b9() {
-  imageStore(arg_0, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureStore_eb78b9() {
-  imageStore(arg_0, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage3D arg_0;
+uniform highp writeonly iimage3D arg_0_1;
 
 void textureStore_eb78b9() {
-  imageStore(arg_0, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 0), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/ee6acc.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/ee6acc.wgsl.expected.glsl
index 9c8618b..47ba299 100644
--- a/test/intrinsics/gen/textureStore/ee6acc.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/ee6acc.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_ee6acc() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_ee6acc() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D arg_0;
+uniform highp writeonly image3D arg_0_1;
 
 void textureStore_ee6acc() {
-  imageStore(arg_0, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  imageStore(arg_0_1, ivec3(0, 0, 0), vec4(0.0f, 0.0f, 0.0f, 0.0f));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/ef9f2f.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/ef9f2f.wgsl.expected.glsl
index caab228..1e51fe5 100644
--- a/test/intrinsics/gen/textureStore/ef9f2f.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/ef9f2f.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureStore_ef9f2f() {
-  imageStore(arg_0, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureStore_ef9f2f() {
-  imageStore(arg_0, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureStore_ef9f2f() {
-  imageStore(arg_0, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/f8dead.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/f8dead.wgsl.expected.glsl
index 3aae373..09fd259 100644
--- a/test/intrinsics/gen/textureStore/f8dead.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/f8dead.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureStore_f8dead() {
-  imageStore(arg_0, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureStore_f8dead() {
-  imageStore(arg_0, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage3D arg_0;
+uniform highp writeonly uimage3D arg_0_1;
 
 void textureStore_f8dead() {
-  imageStore(arg_0, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, ivec3(0, 0, 0), uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/f9be83.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/f9be83.wgsl.expected.glsl
index cfe8a94..b02da21 100644
--- a/test/intrinsics/gen/textureStore/f9be83.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/f9be83.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureStore_f9be83() {
-  imageStore(arg_0, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureStore_f9be83() {
-  imageStore(arg_0, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureStore_f9be83() {
-  imageStore(arg_0, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/fb9a8f.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/fb9a8f.wgsl.expected.glsl
index 8225121..882c4ee 100644
--- a/test/intrinsics/gen/textureStore/fb9a8f.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/fb9a8f.wgsl.expected.glsl
@@ -3,10 +3,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureStore_fb9a8f() {
-  imageStore(arg_0, 1, uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, 1, uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -42,10 +42,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureStore_fb9a8f() {
-  imageStore(arg_0, 1, uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, 1, uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
@@ -71,10 +71,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly uimage1D arg_0;
+uniform highp writeonly uimage1D arg_0_1;
 
 void textureStore_fb9a8f() {
-  imageStore(arg_0, 1, uvec4(0u, 0u, 0u, 0u));
+  imageStore(arg_0_1, 1, uvec4(0u, 0u, 0u, 0u));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/gen/textureStore/fbf53f.wgsl.expected.glsl b/test/intrinsics/gen/textureStore/fbf53f.wgsl.expected.glsl
index 3a08d14..7e08398 100644
--- a/test/intrinsics/gen/textureStore/fbf53f.wgsl.expected.glsl
+++ b/test/intrinsics/gen/textureStore/fbf53f.wgsl.expected.glsl
@@ -1,10 +1,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureStore_fbf53f() {
-  imageStore(arg_0, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -33,10 +33,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureStore_fbf53f() {
-  imageStore(arg_0, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
@@ -55,10 +55,10 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly iimage2DArray arg_0;
+uniform highp writeonly iimage2DArray arg_0_1;
 
 void textureStore_fbf53f() {
-  imageStore(arg_0, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
+  imageStore(arg_0_1, ivec3(0, 0, 1), ivec4(0, 0, 0, 0));
 }
 
 struct tint_symbol {
diff --git a/test/intrinsics/textureDimensions/depth_ms.spvasm.expected.glsl b/test/intrinsics/textureDimensions/depth_ms.spvasm.expected.glsl
index 490cd99..bdab771 100644
--- a/test/intrinsics/textureDimensions/depth_ms.spvasm.expected.glsl
+++ b/test/intrinsics/textureDimensions/depth_ms.spvasm.expected.glsl
@@ -1,12 +1,12 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
 vec4 tint_symbol_1 = vec4(0.0f, 0.0f, 0.0f, 0.0f);
+uniform highp sampler2DMS arg_0_1;
 
 void textureDimensions_f60bdb() {
   ivec2 res = ivec2(0, 0);
-  ivec2 x_16 = ivec2(textureSize(arg_0));
+  ivec2 x_16 = ivec2(textureSize(arg_0_1));
   res = x_16;
   return;
 }
@@ -52,11 +52,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureDimensions_f60bdb() {
   ivec2 res = ivec2(0, 0);
-  ivec2 x_16 = ivec2(textureSize(arg_0));
+  ivec2 x_16 = ivec2(textureSize(arg_0_1));
   res = x_16;
   return;
 }
@@ -85,11 +85,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureDimensions_f60bdb() {
   ivec2 res = ivec2(0, 0);
-  ivec2 x_16 = ivec2(textureSize(arg_0));
+  ivec2 x_16 = ivec2(textureSize(arg_0_1));
   res = x_16;
   return;
 }
diff --git a/test/intrinsics/textureGather/f32/alpha.wgsl.expected.glsl b/test/intrinsics/textureGather/f32/alpha.wgsl.expected.glsl
index ff11b75..d66b162 100644
--- a/test/intrinsics/textureGather/f32/alpha.wgsl.expected.glsl
+++ b/test/intrinsics/textureGather/f32/alpha.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D t;
+uniform highp sampler2D t_s;
 
 
 void tint_symbol() {
-  vec4 res = textureGather(t, vec2(0.0f, 0.0f), 3);
+  vec4 res = textureGather(t_s, vec2(0.0f, 0.0f), 3);
   return;
 }
 void main() {
diff --git a/test/intrinsics/textureGather/f32/blue.wgsl.expected.glsl b/test/intrinsics/textureGather/f32/blue.wgsl.expected.glsl
index 3ff72f5..23d9bf9 100644
--- a/test/intrinsics/textureGather/f32/blue.wgsl.expected.glsl
+++ b/test/intrinsics/textureGather/f32/blue.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D t;
+uniform highp sampler2D t_s;
 
 
 void tint_symbol() {
-  vec4 res = textureGather(t, vec2(0.0f, 0.0f), 2);
+  vec4 res = textureGather(t_s, vec2(0.0f, 0.0f), 2);
   return;
 }
 void main() {
diff --git a/test/intrinsics/textureGather/f32/green.wgsl.expected.glsl b/test/intrinsics/textureGather/f32/green.wgsl.expected.glsl
index 82b8ae8..0510c4c 100644
--- a/test/intrinsics/textureGather/f32/green.wgsl.expected.glsl
+++ b/test/intrinsics/textureGather/f32/green.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D t;
+uniform highp sampler2D t_s;
 
 
 void tint_symbol() {
-  vec4 res = textureGather(t, vec2(0.0f, 0.0f), 1);
+  vec4 res = textureGather(t_s, vec2(0.0f, 0.0f), 1);
   return;
 }
 void main() {
diff --git a/test/intrinsics/textureGather/f32/red.wgsl.expected.glsl b/test/intrinsics/textureGather/f32/red.wgsl.expected.glsl
index 6a16177..f3ae667 100644
--- a/test/intrinsics/textureGather/f32/red.wgsl.expected.glsl
+++ b/test/intrinsics/textureGather/f32/red.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D t;
+uniform highp sampler2D t_s;
 
 
 void tint_symbol() {
-  vec4 res = textureGather(t, vec2(0.0f, 0.0f), 0);
+  vec4 res = textureGather(t_s, vec2(0.0f, 0.0f), 0);
   return;
 }
 void main() {
diff --git a/test/intrinsics/textureGather/i32/alpha.wgsl.expected.glsl b/test/intrinsics/textureGather/i32/alpha.wgsl.expected.glsl
index 3d98065..3c6bc40 100644
--- a/test/intrinsics/textureGather/i32/alpha.wgsl.expected.glsl
+++ b/test/intrinsics/textureGather/i32/alpha.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D t;
+uniform highp isampler2D t_s;
 
 
 void tint_symbol() {
-  ivec4 res = textureGather(t, vec2(0.0f, 0.0f), 3);
+  ivec4 res = textureGather(t_s, vec2(0.0f, 0.0f), 3);
   return;
 }
 void main() {
diff --git a/test/intrinsics/textureGather/i32/blue.wgsl.expected.glsl b/test/intrinsics/textureGather/i32/blue.wgsl.expected.glsl
index 2f2cce0..ca61900 100644
--- a/test/intrinsics/textureGather/i32/blue.wgsl.expected.glsl
+++ b/test/intrinsics/textureGather/i32/blue.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D t;
+uniform highp isampler2D t_s;
 
 
 void tint_symbol() {
-  ivec4 res = textureGather(t, vec2(0.0f, 0.0f), 2);
+  ivec4 res = textureGather(t_s, vec2(0.0f, 0.0f), 2);
   return;
 }
 void main() {
diff --git a/test/intrinsics/textureGather/i32/green.wgsl.expected.glsl b/test/intrinsics/textureGather/i32/green.wgsl.expected.glsl
index 497c577..86f861a 100644
--- a/test/intrinsics/textureGather/i32/green.wgsl.expected.glsl
+++ b/test/intrinsics/textureGather/i32/green.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D t;
+uniform highp isampler2D t_s;
 
 
 void tint_symbol() {
-  ivec4 res = textureGather(t, vec2(0.0f, 0.0f), 1);
+  ivec4 res = textureGather(t_s, vec2(0.0f, 0.0f), 1);
   return;
 }
 void main() {
diff --git a/test/intrinsics/textureGather/i32/red.wgsl.expected.glsl b/test/intrinsics/textureGather/i32/red.wgsl.expected.glsl
index 25378bc..da5037b 100644
--- a/test/intrinsics/textureGather/i32/red.wgsl.expected.glsl
+++ b/test/intrinsics/textureGather/i32/red.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp isampler2D t;
+uniform highp isampler2D t_s;
 
 
 void tint_symbol() {
-  ivec4 res = textureGather(t, vec2(0.0f, 0.0f), 0);
+  ivec4 res = textureGather(t_s, vec2(0.0f, 0.0f), 0);
   return;
 }
 void main() {
diff --git a/test/intrinsics/textureGather/u32/alpha.wgsl.expected.glsl b/test/intrinsics/textureGather/u32/alpha.wgsl.expected.glsl
index a65eea9..e172b37 100644
--- a/test/intrinsics/textureGather/u32/alpha.wgsl.expected.glsl
+++ b/test/intrinsics/textureGather/u32/alpha.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D t;
+uniform highp usampler2D t_s;
 
 
 void tint_symbol() {
-  uvec4 res = textureGather(t, vec2(0.0f, 0.0f), 3);
+  uvec4 res = textureGather(t_s, vec2(0.0f, 0.0f), 3);
   return;
 }
 void main() {
diff --git a/test/intrinsics/textureGather/u32/blue.wgsl.expected.glsl b/test/intrinsics/textureGather/u32/blue.wgsl.expected.glsl
index 9f2296a..b5fb696 100644
--- a/test/intrinsics/textureGather/u32/blue.wgsl.expected.glsl
+++ b/test/intrinsics/textureGather/u32/blue.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D t;
+uniform highp usampler2D t_s;
 
 
 void tint_symbol() {
-  uvec4 res = textureGather(t, vec2(0.0f, 0.0f), 2);
+  uvec4 res = textureGather(t_s, vec2(0.0f, 0.0f), 2);
   return;
 }
 void main() {
diff --git a/test/intrinsics/textureGather/u32/green.wgsl.expected.glsl b/test/intrinsics/textureGather/u32/green.wgsl.expected.glsl
index 6e3b627..a9e95b4 100644
--- a/test/intrinsics/textureGather/u32/green.wgsl.expected.glsl
+++ b/test/intrinsics/textureGather/u32/green.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D t;
+uniform highp usampler2D t_s;
 
 
 void tint_symbol() {
-  uvec4 res = textureGather(t, vec2(0.0f, 0.0f), 1);
+  uvec4 res = textureGather(t_s, vec2(0.0f, 0.0f), 1);
   return;
 }
 void main() {
diff --git a/test/intrinsics/textureGather/u32/red.wgsl.expected.glsl b/test/intrinsics/textureGather/u32/red.wgsl.expected.glsl
index 6713201..4a21368 100644
--- a/test/intrinsics/textureGather/u32/red.wgsl.expected.glsl
+++ b/test/intrinsics/textureGather/u32/red.wgsl.expected.glsl
@@ -1,11 +1,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp usampler2D t;
+uniform highp usampler2D t_s;
 
 
 void tint_symbol() {
-  uvec4 res = textureGather(t, vec2(0.0f, 0.0f), 0);
+  uvec4 res = textureGather(t_s, vec2(0.0f, 0.0f), 0);
   return;
 }
 void main() {
diff --git a/test/intrinsics/textureLoad/depth_ms.spvasm.expected.glsl b/test/intrinsics/textureLoad/depth_ms.spvasm.expected.glsl
index e9d767d..5f2df56 100644
--- a/test/intrinsics/textureLoad/depth_ms.spvasm.expected.glsl
+++ b/test/intrinsics/textureLoad/depth_ms.spvasm.expected.glsl
@@ -1,12 +1,12 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
 vec4 tint_symbol_1 = vec4(0.0f, 0.0f, 0.0f, 0.0f);
+uniform highp sampler2DMS arg_0_1;
 
 void textureLoad_6273b1() {
   float res = 0.0f;
-  vec4 x_17 = vec4(texelFetch(arg_0, ivec2(0, 0), 1).x, 0.0f, 0.0f, 0.0f);
+  vec4 x_17 = vec4(texelFetch(arg_0_1, ivec2(0, 0), 1).x, 0.0f, 0.0f, 0.0f);
   res = x_17.x;
   return;
 }
@@ -52,11 +52,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureLoad_6273b1() {
   float res = 0.0f;
-  vec4 x_17 = vec4(texelFetch(arg_0, ivec2(0, 0), 1).x, 0.0f, 0.0f, 0.0f);
+  vec4 x_17 = vec4(texelFetch(arg_0_1, ivec2(0, 0), 1).x, 0.0f, 0.0f, 0.0f);
   res = x_17.x;
   return;
 }
@@ -85,11 +85,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureLoad_6273b1() {
   float res = 0.0f;
-  vec4 x_17 = vec4(texelFetch(arg_0, ivec2(0, 0), 1).x, 0.0f, 0.0f, 0.0f);
+  vec4 x_17 = vec4(texelFetch(arg_0_1, ivec2(0, 0), 1).x, 0.0f, 0.0f, 0.0f);
   res = x_17.x;
   return;
 }
diff --git a/test/intrinsics/textureNumSamples/depth_ms.spvasm.expected.glsl b/test/intrinsics/textureNumSamples/depth_ms.spvasm.expected.glsl
index dab32c8..ee1281e 100644
--- a/test/intrinsics/textureNumSamples/depth_ms.spvasm.expected.glsl
+++ b/test/intrinsics/textureNumSamples/depth_ms.spvasm.expected.glsl
@@ -3,12 +3,12 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
 vec4 tint_symbol_1 = vec4(0.0f, 0.0f, 0.0f, 0.0f);
+uniform highp sampler2DMS arg_0_1;
 
 void textureNumSamples_a3c8a0() {
   int res = 0;
-  int x_16 = textureSamples(arg_0);;
+  int x_16 = textureSamples(arg_0_1);;
   res = x_16;
   return;
 }
@@ -62,11 +62,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureNumSamples_a3c8a0() {
   int res = 0;
-  int x_16 = textureSamples(arg_0);;
+  int x_16 = textureSamples(arg_0_1);;
   res = x_16;
   return;
 }
@@ -103,11 +103,11 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS arg_0;
+uniform highp sampler2DMS arg_0_1;
 
 void textureNumSamples_a3c8a0() {
   int res = 0;
-  int x_16 = textureSamples(arg_0);;
+  int x_16 = textureSamples(arg_0_1);;
   res = x_16;
   return;
 }
diff --git a/test/types/sampler.wgsl.expected.glsl b/test/types/sampler.wgsl.expected.glsl
index fe64871..e27344d 100644
--- a/test/types/sampler.wgsl.expected.glsl
+++ b/test/types/sampler.wgsl.expected.glsl
@@ -1,9 +1,6 @@
 #version 310 es
 precision mediump float;
 
-
-
-
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 void tint_symbol() {
   return;
diff --git a/test/types/texture/depth/2d.wgsl.expected.glsl b/test/types/texture/depth/2d.wgsl.expected.glsl
index 2b6d25d..e27344d 100644
--- a/test/types/texture/depth/2d.wgsl.expected.glsl
+++ b/test/types/texture/depth/2d.wgsl.expected.glsl
@@ -1,8 +1,6 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D t_f;
-
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 void tint_symbol() {
   return;
diff --git a/test/types/texture/depth/2d_array.wgsl.expected.glsl b/test/types/texture/depth/2d_array.wgsl.expected.glsl
index 6e356e1..e27344d 100644
--- a/test/types/texture/depth/2d_array.wgsl.expected.glsl
+++ b/test/types/texture/depth/2d_array.wgsl.expected.glsl
@@ -1,8 +1,6 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray t_f;
-
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 void tint_symbol() {
   return;
diff --git a/test/types/texture/depth/cube.wgsl.expected.glsl b/test/types/texture/depth/cube.wgsl.expected.glsl
index cb259d8..e27344d 100644
--- a/test/types/texture/depth/cube.wgsl.expected.glsl
+++ b/test/types/texture/depth/cube.wgsl.expected.glsl
@@ -1,8 +1,6 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube t_f;
-
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 void tint_symbol() {
   return;
diff --git a/test/types/texture/depth/cube_array.wgsl.expected.glsl b/test/types/texture/depth/cube_array.wgsl.expected.glsl
index 1121d73..e27344d 100644
--- a/test/types/texture/depth/cube_array.wgsl.expected.glsl
+++ b/test/types/texture/depth/cube_array.wgsl.expected.glsl
@@ -1,10 +1,6 @@
-SKIP: FAILED
-
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray t_f;
-
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 void tint_symbol() {
   return;
@@ -14,10 +10,3 @@
 }
 
 
-Error parsing GLSL shader:
-ERROR: 0:4: 'samplerCubeArray' : Reserved word. 
-ERROR: 0:4: '' : compilation terminated 
-ERROR: 2 compilation errors.  No code generated.
-
-
-
diff --git a/test/types/texture/multisampled/2d.wgsl.expected.glsl b/test/types/texture/multisampled/2d.wgsl.expected.glsl
index 460c59c..e27344d 100644
--- a/test/types/texture/multisampled/2d.wgsl.expected.glsl
+++ b/test/types/texture/multisampled/2d.wgsl.expected.glsl
@@ -1,10 +1,6 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DMS t_f;
-uniform highp isampler2DMS t_i;
-uniform highp usampler2DMS t_u;
-
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 void tint_symbol() {
   return;
diff --git a/test/types/texture/sampled/1d.wgsl.expected.glsl b/test/types/texture/sampled/1d.wgsl.expected.glsl
index a5b0813..e27344d 100644
--- a/test/types/texture/sampled/1d.wgsl.expected.glsl
+++ b/test/types/texture/sampled/1d.wgsl.expected.glsl
@@ -1,12 +1,6 @@
-SKIP: FAILED
-
 #version 310 es
 precision mediump float;
 
-uniform highp sampler1D t_f;
-uniform highp isampler1D t_i;
-uniform highp usampler1D t_u;
-
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 void tint_symbol() {
   return;
@@ -16,10 +10,3 @@
 }
 
 
-Error parsing GLSL shader:
-ERROR: 0:4: 'sampler1D' : Reserved word. 
-ERROR: 0:4: '' : compilation terminated 
-ERROR: 2 compilation errors.  No code generated.
-
-
-
diff --git a/test/types/texture/sampled/2d.wgsl.expected.glsl b/test/types/texture/sampled/2d.wgsl.expected.glsl
index ce56a24..e27344d 100644
--- a/test/types/texture/sampled/2d.wgsl.expected.glsl
+++ b/test/types/texture/sampled/2d.wgsl.expected.glsl
@@ -1,10 +1,6 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2D t_f;
-uniform highp isampler2D t_i;
-uniform highp usampler2D t_u;
-
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 void tint_symbol() {
   return;
diff --git a/test/types/texture/sampled/2d_array.wgsl.expected.glsl b/test/types/texture/sampled/2d_array.wgsl.expected.glsl
index 3df57e9..e27344d 100644
--- a/test/types/texture/sampled/2d_array.wgsl.expected.glsl
+++ b/test/types/texture/sampled/2d_array.wgsl.expected.glsl
@@ -1,10 +1,6 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler2DArray t_f;
-uniform highp isampler2DArray t_i;
-uniform highp usampler2DArray t_u;
-
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 void tint_symbol() {
   return;
diff --git a/test/types/texture/sampled/3d.wgsl.expected.glsl b/test/types/texture/sampled/3d.wgsl.expected.glsl
index 48ce633..e27344d 100644
--- a/test/types/texture/sampled/3d.wgsl.expected.glsl
+++ b/test/types/texture/sampled/3d.wgsl.expected.glsl
@@ -1,10 +1,6 @@
 #version 310 es
 precision mediump float;
 
-uniform highp sampler3D t_f;
-uniform highp isampler3D t_i;
-uniform highp usampler3D t_u;
-
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 void tint_symbol() {
   return;
diff --git a/test/types/texture/sampled/cube.wgsl.expected.glsl b/test/types/texture/sampled/cube.wgsl.expected.glsl
index daa4f95..e27344d 100644
--- a/test/types/texture/sampled/cube.wgsl.expected.glsl
+++ b/test/types/texture/sampled/cube.wgsl.expected.glsl
@@ -1,10 +1,6 @@
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCube t_f;
-uniform highp isamplerCube t_i;
-uniform highp usamplerCube t_u;
-
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 void tint_symbol() {
   return;
diff --git a/test/types/texture/sampled/cube_array.wgsl.expected.glsl b/test/types/texture/sampled/cube_array.wgsl.expected.glsl
index dada745..e27344d 100644
--- a/test/types/texture/sampled/cube_array.wgsl.expected.glsl
+++ b/test/types/texture/sampled/cube_array.wgsl.expected.glsl
@@ -1,12 +1,6 @@
-SKIP: FAILED
-
 #version 310 es
 precision mediump float;
 
-uniform highp samplerCubeArray t_f;
-uniform highp isamplerCubeArray t_i;
-uniform highp usamplerCubeArray t_u;
-
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 void tint_symbol() {
   return;
@@ -16,10 +10,3 @@
 }
 
 
-Error parsing GLSL shader:
-ERROR: 0:4: 'samplerCubeArray' : Reserved word. 
-ERROR: 0:4: '' : compilation terminated 
-ERROR: 2 compilation errors.  No code generated.
-
-
-
diff --git a/test/types/texture/storage/1d.wgsl.expected.glsl b/test/types/texture/storage/1d.wgsl.expected.glsl
index c1d9ebe..e27344d 100644
--- a/test/types/texture/storage/1d.wgsl.expected.glsl
+++ b/test/types/texture/storage/1d.wgsl.expected.glsl
@@ -1,25 +1,6 @@
-SKIP: FAILED
-
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image1D t_rgba8unorm;
-uniform highp writeonly image1D t_rgba8snorm;
-uniform highp writeonly uimage1D t_rgba8uint;
-uniform highp writeonly iimage1D t_rgba8sint;
-uniform highp writeonly uimage1D t_rgba16uint;
-uniform highp writeonly iimage1D t_rgba16sint;
-uniform highp writeonly image1D t_rgba16float;
-uniform highp writeonly uimage1D t_r32uint;
-uniform highp writeonly iimage1D t_r32sint;
-uniform highp writeonly image1D t_r32float;
-uniform highp writeonly uimage1D t_rg32uint;
-uniform highp writeonly iimage1D t_rg32sint;
-uniform highp writeonly image1D t_rg32float;
-uniform highp writeonly uimage1D t_rgba32uint;
-uniform highp writeonly iimage1D t_rgba32sint;
-uniform highp writeonly image1D t_rgba32float;
-
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 void tint_symbol() {
   return;
@@ -29,10 +10,3 @@
 }
 
 
-Error parsing GLSL shader:
-ERROR: 0:4: 'image1D' : Reserved word. 
-ERROR: 0:4: '' : compilation terminated 
-ERROR: 2 compilation errors.  No code generated.
-
-
-
diff --git a/test/types/texture/storage/2d.wgsl.expected.glsl b/test/types/texture/storage/2d.wgsl.expected.glsl
index 002a656..e27344d 100644
--- a/test/types/texture/storage/2d.wgsl.expected.glsl
+++ b/test/types/texture/storage/2d.wgsl.expected.glsl
@@ -1,23 +1,6 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2D t_rgba8unorm;
-uniform highp writeonly image2D t_rgba8snorm;
-uniform highp writeonly uimage2D t_rgba8uint;
-uniform highp writeonly iimage2D t_rgba8sint;
-uniform highp writeonly uimage2D t_rgba16uint;
-uniform highp writeonly iimage2D t_rgba16sint;
-uniform highp writeonly image2D t_rgba16float;
-uniform highp writeonly uimage2D t_r32uint;
-uniform highp writeonly iimage2D t_r32sint;
-uniform highp writeonly image2D t_r32float;
-uniform highp writeonly uimage2D t_rg32uint;
-uniform highp writeonly iimage2D t_rg32sint;
-uniform highp writeonly image2D t_rg32float;
-uniform highp writeonly uimage2D t_rgba32uint;
-uniform highp writeonly iimage2D t_rgba32sint;
-uniform highp writeonly image2D t_rgba32float;
-
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 void tint_symbol() {
   return;
diff --git a/test/types/texture/storage/2d_array.wgsl.expected.glsl b/test/types/texture/storage/2d_array.wgsl.expected.glsl
index f4a03fc..e27344d 100644
--- a/test/types/texture/storage/2d_array.wgsl.expected.glsl
+++ b/test/types/texture/storage/2d_array.wgsl.expected.glsl
@@ -1,23 +1,6 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image2DArray t_rgba8unorm;
-uniform highp writeonly image2DArray t_rgba8snorm;
-uniform highp writeonly uimage2DArray t_rgba8uint;
-uniform highp writeonly iimage2DArray t_rgba8sint;
-uniform highp writeonly uimage2DArray t_rgba16uint;
-uniform highp writeonly iimage2DArray t_rgba16sint;
-uniform highp writeonly image2DArray t_rgba16float;
-uniform highp writeonly uimage2DArray t_r32uint;
-uniform highp writeonly iimage2DArray t_r32sint;
-uniform highp writeonly image2DArray t_r32float;
-uniform highp writeonly uimage2DArray t_rg32uint;
-uniform highp writeonly iimage2DArray t_rg32sint;
-uniform highp writeonly image2DArray t_rg32float;
-uniform highp writeonly uimage2DArray t_rgba32uint;
-uniform highp writeonly iimage2DArray t_rgba32sint;
-uniform highp writeonly image2DArray t_rgba32float;
-
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 void tint_symbol() {
   return;
diff --git a/test/types/texture/storage/3d.wgsl.expected.glsl b/test/types/texture/storage/3d.wgsl.expected.glsl
index 7ec45d0..e27344d 100644
--- a/test/types/texture/storage/3d.wgsl.expected.glsl
+++ b/test/types/texture/storage/3d.wgsl.expected.glsl
@@ -1,23 +1,6 @@
 #version 310 es
 precision mediump float;
 
-uniform highp writeonly image3D t_rgba8unorm;
-uniform highp writeonly image3D t_rgba8snorm;
-uniform highp writeonly uimage3D t_rgba8uint;
-uniform highp writeonly iimage3D t_rgba8sint;
-uniform highp writeonly uimage3D t_rgba16uint;
-uniform highp writeonly iimage3D t_rgba16sint;
-uniform highp writeonly image3D t_rgba16float;
-uniform highp writeonly uimage3D t_r32uint;
-uniform highp writeonly iimage3D t_r32sint;
-uniform highp writeonly image3D t_r32float;
-uniform highp writeonly uimage3D t_rg32uint;
-uniform highp writeonly iimage3D t_rg32sint;
-uniform highp writeonly image3D t_rg32float;
-uniform highp writeonly uimage3D t_rgba32uint;
-uniform highp writeonly iimage3D t_rgba32sint;
-uniform highp writeonly image3D t_rgba32float;
-
 layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 void tint_symbol() {
   return;