diff --git a/CMakeLists.txt b/CMakeLists.txt
index 59b9f0c..b5276fc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -54,6 +54,7 @@
 option(TINT_DOCS_WARN_AS_ERROR "When building documentation, treat warnings as errors" OFF)
 option(TINT_BUILD_SPV_READER "Build the SPIR-V input reader" ON)
 option(TINT_BUILD_WGSL_READER "Build the WGSL input reader" ON)
+option(TINT_BUILD_GLSL_WRITER "Build the GLSL output writer" ON)
 option(TINT_BUILD_HLSL_WRITER "Build the HLSL output writer" ON)
 option(TINT_BUILD_MSL_WRITER "Build the MSL output writer" ON)
 option(TINT_BUILD_SPV_WRITER "Build the SPIR-V output writer" ON)
@@ -81,6 +82,7 @@
 message(STATUS "Tint build docs with warn as error: ${TINT_DOCS_WARN_AS_ERROR}")
 message(STATUS "Tint build SPIR-V reader: ${TINT_BUILD_SPV_READER}")
 message(STATUS "Tint build WGSL reader: ${TINT_BUILD_WGSL_READER}")
+message(STATUS "Tint build GLSL writer: ${TINT_BUILD_GLSL_WRITER}")
 message(STATUS "Tint build HLSL writer: ${TINT_BUILD_HLSL_WRITER}")
 message(STATUS "Tint build MSL writer: ${TINT_BUILD_MSL_WRITER}")
 message(STATUS "Tint build SPIR-V writer: ${TINT_BUILD_SPV_WRITER}")
@@ -110,6 +112,7 @@
       TINT_BUILD_SPV_WRITER
       TINT_BUILD_WGSL_READER
       TINT_BUILD_WGSL_WRITER
+      TINT_BUILD_GLSL_WRITER
       TINT_BUILD_HLSL_WRITER
       TINT_BUILD_MSL_WRITER to ON")
   set(TINT_BUILD_FUZZERS ON CACHE BOOL "Build tint fuzzers" FORCE)
@@ -117,6 +120,7 @@
   set(TINT_BUILD_SPV_WRITER ON CACHE BOOL "Build SPIR-V writer" FORCE)
   set(TINT_BUILD_WGSL_READER ON CACHE BOOL "Build WGSL reader" FORCE)
   set(TINT_BUILD_WGSL_WRITER ON CACHE BOOL "Build WGSL writer" FORCE)
+  set(TINT_BUILD_GLSL_WRITER ON CACHE BOOL "Build HLSL writer" FORCE)
   set(TINT_BUILD_HLSL_WRITER ON CACHE BOOL "Build HLSL writer" FORCE)
   set(TINT_BUILD_MSL_WRITER ON CACHE BOOL "Build MSL writer" FORCE)
 endif()
@@ -128,12 +132,14 @@
       TINT_BUILD_WGSL_WRITER
       TINT_BUILD_SPV_WRITER
       TINT_BUILD_MSL_WRITER
+      TINT_BUILD_GLSL_WRITER
       TINT_BUILD_HLSL_WRITER to ON")
   set(TINT_BUILD_FUZZERS ON CACHE BOOL "Build tint fuzzers" FORCE)
   set(TINT_BUILD_WGSL_READER ON CACHE BOOL "Build WGSL reader" FORCE)
   set(TINT_BUILD_WGSL_WRITER ON CACHE BOOL "Build WGSL writer" FORCE)
   set(TINT_BUILD_SPV_WRITER ON CACHE BOOL "Build SPIR-V writer" FORCE)
   set(TINT_BUILD_MSL_WRITER ON CACHE BOOL "Build MSL writer" FORCE)
+  set(TINT_BUILD_GLSL_WRITER ON CACHE BOOL "Build GLSL writer" FORCE)
   set(TINT_BUILD_HLSL_WRITER ON CACHE BOOL "Build HLSL writer" FORCE)
 endif()
 
@@ -144,12 +150,14 @@
       TINT_BUILD_WGSL_WRITER
       TINT_BUILD_SPV_WRITER
       TINT_BUILD_MSL_WRITER
+      TINT_BUILD_GLSL_WRITER
       TINT_BUILD_HLSL_WRITER to ON")
       set(TINT_BUILD_FUZZERS ON CACHE BOOL "Build tint fuzzers" FORCE)
       set(TINT_BUILD_WGSL_READER ON CACHE BOOL "Build WGSL reader" FORCE)
       set(TINT_BUILD_WGSL_WRITER ON CACHE BOOL "Build WGSL writer" FORCE)
       set(TINT_BUILD_SPV_WRITER ON CACHE BOOL "Build SPIR-V writer" FORCE)
       set(TINT_BUILD_MSL_WRITER ON CACHE BOOL "Build MSL writer" FORCE)
+      set(TINT_BUILD_GLSL_WRITER ON CACHE BOOL "Build GLSL writer" FORCE)
       set(TINT_BUILD_HLSL_WRITER ON CACHE BOOL "Build HLSL writer" FORCE)
 endif()
 
@@ -240,6 +248,8 @@
   target_compile_definitions(${TARGET} PUBLIC
       -DTINT_BUILD_WGSL_READER=$<BOOL:${TINT_BUILD_WGSL_READER}>)
   target_compile_definitions(${TARGET} PUBLIC
+      -DTINT_BUILD_GLSL_WRITER=$<BOOL:${TINT_BUILD_GLSL_WRITER}>)
+  target_compile_definitions(${TARGET} PUBLIC
       -DTINT_BUILD_HLSL_WRITER=$<BOOL:${TINT_BUILD_HLSL_WRITER}>)
   target_compile_definitions(${TARGET} PUBLIC
       -DTINT_BUILD_MSL_WRITER=$<BOOL:${TINT_BUILD_MSL_WRITER}>)
diff --git a/include/tint/tint.h b/include/tint/tint.h
index ac1c8b3..a28d85e 100644
--- a/include/tint/tint.h
+++ b/include/tint/tint.h
@@ -59,4 +59,9 @@
 #include "src/writer/hlsl/generator.h"
 #endif  // TINT_BUILD_HLSL_WRITER
 
+#if TINT_BUILD_GLSL_WRITER
+#include "src/transform/glsl.h"
+#include "src/writer/glsl/generator.h"
+#endif  // TINT_BUILD_GLSL_WRITER
+
 #endif  // INCLUDE_TINT_TINT_H_
diff --git a/samples/main.cc b/samples/main.cc
index 235ed28..fdc524d 100644
--- a/samples/main.cc
+++ b/samples/main.cc
@@ -54,6 +54,7 @@
   kWgsl,
   kMsl,
   kHlsl,
+  kGlsl,
 };
 
 struct Options {
@@ -142,6 +143,11 @@
     return Format::kHlsl;
 #endif  // TINT_BUILD_HLSL_WRITER
 
+#if TINT_BUILD_GLSL_WRITER
+  if (fmt == "glsl")
+    return Format::kGlsl;
+#endif  // TINT_BUILD_GLSL_WRITER
+
   return Format::kNone;
 }
 
@@ -844,6 +850,33 @@
 #endif  // TINT_BUILD_HLSL_WRITER
 }
 
+/// Generate GLSL code for a program.
+/// @param program the program to generate
+/// @param options the options that Tint was invoked with
+/// @returns true on success
+bool GenerateGlsl(const tint::Program* program, const Options& options) {
+#if TINT_BUILD_GLSL_WRITER
+  tint::writer::glsl::Options gen_options;
+  auto result = tint::writer::glsl::Generate(program, gen_options);
+  if (!result.success) {
+    PrintWGSL(std::cerr, *program);
+    std::cerr << "Failed to generate: " << result.error << std::endl;
+    return false;
+  }
+
+  if (!WriteFile(options.output_file, "w", result.glsl)) {
+    return false;
+  }
+
+  // TODO(senorblanco): implement GLSL validation
+
+  return true;
+#else
+  std::cerr << "GLSL writer not enabled in tint build" << std::endl;
+  return false;
+#endif  // TINT_BUILD_GLSL_WRITER
+}
+
 }  // namespace
 
 int main(int argc, const char** argv) {
@@ -996,6 +1029,14 @@
 #endif  // TINT_BUILD_MSL_WRITER
       break;
     }
+#if TINT_BUILD_GLSL_WRITER
+    case Format::kGlsl: {
+      transform_inputs.Add<tint::transform::Renamer::Config>(
+          tint::transform::Renamer::Target::kGlslKeywords);
+      transform_manager.Add<tint::transform::Renamer>();
+      break;
+    }
+#endif  // TINT_BUILD_GLSL_WRITER
     case Format::kHlsl: {
 #if TINT_BUILD_HLSL_WRITER
       transform_inputs.Add<tint::transform::Renamer::Config>(
@@ -1066,6 +1107,9 @@
     case Format::kHlsl:
       success = GenerateHlsl(program.get(), options);
       break;
+    case Format::kGlsl:
+      success = GenerateGlsl(program.get(), options);
+      break;
     default:
       std::cerr << "Unknown output format specified" << std::endl;
       return 1;
diff --git a/src/BUILD.gn b/src/BUILD.gn
index 8fd81a6..a3262b8 100644
--- a/src/BUILD.gn
+++ b/src/BUILD.gn
@@ -67,6 +67,12 @@
     defines += [ "TINT_BUILD_HLSL_WRITER=0" ]
   }
 
+  if (tint_build_glsl_writer) {
+    defines += [ "TINT_BUILD_GLSL_WRITER=1" ]
+  } else {
+    defines += [ "TINT_BUILD_GLSL_WRITER=0" ]
+  }
+
   include_dirs = [
     "${tint_root_dir}/",
     "${tint_root_dir}/include/",
@@ -688,6 +694,19 @@
   public_deps = [ ":libtint_core_src" ]
 }
 
+libtint_source_set("libtint_glsl_writer_src") {
+  sources = [
+    "transform/glsl.cc",
+    "transform/glsl.h",
+    "writer/glsl/generator.cc",
+    "writer/glsl/generator.h",
+    "writer/glsl/generator_impl.cc",
+    "writer/glsl/generator_impl.h",
+  ]
+
+  public_deps = [ ":libtint_core_src" ]
+}
+
 source_set("libtint") {
   public_deps = [ ":libtint_core_src" ]
 
@@ -715,6 +734,10 @@
     public_deps += [ ":libtint_hlsl_writer_src" ]
   }
 
+  if (tint_build_glsl_writer) {
+    public_deps += [ ":libtint_glsl_writer_src" ]
+  }
+
   configs += [ ":tint_common_config" ]
   public_configs = [ ":tint_public_config" ]
 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 3945f5a..7f91f36e 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -310,6 +310,8 @@
   transform/fold_trivial_single_use_lets.h
   transform/for_loop_to_loop.cc
   transform/for_loop_to_loop.h
+  transform/glsl.cc
+  transform/glsl.h
   transform/inline_pointer_lets.cc
   transform/inline_pointer_lets.h
   transform/loop_to_for_loop.cc
@@ -484,6 +486,15 @@
   )
 endif()
 
+if(${TINT_BUILD_GLSL_WRITER})
+  list(APPEND TINT_LIB_SRCS
+    writer/glsl/generator.cc
+    writer/glsl/generator.h
+    writer/glsl/generator_impl.cc
+    writer/glsl/generator_impl.h
+  )
+endif()
+
 if(${TINT_BUILD_HLSL_WRITER})
   list(APPEND TINT_LIB_SRCS
     writer/hlsl/generator.cc
@@ -981,6 +992,41 @@
     )
   endif()
 
+  if (${TINT_BUILD_GLSL_WRITER})
+    list(APPEND TINT_TEST_SRCS
+      writer/glsl/generator_impl_array_accessor_test.cc
+      writer/glsl/generator_impl_assign_test.cc
+      writer/glsl/generator_impl_binary_test.cc
+      writer/glsl/generator_impl_bitcast_test.cc
+      writer/glsl/generator_impl_block_test.cc
+      writer/glsl/generator_impl_break_test.cc
+      writer/glsl/generator_impl_call_test.cc
+      writer/glsl/generator_impl_case_test.cc
+      writer/glsl/generator_impl_cast_test.cc
+      writer/glsl/generator_impl_constructor_test.cc
+      writer/glsl/generator_impl_continue_test.cc
+      writer/glsl/generator_impl_discard_test.cc
+      writer/glsl/generator_impl_function_test.cc
+      writer/glsl/generator_impl_identifier_test.cc
+      writer/glsl/generator_impl_if_test.cc
+      writer/glsl/generator_impl_intrinsic_test.cc
+      writer/glsl/generator_impl_intrinsic_texture_test.cc
+      writer/glsl/generator_impl_import_test.cc
+      writer/glsl/generator_impl_loop_test.cc
+      writer/glsl/generator_impl_member_accessor_test.cc
+      writer/glsl/generator_impl_module_constant_test.cc
+      writer/glsl/generator_impl_return_test.cc
+      writer/glsl/generator_impl_sanitizer_test.cc
+      writer/glsl/generator_impl_switch_test.cc
+      writer/glsl/generator_impl_test.cc
+      writer/glsl/generator_impl_type_test.cc
+      writer/glsl/generator_impl_unary_op_test.cc
+      writer/glsl/generator_impl_variable_decl_statement_test.cc
+      writer/glsl/generator_impl_workgroup_var_test.cc
+      writer/glsl/test_helper.h
+    )
+  endif()
+
   if (${TINT_BUILD_HLSL_WRITER})
     list(APPEND TINT_TEST_SRCS
       writer/hlsl/generator_impl_array_accessor_test.cc
diff --git a/src/transform/glsl.cc b/src/transform/glsl.cc
new file mode 100644
index 0000000..0457f9f
--- /dev/null
+++ b/src/transform/glsl.cc
@@ -0,0 +1,102 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/transform/glsl.h"
+
+#include <utility>
+
+#include "src/program_builder.h"
+#include "src/transform/calculate_array_length.h"
+#include "src/transform/canonicalize_entry_point_io.h"
+#include "src/transform/decompose_memory_access.h"
+#include "src/transform/external_texture_transform.h"
+#include "src/transform/fold_trivial_single_use_lets.h"
+#include "src/transform/inline_pointer_lets.h"
+#include "src/transform/loop_to_for_loop.h"
+#include "src/transform/manager.h"
+#include "src/transform/pad_array_elements.h"
+#include "src/transform/promote_initializers_to_const_var.h"
+#include "src/transform/simplify.h"
+#include "src/transform/zero_init_workgroup_memory.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::transform::Glsl);
+TINT_INSTANTIATE_TYPEINFO(tint::transform::Glsl::Config);
+
+namespace tint {
+namespace transform {
+
+Glsl::Glsl() = default;
+Glsl::~Glsl() = default;
+
+Output Glsl::Run(const Program* in, const DataMap& inputs) {
+  Manager manager;
+  DataMap data;
+
+  auto* cfg = inputs.Get<Config>();
+
+  // Attempt to convert `loop`s into for-loops. This is to try and massage the
+  // output into something that will not cause FXC to choke or misbehave.
+  manager.Add<FoldTrivialSingleUseLets>();
+  manager.Add<LoopToForLoop>();
+
+  if (!cfg || !cfg->disable_workgroup_init) {
+    // ZeroInitWorkgroupMemory must come before CanonicalizeEntryPointIO as
+    // ZeroInitWorkgroupMemory may inject new builtin parameters.
+    manager.Add<ZeroInitWorkgroupMemory>();
+  }
+  manager.Add<CanonicalizeEntryPointIO>();
+  manager.Add<InlinePointerLets>();
+  // Simplify cleans up messy `*(&(expr))` expressions from InlinePointerLets.
+  manager.Add<Simplify>();
+  manager.Add<CalculateArrayLength>();
+  manager.Add<ExternalTextureTransform>();
+  manager.Add<PromoteInitializersToConstVar>();
+  manager.Add<PadArrayElements>();
+
+  // For now, canonicalize to structs for all IO, as in HLSL.
+  // TODO(senorblanco): we could skip this by accessing global entry point
+  // variables directly.
+  data.Add<CanonicalizeEntryPointIO::Config>(
+      CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
+  auto out = manager.Run(in, data);
+  if (!out.program.IsValid()) {
+    return out;
+  }
+
+  ProgramBuilder builder;
+  CloneContext ctx(&builder, &out.program);
+  AddEmptyEntryPoint(ctx);
+  ctx.Clone();
+  builder.SetTransformApplied(this);
+  return Output{Program(std::move(builder))};
+}
+
+void Glsl::AddEmptyEntryPoint(CloneContext& ctx) const {
+  for (auto* func : ctx.src->AST().Functions()) {
+    if (func->IsEntryPoint()) {
+      return;
+    }
+  }
+  ctx.dst->Func(ctx.dst->Symbols().New("unused_entry_point"), {},
+                ctx.dst->ty.void_(), {},
+                {ctx.dst->Stage(ast::PipelineStage::kCompute),
+                 ctx.dst->WorkgroupSize(1)});
+}
+
+Glsl::Config::Config(bool disable_wi) : disable_workgroup_init(disable_wi) {}
+Glsl::Config::Config(const Config&) = default;
+Glsl::Config::~Config() = default;
+
+}  // namespace transform
+}  // namespace tint
diff --git a/src/transform/glsl.h b/src/transform/glsl.h
new file mode 100644
index 0000000..56d8de9
--- /dev/null
+++ b/src/transform/glsl.h
@@ -0,0 +1,67 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TRANSFORM_GLSL_H_
+#define SRC_TRANSFORM_GLSL_H_
+
+#include "src/transform/transform.h"
+
+namespace tint {
+
+// Forward declarations
+class CloneContext;
+
+namespace transform {
+
+/// Glsl is a transform used to sanitize a Program for use with the Glsl writer.
+/// Passing a non-sanitized Program to the Glsl writer will result in undefined
+/// behavior.
+class Glsl : public Castable<Glsl, Transform> {
+ public:
+  /// Configuration options for the Glsl sanitizer transform.
+  struct Config : public Castable<Data, transform::Data> {
+    /// Constructor
+    /// @param disable_workgroup_init `true` to disable workgroup memory zero
+    ///        initialization
+    explicit Config(bool disable_workgroup_init = false);
+
+    /// Copy constructor
+    Config(const Config&);
+
+    /// Destructor
+    ~Config() override;
+
+    /// Set to `true` to disable workgroup memory zero initialization
+    bool disable_workgroup_init = false;
+  };
+
+  /// Constructor
+  Glsl();
+  ~Glsl() override;
+
+  /// Runs the transform on `program`, returning the transformation result.
+  /// @param program the source program to transform
+  /// @param data optional extra transform-specific data
+  /// @returns the transformation result
+  Output Run(const Program* program, const DataMap& data = {}) override;
+
+ private:
+  /// Add an empty shader entry point if none exist in the module.
+  void AddEmptyEntryPoint(CloneContext& ctx) const;
+};
+
+}  // namespace transform
+}  // namespace tint
+
+#endif  // SRC_TRANSFORM_GLSL_H_
diff --git a/src/transform/glsl_test.cc b/src/transform/glsl_test.cc
new file mode 100644
index 0000000..b280e33
--- /dev/null
+++ b/src/transform/glsl_test.cc
@@ -0,0 +1,41 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/transform/glsl.h"
+
+#include "src/transform/test_helper.h"
+
+namespace tint {
+namespace transform {
+namespace {
+
+using GlslTest = TransformTest;
+
+TEST_F(GlslTest, AddEmptyEntryPoint) {
+  auto* src = R"()";
+
+  auto* expect = R"(
+[[stage(compute), workgroup_size(1)]]
+fn unused_entry_point() {
+}
+)";
+
+  auto got = Run<Glsl>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+}  // namespace
+}  // namespace transform
+}  // namespace tint
diff --git a/src/transform/renamer.cc b/src/transform/renamer.cc
index d3d0cf9..6bf953f 100644
--- a/src/transform/renamer.cc
+++ b/src/transform/renamer.cc
@@ -32,6 +32,211 @@
 namespace {
 
 // This list is used for a binary search and must be kept in sorted order.
+const char* kReservedKeywordsGLSL[] = {
+    "active",
+    "asm",
+    "atomic_uint",
+    "attribute",
+    "bool",
+    "break",
+    "buffer",
+    "bvec2",
+    "bvec3",
+    "bvec4",
+    "case",
+    "cast",
+    "centroid",
+    "class",
+    "coherent",
+    "common",
+    "const",
+    "continue",
+    "default",
+    "discard",
+    "dmat2",
+    "dmat2x2",
+    "dmat2x3",
+    "dmat2x4",
+    "dmat3",
+    "dmat3x2",
+    "dmat3x3",
+    "dmat3x4",
+    "dmat4",
+    "dmat4x2",
+    "dmat4x3",
+    "dmat4x4",
+    "do",
+    "double",
+    "dvec2",
+    "dvec3",
+    "dvec4",
+    "else",
+    "enum",
+    "extern",
+    "external",
+    "false",
+    "filter",
+    "fixed",
+    "flat",
+    "float",
+    "for",
+    "fvec2",
+    "fvec3",
+    "fvec4",
+    "goto",
+    "half",
+    "highp",
+    "hvec2",
+    "hvec3",
+    "hvec4",
+    "if",
+    "iimage1D",
+    "iimage1DArray",
+    "iimage2D",
+    "iimage2DArray",
+    "iimage2DMS",
+    "iimage2DMSArray",
+    "iimage2DRect",
+    "iimage3D",
+    "iimageBuffer",
+    "iimageCube",
+    "iimageCubeArray",
+    "image1D",
+    "image1DArray",
+    "image2D",
+    "image2DArray",
+    "image2DMS",
+    "image2DMSArray",
+    "image2DRect",
+    "image3D",
+    "imageBuffer",
+    "imageCube",
+    "imageCubeArray",
+    "in",
+    "inline",
+    "inout",
+    "input",
+    "int",
+    "interface",
+    "invariant",
+    "isampler1D",
+    "isampler1DArray",
+    "isampler2D",
+    "isampler2DArray",
+    "isampler2DMS",
+    "isampler2DMSArray",
+    "isampler2DRect",
+    "isampler3D",
+    "isamplerBuffer",
+    "isamplerCube",
+    "isamplerCubeArray",
+    "ivec2",
+    "ivec3",
+    "ivec4",
+    "layout",
+    "long",
+    "lowp",
+    "mat2",
+    "mat2x2",
+    "mat2x3",
+    "mat2x4",
+    "mat3",
+    "mat3x2",
+    "mat3x3",
+    "mat3x4",
+    "mat4",
+    "mat4x2",
+    "mat4x3",
+    "mat4x4",
+    "mediump",
+    "namespace",
+    "noinline",
+    "noperspective",
+    "out",
+    "output",
+    "partition",
+    "patch",
+    "precise",
+    "precision",
+    "public",
+    "readonly",
+    "resource",
+    "restrict",
+    "return",
+    "sample",
+    "sampler1D",
+    "sampler1DArray",
+    "sampler1DArrayShadow",
+    "sampler1DShadow",
+    "sampler2D",
+    "sampler2DArray",
+    "sampler2DArrayShadow",
+    "sampler2DMS",
+    "sampler2DMSArray",
+    "sampler2DRect",
+    "sampler2DRectShadow",
+    "sampler2DShadow",
+    "sampler3D",
+    "sampler3DRect",
+    "samplerBuffer",
+    "samplerCube",
+    "samplerCubeArray",
+    "samplerCubeArrayShadow",
+    "samplerCubeShadow",
+    "shared",
+    "short",
+    "sizeof",
+    "smooth",
+    "static",
+    "struct",
+    "subroutine",
+    "superp",
+    "switch",
+    "template",
+    "this",
+    "true",
+    "typedef",
+    "uimage1D",
+    "uimage1DArray",
+    "uimage2D",
+    "uimage2DArray",
+    "uimage2DMS",
+    "uimage2DMSArray",
+    "uimage2DRect",
+    "uimage3D",
+    "uimageBuffer",
+    "uimageCube",
+    "uimageCubeArray",
+    "uint",
+    "uniform",
+    "union",
+    "unsigned",
+    "usampler1D",
+    "usampler1DArray",
+    "usampler2D",
+    "usampler2DArray",
+    "usampler2DMS",
+    "usampler2DMSArray",
+    "usampler2DRect",
+    "usampler3D",
+    "usamplerBuffer",
+    "usamplerCube",
+    "usamplerCubeArray",
+    "using",
+    "uvec2",
+    "uvec3",
+    "uvec4",
+    "varying",
+    "vec2",
+    "vec3",
+    "vec4",
+    "void",
+    "volatile",
+    "while",
+    "writeonly",
+};
+
+// This list is used for a binary search and must be kept in sorted order.
 const char* kReservedKeywordsHLSL[] = {
     "AddressU",
     "AddressV",
@@ -944,6 +1149,16 @@
       case Target::kAll:
         // Always rename.
         break;
+      case Target::kGlslKeywords:
+        if (!std::binary_search(
+                kReservedKeywordsGLSL,
+                kReservedKeywordsGLSL +
+                    sizeof(kReservedKeywordsGLSL) / sizeof(const char*),
+                name_in)) {
+          // No match, just reuse the original name.
+          return ctx.dst->Symbols().New(name_in);
+        }
+        break;
       case Target::kHlslKeywords:
         if (!std::binary_search(
                 kReservedKeywordsHLSL,
diff --git a/src/transform/renamer.h b/src/transform/renamer.h
index 5dc0330..2e0586e 100644
--- a/src/transform/renamer.h
+++ b/src/transform/renamer.h
@@ -50,6 +50,8 @@
   enum class Target {
     /// Rename every symbol.
     kAll,
+    /// Only rename symbols that are reserved keywords in GLSL.
+    kGlslKeywords,
     /// Only rename symbols that are reserved keywords in HLSL.
     kHlslKeywords,
     /// Only rename symbols that are reserved keywords in MSL.
diff --git a/src/writer/glsl/generator.cc b/src/writer/glsl/generator.cc
new file mode 100644
index 0000000..6f6bbaa
--- /dev/null
+++ b/src/writer/glsl/generator.cc
@@ -0,0 +1,59 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/writer/glsl/generator.h"
+
+#include "src/transform/glsl.h"
+#include "src/writer/glsl/generator_impl.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+
+Result::Result() = default;
+Result::~Result() = default;
+Result::Result(const Result&) = default;
+
+Result Generate(const Program* program, const Options&) {
+  Result result;
+
+  // Run the GLSL sanitizer.
+  transform::Glsl sanitizer;
+  auto output = sanitizer.Run(program);
+  if (!output.program.IsValid()) {
+    result.success = false;
+    result.error = output.program.Diagnostics().str();
+    return result;
+  }
+
+  // Generate the GLSL code.
+  auto impl = std::make_unique<GeneratorImpl>(&output.program);
+  result.success = impl->Generate();
+  result.error = impl->error();
+  result.glsl = impl->result();
+
+  // Collect the list of entry points in the sanitized program.
+  for (auto* func : output.program.AST().Functions()) {
+    if (func->IsEntryPoint()) {
+      auto name = output.program.Symbols().NameFor(func->symbol());
+      result.entry_points.push_back({name, func->pipeline_stage()});
+    }
+  }
+
+  return result;
+}
+
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator.h b/src/writer/glsl/generator.h
new file mode 100644
index 0000000..6aaf20f
--- /dev/null
+++ b/src/writer/glsl/generator.h
@@ -0,0 +1,76 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_WRITER_GLSL_GENERATOR_H_
+#define SRC_WRITER_GLSL_GENERATOR_H_
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "src/ast/pipeline_stage.h"
+#include "src/writer/text.h"
+
+namespace tint {
+
+// Forward declarations
+class Program;
+
+namespace writer {
+namespace glsl {
+
+// Forward declarations
+class GeneratorImpl;
+
+/// Configuration options used for generating GLSL.
+struct Options {};
+
+/// The result produced when generating GLSL.
+struct Result {
+  /// Constructor
+  Result();
+
+  /// Destructor
+  ~Result();
+
+  /// Copy constructor
+  Result(const Result&);
+
+  /// True if generation was successful.
+  bool success = false;
+
+  /// The errors generated during code generation, if any.
+  std::string error;
+
+  /// The generated GLSL.
+  std::string glsl = "";
+
+  /// The list of entry points in the generated GLSL.
+  std::vector<std::pair<std::string, ast::PipelineStage>> entry_points;
+};
+
+/// Generate GLSL for a program, according to a set of configuration options.
+/// The result will contain the GLSL, as well as success status and diagnostic
+/// information.
+/// @param program the program to translate to GLSL
+/// @param options the configuration options to use when generating GLSL
+/// @returns the resulting GLSL and supplementary information
+Result Generate(const Program* program, const Options& options);
+
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
+
+#endif  // SRC_WRITER_GLSL_GENERATOR_H_
diff --git a/src/writer/glsl/generator_impl.cc b/src/writer/glsl/generator_impl.cc
new file mode 100644
index 0000000..cecee03
--- /dev/null
+++ b/src/writer/glsl/generator_impl.cc
@@ -0,0 +1,2744 @@
+/// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/writer/glsl/generator_impl.h"
+
+#include <algorithm>
+#include <cmath>
+#include <iomanip>
+#include <set>
+#include <utility>
+#include <vector>
+
+#include "src/ast/call_statement.h"
+#include "src/ast/fallthrough_statement.h"
+#include "src/ast/internal_decoration.h"
+#include "src/ast/interpolate_decoration.h"
+#include "src/ast/override_decoration.h"
+#include "src/ast/variable_decl_statement.h"
+#include "src/debug.h"
+#include "src/sem/array.h"
+#include "src/sem/atomic_type.h"
+#include "src/sem/block_statement.h"
+#include "src/sem/call.h"
+#include "src/sem/depth_multisampled_texture_type.h"
+#include "src/sem/depth_texture_type.h"
+#include "src/sem/function.h"
+#include "src/sem/member_accessor_expression.h"
+#include "src/sem/multisampled_texture_type.h"
+#include "src/sem/sampled_texture_type.h"
+#include "src/sem/statement.h"
+#include "src/sem/storage_texture_type.h"
+#include "src/sem/struct.h"
+#include "src/sem/variable.h"
+#include "src/transform/calculate_array_length.h"
+#include "src/transform/glsl.h"
+#include "src/utils/defer.h"
+#include "src/utils/get_or_create.h"
+#include "src/utils/scoped_assignment.h"
+#include "src/writer/append_vector.h"
+#include "src/writer/float_to_string.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+const char kTempNamePrefix[] = "tint_tmp";
+const char kSpecConstantPrefix[] = "WGSL_SPEC_CONSTANT_";
+
+bool last_is_break_or_fallthrough(const ast::BlockStatement* stmts) {
+  if (stmts->empty()) {
+    return false;
+  }
+
+  return stmts->last()->Is<ast::BreakStatement>() ||
+         stmts->last()->Is<ast::FallthroughStatement>();
+}
+
+const char* image_format_to_rwtexture_type(ast::ImageFormat image_format) {
+  switch (image_format) {
+    case ast::ImageFormat::kRgba8Unorm:
+    case ast::ImageFormat::kRgba8Snorm:
+    case ast::ImageFormat::kRgba16Float:
+    case ast::ImageFormat::kR32Float:
+    case ast::ImageFormat::kRg32Float:
+    case ast::ImageFormat::kRgba32Float:
+      return "float4";
+    case ast::ImageFormat::kRgba8Uint:
+    case ast::ImageFormat::kRgba16Uint:
+    case ast::ImageFormat::kR32Uint:
+    case ast::ImageFormat::kRg32Uint:
+    case ast::ImageFormat::kRgba32Uint:
+      return "uint4";
+    case ast::ImageFormat::kRgba8Sint:
+    case ast::ImageFormat::kRgba16Sint:
+    case ast::ImageFormat::kR32Sint:
+    case ast::ImageFormat::kRg32Sint:
+    case ast::ImageFormat::kRgba32Sint:
+      return "int4";
+    default:
+      return nullptr;
+  }
+}
+
+// Helper for writing " : register(RX, spaceY)", where R is the register, X is
+// the binding point binding value, and Y is the binding point group value.
+struct RegisterAndSpace {
+  RegisterAndSpace(char r, ast::Variable::BindingPoint bp)
+      : reg(r), binding_point(bp) {}
+
+  char const reg;
+  ast::Variable::BindingPoint const binding_point;
+};
+
+std::ostream& operator<<(std::ostream& s, const RegisterAndSpace& rs) {
+  s << " : register(" << rs.reg << rs.binding_point.binding->value()
+    << ", space" << rs.binding_point.group->value() << ")";
+  return s;
+}
+
+}  // namespace
+
+GeneratorImpl::GeneratorImpl(const Program* program) : TextGenerator(program) {}
+
+GeneratorImpl::~GeneratorImpl() = default;
+
+bool GeneratorImpl::Generate() {
+  if (!builder_.HasTransformApplied<transform::Glsl>()) {
+    diagnostics_.add_error(
+        diag::System::Writer,
+        "GLSL writer requires the transform::Glsl sanitizer to have been "
+        "applied to the input program");
+    return false;
+  }
+
+  const TypeInfo* last_kind = nullptr;
+  size_t last_padding_line = 0;
+
+  line() << "#version 310 es";
+  line() << "precision mediump float;" << std::endl;
+
+  for (auto* decl : builder_.AST().GlobalDeclarations()) {
+    if (decl->Is<ast::Alias>()) {
+      continue;  // Ignore aliases.
+    }
+
+    // Emit a new line between declarations if the type of declaration has
+    // changed, or we're about to emit a function
+    auto* kind = &decl->TypeInfo();
+    if (current_buffer_->lines.size() != last_padding_line) {
+      if (last_kind && (last_kind != kind || decl->Is<ast::Function>())) {
+        line();
+        last_padding_line = current_buffer_->lines.size();
+      }
+    }
+    last_kind = kind;
+
+    if (auto* global = decl->As<ast::Variable>()) {
+      if (!EmitGlobalVariable(global)) {
+        return false;
+      }
+    } else if (auto* str = decl->As<ast::Struct>()) {
+      if (!EmitStructType(current_buffer_, builder_.Sem().Get(str))) {
+        return false;
+      }
+    } else if (auto* func = decl->As<ast::Function>()) {
+      if (func->IsEntryPoint()) {
+        if (!EmitEntryPointFunction(func)) {
+          return false;
+        }
+      } else {
+        if (!EmitFunction(func)) {
+          return false;
+        }
+      }
+    } else {
+      TINT_ICE(Writer, diagnostics_)
+          << "unhandled module-scope declaration: " << decl->TypeInfo().name;
+      return false;
+    }
+  }
+
+  if (!helpers_.lines.empty()) {
+    current_buffer_->Insert(helpers_, 0, 0);
+  }
+
+  return true;
+}
+
+bool GeneratorImpl::EmitArrayAccessor(std::ostream& out,
+                                      ast::ArrayAccessorExpression* expr) {
+  if (!EmitExpression(out, expr->array())) {
+    return false;
+  }
+  out << "[";
+
+  if (!EmitExpression(out, expr->idx_expr())) {
+    return false;
+  }
+  out << "]";
+
+  return true;
+}
+
+bool GeneratorImpl::EmitBitcast(std::ostream& out,
+                                ast::BitcastExpression* expr) {
+  auto* type = TypeOf(expr);
+  if (auto* vec = type->UnwrapRef()->As<sem::Vector>()) {
+    type = vec->type();
+  }
+
+  if (!type->is_integer_scalar() && !type->is_float_scalar()) {
+    diagnostics_.add_error(diag::System::Writer,
+                           "Unable to do bitcast to type " + type->type_name());
+    return false;
+  }
+
+  out << "as";
+  if (!EmitType(out, type, ast::StorageClass::kNone, ast::Access::kReadWrite,
+                "")) {
+    return false;
+  }
+  out << "(";
+  if (!EmitExpression(out, expr->expr())) {
+    return false;
+  }
+  out << ")";
+  return true;
+}
+
+bool GeneratorImpl::EmitAssign(ast::AssignmentStatement* stmt) {
+  auto out = line();
+  if (!EmitExpression(out, stmt->lhs())) {
+    return false;
+  }
+  out << " = ";
+  if (!EmitExpression(out, stmt->rhs())) {
+    return false;
+  }
+  out << ";";
+  return true;
+}
+
+bool GeneratorImpl::EmitBinary(std::ostream& out, ast::BinaryExpression* expr) {
+  if (expr->op() == ast::BinaryOp::kLogicalAnd ||
+      expr->op() == ast::BinaryOp::kLogicalOr) {
+    auto name = UniqueIdentifier(kTempNamePrefix);
+
+    {
+      auto pre = line();
+      pre << "bool " << name << " = ";
+      if (!EmitExpression(pre, expr->lhs())) {
+        return false;
+      }
+      pre << ";";
+    }
+
+    if (expr->op() == ast::BinaryOp::kLogicalOr) {
+      line() << "if (!" << name << ") {";
+    } else {
+      line() << "if (" << name << ") {";
+    }
+
+    {
+      ScopedIndent si(this);
+      auto pre = line();
+      pre << name << " = ";
+      if (!EmitExpression(pre, expr->rhs())) {
+        return false;
+      }
+      pre << ";";
+    }
+
+    line() << "}";
+
+    out << "(" << name << ")";
+    return true;
+  }
+
+  out << "(";
+  if (!EmitExpression(out, expr->lhs())) {
+    return false;
+  }
+  out << " ";
+
+  switch (expr->op()) {
+    case ast::BinaryOp::kAnd:
+      out << "&";
+      break;
+    case ast::BinaryOp::kOr:
+      out << "|";
+      break;
+    case ast::BinaryOp::kXor:
+      out << "^";
+      break;
+    case ast::BinaryOp::kLogicalAnd:
+    case ast::BinaryOp::kLogicalOr: {
+      // These are both handled above.
+      TINT_UNREACHABLE(Writer, diagnostics_);
+      return false;
+    }
+    case ast::BinaryOp::kEqual:
+      out << "==";
+      break;
+    case ast::BinaryOp::kNotEqual:
+      out << "!=";
+      break;
+    case ast::BinaryOp::kLessThan:
+      out << "<";
+      break;
+    case ast::BinaryOp::kGreaterThan:
+      out << ">";
+      break;
+    case ast::BinaryOp::kLessThanEqual:
+      out << "<=";
+      break;
+    case ast::BinaryOp::kGreaterThanEqual:
+      out << ">=";
+      break;
+    case ast::BinaryOp::kShiftLeft:
+      out << "<<";
+      break;
+    case ast::BinaryOp::kShiftRight:
+      // TODO(dsinclair): MSL is based on C++14, and >> in C++14 has
+      // implementation-defined behaviour for negative LHS.  We may have to
+      // generate extra code to implement WGSL-specified behaviour for negative
+      // LHS.
+      out << R"(>>)";
+      break;
+
+    case ast::BinaryOp::kAdd:
+      out << "+";
+      break;
+    case ast::BinaryOp::kSubtract:
+      out << "-";
+      break;
+    case ast::BinaryOp::kMultiply:
+      out << "*";
+      break;
+    case ast::BinaryOp::kDivide:
+      out << "/";
+      break;
+    case ast::BinaryOp::kModulo:
+      out << "%";
+      break;
+    case ast::BinaryOp::kNone:
+      diagnostics_.add_error(diag::System::Writer,
+                             "missing binary operation type");
+      return false;
+  }
+  out << " ";
+
+  if (!EmitExpression(out, expr->rhs())) {
+    return false;
+  }
+
+  out << ")";
+  return true;
+}
+
+bool GeneratorImpl::EmitStatements(const ast::StatementList& stmts) {
+  for (auto* s : stmts) {
+    if (!EmitStatement(s)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool GeneratorImpl::EmitStatementsWithIndent(const ast::StatementList& stmts) {
+  ScopedIndent si(this);
+  return EmitStatements(stmts);
+}
+
+bool GeneratorImpl::EmitBlock(const ast::BlockStatement* stmt) {
+  line() << "{";
+  if (!EmitStatementsWithIndent(stmt->statements())) {
+    return false;
+  }
+  line() << "}";
+  return true;
+}
+
+bool GeneratorImpl::EmitBreak(ast::BreakStatement*) {
+  line() << "break;";
+  return true;
+}
+
+bool GeneratorImpl::EmitCall(std::ostream& out, ast::CallExpression* expr) {
+  const auto& params = expr->params();
+  auto* ident = expr->func();
+  auto* call = builder_.Sem().Get(expr);
+  auto* target = call->Target();
+
+  if (auto* func = target->As<sem::Function>()) {
+    if (ast::HasDecoration<
+            transform::CalculateArrayLength::BufferSizeIntrinsic>(
+            func->Declaration()->decorations())) {
+      // Special function generated by the CalculateArrayLength transform for
+      // calling X.GetDimensions(Y)
+      if (!EmitExpression(out, params[0])) {
+        return false;
+      }
+      out << ".GetDimensions(";
+      if (!EmitExpression(out, params[1])) {
+        return false;
+      }
+      out << ")";
+      return true;
+    }
+  }
+
+  if (auto* intrinsic = call->Target()->As<sem::Intrinsic>()) {
+    if (intrinsic->IsTexture()) {
+      return EmitTextureCall(out, expr, intrinsic);
+    } else if (intrinsic->Type() == sem::IntrinsicType::kSelect) {
+      return EmitSelectCall(out, expr);
+    } else if (intrinsic->Type() == sem::IntrinsicType::kModf) {
+      return EmitModfCall(out, expr, intrinsic);
+    } else if (intrinsic->Type() == sem::IntrinsicType::kFrexp) {
+      return EmitFrexpCall(out, expr, intrinsic);
+    } else if (intrinsic->Type() == sem::IntrinsicType::kIsNormal) {
+      return EmitIsNormalCall(out, expr, intrinsic);
+    } else if (intrinsic->Type() == sem::IntrinsicType::kIgnore) {
+      return EmitExpression(out, expr->params()[0]);
+    } else if (intrinsic->IsDataPacking()) {
+      return EmitDataPackingCall(out, expr, intrinsic);
+    } else if (intrinsic->IsDataUnpacking()) {
+      return EmitDataUnpackingCall(out, expr, intrinsic);
+    } else if (intrinsic->IsBarrier()) {
+      return EmitBarrierCall(out, intrinsic);
+    } else if (intrinsic->IsAtomic()) {
+      return EmitWorkgroupAtomicCall(out, expr, intrinsic);
+    }
+    auto name = generate_builtin_name(intrinsic);
+    if (name.empty()) {
+      return false;
+    }
+
+    out << name << "(";
+
+    bool first = true;
+    for (auto* param : params) {
+      if (!first) {
+        out << ", ";
+      }
+      first = false;
+
+      if (!EmitExpression(out, param)) {
+        return false;
+      }
+    }
+
+    out << ")";
+    return true;
+  }
+
+  auto name = builder_.Symbols().NameFor(ident->symbol());
+  auto caller_sym = ident->symbol();
+
+  auto* func = builder_.AST().Functions().Find(ident->symbol());
+  if (func == nullptr) {
+    diagnostics_.add_error(diag::System::Writer,
+                           "Unable to find function: " +
+                               builder_.Symbols().NameFor(ident->symbol()));
+    return false;
+  }
+
+  out << name << "(";
+
+  bool first = true;
+  for (auto* param : params) {
+    if (!first) {
+      out << ", ";
+    }
+    first = false;
+
+    if (!EmitExpression(out, param)) {
+      return false;
+    }
+  }
+
+  out << ")";
+
+  return true;
+}
+
+bool GeneratorImpl::EmitWorkgroupAtomicCall(std::ostream& out,
+                                            ast::CallExpression* expr,
+                                            const sem::Intrinsic* intrinsic) {
+  std::string result = UniqueIdentifier("atomic_result");
+
+  if (!intrinsic->ReturnType()->Is<sem::Void>()) {
+    auto pre = line();
+    if (!EmitTypeAndName(pre, intrinsic->ReturnType(), ast::StorageClass::kNone,
+                         ast::Access::kUndefined, result)) {
+      return false;
+    }
+    pre << " = ";
+    if (!EmitZeroValue(pre, intrinsic->ReturnType())) {
+      return false;
+    }
+    pre << ";";
+  }
+
+  auto call = [&](const char* name) {
+    auto pre = line();
+    pre << name;
+
+    {
+      ScopedParen sp(pre);
+      for (size_t i = 0; i < expr->params().size(); i++) {
+        auto* arg = expr->params()[i];
+        if (i > 0) {
+          pre << ", ";
+        }
+        if (!EmitExpression(pre, arg)) {
+          return false;
+        }
+      }
+
+      pre << ", " << result;
+    }
+
+    pre << ";";
+
+    out << result;
+    return true;
+  };
+
+  switch (intrinsic->Type()) {
+    case sem::IntrinsicType::kAtomicLoad: {
+      // GLSL does not have an InterlockedLoad, so we emulate it with
+      // InterlockedOr using 0 as the OR value
+      auto pre = line();
+      pre << "InterlockedOr";
+      {
+        ScopedParen sp(pre);
+        if (!EmitExpression(pre, expr->params()[0])) {
+          return false;
+        }
+        pre << ", 0, " << result;
+      }
+      pre << ";";
+
+      out << result;
+      return true;
+    }
+    case sem::IntrinsicType::kAtomicStore: {
+      // GLSL does not have an InterlockedStore, so we emulate it with
+      // InterlockedExchange and discard the returned value
+      {  // T result = 0;
+        auto pre = line();
+        auto* value_ty = intrinsic->Parameters()[1]->Type();
+        if (!EmitTypeAndName(pre, value_ty, ast::StorageClass::kNone,
+                             ast::Access::kUndefined, result)) {
+          return false;
+        }
+        pre << " = ";
+        if (!EmitZeroValue(pre, value_ty)) {
+          return false;
+        }
+        pre << ";";
+      }
+
+      out << "InterlockedExchange";
+      {
+        ScopedParen sp(out);
+        if (!EmitExpression(out, expr->params()[0])) {
+          return false;
+        }
+        out << ", ";
+        if (!EmitExpression(out, expr->params()[1])) {
+          return false;
+        }
+        out << ", " << result;
+      }
+      return true;
+    }
+    case sem::IntrinsicType::kAtomicCompareExchangeWeak: {
+      auto* dest = expr->params()[0];
+      auto* compare_value = expr->params()[1];
+      auto* value = expr->params()[2];
+
+      std::string compare = UniqueIdentifier("atomic_compare_value");
+
+      {  // T compare_value = <compare_value>;
+        auto pre = line();
+        if (!EmitTypeAndName(pre, TypeOf(compare_value),
+                             ast::StorageClass::kNone, ast::Access::kUndefined,
+                             compare)) {
+          return false;
+        }
+        pre << " = ";
+        if (!EmitExpression(pre, compare_value)) {
+          return false;
+        }
+        pre << ";";
+      }
+
+      {  // InterlockedCompareExchange(dst, compare, value, result.x);
+        auto pre = line();
+        pre << "InterlockedCompareExchange";
+        {
+          ScopedParen sp(pre);
+          if (!EmitExpression(pre, dest)) {
+            return false;
+          }
+          pre << ", " << compare << ", ";
+          if (!EmitExpression(pre, value)) {
+            return false;
+          }
+          pre << ", " << result << ".x";
+        }
+        pre << ";";
+      }
+
+      {  // result.y = result.x == compare;
+        line() << result << ".y = " << result << ".x == " << compare << ";";
+      }
+
+      out << result;
+      return true;
+    }
+
+    case sem::IntrinsicType::kAtomicAdd:
+    case sem::IntrinsicType::kAtomicSub:
+      return call("InterlockedAdd");
+
+    case sem::IntrinsicType::kAtomicMax:
+      return call("InterlockedMax");
+
+    case sem::IntrinsicType::kAtomicMin:
+      return call("InterlockedMin");
+
+    case sem::IntrinsicType::kAtomicAnd:
+      return call("InterlockedAnd");
+
+    case sem::IntrinsicType::kAtomicOr:
+      return call("InterlockedOr");
+
+    case sem::IntrinsicType::kAtomicXor:
+      return call("InterlockedXor");
+
+    case sem::IntrinsicType::kAtomicExchange:
+      return call("InterlockedExchange");
+
+    default:
+      break;
+  }
+
+  TINT_UNREACHABLE(Writer, diagnostics_)
+      << "unsupported atomic intrinsic: " << intrinsic->Type();
+  return false;
+}
+
+bool GeneratorImpl::EmitSelectCall(std::ostream& out,
+                                   ast::CallExpression* expr) {
+  auto* expr_false = expr->params()[0];
+  auto* expr_true = expr->params()[1];
+  auto* expr_cond = expr->params()[2];
+  ScopedParen paren(out);
+  if (!EmitExpression(out, expr_cond)) {
+    return false;
+  }
+
+  out << " ? ";
+
+  if (!EmitExpression(out, expr_true)) {
+    return false;
+  }
+
+  out << " : ";
+
+  if (!EmitExpression(out, expr_false)) {
+    return false;
+  }
+
+  return true;
+}
+
+bool GeneratorImpl::EmitModfCall(std::ostream& out,
+                                 ast::CallExpression* expr,
+                                 const sem::Intrinsic* intrinsic) {
+  if (expr->params().size() == 1) {
+    return CallIntrinsicHelper(
+        out, expr, intrinsic,
+        [&](TextBuffer* b, const std::vector<std::string>& params) {
+          auto* ty = intrinsic->Parameters()[0]->Type();
+          auto in = params[0];
+
+          std::string width;
+          if (auto* vec = ty->As<sem::Vector>()) {
+            width = std::to_string(vec->Width());
+          }
+
+          // Emit the builtin return type unique to this overload. This does not
+          // exist in the AST, so it will not be generated in Generate().
+          if (!EmitStructType(&helpers_,
+                              intrinsic->ReturnType()->As<sem::Struct>())) {
+            return false;
+          }
+
+          line(b) << "float" << width << " whole;";
+          line(b) << "float" << width << " fract = modf(" << in << ", whole);";
+          {
+            auto l = line(b);
+            if (!EmitType(l, intrinsic->ReturnType(), ast::StorageClass::kNone,
+                          ast::Access::kUndefined, "")) {
+              return false;
+            }
+            l << " result = {fract, whole};";
+          }
+          line(b) << "return result;";
+          return true;
+        });
+  }
+
+  // DEPRECATED
+  out << "modf";
+  ScopedParen sp(out);
+  if (!EmitExpression(out, expr->params()[0])) {
+    return false;
+  }
+  out << ", ";
+  if (!EmitExpression(out, expr->params()[1])) {
+    return false;
+  }
+  return true;
+}
+
+bool GeneratorImpl::EmitFrexpCall(std::ostream& out,
+                                  ast::CallExpression* expr,
+                                  const sem::Intrinsic* intrinsic) {
+  if (expr->params().size() == 1) {
+    return CallIntrinsicHelper(
+        out, expr, intrinsic,
+        [&](TextBuffer* b, const std::vector<std::string>& params) {
+          auto* ty = intrinsic->Parameters()[0]->Type();
+          auto in = params[0];
+
+          std::string width;
+          if (auto* vec = ty->As<sem::Vector>()) {
+            width = std::to_string(vec->Width());
+          }
+
+          // Emit the builtin return type unique to this overload. This does not
+          // exist in the AST, so it will not be generated in Generate().
+          if (!EmitStructType(&helpers_,
+                              intrinsic->ReturnType()->As<sem::Struct>())) {
+            return false;
+          }
+
+          line(b) << "float" << width << " exp;";
+          line(b) << "float" << width << " sig = frexp(" << in << ", exp);";
+          {
+            auto l = line(b);
+            if (!EmitType(l, intrinsic->ReturnType(), ast::StorageClass::kNone,
+                          ast::Access::kUndefined, "")) {
+              return false;
+            }
+            l << " result = {sig, int" << width << "(exp)};";
+          }
+          line(b) << "return result;";
+          return true;
+        });
+  }
+  // DEPRECATED
+  // Exponent is an integer in WGSL, but HLSL wants a float.
+  // We need to make the call with a temporary float, and then cast.
+  return CallIntrinsicHelper(
+      out, expr, intrinsic,
+      [&](TextBuffer* b, const std::vector<std::string>& params) {
+        auto* significand_ty = intrinsic->Parameters()[0]->Type();
+        auto significand = params[0];
+        auto* exponent_ty = intrinsic->Parameters()[1]->Type();
+        auto exponent = params[1];
+
+        std::string width;
+        if (auto* vec = significand_ty->As<sem::Vector>()) {
+          width = std::to_string(vec->Width());
+        }
+
+        // Exponent is an integer, which HLSL does not have an overload for.
+        // We need to cast from a float.
+        line(b) << "float" << width << " float_exp;";
+        line(b) << "float" << width << " significand = frexp(" << significand
+                << ", float_exp);";
+        {
+          auto l = line(b);
+          l << exponent << " = ";
+          if (!EmitType(l, exponent_ty->UnwrapPtr(), ast::StorageClass::kNone,
+                        ast::Access::kUndefined, "")) {
+            return false;
+          }
+          l << "(float_exp);";
+        }
+        line(b) << "return significand;";
+        return true;
+      });
+}
+
+bool GeneratorImpl::EmitIsNormalCall(std::ostream& out,
+                                     ast::CallExpression* expr,
+                                     const sem::Intrinsic* intrinsic) {
+  // GLSL doesn't have a isNormal intrinsic, we need to emulate
+  return CallIntrinsicHelper(
+      out, expr, intrinsic,
+      [&](TextBuffer* b, const std::vector<std::string>& params) {
+        auto* input_ty = intrinsic->Parameters()[0]->Type();
+
+        std::string width;
+        if (auto* vec = input_ty->As<sem::Vector>()) {
+          width = std::to_string(vec->Width());
+        }
+
+        constexpr auto* kExponentMask = "0x7f80000";
+        constexpr auto* kMinNormalExponent = "0x0080000";
+        constexpr auto* kMaxNormalExponent = "0x7f00000";
+
+        line(b) << "uint" << width << " exponent = asuint(" << params[0]
+                << ") & " << kExponentMask << ";";
+        line(b) << "uint" << width << " clamped = "
+                << "clamp(exponent, " << kMinNormalExponent << ", "
+                << kMaxNormalExponent << ");";
+        line(b) << "return clamped == exponent;";
+        return true;
+      });
+}
+
+bool GeneratorImpl::EmitDataPackingCall(std::ostream& out,
+                                        ast::CallExpression* expr,
+                                        const sem::Intrinsic* intrinsic) {
+  return CallIntrinsicHelper(
+      out, expr, intrinsic,
+      [&](TextBuffer* b, const std::vector<std::string>& params) {
+        uint32_t dims = 2;
+        bool is_signed = false;
+        uint32_t scale = 65535;
+        if (intrinsic->Type() == sem::IntrinsicType::kPack4x8snorm ||
+            intrinsic->Type() == sem::IntrinsicType::kPack4x8unorm) {
+          dims = 4;
+          scale = 255;
+        }
+        if (intrinsic->Type() == sem::IntrinsicType::kPack4x8snorm ||
+            intrinsic->Type() == sem::IntrinsicType::kPack2x16snorm) {
+          is_signed = true;
+          scale = (scale - 1) / 2;
+        }
+        switch (intrinsic->Type()) {
+          case sem::IntrinsicType::kPack4x8snorm:
+          case sem::IntrinsicType::kPack4x8unorm:
+          case sem::IntrinsicType::kPack2x16snorm:
+          case sem::IntrinsicType::kPack2x16unorm: {
+            {
+              auto l = line(b);
+              l << (is_signed ? "" : "u") << "int" << dims
+                << " i = " << (is_signed ? "" : "u") << "int" << dims
+                << "(round(clamp(" << params[0] << ", "
+                << (is_signed ? "-1.0" : "0.0") << ", 1.0) * " << scale
+                << ".0))";
+              if (is_signed) {
+                l << " & " << (dims == 4 ? "0xff" : "0xffff");
+              }
+              l << ";";
+            }
+            {
+              auto l = line(b);
+              l << "return ";
+              if (is_signed) {
+                l << "asuint";
+              }
+              l << "(i.x | i.y << " << (32 / dims);
+              if (dims == 4) {
+                l << " | i.z << 16 | i.w << 24";
+              }
+              l << ");";
+            }
+            break;
+          }
+          case sem::IntrinsicType::kPack2x16float: {
+            line(b) << "uint2 i = f32tof16(" << params[0] << ");";
+            line(b) << "return i.x | (i.y << 16);";
+            break;
+          }
+          default:
+            diagnostics_.add_error(
+                diag::System::Writer,
+                "Internal error: unhandled data packing intrinsic");
+            return false;
+        }
+
+        return true;
+      });
+}
+
+bool GeneratorImpl::EmitDataUnpackingCall(std::ostream& out,
+                                          ast::CallExpression* expr,
+                                          const sem::Intrinsic* intrinsic) {
+  return CallIntrinsicHelper(
+      out, expr, intrinsic,
+      [&](TextBuffer* b, const std::vector<std::string>& params) {
+        uint32_t dims = 2;
+        bool is_signed = false;
+        uint32_t scale = 65535;
+        if (intrinsic->Type() == sem::IntrinsicType::kUnpack4x8snorm ||
+            intrinsic->Type() == sem::IntrinsicType::kUnpack4x8unorm) {
+          dims = 4;
+          scale = 255;
+        }
+        if (intrinsic->Type() == sem::IntrinsicType::kUnpack4x8snorm ||
+            intrinsic->Type() == sem::IntrinsicType::kUnpack2x16snorm) {
+          is_signed = true;
+          scale = (scale - 1) / 2;
+        }
+        switch (intrinsic->Type()) {
+          case sem::IntrinsicType::kUnpack4x8snorm:
+          case sem::IntrinsicType::kUnpack2x16snorm: {
+            line(b) << "int j = int(" << params[0] << ");";
+            {  // Perform sign extension on the converted values.
+              auto l = line(b);
+              l << "int" << dims << " i = int" << dims << "(";
+              if (dims == 2) {
+                l << "j << 16, j) >> 16";
+              } else {
+                l << "j << 24, j << 16, j << 8, j) >> 24";
+              }
+              l << ";";
+            }
+            line(b) << "return clamp(float" << dims << "(i) / " << scale
+                    << ".0, " << (is_signed ? "-1.0" : "0.0") << ", 1.0);";
+            break;
+          }
+          case sem::IntrinsicType::kUnpack4x8unorm:
+          case sem::IntrinsicType::kUnpack2x16unorm: {
+            line(b) << "uint j = " << params[0] << ";";
+            {
+              auto l = line(b);
+              l << "uint" << dims << " i = uint" << dims << "(";
+              l << "j & " << (dims == 2 ? "0xffff" : "0xff") << ", ";
+              if (dims == 4) {
+                l << "(j >> " << (32 / dims)
+                  << ") & 0xff, (j >> 16) & 0xff, j >> 24";
+              } else {
+                l << "j >> " << (32 / dims);
+              }
+              l << ");";
+            }
+            line(b) << "return float" << dims << "(i) / " << scale << ".0;";
+            break;
+          }
+          case sem::IntrinsicType::kUnpack2x16float:
+            line(b) << "uint i = " << params[0] << ";";
+            line(b) << "return f16tof32(uint2(i & 0xffff, i >> 16));";
+            break;
+          default:
+            diagnostics_.add_error(
+                diag::System::Writer,
+                "Internal error: unhandled data packing intrinsic");
+            return false;
+        }
+
+        return true;
+      });
+}
+
+bool GeneratorImpl::EmitBarrierCall(std::ostream& out,
+                                    const sem::Intrinsic* intrinsic) {
+  // TODO(crbug.com/tint/661): Combine sequential barriers to a single
+  // instruction.
+  if (intrinsic->Type() == sem::IntrinsicType::kWorkgroupBarrier) {
+    out << "GroupMemoryBarrierWithGroupSync()";
+  } else if (intrinsic->Type() == sem::IntrinsicType::kStorageBarrier) {
+    out << "DeviceMemoryBarrierWithGroupSync()";
+  } else {
+    TINT_UNREACHABLE(Writer, diagnostics_)
+        << "unexpected barrier intrinsic type " << sem::str(intrinsic->Type());
+    return false;
+  }
+  return true;
+}
+
+bool GeneratorImpl::EmitTextureCall(std::ostream& out,
+                                    ast::CallExpression* expr,
+                                    const sem::Intrinsic* intrinsic) {
+  using Usage = sem::ParameterUsage;
+
+  auto parameters = intrinsic->Parameters();
+  auto arguments = expr->params();
+
+  // Returns the argument with the given usage
+  auto arg = [&](Usage usage) {
+    int idx = sem::IndexOf(parameters, usage);
+    return (idx >= 0) ? arguments[idx] : nullptr;
+  };
+
+  auto* texture = arg(Usage::kTexture);
+  if (!texture) {
+    TINT_ICE(Writer, diagnostics_) << "missing texture argument";
+    return false;
+  }
+
+  auto* texture_type = TypeOf(texture)->UnwrapRef()->As<sem::Texture>();
+
+  switch (intrinsic->Type()) {
+    case sem::IntrinsicType::kTextureDimensions: {
+      out << "textureSize(";
+      if (!EmitExpression(out, texture)) {
+        return false;
+      }
+
+      auto* level_arg = arg(Usage::kLevel);
+      if (level_arg) {
+        if (!EmitExpression(out, level_arg)) {
+          return false;
+        }
+      }
+      out << ");";
+      return true;
+    }
+    // TODO(senorblanco): determine if this works for array textures
+    case sem::IntrinsicType::kTextureNumLayers:
+    case sem::IntrinsicType::kTextureNumLevels: {
+      out << "textureQueryLevels(";
+      if (!EmitExpression(out, texture)) {
+        return false;
+      }
+      out << ");";
+      return true;
+    }
+    case sem::IntrinsicType::kTextureNumSamples: {
+      out << "textureSamples(";
+      if (!EmitExpression(out, texture)) {
+        return false;
+      }
+      out << ");";
+      return true;
+    }
+    default:
+      break;
+  }
+
+  if (!EmitExpression(out, texture))
+    return false;
+
+  // If pack_level_in_coords is true, then the mip level will be appended as the
+  // last value of the coordinates argument. If the WGSL intrinsic overload does
+  // not have a level parameter and pack_level_in_coords is true, then a zero
+  // mip level will be inserted.
+  bool pack_level_in_coords = false;
+
+  uint32_t glsl_ret_width = 4u;
+
+  switch (intrinsic->Type()) {
+    case sem::IntrinsicType::kTextureSample:
+      out << ".Sample(";
+      break;
+    case sem::IntrinsicType::kTextureSampleBias:
+      out << ".SampleBias(";
+      break;
+    case sem::IntrinsicType::kTextureSampleLevel:
+      out << ".SampleLevel(";
+      break;
+    case sem::IntrinsicType::kTextureSampleGrad:
+      out << ".SampleGrad(";
+      break;
+    case sem::IntrinsicType::kTextureSampleCompare:
+      out << ".SampleCmp(";
+      glsl_ret_width = 1;
+      break;
+    case sem::IntrinsicType::kTextureSampleCompareLevel:
+      out << ".SampleCmpLevelZero(";
+      glsl_ret_width = 1;
+      break;
+    case sem::IntrinsicType::kTextureLoad:
+      out << ".Load(";
+      // Multisampled textures do not support mip-levels.
+      if (!texture_type->Is<sem::MultisampledTexture>()) {
+        pack_level_in_coords = true;
+      }
+      break;
+    case sem::IntrinsicType::kTextureStore:
+      out << "[";
+      break;
+    default:
+      diagnostics_.add_error(
+          diag::System::Writer,
+          "Internal compiler error: Unhandled texture intrinsic '" +
+              std::string(intrinsic->str()) + "'");
+      return false;
+  }
+
+  if (auto* sampler = arg(Usage::kSampler)) {
+    if (!EmitExpression(out, sampler))
+      return false;
+    out << ", ";
+  }
+
+  auto* param_coords = arg(Usage::kCoords);
+  if (!param_coords) {
+    TINT_ICE(Writer, diagnostics_) << "missing coords argument";
+    return false;
+  }
+
+  auto emit_vector_appended_with_i32_zero = [&](tint::ast::Expression* vector) {
+    auto* i32 = builder_.create<sem::I32>();
+    auto* zero = builder_.Expr(0);
+    auto* stmt = builder_.Sem().Get(vector)->Stmt();
+    builder_.Sem().Add(zero, builder_.create<sem::Expression>(zero, i32, stmt,
+                                                              sem::Constant{}));
+    auto* packed = AppendVector(&builder_, vector, zero);
+    return EmitExpression(out, packed);
+  };
+
+  auto emit_vector_appended_with_level = [&](tint::ast::Expression* vector) {
+    if (auto* level = arg(Usage::kLevel)) {
+      auto* packed = AppendVector(&builder_, vector, level);
+      return EmitExpression(out, packed);
+    }
+    return emit_vector_appended_with_i32_zero(vector);
+  };
+
+  if (auto* array_index = arg(Usage::kArrayIndex)) {
+    // Array index needs to be appended to the coordinates.
+    auto* packed = AppendVector(&builder_, param_coords, array_index);
+    if (pack_level_in_coords) {
+      // Then mip level needs to be appended to the coordinates.
+      if (!emit_vector_appended_with_level(packed)) {
+        return false;
+      }
+    } else {
+      if (!EmitExpression(out, packed)) {
+        return false;
+      }
+    }
+  } else if (pack_level_in_coords) {
+    // Mip level needs to be appended to the coordinates.
+    if (!emit_vector_appended_with_level(param_coords)) {
+      return false;
+    }
+  } else {
+    if (!EmitExpression(out, param_coords)) {
+      return false;
+    }
+  }
+
+  for (auto usage : {Usage::kDepthRef, Usage::kBias, Usage::kLevel, Usage::kDdx,
+                     Usage::kDdy, Usage::kSampleIndex, Usage::kOffset}) {
+    if (usage == Usage::kLevel && pack_level_in_coords) {
+      continue;  // mip level already packed in coordinates.
+    }
+    if (auto* e = arg(usage)) {
+      out << ", ";
+      if (!EmitExpression(out, e)) {
+        return false;
+      }
+    }
+  }
+
+  if (intrinsic->Type() == sem::IntrinsicType::kTextureStore) {
+    out << "] = ";
+    if (!EmitExpression(out, arg(Usage::kValue))) {
+      return false;
+    }
+  } else {
+    out << ")";
+
+    // If the intrinsic return type does not match the number of elements of the
+    // GLSL intrinsic, we need to swizzle the expression to generate the correct
+    // number of components.
+    uint32_t wgsl_ret_width = 1;
+    if (auto* vec = intrinsic->ReturnType()->As<sem::Vector>()) {
+      wgsl_ret_width = vec->Width();
+    }
+    if (wgsl_ret_width < glsl_ret_width) {
+      out << ".";
+      for (uint32_t i = 0; i < wgsl_ret_width; i++) {
+        out << "xyz"[i];
+      }
+    }
+    if (wgsl_ret_width > glsl_ret_width) {
+      TINT_ICE(Writer, diagnostics_)
+          << "WGSL return width (" << wgsl_ret_width
+          << ") is wider than GLSL return width (" << glsl_ret_width << ") for "
+          << intrinsic->Type();
+      return false;
+    }
+  }
+
+  return true;
+}
+
+std::string GeneratorImpl::generate_builtin_name(
+    const sem::Intrinsic* intrinsic) {
+  switch (intrinsic->Type()) {
+    case sem::IntrinsicType::kAbs:
+    case sem::IntrinsicType::kAcos:
+    case sem::IntrinsicType::kAll:
+    case sem::IntrinsicType::kAny:
+    case sem::IntrinsicType::kAsin:
+    case sem::IntrinsicType::kAtan:
+    case sem::IntrinsicType::kAtan2:
+    case sem::IntrinsicType::kCeil:
+    case sem::IntrinsicType::kClamp:
+    case sem::IntrinsicType::kCos:
+    case sem::IntrinsicType::kCosh:
+    case sem::IntrinsicType::kCross:
+    case sem::IntrinsicType::kDeterminant:
+    case sem::IntrinsicType::kDistance:
+    case sem::IntrinsicType::kDot:
+    case sem::IntrinsicType::kExp:
+    case sem::IntrinsicType::kExp2:
+    case sem::IntrinsicType::kFloor:
+    case sem::IntrinsicType::kFrexp:
+    case sem::IntrinsicType::kLdexp:
+    case sem::IntrinsicType::kLength:
+    case sem::IntrinsicType::kLog:
+    case sem::IntrinsicType::kLog2:
+    case sem::IntrinsicType::kMax:
+    case sem::IntrinsicType::kMin:
+    case sem::IntrinsicType::kModf:
+    case sem::IntrinsicType::kNormalize:
+    case sem::IntrinsicType::kPow:
+    case sem::IntrinsicType::kReflect:
+    case sem::IntrinsicType::kRefract:
+    case sem::IntrinsicType::kRound:
+    case sem::IntrinsicType::kSign:
+    case sem::IntrinsicType::kSin:
+    case sem::IntrinsicType::kSinh:
+    case sem::IntrinsicType::kSqrt:
+    case sem::IntrinsicType::kStep:
+    case sem::IntrinsicType::kTan:
+    case sem::IntrinsicType::kTanh:
+    case sem::IntrinsicType::kTranspose:
+    case sem::IntrinsicType::kTrunc:
+      return intrinsic->str();
+    case sem::IntrinsicType::kCountOneBits:
+      return "countbits";
+    case sem::IntrinsicType::kDpdx:
+      return "ddx";
+    case sem::IntrinsicType::kDpdxCoarse:
+      return "ddx_coarse";
+    case sem::IntrinsicType::kDpdxFine:
+      return "ddx_fine";
+    case sem::IntrinsicType::kDpdy:
+      return "ddy";
+    case sem::IntrinsicType::kDpdyCoarse:
+      return "ddy_coarse";
+    case sem::IntrinsicType::kDpdyFine:
+      return "ddy_fine";
+    case sem::IntrinsicType::kFaceForward:
+      return "faceforward";
+    case sem::IntrinsicType::kFract:
+      return "frac";
+    case sem::IntrinsicType::kFma:
+      return "mad";
+    case sem::IntrinsicType::kFwidth:
+    case sem::IntrinsicType::kFwidthCoarse:
+    case sem::IntrinsicType::kFwidthFine:
+      return "fwidth";
+    case sem::IntrinsicType::kInverseSqrt:
+      return "rsqrt";
+    case sem::IntrinsicType::kIsFinite:
+      return "isfinite";
+    case sem::IntrinsicType::kIsInf:
+      return "isinf";
+    case sem::IntrinsicType::kIsNan:
+      return "isnan";
+    case sem::IntrinsicType::kMix:
+      return "lerp";
+    case sem::IntrinsicType::kReverseBits:
+      return "reversebits";
+    case sem::IntrinsicType::kSmoothStep:
+      return "smoothstep";
+    default:
+      diagnostics_.add_error(
+          diag::System::Writer,
+          "Unknown builtin method: " + std::string(intrinsic->str()));
+  }
+
+  return "";
+}
+
+bool GeneratorImpl::EmitCase(ast::CaseStatement* stmt) {
+  if (stmt->IsDefault()) {
+    line() << "default: {";
+  } else {
+    for (auto* selector : stmt->selectors()) {
+      auto out = line();
+      out << "case ";
+      if (!EmitLiteral(out, selector)) {
+        return false;
+      }
+      out << ":";
+      if (selector == stmt->selectors().back()) {
+        out << " {";
+      }
+    }
+  }
+
+  {
+    ScopedIndent si(this);
+    if (!EmitStatements(stmt->body()->statements())) {
+      return false;
+    }
+    if (!last_is_break_or_fallthrough(stmt->body())) {
+      line() << "break;";
+    }
+  }
+
+  line() << "}";
+
+  return true;
+}
+
+bool GeneratorImpl::EmitConstructor(std::ostream& out,
+                                    ast::ConstructorExpression* expr) {
+  if (auto* scalar = expr->As<ast::ScalarConstructorExpression>()) {
+    return EmitScalarConstructor(out, scalar);
+  }
+  return EmitTypeConstructor(out, expr->As<ast::TypeConstructorExpression>());
+}
+
+bool GeneratorImpl::EmitScalarConstructor(
+    std::ostream& out,
+    ast::ScalarConstructorExpression* expr) {
+  return EmitLiteral(out, expr->literal());
+}
+
+bool GeneratorImpl::EmitTypeConstructor(std::ostream& out,
+                                        ast::TypeConstructorExpression* expr) {
+  auto* type = TypeOf(expr)->UnwrapRef();
+
+  // If the type constructor is empty then we need to construct with the zero
+  // value for all components.
+  if (expr->values().empty()) {
+    return EmitZeroValue(out, type);
+  }
+
+  // For single-value vector initializers, swizzle the scalar to the right
+  // vector dimension using .x
+  const bool is_single_value_vector_init =
+      type->is_scalar_vector() && expr->values().size() == 1 &&
+      TypeOf(expr->values()[0])->UnwrapRef()->is_scalar();
+
+  auto it = structure_builders_.find(As<sem::Struct>(type));
+  if (it != structure_builders_.end()) {
+    out << it->second << "(";
+  } else {
+    if (!EmitType(out, type, ast::StorageClass::kNone, ast::Access::kReadWrite,
+                  "")) {
+      return false;
+    }
+    out << "(";
+  }
+
+  if (is_single_value_vector_init) {
+    out << "(";
+  }
+
+  bool first = true;
+  for (auto* e : expr->values()) {
+    if (!first) {
+      out << ", ";
+    }
+    first = false;
+
+    if (!EmitExpression(out, e)) {
+      return false;
+    }
+  }
+
+  if (is_single_value_vector_init) {
+    out << ")." << std::string(type->As<sem::Vector>()->Width(), 'x');
+  }
+
+  out << ")";
+  return true;
+}
+
+bool GeneratorImpl::EmitContinue(ast::ContinueStatement*) {
+  if (!emit_continuing_()) {
+    return false;
+  }
+  line() << "continue;";
+  return true;
+}
+
+bool GeneratorImpl::EmitDiscard(ast::DiscardStatement*) {
+  // TODO(dsinclair): Verify this is correct when the discard semantics are
+  // defined for WGSL (https://github.com/gpuweb/gpuweb/issues/361)
+  line() << "discard;";
+  return true;
+}
+
+bool GeneratorImpl::EmitExpression(std::ostream& out, ast::Expression* expr) {
+  if (auto* a = expr->As<ast::ArrayAccessorExpression>()) {
+    return EmitArrayAccessor(out, a);
+  }
+  if (auto* b = expr->As<ast::BinaryExpression>()) {
+    return EmitBinary(out, b);
+  }
+  if (auto* b = expr->As<ast::BitcastExpression>()) {
+    return EmitBitcast(out, b);
+  }
+  if (auto* c = expr->As<ast::CallExpression>()) {
+    return EmitCall(out, c);
+  }
+  if (auto* c = expr->As<ast::ConstructorExpression>()) {
+    return EmitConstructor(out, c);
+  }
+  if (auto* i = expr->As<ast::IdentifierExpression>()) {
+    return EmitIdentifier(out, i);
+  }
+  if (auto* m = expr->As<ast::MemberAccessorExpression>()) {
+    return EmitMemberAccessor(out, m);
+  }
+  if (auto* u = expr->As<ast::UnaryOpExpression>()) {
+    return EmitUnaryOp(out, u);
+  }
+
+  diagnostics_.add_error(diag::System::Writer,
+                         "unknown expression type: " + builder_.str(expr));
+  return false;
+}
+
+bool GeneratorImpl::EmitIdentifier(std::ostream& out,
+                                   ast::IdentifierExpression* expr) {
+  out << builder_.Symbols().NameFor(expr->symbol());
+  return true;
+}
+
+bool GeneratorImpl::EmitIf(ast::IfStatement* stmt) {
+  {
+    auto out = line();
+    out << "if (";
+    if (!EmitExpression(out, stmt->condition())) {
+      return false;
+    }
+    out << ") {";
+  }
+
+  if (!EmitStatementsWithIndent(stmt->body()->statements())) {
+    return false;
+  }
+
+  for (auto* e : stmt->else_statements()) {
+    if (e->HasCondition()) {
+      line() << "} else {";
+      increment_indent();
+
+      {
+        auto out = line();
+        out << "if (";
+        if (!EmitExpression(out, e->condition())) {
+          return false;
+        }
+        out << ") {";
+      }
+    } else {
+      line() << "} else {";
+    }
+
+    if (!EmitStatementsWithIndent(e->body()->statements())) {
+      return false;
+    }
+  }
+
+  line() << "}";
+
+  for (auto* e : stmt->else_statements()) {
+    if (e->HasCondition()) {
+      decrement_indent();
+      line() << "}";
+    }
+  }
+  return true;
+}
+
+bool GeneratorImpl::EmitFunction(ast::Function* func) {
+  auto* sem = builder_.Sem().Get(func);
+
+  if (ast::HasDecoration<ast::InternalDecoration>(func->decorations())) {
+    // An internal function. Do not emit.
+    return true;
+  }
+
+  {
+    auto out = line();
+    auto name = builder_.Symbols().NameFor(func->symbol());
+    // If the function returns an array, then we need to declare a typedef for
+    // this.
+    if (sem->ReturnType()->Is<sem::Array>()) {
+      auto typedef_name = UniqueIdentifier(name + "_ret");
+      auto pre = line();
+      pre << "typedef ";
+      if (!EmitTypeAndName(pre, sem->ReturnType(), ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, typedef_name)) {
+        return false;
+      }
+      pre << ";";
+      out << typedef_name;
+    } else {
+      if (!EmitType(out, sem->ReturnType(), ast::StorageClass::kNone,
+                    ast::Access::kReadWrite, "")) {
+        return false;
+      }
+    }
+
+    out << " " << name << "(";
+
+    bool first = true;
+
+    for (auto* v : sem->Parameters()) {
+      if (!first) {
+        out << ", ";
+      }
+      first = false;
+
+      auto const* type = v->Type();
+
+      if (auto* ptr = type->As<sem::Pointer>()) {
+        // Transform pointer parameters in to `inout` parameters.
+        // The WGSL spec is highly restrictive in what can be passed in pointer
+        // parameters, which allows for this transformation. See:
+        // https://gpuweb.github.io/gpuweb/wgsl/#function-restriction
+        out << "inout ";
+        type = ptr->StoreType();
+      }
+
+      // Note: WGSL only allows for StorageClass::kNone on parameters, however
+      // the sanitizer transforms generates load / store functions for storage
+      // or uniform buffers. These functions have a buffer parameter with
+      // StorageClass::kStorage or StorageClass::kUniform. This is required to
+      // correctly translate the parameter to a [RW]ByteAddressBuffer for
+      // storage buffers and a uint4[N] for uniform buffers.
+      if (!EmitTypeAndName(
+              out, type, v->StorageClass(), v->Access(),
+              builder_.Symbols().NameFor(v->Declaration()->symbol()))) {
+        return false;
+      }
+    }
+    out << ") {";
+  }
+
+  if (!EmitStatementsWithIndent(func->body()->statements())) {
+    return false;
+  }
+
+  line() << "}";
+
+  return true;
+}
+
+bool GeneratorImpl::EmitGlobalVariable(ast::Variable* global) {
+  if (global->is_const()) {
+    return EmitProgramConstVariable(global);
+  }
+
+  auto* sem = builder_.Sem().Get(global);
+  switch (sem->StorageClass()) {
+    case ast::StorageClass::kUniform:
+      return EmitUniformVariable(sem);
+    case ast::StorageClass::kStorage:
+      return EmitStorageVariable(sem);
+    case ast::StorageClass::kUniformConstant:
+      return EmitHandleVariable(sem);
+    case ast::StorageClass::kPrivate:
+      return EmitPrivateVariable(sem);
+    case ast::StorageClass::kWorkgroup:
+      return EmitWorkgroupVariable(sem);
+    default:
+      break;
+  }
+
+  TINT_ICE(Writer, diagnostics_)
+      << "unhandled storage class " << sem->StorageClass();
+  return false;
+}
+
+bool GeneratorImpl::EmitUniformVariable(const sem::Variable* var) {
+  auto* decl = var->Declaration();
+  auto* type = var->Type()->UnwrapRef();
+  auto out = line();
+  if (!EmitTypeAndName(out, type, ast::StorageClass::kUniform, var->Access(),
+                       builder_.Symbols().NameFor(decl->symbol()))) {
+    return false;
+  }
+  out << ";";
+
+  return true;
+}
+
+bool GeneratorImpl::EmitStorageVariable(const sem::Variable* var) {
+  auto* decl = var->Declaration();
+  auto* type = var->Type()->UnwrapRef();
+  auto out = line();
+  if (!EmitTypeAndName(out, type, ast::StorageClass::kStorage, var->Access(),
+                       builder_.Symbols().NameFor(decl->symbol()))) {
+    return false;
+  }
+
+  out << RegisterAndSpace(var->Access() == ast::Access::kRead ? 't' : 'u',
+                          decl->binding_point())
+      << ";";
+
+  return true;
+}
+
+bool GeneratorImpl::EmitHandleVariable(const sem::Variable* var) {
+  auto* decl = var->Declaration();
+  auto* unwrapped_type = var->Type()->UnwrapRef();
+  auto out = line();
+
+  auto name = builder_.Symbols().NameFor(decl->symbol());
+  auto* type = var->Type()->UnwrapRef();
+  if (!EmitTypeAndName(out, type, var->StorageClass(), var->Access(), name)) {
+    return false;
+  }
+
+  const char* register_space = nullptr;
+
+  if (unwrapped_type->Is<sem::Texture>()) {
+    register_space = "t";
+    if (auto* storage_tex = unwrapped_type->As<sem::StorageTexture>()) {
+      if (storage_tex->access() != ast::Access::kRead) {
+        register_space = "u";
+      }
+    }
+  } else if (unwrapped_type->Is<sem::Sampler>()) {
+    register_space = "s";
+  }
+
+  if (register_space) {
+    auto bp = decl->binding_point();
+    out << " : register(" << register_space << bp.binding->value() << ", space"
+        << bp.group->value() << ")";
+  }
+
+  out << ";";
+  return true;
+}
+
+bool GeneratorImpl::EmitPrivateVariable(const sem::Variable* var) {
+  auto* decl = var->Declaration();
+  auto out = line();
+
+  out << "static ";
+
+  auto name = builder_.Symbols().NameFor(decl->symbol());
+  auto* type = var->Type()->UnwrapRef();
+  if (!EmitTypeAndName(out, type, var->StorageClass(), var->Access(), name)) {
+    return false;
+  }
+
+  out << " = ";
+  if (auto* constructor = decl->constructor()) {
+    if (!EmitExpression(out, constructor)) {
+      return false;
+    }
+  } else {
+    if (!EmitZeroValue(out, var->Type()->UnwrapRef())) {
+      return false;
+    }
+  }
+
+  out << ";";
+  return true;
+}
+
+bool GeneratorImpl::EmitWorkgroupVariable(const sem::Variable* var) {
+  auto* decl = var->Declaration();
+  auto out = line();
+
+  out << "groupshared ";
+
+  auto name = builder_.Symbols().NameFor(decl->symbol());
+  auto* type = var->Type()->UnwrapRef();
+  if (!EmitTypeAndName(out, type, var->StorageClass(), var->Access(), name)) {
+    return false;
+  }
+
+  if (auto* constructor = decl->constructor()) {
+    out << " = ";
+    if (!EmitExpression(out, constructor)) {
+      return false;
+    }
+  }
+
+  out << ";";
+  return true;
+}
+
+sem::Type* GeneratorImpl::builtin_type(ast::Builtin builtin) {
+  switch (builtin) {
+    case ast::Builtin::kPosition: {
+      auto* f32 = builder_.create<sem::F32>();
+      return builder_.create<sem::Vector>(f32, 4);
+    }
+    case ast::Builtin::kVertexIndex:
+    case ast::Builtin::kInstanceIndex: {
+      return builder_.create<sem::I32>();
+    }
+    case ast::Builtin::kFrontFacing: {
+      return builder_.create<sem::Bool>();
+    }
+    case ast::Builtin::kFragDepth: {
+      return builder_.create<sem::F32>();
+    }
+    case ast::Builtin::kLocalInvocationId:
+    case ast::Builtin::kGlobalInvocationId:
+    case ast::Builtin::kWorkgroupId: {
+      auto* u32 = builder_.create<sem::U32>();
+      return builder_.create<sem::Vector>(u32, 3);
+    }
+    case ast::Builtin::kSampleIndex: {
+      return builder_.create<sem::I32>();
+    }
+    case ast::Builtin::kSampleMask:
+    default:
+      return nullptr;
+  }
+}
+
+const char* GeneratorImpl::builtin_to_string(ast::Builtin builtin) const {
+  switch (builtin) {
+    case ast::Builtin::kPosition:
+      return "gl_Position";
+    case ast::Builtin::kVertexIndex:
+      return "gl_VertexID";
+    case ast::Builtin::kInstanceIndex:
+      return "gl_InstanceID";
+    case ast::Builtin::kFrontFacing:
+      return "gl_FrontFacing";
+    case ast::Builtin::kFragDepth:
+      return "gl_FragDepth";
+    case ast::Builtin::kLocalInvocationId:
+      return "gl_LocalInvocationID";
+    case ast::Builtin::kLocalInvocationIndex:
+      return "gl_LocalInvocationIndex";
+    case ast::Builtin::kGlobalInvocationId:
+      return "gl_GlobalInvocationID";
+    case ast::Builtin::kWorkgroupId:
+      return "gl_WorkGroupID";
+    case ast::Builtin::kSampleIndex:
+      return "gl_SampleID";
+    case ast::Builtin::kSampleMask:
+      // FIXME: is this always available?
+      return "gl_SampleMask";
+    default:
+      return "";
+  }
+}
+
+std::string GeneratorImpl::interpolation_to_modifiers(
+    ast::InterpolationType type,
+    ast::InterpolationSampling sampling) const {
+  std::string modifiers;
+  switch (type) {
+    case ast::InterpolationType::kPerspective:
+      modifiers += "linear ";
+      break;
+    case ast::InterpolationType::kLinear:
+      modifiers += "noperspective ";
+      break;
+    case ast::InterpolationType::kFlat:
+      modifiers += "nointerpolation ";
+      break;
+  }
+  switch (sampling) {
+    case ast::InterpolationSampling::kCentroid:
+      modifiers += "centroid ";
+      break;
+    case ast::InterpolationSampling::kSample:
+      modifiers += "sample ";
+      break;
+    case ast::InterpolationSampling::kCenter:
+    case ast::InterpolationSampling::kNone:
+      break;
+  }
+  return modifiers;
+}
+
+bool GeneratorImpl::EmitEntryPointFunction(ast::Function* func) {
+  auto* func_sem = builder_.Sem().Get(func);
+
+  {
+    auto out = line();
+    if (func->pipeline_stage() == ast::PipelineStage::kCompute) {
+      // Emit the workgroup_size attribute.
+      auto wgsize = func_sem->workgroup_size();
+      out << "[numthreads(";
+      for (int i = 0; i < 3; i++) {
+        if (i > 0) {
+          out << ", ";
+        }
+
+        if (wgsize[i].overridable_const) {
+          auto* global = builder_.Sem().Get<sem::GlobalVariable>(
+              wgsize[i].overridable_const);
+          if (!global->IsPipelineConstant()) {
+            TINT_ICE(Writer, builder_.Diagnostics())
+                << "expected a pipeline-overridable constant";
+          }
+          out << kSpecConstantPrefix << global->ConstantId();
+        } else {
+          out << std::to_string(wgsize[i].value);
+        }
+      }
+      out << ")]" << std::endl;
+    }
+
+    out << func->return_type()->FriendlyName(builder_.Symbols());
+
+    out << " " << builder_.Symbols().NameFor(func->symbol()) << "(";
+
+    bool first = true;
+
+    // Emit entry point parameters.
+    for (auto* var : func->params()) {
+      auto* sem = builder_.Sem().Get(var);
+      auto* type = sem->Type();
+      if (!type->Is<sem::Struct>()) {
+        // ICE likely indicates that the CanonicalizeEntryPointIO transform was
+        // not run, or a builtin parameter was added after it was run.
+        TINT_ICE(Writer, diagnostics_)
+            << "Unsupported non-struct entry point parameter";
+      }
+
+      if (!first) {
+        out << ", ";
+      }
+      first = false;
+
+      if (!EmitTypeAndName(out, type, sem->StorageClass(), sem->Access(),
+                           builder_.Symbols().NameFor(var->symbol()))) {
+        return false;
+      }
+    }
+
+    out << ") {";
+  }
+
+  {
+    ScopedIndent si(this);
+
+    if (!EmitStatements(func->body()->statements())) {
+      return false;
+    }
+
+    if (!Is<ast::ReturnStatement>(func->get_last_statement())) {
+      ast::ReturnStatement ret(ProgramID(), Source{});
+      if (!EmitStatement(&ret)) {
+        return false;
+      }
+    }
+  }
+
+  line() << "}";
+
+  auto out = line();
+
+  // Declare entry point input variables
+  for (auto* var : func->params()) {
+    auto* sem = builder_.Sem().Get(var);
+    auto* str = sem->Type()->As<sem::Struct>();
+    for (auto* member : str->Members()) {
+      if (ast::HasDecoration<ast::BuiltinDecoration>(
+              member->Declaration()->decorations())) {
+        continue;
+      }
+      if (!EmitTypeAndName(
+              out, member->Type(), ast::StorageClass::kInput,
+              ast::Access::kReadWrite,
+              builder_.Symbols().NameFor(member->Declaration()->symbol()))) {
+        return false;
+      }
+      out << ";" << std::endl;
+    }
+  }
+
+  // Declare entry point output variables
+  auto* return_type = func_sem->ReturnType()->As<sem::Struct>();
+  if (return_type) {
+    for (auto* member : return_type->Members()) {
+      if (ast::HasDecoration<ast::BuiltinDecoration>(
+              member->Declaration()->decorations())) {
+        continue;
+      }
+      if (!EmitTypeAndName(
+              out, member->Type(), ast::StorageClass::kOutput,
+              ast::Access::kReadWrite,
+              builder_.Symbols().NameFor(member->Declaration()->symbol()))) {
+        return false;
+      }
+      out << ";" << std::endl;
+    }
+  }
+
+  // Create a main() function which calls the entry point.
+  out << "void main() {" << std::endl;
+  std::string printed_name;
+  for (auto* var : func->params()) {
+    out << "  ";
+    auto* sem = builder_.Sem().Get(var);
+    if (!EmitTypeAndName(out, sem->Type(), sem->StorageClass(), sem->Access(),
+                         "inputs")) {
+      return false;
+    }
+    out << ";" << std::endl;
+    auto* type = sem->Type();
+    auto* str = type->As<sem::Struct>();
+    for (auto* member : str->Members()) {
+      std::string name =
+          builder_.Symbols().NameFor(member->Declaration()->symbol());
+      out << "  inputs." << name << " = ";
+      if (auto* builtin = ast::GetDecoration<ast::BuiltinDecoration>(
+              member->Declaration()->decorations())) {
+        if (builtin_type(builtin->value()) != member->Type()) {
+          if (!EmitType(out, member->Type(), ast::StorageClass::kNone,
+                        ast::Access::kReadWrite, "")) {
+            return false;
+          }
+          out << "(";
+          out << builtin_to_string(builtin->value());
+          out << ")";
+        } else {
+          out << builtin_to_string(builtin->value());
+        }
+      } else {
+        out << name;
+      }
+      out << ";" << std::endl;
+    }
+  }
+  out << "  ";
+  if (return_type) {
+    out << return_type->FriendlyName(builder_.Symbols()) << " "
+        << "outputs;" << std::endl;
+    out << "  outputs = ";
+  }
+  out << builder_.Symbols().NameFor(func->symbol());
+  if (func->params().empty()) {
+    out << "()";
+  } else {
+    out << "(inputs)";
+  }
+  out << ";" << std::endl;
+
+  auto* str = func_sem->ReturnType()->As<sem::Struct>();
+  if (str) {
+    for (auto* member : str->Members()) {
+      std::string name =
+          builder_.Symbols().NameFor(member->Declaration()->symbol());
+      out << "  ";
+      if (auto* builtin = ast::GetDecoration<ast::BuiltinDecoration>(
+              member->Declaration()->decorations())) {
+        out << builtin_to_string(builtin->value());
+      } else {
+        out << name;
+      }
+      out << " = outputs." << name << ";" << std::endl;
+    }
+  }
+
+  out << "}" << std::endl << std::endl;
+
+  return true;
+}
+
+bool GeneratorImpl::EmitLiteral(std::ostream& out, ast::Literal* lit) {
+  if (auto* l = lit->As<ast::BoolLiteral>()) {
+    out << (l->IsTrue() ? "true" : "false");
+  } else if (auto* fl = lit->As<ast::FloatLiteral>()) {
+    if (std::isinf(fl->value())) {
+      out << (fl->value() >= 0 ? "asfloat(0x7f800000u)"
+                               : "asfloat(0xff800000u)");
+    } else if (std::isnan(fl->value())) {
+      out << "asfloat(0x7fc00000u)";
+    } else {
+      out << FloatToString(fl->value()) << "f";
+    }
+  } else if (auto* sl = lit->As<ast::SintLiteral>()) {
+    out << sl->value();
+  } else if (auto* ul = lit->As<ast::UintLiteral>()) {
+    out << ul->value() << "u";
+  } else {
+    diagnostics_.add_error(diag::System::Writer, "unknown literal type");
+    return false;
+  }
+  return true;
+}
+
+bool GeneratorImpl::EmitZeroValue(std::ostream& out, const sem::Type* type) {
+  if (type->Is<sem::Bool>()) {
+    out << "false";
+  } else if (type->Is<sem::F32>()) {
+    out << "0.0f";
+  } else if (type->Is<sem::I32>()) {
+    out << "0";
+  } else if (type->Is<sem::U32>()) {
+    out << "0u";
+  } else if (auto* vec = type->As<sem::Vector>()) {
+    if (!EmitType(out, type, ast::StorageClass::kNone, ast::Access::kReadWrite,
+                  "")) {
+      return false;
+    }
+    ScopedParen sp(out);
+    for (uint32_t i = 0; i < vec->Width(); i++) {
+      if (i != 0) {
+        out << ", ";
+      }
+      if (!EmitZeroValue(out, vec->type())) {
+        return false;
+      }
+    }
+  } else if (auto* mat = type->As<sem::Matrix>()) {
+    if (!EmitType(out, type, ast::StorageClass::kNone, ast::Access::kReadWrite,
+                  "")) {
+      return false;
+    }
+    ScopedParen sp(out);
+    for (uint32_t i = 0; i < (mat->rows() * mat->columns()); i++) {
+      if (i != 0) {
+        out << ", ";
+      }
+      if (!EmitZeroValue(out, mat->type())) {
+        return false;
+      }
+    }
+  } else if (auto* str = type->As<sem::Struct>()) {
+    if (!EmitType(out, type, ast::StorageClass::kNone, ast::Access::kUndefined,
+                  "")) {
+      return false;
+    }
+    bool first = true;
+    out << "(";
+    for (auto* member : str->Members()) {
+      if (!first) {
+        out << ", ";
+      } else {
+        first = false;
+      }
+      EmitZeroValue(out, member->Type());
+    }
+    out << ")";
+  } else if (auto* array = type->As<sem::Array>()) {
+    if (!EmitType(out, type, ast::StorageClass::kNone, ast::Access::kUndefined,
+                  "")) {
+      return false;
+    }
+    out << "(";
+    for (uint32_t i = 0; i < array->Count(); i++) {
+      if (i != 0) {
+        out << ", ";
+      }
+      EmitZeroValue(out, array->ElemType());
+    }
+    out << ")";
+  } else {
+    diagnostics_.add_error(
+        diag::System::Writer,
+        "Invalid type for zero emission: " + type->type_name());
+    return false;
+  }
+  return true;
+}
+
+bool GeneratorImpl::EmitLoop(ast::LoopStatement* stmt) {
+  auto emit_continuing = [this, stmt]() {
+    if (stmt->has_continuing()) {
+      if (!EmitBlock(stmt->continuing())) {
+        return false;
+      }
+    }
+    return true;
+  };
+
+  TINT_SCOPED_ASSIGNMENT(emit_continuing_, emit_continuing);
+  line() << "while (true) {";
+  {
+    ScopedIndent si(this);
+    if (!EmitStatements(stmt->body()->statements())) {
+      return false;
+    }
+    if (!emit_continuing()) {
+      return false;
+    }
+  }
+  line() << "}";
+
+  return true;
+}
+
+bool GeneratorImpl::EmitForLoop(ast::ForLoopStatement* stmt) {
+  // Nest a for loop with a new block. In HLSL the initializer scope is not
+  // nested by the for-loop, so we may get variable redefinitions.
+  line() << "{";
+  increment_indent();
+  TINT_DEFER({
+    decrement_indent();
+    line() << "}";
+  });
+
+  TextBuffer init_buf;
+  if (auto* init = stmt->initializer()) {
+    TINT_SCOPED_ASSIGNMENT(current_buffer_, &init_buf);
+    if (!EmitStatement(init)) {
+      return false;
+    }
+  }
+
+  TextBuffer cond_pre;
+  std::stringstream cond_buf;
+  if (auto* cond = stmt->condition()) {
+    TINT_SCOPED_ASSIGNMENT(current_buffer_, &cond_pre);
+    if (!EmitExpression(cond_buf, cond)) {
+      return false;
+    }
+  }
+
+  TextBuffer cont_buf;
+  if (auto* cont = stmt->continuing()) {
+    TINT_SCOPED_ASSIGNMENT(current_buffer_, &cont_buf);
+    if (!EmitStatement(cont)) {
+      return false;
+    }
+  }
+
+  // If the for-loop has a multi-statement conditional and / or continuing, then
+  // we cannot emit this as a regular for-loop in HLSL. Instead we need to
+  // generate a `while(true)` loop.
+  bool emit_as_loop = cond_pre.lines.size() > 0 || cont_buf.lines.size() > 1;
+
+  // If the for-loop has multi-statement initializer, or is going to be emitted
+  // as a `while(true)` loop, then declare the initializer statement(s) before
+  // the loop.
+  if (init_buf.lines.size() > 1 || (stmt->initializer() && emit_as_loop)) {
+    current_buffer_->Append(init_buf);
+    init_buf.lines.clear();  // Don't emit the initializer again in the 'for'
+  }
+
+  if (emit_as_loop) {
+    auto emit_continuing = [&]() {
+      current_buffer_->Append(cont_buf);
+      return true;
+    };
+
+    TINT_SCOPED_ASSIGNMENT(emit_continuing_, emit_continuing);
+    line() << "while (true) {";
+    increment_indent();
+    TINT_DEFER({
+      decrement_indent();
+      line() << "}";
+    });
+
+    if (stmt->condition()) {
+      current_buffer_->Append(cond_pre);
+      line() << "if (!(" << cond_buf.str() << ")) { break; }";
+    }
+
+    if (!EmitStatements(stmt->body()->statements())) {
+      return false;
+    }
+
+    if (!emit_continuing()) {
+      return false;
+    }
+  } else {
+    // For-loop can be generated.
+    {
+      auto out = line();
+      out << "for";
+      {
+        ScopedParen sp(out);
+
+        if (!init_buf.lines.empty()) {
+          out << init_buf.lines[0].content << " ";
+        } else {
+          out << "; ";
+        }
+
+        out << cond_buf.str() << "; ";
+
+        if (!cont_buf.lines.empty()) {
+          out << TrimSuffix(cont_buf.lines[0].content, ";");
+        }
+      }
+      out << " {";
+    }
+    {
+      auto emit_continuing = [] { return true; };
+      TINT_SCOPED_ASSIGNMENT(emit_continuing_, emit_continuing);
+      if (!EmitStatementsWithIndent(stmt->body()->statements())) {
+        return false;
+      }
+    }
+    line() << "}";
+  }
+
+  return true;
+}
+
+bool GeneratorImpl::EmitMemberAccessor(std::ostream& out,
+                                       ast::MemberAccessorExpression* expr) {
+  if (!EmitExpression(out, expr->structure())) {
+    return false;
+  }
+  out << ".";
+
+  // Swizzles output the name directly
+  if (builder_.Sem().Get(expr)->Is<sem::Swizzle>()) {
+    out << builder_.Symbols().NameFor(expr->member()->symbol());
+  } else if (!EmitExpression(out, expr->member())) {
+    return false;
+  }
+
+  return true;
+}
+
+bool GeneratorImpl::EmitReturn(ast::ReturnStatement* stmt) {
+  if (stmt->has_value()) {
+    auto out = line();
+    out << "return ";
+    if (!EmitExpression(out, stmt->value())) {
+      return false;
+    }
+    out << ";";
+  } else {
+    line() << "return;";
+  }
+  return true;
+}
+
+bool GeneratorImpl::EmitStatement(ast::Statement* stmt) {
+  if (auto* a = stmt->As<ast::AssignmentStatement>()) {
+    return EmitAssign(a);
+  }
+  if (auto* b = stmt->As<ast::BlockStatement>()) {
+    return EmitBlock(b);
+  }
+  if (auto* b = stmt->As<ast::BreakStatement>()) {
+    return EmitBreak(b);
+  }
+  if (auto* c = stmt->As<ast::CallStatement>()) {
+    auto out = line();
+    if (!TypeOf(c->expr())->Is<sem::Void>()) {
+      out << "(void) ";
+    }
+    if (!EmitCall(out, c->expr())) {
+      return false;
+    }
+    out << ";";
+    return true;
+  }
+  if (auto* c = stmt->As<ast::ContinueStatement>()) {
+    return EmitContinue(c);
+  }
+  if (auto* d = stmt->As<ast::DiscardStatement>()) {
+    return EmitDiscard(d);
+  }
+  if (stmt->As<ast::FallthroughStatement>()) {
+    line() << "/* fallthrough */";
+    return true;
+  }
+  if (auto* i = stmt->As<ast::IfStatement>()) {
+    return EmitIf(i);
+  }
+  if (auto* l = stmt->As<ast::LoopStatement>()) {
+    return EmitLoop(l);
+  }
+  if (auto* l = stmt->As<ast::ForLoopStatement>()) {
+    return EmitForLoop(l);
+  }
+  if (auto* r = stmt->As<ast::ReturnStatement>()) {
+    return EmitReturn(r);
+  }
+  if (auto* s = stmt->As<ast::SwitchStatement>()) {
+    return EmitSwitch(s);
+  }
+  if (auto* v = stmt->As<ast::VariableDeclStatement>()) {
+    return EmitVariable(v->variable());
+  }
+
+  diagnostics_.add_error(diag::System::Writer,
+                         "unknown statement type: " + builder_.str(stmt));
+  return false;
+}
+
+bool GeneratorImpl::EmitSwitch(ast::SwitchStatement* stmt) {
+  {  // switch(expr) {
+    auto out = line();
+    out << "switch(";
+    if (!EmitExpression(out, stmt->condition())) {
+      return false;
+    }
+    out << ") {";
+  }
+
+  {
+    ScopedIndent si(this);
+    for (auto* s : stmt->body()) {
+      if (!EmitCase(s)) {
+        return false;
+      }
+    }
+  }
+
+  line() << "}";
+
+  return true;
+}
+
+bool GeneratorImpl::EmitType(std::ostream& out,
+                             const sem::Type* type,
+                             ast::StorageClass storage_class,
+                             ast::Access access,
+                             const std::string& name,
+                             bool* name_printed /* = nullptr */) {
+  if (name_printed) {
+    *name_printed = false;
+  }
+  switch (storage_class) {
+    case ast::StorageClass::kInput: {
+      out << "in ";
+      break;
+    }
+    case ast::StorageClass::kOutput: {
+      out << "out ";
+      break;
+    }
+    case ast::StorageClass::kUniform: {
+      out << "uniform ";
+      break;
+    }
+    default:
+      break;
+  }
+
+  if (auto* ary = type->As<sem::Array>()) {
+    const sem::Type* base_type = ary;
+    std::vector<uint32_t> sizes;
+    while (auto* arr = base_type->As<sem::Array>()) {
+      if (arr->IsRuntimeSized()) {
+        TINT_ICE(Writer, diagnostics_)
+            << "Runtime arrays may only exist in storage buffers, which should "
+               "have been transformed into a ByteAddressBuffer";
+        return false;
+      }
+      sizes.push_back(arr->Count());
+      base_type = arr->ElemType();
+    }
+    if (!EmitType(out, base_type, storage_class, access, "")) {
+      return false;
+    }
+    if (!name.empty()) {
+      out << " " << name;
+      if (name_printed) {
+        *name_printed = true;
+      }
+    }
+    for (uint32_t size : sizes) {
+      out << "[" << size << "]";
+    }
+  } else if (type->Is<sem::Bool>()) {
+    out << "bool";
+  } else if (type->Is<sem::F32>()) {
+    out << "float";
+  } else if (type->Is<sem::I32>()) {
+    out << "int";
+  } else if (auto* mat = type->As<sem::Matrix>()) {
+    TINT_ASSERT(Writer, mat->type()->Is<sem::F32>());
+    out << "mat" << mat->columns();
+    if (mat->rows() != mat->columns()) {
+      out << "x" << mat->rows();
+    }
+  } else if (type->Is<sem::Pointer>()) {
+    TINT_ICE(Writer, diagnostics_)
+        << "Attempting to emit pointer type. These should have been removed "
+           "with the InlinePointerLets transform";
+    return false;
+  } else if (auto* sampler = type->As<sem::Sampler>()) {
+    out << "Sampler";
+    if (sampler->IsComparison()) {
+      out << "Comparison";
+    }
+    out << "State";
+  } else if (auto* str = type->As<sem::Struct>()) {
+    out << StructName(str);
+  } else if (auto* tex = type->As<sem::Texture>()) {
+    auto* storage = tex->As<sem::StorageTexture>();
+    auto* ms = tex->As<sem::MultisampledTexture>();
+    auto* depth_ms = tex->As<sem::DepthMultisampledTexture>();
+    auto* sampled = tex->As<sem::SampledTexture>();
+
+    if (storage && storage->access() != ast::Access::kRead) {
+      out << "RW";
+    }
+    out << "Texture";
+
+    switch (tex->dim()) {
+      case ast::TextureDimension::k1d:
+        out << "1D";
+        break;
+      case ast::TextureDimension::k2d:
+        out << ((ms || depth_ms) ? "2DMS" : "2D");
+        break;
+      case ast::TextureDimension::k2dArray:
+        out << ((ms || depth_ms) ? "2DMSArray" : "2DArray");
+        break;
+      case ast::TextureDimension::k3d:
+        out << "3D";
+        break;
+      case ast::TextureDimension::kCube:
+        out << "Cube";
+        break;
+      case ast::TextureDimension::kCubeArray:
+        out << "CubeArray";
+        break;
+      default:
+        TINT_UNREACHABLE(Writer, diagnostics_)
+            << "unexpected TextureDimension " << tex->dim();
+        return false;
+    }
+
+    if (storage) {
+      auto* component = image_format_to_rwtexture_type(storage->image_format());
+      if (component == nullptr) {
+        TINT_ICE(Writer, diagnostics_)
+            << "Unsupported StorageTexture ImageFormat: "
+            << static_cast<int>(storage->image_format());
+        return false;
+      }
+      out << "<" << component << ">";
+    } else if (depth_ms) {
+      out << "<float4>";
+    } else if (sampled || ms) {
+      auto* subtype = sampled ? sampled->type() : ms->type();
+      out << "<";
+      if (subtype->Is<sem::F32>()) {
+        out << "float4";
+      } else if (subtype->Is<sem::I32>()) {
+        out << "int4";
+      } else if (subtype->Is<sem::U32>()) {
+        out << "uint4";
+      } else {
+        TINT_ICE(Writer, diagnostics_)
+            << "Unsupported multisampled texture type";
+        return false;
+      }
+      out << ">";
+    }
+  } else if (type->Is<sem::U32>()) {
+    out << "uint";
+  } else if (auto* vec = type->As<sem::Vector>()) {
+    auto width = vec->Width();
+    if (vec->type()->Is<sem::F32>() && width >= 1 && width <= 4) {
+      out << "vec" << width;
+    } else if (vec->type()->Is<sem::I32>() && width >= 1 && width <= 4) {
+      out << "ivec" << width;
+    } else if (vec->type()->Is<sem::U32>() && width >= 1 && width <= 4) {
+      out << "uvec" << width;
+    } else if (vec->type()->Is<sem::Bool>() && width >= 1 && width <= 4) {
+      out << "bvec" << width;
+    } else {
+      out << "vector<";
+      if (!EmitType(out, vec->type(), storage_class, access, "")) {
+        return false;
+      }
+      out << ", " << width << ">";
+    }
+  } else if (auto* atomic = type->As<sem::Atomic>()) {
+    if (!EmitType(out, atomic->Type(), storage_class, access, name)) {
+      return false;
+    }
+  } else if (type->Is<sem::Void>()) {
+    out << "void";
+  } else {
+    diagnostics_.add_error(diag::System::Writer, "unknown type in EmitType");
+    return false;
+  }
+
+  return true;
+}
+
+bool GeneratorImpl::EmitTypeAndName(std::ostream& out,
+                                    const sem::Type* type,
+                                    ast::StorageClass storage_class,
+                                    ast::Access access,
+                                    const std::string& name) {
+  bool printed_name = false;
+  if (!EmitType(out, type, storage_class, access, name, &printed_name)) {
+    return false;
+  }
+  if (!name.empty() && !printed_name) {
+    out << " " << name;
+  }
+  return true;
+}
+
+bool GeneratorImpl::EmitStructType(TextBuffer* b, const sem::Struct* str) {
+  auto storage_class_uses = str->StorageClassUsage();
+  if (storage_class_uses.size() ==
+      (storage_class_uses.count(ast::StorageClass::kStorage))) {
+    // The only use of the structure is as a storage buffer.
+    // Structures used as storage buffer are read and written to via a
+    // ByteAddressBuffer instead of true structure.
+    return true;
+  }
+
+  line(b) << "struct " << StructName(str) << " {";
+  {
+    ScopedIndent si(b);
+    for (auto* mem : str->Members()) {
+      auto name = builder_.Symbols().NameFor(mem->Name());
+
+      auto* ty = mem->Type();
+
+      auto out = line(b);
+
+      std::string pre, post;
+
+      if (auto* decl = mem->Declaration()) {
+        for (auto* deco : decl->decorations()) {
+          if (deco->As<ast::LocationDecoration>()) {
+            auto& pipeline_stage_uses = str->PipelineStageUses();
+            if (pipeline_stage_uses.size() != 1) {
+              TINT_ICE(Writer, diagnostics_)
+                  << "invalid entry point IO struct uses";
+            }
+          } else if (auto* interpolate =
+                         deco->As<ast::InterpolateDecoration>()) {
+            auto mod = interpolation_to_modifiers(interpolate->type(),
+                                                  interpolate->sampling());
+            if (mod.empty()) {
+              diagnostics_.add_error(diag::System::Writer,
+                                     "unsupported interpolation");
+              return false;
+            }
+          }
+        }
+      }
+
+      out << pre;
+      if (!EmitTypeAndName(out, ty, ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, name)) {
+        return false;
+      }
+      out << post << ";";
+    }
+  }
+
+  line(b) << "};";
+
+  return true;
+}
+
+bool GeneratorImpl::EmitUnaryOp(std::ostream& out,
+                                ast::UnaryOpExpression* expr) {
+  switch (expr->op()) {
+    case ast::UnaryOp::kIndirection:
+    case ast::UnaryOp::kAddressOf:
+      return EmitExpression(out, expr->expr());
+    case ast::UnaryOp::kComplement:
+      out << "~";
+      break;
+    case ast::UnaryOp::kNot:
+      out << "!";
+      break;
+    case ast::UnaryOp::kNegation:
+      out << "-";
+      break;
+  }
+  out << "(";
+
+  if (!EmitExpression(out, expr->expr())) {
+    return false;
+  }
+
+  out << ")";
+
+  return true;
+}
+
+bool GeneratorImpl::EmitVariable(ast::Variable* var) {
+  auto* sem = builder_.Sem().Get(var);
+  auto* type = sem->Type()->UnwrapRef();
+
+  // TODO(dsinclair): Handle variable decorations
+  if (!var->decorations().empty()) {
+    diagnostics_.add_error(diag::System::Writer,
+                           "Variable decorations are not handled yet");
+    return false;
+  }
+
+  auto out = line();
+  // TODO(senorblanco): handle const
+  if (!EmitTypeAndName(out, type, sem->StorageClass(), sem->Access(),
+                       builder_.Symbols().NameFor(var->symbol()))) {
+    return false;
+  }
+
+  out << " = ";
+
+  if (var->constructor()) {
+    if (!EmitExpression(out, var->constructor())) {
+      return false;
+    }
+  } else {
+    if (!EmitZeroValue(out, type)) {
+      return false;
+    }
+  }
+  out << ";";
+
+  return true;
+}
+
+bool GeneratorImpl::EmitProgramConstVariable(const ast::Variable* var) {
+  for (auto* d : var->decorations()) {
+    if (!d->Is<ast::OverrideDecoration>()) {
+      diagnostics_.add_error(diag::System::Writer,
+                             "Decorated const values not valid");
+      return false;
+    }
+  }
+  if (!var->is_const()) {
+    diagnostics_.add_error(diag::System::Writer, "Expected a const value");
+    return false;
+  }
+
+  auto* sem = builder_.Sem().Get(var);
+  auto* type = sem->Type();
+
+  auto* global = sem->As<sem::GlobalVariable>();
+  if (global && global->IsPipelineConstant()) {
+    auto const_id = global->ConstantId();
+
+    line() << "#ifndef " << kSpecConstantPrefix << const_id;
+
+    if (var->constructor() != nullptr) {
+      auto out = line();
+      out << "#define " << kSpecConstantPrefix << const_id << " ";
+      if (!EmitExpression(out, var->constructor())) {
+        return false;
+      }
+    } else {
+      line() << "#error spec constant required for constant id " << const_id;
+    }
+    line() << "#endif";
+    {
+      auto out = line();
+      out << "static const ";
+      if (!EmitTypeAndName(out, type, sem->StorageClass(), sem->Access(),
+                           builder_.Symbols().NameFor(var->symbol()))) {
+        return false;
+      }
+      out << " = " << kSpecConstantPrefix << const_id << ";";
+    }
+  } else {
+    auto out = line();
+    out << "static const ";
+    if (!EmitTypeAndName(out, type, sem->StorageClass(), sem->Access(),
+                         builder_.Symbols().NameFor(var->symbol()))) {
+      return false;
+    }
+    out << " = ";
+    if (!EmitExpression(out, var->constructor())) {
+      return false;
+    }
+    out << ";";
+  }
+
+  return true;
+}
+
+template <typename F>
+bool GeneratorImpl::CallIntrinsicHelper(std::ostream& out,
+                                        ast::CallExpression* call,
+                                        const sem::Intrinsic* intrinsic,
+                                        F&& build) {
+  // Generate the helper function if it hasn't been created already
+  auto fn = utils::GetOrCreate(intrinsics_, intrinsic, [&]() -> std::string {
+    TextBuffer b;
+    TINT_DEFER(helpers_.Append(b));
+
+    auto fn_name =
+        UniqueIdentifier(std::string("tint_") + sem::str(intrinsic->Type()));
+    std::vector<std::string> parameter_names;
+    {
+      auto decl = line(&b);
+      if (!EmitTypeAndName(decl, intrinsic->ReturnType(),
+                           ast::StorageClass::kNone, ast::Access::kUndefined,
+                           fn_name)) {
+        return "";
+      }
+      {
+        ScopedParen sp(decl);
+        for (auto* param : intrinsic->Parameters()) {
+          if (!parameter_names.empty()) {
+            decl << ", ";
+          }
+          auto param_name = "param_" + std::to_string(parameter_names.size());
+          const auto* ty = param->Type();
+          if (auto* ptr = ty->As<sem::Pointer>()) {
+            decl << "inout ";
+            ty = ptr->StoreType();
+          }
+          if (!EmitTypeAndName(decl, ty, ast::StorageClass::kNone,
+                               ast::Access::kUndefined, param_name)) {
+            return "";
+          }
+          parameter_names.emplace_back(std::move(param_name));
+        }
+      }
+      decl << " {";
+    }
+    {
+      ScopedIndent si(&b);
+      if (!build(&b, parameter_names)) {
+        return "";
+      }
+    }
+    line(&b) << "}";
+    line(&b);
+    return fn_name;
+  });
+
+  if (fn.empty()) {
+    return false;
+  }
+
+  // Call the helper
+  out << fn;
+  {
+    ScopedParen sp(out);
+    bool first = true;
+    for (auto* arg : call->params()) {
+      if (!first) {
+        out << ", ";
+      }
+      first = false;
+      if (!EmitExpression(out, arg)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl.h b/src/writer/glsl/generator_impl.h
new file mode 100644
index 0000000..c689ba1
--- /dev/null
+++ b/src/writer/glsl/generator_impl.h
@@ -0,0 +1,418 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_WRITER_GLSL_GENERATOR_IMPL_H_
+#define SRC_WRITER_GLSL_GENERATOR_IMPL_H_
+
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+
+#include "src/ast/assignment_statement.h"
+#include "src/ast/bitcast_expression.h"
+#include "src/ast/break_statement.h"
+#include "src/ast/continue_statement.h"
+#include "src/ast/discard_statement.h"
+#include "src/ast/for_loop_statement.h"
+#include "src/ast/if_statement.h"
+#include "src/ast/loop_statement.h"
+#include "src/ast/return_statement.h"
+#include "src/ast/switch_statement.h"
+#include "src/ast/unary_op_expression.h"
+#include "src/program_builder.h"
+#include "src/scope_stack.h"
+#include "src/transform/decompose_memory_access.h"
+#include "src/utils/hash.h"
+#include "src/writer/text_generator.h"
+
+namespace tint {
+
+// Forward declarations
+namespace sem {
+class Call;
+class Intrinsic;
+}  // namespace sem
+
+namespace writer {
+namespace glsl {
+
+/// Implementation class for GLSL generator
+class GeneratorImpl : public TextGenerator {
+ public:
+  /// Constructor
+  /// @param program the program to generate
+  explicit GeneratorImpl(const Program* program);
+  ~GeneratorImpl();
+
+  /// @returns true on successful generation; false otherwise
+  bool Generate();
+
+  /// Handles an array accessor expression
+  /// @param out the output of the expression stream
+  /// @param expr the expression to emit
+  /// @returns true if the array accessor was emitted
+  bool EmitArrayAccessor(std::ostream& out, ast::ArrayAccessorExpression* expr);
+  /// Handles an assignment statement
+  /// @param stmt the statement to emit
+  /// @returns true if the statement was emitted successfully
+  bool EmitAssign(ast::AssignmentStatement* stmt);
+  /// Handles generating a binary expression
+  /// @param out the output of the expression stream
+  /// @param expr the binary expression
+  /// @returns true if the expression was emitted, false otherwise
+  bool EmitBinary(std::ostream& out, ast::BinaryExpression* expr);
+  /// Handles generating a bitcast expression
+  /// @param out the output of the expression stream
+  /// @param expr the as expression
+  /// @returns true if the bitcast was emitted
+  bool EmitBitcast(std::ostream& out, ast::BitcastExpression* expr);
+  /// Emits a list of statements
+  /// @param stmts the statement list
+  /// @returns true if the statements were emitted successfully
+  bool EmitStatements(const ast::StatementList& stmts);
+  /// Emits a list of statements with an indentation
+  /// @param stmts the statement list
+  /// @returns true if the statements were emitted successfully
+  bool EmitStatementsWithIndent(const ast::StatementList& stmts);
+  /// Handles a block statement
+  /// @param stmt the statement to emit
+  /// @returns true if the statement was emitted successfully
+  bool EmitBlock(const ast::BlockStatement* stmt);
+  /// Handles a break statement
+  /// @param stmt the statement to emit
+  /// @returns true if the statement was emitted successfully
+  bool EmitBreak(ast::BreakStatement* stmt);
+  /// Handles generating a call expression
+  /// @param out the output of the expression stream
+  /// @param expr the call expression
+  /// @returns true if the call expression is emitted
+  bool EmitCall(std::ostream& out, ast::CallExpression* expr);
+  /// Handles generating a barrier intrinsic call
+  /// @param out the output of the expression stream
+  /// @param intrinsic the semantic information for the barrier intrinsic
+  /// @returns true if the call expression is emitted
+  bool EmitBarrierCall(std::ostream& out, const sem::Intrinsic* intrinsic);
+  /// Handles generating an atomic intrinsic call for a storage buffer variable
+  /// @param out the output of the expression stream
+  /// @param expr the call expression
+  /// @param intrinsic the atomic intrinsic
+  /// @returns true if the call expression is emitted
+  bool EmitStorageAtomicCall(
+      std::ostream& out,
+      ast::CallExpression* expr,
+      const transform::DecomposeMemoryAccess::Intrinsic* intrinsic);
+  /// Handles generating an atomic intrinsic call for a workgroup variable
+  /// @param out the output of the expression stream
+  /// @param expr the call expression
+  /// @param intrinsic the semantic information for the atomic intrinsic
+  /// @returns true if the call expression is emitted
+  bool EmitWorkgroupAtomicCall(std::ostream& out,
+                               ast::CallExpression* expr,
+                               const sem::Intrinsic* intrinsic);
+  /// Handles generating a call to a texture function (`textureSample`,
+  /// `textureSampleGrad`, etc)
+  /// @param out the output of the expression stream
+  /// @param expr the call expression
+  /// @param intrinsic the semantic information for the texture intrinsic
+  /// @returns true if the call expression is emitted
+  bool EmitTextureCall(std::ostream& out,
+                       ast::CallExpression* expr,
+                       const sem::Intrinsic* intrinsic);
+  /// Handles generating a call to the `select()` intrinsic
+  /// @param out the output of the expression stream
+  /// @param expr the call expression
+  /// @returns true if the call expression is emitted
+  bool EmitSelectCall(std::ostream& out, ast::CallExpression* expr);
+  /// Handles generating a call to the `modf()` intrinsic
+  /// @param out the output of the expression stream
+  /// @param expr the call expression
+  /// @param intrinsic the semantic information for the intrinsic
+  /// @returns true if the call expression is emitted
+  bool EmitModfCall(std::ostream& out,
+                    ast::CallExpression* expr,
+                    const sem::Intrinsic* intrinsic);
+  /// Handles generating a call to the `frexp()` intrinsic
+  /// @param out the output of the expression stream
+  /// @param expr the call expression
+  /// @param intrinsic the semantic information for the intrinsic
+  /// @returns true if the call expression is emitted
+  bool EmitFrexpCall(std::ostream& out,
+                     ast::CallExpression* expr,
+                     const sem::Intrinsic* intrinsic);
+  /// Handles generating a call to the `isNormal()` intrinsic
+  /// @param out the output of the expression stream
+  /// @param expr the call expression
+  /// @param intrinsic the semantic information for the intrinsic
+  /// @returns true if the call expression is emitted
+  bool EmitIsNormalCall(std::ostream& out,
+                        ast::CallExpression* expr,
+                        const sem::Intrinsic* intrinsic);
+  /// Handles generating a call to data packing intrinsic
+  /// @param out the output of the expression stream
+  /// @param expr the call expression
+  /// @param intrinsic the semantic information for the texture intrinsic
+  /// @returns true if the call expression is emitted
+  bool EmitDataPackingCall(std::ostream& out,
+                           ast::CallExpression* expr,
+                           const sem::Intrinsic* intrinsic);
+  /// Handles generating a call to data unpacking intrinsic
+  /// @param out the output of the expression stream
+  /// @param expr the call expression
+  /// @param intrinsic the semantic information for the texture intrinsic
+  /// @returns true if the call expression is emitted
+  bool EmitDataUnpackingCall(std::ostream& out,
+                             ast::CallExpression* expr,
+                             const sem::Intrinsic* intrinsic);
+  /// Handles a case statement
+  /// @param stmt the statement
+  /// @returns true if the statement was emitted successfully
+  bool EmitCase(ast::CaseStatement* stmt);
+  /// Handles generating constructor expressions
+  /// @param out the output of the expression stream
+  /// @param expr the constructor expression
+  /// @returns true if the expression was emitted
+  bool EmitConstructor(std::ostream& out, ast::ConstructorExpression* expr);
+  /// Handles generating a discard statement
+  /// @param stmt the discard statement
+  /// @returns true if the statement was successfully emitted
+  bool EmitDiscard(ast::DiscardStatement* stmt);
+  /// Handles generating a scalar constructor
+  /// @param out the output of the expression stream
+  /// @param expr the scalar constructor expression
+  /// @returns true if the scalar constructor is emitted
+  bool EmitScalarConstructor(std::ostream& out,
+                             ast::ScalarConstructorExpression* expr);
+  /// Handles emitting a type constructor
+  /// @param out the output of the expression stream
+  /// @param expr the type constructor expression
+  /// @returns true if the constructor is emitted
+  bool EmitTypeConstructor(std::ostream& out,
+                           ast::TypeConstructorExpression* expr);
+  /// Handles a continue statement
+  /// @param stmt the statement to emit
+  /// @returns true if the statement was emitted successfully
+  bool EmitContinue(ast::ContinueStatement* stmt);
+  /// Handles generate an Expression
+  /// @param out the output of the expression stream
+  /// @param expr the expression
+  /// @returns true if the expression was emitted
+  bool EmitExpression(std::ostream& out, ast::Expression* expr);
+  /// Handles generating a function
+  /// @param func the function to generate
+  /// @returns true if the function was emitted
+  bool EmitFunction(ast::Function* func);
+
+  /// Handles emitting a global variable
+  /// @param global the global variable
+  /// @returns true on success
+  bool EmitGlobalVariable(ast::Variable* global);
+
+  /// Handles emitting a global variable with the uniform storage class
+  /// @param var the global variable
+  /// @returns true on success
+  bool EmitUniformVariable(const sem::Variable* var);
+
+  /// Handles emitting a global variable with the storage storage class
+  /// @param var the global variable
+  /// @returns true on success
+  bool EmitStorageVariable(const sem::Variable* var);
+
+  /// Handles emitting a global variable with the handle storage class
+  /// @param var the global variable
+  /// @returns true on success
+  bool EmitHandleVariable(const sem::Variable* var);
+
+  /// Handles emitting a global variable with the private storage class
+  /// @param var the global variable
+  /// @returns true on success
+  bool EmitPrivateVariable(const sem::Variable* var);
+
+  /// Handles emitting a global variable with the workgroup storage class
+  /// @param var the global variable
+  /// @returns true on success
+  bool EmitWorkgroupVariable(const sem::Variable* var);
+
+  /// Handles emitting the entry point function
+  /// @param func the entry point
+  /// @returns true if the entry point function was emitted
+  bool EmitEntryPointFunction(ast::Function* func);
+  /// Handles an if statement
+  /// @param stmt the statement to emit
+  /// @returns true if the statement was successfully emitted
+  bool EmitIf(ast::IfStatement* stmt);
+  /// Handles a literal
+  /// @param out the output stream
+  /// @param lit the literal to emit
+  /// @returns true if the literal was successfully emitted
+  bool EmitLiteral(std::ostream& out, ast::Literal* lit);
+  /// Handles a loop statement
+  /// @param stmt the statement to emit
+  /// @returns true if the statement was emitted
+  bool EmitLoop(ast::LoopStatement* stmt);
+  /// Handles a for loop statement
+  /// @param stmt the statement to emit
+  /// @returns true if the statement was emitted
+  bool EmitForLoop(ast::ForLoopStatement* stmt);
+  /// Handles generating an identifier expression
+  /// @param out the output of the expression stream
+  /// @param expr the identifier expression
+  /// @returns true if the identifeir was emitted
+  bool EmitIdentifier(std::ostream& out, ast::IdentifierExpression* expr);
+  /// Handles a member accessor expression
+  /// @param out the output of the expression stream
+  /// @param expr the member accessor expression
+  /// @returns true if the member accessor was emitted
+  bool EmitMemberAccessor(std::ostream& out,
+                          ast::MemberAccessorExpression* expr);
+  /// Handles return statements
+  /// @param stmt the statement to emit
+  /// @returns true if the statement was successfully emitted
+  bool EmitReturn(ast::ReturnStatement* stmt);
+  /// Handles statement
+  /// @param stmt the statement to emit
+  /// @returns true if the statement was emitted
+  bool EmitStatement(ast::Statement* stmt);
+  /// Handles generating a switch statement
+  /// @param stmt the statement to emit
+  /// @returns true if the statement was emitted
+  bool EmitSwitch(ast::SwitchStatement* stmt);
+  /// Handles generating type
+  /// @param out the output stream
+  /// @param type the type to generate
+  /// @param storage_class the storage class of the variable
+  /// @param access the access control type of the variable
+  /// @param name the name of the variable, used for array emission.
+  /// @param name_printed (optional) if not nullptr and an array was printed
+  /// then the boolean is set to true.
+  /// @returns true if the type is emitted
+  bool EmitType(std::ostream& out,
+                const sem::Type* type,
+                ast::StorageClass storage_class,
+                ast::Access access,
+                const std::string& name,
+                bool* name_printed = nullptr);
+  /// Handles generating type and name
+  /// @param out the output stream
+  /// @param type the type to generate
+  /// @param storage_class the storage class of the variable
+  /// @param access the access control type of the variable
+  /// @param name the name to emit
+  /// @returns true if the type is emitted
+  bool EmitTypeAndName(std::ostream& out,
+                       const sem::Type* type,
+                       ast::StorageClass storage_class,
+                       ast::Access access,
+                       const std::string& name);
+  /// Handles generating a structure declaration
+  /// @param buffer the text buffer that the type declaration will be written to
+  /// @param ty the struct to generate
+  /// @returns true if the struct is emitted
+  bool EmitStructType(TextBuffer* buffer, const sem::Struct* ty);
+  /// Handles a unary op expression
+  /// @param out the output of the expression stream
+  /// @param expr the expression to emit
+  /// @returns true if the expression was emitted
+  bool EmitUnaryOp(std::ostream& out, ast::UnaryOpExpression* expr);
+  /// Emits the zero value for the given type
+  /// @param out the output stream
+  /// @param type the type to emit the value for
+  /// @returns true if the zero value was successfully emitted.
+  bool EmitZeroValue(std::ostream& out, const sem::Type* type);
+  /// Handles generating a variable
+  /// @param var the variable to generate
+  /// @returns true if the variable was emitted
+  bool EmitVariable(ast::Variable* var);
+  /// Handles generating a program scope constant variable
+  /// @param var the variable to emit
+  /// @returns true if the variable was emitted
+  bool EmitProgramConstVariable(const ast::Variable* var);
+  /// Handles generating a builtin method name
+  /// @param intrinsic the semantic info for the intrinsic
+  /// @returns the name or "" if not valid
+  std::string generate_builtin_name(const sem::Intrinsic* intrinsic);
+  /// Converts a builtin to a gl_ string
+  /// @param builtin the builtin to convert
+  /// @returns the string name of the builtin or blank on error
+  const char* builtin_to_string(ast::Builtin builtin) const;
+  /// Converts a builtin to a sem::Type appropriate for GLSL.
+  /// @param builtin the builtin to convert
+  /// @returns the appropriate semantic type or null on error.
+  sem::Type* builtin_type(ast::Builtin builtin);
+
+  /// Converts interpolation attributes to a GLSL modifiers
+  /// @param type the interpolation type
+  /// @param sampling the interpolation sampling
+  /// @returns the string name of the attribute or blank on error
+  std::string interpolation_to_modifiers(
+      ast::InterpolationType type,
+      ast::InterpolationSampling sampling) const;
+
+ private:
+  enum class VarType { kIn, kOut };
+
+  struct EntryPointData {
+    std::string struct_name;
+    std::string var_name;
+  };
+
+  struct DMAIntrinsic {
+    transform::DecomposeMemoryAccess::Intrinsic::Op op;
+    transform::DecomposeMemoryAccess::Intrinsic::DataType type;
+    bool operator==(const DMAIntrinsic& rhs) const {
+      return op == rhs.op && type == rhs.type;
+    }
+    /// Hasher is a std::hash function for DMAIntrinsic
+    struct Hasher {
+      /// @param i the DMAIntrinsic to hash
+      /// @returns the hash of `i`
+      inline std::size_t operator()(const DMAIntrinsic& i) const {
+        return utils::Hash(i.op, i.type);
+      }
+    };
+  };
+
+  /// CallIntrinsicHelper will call the intrinsic helper function, creating it
+  /// if it hasn't been built already. If the intrinsic needs to be built then
+  /// CallIntrinsicHelper will generate the function signature and will call
+  /// `build` to emit the body of the function.
+  /// @param out the output of the expression stream
+  /// @param call the call expression
+  /// @param intrinsic the semantic information for the intrinsic
+  /// @param build a function with the signature:
+  ///        `bool(TextBuffer* buffer, const std::vector<std::string>& params)`
+  ///        Where:
+  ///          `buffer` is the body of the generated function
+  ///          `params` is the name of all the generated function parameters
+  /// @returns true if the call expression is emitted
+  template <typename F>
+  bool CallIntrinsicHelper(std::ostream& out,
+                           ast::CallExpression* call,
+                           const sem::Intrinsic* intrinsic,
+                           F&& build);
+
+  TextBuffer helpers_;  // Helper functions emitted at the top of the output
+  std::function<bool()> emit_continuing_;
+  std::unordered_map<DMAIntrinsic, std::string, DMAIntrinsic::Hasher>
+      dma_intrinsics_;
+  std::unordered_map<const sem::Intrinsic*, std::string> intrinsics_;
+  std::unordered_map<const sem::Struct*, std::string> structure_builders_;
+  std::unordered_map<const sem::Vector*, std::string> dynamic_vector_write_;
+};
+
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
+
+#endif  // SRC_WRITER_GLSL_GENERATOR_IMPL_H_
diff --git a/src/writer/glsl/generator_impl_array_accessor_test.cc b/src/writer/glsl/generator_impl_array_accessor_test.cc
new file mode 100644
index 0000000..1ba07b6
--- /dev/null
+++ b/src/writer/glsl/generator_impl_array_accessor_test.cc
@@ -0,0 +1,39 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_Expression = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_Expression, ArrayAccessor) {
+  Global("ary", ty.array<i32, 10>(), ast::StorageClass::kPrivate);
+  auto* expr = IndexAccessor("ary", 5);
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), "ary[5]");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_assign_test.cc b/src/writer/glsl/generator_impl_assign_test.cc
new file mode 100644
index 0000000..db9e19a
--- /dev/null
+++ b/src/writer/glsl/generator_impl_assign_test.cc
@@ -0,0 +1,41 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_Assign = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_Assign, Emit_Assign) {
+  Global("lhs", ty.i32(), ast::StorageClass::kPrivate);
+  Global("rhs", ty.i32(), ast::StorageClass::kPrivate);
+  auto* assign = Assign("lhs", "rhs");
+  WrapInFunction(assign);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(assign)) << gen.error();
+  EXPECT_EQ(gen.result(), "  lhs = rhs;\n");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_binary_test.cc b/src/writer/glsl/generator_impl_binary_test.cc
new file mode 100644
index 0000000..c2d8daf
--- /dev/null
+++ b/src/writer/glsl/generator_impl_binary_test.cc
@@ -0,0 +1,557 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/ast/call_statement.h"
+#include "src/ast/variable_decl_statement.h"
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_Binary = TestHelper;
+
+struct BinaryData {
+  const char* result;
+  ast::BinaryOp op;
+};
+inline std::ostream& operator<<(std::ostream& out, BinaryData data) {
+  out << data.op;
+  return out;
+}
+
+using GlslBinaryTest = TestParamHelper<BinaryData>;
+TEST_P(GlslBinaryTest, Emit_f32) {
+  auto params = GetParam();
+
+  // Skip ops that are illegal for this type
+  if (params.op == ast::BinaryOp::kAnd || params.op == ast::BinaryOp::kOr ||
+      params.op == ast::BinaryOp::kXor ||
+      params.op == ast::BinaryOp::kShiftLeft ||
+      params.op == ast::BinaryOp::kShiftRight) {
+    return;
+  }
+
+  Global("left", ty.f32(), ast::StorageClass::kPrivate);
+  Global("right", ty.f32(), ast::StorageClass::kPrivate);
+
+  auto* left = Expr("left");
+  auto* right = Expr("right");
+
+  auto* expr = create<ast::BinaryExpression>(params.op, left, right);
+
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), params.result);
+}
+TEST_P(GlslBinaryTest, Emit_u32) {
+  auto params = GetParam();
+
+  Global("left", ty.u32(), ast::StorageClass::kPrivate);
+  Global("right", ty.u32(), ast::StorageClass::kPrivate);
+
+  auto* left = Expr("left");
+  auto* right = Expr("right");
+
+  auto* expr = create<ast::BinaryExpression>(params.op, left, right);
+
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), params.result);
+}
+TEST_P(GlslBinaryTest, Emit_i32) {
+  auto params = GetParam();
+
+  // Skip ops that are illegal for this type
+  if (params.op == ast::BinaryOp::kShiftLeft ||
+      params.op == ast::BinaryOp::kShiftRight) {
+    return;
+  }
+
+  Global("left", ty.i32(), ast::StorageClass::kPrivate);
+  Global("right", ty.i32(), ast::StorageClass::kPrivate);
+
+  auto* left = Expr("left");
+  auto* right = Expr("right");
+
+  auto* expr = create<ast::BinaryExpression>(params.op, left, right);
+
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), params.result);
+}
+INSTANTIATE_TEST_SUITE_P(
+    GlslGeneratorImplTest,
+    GlslBinaryTest,
+    testing::Values(
+        BinaryData{"(left & right)", ast::BinaryOp::kAnd},
+        BinaryData{"(left | right)", ast::BinaryOp::kOr},
+        BinaryData{"(left ^ right)", ast::BinaryOp::kXor},
+        BinaryData{"(left == right)", ast::BinaryOp::kEqual},
+        BinaryData{"(left != right)", ast::BinaryOp::kNotEqual},
+        BinaryData{"(left < right)", ast::BinaryOp::kLessThan},
+        BinaryData{"(left > right)", ast::BinaryOp::kGreaterThan},
+        BinaryData{"(left <= right)", ast::BinaryOp::kLessThanEqual},
+        BinaryData{"(left >= right)", ast::BinaryOp::kGreaterThanEqual},
+        BinaryData{"(left << right)", ast::BinaryOp::kShiftLeft},
+        BinaryData{"(left >> right)", ast::BinaryOp::kShiftRight},
+        BinaryData{"(left + right)", ast::BinaryOp::kAdd},
+        BinaryData{"(left - right)", ast::BinaryOp::kSubtract},
+        BinaryData{"(left * right)", ast::BinaryOp::kMultiply},
+        BinaryData{"(left / right)", ast::BinaryOp::kDivide},
+        BinaryData{"(left % right)", ast::BinaryOp::kModulo}));
+
+TEST_F(GlslGeneratorImplTest_Binary, Multiply_VectorScalar) {
+  auto* lhs = vec3<f32>(1.f, 1.f, 1.f);
+  auto* rhs = Expr(1.f);
+
+  auto* expr =
+      create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, lhs, rhs);
+
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  EXPECT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(),
+            "(vec3(1.0f, 1.0f, 1.0f) * "
+            "1.0f)");
+}
+
+TEST_F(GlslGeneratorImplTest_Binary, Multiply_ScalarVector) {
+  auto* lhs = Expr(1.f);
+  auto* rhs = vec3<f32>(1.f, 1.f, 1.f);
+
+  auto* expr =
+      create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, lhs, rhs);
+
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  EXPECT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(),
+            "(1.0f * vec3(1.0f, 1.0f, "
+            "1.0f))");
+}
+
+TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixScalar) {
+  Global("mat", ty.mat3x3<f32>(), ast::StorageClass::kPrivate);
+  auto* lhs = Expr("mat");
+  auto* rhs = Expr(1.f);
+
+  auto* expr =
+      create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, lhs, rhs);
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  EXPECT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), "(mat * 1.0f)");
+}
+
+TEST_F(GlslGeneratorImplTest_Binary, Multiply_ScalarMatrix) {
+  Global("mat", ty.mat3x3<f32>(), ast::StorageClass::kPrivate);
+  auto* lhs = Expr(1.f);
+  auto* rhs = Expr("mat");
+
+  auto* expr =
+      create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, lhs, rhs);
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  EXPECT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), "(1.0f * mat)");
+}
+
+TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixVector) {
+  Global("mat", ty.mat3x3<f32>(), ast::StorageClass::kPrivate);
+  auto* lhs = Expr("mat");
+  auto* rhs = vec3<f32>(1.f, 1.f, 1.f);
+
+  auto* expr =
+      create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, lhs, rhs);
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  EXPECT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), "(mat * vec3(1.0f, 1.0f, 1.0f))");
+}
+
+TEST_F(GlslGeneratorImplTest_Binary, Multiply_VectorMatrix) {
+  Global("mat", ty.mat3x3<f32>(), ast::StorageClass::kPrivate);
+  auto* lhs = vec3<f32>(1.f, 1.f, 1.f);
+  auto* rhs = Expr("mat");
+
+  auto* expr =
+      create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, lhs, rhs);
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  EXPECT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), "(vec3(1.0f, 1.0f, 1.0f) * mat)");
+}
+
+TEST_F(GlslGeneratorImplTest_Binary, Multiply_MatrixMatrix) {
+  Global("lhs", ty.mat3x3<f32>(), ast::StorageClass::kPrivate);
+  Global("rhs", ty.mat3x3<f32>(), ast::StorageClass::kPrivate);
+
+  auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kMultiply,
+                                             Expr("lhs"), Expr("rhs"));
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  EXPECT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), "(lhs * rhs)");
+}
+
+TEST_F(GlslGeneratorImplTest_Binary, Logical_And) {
+  Global("a", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("b", ty.bool_(), ast::StorageClass::kPrivate);
+
+  auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd,
+                                             Expr("a"), Expr("b"));
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), "(tint_tmp)");
+  EXPECT_EQ(gen.result(), R"(bool tint_tmp = a;
+if (tint_tmp) {
+  tint_tmp = b;
+}
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Binary, Logical_Multi) {
+  // (a && b) || (c || d)
+  Global("a", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("b", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("c", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("d", ty.bool_(), ast::StorageClass::kPrivate);
+
+  auto* expr = create<ast::BinaryExpression>(
+      ast::BinaryOp::kLogicalOr,
+      create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd, Expr("a"),
+                                    Expr("b")),
+      create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, Expr("c"),
+                                    Expr("d")));
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), "(tint_tmp)");
+  EXPECT_EQ(gen.result(), R"(bool tint_tmp_1 = a;
+if (tint_tmp_1) {
+  tint_tmp_1 = b;
+}
+bool tint_tmp = (tint_tmp_1);
+if (!tint_tmp) {
+  bool tint_tmp_2 = c;
+  if (!tint_tmp_2) {
+    tint_tmp_2 = d;
+  }
+  tint_tmp = (tint_tmp_2);
+}
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Binary, Logical_Or) {
+  Global("a", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("b", ty.bool_(), ast::StorageClass::kPrivate);
+
+  auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
+                                             Expr("a"), Expr("b"));
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), "(tint_tmp)");
+  EXPECT_EQ(gen.result(), R"(bool tint_tmp = a;
+if (!tint_tmp) {
+  tint_tmp = b;
+}
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Binary, If_WithLogical) {
+  // if (a && b) {
+  //   return 1;
+  // } else if (b || c) {
+  //   return 2;
+  // } else {
+  //   return 3;
+  // }
+
+  Global("a", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("b", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("c", ty.bool_(), ast::StorageClass::kPrivate);
+
+  auto* body = Block(Return(3));
+  auto* else_stmt = create<ast::ElseStatement>(nullptr, body);
+
+  body = Block(Return(2));
+  auto* else_if_stmt = create<ast::ElseStatement>(
+      create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, Expr("b"),
+                                    Expr("c")),
+      body);
+
+  body = Block(Return(1));
+
+  auto* expr = create<ast::IfStatement>(
+      create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd, Expr("a"),
+                                    Expr("b")),
+      body,
+      ast::ElseStatementList{
+          else_if_stmt,
+          else_stmt,
+      });
+  Func("func", {}, ty.i32(), {WrapInStatement(expr), Return(0)});
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitStatement(expr)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(bool tint_tmp = a;
+if (tint_tmp) {
+  tint_tmp = b;
+}
+if ((tint_tmp)) {
+  return 1;
+} else {
+  bool tint_tmp_1 = b;
+  if (!tint_tmp_1) {
+    tint_tmp_1 = c;
+  }
+  if ((tint_tmp_1)) {
+    return 2;
+  } else {
+    return 3;
+  }
+}
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Binary, Return_WithLogical) {
+  // return (a && b) || c;
+
+  Global("a", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("b", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("c", ty.bool_(), ast::StorageClass::kPrivate);
+
+  auto* expr = Return(create<ast::BinaryExpression>(
+      ast::BinaryOp::kLogicalOr,
+      create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd, Expr("a"),
+                                    Expr("b")),
+      Expr("c")));
+  Func("func", {}, ty.bool_(), {WrapInStatement(expr)});
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitStatement(expr)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(bool tint_tmp_1 = a;
+if (tint_tmp_1) {
+  tint_tmp_1 = b;
+}
+bool tint_tmp = (tint_tmp_1);
+if (!tint_tmp) {
+  tint_tmp = c;
+}
+return (tint_tmp);
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Binary, Assign_WithLogical) {
+  // a = (b || c) && d;
+
+  Global("a", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("b", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("c", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("d", ty.bool_(), ast::StorageClass::kPrivate);
+
+  auto* expr = Assign(
+      Expr("a"), create<ast::BinaryExpression>(
+                     ast::BinaryOp::kLogicalAnd,
+                     create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
+                                                   Expr("b"), Expr("c")),
+                     Expr("d")));
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitStatement(expr)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(bool tint_tmp_1 = b;
+if (!tint_tmp_1) {
+  tint_tmp_1 = c;
+}
+bool tint_tmp = (tint_tmp_1);
+if (tint_tmp) {
+  tint_tmp = d;
+}
+a = (tint_tmp);
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Binary, Decl_WithLogical) {
+  // var a : bool = (b && c) || d;
+
+  Global("b", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("c", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("d", ty.bool_(), ast::StorageClass::kPrivate);
+
+  auto* var = Var("a", ty.bool_(), ast::StorageClass::kNone,
+                  create<ast::BinaryExpression>(
+                      ast::BinaryOp::kLogicalOr,
+                      create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd,
+                                                    Expr("b"), Expr("c")),
+                      Expr("d")));
+
+  auto* decl = Decl(var);
+  WrapInFunction(decl);
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitStatement(decl)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(bool tint_tmp_1 = b;
+if (tint_tmp_1) {
+  tint_tmp_1 = c;
+}
+bool tint_tmp = (tint_tmp_1);
+if (!tint_tmp) {
+  tint_tmp = d;
+}
+bool a = (tint_tmp);
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Binary, Bitcast_WithLogical) {
+  // as<i32>(a && (b || c))
+
+  Global("a", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("b", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("c", ty.bool_(), ast::StorageClass::kPrivate);
+
+  auto* expr = create<ast::BitcastExpression>(
+      ty.i32(), create<ast::BinaryExpression>(
+                    ast::BinaryOp::kLogicalAnd, Expr("a"),
+                    create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
+                                                  Expr("b"), Expr("c"))));
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(bool tint_tmp = a;
+if (tint_tmp) {
+  bool tint_tmp_1 = b;
+  if (!tint_tmp_1) {
+    tint_tmp_1 = c;
+  }
+  tint_tmp = (tint_tmp_1);
+}
+)");
+  EXPECT_EQ(out.str(), R"(asint((tint_tmp)))");
+}
+
+TEST_F(GlslGeneratorImplTest_Binary, Call_WithLogical) {
+  // foo(a && b, c || d, (a || c) && (b || d))
+
+  Func("foo",
+       {
+           Param(Sym(), ty.bool_()),
+           Param(Sym(), ty.bool_()),
+           Param(Sym(), ty.bool_()),
+       },
+       ty.void_(), ast::StatementList{}, ast::DecorationList{});
+  Global("a", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("b", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("c", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("d", ty.bool_(), ast::StorageClass::kPrivate);
+
+  ast::ExpressionList params;
+  params.push_back(create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd,
+                                                 Expr("a"), Expr("b")));
+  params.push_back(create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
+                                                 Expr("c"), Expr("d")));
+  params.push_back(create<ast::BinaryExpression>(
+      ast::BinaryOp::kLogicalAnd,
+      create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, Expr("a"),
+                                    Expr("c")),
+      create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, Expr("b"),
+                                    Expr("d"))));
+
+  auto* expr = create<ast::CallStatement>(Call("foo", params));
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitStatement(expr)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(bool tint_tmp = a;
+if (tint_tmp) {
+  tint_tmp = b;
+}
+bool tint_tmp_1 = c;
+if (!tint_tmp_1) {
+  tint_tmp_1 = d;
+}
+bool tint_tmp_3 = a;
+if (!tint_tmp_3) {
+  tint_tmp_3 = c;
+}
+bool tint_tmp_2 = (tint_tmp_3);
+if (tint_tmp_2) {
+  bool tint_tmp_4 = b;
+  if (!tint_tmp_4) {
+    tint_tmp_4 = d;
+  }
+  tint_tmp_2 = (tint_tmp_4);
+}
+foo((tint_tmp), (tint_tmp_1), (tint_tmp_2));
+)");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_bitcast_test.cc b/src/writer/glsl/generator_impl_bitcast_test.cc
new file mode 100644
index 0000000..d744615
--- /dev/null
+++ b/src/writer/glsl/generator_impl_bitcast_test.cc
@@ -0,0 +1,60 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_Bitcast = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Float) {
+  auto* bitcast = create<ast::BitcastExpression>(ty.f32(), Expr(1));
+  WrapInFunction(bitcast);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, bitcast)) << gen.error();
+  EXPECT_EQ(out.str(), "asfloat(1)");
+}
+
+TEST_F(GlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Int) {
+  auto* bitcast = create<ast::BitcastExpression>(ty.i32(), Expr(1u));
+  WrapInFunction(bitcast);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, bitcast)) << gen.error();
+  EXPECT_EQ(out.str(), "asint(1u)");
+}
+
+TEST_F(GlslGeneratorImplTest_Bitcast, EmitExpression_Bitcast_Uint) {
+  auto* bitcast = create<ast::BitcastExpression>(ty.u32(), Expr(1));
+  WrapInFunction(bitcast);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, bitcast)) << gen.error();
+  EXPECT_EQ(out.str(), "asuint(1)");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_block_test.cc b/src/writer/glsl/generator_impl_block_test.cc
new file mode 100644
index 0000000..191d9e8
--- /dev/null
+++ b/src/writer/glsl/generator_impl_block_test.cc
@@ -0,0 +1,42 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_Block = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_Block, Emit_Block) {
+  auto* b = Block(create<ast::DiscardStatement>());
+  WrapInFunction(b);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(b)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  {
+    discard;
+  }
+)");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_break_test.cc b/src/writer/glsl/generator_impl_break_test.cc
new file mode 100644
index 0000000..722e352
--- /dev/null
+++ b/src/writer/glsl/generator_impl_break_test.cc
@@ -0,0 +1,39 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_Break = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_Break, Emit_Break) {
+  auto* b = create<ast::BreakStatement>();
+  WrapInFunction(Loop(Block(b)));
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(b)) << gen.error();
+  EXPECT_EQ(gen.result(), "  break;\n");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_call_test.cc b/src/writer/glsl/generator_impl_call_test.cc
new file mode 100644
index 0000000..3d17148
--- /dev/null
+++ b/src/writer/glsl/generator_impl_call_test.cc
@@ -0,0 +1,81 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/ast/call_statement.h"
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_Call = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_Call, EmitExpression_Call_WithoutParams) {
+  Func("my_func", {}, ty.f32(), {Return(1.23f)});
+
+  auto* call = Call("my_func");
+  WrapInFunction(call);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, call)) << gen.error();
+  EXPECT_EQ(out.str(), "my_func()");
+}
+
+TEST_F(GlslGeneratorImplTest_Call, EmitExpression_Call_WithParams) {
+  Func("my_func",
+       {
+           Param(Sym(), ty.f32()),
+           Param(Sym(), ty.f32()),
+       },
+       ty.f32(), {Return(1.23f)});
+  Global("param1", ty.f32(), ast::StorageClass::kPrivate);
+  Global("param2", ty.f32(), ast::StorageClass::kPrivate);
+
+  auto* call = Call("my_func", "param1", "param2");
+  WrapInFunction(call);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, call)) << gen.error();
+  EXPECT_EQ(out.str(), "my_func(param1, param2)");
+}
+
+TEST_F(GlslGeneratorImplTest_Call, EmitStatement_Call) {
+  Func("my_func",
+       {
+           Param(Sym(), ty.f32()),
+           Param(Sym(), ty.f32()),
+       },
+       ty.void_(), ast::StatementList{}, ast::DecorationList{});
+  Global("param1", ty.f32(), ast::StorageClass::kPrivate);
+  Global("param2", ty.f32(), ast::StorageClass::kPrivate);
+
+  auto* call = create<ast::CallStatement>(Call("my_func", "param1", "param2"));
+  WrapInFunction(call);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+  ASSERT_TRUE(gen.EmitStatement(call)) << gen.error();
+  EXPECT_EQ(gen.result(), "  my_func(param1, param2);\n");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_case_test.cc b/src/writer/glsl/generator_impl_case_test.cc
new file mode 100644
index 0000000..10d1c51
--- /dev/null
+++ b/src/writer/glsl/generator_impl_case_test.cc
@@ -0,0 +1,109 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/ast/fallthrough_statement.h"
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_Case = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_Case, Emit_Case) {
+  auto* s = Switch(1, Case(Literal(5), Block(create<ast::BreakStatement>())),
+                   DefaultCase());
+  WrapInFunction(s);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitCase(s->body()[0])) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  case 5: {
+    break;
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Case, Emit_Case_BreaksByDefault) {
+  auto* s = Switch(1, Case(Literal(5), Block()), DefaultCase());
+  WrapInFunction(s);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitCase(s->body()[0])) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  case 5: {
+    break;
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Case, Emit_Case_WithFallthrough) {
+  auto* s =
+      Switch(1, Case(Literal(5), Block(create<ast::FallthroughStatement>())),
+             DefaultCase());
+  WrapInFunction(s);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitCase(s->body()[0])) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  case 5: {
+    /* fallthrough */
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Case, Emit_Case_MultipleSelectors) {
+  auto* s = Switch(
+      1, Case({Literal(5), Literal(6)}, Block(create<ast::BreakStatement>())),
+      DefaultCase());
+  WrapInFunction(s);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitCase(s->body()[0])) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  case 5:
+  case 6: {
+    break;
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Case, Emit_Case_Default) {
+  auto* s = Switch(1, DefaultCase(Block(create<ast::BreakStatement>())));
+  WrapInFunction(s);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitCase(s->body()[0])) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  default: {
+    break;
+  }
+)");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_cast_test.cc b/src/writer/glsl/generator_impl_cast_test.cc
new file mode 100644
index 0000000..207a4c3
--- /dev/null
+++ b/src/writer/glsl/generator_impl_cast_test.cc
@@ -0,0 +1,49 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_Cast = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_Cast, EmitExpression_Cast_Scalar) {
+  auto* cast = Construct<f32>(1);
+  WrapInFunction(cast);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, cast)) << gen.error();
+  EXPECT_EQ(out.str(), "float(1)");
+}
+
+TEST_F(GlslGeneratorImplTest_Cast, EmitExpression_Cast_Vector) {
+  auto* cast = vec3<f32>(vec3<i32>(1, 2, 3));
+  WrapInFunction(cast);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, cast)) << gen.error();
+  EXPECT_EQ(out.str(), "vec3(ivec3(1, 2, 3))");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_constructor_test.cc b/src/writer/glsl/generator_impl_constructor_test.cc
new file mode 100644
index 0000000..f70b5f3
--- /dev/null
+++ b/src/writer/glsl/generator_impl_constructor_test.cc
@@ -0,0 +1,241 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "gmock/gmock.h"
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using ::testing::HasSubstr;
+
+using GlslGeneratorImplTest_Constructor = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_Constructor, EmitConstructor_Bool) {
+  WrapInFunction(Expr(false));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("false"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor, EmitConstructor_Int) {
+  WrapInFunction(Expr(-12345));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("-12345"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor, EmitConstructor_UInt) {
+  WrapInFunction(Expr(56779u));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("56779u"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor, EmitConstructor_Float) {
+  // Use a number close to 1<<30 but whose decimal representation ends in 0.
+  WrapInFunction(Expr(static_cast<float>((1 << 30) - 4)));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("1073741824.0f"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor, EmitConstructor_Type_Float) {
+  WrapInFunction(Construct<f32>(-1.2e-5f));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("float(-0.000012f)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor, EmitConstructor_Type_Bool) {
+  WrapInFunction(Construct<bool>(true));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("bool(true)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor, EmitConstructor_Type_Int) {
+  WrapInFunction(Construct<i32>(-12345));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("int(-12345)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor, EmitConstructor_Type_Uint) {
+  WrapInFunction(Construct<u32>(12345u));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("uint(12345u)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor, EmitConstructor_Type_Vec) {
+  WrapInFunction(vec3<f32>(1.f, 2.f, 3.f));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("vec3(1.0f, 2.0f, 3.0f)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor, EmitConstructor_Type_Vec_Empty) {
+  WrapInFunction(vec3<f32>());
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("vec3(0.0f, 0.0f, 0.0f)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor,
+       EmitConstructor_Type_Vec_SingleScalar_Float) {
+  WrapInFunction(vec3<f32>(2.0f));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("vec3((2.0f).xxx)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor,
+       EmitConstructor_Type_Vec_SingleScalar_Bool) {
+  WrapInFunction(vec3<bool>(true));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("bvec3((true).xxx)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor,
+       EmitConstructor_Type_Vec_SingleScalar_Int) {
+  WrapInFunction(vec3<i32>(2));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("ivec3((2).xxx)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor,
+       EmitConstructor_Type_Vec_SingleScalar_UInt) {
+  WrapInFunction(vec3<u32>(2u));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("uvec3((2u).xxx)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor, EmitConstructor_Type_Mat) {
+  WrapInFunction(
+      mat2x3<f32>(vec3<f32>(1.f, 2.f, 3.f), vec3<f32>(3.f, 4.f, 5.f)));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+
+  EXPECT_THAT(
+      gen.result(),
+      HasSubstr("mat2x3(vec3(1.0f, 2.0f, 3.0f), vec3(3.0f, 4.0f, 5.0f))"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor, EmitConstructor_Type_Mat_Empty) {
+  WrapInFunction(mat2x3<f32>());
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+
+  EXPECT_THAT(gen.result(),
+              HasSubstr("mat2x3(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor, EmitConstructor_Type_Array) {
+  WrapInFunction(Construct(ty.array(ty.vec3<f32>(), 3),
+                           vec3<f32>(1.f, 2.f, 3.f), vec3<f32>(4.f, 5.f, 6.f),
+                           vec3<f32>(7.f, 8.f, 9.f)));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("vec3[3](vec3(1.0f, 2.0f, 3.0f), "
+                                      "vec3(4.0f, 5.0f, 6.0f), "
+                                      "vec3(7.0f, 8.0f, 9.0f))"));
+}
+
+// TODO(bclayton): Zero-init arrays
+TEST_F(GlslGeneratorImplTest_Constructor,
+       DISABLED_EmitConstructor_Type_Array_Empty) {
+  WrapInFunction(Construct(ty.array(ty.vec3<f32>(), 3)));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(),
+              HasSubstr("{vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f),"
+                        " vec3(0.0f, 0.0f, 0.0f)}"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor, EmitConstructor_Type_Struct) {
+  auto* str = Structure("S", {
+                                 Member("a", ty.i32()),
+                                 Member("b", ty.f32()),
+                                 Member("c", ty.vec3<i32>()),
+                             });
+
+  WrapInFunction(Construct(ty.Of(str), 1, 2.0f, vec3<i32>(3, 4, 5)));
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("S(1, 2.0f, ivec3(3, 4, 5))"));
+}
+
+TEST_F(GlslGeneratorImplTest_Constructor, EmitConstructor_Type_Struct_Empty) {
+  auto* str = Structure("S", {
+                                 Member("a", ty.i32()),
+                                 Member("b", ty.f32()),
+                                 Member("c", ty.vec3<i32>()),
+                             });
+
+  WrapInFunction(Construct(ty.Of(str)));
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("S(0"));
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_continue_test.cc b/src/writer/glsl/generator_impl_continue_test.cc
new file mode 100644
index 0000000..66cd37d
--- /dev/null
+++ b/src/writer/glsl/generator_impl_continue_test.cc
@@ -0,0 +1,42 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_Continue = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_Continue, Emit_Continue) {
+  auto* loop = Loop(Block(create<ast::ContinueStatement>()));
+  WrapInFunction(loop);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(loop)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  while (true) {
+    continue;
+  }
+)");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_discard_test.cc b/src/writer/glsl/generator_impl_discard_test.cc
new file mode 100644
index 0000000..551c24f
--- /dev/null
+++ b/src/writer/glsl/generator_impl_discard_test.cc
@@ -0,0 +1,39 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_Discard = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_Discard, Emit_Discard) {
+  auto* stmt = create<ast::DiscardStatement>();
+  WrapInFunction(stmt);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
+  EXPECT_EQ(gen.result(), "  discard;\n");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_function_test.cc b/src/writer/glsl/generator_impl_function_test.cc
new file mode 100644
index 0000000..e0ed9d9
--- /dev/null
+++ b/src/writer/glsl/generator_impl_function_test.cc
@@ -0,0 +1,1079 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "gmock/gmock.h"
+#include "src/ast/stage_decoration.h"
+#include "src/ast/struct_block_decoration.h"
+#include "src/ast/variable_decl_statement.h"
+#include "src/ast/workgroup_decoration.h"
+#include "src/writer/glsl/test_helper.h"
+
+using ::testing::HasSubstr;
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_Function = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_Function, Emit_Function) {
+  Func("my_func", ast::VariableList{}, ty.void_(),
+       {
+           Return(),
+       });
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  #version 310 es
+  precision mediump float;
+
+  void my_func() {
+    return;
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function, Emit_Function_Name_Collision) {
+  Func("centroid", ast::VariableList{}, ty.void_(),
+       {
+           Return(),
+       });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr(R"(  void tint_symbol() {
+    return;
+  })"));
+}
+
+TEST_F(GlslGeneratorImplTest_Function, Emit_Function_WithParams) {
+  Func("my_func", ast::VariableList{Param("a", ty.f32()), Param("b", ty.i32())},
+       ty.void_(),
+       {
+           Return(),
+       });
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  #version 310 es
+  precision mediump float;
+
+  void my_func(float a, int b) {
+    return;
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Decoration_EntryPoint_NoReturn_Void) {
+  Func("func", ast::VariableList{}, ty.void_(), {/* no explicit return */},
+       {
+           Stage(ast::PipelineStage::kFragment),
+       });
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+void func() {
+  return;
+}
+void main() {
+  func();
+}
+
+
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function, PtrParameter) {
+  // fn f(foo : ptr<function, f32>) -> f32 {
+  //   return *foo;
+  // }
+  Func("f", {Param("foo", ty.pointer<f32>(ast::StorageClass::kFunction))},
+       ty.f32(), {Return(Deref("foo"))});
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr(R"(float f(inout float foo) {
+  return foo;
+}
+)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Decoration_EntryPoint_WithInOutVars) {
+  // fn frag_main([[location(0)]] foo : f32) -> [[location(1)]] f32 {
+  //   return foo;
+  // }
+  auto* foo_in = Param("foo", ty.f32(), {Location(0)});
+  Func("frag_main", ast::VariableList{foo_in}, ty.f32(), {Return("foo")},
+       {Stage(ast::PipelineStage::kFragment)}, {Location(1)});
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+struct tint_symbol_1 {
+  float foo;
+};
+struct tint_symbol_2 {
+  float value;
+};
+
+float frag_main_inner(float foo) {
+  return foo;
+}
+
+tint_symbol_2 frag_main(tint_symbol_1 tint_symbol) {
+  float inner_result = frag_main_inner(tint_symbol.foo);
+  tint_symbol_2 wrapper_result = tint_symbol_2(0.0f);
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
+in float foo;
+out float value;
+void main() {
+  tint_symbol_1 inputs;
+  inputs.foo = foo;
+  tint_symbol_2 outputs;
+  outputs = frag_main(inputs);
+  value = outputs.value;
+}
+
+
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Decoration_EntryPoint_WithInOut_Builtins) {
+  // fn frag_main([[position(0)]] coord : vec4<f32>) -> [[frag_depth]] f32 {
+  //   return coord.x;
+  // }
+  auto* coord_in =
+      Param("coord", ty.vec4<f32>(), {Builtin(ast::Builtin::kPosition)});
+  Func("frag_main", ast::VariableList{coord_in}, ty.f32(),
+       {Return(MemberAccessor("coord", "x"))},
+       {Stage(ast::PipelineStage::kFragment)},
+       {Builtin(ast::Builtin::kFragDepth)});
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+struct tint_symbol_1 {
+  vec4 coord;
+};
+struct tint_symbol_2 {
+  float value;
+};
+
+float frag_main_inner(vec4 coord) {
+  return coord.x;
+}
+
+tint_symbol_2 frag_main(tint_symbol_1 tint_symbol) {
+  float inner_result = frag_main_inner(tint_symbol.coord);
+  tint_symbol_2 wrapper_result = tint_symbol_2(0.0f);
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
+void main() {
+  tint_symbol_1 inputs;
+  inputs.coord = gl_Position;
+  tint_symbol_2 outputs;
+  outputs = frag_main(inputs);
+  gl_FragDepth = outputs.value;
+}
+
+
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Decoration_EntryPoint_SharedStruct_DifferentStages) {
+  // struct Interface {
+  //   [[builtin(position)]] pos : vec4<f32>;
+  //   [[location(1)]] col1 : f32;
+  //   [[location(2)]] col2 : f32;
+  // };
+  // fn vert_main() -> Interface {
+  //   return Interface(vec4<f32>(), 0.4, 0.6);
+  // }
+  // fn frag_main(inputs : Interface) {
+  //   const r = inputs.col1;
+  //   const g = inputs.col2;
+  //   const p = inputs.pos;
+  // }
+  auto* interface_struct = Structure(
+      "Interface",
+      {
+          Member("pos", ty.vec4<f32>(), {Builtin(ast::Builtin::kPosition)}),
+          Member("col1", ty.f32(), {Location(1)}),
+          Member("col2", ty.f32(), {Location(2)}),
+      });
+
+  Func("vert_main", {}, ty.Of(interface_struct),
+       {Return(Construct(ty.Of(interface_struct), Construct(ty.vec4<f32>()),
+                         Expr(0.5f), Expr(0.25f)))},
+       {Stage(ast::PipelineStage::kVertex)});
+
+  Func("frag_main", {Param("inputs", ty.Of(interface_struct))}, ty.void_(),
+       {
+           Decl(Const("r", ty.f32(), MemberAccessor("inputs", "col1"))),
+           Decl(Const("g", ty.f32(), MemberAccessor("inputs", "col2"))),
+           Decl(Const("p", ty.vec4<f32>(), MemberAccessor("inputs", "pos"))),
+       },
+       {Stage(ast::PipelineStage::kFragment)});
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+struct Interface {
+  vec4 pos;
+  float col1;
+  float col2;
+};
+struct tint_symbol {
+  float col1;
+  float col2;
+  vec4 pos;
+};
+
+Interface vert_main_inner() {
+  Interface tint_symbol_3 = Interface(vec4(0.0f, 0.0f, 0.0f, 0.0f), 0.5f, 0.25f);
+  return tint_symbol_3;
+}
+
+tint_symbol vert_main() {
+  Interface inner_result = vert_main_inner();
+  tint_symbol wrapper_result = tint_symbol(0.0f, 0.0f, vec4(0.0f, 0.0f, 0.0f, 0.0f));
+  wrapper_result.pos = inner_result.pos;
+  wrapper_result.col1 = inner_result.col1;
+  wrapper_result.col2 = inner_result.col2;
+  return wrapper_result;
+}
+out float col1;
+out float col2;
+void main() {
+  tint_symbol outputs;
+  outputs = vert_main();
+  col1 = outputs.col1;
+  col2 = outputs.col2;
+  gl_Position = outputs.pos;
+}
+
+
+
+struct tint_symbol_2 {
+  float col1;
+  float col2;
+  vec4 pos;
+};
+
+void frag_main_inner(Interface inputs) {
+  float r = inputs.col1;
+  float g = inputs.col2;
+  vec4 p = inputs.pos;
+}
+
+void frag_main(tint_symbol_2 tint_symbol_1) {
+  Interface tint_symbol_4 = Interface(tint_symbol_1.pos, tint_symbol_1.col1, tint_symbol_1.col2);
+  frag_main_inner(tint_symbol_4);
+  return;
+}
+in float col1;
+in float col2;
+void main() {
+  tint_symbol_2 inputs;
+  inputs.col1 = col1;
+  inputs.col2 = col2;
+  inputs.pos = gl_Position;
+  frag_main(inputs);
+}
+
+
+)");
+}
+
+#if 0
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Decoration_EntryPoint_SharedStruct_HelperFunction) {
+  // struct VertexOutput {
+  //   [[builtin(position)]] pos : vec4<f32>;
+  // };
+  // fn foo(x : f32) -> VertexOutput {
+  //   return VertexOutput(vec4<f32>(x, x, x, 1.0));
+  // }
+  // fn vert_main1() -> VertexOutput {
+  //   return foo(0.5);
+  // }
+  // fn vert_main2() -> VertexOutput {
+  //   return foo(0.25);
+  // }
+  auto* vertex_output_struct = Structure(
+      "VertexOutput",
+      {Member("pos", ty.vec4<f32>(), {Builtin(ast::Builtin::kPosition)})});
+
+  Func("foo", {Param("x", ty.f32())}, ty.Of(vertex_output_struct),
+       {Return(Construct(ty.Of(vertex_output_struct),
+                         Construct(ty.vec4<f32>(), "x", "x", "x", Expr(1.f))))},
+       {});
+
+  Func("vert_main1", {}, ty.Of(vertex_output_struct),
+       {Return(Construct(ty.Of(vertex_output_struct),
+                         Expr(Call("foo", Expr(0.5f)))))},
+       {Stage(ast::PipelineStage::kVertex)});
+
+  Func("vert_main2", {}, ty.Of(vertex_output_struct),
+       {Return(Construct(ty.Of(vertex_output_struct),
+                         Expr(Call("foo", Expr(0.25f)))))},
+       {Stage(ast::PipelineStage::kVertex)});
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(struct VertexOutput {
+  float4 pos;
+};
+
+VertexOutput foo(float x) {
+  const VertexOutput tint_symbol_4 = {float4(x, x, x, 1.0f)};
+  return tint_symbol_4;
+}
+
+struct tint_symbol {
+  float4 pos : SV_Position;
+};
+
+tint_symbol vert_main1() {
+  const VertexOutput tint_symbol_1 = {foo(0.5f)};
+  const tint_symbol tint_symbol_5 = {tint_symbol_1.pos};
+  return tint_symbol_5;
+}
+
+struct tint_symbol_2 {
+  float4 pos : SV_Position;
+};
+
+tint_symbol_2 vert_main2() {
+  const VertexOutput tint_symbol_3 = {foo(0.25f)};
+  const tint_symbol_2 tint_symbol_6 = {tint_symbol_3.pos};
+  return tint_symbol_6;
+}
+)");
+}
+#endif
+
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Decoration_EntryPoint_With_Uniform) {
+  auto* ubo_ty = Structure("UBO", {Member("coord", ty.vec4<f32>())},
+                           {create<ast::StructBlockDecoration>()});
+  auto* ubo = Global("ubo", ty.Of(ubo_ty), ast::StorageClass::kUniform,
+                     ast::DecorationList{
+                         create<ast::BindingDecoration>(0),
+                         create<ast::GroupDecoration>(1),
+                     });
+
+  Func("sub_func",
+       {
+           Param("param", ty.f32()),
+       },
+       ty.f32(),
+       {
+           Return(MemberAccessor(MemberAccessor(ubo, "coord"), "x")),
+       });
+
+  auto* var =
+      Var("v", ty.f32(), ast::StorageClass::kNone, Call("sub_func", 1.0f));
+
+  Func("frag_main", {}, ty.void_(),
+       {
+           Decl(var),
+           Return(),
+       },
+       {
+           Stage(ast::PipelineStage::kFragment),
+       });
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+struct UBO {
+  vec4 coord;
+};
+
+uniform UBO ubo;
+
+float sub_func(float param) {
+  return ubo.coord.x;
+}
+
+void frag_main() {
+  float v = sub_func(1.0f);
+  return;
+}
+void main() {
+  frag_main();
+}
+
+
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Decoration_EntryPoint_With_UniformStruct) {
+  auto* s = Structure("Uniforms", {Member("coord", ty.vec4<f32>())},
+                      {create<ast::StructBlockDecoration>()});
+
+  Global("uniforms", ty.Of(s), ast::StorageClass::kUniform,
+         ast::DecorationList{
+             create<ast::BindingDecoration>(0),
+             create<ast::GroupDecoration>(1),
+         });
+
+  auto* var = Var("v", ty.f32(), ast::StorageClass::kNone,
+                  MemberAccessor(MemberAccessor("uniforms", "coord"), "x"));
+
+  Func("frag_main", ast::VariableList{}, ty.void_(),
+       {
+           Decl(var),
+           Return(),
+       },
+       {
+           Stage(ast::PipelineStage::kFragment),
+       });
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+struct Uniforms {
+  vec4 coord;
+};
+
+uniform Uniforms uniforms;
+
+void frag_main() {
+  float v = uniforms.coord.x;
+  return;
+}
+void main() {
+  frag_main();
+}
+
+
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Decoration_EntryPoint_With_RW_StorageBuffer_Read) {
+  auto* s = Structure("Data",
+                      {
+                          Member("a", ty.i32()),
+                          Member("b", ty.f32()),
+                      },
+                      {create<ast::StructBlockDecoration>()});
+
+  Global("coord", ty.Of(s), ast::StorageClass::kStorage,
+         ast::Access::kReadWrite,
+         ast::DecorationList{
+             create<ast::BindingDecoration>(0),
+             create<ast::GroupDecoration>(1),
+         });
+
+  auto* var = Var("v", ty.f32(), ast::StorageClass::kNone,
+                  MemberAccessor("coord", "b"));
+
+  Func("frag_main", ast::VariableList{}, ty.void_(),
+       {
+           Decl(var),
+           Return(),
+       },
+       {
+           Stage(ast::PipelineStage::kFragment),
+       });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+
+Data coord : register(u0, space1);
+
+void frag_main() {
+  float v = coord.b;
+  return;
+}
+void main() {
+  frag_main();
+}
+
+
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Decoration_EntryPoint_With_RO_StorageBuffer_Read) {
+  auto* s = Structure("Data",
+                      {
+                          Member("a", ty.i32()),
+                          Member("b", ty.f32()),
+                      },
+                      {create<ast::StructBlockDecoration>()});
+
+  Global("coord", ty.Of(s), ast::StorageClass::kStorage, ast::Access::kRead,
+         ast::DecorationList{
+             create<ast::BindingDecoration>(0),
+             create<ast::GroupDecoration>(1),
+         });
+
+  auto* var = Var("v", ty.f32(), ast::StorageClass::kNone,
+                  MemberAccessor("coord", "b"));
+
+  Func("frag_main", ast::VariableList{}, ty.void_(),
+       {
+           Decl(var),
+           Return(),
+       },
+       {
+           Stage(ast::PipelineStage::kFragment),
+       });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(),
+            R"(#version 310 es
+precision mediump float;
+
+
+Data coord : register(t0, space1);
+
+void frag_main() {
+  float v = coord.b;
+  return;
+}
+void main() {
+  frag_main();
+}
+
+
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Decoration_EntryPoint_With_WO_StorageBuffer_Store) {
+  auto* s = Structure("Data",
+                      {
+                          Member("a", ty.i32()),
+                          Member("b", ty.f32()),
+                      },
+                      {create<ast::StructBlockDecoration>()});
+
+  Global("coord", ty.Of(s), ast::StorageClass::kStorage, ast::Access::kWrite,
+         ast::DecorationList{
+             create<ast::BindingDecoration>(0),
+             create<ast::GroupDecoration>(1),
+         });
+
+  Func("frag_main", ast::VariableList{}, ty.void_(),
+       {
+           Assign(MemberAccessor("coord", "b"), Expr(2.0f)),
+           Return(),
+       },
+       {
+           Stage(ast::PipelineStage::kFragment),
+       });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+
+Data coord : register(u0, space1);
+
+void frag_main() {
+  coord.b = 2.0f;
+  return;
+}
+void main() {
+  frag_main();
+}
+
+
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Decoration_EntryPoint_With_StorageBuffer_Store) {
+  auto* s = Structure("Data",
+                      {
+                          Member("a", ty.i32()),
+                          Member("b", ty.f32()),
+                      },
+                      {create<ast::StructBlockDecoration>()});
+
+  Global("coord", ty.Of(s), ast::StorageClass::kStorage,
+         ast::Access::kReadWrite,
+         ast::DecorationList{
+             create<ast::BindingDecoration>(0),
+             create<ast::GroupDecoration>(1),
+         });
+
+  Func("frag_main", ast::VariableList{}, ty.void_(),
+       {
+           Assign(MemberAccessor("coord", "b"), Expr(2.0f)),
+           Return(),
+       },
+       {
+           Stage(ast::PipelineStage::kFragment),
+       });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+
+Data coord : register(u0, space1);
+
+void frag_main() {
+  coord.b = 2.0f;
+  return;
+}
+void main() {
+  frag_main();
+}
+
+
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Decoration_Called_By_EntryPoint_With_Uniform) {
+  auto* s = Structure("S", {Member("x", ty.f32())},
+                      {create<ast::StructBlockDecoration>()});
+  Global("coord", ty.Of(s), ast::StorageClass::kUniform,
+         ast::DecorationList{
+             create<ast::BindingDecoration>(0),
+             create<ast::GroupDecoration>(1),
+         });
+
+  Func("sub_func", ast::VariableList{Param("param", ty.f32())}, ty.f32(),
+       {
+           Return(MemberAccessor("coord", "x")),
+       });
+
+  auto* var =
+      Var("v", ty.f32(), ast::StorageClass::kNone, Call("sub_func", 1.0f));
+
+  Func("frag_main", ast::VariableList{}, ty.void_(),
+       {
+           Decl(var),
+           Return(),
+       },
+       {
+           Stage(ast::PipelineStage::kFragment),
+       });
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+struct S {
+  float x;
+};
+
+uniform S coord;
+
+float sub_func(float param) {
+  return coord.x;
+}
+
+void frag_main() {
+  float v = sub_func(1.0f);
+  return;
+}
+void main() {
+  frag_main();
+}
+
+
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Decoration_Called_By_EntryPoint_With_StorageBuffer) {
+  auto* s = Structure("S", {Member("x", ty.f32())},
+                      {create<ast::StructBlockDecoration>()});
+  Global("coord", ty.Of(s), ast::StorageClass::kStorage,
+         ast::Access::kReadWrite,
+         ast::DecorationList{
+             create<ast::BindingDecoration>(0),
+             create<ast::GroupDecoration>(1),
+         });
+
+  Func("sub_func", ast::VariableList{Param("param", ty.f32())}, ty.f32(),
+       {
+           Return(MemberAccessor("coord", "x")),
+       });
+
+  auto* var =
+      Var("v", ty.f32(), ast::StorageClass::kNone, Call("sub_func", 1.0f));
+
+  Func("frag_main", ast::VariableList{}, ty.void_(),
+       {
+           Decl(var),
+           Return(),
+       },
+       {
+           Stage(ast::PipelineStage::kFragment),
+       });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(),
+            R"(#version 310 es
+precision mediump float;
+
+
+S coord : register(u0, space1);
+
+float sub_func(float param) {
+  return coord.x;
+}
+
+void frag_main() {
+  float v = sub_func(1.0f);
+  return;
+}
+void main() {
+  frag_main();
+}
+
+
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Decoration_EntryPoint_WithNameCollision) {
+  Func("centroid", ast::VariableList{}, ty.void_(), {},
+       {
+           Stage(ast::PipelineStage::kFragment),
+       });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+void tint_symbol() {
+  return;
+}
+void main() {
+  tint_symbol();
+}
+
+
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function, Emit_Decoration_EntryPoint_Compute) {
+  Func("main", ast::VariableList{}, ty.void_(),
+       {
+           Return(),
+       },
+       {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1)});
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+[numthreads(1, 1, 1)]
+void main() {
+  return;
+}
+void main() {
+  main();
+}
+
+
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Decoration_EntryPoint_Compute_WithWorkgroup_Literal) {
+  Func("main", ast::VariableList{}, ty.void_(), {},
+       {
+           Stage(ast::PipelineStage::kCompute),
+           WorkgroupSize(2, 4, 6),
+       });
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+[numthreads(2, 4, 6)]
+void main() {
+  return;
+}
+void main() {
+  main();
+}
+
+
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Decoration_EntryPoint_Compute_WithWorkgroup_Const) {
+  GlobalConst("width", ty.i32(), Construct(ty.i32(), 2));
+  GlobalConst("height", ty.i32(), Construct(ty.i32(), 3));
+  GlobalConst("depth", ty.i32(), Construct(ty.i32(), 4));
+  Func("main", ast::VariableList{}, ty.void_(), {},
+       {
+           Stage(ast::PipelineStage::kCompute),
+           WorkgroupSize("width", "height", "depth"),
+       });
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+static const int width = int(2);
+static const int height = int(3);
+static const int depth = int(4);
+
+[numthreads(2, 3, 4)]
+void main() {
+  return;
+}
+void main() {
+  main();
+}
+
+
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Decoration_EntryPoint_Compute_WithWorkgroup_OverridableConst) {
+  GlobalConst("width", ty.i32(), Construct(ty.i32(), 2), {Override(7u)});
+  GlobalConst("height", ty.i32(), Construct(ty.i32(), 3), {Override(8u)});
+  GlobalConst("depth", ty.i32(), Construct(ty.i32(), 4), {Override(9u)});
+  Func("main", ast::VariableList{}, ty.void_(), {},
+       {
+           Stage(ast::PipelineStage::kCompute),
+           WorkgroupSize("width", "height", "depth"),
+       });
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+#ifndef WGSL_SPEC_CONSTANT_7
+#define WGSL_SPEC_CONSTANT_7 int(2)
+#endif
+static const int width = WGSL_SPEC_CONSTANT_7;
+#ifndef WGSL_SPEC_CONSTANT_8
+#define WGSL_SPEC_CONSTANT_8 int(3)
+#endif
+static const int height = WGSL_SPEC_CONSTANT_8;
+#ifndef WGSL_SPEC_CONSTANT_9
+#define WGSL_SPEC_CONSTANT_9 int(4)
+#endif
+static const int depth = WGSL_SPEC_CONSTANT_9;
+
+[numthreads(WGSL_SPEC_CONSTANT_7, WGSL_SPEC_CONSTANT_8, WGSL_SPEC_CONSTANT_9)]
+void main() {
+  return;
+}
+void main() {
+  main();
+}
+
+
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function, Emit_Function_WithArrayParams) {
+  Func("my_func", ast::VariableList{Param("a", ty.array<f32, 5>())}, ty.void_(),
+       {
+           Return(),
+       });
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+void my_func(float a[5]) {
+  return;
+}
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Function, Emit_Function_WithArrayReturn) {
+  Func("my_func", {}, ty.array<f32, 5>(),
+       {
+           Return(Construct(ty.array<f32, 5>())),
+       });
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+typedef float my_func_ret[5];
+my_func_ret my_func() {
+  return float[5](0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
+}
+)");
+}
+
+// https://crbug.com/tint/297
+TEST_F(GlslGeneratorImplTest_Function,
+       Emit_Multiple_EntryPoint_With_Same_ModuleVar) {
+  // [[block]] struct Data {
+  //   d : f32;
+  // };
+  // [[binding(0), group(0)]] var<storage> data : Data;
+  //
+  // [[stage(compute), workgroup_size(1)]]
+  // fn a() {
+  //   var v = data.d;
+  //   return;
+  // }
+  //
+  // [[stage(compute), workgroup_size(1)]]
+  // fn b() {
+  //   var v = data.d;
+  //   return;
+  // }
+
+  auto* s = Structure("Data", {Member("d", ty.f32())},
+                      {create<ast::StructBlockDecoration>()});
+
+  Global("data", ty.Of(s), ast::StorageClass::kStorage, ast::Access::kReadWrite,
+         ast::DecorationList{
+             create<ast::BindingDecoration>(0),
+             create<ast::GroupDecoration>(0),
+         });
+
+  {
+    auto* var = Var("v", ty.f32(), ast::StorageClass::kNone,
+                    MemberAccessor("data", "d"));
+
+    Func("a", ast::VariableList{}, ty.void_(),
+         {
+             Decl(var),
+             Return(),
+         },
+         {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1)});
+  }
+
+  {
+    auto* var = Var("v", ty.f32(), ast::StorageClass::kNone,
+                    MemberAccessor("data", "d"));
+
+    Func("b", ast::VariableList{}, ty.void_(),
+         {
+             Decl(var),
+             Return(),
+         },
+         {Stage(ast::PipelineStage::kCompute), WorkgroupSize(1)});
+  }
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+
+Data data : register(u0, space0);
+
+[numthreads(1, 1, 1)]
+void a() {
+  float v = data.d;
+  return;
+}
+void main() {
+  a();
+}
+
+
+
+[numthreads(1, 1, 1)]
+void b() {
+  float v = data.d;
+  return;
+}
+void main() {
+  b();
+}
+
+
+)");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_identifier_test.cc b/src/writer/glsl/generator_impl_identifier_test.cc
new file mode 100644
index 0000000..e4c0536
--- /dev/null
+++ b/src/writer/glsl/generator_impl_identifier_test.cc
@@ -0,0 +1,40 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_Identifier = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_Identifier, EmitIdentifierExpression) {
+  Global("foo", ty.i32(), ast::StorageClass::kPrivate);
+
+  auto* i = Expr("foo");
+  WrapInFunction(i);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, i)) << gen.error();
+  EXPECT_EQ(out.str(), "foo");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_if_test.cc b/src/writer/glsl/generator_impl_if_test.cc
new file mode 100644
index 0000000..58b3d48
--- /dev/null
+++ b/src/writer/glsl/generator_impl_if_test.cc
@@ -0,0 +1,135 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_If = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_If, Emit_If) {
+  Global("cond", ty.bool_(), ast::StorageClass::kPrivate);
+
+  auto* cond = Expr("cond");
+  auto* body = Block(Return());
+  auto* i = If(cond, body);
+  WrapInFunction(i);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+  ASSERT_TRUE(gen.EmitStatement(i)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  if (cond) {
+    return;
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_If, Emit_IfWithElseIf) {
+  Global("cond", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("else_cond", ty.bool_(), ast::StorageClass::kPrivate);
+
+  auto* else_cond = Expr("else_cond");
+  auto* else_body = Block(Return());
+
+  auto* cond = Expr("cond");
+  auto* body = Block(Return());
+  auto* i = If(
+      cond, body,
+      ast::ElseStatementList{create<ast::ElseStatement>(else_cond, else_body)});
+  WrapInFunction(i);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(i)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  if (cond) {
+    return;
+  } else {
+    if (else_cond) {
+      return;
+    }
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_If, Emit_IfWithElse) {
+  Global("cond", ty.bool_(), ast::StorageClass::kPrivate);
+
+  auto* else_body = Block(Return());
+
+  auto* cond = Expr("cond");
+  auto* body = Block(Return());
+  auto* i = If(
+      cond, body,
+      ast::ElseStatementList{create<ast::ElseStatement>(nullptr, else_body)});
+  WrapInFunction(i);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(i)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  if (cond) {
+    return;
+  } else {
+    return;
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_If, Emit_IfWithMultiple) {
+  Global("cond", ty.bool_(), ast::StorageClass::kPrivate);
+  Global("else_cond", ty.bool_(), ast::StorageClass::kPrivate);
+
+  auto* else_cond = Expr("else_cond");
+
+  auto* else_body = Block(Return());
+
+  auto* else_body_2 = Block(Return());
+
+  auto* cond = Expr("cond");
+  auto* body = Block(Return());
+  auto* i = If(cond, body,
+               ast::ElseStatementList{
+                   create<ast::ElseStatement>(else_cond, else_body),
+                   create<ast::ElseStatement>(nullptr, else_body_2),
+               });
+  WrapInFunction(i);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(i)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  if (cond) {
+    return;
+  } else {
+    if (else_cond) {
+      return;
+    } else {
+      return;
+    }
+  }
+)");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_import_test.cc b/src/writer/glsl/generator_impl_import_test.cc
new file mode 100644
index 0000000..6e6ee73
--- /dev/null
+++ b/src/writer/glsl/generator_impl_import_test.cc
@@ -0,0 +1,282 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_Import = TestHelper;
+
+struct GlslImportData {
+  const char* name;
+  const char* glsl_name;
+};
+inline std::ostream& operator<<(std::ostream& out, GlslImportData data) {
+  out << data.name;
+  return out;
+}
+
+using GlslImportData_SingleParamTest = TestParamHelper<GlslImportData>;
+TEST_P(GlslImportData_SingleParamTest, FloatScalar) {
+  auto param = GetParam();
+
+  auto* ident = Expr(param.name);
+  auto* expr = Call(ident, 1.f);
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), std::string(param.glsl_name) + "(1.0f)");
+}
+INSTANTIATE_TEST_SUITE_P(GlslGeneratorImplTest_Import,
+                         GlslImportData_SingleParamTest,
+                         testing::Values(GlslImportData{"abs", "abs"},
+                                         GlslImportData{"acos", "acos"},
+                                         GlslImportData{"asin", "asin"},
+                                         GlslImportData{"atan", "atan"},
+                                         GlslImportData{"cos", "cos"},
+                                         GlslImportData{"cosh", "cosh"},
+                                         GlslImportData{"ceil", "ceil"},
+                                         GlslImportData{"exp", "exp"},
+                                         GlslImportData{"exp2", "exp2"},
+                                         GlslImportData{"floor", "floor"},
+                                         GlslImportData{"fract", "frac"},
+                                         GlslImportData{"inverseSqrt", "rsqrt"},
+                                         GlslImportData{"length", "length"},
+                                         GlslImportData{"log", "log"},
+                                         GlslImportData{"log2", "log2"},
+                                         GlslImportData{"round", "round"},
+                                         GlslImportData{"sign", "sign"},
+                                         GlslImportData{"sin", "sin"},
+                                         GlslImportData{"sinh", "sinh"},
+                                         GlslImportData{"sqrt", "sqrt"},
+                                         GlslImportData{"tan", "tan"},
+                                         GlslImportData{"tanh", "tanh"},
+                                         GlslImportData{"trunc", "trunc"}));
+
+using GlslImportData_SingleIntParamTest = TestParamHelper<GlslImportData>;
+TEST_P(GlslImportData_SingleIntParamTest, IntScalar) {
+  auto param = GetParam();
+
+  auto* expr = Call(param.name, Expr(1));
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), std::string(param.glsl_name) + "(1)");
+}
+INSTANTIATE_TEST_SUITE_P(GlslGeneratorImplTest_Import,
+                         GlslImportData_SingleIntParamTest,
+                         testing::Values(GlslImportData{"abs", "abs"}));
+
+using GlslImportData_SingleVectorParamTest = TestParamHelper<GlslImportData>;
+TEST_P(GlslImportData_SingleVectorParamTest, FloatVector) {
+  auto param = GetParam();
+
+  auto* ident = Expr(param.name);
+  auto* expr = Call(ident, vec3<f32>(1.f, 2.f, 3.f));
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(),
+            std::string(param.glsl_name) + "(vec3(1.0f, 2.0f, 3.0f))");
+}
+INSTANTIATE_TEST_SUITE_P(GlslGeneratorImplTest_Import,
+                         GlslImportData_SingleVectorParamTest,
+                         testing::Values(GlslImportData{"abs", "abs"},
+                                         GlslImportData{"acos", "acos"},
+                                         GlslImportData{"asin", "asin"},
+                                         GlslImportData{"atan", "atan"},
+                                         GlslImportData{"cos", "cos"},
+                                         GlslImportData{"cosh", "cosh"},
+                                         GlslImportData{"ceil", "ceil"},
+                                         GlslImportData{"exp", "exp"},
+                                         GlslImportData{"exp2", "exp2"},
+                                         GlslImportData{"floor", "floor"},
+                                         GlslImportData{"fract", "frac"},
+                                         GlslImportData{"inverseSqrt", "rsqrt"},
+                                         GlslImportData{"length", "length"},
+                                         GlslImportData{"log", "log"},
+                                         GlslImportData{"log2", "log2"},
+                                         GlslImportData{"normalize",
+                                                        "normalize"},
+                                         GlslImportData{"round", "round"},
+                                         GlslImportData{"sign", "sign"},
+                                         GlslImportData{"sin", "sin"},
+                                         GlslImportData{"sinh", "sinh"},
+                                         GlslImportData{"sqrt", "sqrt"},
+                                         GlslImportData{"tan", "tan"},
+                                         GlslImportData{"tanh", "tanh"},
+                                         GlslImportData{"trunc", "trunc"}));
+
+using GlslImportData_DualParam_ScalarTest = TestParamHelper<GlslImportData>;
+TEST_P(GlslImportData_DualParam_ScalarTest, Float) {
+  auto param = GetParam();
+
+  auto* expr = Call(param.name, 1.f, 2.f);
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), std::string(param.glsl_name) + "(1.0f, 2.0f)");
+}
+INSTANTIATE_TEST_SUITE_P(GlslGeneratorImplTest_Import,
+                         GlslImportData_DualParam_ScalarTest,
+                         testing::Values(GlslImportData{"atan2", "atan2"},
+                                         GlslImportData{"distance", "distance"},
+                                         GlslImportData{"max", "max"},
+                                         GlslImportData{"min", "min"},
+                                         GlslImportData{"pow", "pow"},
+                                         GlslImportData{"step", "step"}));
+
+using GlslImportData_DualParam_VectorTest = TestParamHelper<GlslImportData>;
+TEST_P(GlslImportData_DualParam_VectorTest, Float) {
+  auto param = GetParam();
+
+  auto* expr =
+      Call(param.name, vec3<f32>(1.f, 2.f, 3.f), vec3<f32>(4.f, 5.f, 6.f));
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), std::string(param.glsl_name) +
+                           "(vec3(1.0f, 2.0f, 3.0f), vec3(4.0f, 5.0f, 6.0f))");
+}
+INSTANTIATE_TEST_SUITE_P(GlslGeneratorImplTest_Import,
+                         GlslImportData_DualParam_VectorTest,
+                         testing::Values(GlslImportData{"atan2", "atan2"},
+                                         GlslImportData{"cross", "cross"},
+                                         GlslImportData{"distance", "distance"},
+                                         GlslImportData{"max", "max"},
+                                         GlslImportData{"min", "min"},
+                                         GlslImportData{"pow", "pow"},
+                                         GlslImportData{"reflect", "reflect"},
+                                         GlslImportData{"step", "step"}));
+
+using GlslImportData_DualParam_Int_Test = TestParamHelper<GlslImportData>;
+TEST_P(GlslImportData_DualParam_Int_Test, IntScalar) {
+  auto param = GetParam();
+
+  auto* expr = Call(param.name, 1, 2);
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), std::string(param.glsl_name) + "(1, 2)");
+}
+INSTANTIATE_TEST_SUITE_P(GlslGeneratorImplTest_Import,
+                         GlslImportData_DualParam_Int_Test,
+                         testing::Values(GlslImportData{"max", "max"},
+                                         GlslImportData{"min", "min"}));
+
+using GlslImportData_TripleParam_ScalarTest = TestParamHelper<GlslImportData>;
+TEST_P(GlslImportData_TripleParam_ScalarTest, Float) {
+  auto param = GetParam();
+
+  auto* expr = Call(param.name, 1.f, 2.f, 3.f);
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), std::string(param.glsl_name) + "(1.0f, 2.0f, 3.0f)");
+}
+INSTANTIATE_TEST_SUITE_P(GlslGeneratorImplTest_Import,
+                         GlslImportData_TripleParam_ScalarTest,
+                         testing::Values(GlslImportData{"fma", "mad"},
+                                         GlslImportData{"mix", "lerp"},
+                                         GlslImportData{"clamp", "clamp"},
+                                         GlslImportData{"smoothStep",
+                                                        "smoothstep"}));
+
+using GlslImportData_TripleParam_VectorTest = TestParamHelper<GlslImportData>;
+TEST_P(GlslImportData_TripleParam_VectorTest, Float) {
+  auto param = GetParam();
+
+  auto* expr = Call(param.name, vec3<f32>(1.f, 2.f, 3.f),
+                    vec3<f32>(4.f, 5.f, 6.f), vec3<f32>(7.f, 8.f, 9.f));
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
+  EXPECT_EQ(
+      out.str(),
+      std::string(param.glsl_name) +
+          R"((vec3(1.0f, 2.0f, 3.0f), vec3(4.0f, 5.0f, 6.0f), vec3(7.0f, 8.0f, 9.0f)))");
+}
+INSTANTIATE_TEST_SUITE_P(
+    GlslGeneratorImplTest_Import,
+    GlslImportData_TripleParam_VectorTest,
+    testing::Values(GlslImportData{"faceForward", "faceforward"},
+                    GlslImportData{"fma", "mad"},
+                    GlslImportData{"clamp", "clamp"},
+                    GlslImportData{"smoothStep", "smoothstep"}));
+
+TEST_F(GlslGeneratorImplTest_Import, DISABLED_GlslImportData_FMix) {
+  FAIL();
+}
+
+using GlslImportData_TripleParam_Int_Test = TestParamHelper<GlslImportData>;
+TEST_P(GlslImportData_TripleParam_Int_Test, IntScalar) {
+  auto param = GetParam();
+
+  auto* expr = Call(param.name, 1, 2, 3);
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), std::string(param.glsl_name) + "(1, 2, 3)");
+}
+INSTANTIATE_TEST_SUITE_P(GlslGeneratorImplTest_Import,
+                         GlslImportData_TripleParam_Int_Test,
+                         testing::Values(GlslImportData{"clamp", "clamp"}));
+
+TEST_F(GlslGeneratorImplTest_Import, GlslImportData_Determinant) {
+  Global("var", ty.mat3x3<f32>(), ast::StorageClass::kPrivate);
+
+  auto* expr = Call("determinant", "var");
+  WrapInFunction(expr);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitCall(out, expr)) << gen.error();
+  EXPECT_EQ(out.str(), std::string("determinant(var)"));
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_intrinsic_test.cc b/src/writer/glsl/generator_impl_intrinsic_test.cc
new file mode 100644
index 0000000..646357d
--- /dev/null
+++ b/src/writer/glsl/generator_impl_intrinsic_test.cc
@@ -0,0 +1,605 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "gmock/gmock.h"
+#include "src/ast/call_statement.h"
+#include "src/ast/stage_decoration.h"
+#include "src/sem/call.h"
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using IntrinsicType = sem::IntrinsicType;
+
+using ::testing::HasSubstr;
+
+using GlslGeneratorImplTest_Intrinsic = TestHelper;
+
+enum class ParamType {
+  kF32,
+  kU32,
+  kBool,
+};
+
+struct IntrinsicData {
+  IntrinsicType intrinsic;
+  ParamType type;
+  const char* glsl_name;
+};
+inline std::ostream& operator<<(std::ostream& out, IntrinsicData data) {
+  out << data.glsl_name;
+  switch (data.type) {
+    case ParamType::kF32:
+      out << "f32";
+      break;
+    case ParamType::kU32:
+      out << "u32";
+      break;
+    case ParamType::kBool:
+      out << "bool";
+      break;
+  }
+  out << ">";
+  return out;
+}
+
+ast::CallExpression* GenerateCall(IntrinsicType intrinsic,
+                                  ParamType type,
+                                  ProgramBuilder* builder) {
+  std::string name;
+  std::ostringstream str(name);
+  str << intrinsic;
+  switch (intrinsic) {
+    case IntrinsicType::kAcos:
+    case IntrinsicType::kAsin:
+    case IntrinsicType::kAtan:
+    case IntrinsicType::kCeil:
+    case IntrinsicType::kCos:
+    case IntrinsicType::kCosh:
+    case IntrinsicType::kDpdx:
+    case IntrinsicType::kDpdxCoarse:
+    case IntrinsicType::kDpdxFine:
+    case IntrinsicType::kDpdy:
+    case IntrinsicType::kDpdyCoarse:
+    case IntrinsicType::kDpdyFine:
+    case IntrinsicType::kExp:
+    case IntrinsicType::kExp2:
+    case IntrinsicType::kFloor:
+    case IntrinsicType::kFract:
+    case IntrinsicType::kFwidth:
+    case IntrinsicType::kFwidthCoarse:
+    case IntrinsicType::kFwidthFine:
+    case IntrinsicType::kInverseSqrt:
+    case IntrinsicType::kIsFinite:
+    case IntrinsicType::kIsInf:
+    case IntrinsicType::kIsNan:
+    case IntrinsicType::kIsNormal:
+    case IntrinsicType::kLength:
+    case IntrinsicType::kLog:
+    case IntrinsicType::kLog2:
+    case IntrinsicType::kNormalize:
+    case IntrinsicType::kRound:
+    case IntrinsicType::kSin:
+    case IntrinsicType::kSinh:
+    case IntrinsicType::kSqrt:
+    case IntrinsicType::kTan:
+    case IntrinsicType::kTanh:
+    case IntrinsicType::kTrunc:
+    case IntrinsicType::kSign:
+      return builder->Call(str.str(), "f2");
+    case IntrinsicType::kLdexp:
+      return builder->Call(str.str(), "f2", "i2");
+    case IntrinsicType::kAtan2:
+    case IntrinsicType::kDot:
+    case IntrinsicType::kDistance:
+    case IntrinsicType::kPow:
+    case IntrinsicType::kReflect:
+    case IntrinsicType::kStep:
+      return builder->Call(str.str(), "f2", "f2");
+    case IntrinsicType::kCross:
+      return builder->Call(str.str(), "f3", "f3");
+    case IntrinsicType::kFma:
+    case IntrinsicType::kMix:
+    case IntrinsicType::kFaceForward:
+    case IntrinsicType::kSmoothStep:
+      return builder->Call(str.str(), "f2", "f2", "f2");
+    case IntrinsicType::kAll:
+    case IntrinsicType::kAny:
+      return builder->Call(str.str(), "b2");
+    case IntrinsicType::kAbs:
+      if (type == ParamType::kF32) {
+        return builder->Call(str.str(), "f2");
+      } else {
+        return builder->Call(str.str(), "u2");
+      }
+    case IntrinsicType::kCountOneBits:
+    case IntrinsicType::kReverseBits:
+      return builder->Call(str.str(), "u2");
+    case IntrinsicType::kMax:
+    case IntrinsicType::kMin:
+      if (type == ParamType::kF32) {
+        return builder->Call(str.str(), "f2", "f2");
+      } else {
+        return builder->Call(str.str(), "u2", "u2");
+      }
+    case IntrinsicType::kClamp:
+      if (type == ParamType::kF32) {
+        return builder->Call(str.str(), "f2", "f2", "f2");
+      } else {
+        return builder->Call(str.str(), "u2", "u2", "u2");
+      }
+    case IntrinsicType::kSelect:
+      return builder->Call(str.str(), "f2", "f2", "b2");
+    case IntrinsicType::kDeterminant:
+      return builder->Call(str.str(), "m2x2");
+    case IntrinsicType::kTranspose:
+      return builder->Call(str.str(), "m3x2");
+    default:
+      break;
+  }
+  return nullptr;
+}
+using GlslIntrinsicTest = TestParamHelper<IntrinsicData>;
+TEST_P(GlslIntrinsicTest, Emit) {
+  auto param = GetParam();
+
+  Global("f2", ty.vec2<f32>(), ast::StorageClass::kPrivate);
+  Global("f3", ty.vec3<f32>(), ast::StorageClass::kPrivate);
+  Global("u2", ty.vec2<u32>(), ast::StorageClass::kPrivate);
+  Global("i2", ty.vec2<i32>(), ast::StorageClass::kPrivate);
+  Global("b2", ty.vec2<bool>(), ast::StorageClass::kPrivate);
+  Global("m2x2", ty.mat2x2<f32>(), ast::StorageClass::kPrivate);
+  Global("m3x2", ty.mat3x2<f32>(), ast::StorageClass::kPrivate);
+
+  auto* call = GenerateCall(param.intrinsic, param.type, this);
+  ASSERT_NE(nullptr, call) << "Unhandled intrinsic";
+  Func("func", {}, ty.void_(), {Ignore(call)},
+       {create<ast::StageDecoration>(ast::PipelineStage::kFragment)});
+
+  GeneratorImpl& gen = Build();
+
+  auto* sem = program->Sem().Get(call);
+  ASSERT_NE(sem, nullptr);
+  auto* target = sem->Target();
+  ASSERT_NE(target, nullptr);
+  auto* intrinsic = target->As<sem::Intrinsic>();
+  ASSERT_NE(intrinsic, nullptr);
+
+  EXPECT_EQ(gen.generate_builtin_name(intrinsic), param.glsl_name);
+}
+INSTANTIATE_TEST_SUITE_P(
+    GlslGeneratorImplTest_Intrinsic,
+    GlslIntrinsicTest,
+    testing::Values(
+        IntrinsicData{IntrinsicType::kAbs, ParamType::kF32, "abs"},
+        IntrinsicData{IntrinsicType::kAbs, ParamType::kU32, "abs"},
+        IntrinsicData{IntrinsicType::kAcos, ParamType::kF32, "acos"},
+        IntrinsicData{IntrinsicType::kAll, ParamType::kBool, "all"},
+        IntrinsicData{IntrinsicType::kAny, ParamType::kBool, "any"},
+        IntrinsicData{IntrinsicType::kAsin, ParamType::kF32, "asin"},
+        IntrinsicData{IntrinsicType::kAtan, ParamType::kF32, "atan"},
+        IntrinsicData{IntrinsicType::kAtan2, ParamType::kF32, "atan2"},
+        IntrinsicData{IntrinsicType::kCeil, ParamType::kF32, "ceil"},
+        IntrinsicData{IntrinsicType::kClamp, ParamType::kF32, "clamp"},
+        IntrinsicData{IntrinsicType::kClamp, ParamType::kU32, "clamp"},
+        IntrinsicData{IntrinsicType::kCos, ParamType::kF32, "cos"},
+        IntrinsicData{IntrinsicType::kCosh, ParamType::kF32, "cosh"},
+        IntrinsicData{IntrinsicType::kCountOneBits, ParamType::kU32,
+                      "countbits"},
+        IntrinsicData{IntrinsicType::kCross, ParamType::kF32, "cross"},
+        IntrinsicData{IntrinsicType::kDeterminant, ParamType::kF32,
+                      "determinant"},
+        IntrinsicData{IntrinsicType::kDistance, ParamType::kF32, "distance"},
+        IntrinsicData{IntrinsicType::kDot, ParamType::kF32, "dot"},
+        IntrinsicData{IntrinsicType::kDpdx, ParamType::kF32, "ddx"},
+        IntrinsicData{IntrinsicType::kDpdxCoarse, ParamType::kF32,
+                      "ddx_coarse"},
+        IntrinsicData{IntrinsicType::kDpdxFine, ParamType::kF32, "ddx_fine"},
+        IntrinsicData{IntrinsicType::kDpdy, ParamType::kF32, "ddy"},
+        IntrinsicData{IntrinsicType::kDpdyCoarse, ParamType::kF32,
+                      "ddy_coarse"},
+        IntrinsicData{IntrinsicType::kDpdyFine, ParamType::kF32, "ddy_fine"},
+        IntrinsicData{IntrinsicType::kExp, ParamType::kF32, "exp"},
+        IntrinsicData{IntrinsicType::kExp2, ParamType::kF32, "exp2"},
+        IntrinsicData{IntrinsicType::kFaceForward, ParamType::kF32,
+                      "faceforward"},
+        IntrinsicData{IntrinsicType::kFloor, ParamType::kF32, "floor"},
+        IntrinsicData{IntrinsicType::kFma, ParamType::kF32, "mad"},
+        IntrinsicData{IntrinsicType::kFract, ParamType::kF32, "frac"},
+        IntrinsicData{IntrinsicType::kFwidth, ParamType::kF32, "fwidth"},
+        IntrinsicData{IntrinsicType::kFwidthCoarse, ParamType::kF32, "fwidth"},
+        IntrinsicData{IntrinsicType::kFwidthFine, ParamType::kF32, "fwidth"},
+        IntrinsicData{IntrinsicType::kInverseSqrt, ParamType::kF32, "rsqrt"},
+        IntrinsicData{IntrinsicType::kIsFinite, ParamType::kF32, "isfinite"},
+        IntrinsicData{IntrinsicType::kIsInf, ParamType::kF32, "isinf"},
+        IntrinsicData{IntrinsicType::kIsNan, ParamType::kF32, "isnan"},
+        IntrinsicData{IntrinsicType::kLdexp, ParamType::kF32, "ldexp"},
+        IntrinsicData{IntrinsicType::kLength, ParamType::kF32, "length"},
+        IntrinsicData{IntrinsicType::kLog, ParamType::kF32, "log"},
+        IntrinsicData{IntrinsicType::kLog2, ParamType::kF32, "log2"},
+        IntrinsicData{IntrinsicType::kMax, ParamType::kF32, "max"},
+        IntrinsicData{IntrinsicType::kMax, ParamType::kU32, "max"},
+        IntrinsicData{IntrinsicType::kMin, ParamType::kF32, "min"},
+        IntrinsicData{IntrinsicType::kMin, ParamType::kU32, "min"},
+        IntrinsicData{IntrinsicType::kMix, ParamType::kF32, "lerp"},
+        IntrinsicData{IntrinsicType::kNormalize, ParamType::kF32, "normalize"},
+        IntrinsicData{IntrinsicType::kPow, ParamType::kF32, "pow"},
+        IntrinsicData{IntrinsicType::kReflect, ParamType::kF32, "reflect"},
+        IntrinsicData{IntrinsicType::kReverseBits, ParamType::kU32,
+                      "reversebits"},
+        IntrinsicData{IntrinsicType::kRound, ParamType::kU32, "round"},
+        IntrinsicData{IntrinsicType::kSign, ParamType::kF32, "sign"},
+        IntrinsicData{IntrinsicType::kSin, ParamType::kF32, "sin"},
+        IntrinsicData{IntrinsicType::kSinh, ParamType::kF32, "sinh"},
+        IntrinsicData{IntrinsicType::kSmoothStep, ParamType::kF32,
+                      "smoothstep"},
+        IntrinsicData{IntrinsicType::kSqrt, ParamType::kF32, "sqrt"},
+        IntrinsicData{IntrinsicType::kStep, ParamType::kF32, "step"},
+        IntrinsicData{IntrinsicType::kTan, ParamType::kF32, "tan"},
+        IntrinsicData{IntrinsicType::kTanh, ParamType::kF32, "tanh"},
+        IntrinsicData{IntrinsicType::kTranspose, ParamType::kF32, "transpose"},
+        IntrinsicData{IntrinsicType::kTrunc, ParamType::kF32, "trunc"}));
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, DISABLED_Intrinsic_IsNormal) {
+  FAIL();
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, Intrinsic_Call) {
+  auto* call = Call("dot", "param1", "param2");
+
+  Global("param1", ty.vec3<f32>(), ast::StorageClass::kPrivate);
+  Global("param2", ty.vec3<f32>(), ast::StorageClass::kPrivate);
+
+  WrapInFunction(call);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, call)) << gen.error();
+  EXPECT_EQ(out.str(), "dot(param1, param2)");
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, Select_Scalar) {
+  auto* call = Call("select", 1.0f, 2.0f, true);
+  WrapInFunction(call);
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, call)) << gen.error();
+  EXPECT_EQ(out.str(), "(true ? 2.0f : 1.0f)");
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, Select_Vector) {
+  auto* call =
+      Call("select", vec2<i32>(1, 2), vec2<i32>(3, 4), vec2<bool>(true, false));
+  WrapInFunction(call);
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, call)) << gen.error();
+  EXPECT_EQ(out.str(), "(bvec2(true, false) ? ivec2(3, 4) : ivec2(1, 2))");
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, Modf_Scalar) {
+  auto* res = Var("res", ty.f32());
+  auto* call = Call("modf", 1.0f, AddressOf(res));
+  WrapInFunction(res, call);
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("modf(1.0f, res)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, Modf_Vector) {
+  auto* res = Var("res", ty.vec3<f32>());
+  auto* call = Call("modf", vec3<f32>(), AddressOf(res));
+  WrapInFunction(res, call);
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("modf(vec3(0.0f, 0.0f, 0.0f), res)"));
+}
+
+#if 0
+TEST_F(GlslGeneratorImplTest_Intrinsic, Frexp_Scalar_i32) {
+  auto* exp = Var("exp", ty.i32());
+  auto* call = Call("frexp", 1.0f, AddressOf(exp));
+  WrapInFunction(exp, call);
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr(R"(
+  float tint_tmp;
+  float tint_tmp_1 = frexp(1.0f, tint_tmp);
+  exp = int(tint_tmp);
+  tint_tmp_1;
+)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, Frexp_Vector_i32) {
+  auto* res = Var("res", ty.vec3<i32>());
+  auto* call = Call("frexp", vec3<f32>(), AddressOf(res));
+  WrapInFunction(res, call);
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr(R"(
+  vec3 tint_tmp;
+  vec3 tint_tmp_1 = frexp(vec3(0.0f, 0.0f, 0.0f), tint_tmp);
+  res = ivec3(tint_tmp);
+  tint_tmp_1;
+)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, IsNormal_Scalar) {
+  auto* val = Var("val", ty.f32());
+  auto* call = Call("isNormal", val);
+  WrapInFunction(val, call);
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr(R"(
+  uint tint_isnormal_exponent = asuint(val) & 0x7f80000;
+  uint tint_isnormal_clamped = clamp(tint_isnormal_exponent, 0x0080000, 0x7f00000);
+  (tint_isnormal_clamped == tint_isnormal_exponent);
+)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, IsNormal_Vector) {
+  auto* val = Var("val", ty.vec3<f32>());
+  auto* call = Call("isNormal", val);
+  WrapInFunction(val, call);
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr(R"(
+  uvec3 tint_isnormal_exponent = asuint(val) & 0x7f80000;
+  uvec3 tint_isnormal_clamped = clamp(tint_isnormal_exponent, 0x0080000, 0x7f00000);
+  (tint_isnormal_clamped == tint_isnormal_exponent);
+)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, Pack4x8Snorm) {
+  auto* call = Call("pack4x8snorm", "p1");
+  Global("p1", ty.vec4<f32>(), ast::StorageClass::kPrivate);
+  WrapInFunction(call);
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, call)) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("ivec4 tint_tmp = ivec4(round(clamp(p1, "
+                                      "-1.0, 1.0) * 127.0)) & 0xff;"));
+  EXPECT_THAT(out.str(), HasSubstr("asuint(tint_tmp.x | tint_tmp.y << 8 | "
+                                   "tint_tmp.z << 16 | tint_tmp.w << 24)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, Pack4x8Unorm) {
+  auto* call = Call("pack4x8unorm", "p1");
+  Global("p1", ty.vec4<f32>(), ast::StorageClass::kPrivate);
+  WrapInFunction(call);
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, call)) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("uvec4 tint_tmp = uvec4(round(clamp(p1, "
+                                      "0.0, 1.0) * 255.0));"));
+  EXPECT_THAT(out.str(), HasSubstr("(tint_tmp.x | tint_tmp.y << 8 | "
+                                   "tint_tmp.z << 16 | tint_tmp.w << 24)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, Pack2x16Snorm) {
+  auto* call = Call("pack2x16snorm", "p1");
+  Global("p1", ty.vec2<f32>(), ast::StorageClass::kPrivate);
+  WrapInFunction(call);
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, call)) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("int2 tint_tmp = int2(round(clamp(p1, "
+                                      "-1.0, 1.0) * 32767.0)) & 0xffff;"));
+  EXPECT_THAT(out.str(), HasSubstr("asuint(tint_tmp.x | tint_tmp.y << 16)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, Pack2x16Unorm) {
+  auto* call = Call("pack2x16unorm", "p1");
+  Global("p1", ty.vec2<f32>(), ast::StorageClass::kPrivate);
+  WrapInFunction(call);
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, call)) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("uint2 tint_tmp = uint2(round(clamp(p1, "
+                                      "0.0, 1.0) * 65535.0));"));
+  EXPECT_THAT(out.str(), HasSubstr("(tint_tmp.x | tint_tmp.y << 16)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, Pack2x16Float) {
+  auto* call = Call("pack2x16float", "p1");
+  Global("p1", ty.vec2<f32>(), ast::StorageClass::kPrivate);
+  WrapInFunction(call);
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, call)) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("uint2 tint_tmp = f32tof16(p1);"));
+  EXPECT_THAT(out.str(), HasSubstr("(tint_tmp.x | tint_tmp.y << 16)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, Unpack4x8Snorm) {
+  auto* call = Call("unpack4x8snorm", "p1");
+  Global("p1", ty.u32(), ast::StorageClass::kPrivate);
+  WrapInFunction(call);
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, call)) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("int tint_tmp_1 = int(p1);"));
+  EXPECT_THAT(gen.result(),
+              HasSubstr("ivec4 tint_tmp = ivec4(tint_tmp_1 << 24, tint_tmp_1 "
+                        "<< 16, tint_tmp_1 << 8, tint_tmp_1) >> 24;"));
+  EXPECT_THAT(out.str(),
+              HasSubstr("clamp(float4(tint_tmp) / 127.0, -1.0, 1.0)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, Unpack4x8Unorm) {
+  auto* call = Call("unpack4x8unorm", "p1");
+  Global("p1", ty.u32(), ast::StorageClass::kPrivate);
+  WrapInFunction(call);
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, call)) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("uint tint_tmp_1 = p1;"));
+  EXPECT_THAT(
+      gen.result(),
+      HasSubstr("uvec4 tint_tmp = uvec4(tint_tmp_1 & 0xff, (tint_tmp_1 >> "
+                "8) & 0xff, (tint_tmp_1 >> 16) & 0xff, tint_tmp_1 >> 24);"));
+  EXPECT_THAT(out.str(), HasSubstr("float4(tint_tmp) / 255.0"));
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, Unpack2x16Snorm) {
+  auto* call = Call("unpack2x16snorm", "p1");
+  Global("p1", ty.u32(), ast::StorageClass::kPrivate);
+  WrapInFunction(call);
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, call)) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("int tint_tmp_1 = int(p1);"));
+  EXPECT_THAT(
+      gen.result(),
+      HasSubstr("int2 tint_tmp = int2(tint_tmp_1 << 16, tint_tmp_1) >> 16;"));
+  EXPECT_THAT(out.str(),
+              HasSubstr("clamp(float2(tint_tmp) / 32767.0, -1.0, 1.0)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, Unpack2x16Unorm) {
+  auto* call = Call("unpack2x16unorm", "p1");
+  Global("p1", ty.u32(), ast::StorageClass::kPrivate);
+  WrapInFunction(call);
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, call)) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("uint tint_tmp_1 = p1;"));
+  EXPECT_THAT(gen.result(),
+              HasSubstr("uint2 tint_tmp = uint2(tint_tmp_1 & 0xffff, "
+                        "tint_tmp_1 >> 16);"));
+  EXPECT_THAT(out.str(), HasSubstr("float2(tint_tmp) / 65535.0"));
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, Unpack2x16Float) {
+  auto* call = Call("unpack2x16float", "p1");
+  Global("p1", ty.u32(), ast::StorageClass::kPrivate);
+  WrapInFunction(call);
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, call)) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("uint tint_tmp = p1;"));
+  EXPECT_THAT(out.str(),
+              HasSubstr("f16tof32(uint2(tint_tmp & 0xffff, tint_tmp >> 16))"));
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, StorageBarrier) {
+  Func("main", {}, ty.void_(),
+       {create<ast::CallStatement>(Call("storageBarrier"))},
+       {
+           Stage(ast::PipelineStage::kCompute),
+           WorkgroupSize(1),
+       });
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"([numthreads(1, 1, 1)]
+void main() {
+  DeviceMemoryBarrierWithGroupSync();
+  return;
+}
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, WorkgroupBarrier) {
+  Func("main", {}, ty.void_(),
+       {create<ast::CallStatement>(Call("workgroupBarrier"))},
+       {
+           Stage(ast::PipelineStage::kCompute),
+           WorkgroupSize(1),
+       });
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"([numthreads(1, 1, 1)]
+void main() {
+  GroupMemoryBarrierWithGroupSync();
+  return;
+}
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Intrinsic, Ignore) {
+  Func("f", {Param("a", ty.i32()), Param("b", ty.i32()), Param("c", ty.i32())},
+       ty.i32(), {Return(Mul(Add("a", "b"), "c"))});
+
+  Func("main", {}, ty.void_(),
+       {create<ast::CallStatement>(Call("ignore", Call("f", 1, 2, 3)))},
+       {
+           Stage(ast::PipelineStage::kCompute),
+           WorkgroupSize(1),
+       });
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(int f(int a, int b, int c) {
+  return ((a + b) * c);
+}
+
+[numthreads(1, 1, 1)]
+void main() {
+  f(1, 2, 3);
+  return;
+}
+)");
+}
+#endif
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_intrinsic_texture_test.cc b/src/writer/glsl/generator_impl_intrinsic_texture_test.cc
new file mode 100644
index 0000000..850b448
--- /dev/null
+++ b/src/writer/glsl/generator_impl_intrinsic_texture_test.cc
@@ -0,0 +1,293 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "gmock/gmock.h"
+#include "src/ast/call_statement.h"
+#include "src/ast/intrinsic_texture_helper_test.h"
+#include "src/ast/stage_decoration.h"
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using ::testing::HasSubstr;
+
+struct ExpectedResult {
+  ExpectedResult(const char* o) : out(o) {}  // NOLINT
+
+  std::string pre;
+  std::string out;
+};
+
+ExpectedResult expected_texture_overload(
+    ast::intrinsic::test::ValidTextureOverload overload) {
+  using ValidTextureOverload = ast::intrinsic::test::ValidTextureOverload;
+  switch (overload) {
+    case ValidTextureOverload::kDimensions1d:
+    case ValidTextureOverload::kDimensionsStorageRO1d:
+    case ValidTextureOverload::kDimensionsStorageWO1d:
+    case ValidTextureOverload::kDimensions2d:
+    case ValidTextureOverload::kDimensionsDepth2d:
+    case ValidTextureOverload::kDimensionsStorageRO2d:
+    case ValidTextureOverload::kDimensionsStorageWO2d:
+    case ValidTextureOverload::kDimensionsDepthMultisampled2d:
+    case ValidTextureOverload::kDimensionsMultisampled2d:
+    case ValidTextureOverload::kDimensions2dArray:
+    case ValidTextureOverload::kDimensionsDepth2dArray:
+    case ValidTextureOverload::kDimensionsStorageRO2dArray:
+    case ValidTextureOverload::kDimensionsStorageWO2dArray:
+    case ValidTextureOverload::kDimensions3d:
+    case ValidTextureOverload::kDimensionsStorageRO3d:
+    case ValidTextureOverload::kDimensionsStorageWO3d:
+    case ValidTextureOverload::kDimensionsCube:
+    case ValidTextureOverload::kDimensionsDepthCube:
+    case ValidTextureOverload::kDimensionsCubeArray:
+    case ValidTextureOverload::kDimensionsDepthCubeArray:
+    case ValidTextureOverload::kDimensions2dLevel:
+    case ValidTextureOverload::kDimensionsDepth2dLevel:
+    case ValidTextureOverload::kDimensions2dArrayLevel:
+    case ValidTextureOverload::kDimensionsDepth2dArrayLevel:
+    case ValidTextureOverload::kDimensions3dLevel:
+    case ValidTextureOverload::kDimensionsCubeLevel:
+    case ValidTextureOverload::kDimensionsDepthCubeLevel:
+    case ValidTextureOverload::kDimensionsCubeArrayLevel:
+    case ValidTextureOverload::kDimensionsDepthCubeArrayLevel:
+      return {"textureSize"};
+    case ValidTextureOverload::kNumLayers2dArray:
+    case ValidTextureOverload::kNumLayersDepth2dArray:
+    case ValidTextureOverload::kNumLayersCubeArray:
+    case ValidTextureOverload::kNumLayersDepthCubeArray:
+    case ValidTextureOverload::kNumLayersStorageWO2dArray:
+    case ValidTextureOverload::kNumLevels2d:
+    case ValidTextureOverload::kNumLevelsCube:
+    case ValidTextureOverload::kNumLevelsDepth2d:
+    case ValidTextureOverload::kNumLevelsDepthCube:
+    case ValidTextureOverload::kNumLevels2dArray:
+    case ValidTextureOverload::kNumLevels3d:
+    case ValidTextureOverload::kNumLevelsCubeArray:
+    case ValidTextureOverload::kNumLevelsDepth2dArray:
+    case ValidTextureOverload::kNumLevelsDepthCubeArray:
+      return {"textureQueryLevels"};
+    case ValidTextureOverload::kNumSamplesDepthMultisampled2d:
+    case ValidTextureOverload::kNumSamplesMultisampled2d:
+      return {"textureSamples"};
+    case ValidTextureOverload::kSample1dF32:
+      return R"(texture.Sample(sampler, 1.0f);)";
+    case ValidTextureOverload::kSample2dF32:
+      return R"(texture.Sample(sampler, vec2(1.0f, 2.0f));)";
+    case ValidTextureOverload::kSample2dOffsetF32:
+      return R"(texture.Sample(sampler, vec2(1.0f, 2.0f), ivec2(3, 4));)";
+    case ValidTextureOverload::kSample2dArrayF32:
+      return R"(texture.Sample(sampler, vec3(1.0f, 2.0f, float(3)));)";
+    case ValidTextureOverload::kSample2dArrayOffsetF32:
+      return R"(texture.Sample(sampler, vec3(1.0f, 2.0f, float(3)), ivec2(4, 5));)";
+    case ValidTextureOverload::kSample3dF32:
+      return R"(texture.Sample(sampler, vec3(1.0f, 2.0f, 3.0f));)";
+    case ValidTextureOverload::kSample3dOffsetF32:
+      return R"(texture.Sample(sampler, vec3(1.0f, 2.0f, 3.0f), ivec3(4, 5, 6));)";
+    case ValidTextureOverload::kSampleCubeF32:
+      return R"(texture.Sample(sampler, vec3(1.0f, 2.0f, 3.0f));)";
+    case ValidTextureOverload::kSampleCubeArrayF32:
+      return R"(texture.Sample(sampler, vec4(1.0f, 2.0f, 3.0f, float(4)));)";
+    case ValidTextureOverload::kSampleDepth2dF32:
+      return R"(texture.Sample(sampler, vec2(1.0f, 2.0f)).x;)";
+    case ValidTextureOverload::kSampleDepth2dOffsetF32:
+      return R"(texture.Sample(sampler, vec2(1.0f, 2.0f), ivec2(3, 4)).x;)";
+    case ValidTextureOverload::kSampleDepth2dArrayF32:
+      return R"(texture.Sample(sampler, vec3(1.0f, 2.0f, float(3))).x;)";
+    case ValidTextureOverload::kSampleDepth2dArrayOffsetF32:
+      return R"(texture.Sample(sampler, vec3(1.0f, 2.0f, float(3)), ivec2(4, 5)).x;)";
+    case ValidTextureOverload::kSampleDepthCubeF32:
+      return R"(texture.Sample(sampler, vec3(1.0f, 2.0f, 3.0f)).x;)";
+    case ValidTextureOverload::kSampleDepthCubeArrayF32:
+      return R"(texture.Sample(sampler, vec4(1.0f, 2.0f, 3.0f, float(4))).x;)";
+    case ValidTextureOverload::kSampleBias2dF32:
+      return R"(texture.SampleBias(sampler, vec2(1.0f, 2.0f), 3.0f);)";
+    case ValidTextureOverload::kSampleBias2dOffsetF32:
+      return R"(texture.SampleBias(sampler, vec2(1.0f, 2.0f), 3.0f, ivec2(4, 5));)";
+    case ValidTextureOverload::kSampleBias2dArrayF32:
+      return R"(texture.SampleBias(sampler, vec3(1.0f, 2.0f, float(4)), 3.0f);)";
+    case ValidTextureOverload::kSampleBias2dArrayOffsetF32:
+      return R"(texture.SampleBias(sampler, vec3(1.0f, 2.0f, float(3)), 4.0f, ivec2(5, 6));)";
+    case ValidTextureOverload::kSampleBias3dF32:
+      return R"(texture.SampleBias(sampler, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
+    case ValidTextureOverload::kSampleBias3dOffsetF32:
+      return R"(texture.SampleBias(sampler, vec3(1.0f, 2.0f, 3.0f), 4.0f, ivec3(5, 6, 7));)";
+    case ValidTextureOverload::kSampleBiasCubeF32:
+      return R"(texture.SampleBias(sampler, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
+    case ValidTextureOverload::kSampleBiasCubeArrayF32:
+      return R"(texture.SampleBias(sampler, vec4(1.0f, 2.0f, 3.0f, float(3)), 4.0f);)";
+    case ValidTextureOverload::kSampleLevel2dF32:
+      return R"(texture.SampleLevel(sampler, vec2(1.0f, 2.0f), 3.0f);)";
+    case ValidTextureOverload::kSampleLevel2dOffsetF32:
+      return R"(texture.SampleLevel(sampler, vec2(1.0f, 2.0f), 3.0f, ivec2(4, 5));)";
+    case ValidTextureOverload::kSampleLevel2dArrayF32:
+      return R"(texture.SampleLevel(sampler, vec3(1.0f, 2.0f, float(3)), 4.0f);)";
+    case ValidTextureOverload::kSampleLevel2dArrayOffsetF32:
+      return R"(texture.SampleLevel(sampler, vec3(1.0f, 2.0f, float(3)), 4.0f, ivec2(5, 6));)";
+    case ValidTextureOverload::kSampleLevel3dF32:
+      return R"(texture.SampleLevel(sampler, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
+    case ValidTextureOverload::kSampleLevel3dOffsetF32:
+      return R"(texture.SampleLevel(sampler, vec3(1.0f, 2.0f, 3.0f), 4.0f, ivec3(5, 6, 7));)";
+    case ValidTextureOverload::kSampleLevelCubeF32:
+      return R"(texture.SampleLevel(sampler, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
+    case ValidTextureOverload::kSampleLevelCubeArrayF32:
+      return R"(texture.SampleLevel(sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), 5.0f);)";
+    case ValidTextureOverload::kSampleLevelDepth2dF32:
+      return R"(texture.SampleLevel(sampler, vec2(1.0f, 2.0f), 3).x;)";
+    case ValidTextureOverload::kSampleLevelDepth2dOffsetF32:
+      return R"(texture.SampleLevel(sampler, vec2(1.0f, 2.0f), 3, ivec2(4, 5)).x;)";
+    case ValidTextureOverload::kSampleLevelDepth2dArrayF32:
+      return R"(texture.SampleLevel(sampler, vec3(1.0f, 2.0f, float(3)), 4).x;)";
+    case ValidTextureOverload::kSampleLevelDepth2dArrayOffsetF32:
+      return R"(texture.SampleLevel(sampler, vec3(1.0f, 2.0f, float(3)), 4, ivec2(5, 6)).x;)";
+    case ValidTextureOverload::kSampleLevelDepthCubeF32:
+      return R"(texture.SampleLevel(sampler, vec3(1.0f, 2.0f, 3.0f), 4).x;)";
+    case ValidTextureOverload::kSampleLevelDepthCubeArrayF32:
+      return R"(texture.SampleLevel(sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), 5).x;)";
+    case ValidTextureOverload::kSampleGrad2dF32:
+      return R"(texture.SampleGrad(sampler, vec2(1.0f, 2.0f), vec2(3.0f, 4.0f), vec2(5.0f, 6.0f));)";
+    case ValidTextureOverload::kSampleGrad2dOffsetF32:
+      return R"(texture.SampleGrad(sampler, vec2(1.0f, 2.0f), vec2(3.0f, 4.0f), vec2(5.0f, 6.0f), ivec2(7, 7));)";
+    case ValidTextureOverload::kSampleGrad2dArrayF32:
+      return R"(texture.SampleGrad(sampler, vec3(1.0f, 2.0f, float(3)), vec2(4.0f, 5.0f), vec2(6.0f, 7.0f));)";
+    case ValidTextureOverload::kSampleGrad2dArrayOffsetF32:
+      return R"(texture.SampleGrad(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"(texture.SampleGrad(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"(texture.SampleGrad(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"(texture.SampleGrad(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"(texture.SampleGrad(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.SampleCmp(sampler, vec2(1.0f, 2.0f), 3.0f);)";
+    case ValidTextureOverload::kSampleCompareDepth2dOffsetF32:
+      return R"(texture.SampleCmp(sampler, vec2(1.0f, 2.0f), 3.0f, ivec2(4, 5));)";
+    case ValidTextureOverload::kSampleCompareDepth2dArrayF32:
+      return R"(texture.SampleCmp(sampler, vec3(1.0f, 2.0f, float(4)), 3.0f);)";
+    case ValidTextureOverload::kSampleCompareDepth2dArrayOffsetF32:
+      return R"(texture.SampleCmp(sampler, vec3(1.0f, 2.0f, float(4)), 3.0f, ivec2(5, 6));)";
+    case ValidTextureOverload::kSampleCompareDepthCubeF32:
+      return R"(texture.SampleCmp(sampler, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
+    case ValidTextureOverload::kSampleCompareDepthCubeArrayF32:
+      return R"(texture.SampleCmp(sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), 5.0f);)";
+    case ValidTextureOverload::kSampleCompareLevelDepth2dF32:
+      return R"(texture.SampleCmpLevelZero(sampler, vec2(1.0f, 2.0f), 3.0f);)";
+    case ValidTextureOverload::kSampleCompareLevelDepth2dOffsetF32:
+      return R"(texture.SampleCmpLevelZero(sampler, vec2(1.0f, 2.0f), 3.0f, ivec2(4, 5));)";
+    case ValidTextureOverload::kSampleCompareLevelDepth2dArrayF32:
+      return R"(texture.SampleCmpLevelZero(sampler, vec3(1.0f, 2.0f, float(4)), 3.0f);)";
+    case ValidTextureOverload::kSampleCompareLevelDepth2dArrayOffsetF32:
+      return R"(texture.SampleCmpLevelZero(sampler, vec3(1.0f, 2.0f, float(4)), 3.0f, ivec2(5, 6));)";
+    case ValidTextureOverload::kSampleCompareLevelDepthCubeF32:
+      return R"(texture.SampleCmpLevelZero(sampler, vec3(1.0f, 2.0f, 3.0f), 4.0f);)";
+    case ValidTextureOverload::kSampleCompareLevelDepthCubeArrayF32:
+      return R"(texture.SampleCmpLevelZero(sampler, vec4(1.0f, 2.0f, 3.0f, float(4)), 5.0f);)";
+    case ValidTextureOverload::kLoad1dLevelF32:
+    case ValidTextureOverload::kLoad1dLevelU32:
+    case ValidTextureOverload::kLoad1dLevelI32:
+      return R"(texture.Load(ivec2(1, 3));)";
+    case ValidTextureOverload::kLoad2dLevelF32:
+    case ValidTextureOverload::kLoad2dLevelU32:
+    case ValidTextureOverload::kLoad2dLevelI32:
+      return R"(texture.Load(ivec3(1, 2, 3));)";
+    case ValidTextureOverload::kLoad2dArrayLevelF32:
+    case ValidTextureOverload::kLoad2dArrayLevelU32:
+    case ValidTextureOverload::kLoad2dArrayLevelI32:
+    case ValidTextureOverload::kLoad3dLevelF32:
+    case ValidTextureOverload::kLoad3dLevelU32:
+    case ValidTextureOverload::kLoad3dLevelI32:
+      return R"(texture.Load(ivec4(1, 2, 3, 4));)";
+    case ValidTextureOverload::kLoadDepthMultisampled2dF32:
+    case ValidTextureOverload::kLoadMultisampled2dF32:
+    case ValidTextureOverload::kLoadMultisampled2dU32:
+    case ValidTextureOverload::kLoadMultisampled2dI32:
+      return R"(texture.Load(ivec2(1, 2), 3);)";
+    case ValidTextureOverload::kLoadDepth2dLevelF32:
+      return R"(texture.Load(ivec3(1, 2, 3)).x;)";
+    case ValidTextureOverload::kLoadDepth2dArrayLevelF32:
+      return R"(texture.Load(ivec4(1, 2, 3, 4)).x;)";
+    case ValidTextureOverload::kLoadStorageRO1dRgba32float:
+      return R"(texture.Load(ivec2(1, 0));)";
+    case ValidTextureOverload::kLoadStorageRO2dRgba8unorm:
+    case ValidTextureOverload::kLoadStorageRO2dRgba8snorm:
+    case ValidTextureOverload::kLoadStorageRO2dRgba8uint:
+    case ValidTextureOverload::kLoadStorageRO2dRgba8sint:
+    case ValidTextureOverload::kLoadStorageRO2dRgba16uint:
+    case ValidTextureOverload::kLoadStorageRO2dRgba16sint:
+    case ValidTextureOverload::kLoadStorageRO2dRgba16float:
+    case ValidTextureOverload::kLoadStorageRO2dR32uint:
+    case ValidTextureOverload::kLoadStorageRO2dR32sint:
+    case ValidTextureOverload::kLoadStorageRO2dR32float:
+    case ValidTextureOverload::kLoadStorageRO2dRg32uint:
+    case ValidTextureOverload::kLoadStorageRO2dRg32sint:
+    case ValidTextureOverload::kLoadStorageRO2dRg32float:
+    case ValidTextureOverload::kLoadStorageRO2dRgba32uint:
+    case ValidTextureOverload::kLoadStorageRO2dRgba32sint:
+    case ValidTextureOverload::kLoadStorageRO2dRgba32float:
+      return R"(texture.Load(ivec3(1, 2, 0));)";
+    case ValidTextureOverload::kLoadStorageRO2dArrayRgba32float:
+    case ValidTextureOverload::kLoadStorageRO3dRgba32float:
+      return R"(texture.Load(ivec4(1, 2, 3, 0));)";
+    case ValidTextureOverload::kStoreWO1dRgba32float:
+      return R"(texture[1] = vec4(2.0f, 3.0f, 4.0f, 5.0f);)";
+    case ValidTextureOverload::kStoreWO2dRgba32float:
+      return R"(texture[ivec2(1, 2)] = vec4(3.0f, 4.0f, 5.0f, 6.0f);)";
+    case ValidTextureOverload::kStoreWO2dArrayRgba32float:
+      return R"(texture[ivec3(1, 2, 3)] = vec4(4.0f, 5.0f, 6.0f, 7.0f);)";
+    case ValidTextureOverload::kStoreWO3dRgba32float:
+      return R"(texture[ivec3(1, 2, 3)] = vec4(4.0f, 5.0f, 6.0f, 7.0f);)";
+  }
+  return "<unmatched texture overload>";
+}  // NOLINT - Ignore the length of this function
+
+class GlslGeneratorIntrinsicTextureTest
+    : public TestParamHelper<ast::intrinsic::test::TextureOverloadCase> {};
+
+TEST_P(GlslGeneratorIntrinsicTextureTest, Call) {
+  auto param = GetParam();
+
+  param.buildTextureVariable(this);
+  param.buildSamplerVariable(this);
+
+  auto* call = Call(param.function, param.args(this));
+  auto* stmt = ast::intrinsic::test::ReturnsVoid(param.overload)
+                   ? create<ast::CallStatement>(call)
+                   : Ignore(call);
+
+  Func("main", {}, ty.void_(), {stmt}, {Stage(ast::PipelineStage::kFragment)});
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+
+  auto expected = expected_texture_overload(param.overload);
+
+  EXPECT_THAT(gen.result(), HasSubstr(expected.pre));
+  EXPECT_THAT(gen.result(), HasSubstr(expected.out));
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    GlslGeneratorIntrinsicTextureTest,
+    GlslGeneratorIntrinsicTextureTest,
+    testing::ValuesIn(ast::intrinsic::test::TextureOverloadCase::ValidCases()));
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_loop_test.cc b/src/writer/glsl/generator_impl_loop_test.cc
new file mode 100644
index 0000000..102eb5e
--- /dev/null
+++ b/src/writer/glsl/generator_impl_loop_test.cc
@@ -0,0 +1,418 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/ast/variable_decl_statement.h"
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_Loop = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_Loop, Emit_Loop) {
+  auto* body = Block(create<ast::DiscardStatement>());
+  auto* continuing = Block();
+  auto* l = Loop(body, continuing);
+
+  WrapInFunction(l);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(l)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  while (true) {
+    discard;
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Loop, Emit_LoopWithContinuing) {
+  Func("a_statement", {}, ty.void_(), {});
+
+  auto* body = Block(create<ast::DiscardStatement>());
+  auto* continuing = Block(create<ast::CallStatement>(Call("a_statement")));
+  auto* l = Loop(body, continuing);
+
+  WrapInFunction(l);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(l)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  while (true) {
+    discard;
+    {
+      a_statement();
+    }
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Loop, Emit_LoopNestedWithContinuing) {
+  Func("a_statement", {}, ty.void_(), {});
+
+  Global("lhs", ty.f32(), ast::StorageClass::kPrivate);
+  Global("rhs", ty.f32(), ast::StorageClass::kPrivate);
+
+  auto* body = Block(create<ast::DiscardStatement>());
+  auto* continuing = Block(create<ast::CallStatement>(Call("a_statement")));
+  auto* inner = Loop(body, continuing);
+
+  body = Block(inner);
+
+  auto* lhs = Expr("lhs");
+  auto* rhs = Expr("rhs");
+
+  continuing = Block(Assign(lhs, rhs));
+
+  auto* outer = Loop(body, continuing);
+  WrapInFunction(outer);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(outer)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  while (true) {
+    while (true) {
+      discard;
+      {
+        a_statement();
+      }
+    }
+    {
+      lhs = rhs;
+    }
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Loop, Emit_LoopWithVarUsedInContinuing) {
+  // loop {
+  //   var lhs : f32 = 2.4;
+  //   var other : f32;
+  //   continuing {
+  //     lhs = rhs
+  //   }
+  // }
+  //
+  // ->
+  // {
+  //   float lhs;
+  //   float other;
+  //   for (;;) {
+  //     if (continuing) {
+  //       lhs = rhs;
+  //     }
+  //     lhs = 2.4f;
+  //     other = 0.0f;
+  //   }
+  // }
+
+  Global("rhs", ty.f32(), ast::StorageClass::kPrivate);
+
+  auto* var = Var("lhs", ty.f32(), ast::StorageClass::kNone, Expr(2.4f));
+
+  auto* body = Block(Decl(var), Decl(Var("other", ty.f32())));
+
+  auto* lhs = Expr("lhs");
+  auto* rhs = Expr("rhs");
+
+  auto* continuing = Block(Assign(lhs, rhs));
+  auto* outer = Loop(body, continuing);
+  WrapInFunction(outer);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(outer)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  while (true) {
+    float lhs = 2.400000095f;
+    float other = 0.0f;
+    {
+      lhs = rhs;
+    }
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Loop, Emit_ForLoop) {
+  // for(; ; ) {
+  //   return;
+  // }
+
+  Func("a_statement", {}, ty.void_(), {});
+
+  auto* f = For(nullptr, nullptr, nullptr,
+                Block(create<ast::CallStatement>(Call("a_statement"))));
+  WrapInFunction(f);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(f)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  {
+    for(; ; ) {
+      a_statement();
+    }
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Loop, Emit_ForLoopWithSimpleInit) {
+  // for(var i : i32; ; ) {
+  //   return;
+  // }
+
+  Func("a_statement", {}, ty.void_(), {});
+
+  auto* f = For(Decl(Var("i", ty.i32())), nullptr, nullptr,
+                Block(create<ast::CallStatement>(Call("a_statement"))));
+  WrapInFunction(f);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(f)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  {
+    for(int i = 0; ; ) {
+      a_statement();
+    }
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Loop, Emit_ForLoopWithMultiStmtInit) {
+  // for(var b = true && false; ; ) {
+  //   return;
+  // }
+  Func("a_statement", {}, ty.void_(), {});
+
+  auto* multi_stmt = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd,
+                                                   Expr(true), Expr(false));
+  auto* f = For(Decl(Var("b", nullptr, multi_stmt)), nullptr, nullptr,
+                Block(create<ast::CallStatement>(Call("a_statement"))));
+  WrapInFunction(f);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(f)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  {
+    bool tint_tmp = true;
+    if (tint_tmp) {
+      tint_tmp = false;
+    }
+    bool b = (tint_tmp);
+    for(; ; ) {
+      a_statement();
+    }
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Loop, Emit_ForLoopWithSimpleCond) {
+  // for(; true; ) {
+  //   return;
+  // }
+
+  Func("a_statement", {}, ty.void_(), {});
+
+  auto* f = For(nullptr, true, nullptr,
+                Block(create<ast::CallStatement>(Call("a_statement"))));
+  WrapInFunction(f);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(f)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  {
+    for(; true; ) {
+      a_statement();
+    }
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Loop, Emit_ForLoopWithMultiStmtCond) {
+  // for(; true && false; ) {
+  //   return;
+  // }
+
+  Func("a_statement", {}, ty.void_(), {});
+
+  auto* multi_stmt = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd,
+                                                   Expr(true), Expr(false));
+  auto* f = For(nullptr, multi_stmt, nullptr,
+                Block(create<ast::CallStatement>(Call("a_statement"))));
+  WrapInFunction(f);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(f)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  {
+    while (true) {
+      bool tint_tmp = true;
+      if (tint_tmp) {
+        tint_tmp = false;
+      }
+      if (!((tint_tmp))) { break; }
+      a_statement();
+    }
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Loop, Emit_ForLoopWithSimpleCont) {
+  // for(; ; i = i + 1) {
+  //   return;
+  // }
+
+  Func("a_statement", {}, ty.void_(), {});
+
+  auto* v = Decl(Var("i", ty.i32()));
+  auto* f = For(nullptr, nullptr, Assign("i", Add("i", 1)),
+                Block(create<ast::CallStatement>(Call("a_statement"))));
+  WrapInFunction(v, f);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(f)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  {
+    for(; ; i = (i + 1)) {
+      a_statement();
+    }
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Loop, Emit_ForLoopWithMultiStmtCont) {
+  // for(; ; i = true && false) {
+  //   return;
+  // }
+
+  Func("a_statement", {}, ty.void_(), {});
+
+  auto* multi_stmt = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd,
+                                                   Expr(true), Expr(false));
+  auto* v = Decl(Var("i", ty.bool_()));
+  auto* f = For(nullptr, nullptr, Assign("i", multi_stmt),
+                Block(create<ast::CallStatement>(Call("a_statement"))));
+  WrapInFunction(v, f);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(f)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  {
+    while (true) {
+      a_statement();
+      bool tint_tmp = true;
+      if (tint_tmp) {
+        tint_tmp = false;
+      }
+      i = (tint_tmp);
+    }
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Loop, Emit_ForLoopWithSimpleInitCondCont) {
+  // for(var i : i32; true; i = i + 1) {
+  //   return;
+  // }
+
+  Func("a_statement", {}, ty.void_(), {});
+
+  auto* f = For(Decl(Var("i", ty.i32())), true, Assign("i", Add("i", 1)),
+                Block(create<ast::CallStatement>(Call("a_statement"))));
+  WrapInFunction(f);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(f)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  {
+    for(int i = 0; true; i = (i + 1)) {
+      a_statement();
+    }
+  }
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Loop, Emit_ForLoopWithMultiStmtInitCondCont) {
+  // for(var i = true && false; true && false; i = true && false) {
+  //   return;
+  // }
+  Func("a_statement", {}, ty.void_(), {});
+
+  auto* multi_stmt_a = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd,
+                                                     Expr(true), Expr(false));
+  auto* multi_stmt_b = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd,
+                                                     Expr(true), Expr(false));
+  auto* multi_stmt_c = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd,
+                                                     Expr(true), Expr(false));
+
+  auto* f = For(Decl(Var("i", nullptr, multi_stmt_a)), multi_stmt_b,
+                Assign("i", multi_stmt_c),
+                Block(create<ast::CallStatement>(Call("a_statement"))));
+  WrapInFunction(f);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(f)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  {
+    bool tint_tmp = true;
+    if (tint_tmp) {
+      tint_tmp = false;
+    }
+    bool i = (tint_tmp);
+    while (true) {
+      bool tint_tmp_1 = true;
+      if (tint_tmp_1) {
+        tint_tmp_1 = false;
+      }
+      if (!((tint_tmp_1))) { break; }
+      a_statement();
+      bool tint_tmp_2 = true;
+      if (tint_tmp_2) {
+        tint_tmp_2 = false;
+      }
+      i = (tint_tmp_2);
+    }
+  }
+)");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_member_accessor_test.cc b/src/writer/glsl/generator_impl_member_accessor_test.cc
new file mode 100644
index 0000000..808c211
--- /dev/null
+++ b/src/writer/glsl/generator_impl_member_accessor_test.cc
@@ -0,0 +1,816 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "gmock/gmock.h"
+#include "src/ast/stage_decoration.h"
+#include "src/ast/struct_block_decoration.h"
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using ::testing::HasSubstr;
+
+using create_type_func_ptr =
+    ast::Type* (*)(const ProgramBuilder::TypesBuilder& ty);
+
+inline ast::Type* ty_i32(const ProgramBuilder::TypesBuilder& ty) {
+  return ty.i32();
+}
+inline ast::Type* ty_u32(const ProgramBuilder::TypesBuilder& ty) {
+  return ty.u32();
+}
+inline ast::Type* ty_f32(const ProgramBuilder::TypesBuilder& ty) {
+  return ty.f32();
+}
+template <typename T>
+inline ast::Type* ty_vec2(const ProgramBuilder::TypesBuilder& ty) {
+  return ty.vec2<T>();
+}
+template <typename T>
+inline ast::Type* ty_vec3(const ProgramBuilder::TypesBuilder& ty) {
+  return ty.vec3<T>();
+}
+template <typename T>
+inline ast::Type* ty_vec4(const ProgramBuilder::TypesBuilder& ty) {
+  return ty.vec4<T>();
+}
+template <typename T>
+inline ast::Type* ty_mat2x2(const ProgramBuilder::TypesBuilder& ty) {
+  return ty.mat2x2<T>();
+}
+template <typename T>
+inline ast::Type* ty_mat2x3(const ProgramBuilder::TypesBuilder& ty) {
+  return ty.mat2x3<T>();
+}
+template <typename T>
+inline ast::Type* ty_mat2x4(const ProgramBuilder::TypesBuilder& ty) {
+  return ty.mat2x4<T>();
+}
+template <typename T>
+inline ast::Type* ty_mat3x2(const ProgramBuilder::TypesBuilder& ty) {
+  return ty.mat3x2<T>();
+}
+template <typename T>
+inline ast::Type* ty_mat3x3(const ProgramBuilder::TypesBuilder& ty) {
+  return ty.mat3x3<T>();
+}
+template <typename T>
+inline ast::Type* ty_mat3x4(const ProgramBuilder::TypesBuilder& ty) {
+  return ty.mat3x4<T>();
+}
+template <typename T>
+inline ast::Type* ty_mat4x2(const ProgramBuilder::TypesBuilder& ty) {
+  return ty.mat4x2<T>();
+}
+template <typename T>
+inline ast::Type* ty_mat4x3(const ProgramBuilder::TypesBuilder& ty) {
+  return ty.mat4x3<T>();
+}
+template <typename T>
+inline ast::Type* ty_mat4x4(const ProgramBuilder::TypesBuilder& ty) {
+  return ty.mat4x4<T>();
+}
+
+using i32 = ProgramBuilder::i32;
+using u32 = ProgramBuilder::u32;
+using f32 = ProgramBuilder::f32;
+
+template <typename BASE>
+class GlslGeneratorImplTest_MemberAccessorBase : public BASE {
+ public:
+  void SetupStorageBuffer(ast::StructMemberList members) {
+    ProgramBuilder& b = *this;
+
+    auto* s =
+        b.Structure("Data", members, {b.create<ast::StructBlockDecoration>()});
+
+    b.Global("data", b.ty.Of(s), ast::StorageClass::kStorage,
+             ast::Access::kReadWrite,
+             ast::DecorationList{
+                 b.create<ast::BindingDecoration>(0),
+                 b.create<ast::GroupDecoration>(1),
+             });
+  }
+
+  void SetupFunction(ast::StatementList statements) {
+    ProgramBuilder& b = *this;
+    b.Func("main", ast::VariableList{}, b.ty.void_(), statements,
+           ast::DecorationList{
+               b.Stage(ast::PipelineStage::kFragment),
+           });
+  }
+};
+
+using GlslGeneratorImplTest_MemberAccessor =
+    GlslGeneratorImplTest_MemberAccessorBase<TestHelper>;
+
+template <typename T>
+using GlslGeneratorImplTest_MemberAccessorWithParam =
+    GlslGeneratorImplTest_MemberAccessorBase<TestParamHelper<T>>;
+
+TEST_F(GlslGeneratorImplTest_MemberAccessor, EmitExpression_MemberAccessor) {
+  auto* s = Structure("Data", {Member("mem", ty.f32())});
+  Global("str", ty.Of(s), ast::StorageClass::kPrivate);
+
+  auto* expr = MemberAccessor("str", "mem");
+  WrapInFunction(Var("expr", ty.f32(), ast::StorageClass::kNone, expr));
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+struct Data {
+  float mem;
+};
+
+static Data str = Data(0.0f);
+
+[numthreads(1, 1, 1)]
+void test_function() {
+  float expr = str.mem;
+  return;
+}
+void main() {
+  test_function();
+}
+
+
+)");
+}
+
+struct TypeCase {
+  create_type_func_ptr member_type;
+  std::string expected;
+};
+inline std::ostream& operator<<(std::ostream& out, TypeCase c) {
+  ProgramBuilder b;
+  auto* ty = c.member_type(b.ty);
+  out << ty->FriendlyName(b.Symbols());
+  return out;
+}
+
+using GlslGeneratorImplTest_MemberAccessor_StorageBufferLoad =
+    GlslGeneratorImplTest_MemberAccessorWithParam<TypeCase>;
+TEST_P(GlslGeneratorImplTest_MemberAccessor_StorageBufferLoad, Test) {
+  // struct Data {
+  //   a : i32;
+  //   b : <type>;
+  // };
+  // var<storage> data : Data;
+  // data.b;
+
+  auto p = GetParam();
+
+  SetupStorageBuffer({
+      Member("a", ty.i32()),
+      Member("b", p.member_type(ty)),
+  });
+
+  SetupFunction({
+      Decl(Var("x", nullptr, ast::StorageClass::kNone,
+               MemberAccessor("data", "b"))),
+  });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr(p.expected));
+}
+
+INSTANTIATE_TEST_SUITE_P(GlslGeneratorImplTest_MemberAccessor,
+                         GlslGeneratorImplTest_MemberAccessor_StorageBufferLoad,
+                         testing::Values(TypeCase{ty_u32, "data.b"},
+                                         TypeCase{ty_f32, "data.b"},
+                                         TypeCase{ty_i32, "data.b"},
+                                         TypeCase{ty_vec2<u32>, "data.b"},
+                                         TypeCase{ty_vec2<f32>, "data.b"},
+                                         TypeCase{ty_vec2<i32>, "data.b"},
+                                         TypeCase{ty_vec3<u32>, "data.b"},
+                                         TypeCase{ty_vec3<f32>, "data.b"},
+                                         TypeCase{ty_vec3<i32>, "data.b"},
+                                         TypeCase{ty_vec4<u32>, "data.b"},
+                                         TypeCase{ty_vec4<f32>, "data.b"},
+                                         TypeCase{ty_vec4<i32>, "data.b"},
+                                         TypeCase{ty_mat2x2<f32>, "data.b"},
+                                         TypeCase{ty_mat2x3<f32>, "data.b"},
+                                         TypeCase{ty_mat2x4<f32>, "data.b"},
+                                         TypeCase{ty_mat3x2<f32>, "data.b"},
+                                         TypeCase{ty_mat3x3<f32>, "data.b"},
+                                         TypeCase{ty_mat3x4<f32>, "data.b"},
+                                         TypeCase{ty_mat4x2<f32>, "data.b"},
+                                         TypeCase{ty_mat4x3<f32>, "data.b"},
+                                         TypeCase{ty_mat4x4<f32>, "data.b"}));
+
+using GlslGeneratorImplTest_MemberAccessor_StorageBufferStore =
+    GlslGeneratorImplTest_MemberAccessorWithParam<TypeCase>;
+TEST_P(GlslGeneratorImplTest_MemberAccessor_StorageBufferStore, Test) {
+  // struct Data {
+  //   a : i32;
+  //   b : <type>;
+  // };
+  // var<storage> data : Data;
+  // data.b = <type>();
+
+  auto p = GetParam();
+
+  SetupStorageBuffer({
+      Member("a", ty.i32()),
+      Member("b", p.member_type(ty)),
+  });
+
+  SetupFunction({
+      Decl(Var("value", p.member_type(ty), ast::StorageClass::kNone,
+               Construct(p.member_type(ty)))),
+      Assign(MemberAccessor("data", "b"), Expr("value")),
+  });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr(p.expected));
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    GlslGeneratorImplTest_MemberAccessor,
+    GlslGeneratorImplTest_MemberAccessor_StorageBufferStore,
+    testing::Values(TypeCase{ty_u32, "data.b = value"},
+                    TypeCase{ty_f32, "data.b = value"},
+                    TypeCase{ty_i32, "data.b = value"},
+                    TypeCase{ty_vec2<u32>, "data.b = value"},
+                    TypeCase{ty_vec2<f32>, "data.b = value"},
+                    TypeCase{ty_vec2<i32>, "data.b = value"},
+                    TypeCase{ty_vec3<u32>, "data.b = value"},
+                    TypeCase{ty_vec3<f32>, "data.b = value"},
+                    TypeCase{ty_vec3<i32>, "data.b = value"},
+                    TypeCase{ty_vec4<u32>, "data.b = value"},
+                    TypeCase{ty_vec4<f32>, "data.b = value"},
+                    TypeCase{ty_vec4<i32>, "data.b = value"},
+                    TypeCase{ty_mat2x2<f32>, "data.b = value"},
+                    TypeCase{ty_mat2x3<f32>, "data.b = value"},
+                    TypeCase{ty_mat2x4<f32>, "data.b = value"},
+                    TypeCase{ty_mat3x2<f32>, "data.b = value"},
+                    TypeCase{ty_mat3x3<f32>, "data.b = value"},
+                    TypeCase{ty_mat3x4<f32>, "data.b = value"},
+                    TypeCase{ty_mat4x2<f32>, "data.b = value"},
+                    TypeCase{ty_mat4x3<f32>, "data.b = value"},
+                    TypeCase{ty_mat4x4<f32>, "data.b = value"}));
+
+TEST_F(GlslGeneratorImplTest_MemberAccessor, StorageBuffer_Store_Matrix_Empty) {
+  // struct Data {
+  //   z : f32;
+  //   a : mat2x3<f32>;
+  // };
+  // var<storage> data : Data;
+  // data.a = mat2x3<f32>();
+
+  SetupStorageBuffer({
+      Member("a", ty.i32()),
+      Member("b", ty.mat2x3<f32>()),
+  });
+
+  SetupFunction({
+      Assign(MemberAccessor("data", "b"),
+             Construct(ty.mat2x3<f32>(), ast::ExpressionList{})),
+  });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  auto* expected =
+      R"(#version 310 es
+precision mediump float;
+
+
+Data data : register(u0, space1);
+
+void main() {
+  data.b = mat2x3(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
+  return;
+}
+void main() {
+  main();
+}
+
+
+)";
+  EXPECT_EQ(gen.result(), expected);
+}
+
+TEST_F(GlslGeneratorImplTest_MemberAccessor,
+       StorageBuffer_Load_Matrix_Single_Element) {
+  // struct Data {
+  //   z : f32;
+  //   a : mat4x3<f32>;
+  // };
+  // var<storage> data : Data;
+  // data.a[2][1];
+
+  SetupStorageBuffer({
+      Member("z", ty.f32()),
+      Member("a", ty.mat4x3<f32>()),
+  });
+
+  SetupFunction({
+      Decl(
+          Var("x", nullptr, ast::StorageClass::kNone,
+              IndexAccessor(IndexAccessor(MemberAccessor("data", "a"), 2), 1))),
+  });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  auto* expected =
+      R"(#version 310 es
+precision mediump float;
+
+
+Data data : register(u0, space1);
+
+void main() {
+  float x = data.a[2][1];
+  return;
+}
+void main() {
+  main();
+}
+
+
+)";
+  EXPECT_EQ(gen.result(), expected);
+}
+
+TEST_F(GlslGeneratorImplTest_MemberAccessor,
+       EmitExpression_ArrayAccessor_StorageBuffer_Load_Int_FromArray) {
+  // struct Data {
+  //   a : [[stride(4)]] array<i32, 5>;
+  // };
+  // var<storage> data : Data;
+  // data.a[2];
+
+  SetupStorageBuffer({
+      Member("z", ty.f32()),
+      Member("a", ty.array<i32, 5>(4)),
+  });
+
+  SetupFunction({
+      Decl(Var("x", nullptr, ast::StorageClass::kNone,
+               IndexAccessor(MemberAccessor("data", "a"), 2))),
+  });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  auto* expected =
+      R"(#version 310 es
+precision mediump float;
+
+
+Data data : register(u0, space1);
+
+void main() {
+  int x = data.a[2];
+  return;
+}
+void main() {
+  main();
+}
+
+
+)";
+  EXPECT_EQ(gen.result(), expected);
+}
+
+TEST_F(GlslGeneratorImplTest_MemberAccessor,
+       EmitExpression_ArrayAccessor_StorageBuffer_Load_Int_FromArray_ExprIdx) {
+  // struct Data {
+  //   a : [[stride(4)]] array<i32, 5>;
+  // };
+  // var<storage> data : Data;
+  // data.a[(2 + 4) - 3];
+
+  SetupStorageBuffer({
+      Member("z", ty.f32()),
+      Member("a", ty.array<i32, 5>(4)),
+  });
+
+  SetupFunction({
+      Decl(Var("x", nullptr, ast::StorageClass::kNone,
+               IndexAccessor(MemberAccessor("data", "a"),
+                             Sub(Add(2, Expr(4)), Expr(3))))),
+  });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  auto* expected =
+      R"(#version 310 es
+precision mediump float;
+
+
+Data data : register(u0, space1);
+
+void main() {
+  int x = data.a[((2 + 4) - 3)];
+  return;
+}
+void main() {
+  main();
+}
+
+
+)";
+  EXPECT_EQ(gen.result(), expected);
+}
+
+TEST_F(GlslGeneratorImplTest_MemberAccessor, StorageBuffer_Store_ToArray) {
+  // struct Data {
+  //   a : [[stride(4)]] array<i32, 5>;
+  // };
+  // var<storage> data : Data;
+  // data.a[2] = 2;
+
+  SetupStorageBuffer({
+      Member("z", ty.f32()),
+      Member("a", ty.array<i32, 5>(4)),
+  });
+
+  SetupFunction({
+      Assign(IndexAccessor(MemberAccessor("data", "a"), 2), 2),
+  });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  auto* expected =
+      R"(#version 310 es
+precision mediump float;
+
+
+Data data : register(u0, space1);
+
+void main() {
+  data.a[2] = 2;
+  return;
+}
+void main() {
+  main();
+}
+
+
+)";
+  EXPECT_EQ(gen.result(), expected);
+}
+
+TEST_F(GlslGeneratorImplTest_MemberAccessor, StorageBuffer_Load_MultiLevel) {
+  // struct Inner {
+  //   a : vec3<i32>;
+  //   b : vec3<f32>;
+  // };
+  // struct Data {
+  //   var c : [[stride(32)]] array<Inner, 4>;
+  // };
+  //
+  // var<storage> data : Pre;
+  // data.c[2].b
+
+  auto* inner = Structure("Inner", {
+                                       Member("a", ty.vec3<f32>()),
+                                       Member("b", ty.vec3<f32>()),
+                                   });
+
+  SetupStorageBuffer({
+      Member("c", ty.array(ty.Of(inner), 4, 32)),
+  });
+
+  SetupFunction({
+      Decl(Var(
+          "x", nullptr, ast::StorageClass::kNone,
+          MemberAccessor(IndexAccessor(MemberAccessor("data", "c"), 2), "b"))),
+  });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  auto* expected =
+      R"(#version 310 es
+precision mediump float;
+
+
+Data data : register(u0, space1);
+
+void main() {
+  vec3 x = data.c[2].b;
+  return;
+}
+void main() {
+  main();
+}
+
+
+)";
+  EXPECT_EQ(gen.result(), expected);
+}
+
+TEST_F(GlslGeneratorImplTest_MemberAccessor,
+       StorageBuffer_Load_MultiLevel_Swizzle) {
+  // struct Inner {
+  //   a : vec3<i32>;
+  //   b : vec3<f32>;
+  // };
+  // struct Data {
+  //   var c : [[stride(32)]] array<Inner, 4>;
+  // };
+  //
+  // var<storage> data : Pre;
+  // data.c[2].b.xy
+
+  auto* inner = Structure("Inner", {
+                                       Member("a", ty.vec3<f32>()),
+                                       Member("b", ty.vec3<f32>()),
+                                   });
+
+  SetupStorageBuffer({
+      Member("c", ty.array(ty.Of(inner), 4, 32)),
+  });
+
+  SetupFunction({
+      Decl(Var("x", nullptr, ast::StorageClass::kNone,
+               MemberAccessor(
+                   MemberAccessor(IndexAccessor(MemberAccessor("data", "c"), 2),
+                                  "b"),
+                   "xy"))),
+  });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  auto* expected =
+      R"(#version 310 es
+precision mediump float;
+
+
+Data data : register(u0, space1);
+
+void main() {
+  vec2 x = data.c[2].b.xy;
+  return;
+}
+void main() {
+  main();
+}
+
+
+)";
+  EXPECT_EQ(gen.result(), expected);
+}
+
+TEST_F(GlslGeneratorImplTest_MemberAccessor,
+       StorageBuffer_Load_MultiLevel_Swizzle_SingleLetter) {  // NOLINT
+  // struct Inner {
+  //   a : vec3<i32>;
+  //   b : vec3<f32>;
+  // };
+  // struct Data {
+  //   var c : [[stride(32)]] array<Inner, 4>;
+  // };
+  //
+  // var<storage> data : Pre;
+  // data.c[2].b.g
+
+  auto* inner = Structure("Inner", {
+                                       Member("a", ty.vec3<f32>()),
+                                       Member("b", ty.vec3<f32>()),
+                                   });
+
+  SetupStorageBuffer({
+      Member("c", ty.array(ty.Of(inner), 4, 32)),
+  });
+
+  SetupFunction({
+      Decl(Var("x", nullptr, ast::StorageClass::kNone,
+               MemberAccessor(
+                   MemberAccessor(IndexAccessor(MemberAccessor("data", "c"), 2),
+                                  "b"),
+                   "g"))),
+  });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  auto* expected =
+      R"(#version 310 es
+precision mediump float;
+
+
+Data data : register(u0, space1);
+
+void main() {
+  float x = data.c[2].b.g;
+  return;
+}
+void main() {
+  main();
+}
+
+
+)";
+  EXPECT_EQ(gen.result(), expected);
+}
+
+TEST_F(GlslGeneratorImplTest_MemberAccessor,
+       StorageBuffer_Load_MultiLevel_Index) {
+  // struct Inner {
+  //   a : vec3<i32>;
+  //   b : vec3<f32>;
+  // };
+  // struct Data {
+  //   var c : [[stride(32)]] array<Inner, 4>;
+  // };
+  //
+  // var<storage> data : Pre;
+  // data.c[2].b[1]
+
+  auto* inner = Structure("Inner", {
+                                       Member("a", ty.vec3<f32>()),
+                                       Member("b", ty.vec3<f32>()),
+                                   });
+
+  SetupStorageBuffer({
+      Member("c", ty.array(ty.Of(inner), 4, 32)),
+  });
+
+  SetupFunction({
+      Decl(Var(
+          "x", nullptr, ast::StorageClass::kNone,
+          IndexAccessor(MemberAccessor(
+                            IndexAccessor(MemberAccessor("data", "c"), 2), "b"),
+                        1))),
+  });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  auto* expected =
+      R"(#version 310 es
+precision mediump float;
+
+
+Data data : register(u0, space1);
+
+void main() {
+  float x = data.c[2].b[1];
+  return;
+}
+void main() {
+  main();
+}
+
+
+)";
+  EXPECT_EQ(gen.result(), expected);
+}
+
+TEST_F(GlslGeneratorImplTest_MemberAccessor, StorageBuffer_Store_MultiLevel) {
+  // struct Inner {
+  //   a : vec3<i32>;
+  //   b : vec3<f32>;
+  // };
+  // struct Data {
+  //   var c : [[stride(32)]] array<Inner, 4>;
+  // };
+  //
+  // var<storage> data : Pre;
+  // data.c[2].b = vec3<f32>(1.f, 2.f, 3.f);
+
+  auto* inner = Structure("Inner", {
+                                       Member("a", ty.vec3<f32>()),
+                                       Member("b", ty.vec3<f32>()),
+                                   });
+
+  SetupStorageBuffer({
+      Member("c", ty.array(ty.Of(inner), 4, 32)),
+  });
+
+  SetupFunction({
+      Assign(MemberAccessor(IndexAccessor(MemberAccessor("data", "c"), 2), "b"),
+             vec3<f32>(1.f, 2.f, 3.f)),
+  });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  auto* expected =
+      R"(#version 310 es
+precision mediump float;
+
+
+Data data : register(u0, space1);
+
+void main() {
+  data.c[2].b = vec3(1.0f, 2.0f, 3.0f);
+  return;
+}
+void main() {
+  main();
+}
+
+
+)";
+  EXPECT_EQ(gen.result(), expected);
+}
+
+TEST_F(GlslGeneratorImplTest_MemberAccessor,
+       StorageBuffer_Store_Swizzle_SingleLetter) {
+  // struct Inner {
+  //   a : vec3<i32>;
+  //   b : vec3<f32>;
+  // };
+  // struct Data {
+  //   var c : [[stride(32)]] array<Inner, 4>;
+  // };
+  //
+  // var<storage> data : Pre;
+  // data.c[2].b.y = 1.f;
+
+  auto* inner = Structure("Inner", {
+                                       Member("a", ty.vec3<i32>()),
+                                       Member("b", ty.vec3<f32>()),
+                                   });
+
+  SetupStorageBuffer({
+      Member("c", ty.array(ty.Of(inner), 4, 32)),
+  });
+
+  SetupFunction({
+      Assign(MemberAccessor(
+                 MemberAccessor(IndexAccessor(MemberAccessor("data", "c"), 2),
+                                "b"),
+                 "y"),
+             Expr(1.f)),
+  });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  auto* expected =
+      R"(#version 310 es
+precision mediump float;
+
+
+Data data : register(u0, space1);
+
+void main() {
+  data.c[2].b.y = 1.0f;
+  return;
+}
+void main() {
+  main();
+}
+
+
+)";
+  EXPECT_EQ(gen.result(), expected);
+}
+
+TEST_F(GlslGeneratorImplTest_MemberAccessor, Swizzle_xyz) {
+  auto* var = Var("my_vec", ty.vec4<f32>(), ast::StorageClass::kNone,
+                  vec4<f32>(1.f, 2.f, 3.f, 4.f));
+  auto* expr = MemberAccessor("my_vec", "xyz");
+  WrapInFunction(var, expr);
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("my_vec.xyz"));
+}
+
+TEST_F(GlslGeneratorImplTest_MemberAccessor, Swizzle_gbr) {
+  auto* var = Var("my_vec", ty.vec4<f32>(), ast::StorageClass::kNone,
+                  vec4<f32>(1.f, 2.f, 3.f, 4.f));
+  auto* expr = MemberAccessor("my_vec", "gbr");
+  WrapInFunction(var, expr);
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("my_vec.gbr"));
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_module_constant_test.cc b/src/writer/glsl/generator_impl_module_constant_test.cc
new file mode 100644
index 0000000..85bcab9
--- /dev/null
+++ b/src/writer/glsl/generator_impl_module_constant_test.cc
@@ -0,0 +1,96 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/ast/override_decoration.h"
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_ModuleConstant = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_ModuleConstant, Emit_ModuleConstant) {
+  auto* var = Const("pos", ty.array<f32, 3>(), array<f32, 3>(1.f, 2.f, 3.f));
+  WrapInFunction(Decl(var));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitProgramConstVariable(var)) << gen.error();
+  EXPECT_EQ(gen.result(),
+            "static const float pos[3] = float[3](1.0f, 2.0f, 3.0f);\n");
+}
+
+TEST_F(GlslGeneratorImplTest_ModuleConstant, Emit_SpecConstant) {
+  auto* var = GlobalConst("pos", ty.f32(), Expr(3.0f),
+                          ast::DecorationList{
+                              create<ast::OverrideDecoration>(23),
+                          });
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitProgramConstVariable(var)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#ifndef WGSL_SPEC_CONSTANT_23
+#define WGSL_SPEC_CONSTANT_23 3.0f
+#endif
+static const float pos = WGSL_SPEC_CONSTANT_23;
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_ModuleConstant, Emit_SpecConstant_NoConstructor) {
+  auto* var = GlobalConst("pos", ty.f32(), nullptr,
+                          ast::DecorationList{
+                              create<ast::OverrideDecoration>(23),
+                          });
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitProgramConstVariable(var)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#ifndef WGSL_SPEC_CONSTANT_23
+#error spec constant required for constant id 23
+#endif
+static const float pos = WGSL_SPEC_CONSTANT_23;
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_ModuleConstant, Emit_SpecConstant_NoId) {
+  auto* a = GlobalConst("a", ty.f32(), Expr(3.0f),
+                        ast::DecorationList{
+                            create<ast::OverrideDecoration>(0),
+                        });
+  auto* b = GlobalConst("b", ty.f32(), Expr(2.0f),
+                        ast::DecorationList{
+                            create<ast::OverrideDecoration>(),
+                        });
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitProgramConstVariable(a)) << gen.error();
+  ASSERT_TRUE(gen.EmitProgramConstVariable(b)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#ifndef WGSL_SPEC_CONSTANT_0
+#define WGSL_SPEC_CONSTANT_0 3.0f
+#endif
+static const float a = WGSL_SPEC_CONSTANT_0;
+#ifndef WGSL_SPEC_CONSTANT_1
+#define WGSL_SPEC_CONSTANT_1 2.0f
+#endif
+static const float b = WGSL_SPEC_CONSTANT_1;
+)");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_return_test.cc b/src/writer/glsl/generator_impl_return_test.cc
new file mode 100644
index 0000000..bcb5bc6
--- /dev/null
+++ b/src/writer/glsl/generator_impl_return_test.cc
@@ -0,0 +1,51 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_Return = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_Return, Emit_Return) {
+  auto* r = Return();
+  WrapInFunction(r);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(r)) << gen.error();
+  EXPECT_EQ(gen.result(), "  return;\n");
+}
+
+TEST_F(GlslGeneratorImplTest_Return, Emit_ReturnWithValue) {
+  auto* r = Return(123);
+  Func("f", {}, ty.i32(), {r});
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(r)) << gen.error();
+  EXPECT_EQ(gen.result(), "  return 123;\n");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_sanitizer_test.cc b/src/writer/glsl/generator_impl_sanitizer_test.cc
new file mode 100644
index 0000000..5bf694a
--- /dev/null
+++ b/src/writer/glsl/generator_impl_sanitizer_test.cc
@@ -0,0 +1,351 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/ast/call_statement.h"
+#include "src/ast/stage_decoration.h"
+#include "src/ast/struct_block_decoration.h"
+#include "src/ast/variable_decl_statement.h"
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslSanitizerTest = TestHelper;
+
+TEST_F(GlslSanitizerTest, Call_ArrayLength) {
+  auto* s = Structure("my_struct", {Member(0, "a", ty.array<f32>(4))},
+                      {create<ast::StructBlockDecoration>()});
+  Global("b", ty.Of(s), ast::StorageClass::kStorage, ast::Access::kRead,
+         ast::DecorationList{
+             create<ast::BindingDecoration>(1),
+             create<ast::GroupDecoration>(2),
+         });
+
+  Func("a_func", ast::VariableList{}, ty.void_(),
+       ast::StatementList{
+           Decl(Var("len", ty.u32(), ast::StorageClass::kNone,
+                    Call("arrayLength", AddressOf(MemberAccessor("b", "a"))))),
+       },
+       ast::DecorationList{
+           Stage(ast::PipelineStage::kFragment),
+       });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+
+  auto got = gen.result();
+  auto* expect = R"(#version 310 es
+precision mediump float;
+
+
+my_struct b : register(t1, space2);
+
+void a_func() {
+  uint tint_symbol_1 = 0u;
+  b.GetDimensions(tint_symbol_1);
+  uint tint_symbol_2 = ((tint_symbol_1 - 0u) / 4u);
+  uint len = tint_symbol_2;
+  return;
+}
+void main() {
+  a_func();
+}
+
+
+)";
+  EXPECT_EQ(expect, got);
+}
+
+TEST_F(GlslSanitizerTest, Call_ArrayLength_OtherMembersInStruct) {
+  auto* s = Structure("my_struct",
+                      {
+                          Member(0, "z", ty.f32()),
+                          Member(4, "a", ty.array<f32>(4)),
+                      },
+                      {create<ast::StructBlockDecoration>()});
+  Global("b", ty.Of(s), ast::StorageClass::kStorage, ast::Access::kRead,
+         ast::DecorationList{
+             create<ast::BindingDecoration>(1),
+             create<ast::GroupDecoration>(2),
+         });
+
+  Func("a_func", ast::VariableList{}, ty.void_(),
+       ast::StatementList{
+           Decl(Var("len", ty.u32(), ast::StorageClass::kNone,
+                    Call("arrayLength", AddressOf(MemberAccessor("b", "a"))))),
+       },
+       ast::DecorationList{
+           Stage(ast::PipelineStage::kFragment),
+       });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+
+  auto got = gen.result();
+  auto* expect = R"(#version 310 es
+precision mediump float;
+
+
+my_struct b : register(t1, space2);
+
+void a_func() {
+  uint tint_symbol_1 = 0u;
+  b.GetDimensions(tint_symbol_1);
+  uint tint_symbol_2 = ((tint_symbol_1 - 4u) / 4u);
+  uint len = tint_symbol_2;
+  return;
+}
+void main() {
+  a_func();
+}
+
+
+)";
+
+  EXPECT_EQ(expect, got);
+}
+
+TEST_F(GlslSanitizerTest, Call_ArrayLength_ViaLets) {
+  auto* s = Structure("my_struct", {Member(0, "a", ty.array<f32>(4))},
+                      {create<ast::StructBlockDecoration>()});
+  Global("b", ty.Of(s), ast::StorageClass::kStorage, ast::Access::kRead,
+         ast::DecorationList{
+             create<ast::BindingDecoration>(1),
+             create<ast::GroupDecoration>(2),
+         });
+
+  auto* p = Const("p", nullptr, AddressOf("b"));
+  auto* p2 = Const("p2", nullptr, AddressOf(MemberAccessor(Deref(p), "a")));
+
+  Func("a_func", ast::VariableList{}, ty.void_(),
+       ast::StatementList{
+           Decl(p),
+           Decl(p2),
+           Decl(Var("len", ty.u32(), ast::StorageClass::kNone,
+                    Call("arrayLength", p2))),
+       },
+       ast::DecorationList{
+           Stage(ast::PipelineStage::kFragment),
+       });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+
+  auto got = gen.result();
+  auto* expect = R"(#version 310 es
+precision mediump float;
+
+
+my_struct b : register(t1, space2);
+
+void a_func() {
+  uint tint_symbol_1 = 0u;
+  b.GetDimensions(tint_symbol_1);
+  uint tint_symbol_2 = ((tint_symbol_1 - 0u) / 4u);
+  uint len = tint_symbol_2;
+  return;
+}
+void main() {
+  a_func();
+}
+
+
+)";
+
+  EXPECT_EQ(expect, got);
+}
+
+TEST_F(GlslSanitizerTest, PromoteArrayInitializerToConstVar) {
+  auto* array_init = array<i32, 4>(1, 2, 3, 4);
+  auto* array_index = IndexAccessor(array_init, 3);
+  auto* pos = Var("pos", ty.i32(), ast::StorageClass::kNone, array_index);
+
+  Func("main", ast::VariableList{}, ty.void_(),
+       {
+           Decl(pos),
+       },
+       {
+           Stage(ast::PipelineStage::kFragment),
+       });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+
+  auto got = gen.result();
+  auto* expect = R"(#version 310 es
+precision mediump float;
+
+void main() {
+  int tint_symbol[4] = int[4](1, 2, 3, 4);
+  int pos = tint_symbol[3];
+  return;
+}
+void main() {
+  main();
+}
+
+
+)";
+  EXPECT_EQ(expect, got);
+}
+
+TEST_F(GlslSanitizerTest, PromoteStructInitializerToConstVar) {
+  auto* str = Structure("S", {
+                                 Member("a", ty.i32()),
+                                 Member("b", ty.vec3<f32>()),
+                                 Member("c", ty.i32()),
+                             });
+  auto* struct_init = Construct(ty.Of(str), 1, vec3<f32>(2.f, 3.f, 4.f), 4);
+  auto* struct_access = MemberAccessor(struct_init, "b");
+  auto* pos =
+      Var("pos", ty.vec3<f32>(), ast::StorageClass::kNone, struct_access);
+
+  Func("main", ast::VariableList{}, ty.void_(),
+       {
+           Decl(pos),
+       },
+       {
+           Stage(ast::PipelineStage::kFragment),
+       });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+
+  auto got = gen.result();
+  auto* expect = R"(#version 310 es
+precision mediump float;
+
+struct S {
+  int a;
+  vec3 b;
+  int c;
+};
+
+void main() {
+  S tint_symbol = S(1, vec3(2.0f, 3.0f, 4.0f), 4);
+  vec3 pos = tint_symbol.b;
+  return;
+}
+void main() {
+  main();
+}
+
+
+)";
+  EXPECT_EQ(expect, got);
+}
+
+TEST_F(GlslSanitizerTest, InlinePtrLetsBasic) {
+  // var v : i32;
+  // let p : ptr<function, i32> = &v;
+  // let x : i32 = *p;
+  auto* v = Var("v", ty.i32());
+  auto* p =
+      Const("p", ty.pointer<i32>(ast::StorageClass::kFunction), AddressOf(v));
+  auto* x = Var("x", ty.i32(), ast::StorageClass::kNone, Deref(p));
+
+  Func("main", ast::VariableList{}, ty.void_(),
+       {
+           Decl(v),
+           Decl(p),
+           Decl(x),
+       },
+       {
+           Stage(ast::PipelineStage::kFragment),
+       });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+
+  auto got = gen.result();
+  auto* expect = R"(#version 310 es
+precision mediump float;
+
+void main() {
+  int v = 0;
+  int x = v;
+  return;
+}
+void main() {
+  main();
+}
+
+
+)";
+  EXPECT_EQ(expect, got);
+}
+
+TEST_F(GlslSanitizerTest, InlinePtrLetsComplexChain) {
+  // var m : mat4x4<f32>;
+  // let mp : ptr<function, mat4x4<f32>> = &m;
+  // let vp : ptr<function, vec4<f32>> = &(*mp)[2];
+  // let fp : ptr<function, f32> = &(*vp)[1];
+  // let f : f32 = *fp;
+  auto* m = Var("m", ty.mat4x4<f32>());
+  auto* mp =
+      Const("mp", ty.pointer(ty.mat4x4<f32>(), ast::StorageClass::kFunction),
+            AddressOf(m));
+  auto* vp =
+      Const("vp", ty.pointer(ty.vec4<f32>(), ast::StorageClass::kFunction),
+            AddressOf(IndexAccessor(Deref(mp), 2)));
+  auto* fp = Const("fp", ty.pointer<f32>(ast::StorageClass::kFunction),
+                   AddressOf(IndexAccessor(Deref(vp), 1)));
+  auto* f = Var("f", ty.f32(), ast::StorageClass::kNone, Deref(fp));
+
+  Func("main", ast::VariableList{}, ty.void_(),
+       {
+           Decl(m),
+           Decl(mp),
+           Decl(vp),
+           Decl(fp),
+           Decl(f),
+       },
+       {
+           Stage(ast::PipelineStage::kFragment),
+       });
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+
+  auto got = gen.result();
+  auto* expect = R"(#version 310 es
+precision mediump float;
+
+void main() {
+  mat4 m = mat4(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
+  float f = m[2][1];
+  return;
+}
+void main() {
+  main();
+}
+
+
+)";
+  EXPECT_EQ(expect, got);
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_switch_test.cc b/src/writer/glsl/generator_impl_switch_test.cc
new file mode 100644
index 0000000..9ebe45b
--- /dev/null
+++ b/src/writer/glsl/generator_impl_switch_test.cc
@@ -0,0 +1,64 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest_Switch = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_Switch, Emit_Switch) {
+  Global("cond", ty.i32(), ast::StorageClass::kPrivate);
+
+  auto* def_body = Block(create<ast::BreakStatement>());
+  auto* def = create<ast::CaseStatement>(ast::CaseSelectorList{}, def_body);
+
+  ast::CaseSelectorList case_val;
+  case_val.push_back(Literal(5));
+
+  auto* case_body = Block(create<ast::BreakStatement>());
+
+  auto* case_stmt = create<ast::CaseStatement>(case_val, case_body);
+
+  ast::CaseStatementList body;
+  body.push_back(case_stmt);
+  body.push_back(def);
+
+  auto* cond = Expr("cond");
+  auto* s = create<ast::SwitchStatement>(cond, body);
+  WrapInFunction(s);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(s)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(  switch(cond) {
+    case 5: {
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+)");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_test.cc b/src/writer/glsl/generator_impl_test.cc
new file mode 100644
index 0000000..3075885
--- /dev/null
+++ b/src/writer/glsl/generator_impl_test.cc
@@ -0,0 +1,87 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslGeneratorImplTest = TestHelper;
+
+TEST_F(GlslGeneratorImplTest, ErrorIfSanitizerNotRun) {
+  auto program = std::make_unique<Program>(std::move(*this));
+  GeneratorImpl gen(program.get());
+  EXPECT_FALSE(gen.Generate());
+  EXPECT_EQ(
+      gen.error(),
+      "error: GLSL writer requires the transform::Glsl sanitizer to have been "
+      "applied to the input program");
+}
+
+TEST_F(GlslGeneratorImplTest, Generate) {
+  Func("my_func", ast::VariableList{}, ty.void_(), ast::StatementList{},
+       ast::DecorationList{});
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_EQ(gen.result(), R"(#version 310 es
+precision mediump float;
+
+void my_func() {
+}
+)");
+}
+
+struct GlslBuiltinData {
+  ast::Builtin builtin;
+  const char* attribute_name;
+};
+inline std::ostream& operator<<(std::ostream& out, GlslBuiltinData data) {
+  out << data.builtin;
+  return out;
+}
+using GlslBuiltinConversionTest = TestParamHelper<GlslBuiltinData>;
+TEST_P(GlslBuiltinConversionTest, Emit) {
+  auto params = GetParam();
+  GeneratorImpl& gen = Build();
+
+  EXPECT_EQ(gen.builtin_to_string(params.builtin),
+            std::string(params.attribute_name));
+}
+INSTANTIATE_TEST_SUITE_P(
+    GlslGeneratorImplTest,
+    GlslBuiltinConversionTest,
+    testing::Values(
+        GlslBuiltinData{ast::Builtin::kPosition, "gl_Position"},
+        GlslBuiltinData{ast::Builtin::kVertexIndex, "gl_VertexID"},
+        GlslBuiltinData{ast::Builtin::kInstanceIndex, "gl_InstanceID"},
+        GlslBuiltinData{ast::Builtin::kFrontFacing, "gl_FrontFacing"},
+        GlslBuiltinData{ast::Builtin::kFragDepth, "gl_FragDepth"},
+        GlslBuiltinData{ast::Builtin::kLocalInvocationId,
+                        "gl_LocalInvocationID"},
+        GlslBuiltinData{ast::Builtin::kLocalInvocationIndex,
+                        "gl_LocalInvocationIndex"},
+        GlslBuiltinData{ast::Builtin::kGlobalInvocationId,
+                        "gl_GlobalInvocationID"},
+        GlslBuiltinData{ast::Builtin::kWorkgroupId, "gl_WorkGroupID"},
+        GlslBuiltinData{ast::Builtin::kSampleIndex, "gl_SampleID"},
+        GlslBuiltinData{ast::Builtin::kSampleMask, "gl_SampleMask"}));
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_type_test.cc b/src/writer/glsl/generator_impl_type_test.cc
new file mode 100644
index 0000000..c5cde9f
--- /dev/null
+++ b/src/writer/glsl/generator_impl_type_test.cc
@@ -0,0 +1,615 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "gmock/gmock.h"
+#include "src/ast/call_statement.h"
+#include "src/ast/stage_decoration.h"
+#include "src/ast/struct_block_decoration.h"
+#include "src/sem/depth_texture_type.h"
+#include "src/sem/multisampled_texture_type.h"
+#include "src/sem/sampled_texture_type.h"
+#include "src/sem/sampler_type.h"
+#include "src/sem/storage_texture_type.h"
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using ::testing::HasSubstr;
+
+using GlslGeneratorImplTest_Type = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_Type, EmitType_Array) {
+  auto* arr = ty.array<bool, 4>();
+  Global("G", arr, ast::StorageClass::kPrivate);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, "ary"))
+      << gen.error();
+  EXPECT_EQ(out.str(), "bool ary[4]");
+}
+
+TEST_F(GlslGeneratorImplTest_Type, EmitType_ArrayOfArray) {
+  auto* arr = ty.array(ty.array<bool, 4>(), 5);
+  Global("G", arr, ast::StorageClass::kPrivate);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, "ary"))
+      << gen.error();
+  EXPECT_EQ(out.str(), "bool ary[5][4]");
+}
+
+// TODO(dsinclair): Is this possible? What order should it output in?
+TEST_F(GlslGeneratorImplTest_Type,
+       DISABLED_EmitType_ArrayOfArrayOfRuntimeArray) {
+  auto* arr = ty.array(ty.array(ty.array<bool, 4>(), 5), 0);
+  Global("G", arr, ast::StorageClass::kPrivate);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, "ary"))
+      << gen.error();
+  EXPECT_EQ(out.str(), "bool ary[5][4][1]");
+}
+
+TEST_F(GlslGeneratorImplTest_Type, EmitType_ArrayOfArrayOfArray) {
+  auto* arr = ty.array(ty.array(ty.array<bool, 4>(), 5), 6);
+  Global("G", arr, ast::StorageClass::kPrivate);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, "ary"))
+      << gen.error();
+  EXPECT_EQ(out.str(), "bool ary[6][5][4]");
+}
+
+TEST_F(GlslGeneratorImplTest_Type, EmitType_Array_WithoutName) {
+  auto* arr = ty.array<bool, 4>();
+  Global("G", arr, ast::StorageClass::kPrivate);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitType(out, program->TypeOf(arr), ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, ""))
+      << gen.error();
+  EXPECT_EQ(out.str(), "bool[4]");
+}
+
+TEST_F(GlslGeneratorImplTest_Type, EmitType_Bool) {
+  auto* bool_ = create<sem::Bool>();
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitType(out, bool_, ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, ""))
+      << gen.error();
+  EXPECT_EQ(out.str(), "bool");
+}
+
+TEST_F(GlslGeneratorImplTest_Type, EmitType_F32) {
+  auto* f32 = create<sem::F32>();
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitType(out, f32, ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, ""))
+      << gen.error();
+  EXPECT_EQ(out.str(), "float");
+}
+
+TEST_F(GlslGeneratorImplTest_Type, EmitType_I32) {
+  auto* i32 = create<sem::I32>();
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitType(out, i32, ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, ""))
+      << gen.error();
+  EXPECT_EQ(out.str(), "int");
+}
+
+TEST_F(GlslGeneratorImplTest_Type, EmitType_Matrix) {
+  auto* f32 = create<sem::F32>();
+  auto* vec3 = create<sem::Vector>(f32, 3);
+  auto* mat2x3 = create<sem::Matrix>(vec3, 2);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitType(out, mat2x3, ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, ""))
+      << gen.error();
+  EXPECT_EQ(out.str(), "mat2x3");
+}
+
+// TODO(dsinclair): How to annotate as workgroup?
+TEST_F(GlslGeneratorImplTest_Type, DISABLED_EmitType_Pointer) {
+  auto* f32 = create<sem::F32>();
+  auto* p = create<sem::Pointer>(f32, ast::StorageClass::kWorkgroup,
+                                 ast::Access::kReadWrite);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitType(out, p, ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, ""))
+      << gen.error();
+  EXPECT_EQ(out.str(), "float*");
+}
+
+TEST_F(GlslGeneratorImplTest_Type, EmitType_StructDecl) {
+  auto* s = Structure("S", {
+                               Member("a", ty.i32()),
+                               Member("b", ty.f32()),
+                           });
+  Global("g", ty.Of(s), ast::StorageClass::kPrivate);
+
+  GeneratorImpl& gen = Build();
+
+  TextGenerator::TextBuffer buf;
+  auto* sem_s = program->TypeOf(s)->As<sem::Struct>();
+  ASSERT_TRUE(gen.EmitStructType(&buf, sem_s)) << gen.error();
+  EXPECT_EQ(buf.String(), R"(struct S {
+  int a;
+  float b;
+};
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Type, EmitType_StructDecl_OmittedIfStorageBuffer) {
+  auto* s = Structure("S",
+                      {
+                          Member("a", ty.i32()),
+                          Member("b", ty.f32()),
+                      },
+                      {create<ast::StructBlockDecoration>()});
+  Global("g", ty.Of(s), ast::StorageClass::kStorage, ast::Access::kReadWrite,
+         ast::DecorationList{
+             create<ast::BindingDecoration>(0),
+             create<ast::GroupDecoration>(0),
+         });
+
+  GeneratorImpl& gen = Build();
+
+  TextGenerator::TextBuffer buf;
+  auto* sem_s = program->TypeOf(s)->As<sem::Struct>();
+  ASSERT_TRUE(gen.EmitStructType(&buf, sem_s)) << gen.error();
+  EXPECT_EQ(buf.String(), "");
+}
+
+TEST_F(GlslGeneratorImplTest_Type, EmitType_Struct) {
+  auto* s = Structure("S", {
+                               Member("a", ty.i32()),
+                               Member("b", ty.f32()),
+                           });
+  Global("g", ty.Of(s), ast::StorageClass::kPrivate);
+
+  GeneratorImpl& gen = Build();
+
+  auto* sem_s = program->TypeOf(s)->As<sem::Struct>();
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitType(out, sem_s, ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, ""))
+      << gen.error();
+  EXPECT_EQ(out.str(), "S");
+}
+
+TEST_F(GlslGeneratorImplTest_Type, EmitType_Struct_NameCollision) {
+  auto* s = Structure("S", {
+                               Member("double", ty.i32()),
+                               Member("float", ty.f32()),
+                           });
+  Global("g", ty.Of(s), ast::StorageClass::kPrivate);
+
+  GeneratorImpl& gen = SanitizeAndBuild();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr(R"(struct S {
+  int tint_symbol;
+  float tint_symbol_1;
+};
+)"));
+}
+
+TEST_F(GlslGeneratorImplTest_Type, EmitType_Struct_WithOffsetAttributes) {
+  auto* s = Structure("S",
+                      {
+                          Member("a", ty.i32(), {MemberOffset(0)}),
+                          Member("b", ty.f32(), {MemberOffset(8)}),
+                      },
+                      {create<ast::StructBlockDecoration>()});
+  Global("g", ty.Of(s), ast::StorageClass::kPrivate);
+
+  GeneratorImpl& gen = Build();
+
+  TextGenerator::TextBuffer buf;
+  auto* sem_s = program->TypeOf(s)->As<sem::Struct>();
+  ASSERT_TRUE(gen.EmitStructType(&buf, sem_s)) << gen.error();
+  EXPECT_EQ(buf.String(), R"(struct S {
+  int a;
+  float b;
+};
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_Type, EmitType_U32) {
+  auto* u32 = create<sem::U32>();
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitType(out, u32, ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, ""))
+      << gen.error();
+  EXPECT_EQ(out.str(), "uint");
+}
+
+TEST_F(GlslGeneratorImplTest_Type, EmitType_Vector) {
+  auto* f32 = create<sem::F32>();
+  auto* vec3 = create<sem::Vector>(f32, 3);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitType(out, vec3, ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, ""))
+      << gen.error();
+  EXPECT_EQ(out.str(), "vec3");
+}
+
+TEST_F(GlslGeneratorImplTest_Type, EmitType_Void) {
+  auto* void_ = create<sem::Void>();
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitType(out, void_, ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, ""))
+      << gen.error();
+  EXPECT_EQ(out.str(), "void");
+}
+
+TEST_F(GlslGeneratorImplTest_Type, EmitSampler) {
+  auto* sampler = create<sem::Sampler>(ast::SamplerKind::kSampler);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitType(out, sampler, ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, ""))
+      << gen.error();
+  EXPECT_EQ(out.str(), "SamplerState");
+}
+
+TEST_F(GlslGeneratorImplTest_Type, EmitSamplerComparison) {
+  auto* sampler = create<sem::Sampler>(ast::SamplerKind::kComparisonSampler);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitType(out, sampler, ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, ""))
+      << gen.error();
+  EXPECT_EQ(out.str(), "SamplerComparisonState");
+}
+
+struct GlslDepthTextureData {
+  ast::TextureDimension dim;
+  std::string result;
+};
+inline std::ostream& operator<<(std::ostream& out, GlslDepthTextureData data) {
+  out << data.dim;
+  return out;
+}
+using GlslDepthTexturesTest = TestParamHelper<GlslDepthTextureData>;
+TEST_P(GlslDepthTexturesTest, Emit) {
+  auto params = GetParam();
+
+  auto* t = ty.depth_texture(params.dim);
+
+  Global("tex", t,
+         ast::DecorationList{
+             create<ast::BindingDecoration>(1),
+             create<ast::GroupDecoration>(2),
+         });
+
+  Func("main", {}, ty.void_(), {Ignore(Call("textureDimensions", "tex"))},
+       {Stage(ast::PipelineStage::kFragment)});
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr(params.result));
+}
+INSTANTIATE_TEST_SUITE_P(
+    GlslGeneratorImplTest_Type,
+    GlslDepthTexturesTest,
+    testing::Values(
+        GlslDepthTextureData{ast::TextureDimension::k2d,
+                             "Texture2D tex : register(t1, space2);"},
+        GlslDepthTextureData{ast::TextureDimension::k2dArray,
+                             "Texture2DArray tex : register(t1, space2);"},
+        GlslDepthTextureData{ast::TextureDimension::kCube,
+                             "TextureCube tex : register(t1, space2);"},
+        GlslDepthTextureData{ast::TextureDimension::kCubeArray,
+                             "TextureCubeArray tex : register(t1, space2);"}));
+
+using GlslDepthMultisampledTexturesTest = TestHelper;
+TEST_F(GlslDepthMultisampledTexturesTest, Emit) {
+  auto* t = ty.depth_multisampled_texture(ast::TextureDimension::k2d);
+
+  Global("tex", t,
+         ast::DecorationList{
+             create<ast::BindingDecoration>(1),
+             create<ast::GroupDecoration>(2),
+         });
+
+  Func("main", {}, ty.void_(), {Ignore(Call("textureDimensions", "tex"))},
+       {Stage(ast::PipelineStage::kFragment)});
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(),
+              HasSubstr("Texture2DMS<float4> tex : register(t1, space2);"));
+}
+
+enum class TextureDataType { F32, U32, I32 };
+struct GlslSampledTextureData {
+  ast::TextureDimension dim;
+  TextureDataType datatype;
+  std::string result;
+};
+inline std::ostream& operator<<(std::ostream& out,
+                                GlslSampledTextureData data) {
+  out << data.dim;
+  return out;
+}
+using GlslSampledTexturesTest = TestParamHelper<GlslSampledTextureData>;
+TEST_P(GlslSampledTexturesTest, Emit) {
+  auto params = GetParam();
+
+  ast::Type* datatype = nullptr;
+  switch (params.datatype) {
+    case TextureDataType::F32:
+      datatype = ty.f32();
+      break;
+    case TextureDataType::U32:
+      datatype = ty.u32();
+      break;
+    case TextureDataType::I32:
+      datatype = ty.i32();
+      break;
+  }
+  auto* t = ty.sampled_texture(params.dim, datatype);
+
+  Global("tex", t,
+         ast::DecorationList{
+             create<ast::BindingDecoration>(1),
+             create<ast::GroupDecoration>(2),
+         });
+
+  Func("main", {}, ty.void_(), {Ignore(Call("textureDimensions", "tex"))},
+       {Stage(ast::PipelineStage::kFragment)});
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr(params.result));
+}
+INSTANTIATE_TEST_SUITE_P(
+    GlslGeneratorImplTest_Type,
+    GlslSampledTexturesTest,
+    testing::Values(
+        GlslSampledTextureData{
+            ast::TextureDimension::k1d,
+            TextureDataType::F32,
+            "Texture1D<float4> tex : register(t1, space2);",
+        },
+        GlslSampledTextureData{
+            ast::TextureDimension::k2d,
+            TextureDataType::F32,
+            "Texture2D<float4> tex : register(t1, space2);",
+        },
+        GlslSampledTextureData{
+            ast::TextureDimension::k2dArray,
+            TextureDataType::F32,
+            "Texture2DArray<float4> tex : register(t1, space2);",
+        },
+        GlslSampledTextureData{
+            ast::TextureDimension::k3d,
+            TextureDataType::F32,
+            "Texture3D<float4> tex : register(t1, space2);",
+        },
+        GlslSampledTextureData{
+            ast::TextureDimension::kCube,
+            TextureDataType::F32,
+            "TextureCube<float4> tex : register(t1, space2);",
+        },
+        GlslSampledTextureData{
+            ast::TextureDimension::kCubeArray,
+            TextureDataType::F32,
+            "TextureCubeArray<float4> tex : register(t1, space2);",
+        },
+        GlslSampledTextureData{
+            ast::TextureDimension::k1d,
+            TextureDataType::U32,
+            "Texture1D<uint4> tex : register(t1, space2);",
+        },
+        GlslSampledTextureData{
+            ast::TextureDimension::k2d,
+            TextureDataType::U32,
+            "Texture2D<uint4> tex : register(t1, space2);",
+        },
+        GlslSampledTextureData{
+            ast::TextureDimension::k2dArray,
+            TextureDataType::U32,
+            "Texture2DArray<uint4> tex : register(t1, space2);",
+        },
+        GlslSampledTextureData{
+            ast::TextureDimension::k3d,
+            TextureDataType::U32,
+            "Texture3D<uint4> tex : register(t1, space2);",
+        },
+        GlslSampledTextureData{
+            ast::TextureDimension::kCube,
+            TextureDataType::U32,
+            "TextureCube<uint4> tex : register(t1, space2);",
+        },
+        GlslSampledTextureData{
+            ast::TextureDimension::kCubeArray,
+            TextureDataType::U32,
+            "TextureCubeArray<uint4> tex : register(t1, space2);",
+        },
+        GlslSampledTextureData{
+            ast::TextureDimension::k1d,
+            TextureDataType::I32,
+            "Texture1D<int4> tex : register(t1, space2);",
+        },
+        GlslSampledTextureData{
+            ast::TextureDimension::k2d,
+            TextureDataType::I32,
+            "Texture2D<int4> tex : register(t1, space2);",
+        },
+        GlslSampledTextureData{
+            ast::TextureDimension::k2dArray,
+            TextureDataType::I32,
+            "Texture2DArray<int4> tex : register(t1, space2);",
+        },
+        GlslSampledTextureData{
+            ast::TextureDimension::k3d,
+            TextureDataType::I32,
+            "Texture3D<int4> tex : register(t1, space2);",
+        },
+        GlslSampledTextureData{
+            ast::TextureDimension::kCube,
+            TextureDataType::I32,
+            "TextureCube<int4> tex : register(t1, space2);",
+        },
+        GlslSampledTextureData{
+            ast::TextureDimension::kCubeArray,
+            TextureDataType::I32,
+            "TextureCubeArray<int4> tex : register(t1, space2);",
+        }));
+
+TEST_F(GlslGeneratorImplTest_Type, EmitMultisampledTexture) {
+  auto* f32 = create<sem::F32>();
+  auto* s = create<sem::MultisampledTexture>(ast::TextureDimension::k2d, f32);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitType(out, s, ast::StorageClass::kNone,
+                           ast::Access::kReadWrite, ""))
+      << gen.error();
+  EXPECT_EQ(out.str(), "Texture2DMS<float4>");
+}
+
+struct GlslStorageTextureData {
+  ast::TextureDimension dim;
+  ast::ImageFormat imgfmt;
+  bool ro;
+  std::string result;
+};
+inline std::ostream& operator<<(std::ostream& out,
+                                GlslStorageTextureData data) {
+  out << data.dim << (data.ro ? "ReadOnly" : "WriteOnly");
+  return out;
+}
+using GlslStorageTexturesTest = TestParamHelper<GlslStorageTextureData>;
+TEST_P(GlslStorageTexturesTest, Emit) {
+  auto params = GetParam();
+
+  auto* t =
+      ty.storage_texture(params.dim, params.imgfmt,
+                         params.ro ? ast::Access::kRead : ast::Access::kWrite);
+
+  Global("tex", t,
+         ast::DecorationList{
+             create<ast::BindingDecoration>(1),
+             create<ast::GroupDecoration>(2),
+         });
+
+  Func("main", {}, ty.void_(), {Ignore(Call("textureDimensions", "tex"))},
+       {Stage(ast::PipelineStage::kFragment)});
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr(params.result));
+}
+INSTANTIATE_TEST_SUITE_P(
+    GlslGeneratorImplTest_Type,
+    GlslStorageTexturesTest,
+    testing::Values(
+        GlslStorageTextureData{ast::TextureDimension::k1d,
+                               ast::ImageFormat::kRgba8Unorm, true,
+                               "Texture1D<float4> tex : register(t1, space2);"},
+        GlslStorageTextureData{ast::TextureDimension::k2d,
+                               ast::ImageFormat::kRgba16Float, true,
+                               "Texture2D<float4> tex : register(t1, space2);"},
+        GlslStorageTextureData{
+            ast::TextureDimension::k2dArray, ast::ImageFormat::kR32Float, true,
+            "Texture2DArray<float4> tex : register(t1, space2);"},
+        GlslStorageTextureData{ast::TextureDimension::k3d,
+                               ast::ImageFormat::kRg32Float, true,
+                               "Texture3D<float4> tex : register(t1, space2);"},
+        GlslStorageTextureData{
+            ast::TextureDimension::k1d, ast::ImageFormat::kRgba32Float, false,
+            "RWTexture1D<float4> tex : register(u1, space2);"},
+        GlslStorageTextureData{
+            ast::TextureDimension::k2d, ast::ImageFormat::kRgba16Uint, false,
+            "RWTexture2D<uint4> tex : register(u1, space2);"},
+        GlslStorageTextureData{
+            ast::TextureDimension::k2dArray, ast::ImageFormat::kR32Uint, false,
+            "RWTexture2DArray<uint4> tex : register(u1, space2);"},
+        GlslStorageTextureData{
+            ast::TextureDimension::k3d, ast::ImageFormat::kRg32Uint, false,
+            "RWTexture3D<uint4> tex : register(u1, space2);"},
+        GlslStorageTextureData{ast::TextureDimension::k1d,
+                               ast::ImageFormat::kRgba32Uint, true,
+                               "Texture1D<uint4> tex : register(t1, space2);"},
+        GlslStorageTextureData{ast::TextureDimension::k2d,
+                               ast::ImageFormat::kRgba16Sint, true,
+                               "Texture2D<int4> tex : register(t1, space2);"},
+        GlslStorageTextureData{
+            ast::TextureDimension::k2dArray, ast::ImageFormat::kR32Sint, true,
+            "Texture2DArray<int4> tex : register(t1, space2);"},
+        GlslStorageTextureData{ast::TextureDimension::k3d,
+                               ast::ImageFormat::kRg32Sint, true,
+                               "Texture3D<int4> tex : register(t1, space2);"},
+        GlslStorageTextureData{
+            ast::TextureDimension::k1d, ast::ImageFormat::kRgba32Sint, false,
+            "RWTexture1D<int4> tex : register(u1, space2);"}));
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_unary_op_test.cc b/src/writer/glsl/generator_impl_unary_op_test.cc
new file mode 100644
index 0000000..0b523e9
--- /dev/null
+++ b/src/writer/glsl/generator_impl_unary_op_test.cc
@@ -0,0 +1,93 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using GlslUnaryOpTest = TestHelper;
+
+TEST_F(GlslUnaryOpTest, AddressOf) {
+  Global("expr", ty.f32(), ast::StorageClass::kPrivate);
+  auto* op =
+      create<ast::UnaryOpExpression>(ast::UnaryOp::kAddressOf, Expr("expr"));
+  WrapInFunction(op);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, op)) << gen.error();
+  EXPECT_EQ(out.str(), "expr");
+}
+
+TEST_F(GlslUnaryOpTest, Complement) {
+  Global("expr", ty.u32(), ast::StorageClass::kPrivate);
+  auto* op =
+      create<ast::UnaryOpExpression>(ast::UnaryOp::kComplement, Expr("expr"));
+  WrapInFunction(op);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, op)) << gen.error();
+  EXPECT_EQ(out.str(), "~(expr)");
+}
+
+TEST_F(GlslUnaryOpTest, Indirection) {
+  Global("G", ty.f32(), ast::StorageClass::kPrivate);
+  auto* p = Const(
+      "expr", nullptr,
+      create<ast::UnaryOpExpression>(ast::UnaryOp::kAddressOf, Expr("G")));
+  auto* op =
+      create<ast::UnaryOpExpression>(ast::UnaryOp::kIndirection, Expr("expr"));
+  WrapInFunction(p, op);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, op)) << gen.error();
+  EXPECT_EQ(out.str(), "expr");
+}
+
+TEST_F(GlslUnaryOpTest, Not) {
+  Global("expr", ty.bool_(), ast::StorageClass::kPrivate);
+  auto* op = create<ast::UnaryOpExpression>(ast::UnaryOp::kNot, Expr("expr"));
+  WrapInFunction(op);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, op)) << gen.error();
+  EXPECT_EQ(out.str(), "!(expr)");
+}
+
+TEST_F(GlslUnaryOpTest, Negation) {
+  Global("expr", ty.i32(), ast::StorageClass::kPrivate);
+  auto* op =
+      create<ast::UnaryOpExpression>(ast::UnaryOp::kNegation, Expr("expr"));
+  WrapInFunction(op);
+
+  GeneratorImpl& gen = Build();
+
+  std::stringstream out;
+  ASSERT_TRUE(gen.EmitExpression(out, op)) << gen.error();
+  EXPECT_EQ(out.str(), "-(expr)");
+}
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_variable_decl_statement_test.cc b/src/writer/glsl/generator_impl_variable_decl_statement_test.cc
new file mode 100644
index 0000000..3db868b
--- /dev/null
+++ b/src/writer/glsl/generator_impl_variable_decl_statement_test.cc
@@ -0,0 +1,129 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "gmock/gmock.h"
+#include "src/ast/variable_decl_statement.h"
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+
+using ::testing::HasSubstr;
+
+using GlslGeneratorImplTest_VariableDecl = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement) {
+  auto* var = Var("a", ty.f32());
+  auto* stmt = Decl(var);
+  WrapInFunction(stmt);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
+  EXPECT_EQ(gen.result(), "  float a = 0.0f;\n");
+}
+
+TEST_F(GlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Const) {
+  auto* var = Const("a", ty.f32(), Construct(ty.f32()));
+  auto* stmt = Decl(var);
+  WrapInFunction(stmt);
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
+  EXPECT_EQ(gen.result(), "  float a = 0.0f;\n");
+}
+
+TEST_F(GlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Array) {
+  auto* var = Var("a", ty.array<f32, 5>());
+
+  WrapInFunction(var, Expr("a"));
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(
+      gen.result(),
+      HasSubstr("  float a[5] = float[5](0.0f, 0.0f, 0.0f, 0.0f, 0.0f);\n"));
+}
+
+TEST_F(GlslGeneratorImplTest_VariableDecl, Emit_VariableDeclStatement_Private) {
+  Global("a", ty.f32(), ast::StorageClass::kPrivate);
+
+  WrapInFunction(Expr("a"));
+
+  GeneratorImpl& gen = Build();
+
+  gen.increment_indent();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("  static float a = 0.0f;\n"));
+}
+
+TEST_F(GlslGeneratorImplTest_VariableDecl,
+       Emit_VariableDeclStatement_Initializer_Private) {
+  Global("initializer", ty.f32(), ast::StorageClass::kPrivate);
+  Global("a", ty.f32(), ast::StorageClass::kPrivate, Expr("initializer"));
+
+  WrapInFunction(Expr("a"));
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr(R"(float a = initializer;
+)"));
+}
+
+TEST_F(GlslGeneratorImplTest_VariableDecl,
+       Emit_VariableDeclStatement_Initializer_ZeroVec) {
+  auto* var = Var("a", ty.vec3<f32>(), ast::StorageClass::kNone, vec3<f32>());
+
+  auto* stmt = Decl(var);
+  WrapInFunction(stmt);
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
+  EXPECT_EQ(gen.result(), R"(vec3 a = vec3(0.0f, 0.0f, 0.0f);
+)");
+}
+
+TEST_F(GlslGeneratorImplTest_VariableDecl,
+       Emit_VariableDeclStatement_Initializer_ZeroMat) {
+  auto* var =
+      Var("a", ty.mat2x3<f32>(), ast::StorageClass::kNone, mat2x3<f32>());
+
+  auto* stmt = Decl(var);
+  WrapInFunction(stmt);
+
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.EmitStatement(stmt)) << gen.error();
+  EXPECT_EQ(gen.result(),
+            R"(mat2x3 a = mat2x3(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
+)");
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_workgroup_var_test.cc b/src/writer/glsl/generator_impl_workgroup_var_test.cc
new file mode 100644
index 0000000..40bc9c9
--- /dev/null
+++ b/src/writer/glsl/generator_impl_workgroup_var_test.cc
@@ -0,0 +1,61 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "gmock/gmock.h"
+#include "src/ast/override_decoration.h"
+#include "src/ast/stage_decoration.h"
+#include "src/writer/glsl/test_helper.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+namespace {
+using ::testing::HasSubstr;
+
+using GlslGeneratorImplTest_WorkgroupVar = TestHelper;
+
+TEST_F(GlslGeneratorImplTest_WorkgroupVar, Basic) {
+  Global("wg", ty.f32(), ast::StorageClass::kWorkgroup);
+
+  Func("main", {}, ty.void_(), {Assign("wg", 1.2f)},
+       {
+           Stage(ast::PipelineStage::kCompute),
+           WorkgroupSize(1),
+       });
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("groupshared float wg;\n"));
+}
+
+TEST_F(GlslGeneratorImplTest_WorkgroupVar, Aliased) {
+  auto* alias = Alias("F32", ty.f32());
+
+  Global("wg", ty.Of(alias), ast::StorageClass::kWorkgroup);
+
+  Func("main", {}, ty.void_(), {Assign("wg", 1.2f)},
+       {
+           Stage(ast::PipelineStage::kCompute),
+           WorkgroupSize(1),
+       });
+  GeneratorImpl& gen = Build();
+
+  ASSERT_TRUE(gen.Generate()) << gen.error();
+  EXPECT_THAT(gen.result(), HasSubstr("groupshared float wg;\n"));
+}
+
+}  // namespace
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
diff --git a/src/writer/glsl/test_helper.h b/src/writer/glsl/test_helper.h
new file mode 100644
index 0000000..298cbd8
--- /dev/null
+++ b/src/writer/glsl/test_helper.h
@@ -0,0 +1,114 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_WRITER_GLSL_TEST_HELPER_H_
+#define SRC_WRITER_GLSL_TEST_HELPER_H_
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "gtest/gtest.h"
+#include "src/transform/glsl.h"
+#include "src/transform/manager.h"
+#include "src/transform/renamer.h"
+#include "src/writer/glsl/generator_impl.h"
+
+namespace tint {
+namespace writer {
+namespace glsl {
+
+/// Helper class for testing
+template <typename BODY>
+class TestHelperBase : public BODY, public ProgramBuilder {
+ public:
+  TestHelperBase() = default;
+  ~TestHelperBase() override = default;
+
+  /// Builds the program and returns a GeneratorImpl from the program.
+  /// @note The generator is only built once. Multiple calls to Build() will
+  /// return the same GeneratorImpl without rebuilding.
+  /// @return the built generator
+  GeneratorImpl& Build() {
+    if (gen_) {
+      return *gen_;
+    }
+    // Fake that the GLSL sanitizer has been applied, so that we can unit test
+    // the writer without it erroring.
+    SetTransformApplied<transform::Glsl>();
+    [&]() {
+      ASSERT_TRUE(IsValid()) << "Builder program is not valid\n"
+                             << diag::Formatter().format(Diagnostics());
+    }();
+    program = std::make_unique<Program>(std::move(*this));
+    [&]() {
+      ASSERT_TRUE(program->IsValid())
+          << diag::Formatter().format(program->Diagnostics());
+    }();
+    gen_ = std::make_unique<GeneratorImpl>(program.get());
+    return *gen_;
+  }
+
+  /// Builds the program, runs the program through the transform::Glsl sanitizer
+  /// and returns a GeneratorImpl from the sanitized program.
+  /// @note The generator is only built once. Multiple calls to Build() will
+  /// return the same GeneratorImpl without rebuilding.
+  /// @return the built generator
+  GeneratorImpl& SanitizeAndBuild() {
+    if (gen_) {
+      return *gen_;
+    }
+    diag::Formatter formatter;
+    [&]() {
+      ASSERT_TRUE(IsValid()) << "Builder program is not valid\n"
+                             << formatter.format(Diagnostics());
+    }();
+    program = std::make_unique<Program>(std::move(*this));
+    [&]() {
+      ASSERT_TRUE(program->IsValid())
+          << formatter.format(program->Diagnostics());
+    }();
+
+    transform::Manager transform_manager;
+    transform::DataMap transform_data;
+    transform_data.Add<transform::Renamer::Config>(
+        transform::Renamer::Target::kGlslKeywords);
+    transform_manager.Add<tint::transform::Renamer>();
+    transform_manager.Add<tint::transform::Glsl>();
+    auto result = transform_manager.Run(program.get(), transform_data);
+    [&]() {
+      ASSERT_TRUE(result.program.IsValid())
+          << formatter.format(result.program.Diagnostics());
+    }();
+    *program = std::move(result.program);
+    gen_ = std::make_unique<GeneratorImpl>(program.get());
+    return *gen_;
+  }
+
+  /// The program built with a call to Build()
+  std::unique_ptr<Program> program;
+
+ private:
+  std::unique_ptr<GeneratorImpl> gen_;
+};
+using TestHelper = TestHelperBase<testing::Test>;
+
+template <typename T>
+using TestParamHelper = TestHelperBase<testing::TestWithParam<T>>;
+
+}  // namespace glsl
+}  // namespace writer
+}  // namespace tint
+
+#endif  // SRC_WRITER_GLSL_TEST_HELPER_H_
diff --git a/test/BUILD.gn b/test/BUILD.gn
index 9ee7db0..d0a6527 100644
--- a/test/BUILD.gn
+++ b/test/BUILD.gn
@@ -624,6 +624,47 @@
   ]
 }
 
+tint_unittests_source_set("tint_unittests_glsl_writer_src") {
+  sources = [
+    "../src/transform/glsl_test.cc",
+    "../src/writer/glsl/generator_impl_array_accessor_test.cc",
+    "../src/writer/glsl/generator_impl_assign_test.cc",
+    "../src/writer/glsl/generator_impl_binary_test.cc",
+    "../src/writer/glsl/generator_impl_bitcast_test.cc",
+    "../src/writer/glsl/generator_impl_block_test.cc",
+    "../src/writer/glsl/generator_impl_break_test.cc",
+    "../src/writer/glsl/generator_impl_call_test.cc",
+    "../src/writer/glsl/generator_impl_case_test.cc",
+    "../src/writer/glsl/generator_impl_cast_test.cc",
+    "../src/writer/glsl/generator_impl_constructor_test.cc",
+    "../src/writer/glsl/generator_impl_continue_test.cc",
+    "../src/writer/glsl/generator_impl_discard_test.cc",
+    "../src/writer/glsl/generator_impl_function_test.cc",
+    "../src/writer/glsl/generator_impl_identifier_test.cc",
+    "../src/writer/glsl/generator_impl_if_test.cc",
+    "../src/writer/glsl/generator_impl_import_test.cc",
+    "../src/writer/glsl/generator_impl_intrinsic_test.cc",
+    "../src/writer/glsl/generator_impl_intrinsic_texture_test.cc",
+    "../src/writer/glsl/generator_impl_loop_test.cc",
+    "../src/writer/glsl/generator_impl_member_accessor_test.cc",
+    "../src/writer/glsl/generator_impl_module_constant_test.cc",
+    "../src/writer/glsl/generator_impl_return_test.cc",
+    "../src/writer/glsl/generator_impl_sanitizer_test.cc",
+    "../src/writer/glsl/generator_impl_switch_test.cc",
+    "../src/writer/glsl/generator_impl_test.cc",
+    "../src/writer/glsl/generator_impl_type_test.cc",
+    "../src/writer/glsl/generator_impl_unary_op_test.cc",
+    "../src/writer/glsl/generator_impl_variable_decl_statement_test.cc",
+    "../src/writer/glsl/generator_impl_workgroup_var_test.cc",
+    "../src/writer/glsl/test_helper.h",
+  ]
+
+  deps = [
+    ":tint_unittests_core_src",
+    "${tint_root_dir}/src:libtint_glsl_writer_src",
+  ]
+}
+
 source_set("tint_unittests_src") {
   testonly = true
 
@@ -653,6 +694,10 @@
     deps += [ ":tint_unittests_hlsl_writer_src" ]
   }
 
+  if (tint_build_glsl_writer) {
+    deps += [ ":tint_unittests_glsl_writer_src" ]
+  }
+
   configs += [ ":tint_unittests_config" ]
 
   if (build_with_chromium) {
diff --git a/tint_overrides_with_defaults.gni b/tint_overrides_with_defaults.gni
index ceb80c0..e952005 100644
--- a/tint_overrides_with_defaults.gni
+++ b/tint_overrides_with_defaults.gni
@@ -66,4 +66,9 @@
   if (!defined(tint_build_hlsl_writer)) {
     tint_build_hlsl_writer = true
   }
+
+  # Build the GLSL output writer
+  if (!defined(tint_build_glsl_writer)) {
+    tint_build_glsl_writer = true
+  }
 }