diff --git a/docs/origin-trial-changes.md b/docs/origin-trial-changes.md
index 1ad9f85..8ba5154 100644
--- a/docs/origin-trial-changes.md
+++ b/docs/origin-trial-changes.md
@@ -6,6 +6,7 @@
 
 * Taking the address of a vector component is no longer allowed.
 * Module-scope declarations can no longer alias a builtin name. [tint:1318](https://crbug.com/tint/1318)
+* It is now an error to call a function either directly or transitively, from a loop continuing block, that uses `discard`. [tint:1302](https://crbug.com/tint/1302)
 
 ### Deprecated Features
 
@@ -16,6 +17,8 @@
 * Shadowing is now fully supported. [tint:819](https://crbug.com/tint/819)
 * The `dot()` builtin now supports integer vector types.
 * Identifiers can now start with a single leading underscore.  [tint:1292](https://crbug.com/tint/1292)
+* Control flow analysis has been improved, and functions no longer need to `return` if the statement is unreachable. [tint:1302](https://crbug.com/tint/1302)
+* Unreachable statements now produce a warning instead of an error, to allow WGSL code to be updated to the new analysis behavior. These warnings may become errors in the future [gpuweb#2378](https://github.com/gpuweb/gpuweb/issues/2378)
 
 ### Fixes
 
diff --git a/src/BUILD.gn b/src/BUILD.gn
index 9dab4d3..7818eec 100644
--- a/src/BUILD.gn
+++ b/src/BUILD.gn
@@ -465,6 +465,8 @@
     "transform/promote_initializers_to_const_var.h",
     "transform/remove_phonies.cc",
     "transform/remove_phonies.h",
+    "transform/remove_unreachable_statements.cc",
+    "transform/remove_unreachable_statements.h",
     "transform/renamer.cc",
     "transform/renamer.h",
     "transform/robustness.cc",
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 7a3bb13..9db881d 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -330,6 +330,8 @@
   transform/promote_initializers_to_const_var.h
   transform/remove_phonies.cc
   transform/remove_phonies.h
+  transform/remove_unreachable_statements.cc
+  transform/remove_unreachable_statements.h
   transform/renamer.cc
   transform/renamer.h
   transform/robustness.cc
@@ -969,6 +971,7 @@
       transform/pad_array_elements_test.cc
       transform/promote_initializers_to_const_var_test.cc
       transform/remove_phonies_test.cc
+      transform/remove_unreachable_statements_test.cc
       transform/renamer_test.cc
       transform/robustness_test.cc
       transform/simplify_pointers_test.cc
diff --git a/src/ast/module_clone_test.cc b/src/ast/module_clone_test.cc
index bbd30f9..b2415dc 100644
--- a/src/ast/module_clone_test.cc
+++ b/src/ast/module_clone_test.cc
@@ -76,7 +76,7 @@
   loop {
     l0 = (p1 + 2);
     if (((l0 % 4) == 0)) {
-      continue;
+      break;
     }
 
     continuing {
diff --git a/src/program_builder.h b/src/program_builder.h
index 4335126..e440474 100644
--- a/src/program_builder.h
+++ b/src/program_builder.h
@@ -2105,6 +2105,18 @@
   }
 
   /// Creates a ast::LoopStatement with input body and optional continuing
+  /// @param source the source information
+  /// @param body the loop body
+  /// @param continuing the optional continuing block
+  /// @returns the loop statement pointer
+  const ast::LoopStatement* Loop(
+      const Source& source,
+      const ast::BlockStatement* body,
+      const ast::BlockStatement* continuing = nullptr) {
+    return create<ast::LoopStatement>(source, body, continuing);
+  }
+
+  /// Creates a ast::LoopStatement with input body and optional continuing
   /// @param body the loop body
   /// @param continuing the optional continuing block
   /// @returns the loop statement pointer
diff --git a/src/reader/spirv/parser.cc b/src/reader/spirv/parser.cc
index 6500966..eabdc4b 100644
--- a/src/reader/spirv/parser.cc
+++ b/src/reader/spirv/parser.cc
@@ -19,6 +19,7 @@
 #include "src/reader/spirv/parser_impl.h"
 #include "src/transform/decompose_strided_matrix.h"
 #include "src/transform/manager.h"
+#include "src/transform/remove_unreachable_statements.h"
 #include "src/transform/simplify_pointers.h"
 #include "src/transform/unshadow.h"
 
@@ -56,6 +57,7 @@
     manager.Add<transform::Unshadow>();
     manager.Add<transform::SimplifyPointers>();
     manager.Add<transform::DecomposeStridedMatrix>();
+    manager.Add<transform::RemoveUnreachableStatements>();
     return manager.Run(&program).program;
   }
 
diff --git a/src/resolver/control_block_validation_test.cc b/src/resolver/control_block_validation_test.cc
index 41389dd..65f3f71 100644
--- a/src/resolver/control_block_validation_test.cc
+++ b/src/resolver/control_block_validation_test.cc
@@ -30,7 +30,7 @@
   // switch (a) {
   //   default: {}
   // }
-  auto* var = Var("a", ty.f32(), ast::StorageClass::kNone, Expr(3.14f));
+  auto* var = Var("a", ty.f32(), Expr(3.14f));
 
   auto* block = Block(Decl(var), Switch(Expr(Source{{12, 34}}, "a"),  //
                                         DefaultCase()));
@@ -48,7 +48,7 @@
   // switch (a) {
   //   case 1: {}
   // }
-  auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
+  auto* var = Var("a", ty.i32(), Expr(2));
 
   auto* block = Block(Decl(var),                     //
                       Switch(Source{{12, 34}}, "a",  //
@@ -68,7 +68,7 @@
   //   case 1: {}
   //   default: {}
   // }
-  auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
+  auto* var = Var("a", ty.i32(), Expr(2));
 
   auto* block = Block(Decl(var),             //
                       Switch("a",            //
@@ -90,12 +90,16 @@
   //   continue;
   //   z = 1;
   // }
-  WrapInFunction(Loop(Block(Decl(Var("z", ty.i32(), ast::StorageClass::kNone)),
-                            create<ast::ContinueStatement>(),
-                            Assign(Source{{12, 34}}, "z", 1))));
+  auto* decl_z = Decl(Var("z", ty.i32()));
+  auto* cont = Continue();
+  auto* assign_z = Assign(Source{{12, 34}}, "z", 1);
+  WrapInFunction(Loop(Block(decl_z, cont, assign_z)));
 
-  EXPECT_FALSE(r()->Resolve()) << r()->error();
-  EXPECT_EQ(r()->error(), "12:34 error: code is unreachable");
+  ASSERT_TRUE(r()->Resolve()) << r()->error();
+  EXPECT_EQ(r()->error(), "12:34 warning: code is unreachable");
+  EXPECT_TRUE(Sem().Get(decl_z)->IsReachable());
+  EXPECT_TRUE(Sem().Get(cont)->IsReachable());
+  EXPECT_FALSE(Sem().Get(assign_z)->IsReachable());
 }
 
 TEST_F(ResolverControlBlockValidationTest,
@@ -105,13 +109,16 @@
   //   {{{continue;}}}
   //   z = 1;
   // }
-  WrapInFunction(
-      Loop(Block(Decl(Var("z", ty.i32(), ast::StorageClass::kNone)),
-                 Block(Block(Block(create<ast::ContinueStatement>()))),
-                 Assign(Source{{12, 34}}, "z", 1))));
+  auto* decl_z = Decl(Var("z", ty.i32()));
+  auto* cont = Continue();
+  auto* assign_z = Assign(Source{{12, 34}}, "z", 1);
+  WrapInFunction(Loop(Block(decl_z, Block(Block(Block(cont))), assign_z)));
 
-  EXPECT_FALSE(r()->Resolve()) << r()->error();
-  EXPECT_EQ(r()->error(), "12:34 error: code is unreachable");
+  ASSERT_TRUE(r()->Resolve()) << r()->error();
+  EXPECT_EQ(r()->error(), "12:34 warning: code is unreachable");
+  EXPECT_TRUE(Sem().Get(decl_z)->IsReachable());
+  EXPECT_TRUE(Sem().Get(cont)->IsReachable());
+  EXPECT_FALSE(Sem().Get(assign_z)->IsReachable());
 }
 
 TEST_F(ResolverControlBlockValidationTest, UnreachableCode_ForLoop_continue) {
@@ -120,14 +127,17 @@
   //   continue;
   //   z = 1;
   // }
-  WrapInFunction(
-      For(nullptr, nullptr, nullptr,
-          Block(create<ast::ContinueStatement>(),
-                Decl(Source{{12, 34}},
-                     Var("z", ty.i32(), ast::StorageClass::kNone)))));
+  auto* decl_z = Decl(Var("z", ty.i32()));
+  auto* cont = Continue();
+  auto* assign_z = Assign(Source{{12, 34}}, "z", 1);
+  WrapInFunction(For(nullptr, nullptr, nullptr,  //
+                     Block(decl_z, cont, assign_z)));
 
-  EXPECT_FALSE(r()->Resolve()) << r()->error();
-  EXPECT_EQ(r()->error(), "12:34 error: code is unreachable");
+  ASSERT_TRUE(r()->Resolve()) << r()->error();
+  EXPECT_EQ(r()->error(), "12:34 warning: code is unreachable");
+  EXPECT_TRUE(Sem().Get(decl_z)->IsReachable());
+  EXPECT_TRUE(Sem().Get(cont)->IsReachable());
+  EXPECT_FALSE(Sem().Get(assign_z)->IsReachable());
 }
 
 TEST_F(ResolverControlBlockValidationTest,
@@ -137,31 +147,40 @@
   //   {{{continue;}}}
   //   z = 1;
   // }
-  WrapInFunction(
-      For(nullptr, nullptr, nullptr,
-          Block(Decl(Var("z", ty.i32(), ast::StorageClass::kNone)),
-                Block(Block(Block(create<ast::ContinueStatement>()))),
-                Assign(Source{{12, 34}}, "z", 1))));
+  auto* decl_z = Decl(Var("z", ty.i32()));
+  auto* cont = Continue();
+  auto* assign_z = Assign(Source{{12, 34}}, "z", 1);
+  WrapInFunction(For(nullptr, nullptr, nullptr,
+                     Block(decl_z, Block(Block(Block(cont))), assign_z)));
 
-  EXPECT_FALSE(r()->Resolve()) << r()->error();
-  EXPECT_EQ(r()->error(), "12:34 error: code is unreachable");
+  ASSERT_TRUE(r()->Resolve()) << r()->error();
+  EXPECT_EQ(r()->error(), "12:34 warning: code is unreachable");
+  EXPECT_TRUE(Sem().Get(decl_z)->IsReachable());
+  EXPECT_TRUE(Sem().Get(cont)->IsReachable());
+  EXPECT_FALSE(Sem().Get(assign_z)->IsReachable());
 }
 
 TEST_F(ResolverControlBlockValidationTest, UnreachableCode_break) {
   // switch (1) {
-  //   case 1: { break; var a : u32 = 2;}
+  //   case 1: {
+  //     var z: i32;
+  //     break;
+  //     z = 1;
   //   default: {}
   // }
-  auto* decl = Decl(Source{{12, 34}},
-                    Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2)));
-
-  WrapInFunction(                                             //
-      Loop(Block(Switch(1,                                    //
-                        Case(Expr(1), Block(Break(), decl)),  //
+  auto* decl_z = Decl(Var("z", ty.i32()));
+  auto* brk = Break();
+  auto* assign_z = Assign(Source{{12, 34}}, "z", 1);
+  WrapInFunction(                                                     //
+      Loop(Block(Switch(1,                                            //
+                        Case(Expr(1), Block(decl_z, brk, assign_z)),  //
                         DefaultCase()))));
 
-  EXPECT_FALSE(r()->Resolve());
-  EXPECT_EQ(r()->error(), "12:34 error: code is unreachable");
+  ASSERT_TRUE(r()->Resolve()) << r()->error();
+  EXPECT_EQ(r()->error(), "12:34 warning: code is unreachable");
+  EXPECT_TRUE(Sem().Get(decl_z)->IsReachable());
+  EXPECT_TRUE(Sem().Get(brk)->IsReachable());
+  EXPECT_FALSE(Sem().Get(assign_z)->IsReachable());
 }
 
 TEST_F(ResolverControlBlockValidationTest, UnreachableCode_break_InBlocks) {
@@ -171,16 +190,19 @@
   //     default: {}
   //   }
   // }
-  auto* decl = Decl(Source{{12, 34}},
-                    Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2)));
+  auto* decl_z = Decl(Var("z", ty.i32()));
+  auto* brk = Break();
+  auto* assign_z = Assign(Source{{12, 34}}, "z", 1);
+  WrapInFunction(Loop(Block(
+      Switch(1,  //
+             Case(Expr(1), Block(decl_z, Block(Block(Block(brk))), assign_z)),
+             DefaultCase()))));
 
-  WrapInFunction(Loop(
-      Block(Switch(1,  //
-                   Case(Expr(1), Block(Block(Block(Block(Break()))), decl)),
-                   DefaultCase()))));
-
-  EXPECT_FALSE(r()->Resolve());
-  EXPECT_EQ(r()->error(), "12:34 error: code is unreachable");
+  ASSERT_TRUE(r()->Resolve()) << r()->error();
+  EXPECT_EQ(r()->error(), "12:34 warning: code is unreachable");
+  EXPECT_TRUE(Sem().Get(decl_z)->IsReachable());
+  EXPECT_TRUE(Sem().Get(brk)->IsReachable());
+  EXPECT_FALSE(Sem().Get(assign_z)->IsReachable());
 }
 
 TEST_F(ResolverControlBlockValidationTest,
@@ -190,7 +212,7 @@
   //   case 1: {}
   //   default: {}
   // }
-  auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
+  auto* var = Var("a", ty.i32(), Expr(2));
 
   auto* block = Block(Decl(var), Switch("a",                                 //
                                         Case(Source{{12, 34}}, {Expr(1u)}),  //
@@ -210,7 +232,7 @@
   //   case -1: {}
   //   default: {}
   // }
-  auto* var = Var("a", ty.u32(), ast::StorageClass::kNone, Expr(2u));
+  auto* var = Var("a", ty.u32(), Expr(2u));
 
   auto* block = Block(Decl(var),                                  //
                       Switch("a",                                 //
@@ -232,7 +254,7 @@
   //   case 2u, 3u, 2u: {}
   //   default: {}
   // }
-  auto* var = Var("a", ty.u32(), ast::StorageClass::kNone, Expr(3u));
+  auto* var = Var("a", ty.u32(), Expr(3u));
 
   auto* block = Block(Decl(var),   //
                       Switch("a",  //
@@ -259,7 +281,7 @@
   //   case 0,1,2,-10: {}
   //   default: {}
   // }
-  auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
+  auto* var = Var("a", ty.i32(), Expr(2));
 
   auto* block = Block(Decl(var),   //
                       Switch("a",  //
@@ -285,7 +307,7 @@
   // switch (a) {
   //   default: { fallthrough; }
   // }
-  auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
+  auto* var = Var("a", ty.i32(), Expr(2));
   auto* fallthrough = create<ast::FallthroughStatement>(Source{{12, 34}});
   auto* block = Block(Decl(var),   //
                       Switch("a",  //
@@ -304,7 +326,7 @@
   //   default: {}
   //   case 5: {}
   // }
-  auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
+  auto* var = Var("a", ty.i32(), Expr(2));
 
   auto* block = Block(Decl(var),                             //
                       Switch("a",                            //
@@ -323,7 +345,7 @@
   // }
 
   auto* my_int = Alias("MyInt", ty.u32());
-  auto* var = Var("a", ty.Of(my_int), ast::StorageClass::kNone, Expr(2u));
+  auto* var = Var("a", ty.Of(my_int), Expr(2u));
   auto* block = Block(Decl(var),  //
                       Switch("a", DefaultCase(Source{{12, 34}})));
 
diff --git a/src/resolver/function_validation_test.cc b/src/resolver/function_validation_test.cc
index 302ad88..cd6bd6a 100644
--- a/src/resolver/function_validation_test.cc
+++ b/src/resolver/function_validation_test.cc
@@ -71,7 +71,7 @@
 TEST_F(ResolverFunctionValidationTest,
        VoidFunctionEndWithoutReturnStatement_Pass) {
   // fn func { var a:i32 = 2; }
-  auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
+  auto* var = Var("a", ty.i32(), Expr(2));
 
   Func(Source{{12, 34}}, "func", ast::VariableList{}, ty.void_(),
        ast::StatementList{
@@ -87,7 +87,7 @@
   //   return func;
   // }
 
-  auto* var = Var("func", ty.i32(), ast::StorageClass::kNone, Expr(0));
+  auto* var = Var("func", ty.i32(), Expr(0));
   Func("func", ast::VariableList{}, ty.i32(),
        ast::StatementList{
            Decl(var),
@@ -103,7 +103,7 @@
   // fn a() -> void { var b:i32 = 0; }
   // fn b() -> i32 { return 2; }
 
-  auto* var = Var("b", ty.i32(), ast::StorageClass::kNone, Expr(0));
+  auto* var = Var("b", ty.i32(), Expr(0));
   Func("a", ast::VariableList{}, ty.void_(),
        ast::StatementList{
            Decl(var),
@@ -126,14 +126,18 @@
   //  a = 2;
   //}
 
-  Func("func", ast::VariableList{}, ty.void_(),
-       {
-           Decl(Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2))),
-           Return(),
-           Assign(Source{{12, 34}}, "a", 2),
-       });
-  EXPECT_FALSE(r()->Resolve());
-  EXPECT_EQ(r()->error(), "12:34 error: code is unreachable");
+  auto* decl_a = Decl(Var("a", ty.i32()));
+  auto* ret = Return();
+  auto* assign_a = Assign(Source{{12, 34}}, "a", 2);
+
+  Func("func", ast::VariableList{}, ty.void_(), {decl_a, ret, assign_a});
+
+  ASSERT_TRUE(r()->Resolve());
+
+  EXPECT_EQ(r()->error(), "12:34 warning: code is unreachable");
+  EXPECT_TRUE(Sem().Get(decl_a)->IsReachable());
+  EXPECT_TRUE(Sem().Get(ret)->IsReachable());
+  EXPECT_FALSE(Sem().Get(assign_a)->IsReachable());
 }
 
 TEST_F(ResolverFunctionValidationTest, UnreachableCode_return_InBlocks) {
@@ -143,14 +147,18 @@
   //  a = 2;
   //}
 
+  auto* decl_a = Decl(Var("a", ty.i32()));
+  auto* ret = Return();
+  auto* assign_a = Assign(Source{{12, 34}}, "a", 2);
+
   Func("func", ast::VariableList{}, ty.void_(),
-       {
-           Decl(Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2))),
-           Block(Block(Block(Return()))),
-           Assign(Source{{12, 34}}, "a", 2),
-       });
-  EXPECT_FALSE(r()->Resolve());
-  EXPECT_EQ(r()->error(), "12:34 error: code is unreachable");
+       {decl_a, Block(Block(Block(ret))), assign_a});
+
+  ASSERT_TRUE(r()->Resolve());
+  EXPECT_EQ(r()->error(), "12:34 warning: code is unreachable");
+  EXPECT_TRUE(Sem().Get(decl_a)->IsReachable());
+  EXPECT_TRUE(Sem().Get(ret)->IsReachable());
+  EXPECT_FALSE(Sem().Get(assign_a)->IsReachable());
 }
 
 TEST_F(ResolverFunctionValidationTest, UnreachableCode_discard) {
@@ -160,14 +168,17 @@
   //  a = 2;
   //}
 
-  Func("func", ast::VariableList{}, ty.void_(),
-       {
-           Decl(Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2))),
-           create<ast::DiscardStatement>(),
-           Assign(Source{{12, 34}}, "a", 2),
-       });
-  EXPECT_FALSE(r()->Resolve());
-  EXPECT_EQ(r()->error(), "12:34 error: code is unreachable");
+  auto* decl_a = Decl(Var("a", ty.i32()));
+  auto* discard = Discard();
+  auto* assign_a = Assign(Source{{12, 34}}, "a", 2);
+
+  Func("func", ast::VariableList{}, ty.void_(), {decl_a, discard, assign_a});
+
+  ASSERT_TRUE(r()->Resolve());
+  EXPECT_EQ(r()->error(), "12:34 warning: code is unreachable");
+  EXPECT_TRUE(Sem().Get(decl_a)->IsReachable());
+  EXPECT_TRUE(Sem().Get(discard)->IsReachable());
+  EXPECT_FALSE(Sem().Get(assign_a)->IsReachable());
 }
 
 TEST_F(ResolverFunctionValidationTest, UnreachableCode_discard_InBlocks) {
@@ -177,20 +188,24 @@
   //  a = 2;
   //}
 
+  auto* decl_a = Decl(Var("a", ty.i32()));
+  auto* discard = Discard();
+  auto* assign_a = Assign(Source{{12, 34}}, "a", 2);
+
   Func("func", ast::VariableList{}, ty.void_(),
-       {
-           Decl(Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2))),
-           Block(Block(Block(create<ast::DiscardStatement>()))),
-           Assign(Source{{12, 34}}, "a", 2),
-       });
-  EXPECT_FALSE(r()->Resolve());
-  EXPECT_EQ(r()->error(), "12:34 error: code is unreachable");
+       {decl_a, Block(Block(Block(discard))), assign_a});
+
+  ASSERT_TRUE(r()->Resolve());
+  EXPECT_EQ(r()->error(), "12:34 warning: code is unreachable");
+  EXPECT_TRUE(Sem().Get(decl_a)->IsReachable());
+  EXPECT_TRUE(Sem().Get(discard)->IsReachable());
+  EXPECT_FALSE(Sem().Get(assign_a)->IsReachable());
 }
 
 TEST_F(ResolverFunctionValidationTest, FunctionEndWithoutReturnStatement_Fail) {
   // fn func() -> int { var a:i32 = 2; }
 
-  auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2));
+  auto* var = Var("a", ty.i32(), Expr(2));
 
   Func(Source{{12, 34}}, "func", ast::VariableList{}, ty.i32(),
        ast::StatementList{
@@ -199,8 +214,7 @@
        ast::DecorationList{});
 
   EXPECT_FALSE(r()->Resolve());
-  EXPECT_EQ(r()->error(),
-            "12:34 error: non-void function must end with a return statement");
+  EXPECT_EQ(r()->error(), "12:34 error: missing return at end of function");
 }
 
 TEST_F(ResolverFunctionValidationTest,
@@ -221,8 +235,7 @@
        ast::StatementList{}, ast::DecorationList{});
 
   EXPECT_FALSE(r()->Resolve());
-  EXPECT_EQ(r()->error(),
-            "12:34 error: non-void function must end with a return statement");
+  EXPECT_EQ(r()->error(), "12:34 error: missing return at end of function");
 }
 
 TEST_F(ResolverFunctionValidationTest,
@@ -392,7 +405,7 @@
   // }
 
   auto* bar = Param("bar", ty.f32());
-  auto* baz = Var("baz", ty.f32(), ast::StorageClass::kNone, Expr("bar"));
+  auto* baz = Var("baz", ty.f32(), Expr("bar"));
 
   Func("foo", ast::VariableList{bar}, ty.void_(), ast::StatementList{Decl(baz)},
        ast::DecorationList{});
diff --git a/src/resolver/resolver.cc b/src/resolver/resolver.cc
index 6ac7835..c53de55 100644
--- a/src/resolver/resolver.cc
+++ b/src/resolver/resolver.cc
@@ -809,6 +809,7 @@
 bool Resolver::Statements(const ast::StatementList& stmts) {
   sem::Behaviors behaviors{sem::Behavior::kNext};
 
+  bool reachable = true;
   for (auto* stmt : stmts) {
     Mark(stmt);
     auto* sem = Statement(stmt);
@@ -816,9 +817,11 @@
       return false;
     }
     // s1 s2:(B1∖{Next}) ∪ B2
-    // ValidateStatements will ensure that statements can only follow a Next.
-    behaviors.Remove(sem::Behavior::kNext);
-    behaviors.Add(sem->Behaviors());
+    sem->SetIsReachable(reachable);
+    if (reachable) {
+      behaviors = (behaviors - sem::Behavior::kNext) + sem->Behaviors();
+    }
+    reachable = reachable && sem->Behaviors().Contains(sem::Behavior::kNext);
   }
 
   current_statement_->Behaviors() = behaviors;
@@ -2660,6 +2663,26 @@
                                 [&](auto* stmt) { return stmt->expr == expr; });
 }
 
+const ast::Statement* Resolver::ClosestContinuing(bool stop_at_loop) const {
+  for (const auto* s = current_statement_; s != nullptr; s = s->Parent()) {
+    if (stop_at_loop && s->Is<sem::LoopStatement>()) {
+      break;
+    }
+    if (s->Is<sem::LoopContinuingBlockStatement>()) {
+      return s->Declaration();
+    }
+    if (auto* f = As<sem::ForLoopStatement>(s->Parent())) {
+      if (f->Declaration()->continuing == s->Declaration()) {
+        return s->Declaration();
+      }
+      if (stop_at_loop) {
+        break;
+      }
+    }
+  }
+  return nullptr;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Resolver::TypeConversionSig
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/src/resolver/resolver.h b/src/resolver/resolver.h
index 336e183..2de937e 100644
--- a/src/resolver/resolver.h
+++ b/src/resolver/resolver.h
@@ -464,6 +464,14 @@
   /// @returns true if `expr` is the current CallStatement's CallExpression
   bool IsCallStatement(const ast::Expression* expr) const;
 
+  /// Searches the current statement and up through parents of the current
+  /// statement looking for a loop or for-loop continuing statement.
+  /// @returns the closest continuing statement to the current statement that
+  /// (transitively) owns the current statement.
+  /// @param stop_at_loop if true then the function will return nullptr if a
+  /// loop or for-loop was found before the continuing.
+  const ast::Statement* ClosestContinuing(bool stop_at_loop) const;
+
   /// @returns the resolved symbol (function, type or variable) for the given
   /// ast::Identifier or ast::TypeName cast to the given semantic type.
   template <typename SEM = sem::Node>
diff --git a/src/resolver/resolver_behavior_test.cc b/src/resolver/resolver_behavior_test.cc
index 6ee656b..9099dd7 100644
--- a/src/resolver/resolver_behavior_test.cc
+++ b/src/resolver/resolver_behavior_test.cc
@@ -327,28 +327,6 @@
             sem::Behaviors(sem::Behavior::kDiscard, sem::Behavior::kNext));
 }
 
-TEST_F(ResolverBehaviorTest, StmtForLoopBreak_ContCallFuncMayDiscard) {
-  auto* stmt =
-      For(nullptr, nullptr, CallStmt(Call("DiscardOrNext")), Block(Break()));
-  WrapInFunction(stmt);
-
-  ASSERT_TRUE(r()->Resolve()) << r()->error();
-
-  auto* sem = Sem().Get(stmt);
-  EXPECT_EQ(sem->Behaviors(),
-            sem::Behaviors(sem::Behavior::kDiscard, sem::Behavior::kNext));
-}
-
-TEST_F(ResolverBehaviorTest, StmtForLoopEmpty_ContCallFuncMayDiscard) {
-  auto* stmt = For(nullptr, nullptr, CallStmt(Call("DiscardOrNext")), Block());
-  WrapInFunction(stmt);
-
-  ASSERT_TRUE(r()->Resolve()) << r()->error();
-
-  auto* sem = Sem().Get(stmt);
-  EXPECT_EQ(sem->Behaviors(), sem::Behavior::kDiscard);
-}
-
 TEST_F(ResolverBehaviorTest, StmtIfTrue_ThenEmptyBlock) {
   auto* stmt = If(true, Block());
   WrapInFunction(stmt);
diff --git a/src/resolver/resolver_validation.cc b/src/resolver/resolver_validation.cc
index ef365ce..f376335 100644
--- a/src/resolver/resolver_validation.cc
+++ b/src/resolver/resolver_validation.cc
@@ -1000,10 +1000,12 @@
     }
 
     if (decl->body) {
-      if (!decl->body->Last() ||
-          !decl->body->Last()->Is<ast::ReturnStatement>()) {
-        AddError("non-void function must end with a return statement",
-                 decl->source);
+      sem::Behaviors behaviors{sem::Behavior::kNext};
+      if (auto* last = decl->body->Last()) {
+        behaviors = Sem(last)->Behaviors();
+      }
+      if (behaviors.Contains(sem::Behavior::kNext)) {
+        AddError("missing return at end of function", decl->source);
         return false;
       }
     } else if (IsValidationEnabled(
@@ -1334,31 +1336,19 @@
 }
 
 bool Resolver::ValidateStatements(const ast::StatementList& stmts) {
-  bool unreachable = false;
   for (auto* stmt : stmts) {
-    if (unreachable) {
-      AddError("code is unreachable", stmt->source);
-      return false;
-    }
-
-    auto* nested_stmt = stmt;
-    while (auto* block = nested_stmt->As<ast::BlockStatement>()) {
-      if (block->Empty()) {
-        break;
-      }
-      nested_stmt = block->statements.back();
-    }
-    if (nested_stmt->IsAnyOf<ast::ReturnStatement, ast::BreakStatement,
-                             ast::ContinueStatement, ast::DiscardStatement>()) {
-      unreachable = true;
+    if (!Sem(stmt)->IsReachable()) {
+      /// TODO(https://github.com/gpuweb/gpuweb/issues/2378): This may need to
+      /// become an error.
+      AddWarning("code is unreachable", stmt->source);
+      break;
     }
   }
   return true;
 }
 
 bool Resolver::ValidateBreakStatement(const sem::Statement* stmt) {
-  if (!stmt->FindFirstParent<sem::LoopBlockStatement>() &&
-      !stmt->FindFirstParent<sem::CaseStatement>()) {
+  if (!stmt->FindFirstParent<sem::LoopBlockStatement, sem::CaseStatement>()) {
     AddError("break statement must be in a loop or switch case",
              stmt->Declaration()->source);
     return false;
@@ -1367,15 +1357,17 @@
 }
 
 bool Resolver::ValidateContinueStatement(const sem::Statement* stmt) {
-  if (auto* block =
-          stmt->FindFirstParent<sem::LoopBlockStatement,
-                                sem::LoopContinuingBlockStatement>()) {
-    if (block->Is<sem::LoopContinuingBlockStatement>()) {
-      AddError("continuing blocks must not contain a continue statement",
-               stmt->Declaration()->source);
-      return false;
+  if (auto* continuing = ClosestContinuing(/*stop_at_loop*/ true)) {
+    AddError("continuing blocks must not contain a continue statement",
+             stmt->Declaration()->source);
+    if (continuing != stmt->Declaration() &&
+        continuing != stmt->Parent()->Declaration()) {
+      AddNote("see continuing block here", continuing->source);
     }
-  } else {
+    return false;
+  }
+
+  if (!stmt->FindFirstParent<sem::LoopBlockStatement>()) {
     AddError("continue statement must be in a loop",
              stmt->Declaration()->source);
     return false;
@@ -1385,12 +1377,12 @@
 }
 
 bool Resolver::ValidateDiscardStatement(const sem::Statement* stmt) {
-  if (auto* continuing =
-          stmt->FindFirstParent<sem::LoopContinuingBlockStatement>()) {
+  if (auto* continuing = ClosestContinuing(/*stop_at_loop*/ false)) {
     AddError("continuing blocks must not contain a discard statement",
              stmt->Declaration()->source);
-    if (continuing != stmt->Parent()) {
-      AddNote("see continuing block here", continuing->Declaration()->source);
+    if (continuing != stmt->Declaration() &&
+        continuing != stmt->Parent()->Declaration()) {
+      AddNote("see continuing block here", continuing->source);
     }
     return false;
   }
@@ -1629,6 +1621,20 @@
       return false;
     }
   }
+
+  if (call->Behaviors().Contains(sem::Behavior::kDiscard)) {
+    if (auto* continuing = ClosestContinuing(/*stop_at_loop*/ false)) {
+      AddError(
+          "cannot call a function that may discard inside a continuing block",
+          call->Declaration()->source);
+      if (continuing != call->Stmt()->Declaration() &&
+          continuing != call->Stmt()->Parent()->Declaration()) {
+        AddNote("see continuing block here", continuing->source);
+      }
+      return false;
+    }
+  }
+
   return true;
 }
 
@@ -2200,12 +2206,12 @@
   }
 
   auto* sem = Sem(ret);
-  if (auto* continuing =
-          sem->FindFirstParent<sem::LoopContinuingBlockStatement>()) {
+  if (auto* continuing = ClosestContinuing(/*stop_at_loop*/ false)) {
     AddError("continuing blocks must not contain a return statement",
              ret->source);
-    if (continuing != sem->Parent()) {
-      AddNote("see continuing block here", continuing->Declaration()->source);
+    if (continuing != sem->Declaration() &&
+        continuing != sem->Parent()->Declaration()) {
+      AddNote("see continuing block here", continuing->source);
     }
     return false;
   }
diff --git a/src/resolver/validation_test.cc b/src/resolver/validation_test.cc
index 96557d9..7d8706d 100644
--- a/src/resolver/validation_test.cc
+++ b/src/resolver/validation_test.cc
@@ -455,8 +455,7 @@
        Stmt_Loop_ContinueInLoopBodyBeforeDeclAndAfterDecl_UsageInContinuing) {
   // loop  {
   //     continue; // Bypasses z decl
-  //     var z : i32;
-  //     continue; // Ok
+  //     var z : i32; // unreachable
   //
   //     continuing {
   //         z = 2;
@@ -465,24 +464,25 @@
 
   auto error_loc = Source{{12, 34}};
   auto* body =
-      Block(create<ast::ContinueStatement>(),
-            Decl(error_loc, Var("z", ty.i32(), ast::StorageClass::kNone)),
-            create<ast::ContinueStatement>());
+      Block(Continue(),
+            Decl(error_loc, Var("z", ty.i32(), ast::StorageClass::kNone)));
   auto* continuing = Block(Assign(Expr("z"), 2));
   auto* loop_stmt = Loop(body, continuing);
   WrapInFunction(loop_stmt);
 
-  EXPECT_FALSE(r()->Resolve()) << r()->error();
-  EXPECT_EQ(r()->error(), "12:34 error: code is unreachable");
+  EXPECT_FALSE(r()->Resolve());
+  EXPECT_EQ(r()->error(),
+            R"(12:34 warning: code is unreachable
+error: continue statement bypasses declaration of 'z'
+note: identifier 'z' declared here
+note: identifier 'z' referenced in continuing block here)");
 }
 
-TEST_F(
-    ResolverValidationTest,
-    Stmt_Loop_ContinueInLoopBodyBeforeDeclAndAfterDecl_UsageInContinuing_InBlocks) {  // NOLINT - line length
+TEST_F(ResolverValidationTest,
+       Stmt_Loop_ContinueInLoopBodyAfterDecl_UsageInContinuing_InBlocks) {
   // loop  {
   //     var z : i32;
-  //     {{{continue;}}} // Bypasses z decl
-  //     z = 1;
+  //     {{{continue;}}}
   //     continue; // Ok
   //
   //     continuing {
@@ -490,16 +490,13 @@
   //     }
   // }
 
-  auto* body =
-      Block(Decl(Var("z", ty.i32(), ast::StorageClass::kNone)),
-            Block(Block(Block(create<ast::ContinueStatement>()))),
-            Assign(Source{{12, 34}}, "z", 2), create<ast::ContinueStatement>());
+  auto* body = Block(Decl(Var("z", ty.i32(), ast::StorageClass::kNone)),
+                     Block(Block(Block(Continue()))));
   auto* continuing = Block(Assign(Expr("z"), 2));
   auto* loop_stmt = Loop(body, continuing);
   WrapInFunction(loop_stmt);
 
-  EXPECT_FALSE(r()->Resolve()) << r()->error();
-  EXPECT_EQ(r()->error(), "12:34 error: code is unreachable");
+  ASSERT_TRUE(r()->Resolve()) << r()->error();
 }
 
 TEST_F(ResolverValidationTest,
@@ -518,7 +515,7 @@
   auto decl_loc = Source{{56, 78}};
   auto ref_loc = Source{{90, 12}};
   auto* body =
-      Block(If(Expr(true), Block(create<ast::ContinueStatement>(cont_loc))),
+      Block(If(Expr(true), Block(Continue(cont_loc))),
             Decl(Var(decl_loc, "z", ty.i32(), ast::StorageClass::kNone)));
   auto* continuing = Block(Assign(Expr(ref_loc, "z"), 2));
   auto* loop_stmt = Loop(body, continuing);
@@ -550,7 +547,7 @@
   auto decl_loc = Source{{56, 78}};
   auto ref_loc = Source{{90, 12}};
   auto* body =
-      Block(If(Expr(true), Block(create<ast::ContinueStatement>(cont_loc))),
+      Block(If(Expr(true), Block(Continue(cont_loc))),
             Decl(Var(decl_loc, "z", ty.i32(), ast::StorageClass::kNone)));
 
   auto* continuing =
@@ -584,7 +581,7 @@
   auto decl_loc = Source{{56, 78}};
   auto ref_loc = Source{{90, 12}};
   auto* body =
-      Block(If(Expr(true), Block(create<ast::ContinueStatement>(cont_loc))),
+      Block(If(Expr(true), Block(Continue(cont_loc))),
             Decl(Var(decl_loc, "z", ty.i32(), ast::StorageClass::kNone)));
   auto* compare = create<ast::BinaryExpression>(ast::BinaryOp::kLessThan,
                                                 Expr(ref_loc, "z"), Expr(2));
@@ -617,7 +614,7 @@
   auto decl_loc = Source{{56, 78}};
   auto ref_loc = Source{{90, 12}};
   auto* body =
-      Block(If(Expr(true), Block(create<ast::ContinueStatement>(cont_loc))),
+      Block(If(Expr(true), Block(Continue(cont_loc))),
             Decl(Var(decl_loc, "z", ty.i32(), ast::StorageClass::kNone)));
 
   auto* continuing = Block(Loop(Block(Assign(Expr(ref_loc, "z"), 2))));
@@ -635,7 +632,8 @@
        Stmt_Loop_ContinueInNestedLoopBodyBeforeDecl_UsageInContinuing) {
   // loop  {
   //     loop {
-  //         continue; // OK: not part of the outer loop
+  //         if (true) { continue; } // OK: not part of the outer loop
+  //         break;
   //     }
   //     var z : i32;
   //
@@ -644,7 +642,9 @@
   //     }
   // }
 
-  auto* inner_loop = Loop(Block(create<ast::ContinueStatement>()));
+  auto* inner_loop = Loop(Block(    //
+      If(true, Block(Continue())),  //
+      Break()));
   auto* body =
       Block(inner_loop, Decl(Var("z", ty.i32(), ast::StorageClass::kNone)));
   auto* continuing = Block(Assign("z", 2));
@@ -658,7 +658,8 @@
        Stmt_Loop_ContinueInNestedLoopBodyBeforeDecl_UsageInContinuingSubscope) {
   // loop  {
   //     loop {
-  //         continue; // OK: not part of the outer loop
+  //         if (true) { continue; } // OK: not part of the outer loop
+  //         break;
   //     }
   //     var z : i32;
   //
@@ -669,7 +670,8 @@
   //     }
   // }
 
-  auto* inner_loop = Loop(Block(create<ast::ContinueStatement>()));
+  auto* inner_loop = Loop(Block(If(true, Block(Continue())),  //
+                                Break()));
   auto* body =
       Block(inner_loop, Decl(Var("z", ty.i32(), ast::StorageClass::kNone)));
   auto* continuing = Block(If(Expr(true), Block(Assign("z", 2))));
@@ -683,7 +685,8 @@
        Stmt_Loop_ContinueInNestedLoopBodyBeforeDecl_UsageInContinuingLoop) {
   // loop  {
   //     loop {
-  //         continue; // OK: not part of the outer loop
+  //         if (true) { continue; } // OK: not part of the outer loop
+  //         break;
   //     }
   //     var z : i32;
   //
@@ -694,7 +697,8 @@
   //     }
   // }
 
-  auto* inner_loop = Loop(Block(create<ast::ContinueStatement>()));
+  auto* inner_loop = Loop(Block(If(true, Block(Continue())),  //
+                                Break()));
   auto* body =
       Block(inner_loop, Decl(Var("z", ty.i32(), ast::StorageClass::kNone)));
   auto* continuing = Block(Loop(Block(Assign("z", 2))));
@@ -707,7 +711,7 @@
 TEST_F(ResolverTest, Stmt_Loop_ContinueInLoopBodyAfterDecl_UsageInContinuing) {
   // loop  {
   //     var z : i32;
-  //     continue;
+  //     if (true) { continue; }
   //
   //     continuing {
   //         z = 2;
@@ -716,7 +720,7 @@
 
   auto error_loc = Source{{12, 34}};
   auto* body = Block(Decl(Var("z", ty.i32(), ast::StorageClass::kNone)),
-                     create<ast::ContinueStatement>());
+                     If(true, Block(Continue())));
   auto* continuing = Block(Assign(Expr(error_loc, "z"), 2));
   auto* loop_stmt = Loop(body, continuing);
   WrapInFunction(loop_stmt);
@@ -775,7 +779,7 @@
   WrapInFunction(Loop(  // loop
       Block(),          //   loop block
       Block(            //   loop continuing block
-          create<ast::DiscardStatement>(Source{{12, 34}}))));
+          Discard(Source{{12, 34}}))));
 
   EXPECT_FALSE(r()->Resolve());
   EXPECT_EQ(
@@ -795,7 +799,7 @@
       Block(Source{{56, 78}},  //   outer loop continuing block
             Loop(              //     inner loop
                 Block(         //       inner loop block
-                    create<ast::DiscardStatement>(Source{{12, 34}}))))));
+                    Discard(Source{{12, 34}}))))));
 
   EXPECT_FALSE(r()->Resolve());
   EXPECT_EQ(
@@ -804,6 +808,32 @@
 56:78 note: see continuing block here)");
 }
 
+TEST_F(ResolverTest, Stmt_Loop_DiscardInContinuing_Indirect_ViaCall) {
+  // fn MayDiscard() { if (true) { discard; } }
+  // fn F() { MayDiscard(); }
+  // loop {
+  //   continuing {
+  //     loop { F(); }
+  //   }
+  // }
+
+  Func("MayDiscard", {}, ty.void_(), {If(true, Block(Discard()))});
+  Func("SomeFunc", {}, ty.void_(), {CallStmt(Call("MayDiscard"))});
+
+  WrapInFunction(Loop(         // outer loop
+      Block(),                 //   outer loop block
+      Block(Source{{56, 78}},  //   outer loop continuing block
+            Loop(              //     inner loop
+                Block(         //       inner loop block
+                    CallStmt(Call(Source{{12, 34}}, "SomeFunc")))))));
+
+  EXPECT_FALSE(r()->Resolve());
+  EXPECT_EQ(
+      r()->error(),
+      R"(12:34 error: cannot call a function that may discard inside a continuing block
+56:78 note: see continuing block here)");
+}
+
 TEST_F(ResolverTest, Stmt_Loop_ContinueInContinuing_Direct) {
   // loop  {
   //     continuing {
@@ -814,7 +844,7 @@
   WrapInFunction(Loop(         // loop
       Block(),                 //   loop block
       Block(Source{{56, 78}},  //   loop continuing block
-            create<ast::ContinueStatement>(Source{{12, 34}}))));
+            Continue(Source{{12, 34}}))));
 
   EXPECT_FALSE(r()->Resolve());
   EXPECT_EQ(
@@ -836,7 +866,118 @@
       Block(            //   outer loop continuing block
           Loop(         //     inner loop
               Block(    //       inner loop block
-                  create<ast::ContinueStatement>(Source{{12, 34}}))))));
+                  Continue(Source{{12, 34}}))))));
+
+  EXPECT_TRUE(r()->Resolve()) << r()->error();
+}
+
+TEST_F(ResolverTest, Stmt_ForLoop_ReturnInContinuing_Direct) {
+  // for(;; return) {
+  //   break;
+  // }
+
+  WrapInFunction(For(nullptr, nullptr, Return(Source{{12, 34}}),  //
+                     Block(Break())));
+
+  EXPECT_FALSE(r()->Resolve());
+  EXPECT_EQ(
+      r()->error(),
+      R"(12:34 error: continuing blocks must not contain a return statement)");
+}
+
+TEST_F(ResolverTest, Stmt_ForLoop_ReturnInContinuing_Indirect) {
+  // for(;; loop { return }) {
+  //   break;
+  // }
+
+  WrapInFunction(For(nullptr, nullptr,
+                     Loop(Source{{56, 78}},                  //
+                          Block(Return(Source{{12, 34}}))),  //
+                     Block(Break())));
+
+  EXPECT_FALSE(r()->Resolve());
+  EXPECT_EQ(
+      r()->error(),
+      R"(12:34 error: continuing blocks must not contain a return statement
+56:78 note: see continuing block here)");
+}
+
+TEST_F(ResolverTest, Stmt_ForLoop_DiscardInContinuing_Direct) {
+  // for(;; discard) {
+  //   break;
+  // }
+
+  WrapInFunction(For(nullptr, nullptr, Discard(Source{{12, 34}}),  //
+                     Block(Break())));
+
+  EXPECT_FALSE(r()->Resolve());
+  EXPECT_EQ(
+      r()->error(),
+      R"(12:34 error: continuing blocks must not contain a discard statement)");
+}
+
+TEST_F(ResolverTest, Stmt_ForLoop_DiscardInContinuing_Indirect) {
+  // for(;; loop { discard }) {
+  //   break;
+  // }
+
+  WrapInFunction(For(nullptr, nullptr,
+                     Loop(Source{{56, 78}},                   //
+                          Block(Discard(Source{{12, 34}}))),  //
+                     Block(Break())));
+
+  EXPECT_FALSE(r()->Resolve());
+  EXPECT_EQ(
+      r()->error(),
+      R"(12:34 error: continuing blocks must not contain a discard statement
+56:78 note: see continuing block here)");
+}
+
+TEST_F(ResolverTest, Stmt_ForLoop_DiscardInContinuing_Indirect_ViaCall) {
+  // fn MayDiscard() { if (true) { discard; } }
+  // fn F() { MayDiscard(); }
+  // for(;; loop { F() }) {
+  //   break;
+  // }
+
+  Func("MayDiscard", {}, ty.void_(), {If(true, Block(Discard()))});
+  Func("F", {}, ty.void_(), {CallStmt(Call("MayDiscard"))});
+
+  WrapInFunction(For(nullptr, nullptr,
+                     Loop(Source{{56, 78}},                               //
+                          Block(CallStmt(Call(Source{{12, 34}}, "F")))),  //
+                     Block(Break())));
+
+  EXPECT_FALSE(r()->Resolve());
+  EXPECT_EQ(
+      r()->error(),
+      R"(12:34 error: cannot call a function that may discard inside a continuing block
+56:78 note: see continuing block here)");
+}
+
+TEST_F(ResolverTest, Stmt_ForLoop_ContinueInContinuing_Direct) {
+  // for(;; continue) {
+  //   break;
+  // }
+
+  WrapInFunction(For(nullptr, nullptr, Continue(Source{{12, 34}}),  //
+                     Block(Break())));
+
+  EXPECT_FALSE(r()->Resolve());
+  EXPECT_EQ(
+      r()->error(),
+      "12:34 error: continuing blocks must not contain a continue statement");
+}
+
+TEST_F(ResolverTest, Stmt_ForLoop_ContinueInContinuing_Indirect) {
+  // for(;; loop { continue }) {
+  //   break;
+  // }
+
+  WrapInFunction(For(nullptr, nullptr,
+                     Loop(                                    //
+                         Block(Continue(Source{{12, 34}}))),  //
+                     Block(Break())));
 
   EXPECT_TRUE(r()->Resolve()) << r()->error();
 }
@@ -863,12 +1004,12 @@
 }
 
 TEST_F(ResolverValidationTest, Stmt_ContinueInLoop) {
-  WrapInFunction(Loop(Block(create<ast::ContinueStatement>(Source{{12, 34}}))));
+  WrapInFunction(Loop(Block(Continue(Source{{12, 34}}))));
   EXPECT_TRUE(r()->Resolve()) << r()->error();
 }
 
 TEST_F(ResolverValidationTest, Stmt_ContinueNotInLoop) {
-  WrapInFunction(create<ast::ContinueStatement>(Source{{12, 34}}));
+  WrapInFunction(Continue(Source{{12, 34}}));
   EXPECT_FALSE(r()->Resolve());
   EXPECT_EQ(r()->error(), "12:34 error: continue statement must be in a loop");
 }
diff --git a/src/sem/for_loop_statement.cc b/src/sem/for_loop_statement.cc
index db13707..72a1226 100644
--- a/src/sem/for_loop_statement.cc
+++ b/src/sem/for_loop_statement.cc
@@ -28,5 +28,9 @@
 
 ForLoopStatement::~ForLoopStatement() = default;
 
+const ast::ForLoopStatement* ForLoopStatement::Declaration() const {
+  return static_cast<const ast::ForLoopStatement*>(Base::Declaration());
+}
+
 }  // namespace sem
 }  // namespace tint
diff --git a/src/sem/for_loop_statement.h b/src/sem/for_loop_statement.h
index 2f287bb..fad879a 100644
--- a/src/sem/for_loop_statement.h
+++ b/src/sem/for_loop_statement.h
@@ -43,6 +43,9 @@
   /// Destructor
   ~ForLoopStatement() override;
 
+  /// @returns the AST node
+  const ast::ForLoopStatement* Declaration() const;
+
   /// @returns the for-loop condition expression
   const Expression* Condition() const { return condition_; }
 
diff --git a/src/sem/statement.h b/src/sem/statement.h
index 1468da9..153ede1 100644
--- a/src/sem/statement.h
+++ b/src/sem/statement.h
@@ -106,11 +106,20 @@
   /// @return the behaviors of this statement
   sem::Behaviors& Behaviors() { return behaviors_; }
 
+  /// @returns true if this statement is reachable by control flow according to
+  /// the behavior analysis
+  bool IsReachable() const { return is_reachable_; }
+
+  /// @param is_reachable whether this statement is reachable by control flow
+  /// according to the behavior analysis
+  void SetIsReachable(bool is_reachable) { is_reachable_ = is_reachable; }
+
  private:
   const ast::Statement* const declaration_;
   const CompoundStatement* const parent_;
   const sem::Function* const function_;
   sem::Behaviors behaviors_{sem::Behavior::kNext};
+  bool is_reachable_ = true;
 };
 
 /// CompoundStatement is the base class of statements that can hold other
diff --git a/src/transform/remove_phonies_test.cc b/src/transform/remove_phonies_test.cc
index cd7b4ec..138fdbf 100644
--- a/src/transform/remove_phonies_test.cc
+++ b/src/transform/remove_phonies_test.cc
@@ -194,8 +194,10 @@
 
 fn f() {
   for (_ = &s.arr; ;_ = &s.arr) {
+    break;
   }
   for (_ = x(); ;_ = y() + z()) {
+    break;
   }
 }
 )";
@@ -225,8 +227,10 @@
 
 fn f() {
   for(; ; ) {
+    break;
   }
   for(x(); ; phony_sink(y(), z())) {
+    break;
   }
 }
 )";
diff --git a/src/transform/remove_unreachable_statements.cc b/src/transform/remove_unreachable_statements.cc
new file mode 100644
index 0000000..30f8f42
--- /dev/null
+++ b/src/transform/remove_unreachable_statements.cc
@@ -0,0 +1,55 @@
+// 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/remove_unreachable_statements.h"
+
+#include <memory>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "src/ast/traverse_expressions.h"
+#include "src/program_builder.h"
+#include "src/sem/block_statement.h"
+#include "src/sem/function.h"
+#include "src/sem/statement.h"
+#include "src/sem/variable.h"
+#include "src/utils/map.h"
+#include "src/utils/scoped_assignment.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::transform::RemoveUnreachableStatements);
+
+namespace tint {
+namespace transform {
+
+RemoveUnreachableStatements::RemoveUnreachableStatements() = default;
+
+RemoveUnreachableStatements::~RemoveUnreachableStatements() = default;
+
+void RemoveUnreachableStatements::Run(CloneContext& ctx,
+                                      const DataMap&,
+                                      DataMap&) {
+  for (auto* node : ctx.src->ASTNodes().Objects()) {
+    if (auto* stmt = ctx.src->Sem().Get<sem::Statement>(node)) {
+      if (!stmt->IsReachable()) {
+        RemoveStatement(ctx, stmt->Declaration());
+      }
+    }
+  }
+
+  ctx.Clone();
+}
+
+}  // namespace transform
+}  // namespace tint
diff --git a/src/transform/remove_unreachable_statements.h b/src/transform/remove_unreachable_statements.h
new file mode 100644
index 0000000..f7edeee
--- /dev/null
+++ b/src/transform/remove_unreachable_statements.h
@@ -0,0 +1,50 @@
+// 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_REMOVE_UNREACHABLE_STATEMENTS_H_
+#define SRC_TRANSFORM_REMOVE_UNREACHABLE_STATEMENTS_H_
+
+#include <string>
+#include <unordered_map>
+
+#include "src/transform/transform.h"
+
+namespace tint {
+namespace transform {
+
+/// RemoveUnreachableStatements is a Transform that removes all statements
+/// marked as unreachable.
+class RemoveUnreachableStatements
+    : public Castable<RemoveUnreachableStatements, Transform> {
+ public:
+  /// Constructor
+  RemoveUnreachableStatements();
+
+  /// Destructor
+  ~RemoveUnreachableStatements() override;
+
+ protected:
+  /// Runs the transform using the CloneContext built for transforming a
+  /// program. Run() is responsible for calling Clone() on the CloneContext.
+  /// @param ctx the CloneContext primed with the input program and
+  /// ProgramBuilder
+  /// @param inputs optional extra transform-specific input data
+  /// @param outputs optional extra transform-specific output data
+  void Run(CloneContext& ctx, const DataMap& inputs, DataMap& outputs) override;
+};
+
+}  // namespace transform
+}  // namespace tint
+
+#endif  // SRC_TRANSFORM_REMOVE_UNREACHABLE_STATEMENTS_H_
diff --git a/src/transform/remove_unreachable_statements_test.cc b/src/transform/remove_unreachable_statements_test.cc
new file mode 100644
index 0000000..9124c62
--- /dev/null
+++ b/src/transform/remove_unreachable_statements_test.cc
@@ -0,0 +1,537 @@
+// 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/remove_unreachable_statements.h"
+
+#include "src/transform/test_helper.h"
+
+namespace tint {
+namespace transform {
+namespace {
+
+using RemoveUnreachableStatementsTest = TransformTest;
+
+TEST_F(RemoveUnreachableStatementsTest, EmptyModule) {
+  auto* src = "";
+  auto* expect = "";
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, Return) {
+  auto* src = R"(
+fn f() {
+  return;
+  var remove_me = 1;
+  if (true) {
+    var remove_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = R"(
+fn f() {
+  return;
+}
+)";
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, NestedReturn) {
+  auto* src = R"(
+fn f() {
+  {
+    {
+      return;
+    }
+  }
+  var remove_me = 1;
+  if (true) {
+    var remove_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = R"(
+fn f() {
+  {
+    {
+      return;
+    }
+  }
+}
+)";
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, Discard) {
+  auto* src = R"(
+fn f() {
+  discard;
+  var remove_me = 1;
+  if (true) {
+    var remove_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = R"(
+fn f() {
+  discard;
+}
+)";
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, NestedDiscard) {
+  auto* src = R"(
+fn f() {
+  {
+    {
+      discard;
+    }
+  }
+  var remove_me = 1;
+  if (true) {
+    var remove_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = R"(
+fn f() {
+  {
+    {
+      discard;
+    }
+  }
+}
+)";
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, CallToFuncWithDiscard) {
+  auto* src = R"(
+fn DISCARD() {
+  discard;
+}
+
+fn f() {
+  DISCARD();
+  var remove_me = 1;
+  if (true) {
+    var remove_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = R"(
+fn DISCARD() {
+  discard;
+}
+
+fn f() {
+  DISCARD();
+}
+)";
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, CallToFuncWithIfDiscard) {
+  auto* src = R"(
+fn DISCARD() {
+  if (true) {
+    discard;
+  }
+}
+
+fn f() {
+  DISCARD();
+  var preserve_me = 1;
+  if (true) {
+    var preserve_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = src;
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, IfDiscardElseDiscard) {
+  auto* src = R"(
+fn f() {
+  if (true) {
+    discard;
+  } else {
+    discard;
+  }
+  var remove_me = 1;
+  if (true) {
+    var remove_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = R"(
+fn f() {
+  if (true) {
+    discard;
+  } else {
+    discard;
+  }
+}
+)";
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, IfDiscardElseReturn) {
+  auto* src = R"(
+fn f() {
+  if (true) {
+    discard;
+  } else {
+    return;
+  }
+  var remove_me = 1;
+  if (true) {
+    var remove_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = R"(
+fn f() {
+  if (true) {
+    discard;
+  } else {
+    return;
+  }
+}
+)";
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, IfDiscard) {
+  auto* src = R"(
+fn f() {
+  if (true) {
+    discard;
+  }
+  var preserve_me = 1;
+  if (true) {
+    var preserve_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = src;
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, IfReturn) {
+  auto* src = R"(
+fn f() {
+  if (true) {
+    return;
+  }
+  var preserve_me = 1;
+  if (true) {
+    var preserve_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = src;
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, IfElseDiscard) {
+  auto* src = R"(
+fn f() {
+  if (true) {
+  } else {
+    discard;
+  }
+  var preserve_me = 1;
+  if (true) {
+    var preserve_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = src;
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, IfElseReturn) {
+  auto* src = R"(
+fn f() {
+  if (true) {
+  } else {
+    return;
+  }
+  var preserve_me = 1;
+  if (true) {
+    var preserve_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = src;
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, LoopWithNoBreak) {
+  auto* src = R"(
+fn f() {
+  loop {
+    var a = 1;
+    continuing {
+      var b = 2;
+    }
+  }
+  var remove_me = 1;
+  if (true) {
+    var remove_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = R"(
+fn f() {
+  loop {
+    var a = 1;
+
+    continuing {
+      var b = 2;
+    }
+  }
+}
+)";
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, LoopWithConditionalBreak) {
+  auto* src = R"(
+fn f() {
+  loop {
+    var a = 1;
+    if (true) {
+      break;
+    }
+
+    continuing {
+      var b = 2;
+    }
+  }
+  var preserve_me = 1;
+  if (true) {
+    var preserve_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = src;
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, LoopWithConditionalBreakInContinuing) {
+  auto* src = R"(
+fn f() {
+  loop {
+
+    continuing {
+      if (true) {
+        break;
+      }
+    }
+  }
+  var preserve_me = 1;
+  if (true) {
+    var preserve_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = src;
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, SwitchDefaultDiscard) {
+  auto* src = R"(
+fn f() {
+  switch(1) {
+    default: {
+      discard;
+    }
+  }
+  var remove_me = 1;
+  if (true) {
+    var remove_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = R"(
+fn f() {
+  switch(1) {
+    default: {
+      discard;
+    }
+  }
+}
+)";
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, SwitchCaseReturnDefaultDiscard) {
+  auto* src = R"(
+fn f() {
+  switch(1) {
+    case 0: {
+      return;
+    }
+    default: {
+      discard;
+    }
+  }
+  var remove_me = 1;
+  if (true) {
+    var remove_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = R"(
+fn f() {
+  switch(1) {
+    case 0: {
+      return;
+    }
+    default: {
+      discard;
+    }
+  }
+}
+)";
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, SwitchCaseBreakDefaultDiscard) {
+  auto* src = R"(
+fn f() {
+  switch(1) {
+    case 0: {
+      break;
+    }
+    default: {
+      discard;
+    }
+  }
+  var preserve_me = 1;
+  if (true) {
+    var preserve_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = src;
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(RemoveUnreachableStatementsTest, SwitchCaseReturnDefaultBreak) {
+  auto* src = R"(
+fn f() {
+  switch(1) {
+    case 0: {
+      return;
+    }
+    default: {
+      break;
+    }
+  }
+  var preserve_me = 1;
+  if (true) {
+    var preserve_me_too = 1;
+  }
+}
+)";
+
+  auto* expect = src;
+
+  auto got = Run<RemoveUnreachableStatements>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+}  // namespace
+}  // namespace transform
+}  // namespace tint
diff --git a/src/writer/glsl/generator_impl_binary_test.cc b/src/writer/glsl/generator_impl_binary_test.cc
index b23f228..5c397e9 100644
--- a/src/writer/glsl/generator_impl_binary_test.cc
+++ b/src/writer/glsl/generator_impl_binary_test.cc
@@ -328,26 +328,14 @@
   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)});
+  auto* expr = If(create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd,
+                                                Expr("a"), Expr("b")),
+                  Block(Return(1)),
+                  Else(create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
+                                                     Expr("b"), Expr("c")),
+                       Block(Return(2))),
+                  Else(Block(Return(3))));
+  Func("func", {}, ty.i32(), {WrapInStatement(expr)});
 
   GeneratorImpl& gen = Build();
 
diff --git a/src/writer/hlsl/generator_impl_binary_test.cc b/src/writer/hlsl/generator_impl_binary_test.cc
index f7184ac..44d27b7 100644
--- a/src/writer/hlsl/generator_impl_binary_test.cc
+++ b/src/writer/hlsl/generator_impl_binary_test.cc
@@ -328,26 +328,14 @@
   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)});
+  auto* expr = If(create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd,
+                                                Expr("a"), Expr("b")),
+                  Block(Return(1)),
+                  Else(create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
+                                                     Expr("b"), Expr("c")),
+                       Block(Return(2))),
+                  Else(Block(Return(3))));
+  Func("func", {}, ty.i32(), {WrapInStatement(expr)});
 
   GeneratorImpl& gen = Build();
 
diff --git a/test/BUILD.gn b/test/BUILD.gn
index c2cc482..a4467af 100644
--- a/test/BUILD.gn
+++ b/test/BUILD.gn
@@ -319,6 +319,7 @@
     "../src/transform/pad_array_elements_test.cc",
     "../src/transform/promote_initializers_to_const_var_test.cc",
     "../src/transform/remove_phonies_test.cc",
+    "../src/transform/remove_unreachable_statements_test.cc",
     "../src/transform/renamer_test.cc",
     "../src/transform/robustness_test.cc",
     "../src/transform/simplify_pointers_test.cc",
diff --git a/test/loops/continue_in_switch.wgsl.expected.hlsl b/test/loops/continue_in_switch.wgsl.expected.hlsl
index e9f76ea..b077826 100644
--- a/test/loops/continue_in_switch.wgsl.expected.hlsl
+++ b/test/loops/continue_in_switch.wgsl.expected.hlsl
@@ -1,9 +1,7 @@
-SKIP: FAILED
-
 [numthreads(1, 1, 1)]
 void f() {
   {
-    for(int i = 0; (i < 4); i = (i + 1)) {
+    [loop] for(int i = 0; (i < 4); i = (i + 1)) {
       switch(i) {
         case 0: {
           continue;
@@ -17,5 +15,3 @@
   }
   return;
 }
-C:\src\tint\test\Shader@0x000001C513B5E750(7,11-19): error X3708: continue cannot be used in a switch
-
diff --git a/test/loops/loop.wgsl b/test/loops/loop.wgsl
index aaf8ceb..63cd5ec 100644
--- a/test/loops/loop.wgsl
+++ b/test/loops/loop.wgsl
@@ -6,5 +6,4 @@
             return i;
         }
     }
-    return 0;
 }
diff --git a/test/loops/loop.wgsl.expected.hlsl b/test/loops/loop.wgsl.expected.hlsl
index 8eed4b2..d230ae9 100644
--- a/test/loops/loop.wgsl.expected.hlsl
+++ b/test/loops/loop.wgsl.expected.hlsl
@@ -11,5 +11,4 @@
       return i;
     }
   }
-  return 0;
 }
diff --git a/test/loops/loop.wgsl.expected.msl b/test/loops/loop.wgsl.expected.msl
index 59523f0..49a3b1c 100644
--- a/test/loops/loop.wgsl.expected.msl
+++ b/test/loops/loop.wgsl.expected.msl
@@ -9,6 +9,5 @@
       return i;
     }
   }
-  return 0;
 }
 
diff --git a/test/loops/loop.wgsl.expected.spvasm b/test/loops/loop.wgsl.expected.spvasm
index a0044b5..07708ab 100644
--- a/test/loops/loop.wgsl.expected.spvasm
+++ b/test/loops/loop.wgsl.expected.spvasm
@@ -1,7 +1,7 @@
 ; SPIR-V
 ; Version: 1.3
 ; Generator: Google Tint Compiler; 0
-; Bound: 27
+; Bound: 26
 ; Schema: 0
                OpCapability Shader
                OpMemoryModel Logical GLSL450
@@ -19,7 +19,6 @@
       %int_1 = OpConstant %int 1
       %int_4 = OpConstant %int 4
        %bool = OpTypeBool
-      %int_0 = OpConstant %int 0
 %unused_entry_point = OpFunction %void None %1
           %4 = OpLabel
                OpReturn
@@ -47,5 +46,5 @@
          %14 = OpLabel
                OpBranch %12
          %13 = OpLabel
-               OpReturnValue %int_0
+               OpReturnValue %11
                OpFunctionEnd
diff --git a/test/loops/loop.wgsl.expected.wgsl b/test/loops/loop.wgsl.expected.wgsl
index 783314f..bcbc58d 100644
--- a/test/loops/loop.wgsl.expected.wgsl
+++ b/test/loops/loop.wgsl.expected.wgsl
@@ -6,5 +6,4 @@
       return i;
     }
   }
-  return 0;
 }
diff --git a/test/loops/loop_with_continuing.wgsl b/test/loops/loop_with_continuing.wgsl
index a406853..862a53d 100644
--- a/test/loops/loop_with_continuing.wgsl
+++ b/test/loops/loop_with_continuing.wgsl
@@ -8,5 +8,4 @@
             i = i + 1;
         }
     }
-    return 0;
 }
diff --git a/test/loops/loop_with_continuing.wgsl.expected.hlsl b/test/loops/loop_with_continuing.wgsl.expected.hlsl
index 440ef88..3ab6ee6 100644
--- a/test/loops/loop_with_continuing.wgsl.expected.hlsl
+++ b/test/loops/loop_with_continuing.wgsl.expected.hlsl
@@ -13,5 +13,4 @@
       i = (i + 1);
     }
   }
-  return 0;
 }
diff --git a/test/loops/loop_with_continuing.wgsl.expected.msl b/test/loops/loop_with_continuing.wgsl.expected.msl
index c99f6f8..52a015b 100644
--- a/test/loops/loop_with_continuing.wgsl.expected.msl
+++ b/test/loops/loop_with_continuing.wgsl.expected.msl
@@ -11,6 +11,5 @@
       i = as_type<int>((as_type<uint>(i) + as_type<uint>(1)));
     }
   }
-  return 0;
 }
 
diff --git a/test/loops/loop_with_continuing.wgsl.expected.spvasm b/test/loops/loop_with_continuing.wgsl.expected.spvasm
index 2bc00b4..24b9b0b 100644
--- a/test/loops/loop_with_continuing.wgsl.expected.spvasm
+++ b/test/loops/loop_with_continuing.wgsl.expected.spvasm
@@ -1,7 +1,7 @@
 ; SPIR-V
 ; Version: 1.3
 ; Generator: Google Tint Compiler; 0
-; Bound: 27
+; Bound: 26
 ; Schema: 0
                OpCapability Shader
                OpMemoryModel Logical GLSL450
@@ -19,7 +19,6 @@
       %int_4 = OpConstant %int 4
        %bool = OpTypeBool
       %int_1 = OpConstant %int 1
-      %int_0 = OpConstant %int 0
 %unused_entry_point = OpFunction %void None %1
           %4 = OpLabel
                OpReturn
@@ -47,5 +46,5 @@
                OpStore %i %25
                OpBranch %12
          %13 = OpLabel
-               OpReturnValue %int_0
+               OpReturnValue %11
                OpFunctionEnd
diff --git a/test/loops/loop_with_continuing.wgsl.expected.wgsl b/test/loops/loop_with_continuing.wgsl.expected.wgsl
index eba6d8f..e79c789 100644
--- a/test/loops/loop_with_continuing.wgsl.expected.wgsl
+++ b/test/loops/loop_with_continuing.wgsl.expected.wgsl
@@ -9,5 +9,4 @@
       i = (i + 1);
     }
   }
-  return 0;
 }
