diff --git a/include/mlir/Analysis/LoopAnalysis.h b/include/mlir/Analysis/LoopAnalysis.h
index 7f6d799..6820ee8 100644
--- a/include/mlir/Analysis/LoopAnalysis.h
+++ b/include/mlir/Analysis/LoopAnalysis.h
@@ -51,7 +51,7 @@
 /// whether indices[dim] is independent of the value `input`.
 // For now we assume no layout map or identity layout map in the MemRef.
 // TODO(ntv): support more than identity layout map.
-bool isAccessInvariant(const MLValue &input, MemRefType *memRefType,
+bool isAccessInvariant(const MLValue &input, MemRefType memRefType,
                        llvm::ArrayRef<MLValue *> indices, unsigned dim);
 
 /// Checks whether all the LoadOp and StoreOp matched have access indexing
diff --git a/include/mlir/IR/Attributes.h b/include/mlir/IR/Attributes.h
index b84d20f..7c30397 100644
--- a/include/mlir/IR/Attributes.h
+++ b/include/mlir/IR/Attributes.h
@@ -250,9 +250,9 @@
   TypeAttr() = default;
   /* implicit */ TypeAttr(Attribute::ImplType *ptr);
 
-  static TypeAttr get(Type *type, MLIRContext *context);
+  static TypeAttr get(Type type, MLIRContext *context);
 
-  Type *getValue() const;
+  Type getValue() const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool kindof(Kind kind) { return kind == Kind::Type; }
@@ -277,7 +277,7 @@
 
   Function *getValue() const;
 
-  FunctionType *getType() const;
+  FunctionType getType() const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool kindof(Kind kind) { return kind == Kind::Function; }
@@ -294,7 +294,7 @@
   ElementsAttr() = default;
   /* implicit */ ElementsAttr(Attribute::ImplType *ptr);
 
-  VectorOrTensorType *getType() const;
+  VectorOrTensorType getType() const;
 
   /// Method for support type inquiry through isa, cast and dyn_cast.
   static bool kindof(Kind kind) {
@@ -313,7 +313,7 @@
   SplatElementsAttr() = default;
   /* implicit */ SplatElementsAttr(Attribute::ImplType *ptr);
 
-  static SplatElementsAttr get(VectorOrTensorType *type, Attribute elt);
+  static SplatElementsAttr get(VectorOrTensorType type, Attribute elt);
   Attribute getValue() const;
 
   /// Method for support type inquiry through isa, cast and dyn_cast.
@@ -335,12 +335,12 @@
   /// width specified by the element type (note all float type are 64 bits).
   /// When the value is retrieved, the bits are read from the storage and extend
   /// to 64 bits if necessary.
-  static DenseElementsAttr get(VectorOrTensorType *type, ArrayRef<char> data);
+  static DenseElementsAttr get(VectorOrTensorType type, ArrayRef<char> data);
 
   // TODO: Read the data from the attribute list and compress them
   // to a character array. Then call the above method to construct the
   // attribute.
-  static DenseElementsAttr get(VectorOrTensorType *type,
+  static DenseElementsAttr get(VectorOrTensorType type,
                                ArrayRef<Attribute> values);
 
   void getValues(SmallVectorImpl<Attribute> &values) const;
@@ -410,7 +410,7 @@
   OpaqueElementsAttr() = default;
   /* implicit */ OpaqueElementsAttr(Attribute::ImplType *ptr);
 
-  static OpaqueElementsAttr get(VectorOrTensorType *type, StringRef bytes);
+  static OpaqueElementsAttr get(VectorOrTensorType type, StringRef bytes);
 
   StringRef getValue() const;
 
@@ -440,7 +440,7 @@
   SparseElementsAttr() = default;
   /* implicit */ SparseElementsAttr(Attribute::ImplType *ptr);
 
-  static SparseElementsAttr get(VectorOrTensorType *type,
+  static SparseElementsAttr get(VectorOrTensorType type,
                                 DenseIntElementsAttr indices,
                                 DenseElementsAttr values);
 
diff --git a/include/mlir/IR/BasicBlock.h b/include/mlir/IR/BasicBlock.h
index c55d09c..cfae6af 100644
--- a/include/mlir/IR/BasicBlock.h
+++ b/include/mlir/IR/BasicBlock.h
@@ -64,10 +64,10 @@
   bool args_empty() const { return arguments.empty(); }
 
   /// Add one value to the operand list.
-  BBArgument *addArgument(Type *type);
+  BBArgument *addArgument(Type type);
 
   /// Add one argument to the argument list for each type specified in the list.
-  llvm::iterator_range<args_iterator> addArguments(ArrayRef<Type *> types);
+  llvm::iterator_range<args_iterator> addArguments(ArrayRef<Type> types);
 
   unsigned getNumArguments() const { return arguments.size(); }
   BBArgument *getArgument(unsigned i) { return arguments[i]; }
diff --git a/include/mlir/IR/Builders.h b/include/mlir/IR/Builders.h
index 2e48008..46952e2 100644
--- a/include/mlir/IR/Builders.h
+++ b/include/mlir/IR/Builders.h
@@ -68,29 +68,28 @@
                                     unsigned column);
 
   // Types.
-  FloatType *getBF16Type();
-  FloatType *getF16Type();
-  FloatType *getF32Type();
-  FloatType *getF64Type();
+  FloatType getBF16Type();
+  FloatType getF16Type();
+  FloatType getF32Type();
+  FloatType getF64Type();
 
-  OtherType *getIndexType();
-  OtherType *getTFControlType();
-  OtherType *getTFStringType();
-  OtherType *getTFResourceType();
-  OtherType *getTFVariantType();
-  OtherType *getTFComplex64Type();
-  OtherType *getTFComplex128Type();
-  OtherType *getTFF32REFType();
+  OtherType getIndexType();
+  OtherType getTFControlType();
+  OtherType getTFStringType();
+  OtherType getTFResourceType();
+  OtherType getTFVariantType();
+  OtherType getTFComplex64Type();
+  OtherType getTFComplex128Type();
+  OtherType getTFF32REFType();
 
-  IntegerType *getIntegerType(unsigned width);
-  FunctionType *getFunctionType(ArrayRef<Type *> inputs,
-                                ArrayRef<Type *> results);
-  MemRefType *getMemRefType(ArrayRef<int> shape, Type *elementType,
-                            ArrayRef<AffineMap> affineMapComposition = {},
-                            unsigned memorySpace = 0);
-  VectorType *getVectorType(ArrayRef<int> shape, Type *elementType);
-  RankedTensorType *getTensorType(ArrayRef<int> shape, Type *elementType);
-  UnrankedTensorType *getTensorType(Type *elementType);
+  IntegerType getIntegerType(unsigned width);
+  FunctionType getFunctionType(ArrayRef<Type> inputs, ArrayRef<Type> results);
+  MemRefType getMemRefType(ArrayRef<int> shape, Type elementType,
+                           ArrayRef<AffineMap> affineMapComposition = {},
+                           unsigned memorySpace = 0);
+  VectorType getVectorType(ArrayRef<int> shape, Type elementType);
+  RankedTensorType getTensorType(ArrayRef<int> shape, Type elementType);
+  UnrankedTensorType getTensorType(Type elementType);
 
   // Attributes.
 
@@ -102,15 +101,15 @@
   ArrayAttr getArrayAttr(ArrayRef<Attribute> value);
   AffineMapAttr getAffineMapAttr(AffineMap map);
   IntegerSetAttr getIntegerSetAttr(IntegerSet set);
-  TypeAttr getTypeAttr(Type *type);
+  TypeAttr getTypeAttr(Type type);
   FunctionAttr getFunctionAttr(const Function *value);
-  ElementsAttr getSplatElementsAttr(VectorOrTensorType *type, Attribute elt);
-  ElementsAttr getDenseElementsAttr(VectorOrTensorType *type,
+  ElementsAttr getSplatElementsAttr(VectorOrTensorType type, Attribute elt);
+  ElementsAttr getDenseElementsAttr(VectorOrTensorType type,
                                     ArrayRef<char> data);
-  ElementsAttr getSparseElementsAttr(VectorOrTensorType *type,
+  ElementsAttr getSparseElementsAttr(VectorOrTensorType type,
                                      DenseIntElementsAttr indices,
                                      DenseElementsAttr values);
-  ElementsAttr getOpaqueElementsAttr(VectorOrTensorType *type, StringRef bytes);
+  ElementsAttr getOpaqueElementsAttr(VectorOrTensorType type, StringRef bytes);
 
   // Affine expressions and affine maps.
   AffineExpr getAffineDimExpr(unsigned position);
@@ -366,7 +365,7 @@
   /// Creates an operation given the fields.
   OperationStmt *createOperation(Location *location, OperationName name,
                                  ArrayRef<MLValue *> operands,
-                                 ArrayRef<Type *> types,
+                                 ArrayRef<Type> types,
                                  ArrayRef<NamedAttribute> attrs);
 
   /// Create operation of specific op type at the current insertion point.
diff --git a/include/mlir/IR/BuiltinOps.h b/include/mlir/IR/BuiltinOps.h
index 88d4d81..5d810a9 100644
--- a/include/mlir/IR/BuiltinOps.h
+++ b/include/mlir/IR/BuiltinOps.h
@@ -96,7 +96,7 @@
 public:
   /// Builds a constant op with the specified attribute value and result type.
   static void build(Builder *builder, OperationState *result, Attribute value,
-                    Type *type);
+                    Type type);
 
   Attribute getValue() const { return getAttr("value"); }
 
@@ -123,7 +123,7 @@
 public:
   /// Builds a constant float op producing a float of the specified type.
   static void build(Builder *builder, OperationState *result,
-                    const APFloat &value, FloatType *type);
+                    const APFloat &value, FloatType type);
 
   APFloat getValue() const {
     return getAttrOfType<FloatAttr>("value").getValue();
@@ -150,7 +150,7 @@
   /// Build a constant int op producing an integer with the specified type,
   /// which must be an integer type.
   static void build(Builder *builder, OperationState *result, int64_t value,
-                    Type *type);
+                    Type type);
 
   int64_t getValue() const {
     return getAttrOfType<IntegerAttr>("value").getValue();
diff --git a/include/mlir/IR/CFGFunction.h b/include/mlir/IR/CFGFunction.h
index f3c1da3..fb20a6b 100644
--- a/include/mlir/IR/CFGFunction.h
+++ b/include/mlir/IR/CFGFunction.h
@@ -27,7 +27,7 @@
 // blocks, each of which includes instructions.
 class CFGFunction : public Function {
 public:
-  CFGFunction(Location *location, StringRef name, FunctionType *type,
+  CFGFunction(Location *location, StringRef name, FunctionType type,
               ArrayRef<NamedAttribute> attrs = {});
 
   ~CFGFunction();
diff --git a/include/mlir/IR/CFGValue.h b/include/mlir/IR/CFGValue.h
index 939073c..45b36c1 100644
--- a/include/mlir/IR/CFGValue.h
+++ b/include/mlir/IR/CFGValue.h
@@ -66,7 +66,7 @@
   }
 
 protected:
-  CFGValue(CFGValueKind kind, Type *type) : SSAValueImpl(kind, type) {}
+  CFGValue(CFGValueKind kind, Type type) : SSAValueImpl(kind, type) {}
 };
 
 /// Basic block arguments are CFG Values.
@@ -87,7 +87,7 @@
 
 private:
   friend class BasicBlock; // For access to private constructor.
-  BBArgument(Type *type, BasicBlock *owner)
+  BBArgument(Type type, BasicBlock *owner)
       : CFGValue(CFGValueKind::BBArgument, type), owner(owner) {}
 
   /// The owner of this operand.
@@ -99,7 +99,7 @@
 /// Instruction results are CFG Values.
 class InstResult : public CFGValue {
 public:
-  InstResult(Type *type, OperationInst *owner)
+  InstResult(Type type, OperationInst *owner)
       : CFGValue(CFGValueKind::InstResult, type), owner(owner) {}
 
   static bool classof(const SSAValue *value) {
diff --git a/include/mlir/IR/Function.h b/include/mlir/IR/Function.h
index d42f528..04acc59 100644
--- a/include/mlir/IR/Function.h
+++ b/include/mlir/IR/Function.h
@@ -26,6 +26,7 @@
 
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Identifier.h"
+#include "mlir/IR/Types.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/ilist.h"
 
@@ -55,7 +56,7 @@
   Identifier getName() const { return nameAndKind.getPointer(); }
 
   /// Return the type of this function.
-  FunctionType *getType() const { return type; }
+  FunctionType getType() const { return type; }
 
   /// Returns all of the attributes on this function.
   ArrayRef<NamedAttribute> getAttrs() const;
@@ -93,7 +94,7 @@
   void emitNote(const Twine &message) const;
 
 protected:
-  Function(Kind kind, Location *location, StringRef name, FunctionType *type,
+  Function(Kind kind, Location *location, StringRef name, FunctionType type,
            ArrayRef<NamedAttribute> attrs = {});
   ~Function();
 
@@ -108,7 +109,7 @@
   Location *location;
 
   /// The type of the function.
-  FunctionType *const type;
+  FunctionType type;
 
   /// This holds general named attributes for the function.
   AttributeListStorage *attrs;
@@ -121,7 +122,7 @@
 /// defined in some other module.
 class ExtFunction : public Function {
 public:
-  ExtFunction(Location *location, StringRef name, FunctionType *type,
+  ExtFunction(Location *location, StringRef name, FunctionType type,
               ArrayRef<NamedAttribute> attrs = {});
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
diff --git a/include/mlir/IR/Instructions.h b/include/mlir/IR/Instructions.h
index e74c561..6d5a1ca 100644
--- a/include/mlir/IR/Instructions.h
+++ b/include/mlir/IR/Instructions.h
@@ -202,7 +202,7 @@
   /// Create a new OperationInst with the specified fields.
   static OperationInst *create(Location *location, OperationName name,
                                ArrayRef<CFGValue *> operands,
-                               ArrayRef<Type *> resultTypes,
+                               ArrayRef<Type> resultTypes,
                                ArrayRef<NamedAttribute> attributes,
                                MLIRContext *context);
 
diff --git a/include/mlir/IR/MLFunction.h b/include/mlir/IR/MLFunction.h
index 104692f..cf0deb9 100644
--- a/include/mlir/IR/MLFunction.h
+++ b/include/mlir/IR/MLFunction.h
@@ -41,7 +41,7 @@
 public:
   /// Creates a new MLFunction with the specific type.
   static MLFunction *create(Location *location, StringRef name,
-                            FunctionType *type,
+                            FunctionType type,
                             ArrayRef<NamedAttribute> attrs = {});
 
   /// Destroys this statement and its subclass data.
@@ -52,7 +52,7 @@
   //===--------------------------------------------------------------------===//
 
   /// Returns number of arguments.
-  unsigned getNumArguments() const { return getType()->getInputs().size(); }
+  unsigned getNumArguments() const { return getType().getInputs().size(); }
 
   /// Gets argument.
   MLFuncArgument *getArgument(unsigned idx) {
@@ -103,13 +103,13 @@
   }
 
 private:
-  MLFunction(Location *location, StringRef name, FunctionType *type,
+  MLFunction(Location *location, StringRef name, FunctionType type,
              ArrayRef<NamedAttribute> attrs = {});
 
   // This stuff is used by the TrailingObjects template.
   friend llvm::TrailingObjects<MLFunction, MLFuncArgument>;
   size_t numTrailingObjects(OverloadToken<MLFuncArgument>) const {
-    return getType()->getInputs().size();
+    return getType().getInputs().size();
   }
 
   // Internal functions to get argument list used by getArgument() methods.
diff --git a/include/mlir/IR/MLValue.h b/include/mlir/IR/MLValue.h
index 1961da1..0c6c0b2 100644
--- a/include/mlir/IR/MLValue.h
+++ b/include/mlir/IR/MLValue.h
@@ -73,7 +73,7 @@
   }
 
 protected:
-  MLValue(MLValueKind kind, Type *type) : SSAValueImpl(kind, type) {}
+  MLValue(MLValueKind kind, Type type) : SSAValueImpl(kind, type) {}
 };
 
 /// This is the value defined by an argument of an ML function.
@@ -93,7 +93,7 @@
 
 private:
   friend class MLFunction; // For access to private constructor.
-  MLFuncArgument(Type *type, MLFunction *owner)
+  MLFuncArgument(Type type, MLFunction *owner)
       : MLValue(MLValueKind::MLFuncArgument, type), owner(owner) {}
 
   /// The owner of this operand.
@@ -105,7 +105,7 @@
 /// This is a value defined by a result of an operation instruction.
 class StmtResult : public MLValue {
 public:
-  StmtResult(Type *type, OperationStmt *owner)
+  StmtResult(Type type, OperationStmt *owner)
       : MLValue(MLValueKind::StmtResult, type), owner(owner) {}
 
   static bool classof(const SSAValue *value) {
diff --git a/include/mlir/IR/Matchers.h b/include/mlir/IR/Matchers.h
index 06013a7..ad97dd2 100644
--- a/include/mlir/IR/Matchers.h
+++ b/include/mlir/IR/Matchers.h
@@ -71,13 +71,13 @@
 
   bool match(Operation *op) {
     if (auto constOp = op->dyn_cast<ConstantOp>()) {
-      auto *type = constOp->getResult()->getType();
+      auto type = constOp->getResult()->getType();
       auto attr = constOp->getAttr("value");
 
-      if (isa<IntegerType>(type)) {
+      if (type.isa<IntegerType>()) {
         return attr_value_binder<IntegerAttr>(bind_value).match(attr);
       }
-      if (isa<VectorOrTensorType>(type)) {
+      if (type.isa<VectorOrTensorType>()) {
         if (auto splatAttr = attr.dyn_cast<SplatElementsAttr>()) {
           return attr_value_binder<IntegerAttr>(bind_value)
               .match(splatAttr.getValue());
diff --git a/include/mlir/IR/OpDefinition.h b/include/mlir/IR/OpDefinition.h
index 821beb2..c2bc357 100644
--- a/include/mlir/IR/OpDefinition.h
+++ b/include/mlir/IR/OpDefinition.h
@@ -493,7 +493,7 @@
     return this->getOperation()->getResult(0);
   }
 
-  Type *getType() const { return getResult()->getType(); }
+  Type getType() const { return getResult()->getType(); }
 
   /// Replace all uses of 'this' value with the new value, updating anything in
   /// the IR that uses 'this' to use the other value instead.  When this returns
@@ -539,7 +539,7 @@
       return this->getOperation()->getResult(i);
     }
 
-    Type *getType(unsigned i) const { return getResult(i)->getType(); }
+    Type getType(unsigned i) const { return getResult(i)->getType(); }
 
     static bool verifyTrait(const Operation *op) {
       return impl::verifyNResults(op, N);
@@ -565,7 +565,7 @@
       return this->getOperation()->getResult(i);
     }
 
-    Type *getType(unsigned i) const { return getResult(i)->getType(); }
+    Type getType(unsigned i) const { return getResult(i)->getType(); }
 
     static bool verifyTrait(const Operation *op) {
       return impl::verifyAtLeastNResults(op, N);
@@ -803,7 +803,7 @@
 // which avoids them being template instantiated/duplicated.
 namespace impl {
 void buildCastOp(Builder *builder, OperationState *result, SSAValue *source,
-                 Type *destType);
+                 Type destType);
 bool parseCastOp(OpAsmParser *parser, OperationState *result);
 void printCastOp(const Operation *op, OpAsmPrinter *p);
 } // namespace impl
@@ -819,7 +819,7 @@
                          OpTrait::HasNoSideEffect, Traits...> {
 public:
   static void build(Builder *builder, OperationState *result, SSAValue *source,
-                    Type *destType) {
+                    Type destType) {
     impl::buildCastOp(builder, result, source, destType);
   }
   static bool parse(OpAsmParser *parser, OperationState *result) {
diff --git a/include/mlir/IR/OpImplementation.h b/include/mlir/IR/OpImplementation.h
index 09ec3f9..ae8df55 100644
--- a/include/mlir/IR/OpImplementation.h
+++ b/include/mlir/IR/OpImplementation.h
@@ -67,7 +67,7 @@
       printOperand(*it);
     }
   }
-  virtual void printType(const Type *type) = 0;
+  virtual void printType(Type type) = 0;
   virtual void printFunctionReference(const Function *func) = 0;
   virtual void printAttribute(Attribute attr) = 0;
   virtual void printAffineMap(AffineMap map) = 0;
@@ -95,8 +95,8 @@
   return p;
 }
 
-inline OpAsmPrinter &operator<<(OpAsmPrinter &p, const Type &type) {
-  p.printType(&type);
+inline OpAsmPrinter &operator<<(OpAsmPrinter &p, Type type) {
+  p.printType(type);
   return p;
 }
 
@@ -163,20 +163,20 @@
   virtual bool parseComma() = 0;
 
   /// Parse a colon followed by a type.
-  virtual bool parseColonType(Type *&result) = 0;
+  virtual bool parseColonType(Type &result) = 0;
 
   /// Parse a type of a specific kind, e.g. a FunctionType.
-  template <typename TypeType> bool parseColonType(TypeType *&result) {
+  template <typename TypeType> bool parseColonType(TypeType &result) {
     llvm::SMLoc loc;
     getCurrentLocation(&loc);
 
     // Parse any kind of type.
-    Type *type;
+    Type type;
     if (parseColonType(type))
       return true;
 
     // Check for the right kind of attribute.
-    result = dyn_cast<TypeType>(type);
+    result = type.dyn_cast<TypeType>();
     if (!result) {
       emitError(loc, "invalid kind of type specified");
       return true;
@@ -186,15 +186,15 @@
   }
 
   /// Parse a colon followed by a type list, which must have at least one type.
-  virtual bool parseColonTypeList(SmallVectorImpl<Type *> &result) = 0;
+  virtual bool parseColonTypeList(SmallVectorImpl<Type> &result) = 0;
 
   /// Parse a keyword followed by a type.
-  virtual bool parseKeywordType(const char *keyword, Type *&result) = 0;
+  virtual bool parseKeywordType(const char *keyword, Type &result) = 0;
 
   /// Add the specified type to the end of the specified type list and return
   /// false.  This is a helper designed to allow parse methods to be simple and
   /// chain through || operators.
-  bool addTypeToList(Type *type, SmallVectorImpl<Type *> &result) {
+  bool addTypeToList(Type type, SmallVectorImpl<Type> &result) {
     result.push_back(type);
     return false;
   }
@@ -202,7 +202,7 @@
   /// Add the specified types to the end of the specified type list and return
   /// false.  This is a helper designed to allow parse methods to be simple and
   /// chain through || operators.
-  bool addTypesToList(ArrayRef<Type *> types, SmallVectorImpl<Type *> &result) {
+  bool addTypesToList(ArrayRef<Type> types, SmallVectorImpl<Type> &result) {
     result.append(types.begin(), types.end());
     return false;
   }
@@ -288,13 +288,13 @@
 
   /// Resolve an operand to an SSA value, emitting an error and returning true
   /// on failure.
-  virtual bool resolveOperand(const OperandType &operand, Type *type,
+  virtual bool resolveOperand(const OperandType &operand, Type type,
                               SmallVectorImpl<SSAValue *> &result) = 0;
 
   /// Resolve a list of operands to SSA values, emitting an error and returning
   /// true on failure, or appending the results to the list on success.
   /// This method should be used when all operands have the same type.
-  virtual bool resolveOperands(ArrayRef<OperandType> operands, Type *type,
+  virtual bool resolveOperands(ArrayRef<OperandType> operands, Type type,
                                SmallVectorImpl<SSAValue *> &result) {
     for (auto elt : operands)
       if (resolveOperand(elt, type, result))
@@ -306,7 +306,7 @@
   /// emitting an error and returning true on failure, or appending the results
   /// to the list on success.
   virtual bool resolveOperands(ArrayRef<OperandType> operands,
-                               ArrayRef<Type *> types, llvm::SMLoc loc,
+                               ArrayRef<Type> types, llvm::SMLoc loc,
                                SmallVectorImpl<SSAValue *> &result) {
     if (operands.size() != types.size())
       return emitError(loc, Twine(operands.size()) +
@@ -321,7 +321,7 @@
   }
 
   /// Resolve a parse function name and a type into a function reference.
-  virtual bool resolveFunctionName(StringRef name, FunctionType *type,
+  virtual bool resolveFunctionName(StringRef name, FunctionType type,
                                    llvm::SMLoc loc, Function *&result) = 0;
 
   /// Emit a diagnostic at the specified location and return true.
diff --git a/include/mlir/IR/OperationSupport.h b/include/mlir/IR/OperationSupport.h
index ddf1aee..6833e45 100644
--- a/include/mlir/IR/OperationSupport.h
+++ b/include/mlir/IR/OperationSupport.h
@@ -25,6 +25,7 @@
 
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Identifier.h"
+#include "mlir/IR/Types.h"
 #include "llvm/ADT/PointerUnion.h"
 #include <memory>
 
@@ -191,7 +192,7 @@
   OperationName name;
   SmallVector<SSAValue *, 4> operands;
   /// Types of the results of this operation.
-  SmallVector<Type *, 4> types;
+  SmallVector<Type, 4> types;
   SmallVector<NamedAttribute, 4> attributes;
 
 public:
@@ -202,7 +203,7 @@
       : context(context), location(location), name(name) {}
 
   OperationState(MLIRContext *context, Location *location, StringRef name,
-                 ArrayRef<SSAValue *> operands, ArrayRef<Type *> types,
+                 ArrayRef<SSAValue *> operands, ArrayRef<Type> types,
                  ArrayRef<NamedAttribute> attributes = {})
       : context(context), location(location), name(name, context),
         operands(operands.begin(), operands.end()),
@@ -213,7 +214,7 @@
     operands.append(newOperands.begin(), newOperands.end());
   }
 
-  void addTypes(ArrayRef<Type *> newTypes) {
+  void addTypes(ArrayRef<Type> newTypes) {
     types.append(newTypes.begin(), newTypes.end());
   }
 
diff --git a/include/mlir/IR/SSAValue.h b/include/mlir/IR/SSAValue.h
index 93db6fa..ab16c98 100644
--- a/include/mlir/IR/SSAValue.h
+++ b/include/mlir/IR/SSAValue.h
@@ -25,7 +25,6 @@
 #include "mlir/IR/Types.h"
 #include "mlir/IR/UseDefLists.h"
 #include "mlir/Support/LLVM.h"
-#include "llvm/ADT/PointerIntPair.h"
 
 namespace mlir {
 class Function;
@@ -51,7 +50,7 @@
 
   SSAValueKind getKind() const { return typeAndKind.getInt(); }
 
-  Type *getType() const { return typeAndKind.getPointer(); }
+  Type getType() const { return typeAndKind.getPointer(); }
 
   /// Replace all uses of 'this' value with the new value, updating anything in
   /// the IR that uses 'this' to use the other value instead.  When this returns
@@ -93,9 +92,10 @@
   void dump() const;
 
 protected:
-  SSAValue(SSAValueKind kind, Type *type) : typeAndKind(type, kind) {}
+  SSAValue(SSAValueKind kind, Type type) : typeAndKind(type, kind) {}
+
 private:
-  const llvm::PointerIntPair<Type *, 3, SSAValueKind> typeAndKind;
+  const llvm::PointerIntPair<Type, 3, SSAValueKind> typeAndKind;
 };
 
 inline raw_ostream &operator<<(raw_ostream &os, const SSAValue &value) {
@@ -127,7 +127,7 @@
   inline use_range getUses() const;
 
 protected:
-  SSAValueImpl(KindTy kind, Type *type) : SSAValue((SSAValueKind)kind, type) {}
+  SSAValueImpl(KindTy kind, Type type) : SSAValue((SSAValueKind)kind, type) {}
 };
 
 // Utility functions for iterating through SSAValue uses.
diff --git a/include/mlir/IR/Statements.h b/include/mlir/IR/Statements.h
index 7e7a49f..8a5a9b5 100644
--- a/include/mlir/IR/Statements.h
+++ b/include/mlir/IR/Statements.h
@@ -44,7 +44,7 @@
   /// Create a new OperationStmt with the specific fields.
   static OperationStmt *create(Location *location, OperationName name,
                                ArrayRef<MLValue *> operands,
-                               ArrayRef<Type *> resultTypes,
+                               ArrayRef<Type> resultTypes,
                                ArrayRef<NamedAttribute> attributes,
                                MLIRContext *context);
 
@@ -329,7 +329,7 @@
   //===--------------------------------------------------------------------===//
 
   /// Return the context this operation is associated with.
-  MLIRContext *getContext() const { return getType()->getContext(); }
+  MLIRContext *getContext() const { return getType().getContext(); }
 
   using Statement::dump;
   using Statement::print;
diff --git a/include/mlir/IR/Types.h b/include/mlir/IR/Types.h
index 3d0afdf..493f607 100644
--- a/include/mlir/IR/Types.h
+++ b/include/mlir/IR/Types.h
@@ -20,6 +20,7 @@
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMapInfo.h"
 
 namespace mlir {
 class AffineMap;
@@ -28,6 +29,22 @@
 class FloatType;
 class OtherType;
 
+namespace detail {
+
+class TypeStorage;
+class IntegerTypeStorage;
+class FloatTypeStorage;
+struct OtherTypeStorage;
+struct FunctionTypeStorage;
+struct VectorOrTensorTypeStorage;
+struct VectorTypeStorage;
+struct TensorTypeStorage;
+struct RankedTensorTypeStorage;
+struct UnrankedTensorTypeStorage;
+struct MemRefTypeStorage;
+
+} // namespace detail
+
 /// Instances of the Type class are immutable, uniqued, immortal, and owned by
 /// MLIRContext.  As such, they are passed around by raw non-const pointer.
 ///
@@ -68,11 +85,34 @@
     MemRef,
   };
 
+  using ImplType = detail::TypeStorage;
+
+  Type() : type(nullptr) {}
+  /* implicit */ Type(const ImplType *type)
+      : type(const_cast<ImplType *>(type)) {}
+
+  Type(const Type &other) : type(other.type) {}
+  Type &operator=(Type other) {
+    type = other.type;
+    return *this;
+  }
+
+  bool operator==(Type other) const { return type == other.type; }
+  bool operator!=(Type other) const { return !(*this == other); }
+  explicit operator bool() const { return type; }
+
+  bool operator!() const { return type == nullptr; }
+
+  template <typename U> bool isa() const;
+  template <typename U> U dyn_cast() const;
+  template <typename U> U dyn_cast_or_null() const;
+  template <typename U> U cast() const;
+
   /// Return the classification for this type.
-  Kind getKind() const { return kind; }
+  Kind getKind() const;
 
   /// Return the LLVMContext in which this type was uniqued.
-  MLIRContext *getContext() const { return context; }
+  MLIRContext *getContext() const;
 
   // Convenience predicates.  This is only for 'other' and floating point types,
   // derived types should use isa/dyn_cast.
@@ -97,56 +137,42 @@
   unsigned getBitWidth() const;
 
   // Convenience factories.
-  static IntegerType *getInteger(unsigned width, MLIRContext *ctx);
-  static FloatType *getBF16(MLIRContext *ctx);
-  static FloatType *getF16(MLIRContext *ctx);
-  static FloatType *getF32(MLIRContext *ctx);
-  static FloatType *getF64(MLIRContext *ctx);
-  static OtherType *getIndex(MLIRContext *ctx);
-  static OtherType *getTFControl(MLIRContext *ctx);
-  static OtherType *getTFString(MLIRContext *ctx);
-  static OtherType *getTFResource(MLIRContext *ctx);
-  static OtherType *getTFVariant(MLIRContext *ctx);
-  static OtherType *getTFComplex64(MLIRContext *ctx);
-  static OtherType *getTFComplex128(MLIRContext *ctx);
-  static OtherType *getTFF32REF(MLIRContext *ctx);
+  static IntegerType getInteger(unsigned width, MLIRContext *ctx);
+  static FloatType getBF16(MLIRContext *ctx);
+  static FloatType getF16(MLIRContext *ctx);
+  static FloatType getF32(MLIRContext *ctx);
+  static FloatType getF64(MLIRContext *ctx);
+  static OtherType getIndex(MLIRContext *ctx);
+  static OtherType getTFControl(MLIRContext *ctx);
+  static OtherType getTFString(MLIRContext *ctx);
+  static OtherType getTFResource(MLIRContext *ctx);
+  static OtherType getTFVariant(MLIRContext *ctx);
+  static OtherType getTFComplex64(MLIRContext *ctx);
+  static OtherType getTFComplex128(MLIRContext *ctx);
+  static OtherType getTFF32REF(MLIRContext *ctx);
 
   /// Print the current type.
   void print(raw_ostream &os) const;
   void dump() const;
 
+  friend ::llvm::hash_code hash_value(Type arg);
+
+  unsigned getSubclassData() const;
+  void setSubclassData(unsigned val);
+
+  /// Methods for supporting PointerLikeTypeTraits.
+  const void *getAsOpaquePointer() const {
+    return static_cast<const void *>(type);
+  }
+  static Type getFromOpaquePointer(const void *pointer) {
+    return Type((ImplType *)(pointer));
+  }
+
 protected:
-  explicit Type(Kind kind, MLIRContext *context)
-      : context(context), kind(kind), subclassData(0) {}
-  explicit Type(Kind kind, MLIRContext *context, unsigned subClassData)
-      : Type(kind, context) {
-    setSubclassData(subClassData);
-  }
-
-  ~Type() {}
-
-  unsigned getSubclassData() const { return subclassData; }
-
-  void setSubclassData(unsigned val) {
-    subclassData = val;
-    // Ensure we don't have any accidental truncation.
-    assert(getSubclassData() == val && "Subclass data too large for field");
-  }
-
-private:
-  Type(const Type&) = delete;
-  void operator=(const Type&) = delete;
-  /// This refers to the MLIRContext in which this type was uniqued.
-  MLIRContext *const context;
-
-  /// Classification of the subclass, used for type checking.
-  Kind kind : 8;
-
-  // Space for subclasses to store data.
-  unsigned subclassData : 24;
+  ImplType *type;
 };
 
-inline raw_ostream &operator<<(raw_ostream &os, const Type &type) {
+inline raw_ostream &operator<<(raw_ostream &os, Type type) {
   type.print(os);
   return os;
 }
@@ -154,148 +180,138 @@
 /// Integer types can have arbitrary bitwidth up to a large fixed limit.
 class IntegerType : public Type {
 public:
-  static IntegerType *get(unsigned width, MLIRContext *context);
+  using ImplType = detail::IntegerTypeStorage;
+  IntegerType() = default;
+  /* implicit */ IntegerType(Type::ImplType *ptr);
+
+  static IntegerType get(unsigned width, MLIRContext *context);
 
   /// Return the bitwidth of this integer type.
-  unsigned getWidth() const {
-    return width;
-  }
+  unsigned getWidth() const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool classof(const Type *type) {
-    return type->getKind() == Kind::Integer;
-  }
+  static bool kindof(Kind kind) { return kind == Kind::Integer; }
 
   /// Integer representation maximal bitwidth.
   static constexpr unsigned kMaxWidth = 4096;
-private:
-  unsigned width;
-  IntegerType(unsigned width, MLIRContext *context);
-  ~IntegerType() = delete;
 };
 
-inline IntegerType *Type::getInteger(unsigned width, MLIRContext *ctx) {
+inline IntegerType Type::getInteger(unsigned width, MLIRContext *ctx) {
   return IntegerType::get(width, ctx);
 }
 
 /// Return true if this is an integer type with the specified width.
 inline bool Type::isInteger(unsigned width) const {
-  if (auto *intTy = dyn_cast<IntegerType>(this))
-    return intTy->getWidth() == width;
+  if (auto intTy = dyn_cast<IntegerType>())
+    return intTy.getWidth() == width;
   return false;
 }
 
 class FloatType : public Type {
 public:
+  using ImplType = detail::FloatTypeStorage;
+  FloatType() = default;
+  /* implicit */ FloatType(Type::ImplType *ptr);
+
+  static FloatType get(Kind kind, MLIRContext *context);
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool classof(const Type *type) {
-    return type->getKind() >= Kind::FIRST_FLOATING_POINT_TYPE &&
-           type->getKind() <= Kind::LAST_FLOATING_POINT_TYPE;
+  static bool kindof(Kind kind) {
+    return kind >= Kind::FIRST_FLOATING_POINT_TYPE &&
+           kind <= Kind::LAST_FLOATING_POINT_TYPE;
   }
-
-  static FloatType *get(Kind kind, MLIRContext *context);
-
-private:
-  FloatType(Kind kind, MLIRContext *context);
-  ~FloatType() = delete;
 };
 
-inline FloatType *Type::getBF16(MLIRContext *ctx) {
+inline FloatType Type::getBF16(MLIRContext *ctx) {
   return FloatType::get(Kind::BF16, ctx);
 }
-inline FloatType *Type::getF16(MLIRContext *ctx) {
+inline FloatType Type::getF16(MLIRContext *ctx) {
   return FloatType::get(Kind::F16, ctx);
 }
-inline FloatType *Type::getF32(MLIRContext *ctx) {
+inline FloatType Type::getF32(MLIRContext *ctx) {
   return FloatType::get(Kind::F32, ctx);
 }
-inline FloatType *Type::getF64(MLIRContext *ctx) {
+inline FloatType Type::getF64(MLIRContext *ctx) {
   return FloatType::get(Kind::F64, ctx);
 }
 
 /// This is a type for the random collection of special base types.
 class OtherType : public Type {
 public:
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool classof(const Type *type) {
-    return type->getKind() >= Kind::FIRST_OTHER_TYPE &&
-           type->getKind() <= Kind::LAST_OTHER_TYPE;
-  }
-  static OtherType *get(Kind kind, MLIRContext *context);
+  using ImplType = detail::OtherTypeStorage;
+  OtherType() = default;
+  /* implicit */ OtherType(Type::ImplType *ptr);
 
-private:
-  OtherType(Kind kind, MLIRContext *context);
-  ~OtherType() = delete;
+  static OtherType get(Kind kind, MLIRContext *context);
+
+  /// Methods for support type inquiry through isa, cast, and dyn_cast.
+  static bool kindof(Kind kind) {
+    return kind >= Kind::FIRST_OTHER_TYPE && kind <= Kind::LAST_OTHER_TYPE;
+  }
 };
 
-inline OtherType *Type::getIndex(MLIRContext *ctx) {
+inline OtherType Type::getIndex(MLIRContext *ctx) {
   return OtherType::get(Kind::Index, ctx);
 }
-inline OtherType *Type::getTFControl(MLIRContext *ctx) {
+inline OtherType Type::getTFControl(MLIRContext *ctx) {
   return OtherType::get(Kind::TFControl, ctx);
 }
-inline OtherType *Type::getTFResource(MLIRContext *ctx) {
+inline OtherType Type::getTFResource(MLIRContext *ctx) {
   return OtherType::get(Kind::TFResource, ctx);
 }
-inline OtherType *Type::getTFString(MLIRContext *ctx) {
+inline OtherType Type::getTFString(MLIRContext *ctx) {
   return OtherType::get(Kind::TFString, ctx);
 }
-inline OtherType *Type::getTFVariant(MLIRContext *ctx) {
+inline OtherType Type::getTFVariant(MLIRContext *ctx) {
   return OtherType::get(Kind::TFVariant, ctx);
 }
-inline OtherType *Type::getTFComplex64(MLIRContext *ctx) {
+inline OtherType Type::getTFComplex64(MLIRContext *ctx) {
   return OtherType::get(Kind::TFComplex64, ctx);
 }
-inline OtherType *Type::getTFComplex128(MLIRContext *ctx) {
+inline OtherType Type::getTFComplex128(MLIRContext *ctx) {
   return OtherType::get(Kind::TFComplex128, ctx);
 }
-inline OtherType *Type::getTFF32REF(MLIRContext *ctx) {
+inline OtherType Type::getTFF32REF(MLIRContext *ctx) {
   return OtherType::get(Kind::TFF32REF, ctx);
 }
 
 /// Function types map from a list of inputs to a list of results.
 class FunctionType : public Type {
 public:
-  static FunctionType *get(ArrayRef<Type*> inputs, ArrayRef<Type*> results,
-                           MLIRContext *context);
+  using ImplType = detail::FunctionTypeStorage;
+  FunctionType() = default;
+  /* implicit */ FunctionType(Type::ImplType *ptr);
+
+  static FunctionType get(ArrayRef<Type> inputs, ArrayRef<Type> results,
+                          MLIRContext *context);
 
   // Input types.
   unsigned getNumInputs() const { return getSubclassData(); }
 
-  Type *getInput(unsigned i) const { return getInputs()[i]; }
+  Type getInput(unsigned i) const { return getInputs()[i]; }
 
-  ArrayRef<Type*> getInputs() const {
-    return ArrayRef<Type *>(inputsAndResults, getNumInputs());
-  }
+  ArrayRef<Type> getInputs() const;
 
   // Result types.
-  unsigned getNumResults() const { return numResults; }
+  unsigned getNumResults() const;
 
-  Type *getResult(unsigned i) const { return getResults()[i]; }
+  Type getResult(unsigned i) const { return getResults()[i]; }
 
-  ArrayRef<Type*> getResults() const {
-    return ArrayRef<Type *>(inputsAndResults + getSubclassData(), numResults);
-  }
+  ArrayRef<Type> getResults() const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool classof(const Type *type) {
-    return type->getKind() == Kind::Function;
-  }
-
-private:
-  unsigned numResults;
-  Type *const *inputsAndResults;
-
-  FunctionType(Type *const *inputsAndResults, unsigned numInputs,
-               unsigned numResults, MLIRContext *context);
-  ~FunctionType() = delete;
+  static bool kindof(Kind kind) { return kind == Kind::Function; }
 };
 
 /// This is a common base class between Vector, UnrankedTensor, and RankedTensor
 /// types, because many operations work on values of these aggregate types.
 class VectorOrTensorType : public Type {
 public:
-  Type *getElementType() const { return elementType; }
+  using ImplType = detail::VectorOrTensorTypeStorage;
+  VectorOrTensorType() = default;
+  /* implicit */ VectorOrTensorType(Type::ImplType *ptr);
+
+  Type getElementType() const;
 
   /// If this is ranked tensor or vector type, return the number of elements. If
   /// it is an unranked tensor or vector, abort.
@@ -319,56 +335,40 @@
   int getDimSize(unsigned i) const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool classof(const Type *type) {
-    return type->getKind() == Kind::Vector ||
-           type->getKind() == Kind::RankedTensor ||
-           type->getKind() == Kind::UnrankedTensor;
+  static bool kindof(Kind kind) {
+    return kind == Kind::Vector || kind == Kind::RankedTensor ||
+           kind == Kind::UnrankedTensor;
   }
-
-public:
-  Type *elementType;
-
-  VectorOrTensorType(Kind kind, MLIRContext *context, Type *elementType,
-                     unsigned subClassData = 0);
 };
 
 /// Vector types represent multi-dimensional SIMD vectors, and have a fixed
 /// known constant shape with one or more dimension.
 class VectorType : public VectorOrTensorType {
 public:
-  static VectorType *get(ArrayRef<int> shape, Type *elementType);
+  using ImplType = detail::VectorTypeStorage;
+  VectorType() = default;
+  /* implicit */ VectorType(Type::ImplType *ptr);
 
-  ArrayRef<int> getShape() const {
-    return ArrayRef<int>(shapeElements, getSubclassData());
-  }
+  static VectorType get(ArrayRef<int> shape, Type elementType);
+
+  ArrayRef<int> getShape() const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool classof(const Type *type) {
-    return type->getKind() == Kind::Vector;
-  }
-
-private:
-  const int *shapeElements;
-  Type *elementType;
-
-  VectorType(ArrayRef<int> shape, Type *elementType, MLIRContext *context);
-  ~VectorType() = delete;
+  static bool kindof(Kind kind) { return kind == Kind::Vector; }
 };
 
 /// Tensor types represent multi-dimensional arrays, and have two variants:
 /// RankedTensorType and UnrankedTensorType.
 class TensorType : public VectorOrTensorType {
 public:
+  using ImplType = detail::TensorTypeStorage;
+  TensorType() = default;
+  /* implicit */ TensorType(Type::ImplType *ptr);
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool classof(const Type *type) {
-    return type->getKind() == Kind::RankedTensor ||
-           type->getKind() == Kind::UnrankedTensor;
+  static bool kindof(Kind kind) {
+    return kind == Kind::RankedTensor || kind == Kind::UnrankedTensor;
   }
-
-protected:
-  TensorType(Kind kind, Type *elementType, MLIRContext *context);
-  ~TensorType() {}
 };
 
 /// Ranked tensor types represent multi-dimensional arrays that have a shape
@@ -376,40 +376,30 @@
 /// integer or unknown (represented -1).
 class RankedTensorType : public TensorType {
 public:
-  static RankedTensorType *get(ArrayRef<int> shape,
-                               Type *elementType);
+  using ImplType = detail::RankedTensorTypeStorage;
+  RankedTensorType() = default;
+  /* implicit */ RankedTensorType(Type::ImplType *ptr);
 
-  ArrayRef<int> getShape() const {
-    return ArrayRef<int>(shapeElements, getSubclassData());
-  }
+  static RankedTensorType get(ArrayRef<int> shape, Type elementType);
 
-  static bool classof(const Type *type) {
-    return type->getKind() == Kind::RankedTensor;
-  }
+  ArrayRef<int> getShape() const;
 
-private:
-  const int *shapeElements;
-
-  RankedTensorType(ArrayRef<int> shape, Type *elementType,
-                   MLIRContext *context);
-  ~RankedTensorType() = delete;
+  static bool kindof(Kind kind) { return kind == Kind::RankedTensor; }
 };
 
 /// Unranked tensor types represent multi-dimensional arrays that have an
 /// unknown shape.
 class UnrankedTensorType : public TensorType {
 public:
-  static UnrankedTensorType *get(Type *elementType);
+  using ImplType = detail::UnrankedTensorTypeStorage;
+  UnrankedTensorType() = default;
+  /* implicit */ UnrankedTensorType(Type::ImplType *ptr);
+
+  static UnrankedTensorType get(Type elementType);
 
   ArrayRef<int> getShape() const { return ArrayRef<int>(); }
 
-  static bool classof(const Type *type) {
-    return type->getKind() == Kind::UnrankedTensor;
-  }
-
-private:
-  UnrankedTensorType(Type *elementType, MLIRContext *context);
-  ~UnrankedTensorType() = delete;
+  static bool kindof(Kind kind) { return kind == Kind::UnrankedTensor; }
 };
 
 /// MemRef types represent a region of memory that have a shape with a fixed
@@ -418,62 +408,96 @@
 /// affine map composition, represented as an array AffineMap pointers.
 class MemRefType : public Type {
 public:
+  using ImplType = detail::MemRefTypeStorage;
+  MemRefType() = default;
+  /* implicit */ MemRefType(Type::ImplType *ptr);
+
   /// Get or create a new MemRefType based on shape, element type, affine
   /// map composition, and memory space.
-  static MemRefType *get(ArrayRef<int> shape, Type *elementType,
-                         ArrayRef<AffineMap> affineMapComposition,
-                         unsigned memorySpace);
+  static MemRefType get(ArrayRef<int> shape, Type elementType,
+                        ArrayRef<AffineMap> affineMapComposition,
+                        unsigned memorySpace);
 
   unsigned getRank() const { return getShape().size(); }
 
   /// Returns an array of memref shape dimension sizes.
-  ArrayRef<int> getShape() const {
-    return ArrayRef<int>(shapeElements, getSubclassData());
-  }
+  ArrayRef<int> getShape() const;
 
   /// Return the size of the specified dimension, or -1 if unspecified.
   int getDimSize(unsigned i) const { return getShape()[i]; }
 
   /// Returns the elemental type for this memref shape.
-  Type *getElementType() const { return elementType; }
+  Type getElementType() const;
 
   /// Returns an array of affine map pointers representing the memref affine
   /// map composition.
   ArrayRef<AffineMap> getAffineMaps() const;
 
   /// Returns the memory space in which data referred to by this memref resides.
-  unsigned getMemorySpace() const { return memorySpace; }
+  unsigned getMemorySpace() const;
 
   /// Returns the number of dimensions with dynamic size.
   unsigned getNumDynamicDims() const;
 
-  static bool classof(const Type *type) {
-    return type->getKind() == Kind::MemRef;
-  }
-
-private:
-  /// The type of each scalar element of the memref.
-  Type *elementType;
-  /// An array of integers which stores the shape dimension sizes.
-  const int *shapeElements;
-  /// The number of affine maps in the 'affineMapList' array.
-  const unsigned numAffineMaps;
-  /// List of affine maps in the memref's layout/index map composition.
-  AffineMap const *affineMapList;
-  /// Memory space in which data referenced by memref resides.
-  const unsigned memorySpace;
-
-  MemRefType(ArrayRef<int> shape, Type *elementType,
-             ArrayRef<AffineMap> affineMapList, unsigned memorySpace,
-             MLIRContext *context);
-  ~MemRefType() = delete;
+  static bool kindof(Kind kind) { return kind == Kind::MemRef; }
 };
 
-/// Return true if the specified element type is ok in a tensor.
-static bool isValidTensorElementType(Type *type) {
-  return isa<FloatType>(type) || isa<VectorType>(type) ||
-         isa<IntegerType>(type) || isa<OtherType>(type);
+// Make Type hashable.
+inline ::llvm::hash_code hash_value(Type arg) {
+  return ::llvm::hash_value(arg.type);
 }
+
+template <typename U> bool Type::isa() const {
+  assert(type && "isa<> used on a null type.");
+  return U::kindof(getKind());
+}
+template <typename U> U Type::dyn_cast() const {
+  return isa<U>() ? U(type) : U(nullptr);
+}
+template <typename U> U Type::dyn_cast_or_null() const {
+  return (type && isa<U>()) ? U(type) : U(nullptr);
+}
+template <typename U> U Type::cast() const {
+  assert(isa<U>());
+  return U(type);
+}
+
+/// Return true if the specified element type is ok in a tensor.
+static bool isValidTensorElementType(Type type) {
+  return type.isa<FloatType>() || type.isa<VectorType>() ||
+         type.isa<IntegerType>() || type.isa<OtherType>();
+}
+
 } // end namespace mlir
 
+namespace llvm {
+
+// Type hash just like pointers.
+template <> struct DenseMapInfo<mlir::Type> {
+  static mlir::Type getEmptyKey() {
+    auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
+    return mlir::Type(static_cast<mlir::Type::ImplType *>(pointer));
+  }
+  static mlir::Type getTombstoneKey() {
+    auto pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
+    return mlir::Type(static_cast<mlir::Type::ImplType *>(pointer));
+  }
+  static unsigned getHashValue(mlir::Type val) { return mlir::hash_value(val); }
+  static bool isEqual(mlir::Type LHS, mlir::Type RHS) { return LHS == RHS; }
+};
+
+/// We align TypeStorage by 8, so allow LLVM to steal the low bits.
+template <> struct PointerLikeTypeTraits<mlir::Type> {
+public:
+  static inline void *getAsVoidPointer(mlir::Type I) {
+    return const_cast<void *>(I.getAsOpaquePointer());
+  }
+  static inline mlir::Type getFromVoidPointer(void *P) {
+    return mlir::Type::getFromOpaquePointer(P);
+  }
+  enum { NumLowBitsAvailable = 3 };
+};
+
+} // namespace llvm
+
 #endif  // MLIR_IR_TYPES_H
diff --git a/include/mlir/StandardOps/StandardOps.h b/include/mlir/StandardOps/StandardOps.h
index b733bad..c0fe4cf 100644
--- a/include/mlir/StandardOps/StandardOps.h
+++ b/include/mlir/StandardOps/StandardOps.h
@@ -104,15 +104,15 @@
     : public Op<AllocOp, OpTrait::VariadicOperands, OpTrait::OneResult> {
 public:
   /// The result of an alloc is always a MemRefType.
-  MemRefType *getType() const {
-    return cast<MemRefType>(getResult()->getType());
+  MemRefType getType() const {
+    return getResult()->getType().cast<MemRefType>();
   }
 
   static StringRef getOperationName() { return "alloc"; }
 
   // Hooks to customize behavior of this op.
   static void build(Builder *builder, OperationState *result,
-                    MemRefType *memrefType, ArrayRef<SSAValue *> operands = {});
+                    MemRefType memrefType, ArrayRef<SSAValue *> operands = {});
   bool verify() const;
   static bool parse(OpAsmParser *parser, OperationState *result);
   void print(OpAsmPrinter *p) const;
@@ -276,7 +276,7 @@
   const SSAValue *getSrcMemRef() const { return getOperand(0); }
   // Returns the rank (number of indices) of the source MemRefType.
   unsigned getSrcMemRefRank() const {
-    return cast<MemRefType>(getSrcMemRef()->getType())->getRank();
+    return getSrcMemRef()->getType().cast<MemRefType>().getRank();
   }
   // Returns the source memerf indices for this DMA operation.
   llvm::iterator_range<Operation::const_operand_iterator>
@@ -291,13 +291,13 @@
   }
   // Returns the rank (number of indices) of the destination MemRefType.
   unsigned getDstMemRefRank() const {
-    return cast<MemRefType>(getDstMemRef()->getType())->getRank();
+    return getDstMemRef()->getType().cast<MemRefType>().getRank();
   }
   unsigned getSrcMemorySpace() const {
-    return cast<MemRefType>(getSrcMemRef()->getType())->getMemorySpace();
+    return getSrcMemRef()->getType().cast<MemRefType>().getMemorySpace();
   }
   unsigned getDstMemorySpace() const {
-    return cast<MemRefType>(getDstMemRef()->getType())->getMemorySpace();
+    return getDstMemRef()->getType().cast<MemRefType>().getMemorySpace();
   }
 
   // Returns the destination memref indices for this DMA operation.
@@ -387,7 +387,7 @@
 
   // Returns the rank (number of indices) of the tag memref.
   unsigned getTagMemRefRank() const {
-    return cast<MemRefType>(getTagMemRef()->getType())->getRank();
+    return getTagMemRef()->getType().cast<MemRefType>().getRank();
   }
 
   // Returns the number of elements transferred in the associated DMA operation.
@@ -460,8 +460,8 @@
   SSAValue *getMemRef() { return getOperand(0); }
   const SSAValue *getMemRef() const { return getOperand(0); }
   void setMemRef(SSAValue *value) { setOperand(0, value); }
-  MemRefType *getMemRefType() const {
-    return cast<MemRefType>(getMemRef()->getType());
+  MemRefType getMemRefType() const {
+    return getMemRef()->getType().cast<MemRefType>();
   }
 
   llvm::iterator_range<Operation::operand_iterator> getIndices() {
@@ -508,8 +508,8 @@
   static StringRef getOperationName() { return "memref_cast"; }
 
   /// The result of a memref_cast is always a memref.
-  MemRefType *getType() const {
-    return cast<MemRefType>(getResult()->getType());
+  MemRefType getType() const {
+    return getResult()->getType().cast<MemRefType>();
   }
 
   bool verify() const;
@@ -583,8 +583,8 @@
   SSAValue *getMemRef() { return getOperand(1); }
   const SSAValue *getMemRef() const { return getOperand(1); }
   void setMemRef(SSAValue *value) { setOperand(1, value); }
-  MemRefType *getMemRefType() const {
-    return cast<MemRefType>(getMemRef()->getType());
+  MemRefType getMemRefType() const {
+    return getMemRef()->getType().cast<MemRefType>();
   }
 
   llvm::iterator_range<Operation::operand_iterator> getIndices() {
@@ -671,8 +671,8 @@
   static StringRef getOperationName() { return "tensor_cast"; }
 
   /// The result of a tensor_cast is always a tensor.
-  TensorType *getType() const {
-    return cast<TensorType>(getResult()->getType());
+  TensorType getType() const {
+    return getResult()->getType().cast<TensorType>();
   }
 
   bool verify() const;
diff --git a/lib/Analysis/LoopAnalysis.cpp b/lib/Analysis/LoopAnalysis.cpp
index 1b3c24f..1904a63 100644
--- a/lib/Analysis/LoopAnalysis.cpp
+++ b/lib/Analysis/LoopAnalysis.cpp
@@ -118,15 +118,15 @@
   return tripCountExpr.getLargestKnownDivisor();
 }
 
-bool mlir::isAccessInvariant(const MLValue &input, MemRefType *memRefType,
+bool mlir::isAccessInvariant(const MLValue &input, MemRefType memRefType,
                              ArrayRef<MLValue *> indices, unsigned dim) {
-  assert(indices.size() == memRefType->getRank());
+  assert(indices.size() == memRefType.getRank());
   assert(dim < indices.size());
-  auto layoutMap = memRefType->getAffineMaps();
-  assert(memRefType->getAffineMaps().size() <= 1);
+  auto layoutMap = memRefType.getAffineMaps();
+  assert(memRefType.getAffineMaps().size() <= 1);
   // TODO(ntv): remove dependency on Builder once we support non-identity
   // layout map.
-  Builder b(memRefType->getContext());
+  Builder b(memRefType.getContext());
   assert(layoutMap.empty() ||
          layoutMap[0] == b.getMultiDimIdentityMap(indices.size()));
   (void)layoutMap;
@@ -170,7 +170,7 @@
   using namespace functional;
   auto indices = map([](SSAValue *val) { return dyn_cast<MLValue>(val); },
                      memoryOp->getIndices());
-  auto *memRefType = memoryOp->getMemRefType();
+  auto memRefType = memoryOp->getMemRefType();
   for (unsigned d = 0, numIndices = indices.size(); d < numIndices; ++d) {
     if (fastestVaryingDim == (numIndices - 1) - d) {
       continue;
@@ -184,8 +184,8 @@
 
 template <typename LoadOrStoreOpPointer>
 static bool isVectorElement(LoadOrStoreOpPointer memoryOp) {
-  auto *memRefType = memoryOp->getMemRefType();
-  return isa<VectorType>(memRefType->getElementType());
+  auto memRefType = memoryOp->getMemRefType();
+  return memRefType.getElementType().template isa<VectorType>();
 }
 
 bool mlir::isVectorizableLoop(const ForStmt &loop, unsigned fastestVaryingDim) {
diff --git a/lib/Analysis/Verifier.cpp b/lib/Analysis/Verifier.cpp
index bfbcb16..0dd030d 100644
--- a/lib/Analysis/Verifier.cpp
+++ b/lib/Analysis/Verifier.cpp
@@ -195,7 +195,7 @@
 
   // Verify that the argument list of the function and the arg list of the first
   // block line up.
-  auto fnInputTypes = fn.getType()->getInputs();
+  auto fnInputTypes = fn.getType().getInputs();
   if (fnInputTypes.size() != firstBB->getNumArguments())
     return failure("first block of cfgfunc must have " +
                        Twine(fnInputTypes.size()) +
@@ -306,7 +306,7 @@
 
 bool CFGFuncVerifier::verifyReturn(const ReturnInst &inst) {
   // Verify that the return operands match the results of the function.
-  auto results = fn.getType()->getResults();
+  auto results = fn.getType().getResults();
   if (inst.getNumOperands() != results.size())
     return failure("return has " + Twine(inst.getNumOperands()) +
                        " operands, but enclosing function returns " +
diff --git a/lib/IR/AsmPrinter.cpp b/lib/IR/AsmPrinter.cpp
index 454a28a..cb5e96f 100644
--- a/lib/IR/AsmPrinter.cpp
+++ b/lib/IR/AsmPrinter.cpp
@@ -122,7 +122,7 @@
   void visitForStmt(const ForStmt *forStmt);
   void visitIfStmt(const IfStmt *ifStmt);
   void visitOperationStmt(const OperationStmt *opStmt);
-  void visitType(const Type *type);
+  void visitType(Type type);
   void visitAttribute(Attribute attr);
   void visitOperation(const Operation *op);
 
@@ -135,16 +135,16 @@
 } // end anonymous namespace
 
 // TODO Support visiting other types/instructions when implemented.
-void ModuleState::visitType(const Type *type) {
-  if (auto *funcType = dyn_cast<FunctionType>(type)) {
+void ModuleState::visitType(Type type) {
+  if (auto funcType = type.dyn_cast<FunctionType>()) {
     // Visit input and result types for functions.
-    for (auto *input : funcType->getInputs())
+    for (auto input : funcType.getInputs())
       visitType(input);
-    for (auto *result : funcType->getResults())
+    for (auto result : funcType.getResults())
       visitType(result);
-  } else if (auto *memref = dyn_cast<MemRefType>(type)) {
+  } else if (auto memref = type.dyn_cast<MemRefType>()) {
     // Visit affine maps in memref type.
-    for (auto map : memref->getAffineMaps()) {
+    for (auto map : memref.getAffineMaps()) {
       recordAffineMapReference(map);
     }
   }
@@ -271,7 +271,7 @@
   void print(const Module *module);
   void printFunctionReference(const Function *func);
   void printAttribute(Attribute attr);
-  void printType(const Type *type);
+  void printType(Type type);
   void print(const Function *fn);
   void print(const ExtFunction *fn);
   void print(const CFGFunction *fn);
@@ -290,7 +290,7 @@
   void printFunctionAttributes(const Function *fn);
   void printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
                              ArrayRef<const char *> elidedAttrs = {});
-  void printFunctionResultType(const FunctionType *type);
+  void printFunctionResultType(FunctionType type);
   void printAffineMapId(int affineMapId) const;
   void printAffineMapReference(AffineMap affineMap);
   void printIntegerSetId(int integerSetId) const;
@@ -489,9 +489,9 @@
 }
 
 void ModulePrinter::printDenseElementsAttr(DenseElementsAttr attr) {
-  auto *type = attr.getType();
-  auto shape = type->getShape();
-  auto rank = type->getRank();
+  auto type = attr.getType();
+  auto shape = type.getShape();
+  auto rank = type.getRank();
 
   SmallVector<Attribute, 16> elements;
   attr.getValues(elements);
@@ -541,8 +541,8 @@
     os << ']';
 }
 
-void ModulePrinter::printType(const Type *type) {
-  switch (type->getKind()) {
+void ModulePrinter::printType(Type type) {
+  switch (type.getKind()) {
   case Type::Kind::Index:
     os << "index";
     return;
@@ -581,71 +581,71 @@
     return;
 
   case Type::Kind::Integer: {
-    auto *integer = cast<IntegerType>(type);
-    os << 'i' << integer->getWidth();
+    auto integer = type.cast<IntegerType>();
+    os << 'i' << integer.getWidth();
     return;
   }
   case Type::Kind::Function: {
-    auto *func = cast<FunctionType>(type);
+    auto func = type.cast<FunctionType>();
     os << '(';
-    interleaveComma(func->getInputs(), [&](Type *type) { printType(type); });
+    interleaveComma(func.getInputs(), [&](Type type) { printType(type); });
     os << ") -> ";
-    auto results = func->getResults();
+    auto results = func.getResults();
     if (results.size() == 1)
-      os << *results[0];
+      os << results[0];
     else {
       os << '(';
-      interleaveComma(results, [&](Type *type) { printType(type); });
+      interleaveComma(results, [&](Type type) { printType(type); });
       os << ')';
     }
     return;
   }
   case Type::Kind::Vector: {
-    auto *v = cast<VectorType>(type);
+    auto v = type.cast<VectorType>();
     os << "vector<";
-    for (auto dim : v->getShape())
+    for (auto dim : v.getShape())
       os << dim << 'x';
-    os << *v->getElementType() << '>';
+    os << v.getElementType() << '>';
     return;
   }
   case Type::Kind::RankedTensor: {
-    auto *v = cast<RankedTensorType>(type);
+    auto v = type.cast<RankedTensorType>();
     os << "tensor<";
-    for (auto dim : v->getShape()) {
+    for (auto dim : v.getShape()) {
       if (dim < 0)
         os << '?';
       else
         os << dim;
       os << 'x';
     }
-    os << *v->getElementType() << '>';
+    os << v.getElementType() << '>';
     return;
   }
   case Type::Kind::UnrankedTensor: {
-    auto *v = cast<UnrankedTensorType>(type);
+    auto v = type.cast<UnrankedTensorType>();
     os << "tensor<*x";
-    printType(v->getElementType());
+    printType(v.getElementType());
     os << '>';
     return;
   }
   case Type::Kind::MemRef: {
-    auto *v = cast<MemRefType>(type);
+    auto v = type.cast<MemRefType>();
     os << "memref<";
-    for (auto dim : v->getShape()) {
+    for (auto dim : v.getShape()) {
       if (dim < 0)
         os << '?';
       else
         os << dim;
       os << 'x';
     }
-    printType(v->getElementType());
-    for (auto map : v->getAffineMaps()) {
+    printType(v.getElementType());
+    for (auto map : v.getAffineMaps()) {
       os << ", ";
       printAffineMapReference(map);
     }
     // Only print the memory space if it is the non-default one.
-    if (v->getMemorySpace())
-      os << ", " << v->getMemorySpace();
+    if (v.getMemorySpace())
+      os << ", " << v.getMemorySpace();
     os << '>';
     return;
   }
@@ -842,18 +842,18 @@
 // Function printing
 //===----------------------------------------------------------------------===//
 
-void ModulePrinter::printFunctionResultType(const FunctionType *type) {
-  switch (type->getResults().size()) {
+void ModulePrinter::printFunctionResultType(FunctionType type) {
+  switch (type.getResults().size()) {
   case 0:
     break;
   case 1:
     os << " -> ";
-    printType(type->getResults()[0]);
+    printType(type.getResults()[0]);
     break;
   default:
     os << " -> (";
-    interleaveComma(type->getResults(),
-                    [&](Type *eltType) { printType(eltType); });
+    interleaveComma(type.getResults(),
+                    [&](Type eltType) { printType(eltType); });
     os << ')';
     break;
   }
@@ -871,8 +871,7 @@
   auto type = fn->getType();
 
   os << "@" << fn->getName() << '(';
-  interleaveComma(type->getInputs(),
-                  [&](Type *eltType) { printType(eltType); });
+  interleaveComma(type.getInputs(), [&](Type eltType) { printType(eltType); });
   os << ')';
 
   printFunctionResultType(type);
@@ -937,7 +936,7 @@
 
   // Implement OpAsmPrinter.
   raw_ostream &getStream() const { return os; }
-  void printType(const Type *type) { ModulePrinter::printType(type); }
+  void printType(Type type) { ModulePrinter::printType(type); }
   void printAttribute(Attribute attr) { ModulePrinter::printAttribute(attr); }
   void printAffineMap(AffineMap map) {
     return ModulePrinter::printAffineMapReference(map);
@@ -974,10 +973,10 @@
     if (auto *op = value->getDefiningOperation()) {
       if (auto intOp = op->dyn_cast<ConstantIntOp>()) {
         // i1 constants get special names.
-        if (intOp->getType()->isInteger(1)) {
+        if (intOp->getType().isInteger(1)) {
           specialName << (intOp->getValue() ? "true" : "false");
         } else {
-          specialName << 'c' << intOp->getValue() << '_' << *intOp->getType();
+          specialName << 'c' << intOp->getValue() << '_' << intOp->getType();
         }
       } else if (auto intOp = op->dyn_cast<ConstantIndexOp>()) {
         specialName << 'c' << intOp->getValue();
@@ -1579,7 +1578,7 @@
 
 void Type::print(raw_ostream &os) const {
   ModuleState state(getContext());
-  ModulePrinter(os, state).printType(this);
+  ModulePrinter(os, state).printType(*this);
 }
 
 void Type::dump() const { print(llvm::errs()); }
diff --git a/lib/IR/AttributeDetail.h b/lib/IR/AttributeDetail.h
index a0e9afb..63ad544 100644
--- a/lib/IR/AttributeDetail.h
+++ b/lib/IR/AttributeDetail.h
@@ -26,6 +26,7 @@
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/MLIRContext.h"
+#include "mlir/IR/Types.h"
 #include "llvm/Support/TrailingObjects.h"
 
 namespace mlir {
@@ -86,7 +87,7 @@
 
 /// An attribute representing a reference to a type.
 struct TypeAttributeStorage : public AttributeStorage {
-  Type *value;
+  Type value;
 };
 
 /// An attribute representing a reference to a function.
@@ -96,7 +97,7 @@
 
 /// A base attribute representing a reference to a vector or tensor constant.
 struct ElementsAttributeStorage : public AttributeStorage {
-  VectorOrTensorType *type;
+  VectorOrTensorType type;
 };
 
 /// An attribute representing a reference to a vector or tensor constant,
diff --git a/lib/IR/Attributes.cpp b/lib/IR/Attributes.cpp
index 34312b8..58b5b90 100644
--- a/lib/IR/Attributes.cpp
+++ b/lib/IR/Attributes.cpp
@@ -75,9 +75,7 @@
 
 TypeAttr::TypeAttr(Attribute::ImplType *ptr) : Attribute(ptr) {}
 
-Type *TypeAttr::getValue() const {
-  return static_cast<ImplType *>(attr)->value;
-}
+Type TypeAttr::getValue() const { return static_cast<ImplType *>(attr)->value; }
 
 FunctionAttr::FunctionAttr(Attribute::ImplType *ptr) : Attribute(ptr) {}
 
@@ -85,11 +83,11 @@
   return static_cast<ImplType *>(attr)->value;
 }
 
-FunctionType *FunctionAttr::getType() const { return getValue()->getType(); }
+FunctionType FunctionAttr::getType() const { return getValue()->getType(); }
 
 ElementsAttr::ElementsAttr(Attribute::ImplType *ptr) : Attribute(ptr) {}
 
-VectorOrTensorType *ElementsAttr::getType() const {
+VectorOrTensorType ElementsAttr::getType() const {
   return static_cast<ImplType *>(attr)->type;
 }
 
@@ -166,8 +164,8 @@
 
 void DenseIntElementsAttr::getValues(SmallVectorImpl<Attribute> &values) const {
   auto bitsWidth = static_cast<ImplType *>(attr)->bitsWidth;
-  auto elementNum = getType()->getNumElements();
-  auto context = getType()->getContext();
+  auto elementNum = getType().getNumElements();
+  auto context = getType().getContext();
   values.reserve(elementNum);
   if (bitsWidth == 64) {
     ArrayRef<int64_t> vs(
@@ -192,8 +190,8 @@
     : DenseElementsAttr(ptr) {}
 
 void DenseFPElementsAttr::getValues(SmallVectorImpl<Attribute> &values) const {
-  auto elementNum = getType()->getNumElements();
-  auto context = getType()->getContext();
+  auto elementNum = getType().getNumElements();
+  auto context = getType().getContext();
   ArrayRef<double> vs({reinterpret_cast<const double *>(getRawData().data()),
                        getRawData().size() / 8});
   values.reserve(elementNum);
diff --git a/lib/IR/BasicBlock.cpp b/lib/IR/BasicBlock.cpp
index bb8ac75..29a5ce1 100644
--- a/lib/IR/BasicBlock.cpp
+++ b/lib/IR/BasicBlock.cpp
@@ -33,18 +33,18 @@
 // Argument list management.
 //===----------------------------------------------------------------------===//
 
-BBArgument *BasicBlock::addArgument(Type *type) {
+BBArgument *BasicBlock::addArgument(Type type) {
   auto *arg = new BBArgument(type, this);
   arguments.push_back(arg);
   return arg;
 }
 
 /// Add one argument to the argument list for each type specified in the list.
-auto BasicBlock::addArguments(ArrayRef<Type *> types)
+auto BasicBlock::addArguments(ArrayRef<Type> types)
     -> llvm::iterator_range<args_iterator> {
   arguments.reserve(arguments.size() + types.size());
   auto initialSize = arguments.size();
-  for (auto *type : types) {
+  for (auto type : types) {
     addArgument(type);
   }
   return {arguments.data() + initialSize, arguments.data() + arguments.size()};
diff --git a/lib/IR/Builders.cpp b/lib/IR/Builders.cpp
index 22d749a..906b580 100644
--- a/lib/IR/Builders.cpp
+++ b/lib/IR/Builders.cpp
@@ -52,59 +52,58 @@
 // Types.
 //===----------------------------------------------------------------------===//
 
-FloatType *Builder::getBF16Type() { return Type::getBF16(context); }
+FloatType Builder::getBF16Type() { return Type::getBF16(context); }
 
-FloatType *Builder::getF16Type() { return Type::getF16(context); }
+FloatType Builder::getF16Type() { return Type::getF16(context); }
 
-FloatType *Builder::getF32Type() { return Type::getF32(context); }
+FloatType Builder::getF32Type() { return Type::getF32(context); }
 
-FloatType *Builder::getF64Type() { return Type::getF64(context); }
+FloatType Builder::getF64Type() { return Type::getF64(context); }
 
-OtherType *Builder::getIndexType() { return Type::getIndex(context); }
+OtherType Builder::getIndexType() { return Type::getIndex(context); }
 
-OtherType *Builder::getTFControlType() { return Type::getTFControl(context); }
+OtherType Builder::getTFControlType() { return Type::getTFControl(context); }
 
-OtherType *Builder::getTFResourceType() { return Type::getTFResource(context); }
+OtherType Builder::getTFResourceType() { return Type::getTFResource(context); }
 
-OtherType *Builder::getTFVariantType() { return Type::getTFVariant(context); }
+OtherType Builder::getTFVariantType() { return Type::getTFVariant(context); }
 
-OtherType *Builder::getTFComplex64Type() {
+OtherType Builder::getTFComplex64Type() {
   return Type::getTFComplex64(context);
 }
 
-OtherType *Builder::getTFComplex128Type() {
+OtherType Builder::getTFComplex128Type() {
   return Type::getTFComplex128(context);
 }
 
-OtherType *Builder::getTFF32REFType() { return Type::getTFF32REF(context); }
+OtherType Builder::getTFF32REFType() { return Type::getTFF32REF(context); }
 
-OtherType *Builder::getTFStringType() { return Type::getTFString(context); }
+OtherType Builder::getTFStringType() { return Type::getTFString(context); }
 
-IntegerType *Builder::getIntegerType(unsigned width) {
+IntegerType Builder::getIntegerType(unsigned width) {
   return Type::getInteger(width, context);
 }
 
-FunctionType *Builder::getFunctionType(ArrayRef<Type *> inputs,
-                                       ArrayRef<Type *> results) {
+FunctionType Builder::getFunctionType(ArrayRef<Type> inputs,
+                                      ArrayRef<Type> results) {
   return FunctionType::get(inputs, results, context);
 }
 
-MemRefType *Builder::getMemRefType(ArrayRef<int> shape, Type *elementType,
-                                   ArrayRef<AffineMap> affineMapComposition,
-                                   unsigned memorySpace) {
+MemRefType Builder::getMemRefType(ArrayRef<int> shape, Type elementType,
+                                  ArrayRef<AffineMap> affineMapComposition,
+                                  unsigned memorySpace) {
   return MemRefType::get(shape, elementType, affineMapComposition, memorySpace);
 }
 
-VectorType *Builder::getVectorType(ArrayRef<int> shape, Type *elementType) {
+VectorType Builder::getVectorType(ArrayRef<int> shape, Type elementType) {
   return VectorType::get(shape, elementType);
 }
 
-RankedTensorType *Builder::getTensorType(ArrayRef<int> shape,
-                                         Type *elementType) {
+RankedTensorType Builder::getTensorType(ArrayRef<int> shape, Type elementType) {
   return RankedTensorType::get(shape, elementType);
 }
 
-UnrankedTensorType *Builder::getTensorType(Type *elementType) {
+UnrankedTensorType Builder::getTensorType(Type elementType) {
   return UnrankedTensorType::get(elementType);
 }
 
@@ -144,7 +143,7 @@
   return IntegerSetAttr::get(set);
 }
 
-TypeAttr Builder::getTypeAttr(Type *type) {
+TypeAttr Builder::getTypeAttr(Type type) {
   return TypeAttr::get(type, context);
 }
 
@@ -152,23 +151,23 @@
   return FunctionAttr::get(value, context);
 }
 
-ElementsAttr Builder::getSplatElementsAttr(VectorOrTensorType *type,
+ElementsAttr Builder::getSplatElementsAttr(VectorOrTensorType type,
                                            Attribute elt) {
   return SplatElementsAttr::get(type, elt);
 }
 
-ElementsAttr Builder::getDenseElementsAttr(VectorOrTensorType *type,
+ElementsAttr Builder::getDenseElementsAttr(VectorOrTensorType type,
                                            ArrayRef<char> data) {
   return DenseElementsAttr::get(type, data);
 }
 
-ElementsAttr Builder::getSparseElementsAttr(VectorOrTensorType *type,
+ElementsAttr Builder::getSparseElementsAttr(VectorOrTensorType type,
                                             DenseIntElementsAttr indices,
                                             DenseElementsAttr values) {
   return SparseElementsAttr::get(type, indices, values);
 }
 
-ElementsAttr Builder::getOpaqueElementsAttr(VectorOrTensorType *type,
+ElementsAttr Builder::getOpaqueElementsAttr(VectorOrTensorType type,
                                             StringRef bytes) {
   return OpaqueElementsAttr::get(type, bytes);
 }
@@ -296,7 +295,7 @@
 OperationStmt *MLFuncBuilder::createOperation(Location *location,
                                               OperationName name,
                                               ArrayRef<MLValue *> operands,
-                                              ArrayRef<Type *> types,
+                                              ArrayRef<Type> types,
                                               ArrayRef<NamedAttribute> attrs) {
   auto *op = OperationStmt::create(location, name, operands, types, attrs,
                                    getContext());
diff --git a/lib/IR/BuiltinOps.cpp b/lib/IR/BuiltinOps.cpp
index 542e67e..e4bca03 100644
--- a/lib/IR/BuiltinOps.cpp
+++ b/lib/IR/BuiltinOps.cpp
@@ -63,7 +63,7 @@
   numDims = opInfos.size();
 
   // Parse the optional symbol operands.
-  auto *affineIntTy = parser->getBuilder().getIndexType();
+  auto affineIntTy = parser->getBuilder().getIndexType();
   if (parser->parseOperandList(opInfos, -1,
                                OpAsmParser::Delimiter::OptionalSquare) ||
       parser->resolveOperands(opInfos, affineIntTy, operands))
@@ -84,7 +84,7 @@
 
 bool AffineApplyOp::parse(OpAsmParser *parser, OperationState *result) {
   auto &builder = parser->getBuilder();
-  auto *affineIntTy = builder.getIndexType();
+  auto affineIntTy = builder.getIndexType();
 
   AffineMapAttr mapAttr;
   unsigned numDims;
@@ -171,7 +171,7 @@
 
 /// Builds a constant op with the specified attribute value and result type.
 void ConstantOp::build(Builder *builder, OperationState *result,
-                       Attribute value, Type *type) {
+                       Attribute value, Type type) {
   result->addAttribute("value", value);
   result->types.push_back(type);
 }
@@ -181,12 +181,12 @@
   p->printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/"value");
 
   if (!getValue().isa<FunctionAttr>())
-    *p << " : " << *getType();
+    *p << " : " << getType();
 }
 
 bool ConstantOp::parse(OpAsmParser *parser, OperationState *result) {
   Attribute valueAttr;
-  Type *type;
+  Type type;
 
   if (parser->parseAttribute(valueAttr, "value", result->attributes) ||
       parser->parseOptionalAttributeDict(result->attributes))
@@ -208,33 +208,33 @@
   if (!value)
     return emitOpError("requires a 'value' attribute");
 
-  auto *type = this->getType();
-  if (isa<IntegerType>(type) || type->isIndex()) {
+  auto type = this->getType();
+  if (type.isa<IntegerType>() || type.isIndex()) {
     if (!value.isa<IntegerAttr>())
       return emitOpError(
           "requires 'value' to be an integer for an integer result type");
     return false;
   }
 
-  if (isa<FloatType>(type)) {
+  if (type.isa<FloatType>()) {
     if (!value.isa<FloatAttr>())
       return emitOpError("requires 'value' to be a floating point constant");
     return false;
   }
 
-  if (isa<VectorOrTensorType>(type)) {
+  if (type.isa<VectorOrTensorType>()) {
     if (!value.isa<ElementsAttr>())
       return emitOpError("requires 'value' to be a vector/tensor constant");
     return false;
   }
 
-  if (type->isTFString()) {
+  if (type.isTFString()) {
     if (!value.isa<StringAttr>())
       return emitOpError("requires 'value' to be a string constant");
     return false;
   }
 
-  if (isa<FunctionType>(type)) {
+  if (type.isa<FunctionType>()) {
     if (!value.isa<FunctionAttr>())
       return emitOpError("requires 'value' to be a function reference");
     return false;
@@ -251,19 +251,19 @@
 }
 
 void ConstantFloatOp::build(Builder *builder, OperationState *result,
-                            const APFloat &value, FloatType *type) {
+                            const APFloat &value, FloatType type) {
   ConstantOp::build(builder, result, builder->getFloatAttr(value), type);
 }
 
 bool ConstantFloatOp::isClassFor(const Operation *op) {
   return ConstantOp::isClassFor(op) &&
-         isa<FloatType>(op->getResult(0)->getType());
+         op->getResult(0)->getType().isa<FloatType>();
 }
 
 /// ConstantIntOp only matches values whose result type is an IntegerType.
 bool ConstantIntOp::isClassFor(const Operation *op) {
   return ConstantOp::isClassFor(op) &&
-         isa<IntegerType>(op->getResult(0)->getType());
+         op->getResult(0)->getType().isa<IntegerType>();
 }
 
 void ConstantIntOp::build(Builder *builder, OperationState *result,
@@ -275,14 +275,14 @@
 /// Build a constant int op producing an integer with the specified type,
 /// which must be an integer type.
 void ConstantIntOp::build(Builder *builder, OperationState *result,
-                          int64_t value, Type *type) {
-  assert(isa<IntegerType>(type) && "ConstantIntOp can only have integer type");
+                          int64_t value, Type type) {
+  assert(type.isa<IntegerType>() && "ConstantIntOp can only have integer type");
   ConstantOp::build(builder, result, builder->getIntegerAttr(value), type);
 }
 
 /// ConstantIndexOp only matches values whose result type is Index.
 bool ConstantIndexOp::isClassFor(const Operation *op) {
-  return ConstantOp::isClassFor(op) && op->getResult(0)->getType()->isIndex();
+  return ConstantOp::isClassFor(op) && op->getResult(0)->getType().isIndex();
 }
 
 void ConstantIndexOp::build(Builder *builder, OperationState *result,
@@ -302,7 +302,7 @@
 
 bool ReturnOp::parse(OpAsmParser *parser, OperationState *result) {
   SmallVector<OpAsmParser::OperandType, 2> opInfo;
-  SmallVector<Type *, 2> types;
+  SmallVector<Type, 2> types;
   llvm::SMLoc loc;
   return parser->getCurrentLocation(&loc) || parser->parseOperandList(opInfo) ||
          (!opInfo.empty() && parser->parseColonTypeList(types)) ||
@@ -330,7 +330,7 @@
 
     // The operand number and types must match the function signature.
     MLFunction *function = cast<MLFunction>(block);
-    const auto &results = function->getType()->getResults();
+    const auto &results = function->getType().getResults();
     if (stmt->getNumOperands() != results.size())
       return emitOpError("has " + Twine(stmt->getNumOperands()) +
                          " operands, but enclosing function returns " +
diff --git a/lib/IR/Function.cpp b/lib/IR/Function.cpp
index efeb16b..70c0e12 100644
--- a/lib/IR/Function.cpp
+++ b/lib/IR/Function.cpp
@@ -28,8 +28,8 @@
 using namespace mlir;
 
 Function::Function(Kind kind, Location *location, StringRef name,
-                   FunctionType *type, ArrayRef<NamedAttribute> attrs)
-    : nameAndKind(Identifier::get(name, type->getContext()), kind),
+                   FunctionType type, ArrayRef<NamedAttribute> attrs)
+    : nameAndKind(Identifier::get(name, type.getContext()), kind),
       location(location), type(type) {
   this->attrs = AttributeListStorage::get(attrs, getContext());
 }
@@ -46,7 +46,7 @@
     return {};
 }
 
-MLIRContext *Function::getContext() const { return getType()->getContext(); }
+MLIRContext *Function::getContext() const { return getType().getContext(); }
 
 /// Delete this object.
 void Function::destroy() {
@@ -159,7 +159,7 @@
 // ExtFunction implementation.
 //===----------------------------------------------------------------------===//
 
-ExtFunction::ExtFunction(Location *location, StringRef name, FunctionType *type,
+ExtFunction::ExtFunction(Location *location, StringRef name, FunctionType type,
                          ArrayRef<NamedAttribute> attrs)
     : Function(Kind::ExtFunc, location, name, type, attrs) {}
 
@@ -167,7 +167,7 @@
 // CFGFunction implementation.
 //===----------------------------------------------------------------------===//
 
-CFGFunction::CFGFunction(Location *location, StringRef name, FunctionType *type,
+CFGFunction::CFGFunction(Location *location, StringRef name, FunctionType type,
                          ArrayRef<NamedAttribute> attrs)
     : Function(Kind::CFGFunc, location, name, type, attrs) {}
 
@@ -188,9 +188,9 @@
 
 /// Create a new MLFunction with the specific fields.
 MLFunction *MLFunction::create(Location *location, StringRef name,
-                               FunctionType *type,
+                               FunctionType type,
                                ArrayRef<NamedAttribute> attrs) {
-  const auto &argTypes = type->getInputs();
+  const auto &argTypes = type.getInputs();
   auto byteSize = totalSizeToAlloc<MLFuncArgument>(argTypes.size());
   void *rawMem = malloc(byteSize);
 
@@ -204,7 +204,7 @@
   return function;
 }
 
-MLFunction::MLFunction(Location *location, StringRef name, FunctionType *type,
+MLFunction::MLFunction(Location *location, StringRef name, FunctionType type,
                        ArrayRef<NamedAttribute> attrs)
     : Function(Kind::MLFunc, location, name, type, attrs),
       StmtBlock(StmtBlockKind::MLFunc) {}
diff --git a/lib/IR/Instructions.cpp b/lib/IR/Instructions.cpp
index 422636b..d2f49dd 100644
--- a/lib/IR/Instructions.cpp
+++ b/lib/IR/Instructions.cpp
@@ -143,7 +143,7 @@
 /// Create a new OperationInst with the specified fields.
 OperationInst *OperationInst::create(Location *location, OperationName name,
                                      ArrayRef<CFGValue *> operands,
-                                     ArrayRef<Type *> resultTypes,
+                                     ArrayRef<Type> resultTypes,
                                      ArrayRef<NamedAttribute> attributes,
                                      MLIRContext *context) {
   auto byteSize = totalSizeToAlloc<InstOperand, InstResult>(operands.size(),
@@ -167,7 +167,7 @@
 
 OperationInst *OperationInst::clone() const {
   SmallVector<CFGValue *, 8> operands;
-  SmallVector<Type *, 8> resultTypes;
+  SmallVector<Type, 8> resultTypes;
 
   // Put together the operands and results.
   for (auto *operand : getOperands())
diff --git a/lib/IR/MLIRContext.cpp b/lib/IR/MLIRContext.cpp
index 0a2e941..8811f7b 100644
--- a/lib/IR/MLIRContext.cpp
+++ b/lib/IR/MLIRContext.cpp
@@ -21,6 +21,7 @@
 #include "AttributeDetail.h"
 #include "AttributeListStorage.h"
 #include "IntegerSetDetail.h"
+#include "TypeDetail.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Attributes.h"
@@ -44,11 +45,11 @@
 using namespace llvm;
 
 namespace {
-struct FunctionTypeKeyInfo : DenseMapInfo<FunctionType *> {
+struct FunctionTypeKeyInfo : DenseMapInfo<FunctionTypeStorage *> {
   // Functions are uniqued based on their inputs and results.
-  using KeyTy = std::pair<ArrayRef<Type *>, ArrayRef<Type *>>;
-  using DenseMapInfo<FunctionType *>::getHashValue;
-  using DenseMapInfo<FunctionType *>::isEqual;
+  using KeyTy = std::pair<ArrayRef<Type>, ArrayRef<Type>>;
+  using DenseMapInfo<FunctionTypeStorage *>::getHashValue;
+  using DenseMapInfo<FunctionTypeStorage *>::isEqual;
 
   static unsigned getHashValue(KeyTy key) {
     return hash_combine(
@@ -56,7 +57,7 @@
         hash_combine_range(key.second.begin(), key.second.end()));
   }
 
-  static bool isEqual(const KeyTy &lhs, const FunctionType *rhs) {
+  static bool isEqual(const KeyTy &lhs, const FunctionTypeStorage *rhs) {
     if (rhs == getEmptyKey() || rhs == getTombstoneKey())
       return false;
     return lhs == KeyTy(rhs->getInputs(), rhs->getResults());
@@ -109,65 +110,64 @@
   }
 };
 
-struct VectorTypeKeyInfo : DenseMapInfo<VectorType *> {
+struct VectorTypeKeyInfo : DenseMapInfo<VectorTypeStorage *> {
   // Vectors are uniqued based on their element type and shape.
-  using KeyTy = std::pair<Type *, ArrayRef<int>>;
-  using DenseMapInfo<VectorType *>::getHashValue;
-  using DenseMapInfo<VectorType *>::isEqual;
+  using KeyTy = std::pair<Type, ArrayRef<int>>;
+  using DenseMapInfo<VectorTypeStorage *>::getHashValue;
+  using DenseMapInfo<VectorTypeStorage *>::isEqual;
 
   static unsigned getHashValue(KeyTy key) {
     return hash_combine(
-        DenseMapInfo<Type *>::getHashValue(key.first),
+        DenseMapInfo<Type>::getHashValue(key.first),
         hash_combine_range(key.second.begin(), key.second.end()));
   }
 
-  static bool isEqual(const KeyTy &lhs, const VectorType *rhs) {
+  static bool isEqual(const KeyTy &lhs, const VectorTypeStorage *rhs) {
     if (rhs == getEmptyKey() || rhs == getTombstoneKey())
       return false;
-    return lhs == KeyTy(rhs->getElementType(), rhs->getShape());
+    return lhs == KeyTy(rhs->elementType, rhs->getShape());
   }
 };
 
-struct RankedTensorTypeKeyInfo : DenseMapInfo<RankedTensorType *> {
+struct RankedTensorTypeKeyInfo : DenseMapInfo<RankedTensorTypeStorage *> {
   // Ranked tensors are uniqued based on their element type and shape.
-  using KeyTy = std::pair<Type *, ArrayRef<int>>;
-  using DenseMapInfo<RankedTensorType *>::getHashValue;
-  using DenseMapInfo<RankedTensorType *>::isEqual;
+  using KeyTy = std::pair<Type, ArrayRef<int>>;
+  using DenseMapInfo<RankedTensorTypeStorage *>::getHashValue;
+  using DenseMapInfo<RankedTensorTypeStorage *>::isEqual;
 
   static unsigned getHashValue(KeyTy key) {
     return hash_combine(
-        DenseMapInfo<Type *>::getHashValue(key.first),
+        DenseMapInfo<Type>::getHashValue(key.first),
         hash_combine_range(key.second.begin(), key.second.end()));
   }
 
-  static bool isEqual(const KeyTy &lhs, const RankedTensorType *rhs) {
+  static bool isEqual(const KeyTy &lhs, const RankedTensorTypeStorage *rhs) {
     if (rhs == getEmptyKey() || rhs == getTombstoneKey())
       return false;
-    return lhs == KeyTy(rhs->getElementType(), rhs->getShape());
+    return lhs == KeyTy(rhs->elementType, rhs->getShape());
   }
 };
 
-struct MemRefTypeKeyInfo : DenseMapInfo<MemRefType *> {
+struct MemRefTypeKeyInfo : DenseMapInfo<MemRefTypeStorage *> {
   // MemRefs are uniqued based on their element type, shape, affine map
   // composition, and memory space.
-  using KeyTy =
-      std::tuple<Type *, ArrayRef<int>, ArrayRef<AffineMap>, unsigned>;
-  using DenseMapInfo<MemRefType *>::getHashValue;
-  using DenseMapInfo<MemRefType *>::isEqual;
+  using KeyTy = std::tuple<Type, ArrayRef<int>, ArrayRef<AffineMap>, unsigned>;
+  using DenseMapInfo<MemRefTypeStorage *>::getHashValue;
+  using DenseMapInfo<MemRefTypeStorage *>::isEqual;
 
   static unsigned getHashValue(KeyTy key) {
     return hash_combine(
-        DenseMapInfo<Type *>::getHashValue(std::get<0>(key)),
+        DenseMapInfo<Type>::getHashValue(std::get<0>(key)),
         hash_combine_range(std::get<1>(key).begin(), std::get<1>(key).end()),
         hash_combine_range(std::get<2>(key).begin(), std::get<2>(key).end()),
         std::get<3>(key));
   }
 
-  static bool isEqual(const KeyTy &lhs, const MemRefType *rhs) {
+  static bool isEqual(const KeyTy &lhs, const MemRefTypeStorage *rhs) {
     if (rhs == getEmptyKey() || rhs == getTombstoneKey())
       return false;
-    return lhs == std::make_tuple(rhs->getElementType(), rhs->getShape(),
-                                  rhs->getAffineMaps(), rhs->getMemorySpace());
+    return lhs == std::make_tuple(rhs->elementType, rhs->getShape(),
+                                  rhs->getAffineMaps(), rhs->memorySpace);
   }
 };
 
@@ -221,7 +221,7 @@
 };
 
 struct DenseElementsAttrInfo : DenseMapInfo<DenseElementsAttributeStorage *> {
-  using KeyTy = std::pair<VectorOrTensorType *, ArrayRef<char>>;
+  using KeyTy = std::pair<VectorOrTensorType, ArrayRef<char>>;
   using DenseMapInfo<DenseElementsAttributeStorage *>::getHashValue;
   using DenseMapInfo<DenseElementsAttributeStorage *>::isEqual;
 
@@ -239,7 +239,7 @@
 };
 
 struct OpaqueElementsAttrInfo : DenseMapInfo<OpaqueElementsAttributeStorage *> {
-  using KeyTy = std::pair<VectorOrTensorType *, StringRef>;
+  using KeyTy = std::pair<VectorOrTensorType, StringRef>;
   using DenseMapInfo<OpaqueElementsAttributeStorage *>::getHashValue;
   using DenseMapInfo<OpaqueElementsAttributeStorage *>::isEqual;
 
@@ -295,13 +295,14 @@
   llvm::StringMap<char, llvm::BumpPtrAllocator &> identifiers;
 
   // Uniquing table for 'other' types.
-  OtherType *otherTypes[int(Type::Kind::LAST_OTHER_TYPE) -
-                        int(Type::Kind::FIRST_OTHER_TYPE) + 1] = {nullptr};
+  OtherTypeStorage *otherTypes[int(Type::Kind::LAST_OTHER_TYPE) -
+                               int(Type::Kind::FIRST_OTHER_TYPE) + 1] = {
+      nullptr};
 
   // Uniquing table for 'float' types.
-  FloatType *floatTypes[int(Type::Kind::LAST_FLOATING_POINT_TYPE) -
-                        int(Type::Kind::FIRST_FLOATING_POINT_TYPE) + 1] = {
-      nullptr};
+  FloatTypeStorage *floatTypes[int(Type::Kind::LAST_FLOATING_POINT_TYPE) -
+                               int(Type::Kind::FIRST_FLOATING_POINT_TYPE) + 1] =
+      {nullptr};
 
   // Affine map uniquing.
   using AffineMapSet = DenseSet<AffineMap, AffineMapKeyInfo>;
@@ -324,26 +325,26 @@
   DenseMap<int64_t, AffineConstantExprStorage *> constExprs;
 
   /// Integer type uniquing.
-  DenseMap<unsigned, IntegerType *> integers;
+  DenseMap<unsigned, IntegerTypeStorage *> integers;
 
   /// Function type uniquing.
-  using FunctionTypeSet = DenseSet<FunctionType *, FunctionTypeKeyInfo>;
+  using FunctionTypeSet = DenseSet<FunctionTypeStorage *, FunctionTypeKeyInfo>;
   FunctionTypeSet functions;
 
   /// Vector type uniquing.
-  using VectorTypeSet = DenseSet<VectorType *, VectorTypeKeyInfo>;
+  using VectorTypeSet = DenseSet<VectorTypeStorage *, VectorTypeKeyInfo>;
   VectorTypeSet vectors;
 
   /// Ranked tensor type uniquing.
   using RankedTensorTypeSet =
-      DenseSet<RankedTensorType *, RankedTensorTypeKeyInfo>;
+      DenseSet<RankedTensorTypeStorage *, RankedTensorTypeKeyInfo>;
   RankedTensorTypeSet rankedTensors;
 
   /// Unranked tensor type uniquing.
-  DenseMap<Type *, UnrankedTensorType *> unrankedTensors;
+  DenseMap<Type, UnrankedTensorTypeStorage *> unrankedTensors;
 
   /// MemRef type uniquing.
-  using MemRefTypeSet = DenseSet<MemRefType *, MemRefTypeKeyInfo>;
+  using MemRefTypeSet = DenseSet<MemRefTypeStorage *, MemRefTypeKeyInfo>;
   MemRefTypeSet memrefs;
 
   // Attribute uniquing.
@@ -355,13 +356,12 @@
   ArrayAttrSet arrayAttrs;
   DenseMap<AffineMap, AffineMapAttributeStorage *> affineMapAttrs;
   DenseMap<IntegerSet, IntegerSetAttributeStorage *> integerSetAttrs;
-  DenseMap<Type *, TypeAttributeStorage *> typeAttrs;
+  DenseMap<Type, TypeAttributeStorage *> typeAttrs;
   using AttributeListSet =
       DenseSet<AttributeListStorage *, AttributeListKeyInfo>;
   AttributeListSet attributeLists;
   DenseMap<const Function *, FunctionAttributeStorage *> functionAttrs;
-  DenseMap<std::pair<VectorOrTensorType *, Attribute>,
-           SplatElementsAttributeStorage *>
+  DenseMap<std::pair<Type, Attribute>, SplatElementsAttributeStorage *>
       splatElementsAttrs;
   using DenseElementsAttrSet =
       DenseSet<DenseElementsAttributeStorage *, DenseElementsAttrInfo>;
@@ -369,7 +369,7 @@
   using OpaqueElementsAttrSet =
       DenseSet<OpaqueElementsAttributeStorage *, OpaqueElementsAttrInfo>;
   OpaqueElementsAttrSet opaqueElementsAttrs;
-  DenseMap<std::tuple<Type *, Attribute, Attribute>,
+  DenseMap<std::tuple<Type, Attribute, Attribute>,
            SparseElementsAttributeStorage *>
       sparseElementsAttrs;
 
@@ -556,19 +556,20 @@
 // Type uniquing
 //===----------------------------------------------------------------------===//
 
-IntegerType *IntegerType::get(unsigned width, MLIRContext *context) {
+IntegerType IntegerType::get(unsigned width, MLIRContext *context) {
+  assert(width <= kMaxWidth && "admissible integer bitwidth exceeded");
   auto &impl = context->getImpl();
 
   auto *&result = impl.integers[width];
   if (!result) {
-    result = impl.allocator.Allocate<IntegerType>();
-    new (result) IntegerType(width, context);
+    result = impl.allocator.Allocate<IntegerTypeStorage>();
+    new (result) IntegerTypeStorage{{Kind::Integer, context}, width};
   }
 
   return result;
 }
 
-FloatType *FloatType::get(Kind kind, MLIRContext *context) {
+FloatType FloatType::get(Kind kind, MLIRContext *context) {
   assert(kind >= Kind::FIRST_FLOATING_POINT_TYPE &&
          kind <= Kind::LAST_FLOATING_POINT_TYPE && "Not an FP type kind");
   auto &impl = context->getImpl();
@@ -580,16 +581,16 @@
     return entry;
 
   // On the first use, we allocate them into the bump pointer.
-  auto *ptr = impl.allocator.Allocate<FloatType>();
+  auto *ptr = impl.allocator.Allocate<FloatTypeStorage>();
 
   // Initialize the memory using placement new.
-  new (ptr) FloatType(kind, context);
+  new (ptr) FloatTypeStorage{{kind, context}};
 
   // Cache and return it.
   return entry = ptr;
 }
 
-OtherType *OtherType::get(Kind kind, MLIRContext *context) {
+OtherType OtherType::get(Kind kind, MLIRContext *context) {
   assert(kind >= Kind::FIRST_OTHER_TYPE && kind <= Kind::LAST_OTHER_TYPE &&
          "Not an 'other' type kind");
   auto &impl = context->getImpl();
@@ -600,18 +601,17 @@
     return entry;
 
   // On the first use, we allocate them into the bump pointer.
-  auto *ptr = impl.allocator.Allocate<OtherType>();
+  auto *ptr = impl.allocator.Allocate<OtherTypeStorage>();
 
   // Initialize the memory using placement new.
-  new (ptr) OtherType(kind, context);
+  new (ptr) OtherTypeStorage{{kind, context}};
 
   // Cache and return it.
   return entry = ptr;
 }
 
-FunctionType *FunctionType::get(ArrayRef<Type *> inputs,
-                                ArrayRef<Type *> results,
-                                MLIRContext *context) {
+FunctionType FunctionType::get(ArrayRef<Type> inputs, ArrayRef<Type> results,
+                               MLIRContext *context) {
   auto &impl = context->getImpl();
 
   // Look to see if we already have this function type.
@@ -623,32 +623,34 @@
     return *existing.first;
 
   // On the first use, we allocate them into the bump pointer.
-  auto *result = impl.allocator.Allocate<FunctionType>();
+  auto *result = impl.allocator.Allocate<FunctionTypeStorage>();
 
   // Copy the inputs and results into the bump pointer.
-  SmallVector<Type *, 16> types;
+  SmallVector<Type, 16> types;
   types.reserve(inputs.size() + results.size());
   types.append(inputs.begin(), inputs.end());
   types.append(results.begin(), results.end());
-  auto typesList = impl.copyInto(ArrayRef<Type *>(types));
+  auto typesList = impl.copyInto(ArrayRef<Type>(types));
 
   // Initialize the memory using placement new.
-  new (result)
-      FunctionType(typesList.data(), inputs.size(), results.size(), context);
+  new (result) FunctionTypeStorage{
+      {Kind::Function, context, static_cast<unsigned int>(inputs.size())},
+      static_cast<unsigned int>(results.size()),
+      typesList.data()};
 
   // Cache and return it.
   return *existing.first = result;
 }
 
-VectorType *VectorType::get(ArrayRef<int> shape, Type *elementType) {
+VectorType VectorType::get(ArrayRef<int> shape, Type elementType) {
   assert(!shape.empty() && "vector types must have at least one dimension");
-  assert((isa<FloatType>(elementType) || isa<IntegerType>(elementType)) &&
+  assert((elementType.isa<FloatType>() || elementType.isa<IntegerType>()) &&
          "vectors elements must be primitives");
   assert(!std::any_of(shape.begin(), shape.end(), [](int i) {
     return i < 0;
   }) && "vector types must have static shape");
 
-  auto *context = elementType->getContext();
+  auto *context = elementType.getContext();
   auto &impl = context->getImpl();
 
   // Look to see if we already have this vector type.
@@ -660,21 +662,23 @@
     return *existing.first;
 
   // On the first use, we allocate them into the bump pointer.
-  auto *result = impl.allocator.Allocate<VectorType>();
+  auto *result = impl.allocator.Allocate<VectorTypeStorage>();
 
   // Copy the shape into the bump pointer.
   shape = impl.copyInto(shape);
 
   // Initialize the memory using placement new.
-  new (result) VectorType(shape, elementType, context);
+  new (result) VectorTypeStorage{
+      {{Kind::Vector, context, static_cast<unsigned int>(shape.size())},
+       elementType},
+      shape.data()};
 
   // Cache and return it.
   return *existing.first = result;
 }
 
-RankedTensorType *RankedTensorType::get(ArrayRef<int> shape,
-                                        Type *elementType) {
-  auto *context = elementType->getContext();
+RankedTensorType RankedTensorType::get(ArrayRef<int> shape, Type elementType) {
+  auto *context = elementType.getContext();
   auto &impl = context->getImpl();
 
   // Look to see if we already have this ranked tensor type.
@@ -686,20 +690,23 @@
     return *existing.first;
 
   // On the first use, we allocate them into the bump pointer.
-  auto *result = impl.allocator.Allocate<RankedTensorType>();
+  auto *result = impl.allocator.Allocate<RankedTensorTypeStorage>();
 
   // Copy the shape into the bump pointer.
   shape = impl.copyInto(shape);
 
   // Initialize the memory using placement new.
-  new (result) RankedTensorType(shape, elementType, context);
+  new (result) RankedTensorTypeStorage{
+      {{{Kind::RankedTensor, context, static_cast<unsigned int>(shape.size())},
+        elementType}},
+      shape.data()};
 
   // Cache and return it.
   return *existing.first = result;
 }
 
-UnrankedTensorType *UnrankedTensorType::get(Type *elementType) {
-  auto *context = elementType->getContext();
+UnrankedTensorType UnrankedTensorType::get(Type elementType) {
+  auto *context = elementType.getContext();
   auto &impl = context->getImpl();
 
   // Look to see if we already have this unranked tensor type.
@@ -710,17 +717,18 @@
     return result;
 
   // On the first use, we allocate them into the bump pointer.
-  result = impl.allocator.Allocate<UnrankedTensorType>();
+  result = impl.allocator.Allocate<UnrankedTensorTypeStorage>();
 
   // Initialize the memory using placement new.
-  new (result) UnrankedTensorType(elementType, context);
+  new (result) UnrankedTensorTypeStorage{
+      {{{Kind::UnrankedTensor, context}, elementType}}};
   return result;
 }
 
-MemRefType *MemRefType::get(ArrayRef<int> shape, Type *elementType,
-                            ArrayRef<AffineMap> affineMapComposition,
-                            unsigned memorySpace) {
-  auto *context = elementType->getContext();
+MemRefType MemRefType::get(ArrayRef<int> shape, Type elementType,
+                           ArrayRef<AffineMap> affineMapComposition,
+                           unsigned memorySpace) {
+  auto *context = elementType.getContext();
   auto &impl = context->getImpl();
 
   // Drop the unbounded identity maps from the composition.
@@ -744,7 +752,7 @@
     return *existing.first;
 
   // On the first use, we allocate them into the bump pointer.
-  auto *result = impl.allocator.Allocate<MemRefType>();
+  auto *result = impl.allocator.Allocate<MemRefTypeStorage>();
 
   // Copy the shape into the bump pointer.
   shape = impl.copyInto(shape);
@@ -755,8 +763,13 @@
       impl.copyInto(ArrayRef<AffineMap>(affineMapComposition));
 
   // Initialize the memory using placement new.
-  new (result) MemRefType(shape, elementType, affineMapComposition, memorySpace,
-                          context);
+  new (result) MemRefTypeStorage{
+      {Kind::MemRef, context, static_cast<unsigned int>(shape.size())},
+      elementType,
+      shape.data(),
+      static_cast<unsigned int>(affineMapComposition.size()),
+      affineMapComposition.data(),
+      memorySpace};
   // Cache and return it.
   return *existing.first = result;
 }
@@ -895,7 +908,7 @@
   return result;
 }
 
-TypeAttr TypeAttr::get(Type *type, MLIRContext *context) {
+TypeAttr TypeAttr::get(Type type, MLIRContext *context) {
   auto *&result = context->getImpl().typeAttrs[type];
   if (result)
     return result;
@@ -1009,9 +1022,9 @@
   return *existing.first = result;
 }
 
-SplatElementsAttr SplatElementsAttr::get(VectorOrTensorType *type,
+SplatElementsAttr SplatElementsAttr::get(VectorOrTensorType type,
                                          Attribute elt) {
-  auto &impl = type->getContext()->getImpl();
+  auto &impl = type.getContext()->getImpl();
 
   // Look to see if we already have this.
   auto *&result = impl.splatElementsAttrs[{type, elt}];
@@ -1030,14 +1043,14 @@
   return result;
 }
 
-DenseElementsAttr DenseElementsAttr::get(VectorOrTensorType *type,
+DenseElementsAttr DenseElementsAttr::get(VectorOrTensorType type,
                                          ArrayRef<char> data) {
-  auto bitsRequired = (long)type->getBitWidth() * type->getNumElements();
+  auto bitsRequired = (long)type.getBitWidth() * type.getNumElements();
   (void)bitsRequired;
   assert((bitsRequired <= data.size() * 8L) &&
          "Input data bit size should be larger than that type requires");
 
-  auto &impl = type->getContext()->getImpl();
+  auto &impl = type.getContext()->getImpl();
 
   // Look to see if this constant is already defined.
   DenseElementsAttrInfo::KeyTy key({type, data});
@@ -1048,8 +1061,8 @@
     return *existing.first;
 
   // Otherwise, allocate a new one, unique it and return it.
-  auto *eltType = type->getElementType();
-  switch (eltType->getKind()) {
+  auto eltType = type.getElementType();
+  switch (eltType.getKind()) {
   case Type::Kind::BF16:
   case Type::Kind::F16:
   case Type::Kind::F32:
@@ -1064,7 +1077,7 @@
     return *existing.first = result;
   }
   case Type::Kind::Integer: {
-    auto width = ::cast<IntegerType>(eltType)->getWidth();
+    auto width = eltType.cast<IntegerType>().getWidth();
     auto *result = impl.allocator.Allocate<DenseIntElementsAttributeStorage>();
     auto *copy = (char *)impl.allocator.Allocate(data.size(), 64);
     std::uninitialized_copy(data.begin(), data.end(), copy);
@@ -1080,12 +1093,12 @@
   }
 }
 
-OpaqueElementsAttr OpaqueElementsAttr::get(VectorOrTensorType *type,
+OpaqueElementsAttr OpaqueElementsAttr::get(VectorOrTensorType type,
                                            StringRef bytes) {
-  assert(isValidTensorElementType(type->getElementType()) &&
+  assert(isValidTensorElementType(type.getElementType()) &&
          "Input element type should be a valid tensor element type");
 
-  auto &impl = type->getContext()->getImpl();
+  auto &impl = type.getContext()->getImpl();
 
   // Look to see if this constant is already defined.
   OpaqueElementsAttrInfo::KeyTy key({type, bytes});
@@ -1104,10 +1117,10 @@
   return *existing.first = result;
 }
 
-SparseElementsAttr SparseElementsAttr::get(VectorOrTensorType *type,
+SparseElementsAttr SparseElementsAttr::get(VectorOrTensorType type,
                                            DenseIntElementsAttr indices,
                                            DenseElementsAttr values) {
-  auto &impl = type->getContext()->getImpl();
+  auto &impl = type.getContext()->getImpl();
 
   // Look to see if we already have this.
   auto key = std::make_tuple(type, indices, values);
diff --git a/lib/IR/Operation.cpp b/lib/IR/Operation.cpp
index 2ed09b8..0722421 100644
--- a/lib/IR/Operation.cpp
+++ b/lib/IR/Operation.cpp
@@ -377,7 +377,7 @@
 }
 
 bool OpTrait::impl::verifySameOperandsAndResult(const Operation *op) {
-  auto *type = op->getResult(0)->getType();
+  auto type = op->getResult(0)->getType();
   for (unsigned i = 1, e = op->getNumResults(); i < e; ++i) {
     if (op->getResult(i)->getType() != type)
       return op->emitOpError(
@@ -393,19 +393,19 @@
 
 /// If this is a vector type, or a tensor type, return the scalar element type
 /// that it is built around, otherwise return the type unmodified.
-static Type *getTensorOrVectorElementType(Type *type) {
-  if (auto *vec = dyn_cast<VectorType>(type))
-    return vec->getElementType();
+static Type getTensorOrVectorElementType(Type type) {
+  if (auto vec = type.dyn_cast<VectorType>())
+    return vec.getElementType();
 
   // Look through tensor<vector<...>> to find the underlying element type.
-  if (auto *tensor = dyn_cast<TensorType>(type))
-    return getTensorOrVectorElementType(tensor->getElementType());
+  if (auto tensor = type.dyn_cast<TensorType>())
+    return getTensorOrVectorElementType(tensor.getElementType());
   return type;
 }
 
 bool OpTrait::impl::verifyResultsAreFloatLike(const Operation *op) {
   for (auto *result : op->getResults()) {
-    if (!isa<FloatType>(getTensorOrVectorElementType(result->getType())))
+    if (!getTensorOrVectorElementType(result->getType()).isa<FloatType>())
       return op->emitOpError("requires a floating point type");
   }
 
@@ -414,7 +414,7 @@
 
 bool OpTrait::impl::verifyResultsAreIntegerLike(const Operation *op) {
   for (auto *result : op->getResults()) {
-    if (!isa<IntegerType>(getTensorOrVectorElementType(result->getType())))
+    if (!getTensorOrVectorElementType(result->getType()).isa<IntegerType>())
       return op->emitOpError("requires an integer type");
   }
   return false;
@@ -436,7 +436,7 @@
 
 bool impl::parseBinaryOp(OpAsmParser *parser, OperationState *result) {
   SmallVector<OpAsmParser::OperandType, 2> ops;
-  Type *type;
+  Type type;
   return parser->parseOperandList(ops, 2) ||
          parser->parseOptionalAttributeDict(result->attributes) ||
          parser->parseColonType(type) ||
@@ -448,7 +448,7 @@
   *p << op->getName() << ' ' << *op->getOperand(0) << ", "
      << *op->getOperand(1);
   p->printOptionalAttrDict(op->getAttrs());
-  *p << " : " << *op->getResult(0)->getType();
+  *p << " : " << op->getResult(0)->getType();
 }
 
 //===----------------------------------------------------------------------===//
@@ -456,14 +456,14 @@
 //===----------------------------------------------------------------------===//
 
 void impl::buildCastOp(Builder *builder, OperationState *result,
-                       SSAValue *source, Type *destType) {
+                       SSAValue *source, Type destType) {
   result->addOperands(source);
   result->addTypes(destType);
 }
 
 bool impl::parseCastOp(OpAsmParser *parser, OperationState *result) {
   OpAsmParser::OperandType srcInfo;
-  Type *srcType, *dstType;
+  Type srcType, dstType;
   return parser->parseOperand(srcInfo) || parser->parseColonType(srcType) ||
          parser->resolveOperand(srcInfo, srcType, result->operands) ||
          parser->parseKeywordType("to", dstType) ||
@@ -472,5 +472,5 @@
 
 void impl::printCastOp(const Operation *op, OpAsmPrinter *p) {
   *p << op->getName() << ' ' << *op->getOperand(0) << " : "
-     << *op->getOperand(0)->getType() << " to " << *op->getResult(0)->getType();
+     << op->getOperand(0)->getType() << " to " << op->getResult(0)->getType();
 }
diff --git a/lib/IR/Statement.cpp b/lib/IR/Statement.cpp
index e9c46d6..698089a1 100644
--- a/lib/IR/Statement.cpp
+++ b/lib/IR/Statement.cpp
@@ -239,7 +239,7 @@
 /// Create a new OperationStmt with the specific fields.
 OperationStmt *OperationStmt::create(Location *location, OperationName name,
                                      ArrayRef<MLValue *> operands,
-                                     ArrayRef<Type *> resultTypes,
+                                     ArrayRef<Type> resultTypes,
                                      ArrayRef<NamedAttribute> attributes,
                                      MLIRContext *context) {
   auto byteSize = totalSizeToAlloc<StmtOperand, StmtResult>(operands.size(),
@@ -288,9 +288,9 @@
   // If we have a result or operand type, that is a constant time way to get
   // to the context.
   if (getNumResults())
-    return getResult(0)->getType()->getContext();
+    return getResult(0)->getType().getContext();
   if (getNumOperands())
-    return getOperand(0)->getType()->getContext();
+    return getOperand(0)->getType().getContext();
 
   // In the very odd case where we have no operands or results, fall back to
   // doing a find.
@@ -474,7 +474,7 @@
   if (operands.empty())
     return findFunction()->getContext();
 
-  return getOperand(0)->getType()->getContext();
+  return getOperand(0)->getType().getContext();
 }
 
 //===----------------------------------------------------------------------===//
@@ -501,7 +501,7 @@
     operands.push_back(remapOperand(opValue));
 
   if (auto *opStmt = dyn_cast<OperationStmt>(this)) {
-    SmallVector<Type *, 8> resultTypes;
+    SmallVector<Type, 8> resultTypes;
     resultTypes.reserve(opStmt->getNumResults());
     for (auto *result : opStmt->getResults())
       resultTypes.push_back(result->getType());
diff --git a/lib/IR/TypeDetail.h b/lib/IR/TypeDetail.h
new file mode 100644
index 0000000..c22e87a
--- /dev/null
+++ b/lib/IR/TypeDetail.h
@@ -0,0 +1,126 @@
+//===- TypeDetail.h - MLIR Affine Expr storage details ----------*- C++ -*-===//
+//
+// Copyright 2019 The MLIR 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.
+// =============================================================================
+//
+// This holds implementation details of Type.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TYPEDETAIL_H_
+#define TYPEDETAIL_H_
+
+#include "mlir/IR/MLIRContext.h"
+#include "mlir/IR/Types.h"
+
+namespace mlir {
+
+class AffineMap;
+class MLIRContext;
+
+namespace detail {
+
+/// Base storage class appearing in a Type.
+struct alignas(8) TypeStorage {
+  TypeStorage(Type::Kind kind, MLIRContext *context)
+      : context(context), kind(kind), subclassData(0) {}
+  TypeStorage(Type::Kind kind, MLIRContext *context, unsigned subclassData)
+      : context(context), kind(kind), subclassData(subclassData) {}
+
+  unsigned getSubclassData() const { return subclassData; }
+
+  void setSubclassData(unsigned val) {
+    subclassData = val;
+    // Ensure we don't have any accidental truncation.
+    assert(getSubclassData() == val && "Subclass data too large for field");
+  }
+
+  /// This refers to the MLIRContext in which this type was uniqued.
+  MLIRContext *const context;
+
+  /// Classification of the subclass, used for type checking.
+  Type::Kind kind : 8;
+
+  /// Space for subclasses to store data.
+  unsigned subclassData : 24;
+};
+
+struct IntegerTypeStorage : public TypeStorage {
+  unsigned width;
+};
+
+struct FloatTypeStorage : public TypeStorage {};
+
+struct OtherTypeStorage : public TypeStorage {};
+
+struct FunctionTypeStorage : public TypeStorage {
+  ArrayRef<Type> getInputs() const {
+    return ArrayRef<Type>(inputsAndResults, subclassData);
+  }
+  ArrayRef<Type> getResults() const {
+    return ArrayRef<Type>(inputsAndResults + subclassData, numResults);
+  }
+
+  unsigned numResults;
+  Type const *inputsAndResults;
+};
+
+struct VectorOrTensorTypeStorage : public TypeStorage {
+  Type elementType;
+};
+
+struct VectorTypeStorage : public VectorOrTensorTypeStorage {
+  ArrayRef<int> getShape() const {
+    return ArrayRef<int>(shapeElements, getSubclassData());
+  }
+
+  const int *shapeElements;
+};
+
+struct TensorTypeStorage : public VectorOrTensorTypeStorage {};
+
+struct RankedTensorTypeStorage : public TensorTypeStorage {
+  ArrayRef<int> getShape() const {
+    return ArrayRef<int>(shapeElements, getSubclassData());
+  }
+
+  const int *shapeElements;
+};
+
+struct UnrankedTensorTypeStorage : public TensorTypeStorage {};
+
+struct MemRefTypeStorage : public TypeStorage {
+  ArrayRef<int> getShape() const {
+    return ArrayRef<int>(shapeElements, getSubclassData());
+  }
+
+  ArrayRef<AffineMap> getAffineMaps() const {
+    return ArrayRef<AffineMap>(affineMapList, numAffineMaps);
+  }
+
+  /// The type of each scalar element of the memref.
+  Type elementType;
+  /// An array of integers which stores the shape dimension sizes.
+  const int *shapeElements;
+  /// The number of affine maps in the 'affineMapList' array.
+  const unsigned numAffineMaps;
+  /// List of affine maps in the memref's layout/index map composition.
+  AffineMap const *affineMapList;
+  /// Memory space in which data referenced by memref resides.
+  const unsigned memorySpace;
+};
+
+} // namespace detail
+} // namespace mlir
+#endif // TYPEDETAIL_H_
diff --git a/lib/IR/Types.cpp b/lib/IR/Types.cpp
index 0ad3f47..1a71695 100644
--- a/lib/IR/Types.cpp
+++ b/lib/IR/Types.cpp
@@ -16,10 +16,17 @@
 // =============================================================================
 
 #include "mlir/IR/Types.h"
+#include "TypeDetail.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/Support/STLExtras.h"
 #include "llvm/Support/raw_ostream.h"
+
 using namespace mlir;
+using namespace mlir::detail;
+
+Type::Kind Type::getKind() const { return type->kind; }
+
+MLIRContext *Type::getContext() const { return type->context; }
 
 unsigned Type::getBitWidth() const {
   switch (getKind()) {
@@ -32,34 +39,49 @@
   case Type::Kind::F64:
     return 64;
   case Type::Kind::Integer:
-    return cast<IntegerType>(this)->getWidth();
+    return cast<IntegerType>().getWidth();
   case Type::Kind::Vector:
   case Type::Kind::RankedTensor:
   case Type::Kind::UnrankedTensor:
-    return cast<VectorOrTensorType>(this)->getElementType()->getBitWidth();
+    return cast<VectorOrTensorType>().getElementType().getBitWidth();
     // TODO: Handle more types.
   default:
     llvm_unreachable("unexpected type");
   }
 }
 
-IntegerType::IntegerType(unsigned width, MLIRContext *context)
-    : Type(Kind::Integer, context), width(width) {
-  assert(width <= kMaxWidth && "admissible integer bitwidth exceeded");
+unsigned Type::getSubclassData() const { return type->getSubclassData(); }
+void Type::setSubclassData(unsigned val) { type->setSubclassData(val); }
+
+IntegerType::IntegerType(Type::ImplType *ptr) : Type(ptr) {}
+
+unsigned IntegerType::getWidth() const {
+  return static_cast<ImplType *>(type)->width;
 }
 
-FloatType::FloatType(Kind kind, MLIRContext *context) : Type(kind, context) {}
+FloatType::FloatType(Type::ImplType *ptr) : Type(ptr) {}
 
-OtherType::OtherType(Kind kind, MLIRContext *context) : Type(kind, context) {}
+OtherType::OtherType(Type::ImplType *ptr) : Type(ptr) {}
 
-FunctionType::FunctionType(Type *const *inputsAndResults, unsigned numInputs,
-                           unsigned numResults, MLIRContext *context)
-    : Type(Kind::Function, context, numInputs), numResults(numResults),
-      inputsAndResults(inputsAndResults) {}
+FunctionType::FunctionType(Type::ImplType *ptr) : Type(ptr) {}
 
-VectorOrTensorType::VectorOrTensorType(Kind kind, MLIRContext *context,
-                                       Type *elementType, unsigned subClassData)
-    : Type(kind, context, subClassData), elementType(elementType) {}
+ArrayRef<Type> FunctionType::getInputs() const {
+  return static_cast<ImplType *>(type)->getInputs();
+}
+
+unsigned FunctionType::getNumResults() const {
+  return static_cast<ImplType *>(type)->numResults;
+}
+
+ArrayRef<Type> FunctionType::getResults() const {
+  return static_cast<ImplType *>(type)->getResults();
+}
+
+VectorOrTensorType::VectorOrTensorType(Type::ImplType *ptr) : Type(ptr) {}
+
+Type VectorOrTensorType::getElementType() const {
+  return static_cast<ImplType *>(type)->elementType;
+}
 
 unsigned VectorOrTensorType::getNumElements() const {
   switch (getKind()) {
@@ -103,11 +125,11 @@
 ArrayRef<int> VectorOrTensorType::getShape() const {
   switch (getKind()) {
   case Kind::Vector:
-    return cast<VectorType>(this)->getShape();
+    return cast<VectorType>().getShape();
   case Kind::RankedTensor:
-    return cast<RankedTensorType>(this)->getShape();
+    return cast<RankedTensorType>().getShape();
   case Kind::UnrankedTensor:
-    return cast<RankedTensorType>(this)->getShape();
+    return cast<RankedTensorType>().getShape();
   default:
     llvm_unreachable("not a VectorOrTensorType");
   }
@@ -118,35 +140,38 @@
   return !std::any_of(dims.begin(), dims.end(), [](int i) { return i < 0; });
 }
 
-VectorType::VectorType(ArrayRef<int> shape, Type *elementType,
-                       MLIRContext *context)
-    : VectorOrTensorType(Kind::Vector, context, elementType, shape.size()),
-      shapeElements(shape.data()) {}
+VectorType::VectorType(Type::ImplType *ptr) : VectorOrTensorType(ptr) {}
 
-TensorType::TensorType(Kind kind, Type *elementType, MLIRContext *context)
-    : VectorOrTensorType(kind, context, elementType) {
-  assert(isValidTensorElementType(elementType));
+ArrayRef<int> VectorType::getShape() const {
+  return static_cast<ImplType *>(type)->getShape();
 }
 
-RankedTensorType::RankedTensorType(ArrayRef<int> shape, Type *elementType,
-                                   MLIRContext *context)
-    : TensorType(Kind::RankedTensor, elementType, context),
-      shapeElements(shape.data()) {
-  setSubclassData(shape.size());
+TensorType::TensorType(Type::ImplType *ptr) : VectorOrTensorType(ptr) {}
+
+RankedTensorType::RankedTensorType(Type::ImplType *ptr) : TensorType(ptr) {}
+
+ArrayRef<int> RankedTensorType::getShape() const {
+  return static_cast<ImplType *>(type)->getShape();
 }
 
-UnrankedTensorType::UnrankedTensorType(Type *elementType, MLIRContext *context)
-    : TensorType(Kind::UnrankedTensor, elementType, context) {}
+UnrankedTensorType::UnrankedTensorType(Type::ImplType *ptr) : TensorType(ptr) {}
 
-MemRefType::MemRefType(ArrayRef<int> shape, Type *elementType,
-                       ArrayRef<AffineMap> affineMapList, unsigned memorySpace,
-                       MLIRContext *context)
-    : Type(Kind::MemRef, context, shape.size()), elementType(elementType),
-      shapeElements(shape.data()), numAffineMaps(affineMapList.size()),
-      affineMapList(affineMapList.data()), memorySpace(memorySpace) {}
+MemRefType::MemRefType(Type::ImplType *ptr) : Type(ptr) {}
+
+ArrayRef<int> MemRefType::getShape() const {
+  return static_cast<ImplType *>(type)->getShape();
+}
+
+Type MemRefType::getElementType() const {
+  return static_cast<ImplType *>(type)->elementType;
+}
 
 ArrayRef<AffineMap> MemRefType::getAffineMaps() const {
-  return ArrayRef<AffineMap>(affineMapList, numAffineMaps);
+  return static_cast<ImplType *>(type)->getAffineMaps();
+}
+
+unsigned MemRefType::getMemorySpace() const {
+  return static_cast<ImplType *>(type)->memorySpace;
 }
 
 unsigned MemRefType::getNumDynamicDims() const {
diff --git a/lib/Parser/Parser.cpp b/lib/Parser/Parser.cpp
index 7974c7c..ceb8931 100644
--- a/lib/Parser/Parser.cpp
+++ b/lib/Parser/Parser.cpp
@@ -182,19 +182,19 @@
   // as the results of their action.
 
   // Type parsing.
-  VectorType *parseVectorType();
+  VectorType parseVectorType();
   ParseResult parseXInDimensionList();
   ParseResult parseDimensionListRanked(SmallVectorImpl<int> &dimensions);
-  Type *parseTensorType();
-  Type *parseMemRefType();
-  Type *parseFunctionType();
-  Type *parseType();
-  ParseResult parseTypeListNoParens(SmallVectorImpl<Type *> &elements);
-  ParseResult parseTypeList(SmallVectorImpl<Type *> &elements);
+  Type parseTensorType();
+  Type parseMemRefType();
+  Type parseFunctionType();
+  Type parseType();
+  ParseResult parseTypeListNoParens(SmallVectorImpl<Type> &elements);
+  ParseResult parseTypeList(SmallVectorImpl<Type> &elements);
 
   // Attribute parsing.
   Function *resolveFunctionReference(StringRef nameStr, SMLoc nameLoc,
-                                     FunctionType *type);
+                                     FunctionType type);
   Attribute parseAttribute();
 
   ParseResult parseAttributeDict(SmallVectorImpl<NamedAttribute> &attributes);
@@ -206,9 +206,9 @@
   AffineMap parseAffineMapReference();
   IntegerSet parseIntegerSetInline();
   IntegerSet parseIntegerSetReference();
-  DenseElementsAttr parseDenseElementsAttr(VectorOrTensorType *type);
-  DenseElementsAttr parseDenseElementsAttr(Type *eltType, bool isVector);
-  VectorOrTensorType *parseVectorOrTensorType();
+  DenseElementsAttr parseDenseElementsAttr(VectorOrTensorType type);
+  DenseElementsAttr parseDenseElementsAttr(Type eltType, bool isVector);
+  VectorOrTensorType parseVectorOrTensorType();
 
 private:
   // The Parser is subclassed and reinstantiated.  Do not add additional
@@ -299,7 +299,7 @@
 ///   float-type ::= `f16` | `bf16` | `f32` | `f64`
 ///   other-type ::= `index` | `tf_control`
 ///
-Type *Parser::parseType() {
+Type Parser::parseType() {
   switch (getToken().getKind()) {
   default:
     return (emitError("expected type"), nullptr);
@@ -368,7 +368,7 @@
 ///   vector-type ::= `vector` `<` const-dimension-list primitive-type `>`
 ///   const-dimension-list ::= (integer-literal `x`)+
 ///
-VectorType *Parser::parseVectorType() {
+VectorType Parser::parseVectorType() {
   consumeToken(Token::kw_vector);
 
   if (parseToken(Token::less, "expected '<' in vector type"))
@@ -402,11 +402,11 @@
 
   // Parse the element type.
   auto typeLoc = getToken().getLoc();
-  auto *elementType = parseType();
+  auto elementType = parseType();
   if (!elementType || parseToken(Token::greater, "expected '>' in vector type"))
     return nullptr;
 
-  if (!isa<FloatType>(elementType) && !isa<IntegerType>(elementType))
+  if (!elementType.isa<FloatType>() && !elementType.isa<IntegerType>())
     return (emitError(typeLoc, "invalid vector element type"), nullptr);
 
   return VectorType::get(dimensions, elementType);
@@ -461,7 +461,7 @@
 ///   tensor-type ::= `tensor` `<` dimension-list element-type `>`
 ///   dimension-list ::= dimension-list-ranked | `*x`
 ///
-Type *Parser::parseTensorType() {
+Type Parser::parseTensorType() {
   consumeToken(Token::kw_tensor);
 
   if (parseToken(Token::less, "expected '<' in tensor type"))
@@ -485,7 +485,7 @@
 
   // Parse the element type.
   auto typeLoc = getToken().getLoc();
-  auto *elementType = parseType();
+  auto elementType = parseType();
   if (!elementType || parseToken(Token::greater, "expected '>' in tensor type"))
     return nullptr;
 
@@ -505,7 +505,7 @@
 ///   semi-affine-map-composition ::= (semi-affine-map `,` )* semi-affine-map
 ///   memory-space ::= integer-literal /* | TODO: address-space-id */
 ///
-Type *Parser::parseMemRefType() {
+Type Parser::parseMemRefType() {
   consumeToken(Token::kw_memref);
 
   if (parseToken(Token::less, "expected '<' in memref type"))
@@ -517,12 +517,12 @@
 
   // Parse the element type.
   auto typeLoc = getToken().getLoc();
-  auto *elementType = parseType();
+  auto elementType = parseType();
   if (!elementType)
     return nullptr;
 
-  if (!isa<IntegerType>(elementType) && !isa<FloatType>(elementType) &&
-      !isa<VectorType>(elementType))
+  if (!elementType.isa<IntegerType>() && !elementType.isa<FloatType>() &&
+      !elementType.isa<VectorType>())
     return (emitError(typeLoc, "invalid memref element type"), nullptr);
 
   // Parse semi-affine-map-composition.
@@ -581,10 +581,10 @@
 ///
 ///   function-type ::= type-list-parens `->` type-list
 ///
-Type *Parser::parseFunctionType() {
+Type Parser::parseFunctionType() {
   assert(getToken().is(Token::l_paren));
 
-  SmallVector<Type *, 4> arguments, results;
+  SmallVector<Type, 4> arguments, results;
   if (parseTypeList(arguments) ||
       parseToken(Token::arrow, "expected '->' in function type") ||
       parseTypeList(results))
@@ -598,7 +598,7 @@
 ///
 ///   type-list-no-parens ::=  type (`,` type)*
 ///
-ParseResult Parser::parseTypeListNoParens(SmallVectorImpl<Type *> &elements) {
+ParseResult Parser::parseTypeListNoParens(SmallVectorImpl<Type> &elements) {
   auto parseElt = [&]() -> ParseResult {
     auto elt = parseType();
     elements.push_back(elt);
@@ -615,7 +615,7 @@
 ///   type-list-parens ::= `(` `)`
 ///                      | `(` type-list-no-parens `)`
 ///
-ParseResult Parser::parseTypeList(SmallVectorImpl<Type *> &elements) {
+ParseResult Parser::parseTypeList(SmallVectorImpl<Type> &elements) {
   auto parseElt = [&]() -> ParseResult {
     auto elt = parseType();
     elements.push_back(elt);
@@ -639,8 +639,8 @@
 namespace {
 class TensorLiteralParser {
 public:
-  TensorLiteralParser(Parser &p, Type *eltTy)
-      : p(p), eltTy(eltTy), currBitPos(0), bitsWidth(eltTy->getBitWidth()) {}
+  TensorLiteralParser(Parser &p, Type eltTy)
+      : p(p), eltTy(eltTy), currBitPos(0), bitsWidth(eltTy.getBitWidth()) {}
 
   ParseResult parse() { return parseList(shape); }
 
@@ -676,7 +676,7 @@
   }
 
   Parser &p;
-  Type *eltTy;
+  Type eltTy;
   size_t currBitPos;
   size_t bitsWidth;
   SmallVector<int, 4> shape;
@@ -698,7 +698,7 @@
     if (!result)
       return p.emitError("expected tensor element");
     // check result matches the element type.
-    switch (eltTy->getKind()) {
+    switch (eltTy.getKind()) {
     case Type::Kind::BF16:
     case Type::Kind::F16:
     case Type::Kind::F32:
@@ -779,7 +779,7 @@
 /// synthesizing a forward reference) or emit an error and return null on
 /// failure.
 Function *Parser::resolveFunctionReference(StringRef nameStr, SMLoc nameLoc,
-                                           FunctionType *type) {
+                                           FunctionType type) {
   Identifier name = builder.getIdentifier(nameStr.drop_front());
 
   // See if the function has already been defined in the module.
@@ -902,10 +902,10 @@
     if (parseToken(Token::colon, "expected ':' and function type"))
       return nullptr;
     auto typeLoc = getToken().getLoc();
-    Type *type = parseType();
+    Type type = parseType();
     if (!type)
       return nullptr;
-    auto *fnType = dyn_cast<FunctionType>(type);
+    auto fnType = type.dyn_cast<FunctionType>();
     if (!fnType)
       return (emitError(typeLoc, "expected function type"), nullptr);
 
@@ -916,7 +916,7 @@
     consumeToken(Token::kw_opaque);
     if (parseToken(Token::less, "expected '<' after 'opaque'"))
       return nullptr;
-    auto *type = parseVectorOrTensorType();
+    auto type = parseVectorOrTensorType();
     if (!type)
       return nullptr;
     auto val = getToken().getStringValue();
@@ -937,7 +937,7 @@
     if (parseToken(Token::less, "expected '<' after 'splat'"))
       return nullptr;
 
-    auto *type = parseVectorOrTensorType();
+    auto type = parseVectorOrTensorType();
     if (!type)
       return nullptr;
     switch (getToken().getKind()) {
@@ -959,7 +959,7 @@
     if (parseToken(Token::less, "expected '<' after 'dense'"))
       return nullptr;
 
-    auto *type = parseVectorOrTensorType();
+    auto type = parseVectorOrTensorType();
     if (!type)
       return nullptr;
 
@@ -981,41 +981,41 @@
     if (parseToken(Token::less, "Expected '<' after 'sparse'"))
       return nullptr;
 
-    auto *type = parseVectorOrTensorType();
+    auto type = parseVectorOrTensorType();
     if (!type)
       return nullptr;
 
     switch (getToken().getKind()) {
     case Token::l_square: {
       /// Parse indices
-      auto *indicesEltType = builder.getIntegerType(32);
+      auto indicesEltType = builder.getIntegerType(32);
       auto indices =
-          parseDenseElementsAttr(indicesEltType, isa<VectorType>(type));
+          parseDenseElementsAttr(indicesEltType, type.isa<VectorType>());
 
       if (parseToken(Token::comma, "expected ','"))
         return nullptr;
 
       /// Parse values.
-      auto *valuesEltType = type->getElementType();
+      auto valuesEltType = type.getElementType();
       auto values =
-          parseDenseElementsAttr(valuesEltType, isa<VectorType>(type));
+          parseDenseElementsAttr(valuesEltType, type.isa<VectorType>());
 
       /// Sanity check.
-      auto *indicesType = indices.getType();
-      auto *valuesType = values.getType();
-      auto sameShape = (indicesType->getRank() == 1) ||
-                       (type->getRank() == indicesType->getDimSize(1));
+      auto indicesType = indices.getType();
+      auto valuesType = values.getType();
+      auto sameShape = (indicesType.getRank() == 1) ||
+                       (type.getRank() == indicesType.getDimSize(1));
       auto sameElementNum =
-          indicesType->getDimSize(0) == valuesType->getDimSize(0);
+          indicesType.getDimSize(0) == valuesType.getDimSize(0);
       if (!sameShape || !sameElementNum) {
         std::string str;
         llvm::raw_string_ostream s(str);
         s << "expected shape ([";
-        interleaveComma(type->getShape(), s);
+        interleaveComma(type.getShape(), s);
         s << "]); inferred shape of indices literal ([";
-        interleaveComma(indicesType->getShape(), s);
+        interleaveComma(indicesType.getShape(), s);
         s << "]); inferred shape of values literal ([";
-        interleaveComma(valuesType->getShape(), s);
+        interleaveComma(valuesType.getShape(), s);
         s << "])";
         return (emitError(s.str()), nullptr);
       }
@@ -1035,7 +1035,7 @@
             nullptr);
   }
   default: {
-    if (Type *type = parseType())
+    if (Type type = parseType())
       return builder.getTypeAttr(type);
     return nullptr;
   }
@@ -1051,12 +1051,12 @@
 ///
 /// This method returns a constructed dense elements attribute with the shape
 /// from the parsing result.
-DenseElementsAttr Parser::parseDenseElementsAttr(Type *eltType, bool isVector) {
+DenseElementsAttr Parser::parseDenseElementsAttr(Type eltType, bool isVector) {
   TensorLiteralParser literalParser(*this, eltType);
   if (literalParser.parse())
     return nullptr;
 
-  VectorOrTensorType *type;
+  VectorOrTensorType type;
   if (isVector) {
     type = builder.getVectorType(literalParser.getShape(), eltType);
   } else {
@@ -1076,18 +1076,18 @@
 /// This method compares the shapes from the parsing result and that from the
 /// input argument. It returns a constructed dense elements attribute if both
 /// match.
-DenseElementsAttr Parser::parseDenseElementsAttr(VectorOrTensorType *type) {
-  auto *eltTy = type->getElementType();
+DenseElementsAttr Parser::parseDenseElementsAttr(VectorOrTensorType type) {
+  auto eltTy = type.getElementType();
   TensorLiteralParser literalParser(*this, eltTy);
   if (literalParser.parse())
     return nullptr;
-  if (literalParser.getShape() != type->getShape()) {
+  if (literalParser.getShape() != type.getShape()) {
     std::string str;
     llvm::raw_string_ostream s(str);
     s << "inferred shape of elements literal ([";
     interleaveComma(literalParser.getShape(), s);
     s << "]) does not match type ([";
-    interleaveComma(type->getShape(), s);
+    interleaveComma(type.getShape(), s);
     s << "])";
     return (emitError(s.str()), nullptr);
   }
@@ -1100,8 +1100,8 @@
 ///   vector-or-tensor-type ::= vector-type | tensor-type
 ///
 /// This method also checks the type has static shape and ranked.
-VectorOrTensorType *Parser::parseVectorOrTensorType() {
-  auto *type = dyn_cast<VectorOrTensorType>(parseType());
+VectorOrTensorType Parser::parseVectorOrTensorType() {
+  auto type = parseType().dyn_cast<VectorOrTensorType>();
   if (!type) {
     return (emitError("expected elements literal has a tensor or vector type"),
             nullptr);
@@ -1110,7 +1110,7 @@
   if (parseToken(Token::comma, "expected ','"))
     return nullptr;
 
-  if (!type->hasStaticShape() || type->getRank() == -1) {
+  if (!type.hasStaticShape() || type.getRank() == -1) {
     return (emitError("tensor literals must be ranked and have static shape"),
             nullptr);
   }
@@ -1834,7 +1834,7 @@
 
   /// Given a reference to an SSA value and its type, return a reference. This
   /// returns null on failure.
-  SSAValue *resolveSSAUse(SSAUseInfo useInfo, Type *type);
+  SSAValue *resolveSSAUse(SSAUseInfo useInfo, Type type);
 
   /// Register a definition of a value with the symbol table.
   ParseResult addDefinition(SSAUseInfo useInfo, SSAValue *value);
@@ -1845,11 +1845,11 @@
 
   template <typename ResultType>
   ResultType parseSSADefOrUseAndType(
-      const std::function<ResultType(SSAUseInfo, Type *)> &action);
+      const std::function<ResultType(SSAUseInfo, Type)> &action);
 
   SSAValue *parseSSAUseAndType() {
     return parseSSADefOrUseAndType<SSAValue *>(
-        [&](SSAUseInfo useInfo, Type *type) -> SSAValue * {
+        [&](SSAUseInfo useInfo, Type type) -> SSAValue * {
           return resolveSSAUse(useInfo, type);
         });
   }
@@ -1880,7 +1880,7 @@
   /// their first reference, to allow checking for use of undefined values.
   DenseMap<SSAValue *, SMLoc> forwardReferencePlaceholders;
 
-  SSAValue *createForwardReferencePlaceholder(SMLoc loc, Type *type);
+  SSAValue *createForwardReferencePlaceholder(SMLoc loc, Type type);
 
   /// Return true if this is a forward reference.
   bool isForwardReferencePlaceholder(SSAValue *value) {
@@ -1891,7 +1891,7 @@
 
 /// Create and remember a new placeholder for a forward reference.
 SSAValue *FunctionParser::createForwardReferencePlaceholder(SMLoc loc,
-                                                            Type *type) {
+                                                            Type type) {
   // Forward references are always created as instructions, even in ML
   // functions, because we just need something with a def/use chain.
   //
@@ -1908,7 +1908,7 @@
 
 /// Given an unbound reference to an SSA value and its type, return the value
 /// it specifies.  This returns null on failure.
-SSAValue *FunctionParser::resolveSSAUse(SSAUseInfo useInfo, Type *type) {
+SSAValue *FunctionParser::resolveSSAUse(SSAUseInfo useInfo, Type type) {
   auto &entries = values[useInfo.name];
 
   // If we have already seen a value of this name, return it.
@@ -2057,14 +2057,14 @@
 ///   ssa-use-and-type ::= ssa-use `:` type
 template <typename ResultType>
 ResultType FunctionParser::parseSSADefOrUseAndType(
-    const std::function<ResultType(SSAUseInfo, Type *)> &action) {
+    const std::function<ResultType(SSAUseInfo, Type)> &action) {
 
   SSAUseInfo useInfo;
   if (parseSSAUse(useInfo) ||
       parseToken(Token::colon, "expected ':' and type for SSA operand"))
     return nullptr;
 
-  auto *type = parseType();
+  auto type = parseType();
   if (!type)
     return nullptr;
 
@@ -2101,7 +2101,7 @@
   if (valueIDs.empty())
     return ParseSuccess;
 
-  SmallVector<Type *, 4> types;
+  SmallVector<Type, 4> types;
   if (parseToken(Token::colon, "expected ':' in operand list") ||
       parseTypeListNoParens(types))
     return ParseFailure;
@@ -2209,14 +2209,14 @@
   auto type = parseType();
   if (!type)
     return nullptr;
-  auto fnType = dyn_cast<FunctionType>(type);
+  auto fnType = type.dyn_cast<FunctionType>();
   if (!fnType)
     return (emitError(typeLoc, "expected function type"), nullptr);
 
-  result.addTypes(fnType->getResults());
+  result.addTypes(fnType.getResults());
 
   // Check that we have the right number of types for the operands.
-  auto operandTypes = fnType->getInputs();
+  auto operandTypes = fnType.getInputs();
   if (operandTypes.size() != operandInfos.size()) {
     auto plural = "s"[operandInfos.size() == 1];
     return (emitError(typeLoc, "expected " + llvm::utostr(operandInfos.size()) +
@@ -2253,17 +2253,17 @@
     return parser.parseToken(Token::comma, "expected ','");
   }
 
-  bool parseColonType(Type *&result) override {
+  bool parseColonType(Type &result) override {
     return parser.parseToken(Token::colon, "expected ':'") ||
            !(result = parser.parseType());
   }
 
-  bool parseColonTypeList(SmallVectorImpl<Type *> &result) override {
+  bool parseColonTypeList(SmallVectorImpl<Type> &result) override {
     if (parser.parseToken(Token::colon, "expected ':'"))
       return true;
 
     do {
-      if (auto *type = parser.parseType())
+      if (auto type = parser.parseType())
         result.push_back(type);
       else
         return true;
@@ -2273,7 +2273,7 @@
   }
 
   /// Parse a keyword followed by a type.
-  bool parseKeywordType(const char *keyword, Type *&result) override {
+  bool parseKeywordType(const char *keyword, Type &result) override {
     if (parser.getTokenSpelling() != keyword)
       return parser.emitError("expected '" + Twine(keyword) + "'");
     parser.consumeToken();
@@ -2396,7 +2396,7 @@
   }
 
   /// Resolve a parse function name and a type into a function reference.
-  virtual bool resolveFunctionName(StringRef name, FunctionType *type,
+  virtual bool resolveFunctionName(StringRef name, FunctionType type,
                                    llvm::SMLoc loc, Function *&result) {
     result = parser.resolveFunctionReference(name, loc, type);
     return result == nullptr;
@@ -2410,7 +2410,7 @@
 
   llvm::SMLoc getNameLoc() const override { return nameLoc; }
 
-  bool resolveOperand(const OperandType &operand, Type *type,
+  bool resolveOperand(const OperandType &operand, Type type,
                       SmallVectorImpl<SSAValue *> &result) override {
     FunctionParser::SSAUseInfo operandInfo = {operand.name, operand.number,
                                               operand.location};
@@ -2559,11 +2559,11 @@
     return ParseSuccess;
 
   return parseCommaSeparatedList([&]() -> ParseResult {
-    auto type = parseSSADefOrUseAndType<Type *>(
-        [&](SSAUseInfo useInfo, Type *type) -> Type * {
+    auto type = parseSSADefOrUseAndType<Type>(
+        [&](SSAUseInfo useInfo, Type type) -> Type {
           BBArgument *arg = owner->addArgument(type);
           if (addDefinition(useInfo, arg))
-            return nullptr;
+            return {};
           return type;
         });
     return type ? ParseSuccess : ParseFailure;
@@ -2908,7 +2908,7 @@
                      " symbol count must match");
 
   // Resolve SSA uses.
-  Type *indexType = builder.getIndexType();
+  Type indexType = builder.getIndexType();
   for (unsigned i = 0, e = opInfo.size(); i != e; ++i) {
     SSAValue *sval = resolveSSAUse(opInfo[i], indexType);
     if (!sval)
@@ -3187,9 +3187,9 @@
   ParseResult parseAffineStructureDef();
 
   // Functions.
-  ParseResult parseMLArgumentList(SmallVectorImpl<Type *> &argTypes,
+  ParseResult parseMLArgumentList(SmallVectorImpl<Type> &argTypes,
                                   SmallVectorImpl<StringRef> &argNames);
-  ParseResult parseFunctionSignature(StringRef &name, FunctionType *&type,
+  ParseResult parseFunctionSignature(StringRef &name, FunctionType &type,
                                      SmallVectorImpl<StringRef> *argNames);
   ParseResult parseFunctionAttribute(SmallVectorImpl<NamedAttribute> &attrs);
   ParseResult parseExtFunc();
@@ -3248,7 +3248,7 @@
 /// ml-argument-list ::= ml-argument (`,` ml-argument)* | /*empty*/
 ///
 ParseResult
-ModuleParser::parseMLArgumentList(SmallVectorImpl<Type *> &argTypes,
+ModuleParser::parseMLArgumentList(SmallVectorImpl<Type> &argTypes,
                                   SmallVectorImpl<StringRef> &argNames) {
   consumeToken(Token::l_paren);
 
@@ -3284,7 +3284,7 @@
 ///   type-list)?
 ///
 ParseResult
-ModuleParser::parseFunctionSignature(StringRef &name, FunctionType *&type,
+ModuleParser::parseFunctionSignature(StringRef &name, FunctionType &type,
                                      SmallVectorImpl<StringRef> *argNames) {
   if (getToken().isNot(Token::at_identifier))
     return emitError("expected a function identifier like '@foo'");
@@ -3295,7 +3295,7 @@
   if (getToken().isNot(Token::l_paren))
     return emitError("expected '(' in function signature");
 
-  SmallVector<Type *, 4> argTypes;
+  SmallVector<Type, 4> argTypes;
   ParseResult parseResult;
 
   if (argNames)
@@ -3307,7 +3307,7 @@
     return ParseFailure;
 
   // Parse the return type if present.
-  SmallVector<Type *, 4> results;
+  SmallVector<Type, 4> results;
   if (consumeIf(Token::arrow)) {
     if (parseTypeList(results))
       return ParseFailure;
@@ -3340,7 +3340,7 @@
   auto loc = getToken().getLoc();
 
   StringRef name;
-  FunctionType *type = nullptr;
+  FunctionType type;
   if (parseFunctionSignature(name, type, /*arguments*/ nullptr))
     return ParseFailure;
 
@@ -3372,7 +3372,7 @@
   auto loc = getToken().getLoc();
 
   StringRef name;
-  FunctionType *type = nullptr;
+  FunctionType type;
   if (parseFunctionSignature(name, type, /*arguments*/ nullptr))
     return ParseFailure;
 
@@ -3405,7 +3405,7 @@
   consumeToken(Token::kw_mlfunc);
 
   StringRef name;
-  FunctionType *type = nullptr;
+  FunctionType type;
   SmallVector<StringRef, 4> argNames;
 
   auto loc = getToken().getLoc();
diff --git a/lib/StandardOps/StandardOps.cpp b/lib/StandardOps/StandardOps.cpp
index b60d209..e2bdfd7 100644
--- a/lib/StandardOps/StandardOps.cpp
+++ b/lib/StandardOps/StandardOps.cpp
@@ -138,23 +138,23 @@
 //===----------------------------------------------------------------------===//
 
 void AllocOp::build(Builder *builder, OperationState *result,
-                    MemRefType *memrefType, ArrayRef<SSAValue *> operands) {
+                    MemRefType memrefType, ArrayRef<SSAValue *> operands) {
   result->addOperands(operands);
   result->types.push_back(memrefType);
 }
 
 void AllocOp::print(OpAsmPrinter *p) const {
-  MemRefType *type = getType();
+  MemRefType type = getType();
   *p << "alloc";
   // Print dynamic dimension operands.
   printDimAndSymbolList(operand_begin(), operand_end(),
-                        type->getNumDynamicDims(), p);
+                        type.getNumDynamicDims(), p);
   p->printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/"map");
-  *p << " : " << *type;
+  *p << " : " << type;
 }
 
 bool AllocOp::parse(OpAsmParser *parser, OperationState *result) {
-  MemRefType *type;
+  MemRefType type;
 
   // Parse the dimension operands and optional symbol operands, followed by a
   // memref type.
@@ -170,7 +170,7 @@
   // Verification still checks that the total number of operands matches
   // the number of symbols in the affine map, plus the number of dynamic
   // dimensions in the memref.
-  if (numDimOperands != type->getNumDynamicDims()) {
+  if (numDimOperands != type.getNumDynamicDims()) {
     return parser->emitError(parser->getNameLoc(),
                              "dimension operand count does not equal memref "
                              "dynamic dimension count");
@@ -180,13 +180,13 @@
 }
 
 bool AllocOp::verify() const {
-  auto *memRefType = dyn_cast<MemRefType>(getResult()->getType());
+  auto memRefType = getResult()->getType().dyn_cast<MemRefType>();
   if (!memRefType)
     return emitOpError("result must be a memref");
 
   unsigned numSymbols = 0;
-  if (!memRefType->getAffineMaps().empty()) {
-    AffineMap affineMap = memRefType->getAffineMaps()[0];
+  if (!memRefType.getAffineMaps().empty()) {
+    AffineMap affineMap = memRefType.getAffineMaps()[0];
     // Store number of symbols used in affine map (used in subsequent check).
     numSymbols = affineMap.getNumSymbols();
     // TODO(zinenko): this check does not belong to AllocOp, or any other op but
@@ -195,10 +195,10 @@
     // Remove when we can emit errors directly from *Type::get(...) functions.
     //
     // Verify that the layout affine map matches the rank of the memref.
-    if (affineMap.getNumDims() != memRefType->getRank())
+    if (affineMap.getNumDims() != memRefType.getRank())
       return emitOpError("affine map dimension count must equal memref rank");
   }
-  unsigned numDynamicDims = memRefType->getNumDynamicDims();
+  unsigned numDynamicDims = memRefType.getNumDynamicDims();
   // Check that the total number of operands matches the number of symbols in
   // the affine map, plus the number of dynamic dimensions specified in the
   // memref type.
@@ -208,7 +208,7 @@
   }
   // Verify that all operands are of type Index.
   for (auto *operand : getOperands()) {
-    if (!operand->getType()->isIndex())
+    if (!operand->getType().isIndex())
       return emitOpError("requires operands to be of type Index");
   }
   return false;
@@ -239,13 +239,13 @@
     // Ok, we have one or more constant operands.  Collect the non-constant ones
     // and keep track of the resultant memref type to build.
     SmallVector<int, 4> newShapeConstants;
-    newShapeConstants.reserve(memrefType->getRank());
+    newShapeConstants.reserve(memrefType.getRank());
     SmallVector<SSAValue *, 4> newOperands;
     SmallVector<SSAValue *, 4> droppedOperands;
 
     unsigned dynamicDimPos = 0;
-    for (unsigned dim = 0, e = memrefType->getRank(); dim < e; ++dim) {
-      int dimSize = memrefType->getDimSize(dim);
+    for (unsigned dim = 0, e = memrefType.getRank(); dim < e; ++dim) {
+      int dimSize = memrefType.getDimSize(dim);
       // If this is already static dimension, keep it.
       if (dimSize != -1) {
         newShapeConstants.push_back(dimSize);
@@ -267,10 +267,10 @@
     }
 
     // Create new memref type (which will have fewer dynamic dimensions).
-    auto *newMemRefType = MemRefType::get(
-        newShapeConstants, memrefType->getElementType(),
-        memrefType->getAffineMaps(), memrefType->getMemorySpace());
-    assert(newOperands.size() == newMemRefType->getNumDynamicDims());
+    auto newMemRefType = MemRefType::get(
+        newShapeConstants, memrefType.getElementType(),
+        memrefType.getAffineMaps(), memrefType.getMemorySpace());
+    assert(newOperands.size() == newMemRefType.getNumDynamicDims());
 
     // Create and insert the alloc op for the new memref.
     auto newAlloc =
@@ -297,13 +297,13 @@
                    ArrayRef<SSAValue *> operands) {
   result->addOperands(operands);
   result->addAttribute("callee", builder->getFunctionAttr(callee));
-  result->addTypes(callee->getType()->getResults());
+  result->addTypes(callee->getType().getResults());
 }
 
 bool CallOp::parse(OpAsmParser *parser, OperationState *result) {
   StringRef calleeName;
   llvm::SMLoc calleeLoc;
-  FunctionType *calleeType = nullptr;
+  FunctionType calleeType;
   SmallVector<OpAsmParser::OperandType, 4> operands;
   Function *callee = nullptr;
   if (parser->parseFunctionName(calleeName, calleeLoc) ||
@@ -312,8 +312,8 @@
       parser->parseOptionalAttributeDict(result->attributes) ||
       parser->parseColonType(calleeType) ||
       parser->resolveFunctionName(calleeName, calleeType, calleeLoc, callee) ||
-      parser->addTypesToList(calleeType->getResults(), result->types) ||
-      parser->resolveOperands(operands, calleeType->getInputs(), calleeLoc,
+      parser->addTypesToList(calleeType.getResults(), result->types) ||
+      parser->resolveOperands(operands, calleeType.getInputs(), calleeLoc,
                               result->operands))
     return true;
 
@@ -328,7 +328,7 @@
   p->printOperands(getOperands());
   *p << ')';
   p->printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/"callee");
-  *p << " : " << *getCallee()->getType();
+  *p << " : " << getCallee()->getType();
 }
 
 bool CallOp::verify() const {
@@ -338,20 +338,20 @@
     return emitOpError("requires a 'callee' function attribute");
 
   // Verify that the operand and result types match the callee.
-  auto *fnType = fnAttr.getValue()->getType();
-  if (fnType->getNumInputs() != getNumOperands())
+  auto fnType = fnAttr.getValue()->getType();
+  if (fnType.getNumInputs() != getNumOperands())
     return emitOpError("incorrect number of operands for callee");
 
-  for (unsigned i = 0, e = fnType->getNumInputs(); i != e; ++i) {
-    if (getOperand(i)->getType() != fnType->getInput(i))
+  for (unsigned i = 0, e = fnType.getNumInputs(); i != e; ++i) {
+    if (getOperand(i)->getType() != fnType.getInput(i))
       return emitOpError("operand type mismatch");
   }
 
-  if (fnType->getNumResults() != getNumResults())
+  if (fnType.getNumResults() != getNumResults())
     return emitOpError("incorrect number of results for callee");
 
-  for (unsigned i = 0, e = fnType->getNumResults(); i != e; ++i) {
-    if (getResult(i)->getType() != fnType->getResult(i))
+  for (unsigned i = 0, e = fnType.getNumResults(); i != e; ++i) {
+    if (getResult(i)->getType() != fnType.getResult(i))
       return emitOpError("result type mismatch");
   }
 
@@ -364,14 +364,14 @@
 
 void CallIndirectOp::build(Builder *builder, OperationState *result,
                            SSAValue *callee, ArrayRef<SSAValue *> operands) {
-  auto *fnType = cast<FunctionType>(callee->getType());
+  auto fnType = callee->getType().cast<FunctionType>();
   result->operands.push_back(callee);
   result->addOperands(operands);
-  result->addTypes(fnType->getResults());
+  result->addTypes(fnType.getResults());
 }
 
 bool CallIndirectOp::parse(OpAsmParser *parser, OperationState *result) {
-  FunctionType *calleeType = nullptr;
+  FunctionType calleeType;
   OpAsmParser::OperandType callee;
   llvm::SMLoc operandsLoc;
   SmallVector<OpAsmParser::OperandType, 4> operands;
@@ -382,9 +382,9 @@
          parser->parseOptionalAttributeDict(result->attributes) ||
          parser->parseColonType(calleeType) ||
          parser->resolveOperand(callee, calleeType, result->operands) ||
-         parser->resolveOperands(operands, calleeType->getInputs(), operandsLoc,
+         parser->resolveOperands(operands, calleeType.getInputs(), operandsLoc,
                                  result->operands) ||
-         parser->addTypesToList(calleeType->getResults(), result->types);
+         parser->addTypesToList(calleeType.getResults(), result->types);
 }
 
 void CallIndirectOp::print(OpAsmPrinter *p) const {
@@ -395,29 +395,29 @@
   p->printOperands(++operandRange.begin(), operandRange.end());
   *p << ')';
   p->printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/"callee");
-  *p << " : " << *getCallee()->getType();
+  *p << " : " << getCallee()->getType();
 }
 
 bool CallIndirectOp::verify() const {
   // The callee must be a function.
-  auto *fnType = dyn_cast<FunctionType>(getCallee()->getType());
+  auto fnType = getCallee()->getType().dyn_cast<FunctionType>();
   if (!fnType)
     return emitOpError("callee must have function type");
 
   // Verify that the operand and result types match the callee.
-  if (fnType->getNumInputs() != getNumOperands() - 1)
+  if (fnType.getNumInputs() != getNumOperands() - 1)
     return emitOpError("incorrect number of operands for callee");
 
-  for (unsigned i = 0, e = fnType->getNumInputs(); i != e; ++i) {
-    if (getOperand(i + 1)->getType() != fnType->getInput(i))
+  for (unsigned i = 0, e = fnType.getNumInputs(); i != e; ++i) {
+    if (getOperand(i + 1)->getType() != fnType.getInput(i))
       return emitOpError("operand type mismatch");
   }
 
-  if (fnType->getNumResults() != getNumResults())
+  if (fnType.getNumResults() != getNumResults())
     return emitOpError("incorrect number of results for callee");
 
-  for (unsigned i = 0, e = fnType->getNumResults(); i != e; ++i) {
-    if (getResult(i)->getType() != fnType->getResult(i))
+  for (unsigned i = 0, e = fnType.getNumResults(); i != e; ++i) {
+    if (getResult(i)->getType() != fnType.getResult(i))
       return emitOpError("result type mismatch");
   }
 
@@ -434,19 +434,19 @@
 }
 
 void DeallocOp::print(OpAsmPrinter *p) const {
-  *p << "dealloc " << *getMemRef() << " : " << *getMemRef()->getType();
+  *p << "dealloc " << *getMemRef() << " : " << getMemRef()->getType();
 }
 
 bool DeallocOp::parse(OpAsmParser *parser, OperationState *result) {
   OpAsmParser::OperandType memrefInfo;
-  MemRefType *type;
+  MemRefType type;
 
   return parser->parseOperand(memrefInfo) || parser->parseColonType(type) ||
          parser->resolveOperand(memrefInfo, type, result->operands);
 }
 
 bool DeallocOp::verify() const {
-  if (!isa<MemRefType>(getMemRef()->getType()))
+  if (!getMemRef()->getType().isa<MemRefType>())
     return emitOpError("operand must be a memref");
   return false;
 }
@@ -472,13 +472,13 @@
 void DimOp::print(OpAsmPrinter *p) const {
   *p << "dim " << *getOperand() << ", " << getIndex();
   p->printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/"index");
-  *p << " : " << *getOperand()->getType();
+  *p << " : " << getOperand()->getType();
 }
 
 bool DimOp::parse(OpAsmParser *parser, OperationState *result) {
   OpAsmParser::OperandType operandInfo;
   IntegerAttr indexAttr;
-  Type *type;
+  Type type;
 
   return parser->parseOperand(operandInfo) || parser->parseComma() ||
          parser->parseAttribute(indexAttr, "index", result->attributes) ||
@@ -496,15 +496,15 @@
     return emitOpError("requires an integer attribute named 'index'");
   uint64_t index = (uint64_t)indexAttr.getValue();
 
-  auto *type = getOperand()->getType();
-  if (auto *tensorType = dyn_cast<RankedTensorType>(type)) {
-    if (index >= tensorType->getRank())
+  auto type = getOperand()->getType();
+  if (auto tensorType = type.dyn_cast<RankedTensorType>()) {
+    if (index >= tensorType.getRank())
       return emitOpError("index is out of range");
-  } else if (auto *memrefType = dyn_cast<MemRefType>(type)) {
-    if (index >= memrefType->getRank())
+  } else if (auto memrefType = type.dyn_cast<MemRefType>()) {
+    if (index >= memrefType.getRank())
       return emitOpError("index is out of range");
 
-  } else if (isa<UnrankedTensorType>(type)) {
+  } else if (type.isa<UnrankedTensorType>()) {
     // ok, assumed to be in-range.
   } else {
     return emitOpError("requires an operand with tensor or memref type");
@@ -516,12 +516,12 @@
 Attribute DimOp::constantFold(ArrayRef<Attribute> operands,
                               MLIRContext *context) const {
   // Constant fold dim when the size along the index referred to is a constant.
-  auto *opType = getOperand()->getType();
+  auto opType = getOperand()->getType();
   int indexSize = -1;
-  if (auto *tensorType = dyn_cast<RankedTensorType>(opType)) {
-    indexSize = tensorType->getShape()[getIndex()];
-  } else if (auto *memrefType = dyn_cast<MemRefType>(opType)) {
-    indexSize = memrefType->getShape()[getIndex()];
+  if (auto tensorType = opType.dyn_cast<RankedTensorType>()) {
+    indexSize = tensorType.getShape()[getIndex()];
+  } else if (auto memrefType = opType.dyn_cast<MemRefType>()) {
+    indexSize = memrefType.getShape()[getIndex()];
   }
 
   if (indexSize >= 0)
@@ -544,9 +544,9 @@
   p->printOperands(getTagIndices());
   *p << ']';
   p->printOptionalAttrDict(getAttrs());
-  *p << " : " << *getSrcMemRef()->getType();
-  *p << ", " << *getDstMemRef()->getType();
-  *p << ", " << *getTagMemRef()->getType();
+  *p << " : " << getSrcMemRef()->getType();
+  *p << ", " << getDstMemRef()->getType();
+  *p << ", " << getTagMemRef()->getType();
 }
 
 // Parse DmaStartOp.
@@ -566,8 +566,8 @@
   OpAsmParser::OperandType tagMemrefInfo;
   SmallVector<OpAsmParser::OperandType, 4> tagIndexInfos;
 
-  SmallVector<Type *, 3> types;
-  auto *indexType = parser->getBuilder().getIndexType();
+  SmallVector<Type, 3> types;
+  auto indexType = parser->getBuilder().getIndexType();
 
   // Parse and resolve the following list of operands:
   // *) source memref followed by its indices (in square brackets).
@@ -601,12 +601,12 @@
     return true;
 
   // Check that source/destination index list size matches associated rank.
-  if (srcIndexInfos.size() != cast<MemRefType>(types[0])->getRank() ||
-      dstIndexInfos.size() != cast<MemRefType>(types[1])->getRank())
+  if (srcIndexInfos.size() != types[0].cast<MemRefType>().getRank() ||
+      dstIndexInfos.size() != types[1].cast<MemRefType>().getRank())
     return parser->emitError(parser->getNameLoc(),
                              "memref rank not equal to indices count");
 
-  if (tagIndexInfos.size() != cast<MemRefType>(types[2])->getRank())
+  if (tagIndexInfos.size() != types[2].cast<MemRefType>().getRank())
     return parser->emitError(parser->getNameLoc(),
                              "tag memref rank not equal to indices count");
 
@@ -632,7 +632,7 @@
   p->printOperands(getTagIndices());
   *p << "], ";
   p->printOperand(getNumElements());
-  *p << " : " << *getTagMemRef()->getType();
+  *p << " : " << getTagMemRef()->getType();
 }
 
 // Parse DmaWaitOp.
@@ -642,8 +642,8 @@
 bool DmaWaitOp::parse(OpAsmParser *parser, OperationState *result) {
   OpAsmParser::OperandType tagMemrefInfo;
   SmallVector<OpAsmParser::OperandType, 2> tagIndexInfos;
-  Type *type;
-  auto *indexType = parser->getBuilder().getIndexType();
+  Type type;
+  auto indexType = parser->getBuilder().getIndexType();
   OpAsmParser::OperandType numElementsInfo;
 
   // Parse tag memref, its indices, and dma size.
@@ -657,7 +657,7 @@
       parser->resolveOperand(numElementsInfo, indexType, result->operands))
     return true;
 
-  if (tagIndexInfos.size() != cast<MemRefType>(type)->getRank())
+  if (tagIndexInfos.size() != type.cast<MemRefType>().getRank())
     return parser->emitError(parser->getNameLoc(),
                              "tag memref rank not equal to indices count");
 
@@ -678,10 +678,10 @@
 void ExtractElementOp::build(Builder *builder, OperationState *result,
                              SSAValue *aggregate,
                              ArrayRef<SSAValue *> indices) {
-  auto *aggregateType = cast<VectorOrTensorType>(aggregate->getType());
+  auto aggregateType = aggregate->getType().cast<VectorOrTensorType>();
   result->addOperands(aggregate);
   result->addOperands(indices);
-  result->types.push_back(aggregateType->getElementType());
+  result->types.push_back(aggregateType.getElementType());
 }
 
 void ExtractElementOp::print(OpAsmPrinter *p) const {
@@ -689,13 +689,13 @@
   p->printOperands(getIndices());
   *p << ']';
   p->printOptionalAttrDict(getAttrs());
-  *p << " : " << *getAggregate()->getType();
+  *p << " : " << getAggregate()->getType();
 }
 
 bool ExtractElementOp::parse(OpAsmParser *parser, OperationState *result) {
   OpAsmParser::OperandType aggregateInfo;
   SmallVector<OpAsmParser::OperandType, 4> indexInfo;
-  VectorOrTensorType *type;
+  VectorOrTensorType type;
 
   auto affineIntTy = parser->getBuilder().getIndexType();
   return parser->parseOperand(aggregateInfo) ||
@@ -705,26 +705,26 @@
          parser->parseColonType(type) ||
          parser->resolveOperand(aggregateInfo, type, result->operands) ||
          parser->resolveOperands(indexInfo, affineIntTy, result->operands) ||
-         parser->addTypeToList(type->getElementType(), result->types);
+         parser->addTypeToList(type.getElementType(), result->types);
 }
 
 bool ExtractElementOp::verify() const {
   if (getNumOperands() == 0)
     return emitOpError("expected an aggregate to index into");
 
-  auto *aggregateType = dyn_cast<VectorOrTensorType>(getAggregate()->getType());
+  auto aggregateType = getAggregate()->getType().dyn_cast<VectorOrTensorType>();
   if (!aggregateType)
     return emitOpError("first operand must be a vector or tensor");
 
-  if (getType() != aggregateType->getElementType())
+  if (getType() != aggregateType.getElementType())
     return emitOpError("result type must match element type of aggregate");
 
   for (auto *idx : getIndices())
-    if (!idx->getType()->isIndex())
+    if (!idx->getType().isIndex())
       return emitOpError("index to extract_element must have 'index' type");
 
   // Verify the # indices match if we have a ranked type.
-  auto aggregateRank = aggregateType->getRank();
+  auto aggregateRank = aggregateType.getRank();
   if (aggregateRank != -1 && aggregateRank != getNumOperands() - 1)
     return emitOpError("incorrect number of indices for extract_element");
 
@@ -737,10 +737,10 @@
 
 void LoadOp::build(Builder *builder, OperationState *result, SSAValue *memref,
                    ArrayRef<SSAValue *> indices) {
-  auto *memrefType = cast<MemRefType>(memref->getType());
+  auto memrefType = memref->getType().cast<MemRefType>();
   result->addOperands(memref);
   result->addOperands(indices);
-  result->types.push_back(memrefType->getElementType());
+  result->types.push_back(memrefType.getElementType());
 }
 
 void LoadOp::print(OpAsmPrinter *p) const {
@@ -748,13 +748,13 @@
   p->printOperands(getIndices());
   *p << ']';
   p->printOptionalAttrDict(getAttrs());
-  *p << " : " << *getMemRefType();
+  *p << " : " << getMemRefType();
 }
 
 bool LoadOp::parse(OpAsmParser *parser, OperationState *result) {
   OpAsmParser::OperandType memrefInfo;
   SmallVector<OpAsmParser::OperandType, 4> indexInfo;
-  MemRefType *type;
+  MemRefType type;
 
   auto affineIntTy = parser->getBuilder().getIndexType();
   return parser->parseOperand(memrefInfo) ||
@@ -764,25 +764,25 @@
          parser->parseColonType(type) ||
          parser->resolveOperand(memrefInfo, type, result->operands) ||
          parser->resolveOperands(indexInfo, affineIntTy, result->operands) ||
-         parser->addTypeToList(type->getElementType(), result->types);
+         parser->addTypeToList(type.getElementType(), result->types);
 }
 
 bool LoadOp::verify() const {
   if (getNumOperands() == 0)
     return emitOpError("expected a memref to load from");
 
-  auto *memRefType = dyn_cast<MemRefType>(getMemRef()->getType());
+  auto memRefType = getMemRef()->getType().dyn_cast<MemRefType>();
   if (!memRefType)
     return emitOpError("first operand must be a memref");
 
-  if (getType() != memRefType->getElementType())
+  if (getType() != memRefType.getElementType())
     return emitOpError("result type must match element type of memref");
 
-  if (memRefType->getRank() != getNumOperands() - 1)
+  if (memRefType.getRank() != getNumOperands() - 1)
     return emitOpError("incorrect number of indices for load");
 
   for (auto *idx : getIndices())
-    if (!idx->getType()->isIndex())
+    if (!idx->getType().isIndex())
       return emitOpError("index to load must have 'index' type");
 
   // TODO: Verify we have the right number of indices.
@@ -804,31 +804,31 @@
 //===----------------------------------------------------------------------===//
 
 bool MemRefCastOp::verify() const {
-  auto *opType = dyn_cast<MemRefType>(getOperand()->getType());
-  auto *resType = dyn_cast<MemRefType>(getType());
+  auto opType = getOperand()->getType().dyn_cast<MemRefType>();
+  auto resType = getType().dyn_cast<MemRefType>();
   if (!opType || !resType)
     return emitOpError("requires input and result types to be memrefs");
 
   if (opType == resType)
     return emitOpError("requires the input and result type to be different");
 
-  if (opType->getElementType() != resType->getElementType())
+  if (opType.getElementType() != resType.getElementType())
     return emitOpError(
         "requires input and result element types to be the same");
 
-  if (opType->getAffineMaps() != resType->getAffineMaps())
+  if (opType.getAffineMaps() != resType.getAffineMaps())
     return emitOpError("requires input and result mappings to be the same");
 
-  if (opType->getMemorySpace() != resType->getMemorySpace())
+  if (opType.getMemorySpace() != resType.getMemorySpace())
     return emitOpError(
         "requires input and result memory spaces to be the same");
 
   // They must have the same rank, and any specified dimensions must match.
-  if (opType->getRank() != resType->getRank())
+  if (opType.getRank() != resType.getRank())
     return emitOpError("requires input and result ranks to match");
 
-  for (unsigned i = 0, e = opType->getRank(); i != e; ++i) {
-    int opDim = opType->getDimSize(i), resultDim = resType->getDimSize(i);
+  for (unsigned i = 0, e = opType.getRank(); i != e; ++i) {
+    int opDim = opType.getDimSize(i), resultDim = resType.getDimSize(i);
     if (opDim != -1 && resultDim != -1 && opDim != resultDim)
       return emitOpError("requires static dimensions to match");
   }
@@ -923,14 +923,14 @@
   p->printOperands(getIndices());
   *p << ']';
   p->printOptionalAttrDict(getAttrs());
-  *p << " : " << *getMemRefType();
+  *p << " : " << getMemRefType();
 }
 
 bool StoreOp::parse(OpAsmParser *parser, OperationState *result) {
   OpAsmParser::OperandType storeValueInfo;
   OpAsmParser::OperandType memrefInfo;
   SmallVector<OpAsmParser::OperandType, 4> indexInfo;
-  MemRefType *memrefType;
+  MemRefType memrefType;
 
   auto affineIntTy = parser->getBuilder().getIndexType();
   return parser->parseOperand(storeValueInfo) || parser->parseComma() ||
@@ -939,7 +939,7 @@
                                   OpAsmParser::Delimiter::Square) ||
          parser->parseOptionalAttributeDict(result->attributes) ||
          parser->parseColonType(memrefType) ||
-         parser->resolveOperand(storeValueInfo, memrefType->getElementType(),
+         parser->resolveOperand(storeValueInfo, memrefType.getElementType(),
                                 result->operands) ||
          parser->resolveOperand(memrefInfo, memrefType, result->operands) ||
          parser->resolveOperands(indexInfo, affineIntTy, result->operands);
@@ -950,19 +950,19 @@
     return emitOpError("expected a value to store and a memref");
 
   // Second operand is a memref type.
-  auto *memRefType = dyn_cast<MemRefType>(getMemRef()->getType());
+  auto memRefType = getMemRef()->getType().dyn_cast<MemRefType>();
   if (!memRefType)
     return emitOpError("second operand must be a memref");
 
   // First operand must have same type as memref element type.
-  if (getValueToStore()->getType() != memRefType->getElementType())
+  if (getValueToStore()->getType() != memRefType.getElementType())
     return emitOpError("first operand must have same type memref element type");
 
-  if (getNumOperands() != 2 + memRefType->getRank())
+  if (getNumOperands() != 2 + memRefType.getRank())
     return emitOpError("store index operand count not equal to memref rank");
 
   for (auto *idx : getIndices())
-    if (!idx->getType()->isIndex())
+    if (!idx->getType().isIndex())
       return emitOpError("index to load must have 'index' type");
 
   // TODO: Verify we have the right number of indices.
@@ -1046,31 +1046,31 @@
 //===----------------------------------------------------------------------===//
 
 bool TensorCastOp::verify() const {
-  auto *opType = dyn_cast<TensorType>(getOperand()->getType());
-  auto *resType = dyn_cast<TensorType>(getType());
+  auto opType = getOperand()->getType().dyn_cast<TensorType>();
+  auto resType = getType().dyn_cast<TensorType>();
   if (!opType || !resType)
     return emitOpError("requires input and result types to be tensors");
 
   if (opType == resType)
     return emitOpError("requires the input and result type to be different");
 
-  if (opType->getElementType() != resType->getElementType())
+  if (opType.getElementType() != resType.getElementType())
     return emitOpError(
         "requires input and result element types to be the same");
 
   // If the source or destination are unranked, then the cast is valid.
-  auto *opRType = dyn_cast<RankedTensorType>(opType);
-  auto *resRType = dyn_cast<RankedTensorType>(resType);
+  auto opRType = opType.dyn_cast<RankedTensorType>();
+  auto resRType = resType.dyn_cast<RankedTensorType>();
   if (!opRType || !resRType)
     return false;
 
   // If they are both ranked, they have to have the same rank, and any specified
   // dimensions must match.
-  if (opRType->getRank() != resRType->getRank())
+  if (opRType.getRank() != resRType.getRank())
     return emitOpError("requires input and result ranks to match");
 
-  for (unsigned i = 0, e = opRType->getRank(); i != e; ++i) {
-    int opDim = opRType->getDimSize(i), resultDim = resRType->getDimSize(i);
+  for (unsigned i = 0, e = opRType.getRank(); i != e; ++i) {
+    int opDim = opRType.getDimSize(i), resultDim = resRType.getDimSize(i);
     if (opDim != -1 && resultDim != -1 && opDim != resultDim)
       return emitOpError("requires static dimensions to match");
   }
diff --git a/lib/Transforms/ConstantFold.cpp b/lib/Transforms/ConstantFold.cpp
index 81994dd..15dd89b 100644
--- a/lib/Transforms/ConstantFold.cpp
+++ b/lib/Transforms/ConstantFold.cpp
@@ -31,7 +31,7 @@
   SmallVector<SSAValue *, 8> existingConstants;
   // Operation statements that were folded and that need to be erased.
   std::vector<OperationStmt *> opStmtsToErase;
-  using ConstantFactoryType = std::function<SSAValue *(Attribute, Type *)>;
+  using ConstantFactoryType = std::function<SSAValue *(Attribute, Type)>;
 
   bool foldOperation(Operation *op,
                      SmallVectorImpl<SSAValue *> &existingConstants,
@@ -106,7 +106,7 @@
     for (auto instIt = bb.begin(), e = bb.end(); instIt != e;) {
       auto &inst = *instIt++;
 
-      auto constantFactory = [&](Attribute value, Type *type) -> SSAValue * {
+      auto constantFactory = [&](Attribute value, Type type) -> SSAValue * {
         builder.setInsertionPoint(&inst);
         return builder.create<ConstantOp>(inst.getLoc(), value, type);
       };
@@ -134,7 +134,7 @@
 
 // Override the walker's operation statement visit for constant folding.
 void ConstantFold::visitOperationStmt(OperationStmt *stmt) {
-  auto constantFactory = [&](Attribute value, Type *type) -> SSAValue * {
+  auto constantFactory = [&](Attribute value, Type type) -> SSAValue * {
     MLFuncBuilder builder(stmt);
     return builder.create<ConstantOp>(stmt->getLoc(), value, type);
   };
diff --git a/lib/Transforms/PipelineDataTransfer.cpp b/lib/Transforms/PipelineDataTransfer.cpp
index d96d65b..9042181 100644
--- a/lib/Transforms/PipelineDataTransfer.cpp
+++ b/lib/Transforms/PipelineDataTransfer.cpp
@@ -77,23 +77,23 @@
   bInner.setInsertionPoint(forStmt, forStmt->begin());
 
   // Doubles the shape with a leading dimension extent of 2.
-  auto doubleShape = [&](MemRefType *oldMemRefType) -> MemRefType * {
+  auto doubleShape = [&](MemRefType oldMemRefType) -> MemRefType {
     // Add the leading dimension in the shape for the double buffer.
-    ArrayRef<int> shape = oldMemRefType->getShape();
+    ArrayRef<int> shape = oldMemRefType.getShape();
     SmallVector<int, 4> shapeSizes(shape.begin(), shape.end());
     shapeSizes.insert(shapeSizes.begin(), 2);
 
-    auto *newMemRefType =
-        bInner.getMemRefType(shapeSizes, oldMemRefType->getElementType(), {},
-                             oldMemRefType->getMemorySpace());
+    auto newMemRefType =
+        bInner.getMemRefType(shapeSizes, oldMemRefType.getElementType(), {},
+                             oldMemRefType.getMemorySpace());
     return newMemRefType;
   };
 
-  auto *newMemRefType = doubleShape(cast<MemRefType>(oldMemRef->getType()));
+  auto newMemRefType = doubleShape(oldMemRef->getType().cast<MemRefType>());
 
   // Create and place the alloc at the top level.
   MLFuncBuilder topBuilder(forStmt->getFunction());
-  auto *newMemRef = cast<MLValue>(
+  auto newMemRef = cast<MLValue>(
       topBuilder.create<AllocOp>(forStmt->getLoc(), newMemRefType)
           ->getResult());
 
diff --git a/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp b/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp
index cdf5b71..4ec8942 100644
--- a/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp
+++ b/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp
@@ -78,7 +78,7 @@
   /// As part of canonicalization, we move constants to the top of the entry
   /// block of the current function and de-duplicate them.  This keeps track of
   /// constants we have done this for.
-  DenseMap<std::pair<Attribute, Type *>, Operation *> uniquedConstants;
+  DenseMap<std::pair<Attribute, Type>, Operation *> uniquedConstants;
 };
 }; // end anonymous namespace
 
diff --git a/lib/Transforms/Utils/Utils.cpp b/lib/Transforms/Utils/Utils.cpp
index edd8ce8..ad9d6dc 100644
--- a/lib/Transforms/Utils/Utils.cpp
+++ b/lib/Transforms/Utils/Utils.cpp
@@ -52,9 +52,9 @@
                                     MLValue *newMemRef,
                                     ArrayRef<MLValue *> extraIndices,
                                     AffineMap indexRemap) {
-  unsigned newMemRefRank = cast<MemRefType>(newMemRef->getType())->getRank();
+  unsigned newMemRefRank = newMemRef->getType().cast<MemRefType>().getRank();
   (void)newMemRefRank; // unused in opt mode
-  unsigned oldMemRefRank = cast<MemRefType>(oldMemRef->getType())->getRank();
+  unsigned oldMemRefRank = oldMemRef->getType().cast<MemRefType>().getRank();
   (void)newMemRefRank;
   if (indexRemap) {
     assert(indexRemap.getNumInputs() == oldMemRefRank);
@@ -64,8 +64,8 @@
   }
 
   // Assert same elemental type.
-  assert(cast<MemRefType>(oldMemRef->getType())->getElementType() ==
-         cast<MemRefType>(newMemRef->getType())->getElementType());
+  assert(oldMemRef->getType().cast<MemRefType>().getElementType() ==
+         newMemRef->getType().cast<MemRefType>().getElementType());
 
   // Check if memref was used in a non-deferencing context.
   for (const StmtOperand &use : oldMemRef->getUses()) {
@@ -139,7 +139,7 @@
                     opStmt->operand_end());
 
     // Result types don't change. Both memref's are of the same elemental type.
-    SmallVector<Type *, 8> resultTypes;
+    SmallVector<Type, 8> resultTypes;
     resultTypes.reserve(opStmt->getNumResults());
     for (const auto *result : opStmt->getResults())
       resultTypes.push_back(result->getType());
diff --git a/lib/Transforms/Vectorize.cpp b/lib/Transforms/Vectorize.cpp
index d7a1f53..511afa9 100644
--- a/lib/Transforms/Vectorize.cpp
+++ b/lib/Transforms/Vectorize.cpp
@@ -202,15 +202,15 @@
 /// sizes specified by vectorSize. The MemRef lives in the same memory space as
 /// tmpl. The MemRef should be promoted to a closer memory address space in a
 /// later pass.
-static MemRefType *getVectorizedMemRefType(MemRefType *tmpl,
-                                           ArrayRef<int> vectorSizes) {
-  auto *elementType = tmpl->getElementType();
-  assert(!dyn_cast<VectorType>(elementType) &&
+static MemRefType getVectorizedMemRefType(MemRefType tmpl,
+                                          ArrayRef<int> vectorSizes) {
+  auto elementType = tmpl.getElementType();
+  assert(!elementType.dyn_cast<VectorType>() &&
          "Can't vectorize an already vector type");
-  assert(tmpl->getAffineMaps().empty() &&
+  assert(tmpl.getAffineMaps().empty() &&
          "Unsupported non-implicit identity map");
   return MemRefType::get({1}, VectorType::get(vectorSizes, elementType), {},
-                         tmpl->getMemorySpace());
+                         tmpl.getMemorySpace());
 }
 
 /// Creates an unaligned load with the following semantics:
@@ -258,7 +258,7 @@
   operands.insert(operands.end(), dstMemRef);
   operands.insert(operands.end(), dstIndices.begin(), dstIndices.end());
   using functional::map;
-  std::function<Type *(SSAValue *)> getType = [](SSAValue *v) -> Type * {
+  std::function<Type(SSAValue *)> getType = [](SSAValue *v) -> Type {
     return v->getType();
   };
   auto types = map(getType, operands);
@@ -310,7 +310,7 @@
   operands.insert(operands.end(), dstMemRef);
   operands.insert(operands.end(), dstIndices.begin(), dstIndices.end());
   using functional::map;
-  std::function<Type *(SSAValue *)> getType = [](SSAValue *v) -> Type * {
+  std::function<Type(SSAValue *)> getType = [](SSAValue *v) -> Type {
     return v->getType();
   };
   auto types = map(getType, operands);
@@ -348,8 +348,9 @@
 template <typename LoadOrStoreOpPointer>
 static MLValue *materializeVector(MLValue *iv, LoadOrStoreOpPointer memoryOp,
                                   ArrayRef<int> vectorSize) {
-  auto *memRefType = cast<MemRefType>(memoryOp->getMemRef()->getType());
-  auto *vectorMemRefType = getVectorizedMemRefType(memRefType, vectorSize);
+  auto memRefType =
+      memoryOp->getMemRef()->getType().template cast<MemRefType>();
+  auto vectorMemRefType = getVectorizedMemRefType(memRefType, vectorSize);
 
   // Materialize a MemRef with 1 vector.
   auto *opStmt = cast<OperationStmt>(memoryOp->getOperation());