diff --git a/src/tint/reader/spirv/function.cc b/src/tint/reader/spirv/function.cc
index fe32d35..9c16094 100644
--- a/src/tint/reader/spirv/function.cc
+++ b/src/tint/reader/spirv/function.cc
@@ -1125,7 +1125,7 @@
   // Recursively flatten matrices, arrays, and structures.
   return Switch(
       tip_type,
-      [&](const Matrix* matrix_type) -> bool {
+      [&](const Matrix* matrix_type) {
         index_prefix.push_back(0);
         const auto num_columns = static_cast<int>(matrix_type->columns);
         const Type* vec_ty = ty_.Vector(matrix_type->type, matrix_type->rows);
diff --git a/src/tint/resolver/resolver.cc b/src/tint/resolver/resolver.cc
index 42f8cb1..d7c13a6 100644
--- a/src/tint/resolver/resolver.cc
+++ b/src/tint/resolver/resolver.cc
@@ -121,20 +121,14 @@
   for (auto* decl : dependencies_.ordered_globals) {
     Mark(decl);
     if (!Switch(
-            decl,                           //
-            [&](const ast::TypeDecl* td) {  //
-              return TypeDecl(td) != nullptr;
-            },
-            [&](const ast::Function* func) {
-              return Function(func) != nullptr;
-            },
-            [&](const ast::Variable* var) {
-              return GlobalVariable(var) != nullptr;
-            },
+            decl,  //
+            [&](const ast::TypeDecl* td) { return TypeDecl(td); },
+            [&](const ast::Function* func) { return Function(func); },
+            [&](const ast::Variable* var) { return GlobalVariable(var); },
             [&](Default) {
               TINT_UNREACHABLE(Resolver, diagnostics_)
                   << "unhandled global declaration: " << decl->TypeInfo().name;
-              return false;
+              return nullptr;
             })) {
       return false;
     }
@@ -165,23 +159,13 @@
 sem::Type* Resolver::Type(const ast::Type* ty) {
   Mark(ty);
   auto* s = Switch(
-      ty,
-      [&](const ast::Void*) -> sem::Type* {
-        return builder_->create<sem::Void>();
-      },
-      [&](const ast::Bool*) -> sem::Type* {
-        return builder_->create<sem::Bool>();
-      },
-      [&](const ast::I32*) -> sem::Type* {
-        return builder_->create<sem::I32>();
-      },
-      [&](const ast::U32*) -> sem::Type* {
-        return builder_->create<sem::U32>();
-      },
-      [&](const ast::F32*) -> sem::Type* {
-        return builder_->create<sem::F32>();
-      },
-      [&](const ast::Vector* t) -> sem::Type* {
+      ty,  //
+      [&](const ast::Void*) { return builder_->create<sem::Void>(); },
+      [&](const ast::Bool*) { return builder_->create<sem::Bool>(); },
+      [&](const ast::I32*) { return builder_->create<sem::I32>(); },
+      [&](const ast::U32*) { return builder_->create<sem::U32>(); },
+      [&](const ast::F32*) { return builder_->create<sem::F32>(); },
+      [&](const ast::Vector* t) -> sem::Vector* {
         if (!t->type) {
           AddError("missing vector element type", t->source.End());
           return nullptr;
@@ -195,7 +179,7 @@
         }
         return nullptr;
       },
-      [&](const ast::Matrix* t) -> sem::Type* {
+      [&](const ast::Matrix* t) -> sem::Matrix* {
         if (!t->type) {
           AddError("missing matrix element type", t->source.End());
           return nullptr;
@@ -212,8 +196,8 @@
         }
         return nullptr;
       },
-      [&](const ast::Array* t) -> sem::Type* { return Array(t); },
-      [&](const ast::Atomic* t) -> sem::Type* {
+      [&](const ast::Array* t) { return Array(t); },
+      [&](const ast::Atomic* t) -> sem::Atomic* {
         if (auto* el = Type(t->type)) {
           auto* a = builder_->create<sem::Atomic>(el);
           if (!ValidateAtomic(t, a)) {
@@ -223,7 +207,7 @@
         }
         return nullptr;
       },
-      [&](const ast::Pointer* t) -> sem::Type* {
+      [&](const ast::Pointer* t) -> sem::Pointer* {
         if (auto* el = Type(t->type)) {
           auto access = t->access;
           if (access == ast::kUndefined) {
@@ -233,28 +217,28 @@
         }
         return nullptr;
       },
-      [&](const ast::Sampler* t) -> sem::Type* {
+      [&](const ast::Sampler* t) {
         return builder_->create<sem::Sampler>(t->kind);
       },
-      [&](const ast::SampledTexture* t) -> sem::Type* {
+      [&](const ast::SampledTexture* t) -> sem::SampledTexture* {
         if (auto* el = Type(t->type)) {
           return builder_->create<sem::SampledTexture>(t->dim, el);
         }
         return nullptr;
       },
-      [&](const ast::MultisampledTexture* t) -> sem::Type* {
+      [&](const ast::MultisampledTexture* t) -> sem::MultisampledTexture* {
         if (auto* el = Type(t->type)) {
           return builder_->create<sem::MultisampledTexture>(t->dim, el);
         }
         return nullptr;
       },
-      [&](const ast::DepthTexture* t) -> sem::Type* {
+      [&](const ast::DepthTexture* t) {
         return builder_->create<sem::DepthTexture>(t->dim);
       },
-      [&](const ast::DepthMultisampledTexture* t) -> sem::Type* {
+      [&](const ast::DepthMultisampledTexture* t) {
         return builder_->create<sem::DepthMultisampledTexture>(t->dim);
       },
-      [&](const ast::StorageTexture* t) -> sem::Type* {
+      [&](const ast::StorageTexture* t) -> sem::StorageTexture* {
         if (auto* el = Type(t->type)) {
           if (!ValidateStorageTexture(t)) {
             return nullptr;
@@ -264,10 +248,10 @@
         }
         return nullptr;
       },
-      [&](const ast::ExternalTexture*) -> sem::Type* {
+      [&](const ast::ExternalTexture*) {
         return builder_->create<sem::ExternalTexture>();
       },
-      [&](Default) -> sem::Type* {
+      [&](Default) {
         auto* resolved = ResolvedSymbol(ty);
         return Switch(
             resolved,  //
@@ -858,62 +842,40 @@
       stmt,
       // Compound statements. These create their own sem::CompoundStatement
       // bindings.
-      [&](const ast::BlockStatement* b) -> sem::Statement* {
-        return BlockStatement(b);
-      },
-      [&](const ast::ForLoopStatement* l) -> sem::Statement* {
-        return ForLoopStatement(l);
-      },
-      [&](const ast::LoopStatement* l) -> sem::Statement* {
-        return LoopStatement(l);
-      },
-      [&](const ast::IfStatement* i) -> sem::Statement* {
-        return IfStatement(i);
-      },
-      [&](const ast::SwitchStatement* s) -> sem::Statement* {
-        return SwitchStatement(s);
-      },
+      [&](const ast::BlockStatement* b) { return BlockStatement(b); },
+      [&](const ast::ForLoopStatement* l) { return ForLoopStatement(l); },
+      [&](const ast::LoopStatement* l) { return LoopStatement(l); },
+      [&](const ast::IfStatement* i) { return IfStatement(i); },
+      [&](const ast::SwitchStatement* s) { return SwitchStatement(s); },
 
       // Non-Compound statements
-      [&](const ast::AssignmentStatement* a) -> sem::Statement* {
-        return AssignmentStatement(a);
-      },
-      [&](const ast::BreakStatement* b) -> sem::Statement* {
-        return BreakStatement(b);
-      },
-      [&](const ast::CallStatement* c) -> sem::Statement* {
-        return CallStatement(c);
-      },
-      [&](const ast::ContinueStatement* c) -> sem::Statement* {
-        return ContinueStatement(c);
-      },
-      [&](const ast::DiscardStatement* d) -> sem::Statement* {
-        return DiscardStatement(d);
-      },
-      [&](const ast::FallthroughStatement* f) -> sem::Statement* {
+      [&](const ast::AssignmentStatement* a) { return AssignmentStatement(a); },
+      [&](const ast::BreakStatement* b) { return BreakStatement(b); },
+      [&](const ast::CallStatement* c) { return CallStatement(c); },
+      [&](const ast::ContinueStatement* c) { return ContinueStatement(c); },
+      [&](const ast::DiscardStatement* d) { return DiscardStatement(d); },
+      [&](const ast::FallthroughStatement* f) {
         return FallthroughStatement(f);
       },
-      [&](const ast::ReturnStatement* r) -> sem::Statement* {
-        return ReturnStatement(r);
-      },
-      [&](const ast::VariableDeclStatement* v) -> sem::Statement* {
+      [&](const ast::ReturnStatement* r) { return ReturnStatement(r); },
+      [&](const ast::VariableDeclStatement* v) {
         return VariableDeclStatement(v);
       },
 
       // Error cases
-      [&](const ast::CaseStatement*) -> sem::Statement* {
+      [&](const ast::CaseStatement*) {
         AddError("case statement can only be used inside a switch statement",
                  stmt->source);
         return nullptr;
       },
-      [&](const ast::ElseStatement*) -> sem::Statement* {
+      [&](const ast::ElseStatement*) {
         TINT_ICE(Resolver, diagnostics_)
             << "Resolver::Statement() encountered an Else statement. Else "
                "statements are embedded in If statements, so should never be "
                "encountered as top-level statements";
         return nullptr;
       },
-      [&](Default) -> sem::Statement* {
+      [&](Default) {
         AddError(
             "unknown statement type: " + std::string(stmt->TypeInfo().name),
             stmt->source);
@@ -1196,16 +1158,12 @@
   auto* obj_ty = obj_raw_ty->UnwrapRef();
   auto* ty = Switch(
       obj_ty,  //
-      [&](const sem::Array* arr) -> const sem::Type* {
-        return arr->ElemType();
-      },
-      [&](const sem::Vector* vec) -> const sem::Type* {  //
-        return vec->type();
-      },
-      [&](const sem::Matrix* mat) -> const sem::Type* {
+      [&](const sem::Array* arr) { return arr->ElemType(); },
+      [&](const sem::Vector* vec) { return vec->type(); },
+      [&](const sem::Matrix* mat) {
         return builder_->create<sem::Vector>(mat->type(), mat->rows());
       },
-      [&](Default) -> const sem::Type* {
+      [&](Default) {
         AddError("cannot index type '" + TypeNameOf(obj_ty) + "'",
                  expr->source);
         return nullptr;
@@ -2188,19 +2146,19 @@
 sem::Type* Resolver::TypeOf(const ast::LiteralExpression* lit) {
   return Switch(
       lit,
-      [&](const ast::SintLiteralExpression*) -> sem::Type* {
+      [&](const ast::SintLiteralExpression*) {
         return builder_->create<sem::I32>();
       },
-      [&](const ast::UintLiteralExpression*) -> sem::Type* {
+      [&](const ast::UintLiteralExpression*) {
         return builder_->create<sem::U32>();
       },
-      [&](const ast::FloatLiteralExpression*) -> sem::Type* {
+      [&](const ast::FloatLiteralExpression*) {
         return builder_->create<sem::F32>();
       },
-      [&](const ast::BoolLiteralExpression*) -> sem::Type* {
+      [&](const ast::BoolLiteralExpression*) {
         return builder_->create<sem::Bool>();
       },
-      [&](Default) -> sem::Type* {
+      [&](Default) {
         TINT_UNREACHABLE(Resolver, diagnostics_)
             << "Unhandled literal type: " << lit->TypeInfo().name;
         return nullptr;
diff --git a/src/tint/writer/spirv/builder.cc b/src/tint/writer/spirv/builder.cc
index 83f2666..0f0623e 100644
--- a/src/tint/writer/spirv/builder.cc
+++ b/src/tint/writer/spirv/builder.cc
@@ -575,31 +575,29 @@
 uint32_t Builder::GenerateExpression(const ast::Expression* expr) {
   return Switch(
       expr,
-      [&](const ast::IndexAccessorExpression* a) {  //
+      [&](const ast::IndexAccessorExpression* a) {
         return GenerateAccessorExpression(a);
       },
-      [&](const ast::BinaryExpression* b) {  //
+      [&](const ast::BinaryExpression* b) {
         return GenerateBinaryExpression(b);
       },
-      [&](const ast::BitcastExpression* b) {  //
+      [&](const ast::BitcastExpression* b) {
         return GenerateBitcastExpression(b);
       },
-      [&](const ast::CallExpression* c) {  //
-        return GenerateCallExpression(c);
-      },
-      [&](const ast::IdentifierExpression* i) {  //
+      [&](const ast::CallExpression* c) { return GenerateCallExpression(c); },
+      [&](const ast::IdentifierExpression* i) {
         return GenerateIdentifierExpression(i);
       },
-      [&](const ast::LiteralExpression* l) {  //
+      [&](const ast::LiteralExpression* l) {
         return GenerateLiteralIfNeeded(nullptr, l);
       },
-      [&](const ast::MemberAccessorExpression* m) {  //
+      [&](const ast::MemberAccessorExpression* m) {
         return GenerateAccessorExpression(m);
       },
-      [&](const ast::UnaryOpExpression* u) {  //
+      [&](const ast::UnaryOpExpression* u) {
         return GenerateUnaryOpExpression(u);
       },
-      [&](Default) -> uint32_t {
+      [&](Default) {
         error_ =
             "unknown expression type: " + std::string(expr->TypeInfo().name);
         return 0;
@@ -2271,7 +2269,7 @@
       [&](const sem::TypeConstructor*) {
         return GenerateTypeConstructorOrConversion(call, nullptr);
       },
-      [&](Default) -> uint32_t {
+      [&](Default) {
         TINT_ICE(Writer, builder_.Diagnostics())
             << "unhandled call target: " << target->TypeInfo().name;
         return 0;
@@ -4101,7 +4099,7 @@
       [&](const sem::StorageTexture* t) {
         return GenerateTypeIfNeeded(t->type());
       },
-      [&](Default) -> uint32_t {  //
+      [&](Default)  {
         return 0u;
       });
   if (type_id == 0u) {