diff --git a/include/mlir/Support/LLVM.h b/include/mlir/Support/LLVM.h
index 63225f1..d3f3cd5 100644
--- a/include/mlir/Support/LLVM.h
+++ b/include/mlir/Support/LLVM.h
@@ -29,69 +29,68 @@
 
 // We include these two headers because they cannot be practically forward
 // declared, and are effectively language features.
-#include "llvm/Support/Casting.h"
 #include "llvm/ADT/None.h"
+#include "llvm/Support/Casting.h"
 
 // Forward declarations.
 namespace llvm {
-  // Containers.
-  class StringRef;
-  class StringLiteral;
-  class Twine;
-  template <typename T> class SmallPtrSetImpl;
-  template <typename T, unsigned N> class SmallPtrSet;
-  template <typename T> class SmallVectorImpl;
-  template <typename T, unsigned N> class SmallVector;
-  template <unsigned N> class SmallString;
-  template<typename T> class ArrayRef;
-  template<typename T> class MutableArrayRef;
-  template<typename T> class TinyPtrVector;
-  template<typename T> class Optional;
-  template <typename PT1, typename PT2> class PointerUnion;
-  namespace detail {
-    template <typename KeyT, typename ValueT> struct DenseMapPair;
-  }
-  template<typename T> struct DenseMapInfo;
-  template <typename KeyT, typename ValueT, typename KeyInfoT, typename BucketT>
-  class DenseMap;
+// Containers.
+class StringRef;
+class StringLiteral;
+class Twine;
+template <typename T> class SmallPtrSetImpl;
+template <typename T, unsigned N> class SmallPtrSet;
+template <typename T> class SmallVectorImpl;
+template <typename T, unsigned N> class SmallVector;
+template <unsigned N> class SmallString;
+template <typename T> class ArrayRef;
+template <typename T> class MutableArrayRef;
+template <typename T> class TinyPtrVector;
+template <typename T> class Optional;
+template <typename PT1, typename PT2> class PointerUnion;
+namespace detail {
+template <typename KeyT, typename ValueT> struct DenseMapPair;
+}
+template <typename T> struct DenseMapInfo;
+template <typename KeyT, typename ValueT, typename KeyInfoT, typename BucketT>
+class DenseMap;
 
-  // Other common classes.
-  class raw_ostream;
-  class APInt;
-  class APFloat;
+// Other common classes.
+class raw_ostream;
+class APInt;
+class APFloat;
 } // end namespace llvm
 
-
 namespace mlir {
-  // Casting operators.
-  using llvm::isa;
-  using llvm::cast;
-  using llvm::dyn_cast;
-  using llvm::dyn_cast_or_null;
-  using llvm::cast_or_null;
+// Casting operators.
+using llvm::cast;
+using llvm::cast_or_null;
+using llvm::dyn_cast;
+using llvm::dyn_cast_or_null;
+using llvm::isa;
 
-  // Containers.
-  using llvm::None;
-  using llvm::Optional;
-  using llvm::SmallPtrSetImpl;
-  using llvm::SmallPtrSet;
-  using llvm::SmallString;
-  using llvm::StringRef;
-  using llvm::StringLiteral;
-  using llvm::Twine;
-  using llvm::SmallVectorImpl;
-  using llvm::SmallVector;
-  using llvm::ArrayRef;
-  using llvm::MutableArrayRef;
-  using llvm::TinyPtrVector;
-  using llvm::PointerUnion;
-  using llvm::DenseMap;
+// Containers.
+using llvm::ArrayRef;
+using llvm::DenseMap;
+using llvm::MutableArrayRef;
+using llvm::None;
+using llvm::Optional;
+using llvm::PointerUnion;
+using llvm::SmallPtrSet;
+using llvm::SmallPtrSetImpl;
+using llvm::SmallString;
+using llvm::SmallVector;
+using llvm::SmallVectorImpl;
+using llvm::StringLiteral;
+using llvm::StringRef;
+using llvm::TinyPtrVector;
+using llvm::Twine;
 
-  // Other common classes.
-  using llvm::raw_ostream;
-  using llvm::APInt;
-  using llvm::APFloat;
-  using llvm::NoneType;
-} // end namespace swift
+// Other common classes.
+using llvm::APFloat;
+using llvm::APInt;
+using llvm::NoneType;
+using llvm::raw_ostream;
+} // namespace mlir
 
 #endif // MLIR_SUPPORT_LLVM_H