diff --git a/test/loops/nested_loops.wgsl b/test/loops/nested_loops.wgsl
index 3b8f6dd..3a093e7 100644
--- a/test/loops/nested_loops.wgsl
+++ b/test/loops/nested_loops.wgsl
@@ -13,5 +13,4 @@
             }
         }
     }
-    return 0;
 }
diff --git a/test/loops/nested_loops.wgsl.expected.hlsl b/test/loops/nested_loops.wgsl.expected.hlsl
index 5278d00..f5b1164 100644
--- a/test/loops/nested_loops.wgsl.expected.hlsl
+++ b/test/loops/nested_loops.wgsl.expected.hlsl
@@ -18,5 +18,4 @@
       }
     }
   }
-  return 0;
 }
diff --git a/test/loops/nested_loops.wgsl.expected.msl b/test/loops/nested_loops.wgsl.expected.msl
index 580263c..484b4ca 100644
--- a/test/loops/nested_loops.wgsl.expected.msl
+++ b/test/loops/nested_loops.wgsl.expected.msl
@@ -16,6 +16,5 @@
       }
     }
   }
-  return 0;
 }
 
diff --git a/test/loops/nested_loops.wgsl.expected.spvasm b/test/loops/nested_loops.wgsl.expected.spvasm
index b978879..c77a5e3 100644
--- a/test/loops/nested_loops.wgsl.expected.spvasm
+++ b/test/loops/nested_loops.wgsl.expected.spvasm
@@ -1,7 +1,7 @@
 ; SPIR-V
 ; Version: 1.3
 ; Generator: Google Tint Compiler; 0
