diff --git a/mlir/include/mlir/Dialect/Shape/IR/ShapeBase.td b/mlir/include/mlir/Dialect/Shape/IR/ShapeBase.td
--- a/mlir/include/mlir/Dialect/Shape/IR/ShapeBase.td
+++ b/mlir/include/mlir/Dialect/Shape/IR/ShapeBase.td
@@ -43,9 +43,8 @@
   let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
 }
 
-def Shape_ShapeType : DialectType<ShapeDialect,
-    CPred<"$_self.isa<::mlir::shape::ShapeType>()">, "shape">,
-    BuildableType<"$_builder.getType<::mlir::shape::ShapeType>()"> {
+def Shape_ShapeType : TypeWithDialect<
+    SimpleBuildableType<"::mlir::shape::ShapeType", "shape">, ShapeDialect> {
   let description = [{
     `shape.shape` represents either an unranked shape, a ranked shape with
     possibly unknown dimensions or an invalid shape. The rank is of type
@@ -62,9 +61,8 @@
   }];
 }
 
-def Shape_SizeType : DialectType<ShapeDialect,
-    CPred<"$_self.isa<::mlir::shape::SizeType>()">, "size">,
-    BuildableType<"$_builder.getType<::mlir::shape::SizeType>()"> {
+def Shape_SizeType : TypeWithDialect<
+    SimpleBuildableType<"::mlir::shape::SizeType", "size">, ShapeDialect> {
   let description = [{
     `shape.size` represents a non-negative integer with support for being
     unknown and invalid.
@@ -75,10 +73,9 @@
   }];
 }
 
-def Shape_ValueShapeType : DialectType<ShapeDialect,
-    CPred<"$_self.isa<::mlir::shape::ValueShapeType>()">, "value shape">,
-    BuildableType<"::mlir::shape::ValueShapeType::get($_builder.getContext())">
-{
+def Shape_ValueShapeType : TypeWithDialect<
+    SimpleBuildableType<"::mlir::shape::ValueShapeType", "value shape">,
+    ShapeDialect> {
   let description = [{
     `shape.value_shape` represents the value produced by an operation (this
     corresponds to `Value` in the compiler) and a shape. Conceptually this is a
@@ -112,9 +109,9 @@
 
 def Shape_SizeOrIndexType : AnyTypeOf<[Shape_SizeType, Index], "size or index">;
 
-def Shape_WitnessType : DialectType<ShapeDialect,
-    CPred<"$_self.isa<::mlir::shape::WitnessType>()">, "witness">,
-    BuildableType<"$_builder.getType<::mlir::shape::WitnessType>()"> {
+def Shape_WitnessType : TypeWithDialect<
+    SimpleBuildableType<"::mlir::shape::WitnessType", "witness">,
+    ShapeDialect> {
   let description = [{
     A witness is a structural device in the compiler to maintain ordering of
     code relying on information obtained from passing assertions. Witnesses do
diff --git a/mlir/include/mlir/IR/OpBase.td b/mlir/include/mlir/IR/OpBase.td
--- a/mlir/include/mlir/IR/OpBase.td
+++ b/mlir/include/mlir/IR/OpBase.td
@@ -270,6 +270,7 @@
     TypeConstraint<condition, descr, cppClassName> {
   string description = "";
   string builderCall = "";
+  Dialect dialect = ?;
 }
 
 // Allows providing an alternative name and summary to an existing type def.
@@ -279,13 +280,6 @@
   let builderCall = t.builderCall;
 }
 
-// A type of a specific dialect.
-class DialectType<Dialect d, Pred condition, string descr = "",
-                  string cppClassName = "::mlir::Type"> :
-    Type<condition, descr, cppClassName> {
-  Dialect dialect = d;
-}
-
 // A variadic type constraint. It expands to zero or more of the base type. This
 // class is used for supporting variadic operands/results.
 class Variadic<Type type> : TypeConstraint<type.predicate, type.summary,
@@ -322,6 +316,31 @@
   code builderCall = builder;
 }
 
+// Utility classes to compose Type.
+class TypeWithDialect<Type t, Dialect d> :
+    Type<t.predicate, t.summary, t.cppClassName> {
+  let dialect = d;
+  let builderCall = t.builderCall;
+}
+class TypeWithBuilder<Type t, code builder> :
+    Type<t.predicate, t.summary, t.cppClassName>, BuildableType<builder> {
+  let dialect = t.dialect;
+}
+
+// A type of a specific dialect.
+class DialectType<Dialect d, Pred condition, string descr = "",
+                  string cppClassName = "::mlir::Type"> :
+    TypeWithDialect<Type<condition, descr, cppClassName>, d>;
+
+// Type whose membership is via isa.
+class SimpleType<string cppTypeClass, string desc> :
+  Type<CPred<"$_self.isa<" # cppTypeClass # ">()">, desc, cppTypeClass>;
+// Type whose membership is via isa and whose construction is trivial.
+class SimpleBuildableType<string cppTypeClass, string desc> :
+  TypeWithBuilder<
+    SimpleType<cppTypeClass, desc>,
+    "$_builder.getType<" # cppTypeClass # ">()">;
+
 // A type that's buildable iff the type passed as an argument is buildable.
 // This is intended for use by types like container types, which are only
 // buildable if the type of their elements is buildable.
@@ -333,9 +352,7 @@
 def AnyType : Type<CPred<"true">, "any type">;
 
 // None type
-def NoneType : Type<CPred<"$_self.isa<::mlir::NoneType>()">, "none type",
-                    "::mlir::NoneType">,
-      BuildableType<"$_builder.getType<::mlir::NoneType>()">;
+def NoneType : SimpleBuildableType<"::mlir::NoneType", "none type">;
 
 // Any type from the given list
 class AnyTypeOf<list<Type> allowedTypes, string summary = "",
@@ -440,9 +457,7 @@
 def UI64 : UI<64>;
 
 // Index type.
-def Index : Type<CPred<"$_self.isa<::mlir::IndexType>()">, "index",
-                 "::mlir::IndexType">,
-            BuildableType<"$_builder.getIndexType()">;
+def Index : SimpleBuildableType<"::mlir::IndexType", "index">;
 
 // Any signless integer type or index type.
 def AnySignlessIntegerOrIndex : Type<CPred<"$_self.isSignlessIntOrIndex()">,