diff --git a/lib/IR/AsmPrinter.cpp b/lib/IR/AsmPrinter.cpp
index 64b5a2c..55cc98c 100644
--- a/lib/IR/AsmPrinter.cpp
+++ b/lib/IR/AsmPrinter.cpp
@@ -86,8 +86,7 @@
   DenseMap<const AffineMap *, int> affineMapIds;
   int nextAffineMapId = 0;
 };
-}  // end anonymous namespace
-
+} // end anonymous namespace
 
 // TODO Support visiting other types/instructions when implemented.
 void ModuleState::visitType(const Type *type) {
@@ -235,7 +234,8 @@
     mapAndId.first->print(os);
     os << '\n';
   }
-  for (auto *fn : module->functionList) print(fn);
+  for (auto *fn : module->functionList)
+    print(fn);
 }
 
 void ModulePrinter::print(const Attribute *attr) const {
@@ -308,7 +308,8 @@
   case Type::Kind::Vector: {
     auto *v = cast<VectorType>(type);
     os << "vector<";
-    for (auto dim : v->getShape()) os << dim << 'x';
+    for (auto dim : v->getShape())
+      os << dim << 'x';
     os << *v->getElementType() << '>';
     return;
   }
@@ -549,7 +550,7 @@
   DenseMap<const SSAValue *, unsigned> valueIDs;
   unsigned nextValueID = 0;
 };
-}  // end anonymous namespace
+} // end anonymous namespace
 
 void FunctionState::printOperation(const Operation *op) {
   os << "  ";
@@ -632,7 +633,7 @@
 
   void numberValuesInBlock(const BasicBlock *block);
 };
-}  // end anonymous namespace
+} // end anonymous namespace
 
 CFGFunctionPrinter::CFGFunctionPrinter(const CFGFunction *function,
                                        const ModulePrinter &other)
@@ -665,7 +666,8 @@
   printFunctionSignature(getFunction());
   os << " {\n";
 
-  for (auto &block : *function) print(&block);
+  for (auto &block : *function)
+    print(&block);
   os << "}\n\n";
 }
 
@@ -768,7 +770,7 @@
   const MLFunction *function;
   int numSpaces;
 };
-}  // end anonymous namespace
+} // end anonymous namespace
 
 MLFunctionPrinter::MLFunctionPrinter(const MLFunction *function,
                                      const ModulePrinter &other)
@@ -843,9 +845,7 @@
   ModulePrinter(os, state).print(this);
 }
 