-; Bound: 38
+; Bound: 37
 ; Schema: 0
                OpCapability Shader
                OpMemoryModel Logical GLSL450
@@ -21,7 +21,6 @@
       %int_4 = OpConstant %int 4
        %bool = OpTypeBool
       %int_2 = OpConstant %int 2
-      %int_0 = OpConstant %int 0
 %unused_entry_point = OpFunction %void None %1
           %4 = OpLabel
                OpReturn
@@ -68,5 +67,5 @@
          %15 = OpLabel
                OpBranch %13
          %14 = OpLabel
-               OpReturnValue %int_0
+               OpReturnValue %11
                OpFunctionEnd
diff --git a/test/loops/nested_loops.wgsl.expected.wgsl b/test/loops/nested_loops.wgsl.expected.wgsl
index 048cd04..97c8060 100644
--- a/test/loops/nested_loops.wgsl.expected.wgsl
+++ b/test/loops/nested_loops.wgsl.expected.wgsl
@@ -13,5 +13,4 @@
       }
     }
   }
-  return 0;
 }
diff --git a/test/loops/nested_loops_with_continuing.wgsl b/test/loops/nested_loops_with_continuing.wgsl
index d1e3db6..9fa77ef 100644
--- a/test/loops/nested_loops_with_continuing.wgsl
+++ b/test/loops/nested_loops_with_continuing.wgsl
@@ -17,5 +17,4 @@
             i = i + 1;
         }
     }
