diff --git a/src/ast/access_control_test.cc b/src/ast/access_control_test.cc
index c03d833d7c..54ad8cc392 100644
--- a/src/ast/access_control_test.cc
+++ b/src/ast/access_control_test.cc
@@ -41,24 +41,6 @@ TEST_F(AstAccessControlTest, Create) {
   EXPECT_EQ(a->type(), u32);
 }
 
-TEST_F(AstAccessControlTest, Is) {
-  auto* i32 = create<I32>();
-  Type* ty = create<AccessControl>(AccessControl::kReadOnly, i32);
-  EXPECT_TRUE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Alias>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(AstAccessControlTest, AccessRead) {
   auto* i32 = create<I32>();
   auto* ac = create<AccessControl>(AccessControl::kReadOnly, i32);
diff --git a/src/ast/access_decoration_test.cc b/src/ast/access_decoration_test.cc
index 7fde9f7c44..f22456390a 100644
--- a/src/ast/access_decoration_test.cc
+++ b/src/ast/access_decoration_test.cc
@@ -27,11 +27,6 @@ TEST_F(AccessDecorationTest, Creation) {
   EXPECT_EQ(ast::AccessControl::kWriteOnly, d->value());
 }
 
-TEST_F(AccessDecorationTest, Is) {
-  auto* d = create<AccessDecoration>(ast::AccessControl::kReadWrite);
-  EXPECT_TRUE(d->Is<ast::AccessDecoration>());
-}
-
 TEST_F(AccessDecorationTest, ToStr) {
   auto* d = create<AccessDecoration>(ast::AccessControl::kReadOnly);
   EXPECT_EQ(str(d), R"(AccessDecoration{read_only}
diff --git a/src/ast/alias_test.cc b/src/ast/alias_test.cc
index 751b9b29a8..b6dc0f3a2c 100644
--- a/src/ast/alias_test.cc
+++ b/src/ast/alias_test.cc
@@ -40,23 +40,6 @@ TEST_F(AstAliasTest, Create) {
   EXPECT_EQ(a->type(), u32);
 }
 
-TEST_F(AstAliasTest, Is) {
-  Type* ty = create<Alias>(Sym("a"), create<I32>());
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_TRUE(ty->Is<Alias>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 // Check for linear-time evaluation of Alias::type_name().
 // If type_name() is non-linear, this test should noticeably stall.
 // See: crbug.com/1200936
diff --git a/src/ast/array_test.cc b/src/ast/array_test.cc
index 9619bdf52f..dac15429de 100644
--- a/src/ast/array_test.cc
+++ b/src/ast/array_test.cc
@@ -51,24 +51,6 @@ TEST_F(AstArrayTest, CreateRuntimeArray) {
   EXPECT_TRUE(arr->IsRuntimeArray());
 }
 
-TEST_F(AstArrayTest, Is) {
-  auto* i32 = create<I32>();
-  Type* ty = create<Array>(i32, 3, DecorationList{});
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Alias>());
-  EXPECT_TRUE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(AstArrayTest, TypeName) {
   auto* i32 = create<I32>();
   auto* arr = create<Array>(i32, 0, DecorationList{});
diff --git a/src/ast/binding_decoration_test.cc b/src/ast/binding_decoration_test.cc
index 4b4b29f715..d9db97f310 100644
--- a/src/ast/binding_decoration_test.cc
+++ b/src/ast/binding_decoration_test.cc
@@ -26,15 +26,6 @@ TEST_F(BindingDecorationTest, Creation) {
   EXPECT_EQ(2u, d->value());
 }
 
-TEST_F(BindingDecorationTest, Is) {
-  Decoration* d = create<BindingDecoration>(2);
-  EXPECT_TRUE(d->Is<BindingDecoration>());
-  EXPECT_FALSE(d->Is<BuiltinDecoration>());
-  EXPECT_FALSE(d->Is<OverrideDecoration>());
-  EXPECT_FALSE(d->Is<LocationDecoration>());
-  EXPECT_FALSE(d->Is<GroupDecoration>());
-}
-
 TEST_F(BindingDecorationTest, ToStr) {
   auto* d = create<BindingDecoration>(2);
   EXPECT_EQ(str(d), R"(BindingDecoration{2}
diff --git a/src/ast/bool_literal_test.cc b/src/ast/bool_literal_test.cc
index caf8636b34..e5cc3138d8 100644
--- a/src/ast/bool_literal_test.cc
+++ b/src/ast/bool_literal_test.cc
@@ -34,15 +34,6 @@ TEST_F(BoolLiteralTest, False) {
   ASSERT_TRUE(b->IsFalse());
 }
 
-TEST_F(BoolLiteralTest, Is) {
-  ast::Literal* l = create<BoolLiteral>(false);
-  EXPECT_TRUE(l->Is<BoolLiteral>());
-  EXPECT_FALSE(l->Is<SintLiteral>());
-  EXPECT_FALSE(l->Is<FloatLiteral>());
-  EXPECT_FALSE(l->Is<UintLiteral>());
-  EXPECT_FALSE(l->Is<IntLiteral>());
-}
-
 TEST_F(BoolLiteralTest, ToStr) {
   auto* t = create<BoolLiteral>(true);
   auto* f = create<BoolLiteral>(false);
diff --git a/src/ast/bool_test.cc b/src/ast/bool_test.cc
index 3d2b2a8117..d1668c7ace 100644
--- a/src/ast/bool_test.cc
+++ b/src/ast/bool_test.cc
@@ -33,23 +33,6 @@ namespace {
 
 using AstBoolTest = TestHelper;
 
-TEST_F(AstBoolTest, Is) {
-  Type* ty = create<Bool>();
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Alias>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_TRUE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(AstBoolTest, TypeName) {
   auto* b = create<Bool>();
   EXPECT_EQ(b->type_name(), "__bool");
diff --git a/src/ast/builtin_decoration_test.cc b/src/ast/builtin_decoration_test.cc
index e11b231292..4d71482a42 100644
--- a/src/ast/builtin_decoration_test.cc
+++ b/src/ast/builtin_decoration_test.cc
@@ -26,15 +26,6 @@ TEST_F(BuiltinDecorationTest, Creation) {
   EXPECT_EQ(Builtin::kFragDepth, d->value());
 }
 
-TEST_F(BuiltinDecorationTest, Is) {
-  Decoration* d = create<BuiltinDecoration>(Builtin::kFragDepth);
-  EXPECT_FALSE(d->Is<BindingDecoration>());
-  EXPECT_TRUE(d->Is<BuiltinDecoration>());
-  EXPECT_FALSE(d->Is<OverrideDecoration>());
-  EXPECT_FALSE(d->Is<LocationDecoration>());
-  EXPECT_FALSE(d->Is<GroupDecoration>());
-}
-
 TEST_F(BuiltinDecorationTest, ToStr) {
   auto* d = create<BuiltinDecoration>(Builtin::kFragDepth);
   EXPECT_EQ(str(d), R"(BuiltinDecoration{frag_depth}
diff --git a/src/ast/depth_texture_test.cc b/src/ast/depth_texture_test.cc
index a682d9bbf5..a018e4a71e 100644
--- a/src/ast/depth_texture_test.cc
+++ b/src/ast/depth_texture_test.cc
@@ -36,23 +36,6 @@ namespace {
 
 using AstDepthTextureTest = TestHelper;
 
-TEST_F(AstDepthTextureTest, Is) {
-  Type* ty = create<DepthTexture>(TextureDimension::kCube);
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Alias>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_TRUE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(AstDepthTextureTest, IsTexture) {
   Texture* ty = create<DepthTexture>(TextureDimension::kCube);
   EXPECT_TRUE(ty->Is<DepthTexture>());
diff --git a/src/ast/external_texture_test.cc b/src/ast/external_texture_test.cc
index 803e626a20..b8d75d1d38 100644
--- a/src/ast/external_texture_test.cc
+++ b/src/ast/external_texture_test.cc
@@ -37,23 +37,6 @@ namespace {
 
 using AstExternalTextureTest = TestHelper;
 
-TEST_F(AstExternalTextureTest, Is) {
-  Type* ty = create<ExternalTexture>();
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Alias>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_TRUE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(AstExternalTextureTest, IsTexture) {
   Texture* ty = create<ExternalTexture>();
   EXPECT_FALSE(ty->Is<DepthTexture>());
diff --git a/src/ast/f32_test.cc b/src/ast/f32_test.cc
index 2045d832da..220af9d086 100644
--- a/src/ast/f32_test.cc
+++ b/src/ast/f32_test.cc
@@ -33,23 +33,6 @@ namespace {
 
 using AstF32Test = TestHelper;
 
-TEST_F(AstF32Test, Is) {
-  Type* ty = create<F32>();
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Alias>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_TRUE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(AstF32Test, TypeName) {
   auto* f = create<F32>();
   EXPECT_EQ(f->type_name(), "__f32");
diff --git a/src/ast/float_literal_test.cc b/src/ast/float_literal_test.cc
index 17988bf807..e1e0498c38 100644
--- a/src/ast/float_literal_test.cc
+++ b/src/ast/float_literal_test.cc
@@ -26,15 +26,6 @@ TEST_F(FloatLiteralTest, Value) {
   EXPECT_EQ(f->value(), 47.2f);
 }
 
-TEST_F(FloatLiteralTest, Is) {
-  ast::Literal* l = create<FloatLiteral>(42.f);
-  EXPECT_FALSE(l->Is<BoolLiteral>());
-  EXPECT_FALSE(l->Is<SintLiteral>());
-  EXPECT_FALSE(l->Is<IntLiteral>());
-  EXPECT_TRUE(l->Is<FloatLiteral>());
-  EXPECT_FALSE(l->Is<UintLiteral>());
-}
-
 TEST_F(FloatLiteralTest, ToStr) {
   auto* f = create<FloatLiteral>(42.1f);
   EXPECT_EQ(str(f), "42.099998");
diff --git a/src/ast/group_decoration_test.cc b/src/ast/group_decoration_test.cc
index 79999c1dd9..ec3327f4f9 100644
--- a/src/ast/group_decoration_test.cc
+++ b/src/ast/group_decoration_test.cc
@@ -26,14 +26,6 @@ TEST_F(GroupDecorationTest, Creation) {
   EXPECT_EQ(2u, d->value());
 }
 
-TEST_F(GroupDecorationTest, Is) {
-  Decoration* d = create<GroupDecoration>(2);
-  EXPECT_FALSE(d->Is<BindingDecoration>());
-  EXPECT_FALSE(d->Is<BuiltinDecoration>());
-  EXPECT_FALSE(d->Is<OverrideDecoration>());
-  EXPECT_FALSE(d->Is<LocationDecoration>());
-  EXPECT_TRUE(d->Is<GroupDecoration>());
-}
 
 TEST_F(GroupDecorationTest, ToStr) {
   auto* d = create<GroupDecoration>(2);
diff --git a/src/ast/i32_test.cc b/src/ast/i32_test.cc
index 7a8570796f..5f1ae0a21f 100644
--- a/src/ast/i32_test.cc
+++ b/src/ast/i32_test.cc
@@ -34,23 +34,6 @@ namespace {
 
 using AstI32Test = TestHelper;
 
-TEST_F(AstI32Test, Is) {
-  Type* ty = create<I32>();
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Alias>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_TRUE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(AstI32Test, TypeName) {
   auto* i = create<I32>();
   EXPECT_EQ(i->type_name(), "__i32");
diff --git a/src/ast/location_decoration_test.cc b/src/ast/location_decoration_test.cc
index 3b72d7527e..706b958180 100644
--- a/src/ast/location_decoration_test.cc
+++ b/src/ast/location_decoration_test.cc
@@ -26,15 +26,6 @@ TEST_F(LocationDecorationTest, Creation) {
   EXPECT_EQ(2u, d->value());
 }
 
-TEST_F(LocationDecorationTest, Is) {
-  Decoration* d = create<LocationDecoration>(2);
-  EXPECT_FALSE(d->Is<BindingDecoration>());
-  EXPECT_FALSE(d->Is<BuiltinDecoration>());
-  EXPECT_FALSE(d->Is<OverrideDecoration>());
-  EXPECT_TRUE(d->Is<LocationDecoration>());
-  EXPECT_FALSE(d->Is<GroupDecoration>());
-}
-
 TEST_F(LocationDecorationTest, ToStr) {
   auto* d = create<LocationDecoration>(2);
   EXPECT_EQ(str(d), R"(LocationDecoration{2}
diff --git a/src/ast/matrix_test.cc b/src/ast/matrix_test.cc
index fc5e40b5c7..38b5f23aeb 100644
--- a/src/ast/matrix_test.cc
+++ b/src/ast/matrix_test.cc
@@ -41,24 +41,6 @@ TEST_F(AstMatrixTest, Creation) {
   EXPECT_EQ(m->columns(), 4u);
 }
 
-TEST_F(AstMatrixTest, Is) {
-  auto* i32 = create<I32>();
-  Type* ty = create<Matrix>(i32, 2, 3);
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Alias>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_TRUE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(AstMatrixTest, TypeName) {
   auto* i32 = create<I32>();
   auto* m = create<Matrix>(i32, 2, 3);
diff --git a/src/ast/multisampled_texture_test.cc b/src/ast/multisampled_texture_test.cc
index 277c25a283..a4c55d9b2e 100644
--- a/src/ast/multisampled_texture_test.cc
+++ b/src/ast/multisampled_texture_test.cc
@@ -38,24 +38,6 @@ namespace {
 
 using AstMultisampledTextureTest = TestHelper;
 
-TEST_F(AstMultisampledTextureTest, Is) {
-  auto* f32 = create<F32>();
-  Type* ty = create<MultisampledTexture>(TextureDimension::kCube, f32);
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Alias>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_TRUE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(AstMultisampledTextureTest, IsTexture) {
   auto* f32 = create<F32>();
   Texture* ty = create<MultisampledTexture>(TextureDimension::kCube, f32);
diff --git a/src/ast/override_decoration_test.cc b/src/ast/override_decoration_test.cc
index b5529cfd41..078563c7d8 100644
--- a/src/ast/override_decoration_test.cc
+++ b/src/ast/override_decoration_test.cc
@@ -27,15 +27,6 @@ TEST_F(OverrideDecorationTest, Creation) {
   EXPECT_EQ(12u, d->value());
 }
 
-TEST_F(OverrideDecorationTest, Is) {
-  Decoration* d = create<OverrideDecoration>(27);
-  EXPECT_FALSE(d->Is<BindingDecoration>());
-  EXPECT_FALSE(d->Is<BuiltinDecoration>());
-  EXPECT_TRUE(d->Is<OverrideDecoration>());
-  EXPECT_FALSE(d->Is<LocationDecoration>());
-  EXPECT_FALSE(d->Is<GroupDecoration>());
-}
-
 TEST_F(OverrideDecorationTest, ToStr) {
   auto* d = create<OverrideDecoration>(1200);
   EXPECT_EQ(str(d), R"(OverrideDecoration{1200}
diff --git a/src/ast/pointer_test.cc b/src/ast/pointer_test.cc
index 9e11d2e6ff..6d0104f282 100644
--- a/src/ast/pointer_test.cc
+++ b/src/ast/pointer_test.cc
@@ -40,24 +40,6 @@ TEST_F(AstPointerTest, Creation) {
   EXPECT_EQ(p->storage_class(), ast::StorageClass::kStorage);
 }
 
-TEST_F(AstPointerTest, Is) {
-  auto* i32 = create<I32>();
-  Type* ty = create<Pointer>(i32, ast::StorageClass::kFunction);
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Alias>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_TRUE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(AstPointerTest, TypeName) {
   auto* i32 = create<I32>();
   auto* p = create<Pointer>(i32, ast::StorageClass::kWorkgroup);
diff --git a/src/ast/sampled_texture_test.cc b/src/ast/sampled_texture_test.cc
index 4cba040bfa..6c94c0cd69 100644
--- a/src/ast/sampled_texture_test.cc
+++ b/src/ast/sampled_texture_test.cc
@@ -37,24 +37,6 @@ namespace {
 
 using AstSampledTextureTest = TestHelper;
 
-TEST_F(AstSampledTextureTest, Is) {
-  auto* f32 = create<F32>();
-  Type* ty = create<SampledTexture>(TextureDimension::kCube, f32);
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Alias>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_TRUE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(AstSampledTextureTest, IsTexture) {
   auto* f32 = create<F32>();
   Texture* ty = create<SampledTexture>(TextureDimension::kCube, f32);
diff --git a/src/ast/sampler_test.cc b/src/ast/sampler_test.cc
index 9ddf1fe43d..339e6fa07c 100644
--- a/src/ast/sampler_test.cc
+++ b/src/ast/sampler_test.cc
@@ -44,23 +44,6 @@ TEST_F(AstSamplerTest, Creation_ComparisonSampler) {
   EXPECT_TRUE(s->IsComparison());
 }
 
-TEST_F(AstSamplerTest, Is) {
-  Type* ty = create<Sampler>(SamplerKind::kSampler);
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Alias>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_TRUE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(AstSamplerTest, TypeName_Sampler) {
   auto* s = create<Sampler>(SamplerKind::kSampler);
   EXPECT_EQ(s->type_name(), "__sampler_sampler");
diff --git a/src/ast/sint_literal_test.cc b/src/ast/sint_literal_test.cc
index d7a6bb2747..8843105da0 100644
--- a/src/ast/sint_literal_test.cc
+++ b/src/ast/sint_literal_test.cc
@@ -26,14 +26,6 @@ TEST_F(SintLiteralTest, Value) {
   EXPECT_EQ(i->value(), 47);
 }
 
-TEST_F(SintLiteralTest, Is) {
-  ast::Literal* l = create<SintLiteral>(42);
-  EXPECT_FALSE(l->Is<BoolLiteral>());
-  EXPECT_TRUE(l->Is<SintLiteral>());
-  EXPECT_FALSE(l->Is<FloatLiteral>());
-  EXPECT_FALSE(l->Is<UintLiteral>());
-}
-
 TEST_F(SintLiteralTest, ToStr) {
   auto* i = create<SintLiteral>(-42);
   EXPECT_EQ(str(i), "-42");
diff --git a/src/ast/stage_decoration_test.cc b/src/ast/stage_decoration_test.cc
index ba1efa3d3c..11c807700c 100644
--- a/src/ast/stage_decoration_test.cc
+++ b/src/ast/stage_decoration_test.cc
@@ -28,12 +28,6 @@ TEST_F(StageDecorationTest, Creation_1param) {
   EXPECT_EQ(d->value(), PipelineStage::kFragment);
 }
 
-TEST_F(StageDecorationTest, Is) {
-  Decoration* d = create<StageDecoration>(PipelineStage::kFragment);
-  EXPECT_FALSE(d->Is<WorkgroupDecoration>());
-  EXPECT_TRUE(d->Is<StageDecoration>());
-}
-
 TEST_F(StageDecorationTest, ToStr) {
   auto* d = create<StageDecoration>(PipelineStage::kFragment);
   EXPECT_EQ(str(d), R"(StageDecoration{fragment}
diff --git a/src/ast/storage_texture_test.cc b/src/ast/storage_texture_test.cc
index 0f29196bc1..e2ee6e6d97 100644
--- a/src/ast/storage_texture_test.cc
+++ b/src/ast/storage_texture_test.cc
@@ -36,25 +36,6 @@ namespace {
 
 using AstStorageTextureTest = TestHelper;
 
-TEST_F(AstStorageTextureTest, Is) {
-  auto* subtype = StorageTexture::SubtypeFor(ImageFormat::kRgba32Float, *this);
-  Type* ty = create<StorageTexture>(TextureDimension::k2dArray,
-                                    ImageFormat::kRgba32Float, subtype);
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Alias>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_TRUE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(AstStorageTextureTest, IsTexture) {
   auto* subtype = StorageTexture::SubtypeFor(ImageFormat::kRgba32Float, *this);
   Texture* ty = create<StorageTexture>(TextureDimension::k2dArray,
diff --git a/src/ast/stride_decoration_test.cc b/src/ast/stride_decoration_test.cc
index ae81a292e7..1e25ad3654 100644
--- a/src/ast/stride_decoration_test.cc
+++ b/src/ast/stride_decoration_test.cc
@@ -25,10 +25,6 @@ TEST_F(StrideDecorationTest, Creation) {
   EXPECT_EQ(2u, d->stride());
 }
 
-TEST_F(StrideDecorationTest, Is) {
-  auto* d = create<StrideDecoration>(2);
-  EXPECT_TRUE(d->Is<StrideDecoration>());
-}
 
 TEST_F(StrideDecorationTest, Source) {
   auto* d = create<StrideDecoration>(
diff --git a/src/ast/struct_member_align_decoration_test.cc b/src/ast/struct_member_align_decoration_test.cc
index fc6e5d358d..8dc71a62e3 100644
--- a/src/ast/struct_member_align_decoration_test.cc
+++ b/src/ast/struct_member_align_decoration_test.cc
@@ -27,11 +27,6 @@ TEST_F(StructMemberAlignDecorationTest, Creation) {
   EXPECT_EQ(2u, d->align());
 }
 
-TEST_F(StructMemberAlignDecorationTest, Is) {
-  auto* d = create<StructMemberAlignDecoration>(2);
-  EXPECT_TRUE(d->Is<StructMemberAlignDecoration>());
-}
-
 }  // namespace
 }  // namespace ast
 }  // namespace tint
diff --git a/src/ast/struct_member_offset_decoration_test.cc b/src/ast/struct_member_offset_decoration_test.cc
index 9ebd0a9c4c..94f3e873ad 100644
--- a/src/ast/struct_member_offset_decoration_test.cc
+++ b/src/ast/struct_member_offset_decoration_test.cc
@@ -25,11 +25,6 @@ TEST_F(StructMemberOffsetDecorationTest, Creation) {
   EXPECT_EQ(2u, d->offset());
 }
 
-TEST_F(StructMemberOffsetDecorationTest, Is) {
-  auto* d = create<StructMemberOffsetDecoration>(2);
-  EXPECT_TRUE(d->Is<StructMemberOffsetDecoration>());
-}
-
 }  // namespace
 }  // namespace ast
 }  // namespace tint
diff --git a/src/ast/struct_member_size_decoration_test.cc b/src/ast/struct_member_size_decoration_test.cc
index 61427b72ff..fea6fd2a4c 100644
--- a/src/ast/struct_member_size_decoration_test.cc
+++ b/src/ast/struct_member_size_decoration_test.cc
@@ -27,11 +27,6 @@ TEST_F(StructMemberOffsetDecorationTest, Creation) {
   EXPECT_EQ(2u, d->size());
 }
 
-TEST_F(StructMemberOffsetDecorationTest, Is) {
-  auto* d = create<StructMemberSizeDecoration>(2);
-  EXPECT_TRUE(d->Is<StructMemberSizeDecoration>());
-}
-
 }  // namespace
 }  // namespace ast
 }  // namespace tint
diff --git a/src/ast/struct_test.cc b/src/ast/struct_test.cc
index 904bdc5c46..3e37625cf2 100644
--- a/src/ast/struct_test.cc
+++ b/src/ast/struct_test.cc
@@ -137,24 +137,6 @@ TEST_F(AstStructTest, ToStr) {
 )");
 }
 
-TEST_F(AstStructTest, Is) {
-  Type* ty = create<ast::Struct>(Sym("S"), ast::StructMemberList{},
-                                 ast::DecorationList{});
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Alias>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_TRUE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(AstStructTest, TypeName) {
   auto name = Sym("my_struct");
   auto* s =
diff --git a/src/ast/u32_test.cc b/src/ast/u32_test.cc
index 94deea62ef..af57079834 100644
--- a/src/ast/u32_test.cc
+++ b/src/ast/u32_test.cc
@@ -34,23 +34,6 @@ namespace {
 
 using AstU32Test = TestHelper;
 
-TEST_F(AstU32Test, Is) {
-  Type* ty = create<U32>();
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Alias>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_TRUE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(AstU32Test, TypeName) {
   auto* u = create<U32>();
   EXPECT_EQ(u->type_name(), "__u32");
diff --git a/src/ast/uint_literal_test.cc b/src/ast/uint_literal_test.cc
index 2f4bf7b517..f88ec44376 100644
--- a/src/ast/uint_literal_test.cc
+++ b/src/ast/uint_literal_test.cc
@@ -26,14 +26,6 @@ TEST_F(UintLiteralTest, Value) {
   EXPECT_EQ(u->value(), 47u);
 }
 
-TEST_F(UintLiteralTest, Is) {
-  ast::Literal* l = create<UintLiteral>(42);
-  EXPECT_FALSE(l->Is<BoolLiteral>());
-  EXPECT_FALSE(l->Is<SintLiteral>());
-  EXPECT_FALSE(l->Is<FloatLiteral>());
-  EXPECT_TRUE(l->Is<UintLiteral>());
-}
-
 TEST_F(UintLiteralTest, ToStr) {
   auto* u = create<UintLiteral>(42u);
   EXPECT_EQ(str(u), "42u");
diff --git a/src/ast/vector_test.cc b/src/ast/vector_test.cc
index 7977f3dd26..f4195581ab 100644
--- a/src/ast/vector_test.cc
+++ b/src/ast/vector_test.cc
@@ -40,24 +40,6 @@ TEST_F(AstVectorTest, Creation) {
   EXPECT_EQ(v->size(), 2u);
 }
 
-TEST_F(AstVectorTest, Is) {
-  auto* i32 = create<I32>();
-  Type* ty = create<Vector>(i32, 4);
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Alias>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_TRUE(ty->Is<Vector>());
-}
-
 TEST_F(AstVectorTest, TypeName) {
   auto* i32 = create<I32>();
   auto* v = create<Vector>(i32, 3);
diff --git a/src/ast/workgroup_decoration_test.cc b/src/ast/workgroup_decoration_test.cc
index f4f01263e5..c5c697fb4f 100644
--- a/src/ast/workgroup_decoration_test.cc
+++ b/src/ast/workgroup_decoration_test.cc
@@ -55,12 +55,6 @@ TEST_F(WorkgroupDecorationTest, Creation_3param) {
   EXPECT_EQ(z, 6u);
 }
 
-TEST_F(WorkgroupDecorationTest, Is) {
-  Decoration* d = create<WorkgroupDecoration>(2, 4, 6);
-  EXPECT_TRUE(d->Is<WorkgroupDecoration>());
-  EXPECT_FALSE(d->Is<StageDecoration>());
-}
-
 TEST_F(WorkgroupDecorationTest, ToStr) {
   auto* d = create<WorkgroupDecoration>(2, 4, 6);
   EXPECT_EQ(str(d), R"(WorkgroupDecoration{2 4 6}
diff --git a/src/sem/access_control_type_test.cc b/src/sem/access_control_type_test.cc
index f62a50ab3d..0f738fcc17 100644
--- a/src/sem/access_control_type_test.cc
+++ b/src/sem/access_control_type_test.cc
@@ -30,25 +30,6 @@ TEST_F(AccessControlTest, Create) {
   EXPECT_EQ(a.type(), &u32);
 }
 
-TEST_F(AccessControlTest, Is) {
-  I32 i32;
-
-  AccessControl at{ast::AccessControl::kReadOnly, &i32};
-  Type* ty = &at;
-  EXPECT_TRUE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(AccessControlTest, AccessRead) {
   I32 i32;
   AccessControl at{ast::AccessControl::kReadOnly, &i32};
diff --git a/src/sem/bool_type_test.cc b/src/sem/bool_type_test.cc
index 96dbdda209..bf0e1c8b35 100644
--- a/src/sem/bool_type_test.cc
+++ b/src/sem/bool_type_test.cc
@@ -22,23 +22,6 @@ namespace {
 
 using BoolTest = TestHelper;
 
-TEST_F(BoolTest, Is) {
-  Bool b;
-  Type* ty = &b;
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_TRUE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(BoolTest, TypeName) {
   Bool b;
   EXPECT_EQ(b.type_name(), "__bool");
diff --git a/src/sem/depth_texture_type_test.cc b/src/sem/depth_texture_type_test.cc
index fe6131dbec..bd4829d369 100644
--- a/src/sem/depth_texture_type_test.cc
+++ b/src/sem/depth_texture_type_test.cc
@@ -27,23 +27,6 @@ namespace {
 
 using DepthTextureTest = TestHelper;
 
-TEST_F(DepthTextureTest, Is) {
-  DepthTexture d(ast::TextureDimension::kCube);
-  Type* ty = &d;
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_TRUE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(DepthTextureTest, IsTexture) {
   DepthTexture d(ast::TextureDimension::kCube);
   Texture* ty = &d;
diff --git a/src/sem/external_texture_type_test.cc b/src/sem/external_texture_type_test.cc
index d44cf5831e..c570675ed8 100644
--- a/src/sem/external_texture_type_test.cc
+++ b/src/sem/external_texture_type_test.cc
@@ -27,24 +27,6 @@ namespace {
 
 using ExternalTextureTest = TestHelper;
 
-TEST_F(ExternalTextureTest, Is) {
-  F32 f32;
-  ExternalTexture s;
-  Type* ty = &s;
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_TRUE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(ExternalTextureTest, IsTexture) {
   F32 f32;
   ExternalTexture s;
diff --git a/src/sem/f32_type_test.cc b/src/sem/f32_type_test.cc
index cb1cd2e289..660705c129 100644
--- a/src/sem/f32_type_test.cc
+++ b/src/sem/f32_type_test.cc
@@ -22,23 +22,6 @@ namespace {
 
 using F32Test = TestHelper;
 
-TEST_F(F32Test, Is) {
-  F32 f;
-  Type* ty = &f;
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_TRUE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(F32Test, TypeName) {
   F32 f;
   EXPECT_EQ(f.type_name(), "__f32");
diff --git a/src/sem/i32_type_test.cc b/src/sem/i32_type_test.cc
index 34ddf9b0dc..1578ee8a60 100644
--- a/src/sem/i32_type_test.cc
+++ b/src/sem/i32_type_test.cc
@@ -22,23 +22,6 @@ namespace {
 
 using I32Test = TestHelper;
 
-TEST_F(I32Test, Is) {
-  I32 i;
-  Type* ty = &i;
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_TRUE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(I32Test, TypeName) {
   I32 i;
   EXPECT_EQ(i.type_name(), "__i32");
diff --git a/src/sem/matrix_type_test.cc b/src/sem/matrix_type_test.cc
index c1b071ad6d..19033eff9e 100644
--- a/src/sem/matrix_type_test.cc
+++ b/src/sem/matrix_type_test.cc
@@ -31,25 +31,6 @@ TEST_F(MatrixTest, Creation) {
   EXPECT_EQ(m.columns(), 4u);
 }
 
-TEST_F(MatrixTest, Is) {
-  I32 i32;
-  Vector c{&i32, 2};
-  Matrix m{&c, 4};
-  Type* ty = &m;
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_TRUE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(MatrixTest, TypeName) {
   I32 i32;
   Vector c{&i32, 2};
diff --git a/src/sem/multisampled_texture_type_test.cc b/src/sem/multisampled_texture_type_test.cc
index bd4d1beb8e..ee454b8bfb 100644
--- a/src/sem/multisampled_texture_type_test.cc
+++ b/src/sem/multisampled_texture_type_test.cc
@@ -27,24 +27,6 @@ namespace {
 
 using MultisampledTextureTest = TestHelper;
 
-TEST_F(MultisampledTextureTest, Is) {
-  F32 f32;
-  MultisampledTexture s(ast::TextureDimension::kCube, &f32);
-  Type* ty = &s;
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_TRUE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(MultisampledTextureTest, IsTexture) {
   F32 f32;
   MultisampledTexture s(ast::TextureDimension::kCube, &f32);
diff --git a/src/sem/pointer_type_test.cc b/src/sem/pointer_type_test.cc
index 8c331f9c2a..6c75fa2a00 100644
--- a/src/sem/pointer_type_test.cc
+++ b/src/sem/pointer_type_test.cc
@@ -29,23 +29,6 @@ TEST_F(PointerTest, Creation) {
   EXPECT_EQ(p.storage_class(), ast::StorageClass::kStorage);
 }
 
-TEST_F(PointerTest, Is) {
-  I32 i32;
-  Pointer p{&i32, ast::StorageClass::kFunction};
-  Type* ty = &p;
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_TRUE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
 
 TEST_F(PointerTest, TypeName) {
   I32 i32;
diff --git a/src/sem/sampled_texture_type_test.cc b/src/sem/sampled_texture_type_test.cc
index 92bfcf47b3..89ec80f7e4 100644
--- a/src/sem/sampled_texture_type_test.cc
+++ b/src/sem/sampled_texture_type_test.cc
@@ -26,23 +26,6 @@ namespace {
 
 using SampledTextureTest = TestHelper;
 
-TEST_F(SampledTextureTest, Is) {
-  F32 f32;
-  SampledTexture s(ast::TextureDimension::kCube, &f32);
-  Type* ty = &s;
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_TRUE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
 
 TEST_F(SampledTextureTest, IsTexture) {
   F32 f32;
diff --git a/src/sem/sampler_type_test.cc b/src/sem/sampler_type_test.cc
index fece8da32e..1673edab75 100644
--- a/src/sem/sampler_type_test.cc
+++ b/src/sem/sampler_type_test.cc
@@ -33,23 +33,6 @@ TEST_F(SamplerTest, Creation_ComparisonSampler) {
   EXPECT_TRUE(s.IsComparison());
 }
 
-TEST_F(SamplerTest, Is) {
-  Sampler s{ast::SamplerKind::kSampler};
-  Type* ty = &s;
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_TRUE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(SamplerTest, TypeName_Sampler) {
   Sampler s{ast::SamplerKind::kSampler};
   EXPECT_EQ(s.type_name(), "__sampler_sampler");
diff --git a/src/sem/sem_array_test.cc b/src/sem/sem_array_test.cc
index 05ac10a306..515069e576 100644
--- a/src/sem/sem_array_test.cc
+++ b/src/sem/sem_array_test.cc
@@ -46,24 +46,6 @@ TEST_F(ArrayTest, CreateRuntimeArray) {
   EXPECT_TRUE(arr->IsRuntimeSized());
 }
 
-TEST_F(ArrayTest, Is) {
-  I32 i32;
-
-  Type* ty = create<Array>(&i32, 2, 4, 8, 4, true);
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_TRUE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(ArrayTest, TypeName) {
   I32 i32;
   auto* arr = create<Array>(&i32, 2, 0, 4, 4, true);
diff --git a/src/sem/sem_struct_test.cc b/src/sem/sem_struct_test.cc
index e6aa671cc3..051b8237a4 100644
--- a/src/sem/sem_struct_test.cc
+++ b/src/sem/sem_struct_test.cc
@@ -36,27 +36,6 @@ TEST_F(StructTest, Creation) {
   EXPECT_EQ(s->SizeNoPadding(), 16u);
 }
 
-TEST_F(StructTest, Is) {
-  auto name = Sym("S");
-  auto* impl =
-      create<ast::Struct>(name, ast::StructMemberList{}, ast::DecorationList{});
-  auto* s = create<sem::Struct>(impl, StructMemberList{}, 4 /* align */,
-                                4 /* size */, 4 /* size_no_padding */);
-  sem::Type* ty = s;
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_TRUE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(StructTest, TypeName) {
   auto name = Sym("my_struct");
   auto* impl =
diff --git a/src/sem/storage_texture_type_test.cc b/src/sem/storage_texture_type_test.cc
index fc7e8b86a4..35294c9f7b 100644
--- a/src/sem/storage_texture_type_test.cc
+++ b/src/sem/storage_texture_type_test.cc
@@ -26,38 +26,6 @@ namespace {
 
 using StorageTextureTest = TestHelper;
 
-TEST_F(StorageTextureTest, Is) {
-  auto* subtype =
-      StorageTexture::SubtypeFor(ast::ImageFormat::kRgba32Float, Types());
-  auto* s = create<StorageTexture>(ast::TextureDimension::k2dArray,
-                                   ast::ImageFormat::kRgba32Float, subtype);
-  Type* ty = s;
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_TRUE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
-TEST_F(StorageTextureTest, IsTexture) {
-  auto* subtype =
-      StorageTexture::SubtypeFor(ast::ImageFormat::kRgba32Float, Types());
-  auto* s = create<StorageTexture>(ast::TextureDimension::k2dArray,
-                                   ast::ImageFormat::kRgba32Float, subtype);
-  Texture* ty = s;
-  EXPECT_FALSE(ty->Is<DepthTexture>());
-  EXPECT_FALSE(ty->Is<ExternalTexture>());
-  EXPECT_FALSE(ty->Is<SampledTexture>());
-  EXPECT_TRUE(ty->Is<StorageTexture>());
-}
-
 TEST_F(StorageTextureTest, Dim) {
   auto* subtype =
       StorageTexture::SubtypeFor(ast::ImageFormat::kRgba32Float, Types());
diff --git a/src/sem/u32_type_test.cc b/src/sem/u32_type_test.cc
index 07866e37f1..7859294903 100644
--- a/src/sem/u32_type_test.cc
+++ b/src/sem/u32_type_test.cc
@@ -22,23 +22,6 @@ namespace {
 
 using U32Test = TestHelper;
 
-TEST_F(U32Test, Is) {
-  U32 u;
-  Type* ty = &u;
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_TRUE(ty->Is<U32>());
-  EXPECT_FALSE(ty->Is<Vector>());
-}
-
 TEST_F(U32Test, TypeName) {
   U32 u;
   EXPECT_EQ(u.type_name(), "__u32");
diff --git a/src/sem/vector_type_test.cc b/src/sem/vector_type_test.cc
index 81fec62a49..3ff6904986 100644
--- a/src/sem/vector_type_test.cc
+++ b/src/sem/vector_type_test.cc
@@ -29,24 +29,6 @@ TEST_F(VectorTest, Creation) {
   EXPECT_EQ(v.size(), 2u);
 }
 
-TEST_F(VectorTest, Is) {
-  I32 i32;
-  Vector v{&i32, 4};
-  Type* ty = &v;
-  EXPECT_FALSE(ty->Is<AccessControl>());
-  EXPECT_FALSE(ty->Is<Array>());
-  EXPECT_FALSE(ty->Is<Bool>());
-  EXPECT_FALSE(ty->Is<F32>());
-  EXPECT_FALSE(ty->Is<I32>());
-  EXPECT_FALSE(ty->Is<Matrix>());
-  EXPECT_FALSE(ty->Is<Pointer>());
-  EXPECT_FALSE(ty->Is<Sampler>());
-  EXPECT_FALSE(ty->Is<Struct>());
-  EXPECT_FALSE(ty->Is<Texture>());
-  EXPECT_FALSE(ty->Is<U32>());
-  EXPECT_TRUE(ty->Is<Vector>());
-}
-
 TEST_F(VectorTest, TypeName) {
   auto* i32 = create<I32>();
   auto* v = create<Vector>(i32, 3);