-void Attribute::dump() const {
-  print(llvm::errs());
-}
+void Attribute::dump() const { print(llvm::errs()); }
 
 void Type::print(raw_ostream &os) const {
   ModuleState state(getContext());
diff --git a/lib/IR/MLIRContext.cpp b/lib/IR/MLIRContext.cpp
index 8d2de10..a6086e5 100644
--- a/lib/IR/MLIRContext.cpp
+++ b/lib/IR/MLIRContext.cpp
@@ -33,16 +33,16 @@
 using namespace llvm;
 
 namespace {
-struct FunctionTypeKeyInfo : DenseMapInfo<FunctionType*> {
+struct FunctionTypeKeyInfo : DenseMapInfo<FunctionType *> {
   // 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<FunctionType *>::getHashValue;
+  using DenseMapInfo<FunctionType *>::isEqual;
 
   static unsigned getHashValue(KeyTy key) {
-    return hash_combine(hash_combine_range(key.first.begin(), key.first.end()),
-                        hash_combine_range(key.second.begin(),
-                                           key.second.end()));
+    return hash_combine(
+        hash_combine_range(key.first.begin(), key.first.end()),
+        hash_combine_range(key.second.begin(), key.second.end()));
   }
 
   static bool isEqual(const KeyTy &lhs, const FunctionType *rhs) {
@@ -75,16 +75,16 @@
   }
 };
 
-struct VectorTypeKeyInfo : DenseMapInfo<VectorType*> {
+struct VectorTypeKeyInfo : DenseMapInfo<VectorType *> {
   // Vectors are uniqued based on their element type and shape.
-  using KeyTy = std::pair<Type*, ArrayRef<unsigned>>;
-  using DenseMapInfo<VectorType*>::getHashValue;
-  using DenseMapInfo<VectorType*>::isEqual;
+  using KeyTy = std::pair<Type *, ArrayRef<unsigned>>;
+  using DenseMapInfo<VectorType *>::getHashValue;
+  using DenseMapInfo<VectorType *>::isEqual;
 
   static unsigned getHashValue(KeyTy key) {
-    return hash_combine(DenseMapInfo<Type*>::getHashValue(key.first),
-                        hash_combine_range(key.second.begin(),
-                                           key.second.end()));
+    return hash_combine(
+        DenseMapInfo<Type *>::getHashValue(key.first),
+        hash_combine_range(key.second.begin(), key.second.end()));
   }
 
   static bool isEqual(const KeyTy &lhs, const VectorType *rhs) {
@@ -94,16 +94,16 @@
   }
 };
 
-struct RankedTensorTypeKeyInfo : DenseMapInfo<RankedTensorType*> {
+struct RankedTensorTypeKeyInfo : DenseMapInfo<RankedTensorType *> {
   // 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<RankedTensorType *>::getHashValue;
+  using DenseMapInfo<RankedTensorType *>::isEqual;
 
   static unsigned getHashValue(KeyTy key) {
-    return hash_combine(DenseMapInfo<Type*>::getHashValue(key.first),
-                        hash_combine_range(key.second.begin(),
-                                           key.second.end()));
+    return hash_combine(
+        DenseMapInfo<Type *>::getHashValue(key.first),
+        hash_combine_range(key.second.begin(), key.second.end()));
   }
 
   static bool isEqual(const KeyTy &lhs, const RankedTensorType *rhs) {
@@ -113,17 +113,17 @@
   }
 };
 
-struct MemRefTypeKeyInfo : DenseMapInfo<MemRefType*> {
+struct MemRefTypeKeyInfo : DenseMapInfo<MemRefType *> {
   // 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<MemRefType *>::getHashValue;
+  using DenseMapInfo<MemRefType *>::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));
@@ -137,11 +137,11 @@
   }
 };
 
-struct ArrayAttrKeyInfo : DenseMapInfo<ArrayAttr*> {
+struct ArrayAttrKeyInfo : DenseMapInfo<ArrayAttr *> {
   // Array attributes are uniqued based on their elements.
-  using KeyTy = ArrayRef<Attribute*>;
-  using DenseMapInfo<ArrayAttr*>::getHashValue;
-  using DenseMapInfo<ArrayAttr*>::isEqual;
+  using KeyTy = ArrayRef<Attribute *>;
+  using DenseMapInfo<ArrayAttr *>::getHashValue;
+  using DenseMapInfo<ArrayAttr *>::isEqual;
 
   static unsigned getHashValue(KeyTy key) {
     return hash_combine_range(key.begin(), key.end());
@@ -173,7 +173,6 @@
 
 } // end anonymous namespace.
 
-
 namespace mlir {
 /// This is the implementation of the MLIRContext class, using the pImpl idiom.
 /// This class is completely private to this file, so everything is public.
@@ -186,10 +185,11 @@
   OperationSet operationSet;
 
   /// These are identifiers uniqued into this MLIRContext.
-  llvm::StringMap<char, llvm::BumpPtrAllocator&> identifiers;
+  llvm::StringMap<char, llvm::BumpPtrAllocator &> identifiers;
 
   // Primitive type uniquing.
-  PrimitiveType *primitives[int(Type::Kind::LAST_PRIMITIVE_TYPE)+1] = {nullptr};
+  PrimitiveType *primitives[int(Type::Kind::LAST_PRIMITIVE_TYPE) + 1] = {
+      nullptr};
 
   // Affine map uniquing.
   using AffineMapSet = DenseSet<AffineMap *, AffineMapKeyInfo>;
@@ -201,36 +201,36 @@
       affineExprs;
 
   /// Integer type uniquing.
-  DenseMap<unsigned, IntegerType*> integers;
+  DenseMap<unsigned, IntegerType *> integers;
 
   /// Function type uniquing.
-  using FunctionTypeSet = DenseSet<FunctionType*, FunctionTypeKeyInfo>;
+  using FunctionTypeSet = DenseSet<FunctionType *, FunctionTypeKeyInfo>;
   FunctionTypeSet functions;
 
   /// Vector type uniquing.
-  using VectorTypeSet = DenseSet<VectorType*, VectorTypeKeyInfo>;
+  using VectorTypeSet = DenseSet<VectorType *, VectorTypeKeyInfo>;
   VectorTypeSet vectors;
 
   /// Ranked tensor type uniquing.
-  using RankedTensorTypeSet = DenseSet<RankedTensorType*,
-                                       RankedTensorTypeKeyInfo>;
+  using RankedTensorTypeSet =
+      DenseSet<RankedTensorType *, RankedTensorTypeKeyInfo>;
   RankedTensorTypeSet rankedTensors;
 
   /// Unranked tensor type uniquing.
-  DenseMap<Type*, UnrankedTensorType*> unrankedTensors;
+  DenseMap<Type *, UnrankedTensorType *> unrankedTensors;
 
   /// MemRef type uniquing.
-  using MemRefTypeSet = DenseSet<MemRefType*, MemRefTypeKeyInfo>;
+  using MemRefTypeSet = DenseSet<MemRefType *, MemRefTypeKeyInfo>;
   MemRefTypeSet memrefs;
 
   // Attribute uniquing.
-  BoolAttr *boolAttrs[2] = { nullptr };
-  DenseMap<int64_t, IntegerAttr*> integerAttrs;
-  DenseMap<int64_t, FloatAttr*> floatAttrs;
-  StringMap<StringAttr*> stringAttrs;
-  using ArrayAttrSet = DenseSet<ArrayAttr*, ArrayAttrKeyInfo>;
+  BoolAttr *boolAttrs[2] = {nullptr};
+  DenseMap<int64_t, IntegerAttr *> integerAttrs;
+  DenseMap<int64_t, FloatAttr *> floatAttrs;
+  StringMap<StringAttr *> stringAttrs;
+  using ArrayAttrSet = DenseSet<ArrayAttr *, ArrayAttrKeyInfo>;
   ArrayAttrSet arrayAttrs;
-  DenseMap<AffineMap*, AffineMapAttr*> affineMapAttrs;
+  DenseMap<AffineMap *, AffineMapAttr *> affineMapAttrs;
   using AttributeListSet =
       DenseSet<AttributeListStorage *, AttributeListKeyInfo>;
   AttributeListSet attributeLists;
@@ -242,8 +242,7 @@
 
   /// Copy the specified array of elements into memory managed by our bump
   /// pointer allocator.  This assumes the elements are all PODs.
-  template<typename T>
-  ArrayRef<T> copyInto(ArrayRef<T> elements) {
+  template <typename T> ArrayRef<T> copyInto(ArrayRef<T> elements) {
     auto result = allocator.Allocate<T>(elements.size());
     std::uninitialized_copy(elements.begin(), elements.end(), result);
     return ArrayRef<T>(result, elements.size());
@@ -251,11 +250,9 @@
 };
 } // end namespace mlir
 
-MLIRContext::MLIRContext() : impl(new MLIRContextImpl()) {
-}
+MLIRContext::MLIRContext() : impl(new MLIRContextImpl()) {}
 
-MLIRContext::~MLIRContext() {
-}
+MLIRContext::~MLIRContext() {}
 
 /// Return the operation set associated with the specified MLIRContext object.
 OperationSet &OperationSet::get(MLIRContext *context) {
@@ -301,7 +298,7 @@
   auto *ptr = impl.allocator.Allocate<PrimitiveType>();
 
   // Initialize the memory using placement new.
-  new(ptr) PrimitiveType(kind, context);
+  new (ptr) PrimitiveType(kind, context);
 
   // Cache and return it.
   return impl.primitives[(int)kind] = ptr;
@@ -319,7 +316,8 @@
   return result;
 }
 
-FunctionType *FunctionType::get(ArrayRef<Type*> inputs, ArrayRef<Type*> results,
+FunctionType *FunctionType::get(ArrayRef<Type *> inputs,
+                                ArrayRef<Type *> results,
                                 MLIRContext *context) {
   auto &impl = context->getImpl();
 
@@ -335,15 +333,15 @@
   auto *result = impl.allocator.Allocate<FunctionType>();
 
   // Copy the inputs and results into the bump pointer.
-  SmallVector<Type*, 16> types;
-  types.reserve(inputs.size()+results.size());
+  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)
+      FunctionType(typesList.data(), inputs.size(), results.size(), context);
 
   // Cache and return it.
   return *existing.first = result;
@@ -378,9 +376,8 @@
   return *existing.first = result;
 }
 
-
 TensorType::TensorType(Kind kind, Type *elementType, MLIRContext *context)
-  : Type(kind, context), elementType(elementType) {
+    : Type(kind, context), elementType(elementType) {
   assert((isa<PrimitiveType>(elementType) || isa<VectorType>(elementType) ||
           isa<IntegerType>(elementType)) &&
          "tensor elements must be primitives or vectors");
@@ -433,14 +430,14 @@
 }
 
 MemRefType *MemRefType::get(ArrayRef<int> shape, Type *elementType,
-                            ArrayRef<AffineMap*> affineMapComposition,
+                            ArrayRef<AffineMap *> affineMapComposition,
                             unsigned memorySpace) {
   auto *context = elementType->getContext();
   auto &impl = context->getImpl();
 
   // Look to see if we already have this memref type.
-  auto key = std::make_tuple(elementType, shape, affineMapComposition,
-                             memorySpace);
+  auto key =
+      std::make_tuple(elementType, shape, affineMapComposition, memorySpace);
   auto existing = impl.memrefs.insert_as(nullptr, key);
 
   // If we already have it, return that value.
@@ -455,8 +452,8 @@
 
   // Copy the affine map composition into the bump pointer.
   // TODO(andydavis) Assert that the structure of the composition is valid.
-  affineMapComposition = impl.copyInto(ArrayRef<AffineMap*>(
-      affineMapComposition));
+  affineMapComposition =
+      impl.copyInto(ArrayRef<AffineMap *>(affineMapComposition));
 
   // Initialize the memory using placement new.
   new (result) MemRefType(shape, elementType, affineMapComposition, memorySpace,
@@ -519,7 +516,7 @@
   return result;
 }
 
-ArrayAttr *ArrayAttr::get(ArrayRef<Attribute*> value, MLIRContext *context) {
+ArrayAttr *ArrayAttr::get(ArrayRef<Attribute *> value, MLIRContext *context) {
   auto &impl = context->getImpl();
 
   // Look to see if we already have this.
@@ -542,7 +539,7 @@
   return *existing.first = result;
 }
 
-AffineMapAttr *AffineMapAttr::get(AffineMap* value, MLIRContext *context) {
+AffineMapAttr *AffineMapAttr::get(AffineMap *value, MLIRContext *context) {
   auto *&result = context->getImpl().affineMapAttrs[value];
   if (result)
     return result;