-    return 0;
 }
diff --git a/test/loops/nested_loops_with_continuing.wgsl.expected.hlsl b/test/loops/nested_loops_with_continuing.wgsl.expected.hlsl
index 8d795a8..605a079 100644
--- a/test/loops/nested_loops_with_continuing.wgsl.expected.hlsl
+++ b/test/loops/nested_loops_with_continuing.wgsl.expected.hlsl
@@ -22,5 +22,4 @@
       i = (i + 1);
     }
   }
-  return 0;
 }
diff --git a/test/loops/nested_loops_with_continuing.wgsl.expected.msl b/test/loops/nested_loops_with_continuing.wgsl.expected.msl
index 24fa85d..f28c010 100644
--- a/test/loops/nested_loops_with_continuing.wgsl.expected.msl
+++ b/test/loops/nested_loops_with_continuing.wgsl.expected.msl
@@ -20,6 +20,5 @@
       i = as_type<int>((as_type<uint>(i) + as_type<uint>(1)));
     }
   }
-  return 0;
 }
 
diff --git a/test/loops/nested_loops_with_continuing.wgsl.expected.spvasm b/test/loops/nested_loops_with_continuing.wgsl.expected.spvasm
index 633b73c..6005882 100644
--- a/test/loops/nested_loops_with_continuing.wgsl.expected.spvasm
+++ b/test/loops/nested_loops_with_continuing.wgsl.expected.spvasm
@@ -1,7 +1,7 @@
 ; SPIR-V
 ; Version: 1.3
 ; Generator: Google Tint Compiler; 0
-; Bound: 38
+; Bound: 37
 ; Schema: 0
                OpCapability Shader
                OpMemoryModel Logical GLSL450
@@ -21,7 +21,6 @@
        %bool = OpTypeBool
       %int_1 = OpConstant %int 1
       %int_2 = OpConstant %int 2
-      %int_0 = OpConstant %int 0
 %unused_entry_point = OpFunction %void None %1
           %4 = OpLabel
                OpReturn
@@ -68,5 +67,5 @@
                OpStore %i %36
                OpBranch %13
          %14 = OpLabel
-               OpReturnValue %int_0
+               OpReturnValue %11
                OpFunctionEnd
diff --git a/test/loops/nested_loops_with_continuing.wgsl.expected.wgsl b/test/loops/nested_loops_with_continuing.wgsl.expected.wgsl
index 469e4c1..6b268d4 100644
--- a/test/loops/nested_loops_with_continuing.wgsl.expected.wgsl
+++ b/test/loops/nested_loops_with_continuing.wgsl.expected.wgsl
@@ -19,5 +19,4 @@
       i = (i + 1);
     }
   }
-  return 0;
 }
diff --git a/test/statements/for/scoping.wgsl b/test/statements/for/scoping.wgsl
index 0db6a69..5adcd48 100644
--- a/test/statements/for/scoping.wgsl
+++ b/test/statements/for/scoping.wgsl
@@ -1,4 +1,4 @@
 fn f() {
-    for (var must_not_collide : i32 = 0;;) {}
+    for (var must_not_collide : i32 = 0;;) { break; }
     var must_not_collide : i32;
 }
diff --git a/test/statements/for/scoping.wgsl.expected.hlsl b/test/statements/for/scoping.wgsl.expected.hlsl
index 65cfcf7..16c30ec 100644
--- a/test/statements/for/scoping.wgsl.expected.hlsl
+++ b/test/statements/for/scoping.wgsl.expected.hlsl
@@ -6,6 +6,7 @@
 void f() {
   {
     [loop] for(int must_not_collide = 0; ; ) {
+      break;
     }
   }
   int must_not_collide = 0;
diff --git a/test/statements/for/scoping.wgsl.expected.msl b/test/statements/for/scoping.wgsl.expected.msl
index 0572921..c6d9118 100644
--- a/test/statements/for/scoping.wgsl.expected.msl
+++ b/test/statements/for/scoping.wgsl.expected.msl
@@ -3,6 +3,7 @@
 using namespace metal;
 void f() {
   for(int must_not_collide = 0; ; ) {
+    break;
   }
   int must_not_collide = 0;
 }
diff --git a/test/statements/for/scoping.wgsl.expected.spvasm b/test/statements/for/scoping.wgsl.expected.spvasm
index 2733b61..c17a34e 100644
--- a/test/statements/for/scoping.wgsl.expected.spvasm
+++ b/test/statements/for/scoping.wgsl.expected.spvasm
@@ -31,7 +31,7 @@
                OpLoopMerge %13 %14 None
                OpBranch %15
          %15 = OpLabel
-               OpBranch %14
+               OpBranch %13
          %14 = OpLabel
                OpBranch %12
          %13 = OpLabel
diff --git a/test/statements/for/scoping.wgsl.expected.wgsl b/test/statements/for/scoping.wgsl.expected.wgsl
index 5c32a15..6c0e705 100644
--- a/test/statements/for/scoping.wgsl.expected.wgsl
+++ b/test/statements/for/scoping.wgsl.expected.wgsl
@@ -1,5 +1,6 @@
 fn f() {
   for(var must_not_collide : i32 = 0; ; ) {
+    break;
   }
   var must_not_collide : i32;
 }
diff --git a/test/vk-gl-cts/graphicsfuzz/cov-wrap-op-kill-for-loop/0-opt.spvasm b/test/vk-gl-cts/graphicsfuzz/cov-wrap-op-kill-for-loop/0-opt.spvasm
deleted file mode 100644
index 96a060d..0000000
--- a/test/vk-gl-cts/graphicsfuzz/cov-wrap-op-kill-for-loop/0-opt.spvasm
+++ /dev/null
@@ -1,91 +0,0 @@
-               OpCapability Shader
-          %1 = OpExtInstImport "GLSL.std.450"
-               OpMemoryModel Logical GLSL450
-               OpEntryPoint Fragment %main "main" %_GLF_color
-               OpExecutionMode %main OriginUpperLeft
-               OpSource ESSL 310
-               OpName %main "main"
-               OpName %func_i1_ "func(i1;"
-               OpName %x "x"
-               OpName %buf0 "buf0"
-               OpMemberName %buf0 0 "zero"
-               OpName %_ ""
-               OpName %_GLF_color "_GLF_color"
-               OpName %i "i"
-               OpName %param "param"
-               OpMemberDecorate %buf0 0 Offset 0
-               OpDecorate %buf0 Block
-               OpDecorate %_ DescriptorSet 0
-               OpDecorate %_ Binding 0
-               OpDecorate %_GLF_color Location 0
-       %void = OpTypeVoid
-         %11 = OpTypeFunction %void
-        %int = OpTypeInt 32 1
-%_ptr_Function_int = OpTypePointer Function %int
-         %14 = OpTypeFunction %void %_ptr_Function_int
-       %buf0 = OpTypeStruct %int
-%_ptr_Uniform_buf0 = OpTypePointer Uniform %buf0
-          %_ = OpVariable %_ptr_Uniform_buf0 Uniform
-      %int_0 = OpConstant %int 0
-%_ptr_Uniform_int = OpTypePointer Uniform %int
-       %bool = OpTypeBool
-      %int_8 = OpConstant %int 8
-      %float = OpTypeFloat 32
-    %v4float = OpTypeVector %float 4
-%_ptr_Output_v4float = OpTypePointer Output %v4float
- %_GLF_color = OpVariable %_ptr_Output_v4float Output
-    %float_1 = OpConstant %float 1
-    %float_0 = OpConstant %float 0
-         %25 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_1
-         %26 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0
-     %int_10 = OpConstant %int 10
-      %int_1 = OpConstant %int 1
-       %main = OpFunction %void None %11
-         %29 = OpLabel
-          %i = OpVariable %_ptr_Function_int Function
-      %param = OpVariable %_ptr_Function_int Function
-               OpStore %_GLF_color %26
-               OpStore %i %int_0
-               OpBranch %30
-         %30 = OpLabel
-         %31 = OpPhi %int %int_0 %29 %32 %33
-         %34 = OpAccessChain %_ptr_Uniform_int %_ %int_0
-         %35 = OpLoad %int %34
-         %36 = OpIAdd %int %int_10 %35
-         %37 = OpSLessThan %bool %31 %36
-               OpLoopMerge %38 %33 None
-               OpBranchConditional %37 %33 %38
-         %33 = OpLabel
-               OpStore %param %31
-         %39 = OpFunctionCall %void %func_i1_ %param
-         %32 = OpIAdd %int %31 %int_1
-               OpStore %i %32
-               OpBranch %30
-         %38 = OpLabel
-               OpReturn
-               OpFunctionEnd
-   %func_i1_ = OpFunction %void None %14
-          %x = OpFunctionParameter %_ptr_Function_int
-         %40 = OpLabel
-         %41 = OpLoad %int %x
-         %42 = OpAccessChain %_ptr_Uniform_int %_ %int_0
-         %43 = OpLoad %int %42
-         %44 = OpSLessThan %bool %41 %43
-               OpSelectionMerge %45 None
-               OpBranchConditional %44 %46 %45
-         %46 = OpLabel
-               OpKill
-         %45 = OpLabel
-         %47 = OpLoad %int %x
-         %48 = OpSGreaterThan %bool %47 %int_8
-               OpSelectionMerge %49 None
-               OpBranchConditional %48 %50 %51
-         %50 = OpLabel
-               OpStore %_GLF_color %25
-               OpBranch %49
-         %51 = OpLabel
-               OpStore %_GLF_color %26
-               OpBranch %49
-         %49 = OpLabel
-               OpReturn
-               OpFunctionEnd
diff --git a/test/vk-gl-cts/graphicsfuzz/cov-wrap-op-kill-for-loop/0-opt.wgsl b/test/vk-gl-cts/graphicsfuzz/cov-wrap-op-kill-for-loop/0-opt.wgsl
deleted file mode 100644
index f53a636..0000000
--- a/test/vk-gl-cts/graphicsfuzz/cov-wrap-op-kill-for-loop/0-opt.wgsl
+++ /dev/null
@@ -1,60 +0,0 @@
-[[block]]
-struct buf0 {
-  zero : i32;
-};
-
-[[group(0), binding(0)]] var<uniform> x_7 : buf0;
-
-var<private> x_GLF_color : vec4<f32>;
-
-fn func_i1_(x : ptr<function, i32>) {
-  let x_41 : i32 = *(x);
-  let x_43 : i32 = x_7.zero;
-  if ((x_41 < x_43)) {
-    discard;
-  }
-  let x_47 : i32 = *(x);
-  if ((x_47 > 8)) {
-    x_GLF_color = vec4<f32>(1.0, 0.0, 0.0, 1.0);
-  } else {
-    x_GLF_color = vec4<f32>(0.0, 0.0, 0.0, 0.0);
-  }
-  return;
-}
-
-fn main_1() {
-  var i : i32;
-  var param : i32;
-  var x_31_phi : i32;
-  x_GLF_color = vec4<f32>(0.0, 0.0, 0.0, 0.0);
-  i = 0;
-  x_31_phi = 0;
-  loop {
-    let x_31 : i32 = x_31_phi;
-    let x_35 : i32 = x_7.zero;
-    if ((x_31 < (10 + x_35))) {
-    } else {
-      break;
-    }
-
-    continuing {
-      param = x_31;
-      func_i1_(&(param));
-      let x_32 : i32 = (x_31 + 1);
-      i = x_32;
-      x_31_phi = x_32;
-    }
-  }
-  return;
-}
-
-struct main_out {
-  [[location(0)]]
-  x_GLF_color_1 : vec4<f32>;
-};
-
-[[stage(fragment)]]
-fn main() -> main_out {
-  main_1();
-  return main_out(x_GLF_color);
-}
diff --git a/test/vk-gl-cts/graphicsfuzz/cov-wrap-op-kill-two-branches/0-opt.spvasm b/test/vk-gl-cts/graphicsfuzz/cov-wrap-op-kill-two-branches/0-opt.spvasm
deleted file mode 100644
index fa125c0..0000000
--- a/test/vk-gl-cts/graphicsfuzz/cov-wrap-op-kill-two-branches/0-opt.spvasm
+++ /dev/null
@@ -1,123 +0,0 @@
-               OpCapability Shader
-          %1 = OpExtInstImport "GLSL.std.450"
-               OpMemoryModel Logical GLSL450
-               OpEntryPoint Fragment %main "main" %gl_FragCoord %_GLF_color
-               OpExecutionMode %main OriginUpperLeft
-               OpSource ESSL 310
-               OpName %main "main"
-               OpName %func_f1_ "func(f1;"
-               OpName %x "x"
-               OpName %gl_FragCoord "gl_FragCoord"
-               OpName %f "f"
-               OpName %i "i"
-               OpName %buf0 "buf0"
-               OpMemberName %buf0 0 "five"
-               OpName %_ ""
-               OpName %param "param"
-               OpName %_GLF_color "_GLF_color"
-               OpDecorate %gl_FragCoord BuiltIn FragCoord
-               OpMemberDecorate %buf0 0 Offset 0
-               OpDecorate %buf0 Block
-               OpDecorate %_ DescriptorSet 0
-               OpDecorate %_ Binding 0
-               OpDecorate %_GLF_color Location 0
-       %void = OpTypeVoid
-         %13 = OpTypeFunction %void
-      %float = OpTypeFloat 32
-%_ptr_Function_float = OpTypePointer Function %float
-         %16 = OpTypeFunction %float %_ptr_Function_float
-    %float_5 = OpConstant %float 5
-       %bool = OpTypeBool
-    %v4float = OpTypeVector %float 4
-%_ptr_Input_v4float = OpTypePointer Input %v4float
-%gl_FragCoord = OpVariable %_ptr_Input_v4float Input
-       %uint = OpTypeInt 32 0
-     %uint_0 = OpConstant %uint 0
-%_ptr_Input_float = OpTypePointer Input %float
-  %float_0_5 = OpConstant %float 0.5
-     %uint_1 = OpConstant %uint 1
-    %float_1 = OpConstant %float 1
-    %float_0 = OpConstant %float 0
-        %int = OpTypeInt 32 1
-%_ptr_Function_int = OpTypePointer Function %int
-      %int_0 = OpConstant %int 0
-       %buf0 = OpTypeStruct %int
-%_ptr_Uniform_buf0 = OpTypePointer Uniform %buf0
-          %_ = OpVariable %_ptr_Uniform_buf0 Uniform
-%_ptr_Uniform_int = OpTypePointer Uniform %int
-      %int_1 = OpConstant %int 1
-%_ptr_Output_v4float = OpTypePointer Output %v4float
- %_GLF_color = OpVariable %_ptr_Output_v4float Output
-         %35 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_1
-         %36 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0
-       %main = OpFunction %void None %13
-         %37 = OpLabel
-          %f = OpVariable %_ptr_Function_float Function
-          %i = OpVariable %_ptr_Function_int Function
-      %param = OpVariable %_ptr_Function_float Function
-               OpStore %f %float_0
-               OpStore %i %int_0
-               OpBranch %38
-         %38 = OpLabel
-         %39 = OpLoad %int %i
-         %40 = OpAccessChain %_ptr_Uniform_int %_ %int_0
-         %41 = OpLoad %int %40
-         %42 = OpSLessThan %bool %39 %41
-               OpLoopMerge %43 %44 None
-               OpBranchConditional %42 %44 %43
-         %44 = OpLabel
-         %45 = OpLoad %int %i
-         %46 = OpConvertSToF %float %45
-               OpStore %param %46
-         %47 = OpFunctionCall %float %func_f1_ %param
-               OpStore %f %47
-         %48 = OpLoad %int %i
-         %49 = OpIAdd %int %48 %int_1
-               OpStore %i %49
-               OpBranch %38
-         %43 = OpLabel
-         %50 = OpLoad %float %f
-         %51 = OpFOrdEqual %bool %50 %float_5
-               OpSelectionMerge %52 None
-               OpBranchConditional %51 %53 %54
-         %53 = OpLabel
-               OpStore %_GLF_color %35
-               OpBranch %52
-         %54 = OpLabel
-               OpStore %_GLF_color %36
-               OpBranch %52
-         %52 = OpLabel
-               OpReturn
-               OpFunctionEnd
-   %func_f1_ = OpFunction %float None %16
-          %x = OpFunctionParameter %_ptr_Function_float
-         %55 = OpLabel
-         %56 = OpLoad %float %x
-         %57 = OpFOrdGreaterThan %bool %56 %float_5
-               OpSelectionMerge %58 None
-               OpBranchConditional %57 %59 %58
-         %59 = OpLabel
-         %60 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_0
-         %61 = OpLoad %float %60
-         %62 = OpFOrdLessThan %bool %61 %float_0_5
-               OpSelectionMerge %63 None
-               OpBranchConditional %62 %64 %65
-         %64 = OpLabel
-               OpKill
-         %65 = OpLabel
-         %66 = OpAccessChain %_ptr_Input_float %gl_FragCoord %uint_1
-         %67 = OpLoad %float %66
-         %68 = OpFOrdLessThan %bool %67 %float_0_5
-               OpSelectionMerge %69 None
-               OpBranchConditional %68 %70 %69
-         %70 = OpLabel
-               OpKill
-         %69 = OpLabel
-               OpBranch %63
-         %63 = OpLabel
-               OpBranch %58
-         %58 = OpLabel
-         %71 = OpLoad %float %x
-         %72 = OpFAdd %float %71 %float_1
-               OpReturnValue %72
-               OpFunctionEnd
diff --git a/test/vk-gl-cts/graphicsfuzz/cov-wrap-op-kill-two-branches/0-opt.wgsl b/test/vk-gl-cts/graphicsfuzz/cov-wrap-op-kill-two-branches/0-opt.wgsl
deleted file mode 100644
index d25c0e5..0000000
--- a/test/vk-gl-cts/graphicsfuzz/cov-wrap-op-kill-two-branches/0-opt.wgsl
+++ /dev/null
@@ -1,71 +0,0 @@
-[[block]]
-struct buf0 {
-  five : i32;
-};
-
-var<private> gl_FragCoord : vec4<f32>;
-
-[[group(0), binding(0)]] var<uniform> x_10 : buf0;
-
-var<private> x_GLF_color : vec4<f32>;
-
-fn func_f1_(x : ptr<function, f32>) -> f32 {
-  let x_56 : f32 = *(x);
-  if ((x_56 > 5.0)) {
-    let x_61 : f32 = gl_FragCoord.x;
-    if ((x_61 < 0.5)) {
-      discard;
-    } else {
-      let x_67 : f32 = gl_FragCoord.y;
-      if ((x_67 < 0.5)) {
-        discard;
-      }
-    }
-  }
-  let x_71 : f32 = *(x);
-  return (x_71 + 1.0);
-}
-
-fn main_1() {
-  var f : f32;
-  var i : i32;
-  var param : f32;
-  f = 0.0;
-  i = 0;
-  loop {
-    let x_39 : i32 = i;
-    let x_41 : i32 = x_10.five;
-    if ((x_39 < x_41)) {
-    } else {
-      break;
-    }
-
-    continuing {
-      let x_45 : i32 = i;
-      param = f32(x_45);
-      let x_47 : f32 = func_f1_(&(param));
-      f = x_47;
-      let x_48 : i32 = i;
-      i = (x_48 + 1);
-    }
-  }
-  let x_50 : f32 = f;
-  if ((x_50 == 5.0)) {
-    x_GLF_color = vec4<f32>(1.0, 0.0, 0.0, 1.0);
-  } else {
-    x_GLF_color = vec4<f32>(0.0, 0.0, 0.0, 0.0);
-  }
-  return;
-}
-
-struct main_out {
-  [[location(0)]]
-  x_GLF_color_1 : vec4<f32>;
-};
-
-[[stage(fragment)]]
-fn main([[builtin(position)]] gl_FragCoord_param : vec4<f32>) -> main_out {
-  gl_FragCoord = gl_FragCoord_param;
-  main_1();
-  return main_out(x_GLF_color);
-}
diff --git a/test/vk-gl-cts/graphicsfuzz/two-nested-infinite-loops-discard/0-opt.spvasm b/test/vk-gl-cts/graphicsfuzz/two-nested-infinite-loops-discard/0-opt.spvasm
deleted file mode 100644
index bfce82b..0000000
--- a/test/vk-gl-cts/graphicsfuzz/two-nested-infinite-loops-discard/0-opt.spvasm
+++ /dev/null
@@ -1,91 +0,0 @@
-               OpCapability Shader
-          %1 = OpExtInstImport "GLSL.std.450"
-               OpMemoryModel Logical GLSL450
-               OpEntryPoint Fragment %main "main" %_GLF_color
-               OpExecutionMode %main OriginUpperLeft
-               OpSource ESSL 310
-               OpName %main "main"
-               OpName %mand_ "mand("
-               OpName %k "k"
-               OpName %buf0 "buf0"
-               OpMemberName %buf0 0 "injectionSwitch"
-               OpName %_ ""
-               OpName %j "j"
-               OpName %_GLF_color "_GLF_color"
-               OpDecorate %k RelaxedPrecision
-               OpMemberDecorate %buf0 0 Offset 0
-               OpDecorate %buf0 Block
-               OpDecorate %_ DescriptorSet 0
-               OpDecorate %_ Binding 0
-               OpDecorate %j RelaxedPrecision
-               OpDecorate %_GLF_color Location 0
-               OpDecorate %int_0 RelaxedPrecision
-       %void = OpTypeVoid
-         %11 = OpTypeFunction %void
-      %float = OpTypeFloat 32
-    %v3float = OpTypeVector %float 3
-         %14 = OpTypeFunction %v3float
-        %int = OpTypeInt 32 1
-%_ptr_Function_int = OpTypePointer Function %int
-      %int_0 = OpConstant %int 0
-   %int_1000 = OpConstant %int 1000
-       %bool = OpTypeBool
-      %int_1 = OpConstant %int 1
-    %float_1 = OpConstant %float 1
-         %21 = OpConstantComposite %v3float %float_1 %float_1 %float_1
-    %v2float = OpTypeVector %float 2
-       %buf0 = OpTypeStruct %v2float
-%_ptr_Uniform_buf0 = OpTypePointer Uniform %buf0
-          %_ = OpVariable %_ptr_Uniform_buf0 Uniform
-       %uint = OpTypeInt 32 0
-     %uint_0 = OpConstant %uint 0
-%_ptr_Uniform_float = OpTypePointer Uniform %float
-     %uint_1 = OpConstant %uint 1
-      %int_4 = OpConstant %int 4
-    %v4float = OpTypeVector %float 4
-%_ptr_Output_v4float = OpTypePointer Output %v4float
- %_GLF_color = OpVariable %_ptr_Output_v4float Output
-    %float_0 = OpConstant %float 0
-         %32 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_1
-         %33 = OpUndef %int
-       %true = OpConstantTrue %bool
-       %main = OpFunction %void None %11
-         %35 = OpLabel
-          %j = OpVariable %_ptr_Function_int Function
-         %36 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %uint_0
-         %37 = OpLoad %float %36
-         %38 = OpAccessChain %_ptr_Uniform_float %_ %int_0 %uint_1
-         %39 = OpLoad %float %38
-         %40 = OpFOrdGreaterThan %bool %37 %39
-               OpSelectionMerge %41 None
-               OpBranchConditional %40 %42 %41
-         %42 = OpLabel
-               OpStore %j %int_0
-               OpBranch %43
-         %43 = OpLabel
-               OpLoopMerge %44 %45 None
-               OpBranchConditional %true %45 %44
-         %45 = OpLabel
-         %46 = OpFunctionCall %v3float %mand_
-               OpBranch %43
-         %44 = OpLabel
-               OpBranch %41
-         %41 = OpLabel
-               OpStore %_GLF_color %32
-               OpReturn
-               OpFunctionEnd
-      %mand_ = OpFunction %v3float None %14
-         %47 = OpLabel
-          %k = OpVariable %_ptr_Function_int Function
-               OpStore %k %int_0
-               OpBranch %48
-         %48 = OpLabel
-               OpLoopMerge %49 %50 None
-               OpBranchConditional %true %51 %49
-         %51 = OpLabel
-               OpKill
-         %50 = OpLabel
-               OpBranch %48
-         %49 = OpLabel
-               OpReturnValue %21
-               OpFunctionEnd
diff --git a/test/vk-gl-cts/graphicsfuzz/two-nested-infinite-loops-discard/0-opt.spvasm.expected.hlsl b/test/vk-gl-cts/graphicsfuzz/two-nested-infinite-loops-discard/0-opt.spvasm.expected.hlsl
deleted file mode 100755
index 6bc6cf8..0000000
--- a/test/vk-gl-cts/graphicsfuzz/two-nested-infinite-loops-discard/0-opt.spvasm.expected.hlsl
+++ /dev/null
@@ -1,52 +0,0 @@
-SKIP: FAILED
-
-cbuffer cbuffer_x_7 : register(b0, space0) {
-  uint4 x_7[1];
-};
-static float4 x_GLF_color = float4(0.0f, 0.0f, 0.0f, 0.0f);
-
-float3 mand_() {
-  int k = 0;
-  k = 0;
-  while (true) {
-    if (true) {
-    } else {
-      break;
-    }
-    discard;
-  }
-  return float3(1.0f, 1.0f, 1.0f);
-}
-
-void main_1() {
-  int j = 0;
-  const float x_37 = asfloat(x_7[0].x);
-  const float x_39 = asfloat(x_7[0].y);
-  if ((x_37 > x_39)) {
-    j = 0;
-    {
-      for(; true; const float3 x_46 = mand_()) {
-      }
-    }
-  }
-  x_GLF_color = float4(1.0f, 0.0f, 0.0f, 1.0f);
-  return;
-}
-
-struct main_out {
-  float4 x_GLF_color_1;
-};
-struct tint_symbol {
-  float4 x_GLF_color_1 : SV_Target0;
-};
-
-tint_symbol main() {
-  main_1();
-  const main_out tint_symbol_1 = {x_GLF_color};
-  const tint_symbol tint_symbol_3 = {tint_symbol_1.x_GLF_color_1};
-  return tint_symbol_3;
-}
-C:\src\tint\test\Shader@0x00000294138DDB00(26,19-23): error X3000: syntax error: unexpected token 'const'
-C:\src\tint\test\Shader@0x00000294138DDB00(41,17): error X3000: syntax error: unexpected token '('
-C:\src\tint\test\Shader@0x00000294138DDB00(45,3-23): error X3079: 'main_1': void functions cannot return a value
-
diff --git a/test/vk-gl-cts/graphicsfuzz/two-nested-infinite-loops-discard/0-opt.wgsl b/test/vk-gl-cts/graphicsfuzz/two-nested-infinite-loops-discard/0-opt.wgsl
deleted file mode 100644
index 26e8226..0000000
--- a/test/vk-gl-cts/graphicsfuzz/two-nested-infinite-loops-discard/0-opt.wgsl
+++ /dev/null
@@ -1,53 +0,0 @@
-[[block]]
-struct buf0 {
-  injectionSwitch : vec2<f32>;
-};
-
-[[group(0), binding(0)]] var<uniform> x_7 : buf0;
-
-var<private> x_GLF_color : vec4<f32>;
-
-fn mand_() -> vec3<f32> {
-  var k : i32;
-  k = 0;
-  loop {
-    if (true) {
-    } else {
-      break;
-    }
-    discard;
-  }
-  return vec3<f32>(1.0, 1.0, 1.0);
-}
-
-fn main_1() {
-  var j : i32;
-  let x_37 : f32 = x_7.injectionSwitch.x;
-  let x_39 : f32 = x_7.injectionSwitch.y;
-  if ((x_37 > x_39)) {
-    j = 0;
-    loop {
-      if (true) {
-      } else {
-        break;
-      }
-
-      continuing {
-        let x_46 : vec3<f32> = mand_();
-      }
-    }
-  }
-  x_GLF_color = vec4<f32>(1.0, 0.0, 0.0, 1.0);
-  return;
-}
-
-struct main_out {
-  [[location(0)]]
-  x_GLF_color_1 : vec4<f32>;
-};
-
-[[stage(fragment)]]
-fn main() -> main_out {
-  main_1();
-  return main_out(x_GLF_color);
-}
diff --git a/test/vk-gl-cts/graphicsfuzz/two-nested-infinite-loops-discard/0-opt.wgsl.expected.hlsl b/test/vk-gl-cts/graphicsfuzz/two-nested-infinite-loops-discard/0-opt.wgsl.expected.hlsl
deleted file mode 100755
index 26bd184..0000000
--- a/test/vk-gl-cts/graphicsfuzz/two-nested-infinite-loops-discard/0-opt.wgsl.expected.hlsl
+++ /dev/null
@@ -1,52 +0,0 @@
-SKIP: FAILED
-
-cbuffer cbuffer_x_7 : register(b0, space0) {
-  uint4 x_7[1];
-};
-static float4 x_GLF_color = float4(0.0f, 0.0f, 0.0f, 0.0f);
-
-float3 mand_() {
-  int k = 0;
-  k = 0;
-  while (true) {
-    if (true) {
-    } else {
-      break;
-    }
-    discard;
-  }
-  return float3(1.0f, 1.0f, 1.0f);
-}
-
-void main_1() {
-  int j = 0;
-  const float x_37 = asfloat(x_7[0].x);
-  const float x_39 = asfloat(x_7[0].y);
-  if ((x_37 > x_39)) {
-    j = 0;
-    {
-      for(; true; const float3 x_46 = mand_()) {
-      }
-    }
-  }
-  x_GLF_color = float4(1.0f, 0.0f, 0.0f, 1.0f);
-  return;
-}
-
-struct main_out {
-  float4 x_GLF_color_1;
-};
-struct tint_symbol {
-  float4 x_GLF_color_1 : SV_Target0;
-};
-
-tint_symbol main() {
-  main_1();
-  const main_out tint_symbol_1 = {x_GLF_color};
-  const tint_symbol tint_symbol_3 = {tint_symbol_1.x_GLF_color_1};
-  return tint_symbol_3;
-}
-C:\src\tint\test\Shader@0x000001DB32C08F00(26,19-23): error X3000: syntax error: unexpected token 'const'
-C:\src\tint\test\Shader@0x000001DB32C08F00(41,17): error X3000: syntax error: unexpected token '('
-C:\src\tint\test\Shader@0x000001DB32C08F00(45,3-23): error X3079: 'main_1': void functions cannot return a value
-
diff --git a/test/vk-gl-cts/graphicsfuzz/unreachable-discard-statement/0.spvasm b/test/vk-gl-cts/graphicsfuzz/unreachable-discard-statement/0.spvasm
deleted file mode 100644
index f051a44..0000000
--- a/test/vk-gl-cts/graphicsfuzz/unreachable-discard-statement/0.spvasm
+++ /dev/null
@@ -1,94 +0,0 @@
-               OpCapability Shader
-          %1 = OpExtInstImport "GLSL.std.450"
-               OpMemoryModel Logical GLSL450
-               OpEntryPoint Fragment %main "main" %_GLF_color
-               OpExecutionMode %main OriginUpperLeft
-               OpSource ESSL 310
-               OpName %main "main"
-               OpName %mand_ "mand("
-               OpName %k "k"
-               OpName %_GLF_color "_GLF_color"
-               OpName %i "i"
-               OpDecorate %k RelaxedPrecision
-               OpDecorate %7 RelaxedPrecision
-               OpDecorate %_GLF_color Location 0
-               OpDecorate %i RelaxedPrecision
-               OpDecorate %8 RelaxedPrecision
-               OpDecorate %9 RelaxedPrecision
-               OpDecorate %10 RelaxedPrecision
-       %void = OpTypeVoid
-         %12 = OpTypeFunction %void
-      %float = OpTypeFloat 32
-    %v3float = OpTypeVector %float 3
-         %15 = OpTypeFunction %v3float
-        %int = OpTypeInt 32 1
-%_ptr_Function_int = OpTypePointer Function %int
-      %int_0 = OpConstant %int 0
-   %int_1000 = OpConstant %int 1000
-       %bool = OpTypeBool
-    %float_1 = OpConstant %float 1
-         %22 = OpConstantComposite %v3float %float_1 %float_1 %float_1
-      %int_1 = OpConstant %int 1
-    %v4float = OpTypeVector %float 4
-%_ptr_Output_v4float = OpTypePointer Output %v4float
- %_GLF_color = OpVariable %_ptr_Output_v4float Output
-    %float_0 = OpConstant %float 0
-         %27 = OpConstantComposite %v4float %float_1 %float_0 %float_0 %float_1
-      %int_4 = OpConstant %int 4
-%_ptr_Function_v3float = OpTypePointer Function %v3float
-      %false = OpConstantFalse %bool
-%_ptr_Function_bool = OpTypePointer Function %bool
-       %true = OpConstantTrue %bool
-       %main = OpFunction %void None %12
-         %33 = OpLabel
-          %i = OpVariable %_ptr_Function_int Function
-               OpStore %_GLF_color %27
-               OpStore %i %int_0
-               OpBranch %34
-         %34 = OpLabel
-          %8 = OpLoad %int %i
-         %35 = OpSLessThan %bool %8 %int_4
-               OpLoopMerge %36 %37 None
-               OpBranchConditional %35 %37 %36
-         %37 = OpLabel
-         %38 = OpFunctionCall %v3float %mand_
-          %9 = OpLoad %int %i
-         %10 = OpIAdd %int %9 %int_1
-               OpStore %i %10
-               OpBranch %34
-         %36 = OpLabel
-               OpReturn
-               OpFunctionEnd
-      %mand_ = OpFunction %v3float None %15
-         %39 = OpLabel
-         %40 = OpVariable %_ptr_Function_bool Function %false
-         %41 = OpVariable %_ptr_Function_v3float Function
-          %k = OpVariable %_ptr_Function_int Function
-               OpBranch %42
-         %42 = OpLabel
-               OpStore %k %int_0
-               OpLoopMerge %43 %44 None
-               OpBranch %45
-         %45 = OpLabel
-          %7 = OpLoad %int %k
-         %46 = OpSLessThan %bool %7 %int_1000
-               OpLoopMerge %47 %48 None
-               OpBranchConditional %46 %49 %47
-         %49 = OpLabel
-               OpStore %40 %true
-               OpStore %41 %22
-               OpBranch %47
-         %48 = OpLabel
-               OpBranch %45
-         %47 = OpLabel
-         %50 = OpLoad %bool %40
-               OpSelectionMerge %51 None
-               OpBranchConditional %50 %43 %51
-         %51 = OpLabel
-               OpKill
-         %44 = OpLabel
-               OpBranch %42
-         %43 = OpLabel
-         %52 = OpLoad %v3float %41
-               OpReturnValue %52
-               OpFunctionEnd
diff --git a/test/vk-gl-cts/graphicsfuzz/unreachable-discard-statement/0.wgsl b/test/vk-gl-cts/graphicsfuzz/unreachable-discard-statement/0.wgsl
deleted file mode 100644
index 5ad0b89..0000000
--- a/test/vk-gl-cts/graphicsfuzz/unreachable-discard-statement/0.wgsl
+++ /dev/null
@@ -1,58 +0,0 @@
-var<private> x_GLF_color : vec4<f32>;
-
-fn mand_() -> vec3<f32> {
-  var x_40 : bool = false;
-  var x_41 : vec3<f32>;
-  var k : i32;
-  loop {
-    k = 0;
-    loop {
-      let x_7 : i32 = k;
-      if ((x_7 < 1000)) {
-      } else {
-        break;
-      }
-      x_40 = true;
-      x_41 = vec3<f32>(1.0, 1.0, 1.0);
-      break;
-    }
-    let x_50 : bool = x_40;
-    if (x_50) {
-      break;
-    }
-    discard;
-  }
-  let x_52 : vec3<f32> = x_41;
-  return x_52;
-}
-
-fn main_1() {
-  var i : i32;
-  x_GLF_color = vec4<f32>(1.0, 0.0, 0.0, 1.0);
-  i = 0;
-  loop {
-    let x_8 : i32 = i;
-    if ((x_8 < 4)) {
-    } else {
-      break;
-    }
-
-    continuing {
-      let x_38 : vec3<f32> = mand_();
-      let x_9 : i32 = i;
-      i = (x_9 + 1);
-    }
-  }
-  return;
-}
-
-struct main_out {
-  [[location(0)]]
-  x_GLF_color_1 : vec4<f32>;
-};
-
-[[stage(fragment)]]
-fn main() -> main_out {
-  main_1();
-  return main_out(x_GLF_color);
-}