From 9a9c8233886d78c708d32272da9baee48882611e Mon Sep 17 00:00:00 2001
From: Eugene Zelenko <eugene.zelenko@gmail.com>
Date: Mon, 9 Apr 2018 21:54:38 +0000
Subject: [PATCH] [AST] Fix some Clang-tidy modernize and Include What You Use
 warnings; other minor fixes (NFC).

llvm-svn: 329628
---
 clang/include/clang/AST/ASTImporter.h |  46 +-
 clang/lib/AST/ASTImporter.cpp         | 812 +++++++++++++++++-----------------
 2 files changed, 432 insertions(+), 426 deletions(-)

diff --git a/clang/include/clang/AST/ASTImporter.h b/clang/include/clang/AST/ASTImporter.h
index 66b9cd3..42e9e85 100644
--- a/clang/include/clang/AST/ASTImporter.h
+++ b/clang/include/clang/AST/ASTImporter.h
@@ -1,4 +1,4 @@
-//===--- ASTImporter.h - Importing ASTs from other Contexts -----*- C++ -*-===//
+//===- ASTImporter.h - Importing ASTs from other Contexts -------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -11,37 +11,44 @@
 //  context into another context.
 //
 //===----------------------------------------------------------------------===//
+
 #ifndef LLVM_CLANG_AST_ASTIMPORTER_H
 #define LLVM_CLANG_AST_ASTIMPORTER_H
 
 #include "clang/AST/DeclarationName.h"
+#include "clang/AST/NestedNameSpecifier.h"
+#include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/IdentifierTable.h"
+#include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallVector.h"
+#include <utility>
 
 namespace clang {
-  class ASTContext;
-  class CXXCtorInitializer;
-  class CXXBaseSpecifier;
-  class Decl;
-  class DeclContext;
-  class DiagnosticsEngine;
-  class Expr;
-  class FileManager;
-  class IdentifierInfo;
-  class NestedNameSpecifier;
-  class Stmt;
-  class TypeSourceInfo;
-  
+
+class ASTContext;
+class CXXBaseSpecifier;
+class CXXCtorInitializer;
+class Decl;
+class DeclContext;
+class Expr;
+class FileManager;
+class NamedDecl;
+class Stmt;
+class TagDecl;
+class TypeSourceInfo;
+
   /// \brief Imports selected nodes from one AST context into another context,
   /// merging AST nodes where appropriate.
   class ASTImporter {
   public:
-    typedef llvm::DenseSet<std::pair<Decl *, Decl *> > NonEquivalentDeclSet;
-    typedef llvm::DenseMap<const CXXBaseSpecifier *, CXXBaseSpecifier *>
-    ImportedCXXBaseSpecifierMap;
+    using NonEquivalentDeclSet = llvm::DenseSet<std::pair<Decl *, Decl *>>;
+    using ImportedCXXBaseSpecifierMap =
+        llvm::DenseMap<const CXXBaseSpecifier *, CXXBaseSpecifier *>;
 
   private:
     /// \brief The contexts we're importing to and from.
@@ -54,7 +61,7 @@ namespace clang {
     bool Minimal;
 
     /// \brief Whether the last diagnostic came from the "from" context.
-    bool LastDiagFromFrom;
+    bool LastDiagFromFrom = false;
     
     /// \brief Mapping from the already-imported types in the "from" context
     /// to the corresponding types in the "to" context.
@@ -312,6 +319,7 @@ namespace clang {
     bool IsStructurallyEquivalent(QualType From, QualType To,
                                   bool Complain = true);
   };
-}
+
+} // namespace clang
 
 #endif // LLVM_CLANG_AST_ASTIMPORTER_H
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index 98bde8b..9d87157 100644
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -1,4 +1,4 @@
-//===--- ASTImporter.cpp - Importing ASTs from other Contexts ---*- C++ -*-===//
+//===- ASTImporter.cpp - Importing ASTs from other Contexts ---------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -11,27 +11,73 @@
 //  context into another context.
 //
 //===----------------------------------------------------------------------===//
+
 #include "clang/AST/ASTImporter.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/ASTStructuralEquivalence.h"
+#include "clang/AST/Attr.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclAccessPair.h"
+#include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclCXX.h"
+#include "clang/AST/DeclFriend.h"
+#include "clang/AST/DeclGroup.h"
 #include "clang/AST/DeclObjC.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/AST/DeclVisitor.h"
+#include "clang/AST/DeclarationName.h"
+#include "clang/AST/Expr.h"
+#include "clang/AST/ExprCXX.h"
+#include "clang/AST/ExprObjC.h"
+#include "clang/AST/ExternalASTSource.h"
+#include "clang/AST/LambdaCapture.h"
+#include "clang/AST/NestedNameSpecifier.h"
+#include "clang/AST/OperationKinds.h"
+#include "clang/AST/Stmt.h"
+#include "clang/AST/StmtCXX.h"
+#include "clang/AST/StmtObjC.h"
 #include "clang/AST/StmtVisitor.h"
+#include "clang/AST/TemplateBase.h"
+#include "clang/AST/TemplateName.h"
+#include "clang/AST/Type.h"
+#include "clang/AST/TypeLoc.h"
 #include "clang/AST/TypeVisitor.h"
+#include "clang/AST/UnresolvedSet.h"
+#include "clang/Basic/ExceptionSpecificationType.h"
 #include "clang/Basic/FileManager.h"
+#include "clang/Basic/IdentifierTable.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Basic/LangOptions.h"
+#include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
+#include "clang/Basic/Specifiers.h"
+#include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/None.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <memory>
+#include <type_traits>
+#include <utility>
 
 namespace clang {
+
   class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType>,
                           public DeclVisitor<ASTNodeImporter, Decl *>,
                           public StmtVisitor<ASTNodeImporter, Stmt *> {
     ASTImporter &Importer;
 
   public:
-    explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { }
+    explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) {}
     
     using TypeVisitor<ASTNodeImporter, QualType>::Visit;
     using DeclVisitor<ASTNodeImporter, Decl *>::Visit;
@@ -94,11 +140,11 @@ namespace clang {
 
     bool ImportCastPath(CastExpr *E, CXXCastPath &Path);
 
-    typedef DesignatedInitExpr::Designator Designator;
+    using Designator = DesignatedInitExpr::Designator;
+
     Designator ImportDesignator(const Designator &D);
 
     Optional<LambdaCapture> ImportLambdaCapture(const LambdaCapture &From);
-
                         
     /// \brief What we should import from the definition.
     enum ImportDefinitionKind { 
@@ -106,8 +152,10 @@ namespace clang {
       /// nothing (if minimal import is set) or might be everything (if minimal
       /// import is not set).
       IDK_Default,
+
       /// \brief Import everything.
       IDK_Everything,
+
       /// \brief Import only the bare bones needed to establish a valid
       /// DeclContext.
       IDK_Basic
@@ -197,7 +245,6 @@ namespace clang {
     Decl *VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
     Decl *VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
 
-
     ObjCTypeParamList *ImportObjCTypeParamList(ObjCTypeParamList *list);
     Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
     Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
@@ -318,10 +365,10 @@ namespace clang {
     Expr *VisitTypeTraitExpr(TypeTraitExpr *E);
     Expr *VisitCXXTypeidExpr(CXXTypeidExpr *E);
 
-
     template<typename IIter, typename OIter>
     void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin) {
-      typedef typename std::remove_reference<decltype(*Obegin)>::type ItemT;
+      using ItemT = typename std::remove_reference<decltype(*Obegin)>::type;
+
       ASTImporter &ImporterRef = Importer;
       std::transform(Ibegin, Iend, Obegin,
                      [&ImporterRef](ItemT From) -> ItemT {
@@ -331,13 +378,13 @@ namespace clang {
 
     template<typename IIter, typename OIter>
     bool ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
-      typedef typename std::remove_reference<decltype(**Obegin)>::type ItemT;
+      using ItemT = typename std::remove_reference<decltype(**Obegin)>::type;
+
       ASTImporter &ImporterRef = Importer;
       bool Failed = false;
       std::transform(Ibegin, Iend, Obegin,
                      [&ImporterRef, &Failed](ItemT *From) -> ItemT * {
-                       ItemT *To = cast_or_null<ItemT>(
-                             ImporterRef.Import(From));
+                       auto *To = cast_or_null<ItemT>(ImporterRef.Import(From));
                        if (!To && From)
                          Failed = true;
                        return To;
@@ -361,7 +408,6 @@ namespace clang {
     void ImportOverrides(CXXMethodDecl *ToMethod, CXXMethodDecl *FromMethod);
   };
 
-
 template <typename InContainerTy>
 bool ASTNodeImporter::ImportTemplateArgumentListInfo(
     SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
@@ -389,7 +435,7 @@ bool ASTNodeImporter::ImportTemplateArgumentListInfo<
                                         From.arguments(), Result);
 }
 
-} // end namespace clang
+} // namespace clang
 
 //----------------------------------------------------------------------------
 // Import Types
@@ -400,13 +446,13 @@ using namespace clang;
 QualType ASTNodeImporter::VisitType(const Type *T) {
   Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
     << T->getTypeClassName();
-  return QualType();
+  return {};
 }
 
 QualType ASTNodeImporter::VisitAtomicType(const AtomicType *T){
   QualType UnderlyingType = Importer.Import(T->getValueType());
   if(UnderlyingType.isNull())
-    return QualType();
+    return {};
 
   return Importer.getToContext().getAtomicType(UnderlyingType);
 }
@@ -459,7 +505,7 @@ QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
 QualType ASTNodeImporter::VisitDecayedType(const DecayedType *T) {
   QualType OrigT = Importer.Import(T->getOriginalType());
   if (OrigT.isNull())
-    return QualType();
+    return {};
 
   return Importer.getToContext().getDecayedType(OrigT);
 }
@@ -467,7 +513,7 @@ QualType ASTNodeImporter::VisitDecayedType(const DecayedType *T) {
 QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
   QualType ToElementType = Importer.Import(T->getElementType());
   if (ToElementType.isNull())
-    return QualType();
+    return {};
   
   return Importer.getToContext().getComplexType(ToElementType);
 }
@@ -475,7 +521,7 @@ QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
 QualType ASTNodeImporter::VisitPointerType(const PointerType *T) {
   QualType ToPointeeType = Importer.Import(T->getPointeeType());
   if (ToPointeeType.isNull())
-    return QualType();
+    return {};
   
   return Importer.getToContext().getPointerType(ToPointeeType);
 }
@@ -484,7 +530,7 @@ QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
   // FIXME: Check for blocks support in "to" context.
   QualType ToPointeeType = Importer.Import(T->getPointeeType());
   if (ToPointeeType.isNull())
-    return QualType();
+    return {};
   
   return Importer.getToContext().getBlockPointerType(ToPointeeType);
 }
@@ -494,7 +540,7 @@ ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
   // FIXME: Check for C++ support in "to" context.
   QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
   if (ToPointeeType.isNull())
-    return QualType();
+    return {};
   
   return Importer.getToContext().getLValueReferenceType(ToPointeeType);
 }
@@ -504,7 +550,7 @@ ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
   // FIXME: Check for C++0x support in "to" context.
   QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
   if (ToPointeeType.isNull())
-    return QualType();
+    return {};
   
   return Importer.getToContext().getRValueReferenceType(ToPointeeType);  
 }
@@ -513,7 +559,7 @@ QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
   // FIXME: Check for C++ support in "to" context.
   QualType ToPointeeType = Importer.Import(T->getPointeeType());
   if (ToPointeeType.isNull())
-    return QualType();
+    return {};
   
   QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
   return Importer.getToContext().getMemberPointerType(ToPointeeType, 
@@ -523,7 +569,7 @@ QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
 QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
   QualType ToElementType = Importer.Import(T->getElementType());
   if (ToElementType.isNull())
-    return QualType();
+    return {};
   
   return Importer.getToContext().getConstantArrayType(ToElementType, 
                                                       T->getSize(),
@@ -535,7 +581,7 @@ QualType
 ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
   QualType ToElementType = Importer.Import(T->getElementType());
   if (ToElementType.isNull())
-    return QualType();
+    return {};
   
   return Importer.getToContext().getIncompleteArrayType(ToElementType, 
                                                         T->getSizeModifier(),
@@ -545,11 +591,11 @@ ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
 QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
   QualType ToElementType = Importer.Import(T->getElementType());
   if (ToElementType.isNull())
-    return QualType();
+    return {};
 
   Expr *Size = Importer.Import(T->getSizeExpr());
   if (!Size)
-    return QualType();
+    return {};
   
   SourceRange Brackets = Importer.Import(T->getBracketsRange());
   return Importer.getToContext().getVariableArrayType(ToElementType, Size,
@@ -562,13 +608,13 @@ QualType ASTNodeImporter::VisitDependentSizedArrayType(
     const DependentSizedArrayType *T) {
   QualType ToElementType = Importer.Import(T->getElementType());
   if (ToElementType.isNull())
-    return QualType();
+    return {};
 
   // SizeExpr may be null if size is not specified directly.
   // For example, 'int a[]'.
   Expr *Size = Importer.Import(T->getSizeExpr());
   if (!Size && T->getSizeExpr())
-    return QualType();
+    return {};
 
   SourceRange Brackets = Importer.Import(T->getBracketsRange());
   return Importer.getToContext().getDependentSizedArrayType(
@@ -579,7 +625,7 @@ QualType ASTNodeImporter::VisitDependentSizedArrayType(
 QualType ASTNodeImporter::VisitVectorType(const VectorType *T) {
   QualType ToElementType = Importer.Import(T->getElementType());
   if (ToElementType.isNull())
-    return QualType();
+    return {};
   
   return Importer.getToContext().getVectorType(ToElementType, 
                                                T->getNumElements(),
@@ -589,7 +635,7 @@ QualType ASTNodeImporter::VisitVectorType(const VectorType *T) {
 QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
   QualType ToElementType = Importer.Import(T->getElementType());
   if (ToElementType.isNull())
-    return QualType();
+    return {};
   
   return Importer.getToContext().getExtVectorType(ToElementType, 
                                                   T->getNumElements());
@@ -601,7 +647,7 @@ ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
   // into C++? Should we make it variadic?
   QualType ToResultType = Importer.Import(T->getReturnType());
   if (ToResultType.isNull())
-    return QualType();
+    return {};
 
   return Importer.getToContext().getFunctionNoProtoType(ToResultType,
                                                         T->getExtInfo());
@@ -610,14 +656,14 @@ ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
 QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
   QualType ToResultType = Importer.Import(T->getReturnType());
   if (ToResultType.isNull())
-    return QualType();
+    return {};
   
   // Import argument types
   SmallVector<QualType, 4> ArgTypes;
   for (const auto &A : T->param_types()) {
     QualType ArgType = Importer.Import(A);
     if (ArgType.isNull())
-      return QualType();
+      return {};
     ArgTypes.push_back(ArgType);
   }
   
@@ -626,7 +672,7 @@ QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
   for (const auto &E : T->exceptions()) {
     QualType ExceptionType = Importer.Import(E);
     if (ExceptionType.isNull())
-      return QualType();
+      return {};
     ExceptionTypes.push_back(ExceptionType);
   }
 
@@ -652,16 +698,16 @@ QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
 
 QualType ASTNodeImporter::VisitUnresolvedUsingType(
     const UnresolvedUsingType *T) {
-  UnresolvedUsingTypenameDecl *ToD = cast_or_null<UnresolvedUsingTypenameDecl>(
-        Importer.Import(T->getDecl()));
+  const auto *ToD =
+      cast_or_null<UnresolvedUsingTypenameDecl>(Importer.Import(T->getDecl()));
   if (!ToD)
-    return QualType();
+    return {};
 
-  UnresolvedUsingTypenameDecl *ToPrevD =
+  auto *ToPrevD =
       cast_or_null<UnresolvedUsingTypenameDecl>(
         Importer.Import(T->getDecl()->getPreviousDecl()));
   if (!ToPrevD && T->getDecl()->getPreviousDecl())
-    return QualType();
+    return {};
 
   return Importer.getToContext().getTypeDeclType(ToD, ToPrevD);
 }
@@ -669,16 +715,16 @@ QualType ASTNodeImporter::VisitUnresolvedUsingType(
 QualType ASTNodeImporter::VisitParenType(const ParenType *T) {
   QualType ToInnerType = Importer.Import(T->getInnerType());
   if (ToInnerType.isNull())
-    return QualType();
+    return {};
     
   return Importer.getToContext().getParenType(ToInnerType);
 }
 
 QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
-  TypedefNameDecl *ToDecl
-             = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
+  auto *ToDecl =
+      dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
   if (!ToDecl)
-    return QualType();
+    return {};
   
   return Importer.getToContext().getTypeDeclType(ToDecl);
 }
@@ -686,7 +732,7 @@ QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
 QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
   Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
   if (!ToExpr)
-    return QualType();
+    return {};
   
   return Importer.getToContext().getTypeOfExprType(ToExpr);
 }
@@ -694,7 +740,7 @@ QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
 QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
   QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
   if (ToUnderlyingType.isNull())
-    return QualType();
+    return {};
   
   return Importer.getToContext().getTypeOfType(ToUnderlyingType);
 }
@@ -703,11 +749,11 @@ QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
   // FIXME: Make sure that the "to" context supports C++0x!
   Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
   if (!ToExpr)
-    return QualType();
+    return {};
   
   QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
   if (UnderlyingType.isNull())
-    return QualType();
+    return {};
 
   return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
 }
@@ -716,7 +762,7 @@ QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
   QualType ToBaseType = Importer.Import(T->getBaseType());
   QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
   if (ToBaseType.isNull() || ToUnderlyingType.isNull())
-    return QualType();
+    return {};
 
   return Importer.getToContext().getUnaryTransformType(ToBaseType,
                                                        ToUnderlyingType,
@@ -730,7 +776,7 @@ QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
   if (!FromDeduced.isNull()) {
     ToDeduced = Importer.Import(FromDeduced);
     if (ToDeduced.isNull())
-      return QualType();
+      return {};
   }
   
   return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(),
@@ -739,13 +785,13 @@ QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
 
 QualType ASTNodeImporter::VisitInjectedClassNameType(
     const InjectedClassNameType *T) {
-  CXXRecordDecl *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl()));
+  auto *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl()));
   if (!D)
-    return QualType();
+    return {};
 
   QualType InjType = Importer.Import(T->getInjectedSpecializationType());
   if (InjType.isNull())
-    return QualType();
+    return {};
 
   // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
   // See comments in InjectedClassNameType definition for details
@@ -760,19 +806,17 @@ QualType ASTNodeImporter::VisitInjectedClassNameType(
 }
 
 QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
-  RecordDecl *ToDecl
-    = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
+  auto *ToDecl = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
   if (!ToDecl)
-    return QualType();
+    return {};
 
   return Importer.getToContext().getTagDeclType(ToDecl);
 }
 
 QualType ASTNodeImporter::VisitEnumType(const EnumType *T) {
-  EnumDecl *ToDecl
-    = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
+  auto *ToDecl = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
   if (!ToDecl)
-    return QualType();
+    return {};
 
   return Importer.getToContext().getTagDeclType(ToDecl);
 }
@@ -786,25 +830,24 @@ QualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
   if (!FromModifiedType.isNull()) {
     ToModifiedType = Importer.Import(FromModifiedType);
     if (ToModifiedType.isNull())
-      return QualType();
+      return {};
   }
   if (!FromEquivalentType.isNull()) {
     ToEquivalentType = Importer.Import(FromEquivalentType);
     if (ToEquivalentType.isNull())
-      return QualType();
+      return {};
   }
 
   return Importer.getToContext().getAttributedType(T->getAttrKind(),
     ToModifiedType, ToEquivalentType);
 }
 
-
 QualType ASTNodeImporter::VisitTemplateTypeParmType(
     const TemplateTypeParmType *T) {
-  TemplateTypeParmDecl *ParmDecl =
+  auto *ParmDecl =
       cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl()));
   if (!ParmDecl && T->getDecl())
-    return QualType();
+    return {};
 
   return Importer.getToContext().getTemplateTypeParmType(
         T->getDepth(), T->getIndex(), T->isParameterPack(), ParmDecl);
@@ -812,15 +855,15 @@ QualType ASTNodeImporter::VisitTemplateTypeParmType(
 
 QualType ASTNodeImporter::VisitSubstTemplateTypeParmType(
     const SubstTemplateTypeParmType *T) {
-  const TemplateTypeParmType *Replaced =
+  const auto *Replaced =
       cast_or_null<TemplateTypeParmType>(Importer.Import(
         QualType(T->getReplacedParameter(), 0)).getTypePtr());
   if (!Replaced)
-    return QualType();
+    return {};
 
   QualType Replacement = Importer.Import(T->getReplacementType());
   if (Replacement.isNull())
-    return QualType();
+    return {};
   Replacement = Replacement.getCanonicalType();
 
   return Importer.getToContext().getSubstTemplateTypeParmType(
@@ -831,11 +874,11 @@ QualType ASTNodeImporter::VisitTemplateSpecializationType(
                                        const TemplateSpecializationType *T) {
   TemplateName ToTemplate = Importer.Import(T->getTemplateName());
   if (ToTemplate.isNull())
-    return QualType();
+    return {};
   
   SmallVector<TemplateArgument, 2> ToTemplateArgs;
   if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))
-    return QualType();
+    return {};
   
   QualType ToCanonType;
   if (!QualType(T, 0).isCanonical()) {
@@ -843,7 +886,7 @@ QualType ASTNodeImporter::VisitTemplateSpecializationType(
       = Importer.getFromContext().getCanonicalType(QualType(T, 0));
     ToCanonType =Importer.Import(FromCanonType);
     if (ToCanonType.isNull())
-      return QualType();
+      return {};
   }
   return Importer.getToContext().getTemplateSpecializationType(ToTemplate, 
                                                                ToTemplateArgs,
@@ -856,12 +899,12 @@ QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
   if (T->getQualifier()) {
     ToQualifier = Importer.Import(T->getQualifier());
     if (!ToQualifier)
-      return QualType();
+      return {};
   }
 
   QualType ToNamedType = Importer.Import(T->getNamedType());
   if (ToNamedType.isNull())
-    return QualType();
+    return {};
 
   return Importer.getToContext().getElaboratedType(T->getKeyword(),
                                                    ToQualifier, ToNamedType);
@@ -870,7 +913,7 @@ QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
 QualType ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) {
   QualType Pattern = Importer.Import(T->getPattern());
   if (Pattern.isNull())
-    return QualType();
+    return {};
 
   return Importer.getToContext().getPackExpansionType(Pattern,
                                                       T->getNumExpansions());
@@ -880,26 +923,26 @@ QualType ASTNodeImporter::VisitDependentTemplateSpecializationType(
     const DependentTemplateSpecializationType *T) {
   NestedNameSpecifier *Qualifier = Importer.Import(T->getQualifier());
   if (!Qualifier && T->getQualifier())
-    return QualType();
+    return {};
 
   IdentifierInfo *Name = Importer.Import(T->getIdentifier());
   if (!Name && T->getIdentifier())
-    return QualType();
+    return {};
 
   SmallVector<TemplateArgument, 2> ToPack;
   ToPack.reserve(T->getNumArgs());
   if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToPack))
-    return QualType();
+    return {};
 
   return Importer.getToContext().getDependentTemplateSpecializationType(
         T->getKeyword(), Qualifier, Name, ToPack);
 }
 
 QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
-  ObjCInterfaceDecl *Class
-    = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
+  auto *Class =
+      dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
   if (!Class)
-    return QualType();
+    return {};
 
   return Importer.getToContext().getObjCInterfaceType(Class);
 }
@@ -907,23 +950,22 @@ QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
 QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
   QualType ToBaseType = Importer.Import(T->getBaseType());
   if (ToBaseType.isNull())
-    return QualType();
+    return {};
 
   SmallVector<QualType, 4> TypeArgs;
   for (auto TypeArg : T->getTypeArgsAsWritten()) {
     QualType ImportedTypeArg = Importer.Import(TypeArg);
     if (ImportedTypeArg.isNull())
-      return QualType();
+      return {};
 
     TypeArgs.push_back(ImportedTypeArg);
   }
 
   SmallVector<ObjCProtocolDecl *, 4> Protocols;
   for (auto *P : T->quals()) {
-    ObjCProtocolDecl *Protocol
-      = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
+    auto *Protocol = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
     if (!Protocol)
-      return QualType();
+      return {};
     Protocols.push_back(Protocol);
   }
 
@@ -936,7 +978,7 @@ QualType
 ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
   QualType ToPointeeType = Importer.Import(T->getPointeeType());
   if (ToPointeeType.isNull())
-    return QualType();
+    return {};
 
   return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
 }
@@ -982,8 +1024,8 @@ void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
       return;
   }
   
-  if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
-    if (RecordDecl *ToRecord = cast_or_null<RecordDecl>(ToD)) {
+  if (auto *FromRecord = dyn_cast<RecordDecl>(FromD)) {
+    if (auto *ToRecord = cast_or_null<RecordDecl>(ToD)) {
       if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) {
         ImportDefinition(FromRecord, ToRecord);
       }
@@ -991,8 +1033,8 @@ void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
     return;
   }
 
-  if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
-    if (EnumDecl *ToEnum = cast_or_null<EnumDecl>(ToD)) {
+  if (auto *FromEnum = dyn_cast<EnumDecl>(FromD)) {
+    if (auto *ToEnum = cast_or_null<EnumDecl>(ToD)) {
       if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
         ImportDefinition(FromEnum, ToEnum);
       }
@@ -1058,8 +1100,8 @@ bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To,
   To->startDefinition();
   
   // Add base classes.
-  if (CXXRecordDecl *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
-    CXXRecordDecl *FromCXX = cast<CXXRecordDecl>(From);
+  if (auto *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
+    auto *FromCXX = cast<CXXRecordDecl>(From);
 
     struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
     struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
@@ -1238,36 +1280,36 @@ ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
   case TemplateArgument::Type: {
     QualType ToType = Importer.Import(From.getAsType());
     if (ToType.isNull())
-      return TemplateArgument();
+      return {};
     return TemplateArgument(ToType);
   }
       
   case TemplateArgument::Integral: {
     QualType ToType = Importer.Import(From.getIntegralType());
     if (ToType.isNull())
-      return TemplateArgument();
+      return {};
     return TemplateArgument(From, ToType);
   }
 
   case TemplateArgument::Declaration: {
-    ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
+    auto *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
     QualType ToType = Importer.Import(From.getParamTypeForDecl());
     if (!To || ToType.isNull())
-      return TemplateArgument();
+      return {};
     return TemplateArgument(To, ToType);
   }
 
   case TemplateArgument::NullPtr: {
     QualType ToType = Importer.Import(From.getNullPtrType());
     if (ToType.isNull())
-      return TemplateArgument();
+      return {};
     return TemplateArgument(ToType, /*isNullPtr*/true);
   }
 
   case TemplateArgument::Template: {
     TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
     if (ToTemplate.isNull())
-      return TemplateArgument();
+      return {};
     
     return TemplateArgument(ToTemplate);
   }
@@ -1276,7 +1318,7 @@ ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
     TemplateName ToTemplate 
       = Importer.Import(From.getAsTemplateOrTemplatePattern());
     if (ToTemplate.isNull())
-      return TemplateArgument();
+      return {};
     
     return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
   }
@@ -1290,7 +1332,7 @@ ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
     SmallVector<TemplateArgument, 2> ToPack;
     ToPack.reserve(From.pack_size());
     if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
-      return TemplateArgument();
+      return {};
 
     return TemplateArgument(
         llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
@@ -1359,7 +1401,7 @@ bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
   // something we're trying to import while completing ToRecord.
   Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
   if (ToOrigin) {
-    RecordDecl *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
+    auto *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
     if (ToOriginRecord)
       ToRecord = ToOriginRecord;
   }
@@ -1395,8 +1437,7 @@ bool ASTNodeImporter::IsStructuralMatch(FunctionTemplateDecl *From,
 }
 
 bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
-                                        EnumConstantDecl *ToEC)
-{
+                                        EnumConstantDecl *ToEC) {
   const llvm::APSInt &FromVal = FromEC->getInitVal();
   const llvm::APSInt &ToVal = ToEC->getInitVal();
 
@@ -1460,7 +1501,6 @@ Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
 }
 
 Decl *ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
-
   SourceLocation Loc = Importer.Import(D->getLocation());
   SourceLocation ColonLoc = Importer.Import(D->getColonLoc());
 
@@ -1499,7 +1539,7 @@ Decl *ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
     return nullptr;
 
   StringLiteral *FromMsg = D->getMessage();
-  StringLiteral *ToMsg = cast_or_null<StringLiteral>(Importer.Import(FromMsg));
+  auto *ToMsg = cast_or_null<StringLiteral>(Importer.Import(FromMsg));
   if (!ToMsg && FromMsg)
     return nullptr;
 
@@ -1529,7 +1569,7 @@ Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
     // This is an anonymous namespace. Adopt an existing anonymous
     // namespace if we can.
     // FIXME: Not testable.
-    if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
+    if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
       MergeWithNamespace = TU->getAnonymousNamespace();
     else
       MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
@@ -1537,17 +1577,17 @@ Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
     SmallVector<NamedDecl *, 4> ConflictingDecls;
     SmallVector<NamedDecl *, 2> FoundDecls;
     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
-    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-      if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Namespace))
+    for (auto *FoundDecl : FoundDecls) {
+      if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Namespace))
         continue;
       
-      if (NamespaceDecl *FoundNS = dyn_cast<NamespaceDecl>(FoundDecls[I])) {
+      if (auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {
         MergeWithNamespace = FoundNS;
         ConflictingDecls.clear();
         break;
       }
       
-      ConflictingDecls.push_back(FoundDecls[I]);
+      ConflictingDecls.push_back(FoundDecl);
     }
     
     if (!ConflictingDecls.empty()) {
@@ -1571,7 +1611,7 @@ Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
     // If this is an anonymous namespace, register it as the anonymous
     // namespace within its context.
     if (!Name) {
-      if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
+      if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
         TU->setAnonymousNamespace(ToNamespace);
       else
         cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
@@ -1597,8 +1637,8 @@ Decl *ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
 
   // NOTE: No conflict resolution is done for namespace aliases now.
 
-  NamespaceDecl *TargetDecl = cast_or_null<NamespaceDecl>(
-        Importer.Import(D->getNamespace()));
+  auto *TargetDecl = cast_or_null<NamespaceDecl>(
+      Importer.Import(D->getNamespace()));
   if (!TargetDecl)
     return nullptr;
 
@@ -1641,17 +1681,16 @@ Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
     unsigned IDNS = Decl::IDNS_Ordinary;
     SmallVector<NamedDecl *, 2> FoundDecls;
     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
-    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-      if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
+    for (auto *FoundDecl : FoundDecls) {
+      if (!FoundDecl->isInIdentifierNamespace(IDNS))
         continue;
-      if (TypedefNameDecl *FoundTypedef =
-            dyn_cast<TypedefNameDecl>(FoundDecls[I])) {
+      if (auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
         if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
                                             FoundTypedef->getUnderlyingType()))
           return Importer.Imported(D, FoundTypedef);
       }
 
-      ConflictingDecls.push_back(FoundDecls[I]);
+      ConflictingDecls.push_back(FoundDecl);
     }
 
     if (!ConflictingDecls.empty()) {
@@ -1720,13 +1759,12 @@ Decl *ASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
     unsigned IDNS = Decl::IDNS_Ordinary;
     SmallVector<NamedDecl *, 2> FoundDecls;
     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
-    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-      if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
+    for (auto *FoundDecl : FoundDecls) {
+      if (!FoundDecl->isInIdentifierNamespace(IDNS))
         continue;
-      if (auto *FoundAlias =
-            dyn_cast<TypeAliasTemplateDecl>(FoundDecls[I]))
+      if (auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl))
           return Importer.Imported(D, FoundAlias);
-      ConflictingDecls.push_back(FoundDecls[I]);
+      ConflictingDecls.push_back(FoundDecl);
     }
 
     if (!ConflictingDecls.empty()) {
@@ -1783,7 +1821,7 @@ Decl *ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
                           Name.getAsIdentifierInfo());
   Importer.Imported(D, ToLabel);
 
-  LabelStmt *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt()));
+  auto *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt()));
   if (!Label)
     return nullptr;
 
@@ -1818,22 +1856,22 @@ Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
     SmallVector<NamedDecl *, 4> ConflictingDecls;
     SmallVector<NamedDecl *, 2> FoundDecls;
     DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls);
-    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-      if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
+    for (auto *FoundDecl : FoundDecls) {
+      if (!FoundDecl->isInIdentifierNamespace(IDNS))
         continue;
       
-      Decl *Found = FoundDecls[I];
-      if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
-        if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
+      Decl *Found = FoundDecl;
+      if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
+        if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
           Found = Tag->getDecl();
       }
       
-      if (EnumDecl *FoundEnum = dyn_cast<EnumDecl>(Found)) {
+      if (auto *FoundEnum = dyn_cast<EnumDecl>(Found)) {
         if (IsStructuralMatch(D, FoundEnum))
           return Importer.Imported(D, FoundEnum);
       }
       
-      ConflictingDecls.push_back(FoundDecls[I]);
+      ConflictingDecls.push_back(FoundDecl);
     }
     
     if (!ConflictingDecls.empty()) {
@@ -1915,17 +1953,17 @@ Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
         D->getASTContext().getExternalSource()->CompleteType(D);
     }
 
-    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-      if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
+    for (auto *FoundDecl : FoundDecls) {
+      if (!FoundDecl->isInIdentifierNamespace(IDNS))
         continue;
       
-      Decl *Found = FoundDecls[I];
-      if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
-        if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
+      Decl *Found = FoundDecl;
+      if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
+        if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
           Found = Tag->getDecl();
       }
       
-      if (RecordDecl *FoundRecord = dyn_cast<RecordDecl>(Found)) {
+      if (auto *FoundRecord = dyn_cast<RecordDecl>(Found)) {
         if (!SearchName) {
           // If both unnamed structs/unions are in a record context, make sure
           // they occur in the same location in the context records.
@@ -1979,7 +2017,7 @@ Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
         }
       }
       
-      ConflictingDecls.push_back(FoundDecls[I]);
+      ConflictingDecls.push_back(FoundDecl);
     }
     
     if (!ConflictingDecls.empty() && SearchName) {
@@ -1994,7 +2032,7 @@ Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
   SourceLocation StartLoc = Importer.Import(D->getLocStart());
   if (!D2) {
     CXXRecordDecl *D2CXX = nullptr;
-    if (CXXRecordDecl *DCXX = llvm::dyn_cast<CXXRecordDecl>(D)) {
+    if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
       if (DCXX->isLambda()) {
         TypeSourceInfo *TInfo = Importer.Import(DCXX->getLambdaTypeInfo());
         D2CXX = CXXRecordDecl::CreateLambda(Importer.getToContext(),
@@ -2015,7 +2053,7 @@ Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
             Importer.getToContext(), D->getTagKind(), DC, StartLoc, Loc,
             Name.getAsIdentifierInfo(), PrevDecl, DelayTypeCreation);
         Importer.getToContext().getTypeDeclType(
-            D2CXX, llvm::dyn_cast<CXXRecordDecl>(DC));
+            D2CXX, dyn_cast<CXXRecordDecl>(DC));
       } else {
         D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
                                       D->getTagKind(),
@@ -2032,18 +2070,17 @@ Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
 
       if (ClassTemplateDecl *FromDescribed =
           DCXX->getDescribedClassTemplate()) {
-        ClassTemplateDecl *ToDescribed = cast_or_null<ClassTemplateDecl>(
-              Importer.Import(FromDescribed));
+        auto *ToDescribed = cast_or_null<ClassTemplateDecl>(
+            Importer.Import(FromDescribed));
         if (!ToDescribed)
           return nullptr;
         D2CXX->setDescribedClassTemplate(ToDescribed);
-
       } else if (MemberSpecializationInfo *MemberInfo =
                    DCXX->getMemberSpecializationInfo()) {
         TemplateSpecializationKind SK =
             MemberInfo->getTemplateSpecializationKind();
         CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass();
-        CXXRecordDecl *ToInst =
+        auto *ToInst =
             cast_or_null<CXXRecordDecl>(Importer.Import(FromInst));
         if (FromInst && !ToInst)
           return nullptr;
@@ -2051,7 +2088,6 @@ Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
         D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation(
               Importer.Import(MemberInfo->getPointOfInstantiation()));
       }
-
     } else {
       D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
                               DC, StartLoc, Loc, Name.getAsIdentifierInfo());
@@ -2098,17 +2134,16 @@ Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
     unsigned IDNS = Decl::IDNS_Ordinary;
     SmallVector<NamedDecl *, 2> FoundDecls;
     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
-    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-      if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
+    for (auto *FoundDecl : FoundDecls) {
+      if (!FoundDecl->isInIdentifierNamespace(IDNS))
         continue;
 
-      if (EnumConstantDecl *FoundEnumConstant
-            = dyn_cast<EnumConstantDecl>(FoundDecls[I])) {
+      if (auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {
         if (IsStructuralMatch(D, FoundEnumConstant))
           return Importer.Imported(D, FoundEnumConstant);
       }
 
-      ConflictingDecls.push_back(FoundDecls[I]);
+      ConflictingDecls.push_back(FoundDecl);
     }
     
     if (!ConflictingDecls.empty()) {
@@ -2237,11 +2272,11 @@ Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
     unsigned IDNS = Decl::IDNS_Ordinary;
     SmallVector<NamedDecl *, 2> FoundDecls;
     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
-    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-      if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
+    for (auto *FoundDecl : FoundDecls) {
+      if (!FoundDecl->isInIdentifierNamespace(IDNS))
         continue;
 
-      if (FunctionDecl *FoundFunction = dyn_cast<FunctionDecl>(FoundDecls[I])) {
+      if (auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
         if (FoundFunction->hasExternalFormalLinkage() &&
             D->hasExternalFormalLinkage()) {
           if (Importer.IsStructurallyEquivalent(D->getType(), 
@@ -2273,7 +2308,7 @@ Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
         }
       }
 
-      ConflictingDecls.push_back(FoundDecls[I]);
+      ConflictingDecls.push_back(FoundDecl);
     }
 
     if (!ConflictingDecls.empty()) {
@@ -2292,8 +2327,7 @@ Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
   QualType FromTy = D->getType();
   bool usedDifferentExceptionSpec = false;
 
-  if (const FunctionProtoType *
-        FromFPT = D->getType()->getAs<FunctionProtoType>()) {
+  if (const auto *FromFPT = D->getType()->getAs<FunctionProtoType>()) {
     FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
     // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
     // FunctionDecl that we are importing the FunctionProtoType for.
@@ -2317,7 +2351,7 @@ Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
   // Import the function parameters.
   SmallVector<ParmVarDecl *, 8> Parameters;
   for (auto P : D->parameters()) {
-    ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
+    auto *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
     if (!ToP)
       return nullptr;
 
@@ -2331,7 +2365,7 @@ Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
   // Create the imported function.
   FunctionDecl *ToFunction = nullptr;
   SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart());
-  if (CXXConstructorDecl *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
+  if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
     ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
                                             cast<CXXRecordDecl>(DC),
                                             InnerLocStart,
@@ -2342,17 +2376,16 @@ Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
                                             D->isConstexpr());
     if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
       SmallVector<CXXCtorInitializer *, 4> CtorInitializers;
-      for (CXXCtorInitializer *I : FromConstructor->inits()) {
-        CXXCtorInitializer *ToI =
-            cast_or_null<CXXCtorInitializer>(Importer.Import(I));
+      for (auto *I : FromConstructor->inits()) {
+        auto *ToI = cast_or_null<CXXCtorInitializer>(Importer.Import(I));
         if (!ToI && I)
           return nullptr;
         CtorInitializers.push_back(ToI);
       }
-      CXXCtorInitializer **Memory =
+      auto **Memory =
           new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
       std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
-      CXXConstructorDecl *ToCtor = llvm::cast<CXXConstructorDecl>(ToFunction);
+      auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
       ToCtor->setCtorInitializers(Memory);
       ToCtor->setNumCtorInitializers(NumInitializers);
     }
@@ -2363,8 +2396,7 @@ Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
                                            NameInfo, T, TInfo,
                                            D->isInlineSpecified(),
                                            D->isImplicit());
-  } else if (CXXConversionDecl *FromConversion
-                                           = dyn_cast<CXXConversionDecl>(D)) {
+  } else if (auto *FromConversion = dyn_cast<CXXConversionDecl>(D)) {
     ToFunction = CXXConversionDecl::Create(Importer.getToContext(), 
                                            cast<CXXRecordDecl>(DC),
                                            InnerLocStart,
@@ -2373,7 +2405,7 @@ Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
                                            FromConversion->isExplicit(),
                                            D->isConstexpr(),
                                            Importer.Import(D->getLocEnd()));
-  } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
+  } else if (auto *Method = dyn_cast<CXXMethodDecl>(D)) {
     ToFunction = CXXMethodDecl::Create(Importer.getToContext(), 
                                        cast<CXXRecordDecl>(DC),
                                        InnerLocStart,
@@ -2401,7 +2433,7 @@ Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
   Importer.Imported(D, ToFunction);
 
   // Set the parameters.
-  for (ParmVarDecl *Param : Parameters) {
+  for (auto *Param : Parameters) {
     Param->setOwningFunction(ToFunction);
     ToFunction->addDeclInternal(Param);
   }
@@ -2475,7 +2507,7 @@ Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
 }
 
 static unsigned getFieldIndex(Decl *F) {
-  RecordDecl *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
+  auto *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
   if (!Owner)
     return 0;
 
@@ -2505,8 +2537,8 @@ Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
   // Determine whether we've already imported this field. 
   SmallVector<NamedDecl *, 2> FoundDecls;
   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
-  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-    if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecls[I])) {
+  for (auto *FoundDecl : FoundDecls) {
+    if (auto *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
       // For anonymous fields, match up by index.
       if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
         continue;
@@ -2570,8 +2602,7 @@ Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
   SmallVector<NamedDecl *, 2> FoundDecls;
   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-    if (IndirectFieldDecl *FoundField 
-                                = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
+    if (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
       // For anonymous indirect fields, match up by index.
       if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
         continue;
@@ -2600,8 +2631,8 @@ Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
   if (T.isNull())
     return nullptr;
 
-  NamedDecl **NamedChain =
-    new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
+  auto **NamedChain =
+    new (Importer.getToContext()) NamedDecl*[D->getChainingSize()];
 
   unsigned i = 0;
   for (auto *PI : D->chain()) {
@@ -2666,8 +2697,7 @@ Decl *ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
     return nullptr;
 
   SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists);
-  TemplateParameterList **FromTPLists =
-      D->getTrailingObjects<TemplateParameterList *>();
+  auto **FromTPLists = D->getTrailingObjects<TemplateParameterList *>();
   for (unsigned I = 0; I < D->NumTPLists; I++) {
     TemplateParameterList *List = ImportTemplateParameterList(FromTPLists[I]);
     if (!List)
@@ -2703,8 +2733,8 @@ Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
   // Determine whether we've already imported this ivar
   SmallVector<NamedDecl *, 2> FoundDecls;
   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
-  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-    if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecls[I])) {
+  for (auto *FoundDecl : FoundDecls) {
+    if (auto *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
       if (Importer.IsStructurallyEquivalent(D->getType(),
                                             FoundIvar->getType())) {
         Importer.Imported(D, FoundIvar);
@@ -2739,7 +2769,6 @@ Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
   Importer.Imported(D, ToIvar);
   LexicalDC->addDeclInternal(ToIvar);
   return ToIvar;
-  
 }
 
 Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
@@ -2761,11 +2790,11 @@ Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
     unsigned IDNS = Decl::IDNS_Ordinary;
     SmallVector<NamedDecl *, 2> FoundDecls;
     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
-    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-      if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
+    for (auto *FoundDecl : FoundDecls) {
+      if (!FoundDecl->isInIdentifierNamespace(IDNS))
         continue;
 
-      if (VarDecl *FoundVar = dyn_cast<VarDecl>(FoundDecls[I])) {
+      if (auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
         // We have found a variable that we may need to merge with. Check it.
         if (FoundVar->hasExternalFormalLinkage() &&
             D->hasExternalFormalLinkage()) {
@@ -2804,7 +2833,7 @@ Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
         }
       }
       
-      ConflictingDecls.push_back(FoundDecls[I]);
+      ConflictingDecls.push_back(FoundDecl);
     }
 
     if (MergeWithVar) {
@@ -2974,8 +3003,8 @@ Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
 
   SmallVector<NamedDecl *, 2> FoundDecls;
   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
-  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-    if (ObjCMethodDecl *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecls[I])) {
+  for (auto *FoundDecl : FoundDecls) {
+    if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
       if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
         continue;
 
@@ -3053,7 +3082,7 @@ Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
   // Import the parameters
   SmallVector<ParmVarDecl *, 5> ToParams;
   for (auto *FromP : D->parameters()) {
-    ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
+    auto *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
     if (!ToP)
       return nullptr;
 
@@ -3061,14 +3090,14 @@ Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
   }
   
   // Set the parameters.
-  for (unsigned I = 0, N = ToParams.size(); I != N; ++I) {
-    ToParams[I]->setOwningFunction(ToMethod);
-    ToMethod->addDeclInternal(ToParams[I]);
+  for (auto *ToParam : ToParams) {
+    ToParam->setOwningFunction(ToMethod);
+    ToMethod->addDeclInternal(ToParam);
   }
 
   SmallVector<SourceLocation, 12> SelLocs;
   D->getSelectorLocs(SelLocs);
-  for (SourceLocation &Loc : SelLocs)
+  for (auto &Loc : SelLocs)
     Loc = Importer.Import(Loc);
 
   ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
@@ -3119,8 +3148,8 @@ Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
   if (ToD)
     return ToD;
 
-  ObjCInterfaceDecl *ToInterface
-    = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
+  auto *ToInterface =
+      cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
   if (!ToInterface)
     return nullptr;
 
@@ -3155,8 +3184,8 @@ Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
                                           FromProtoEnd = D->protocol_end();
          FromProto != FromProtoEnd;
          ++FromProto, ++FromProtoLoc) {
-      ObjCProtocolDecl *ToProto
-        = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
+      auto *ToProto =
+          cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
       if (!ToProto)
         return nullptr;
       Protocols.push_back(ToProto);
@@ -3166,7 +3195,6 @@ Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
     // FIXME: If we're merging, make sure that the protocol list is the same.
     ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
                                 ProtocolLocs.data(), Importer.getToContext());
-    
   } else {
     Importer.Imported(D, ToCategory);
   }
@@ -3176,8 +3204,8 @@ Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
  
   // If we have an implementation, import it as well.
   if (D->getImplementation()) {
-    ObjCCategoryImplDecl *Impl
-      = cast_or_null<ObjCCategoryImplDecl>(
+    auto *Impl =
+        cast_or_null<ObjCCategoryImplDecl>(
                                        Importer.Import(D->getImplementation()));
     if (!Impl)
       return nullptr;
@@ -3209,8 +3237,7 @@ bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From,
                                         FromProtoEnd = From->protocol_end();
        FromProto != FromProtoEnd;
        ++FromProto, ++FromProtoLoc) {
-    ObjCProtocolDecl *ToProto
-      = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
+    auto *ToProto = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
     if (!ToProto)
       return true;
     Protocols.push_back(ToProto);
@@ -3254,11 +3281,11 @@ Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
   ObjCProtocolDecl *MergeWithProtocol = nullptr;
   SmallVector<NamedDecl *, 2> FoundDecls;
   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
-  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-    if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
+  for (auto *FoundDecl : FoundDecls) {
+    if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
       continue;
     
-    if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecls[I])))
+    if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))
       break;
   }
   
@@ -3334,16 +3361,16 @@ Decl *ASTNodeImporter::VisitUsingDecl(UsingDecl *D) {
 
   if (NamedDecl *FromPattern =
       Importer.getFromContext().getInstantiatedFromUsingDecl(D)) {
-    if (NamedDecl *ToPattern =
-        dyn_cast_or_null<NamedDecl>(Importer.Import(FromPattern)))
+    if (auto *ToPattern =
+            dyn_cast_or_null<NamedDecl>(Importer.Import(FromPattern)))
       Importer.getToContext().setInstantiatedFromUsingDecl(ToUsing, ToPattern);
     else
       return nullptr;
   }
 
-  for (UsingShadowDecl *FromShadow : D->shadows()) {
-    if (UsingShadowDecl *ToShadow =
-        dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromShadow)))
+  for (auto *FromShadow : D->shadows()) {
+    if (auto *ToShadow =
+            dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromShadow)))
       ToUsing->addShadowDecl(ToShadow);
     else
       // FIXME: We return a nullptr here but the definition is already created
@@ -3363,13 +3390,13 @@ Decl *ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
   if (ToD)
     return ToD;
 
-  UsingDecl *ToUsing = dyn_cast_or_null<UsingDecl>(
-        Importer.Import(D->getUsingDecl()));
+  auto *ToUsing = dyn_cast_or_null<UsingDecl>(
+      Importer.Import(D->getUsingDecl()));
   if (!ToUsing)
     return nullptr;
 
-  NamedDecl *ToTarget = dyn_cast_or_null<NamedDecl>(
-        Importer.Import(D->getTargetDecl()));
+  auto *ToTarget = dyn_cast_or_null<NamedDecl>(
+      Importer.Import(D->getTargetDecl()));
   if (!ToTarget)
     return nullptr;
 
@@ -3382,8 +3409,8 @@ Decl *ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
 
   if (UsingShadowDecl *FromPattern =
       Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) {
-    if (UsingShadowDecl *ToPattern =
-        dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromPattern)))
+    if (auto *ToPattern =
+            dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromPattern)))
       Importer.getToContext().setInstantiatedFromUsingShadowDecl(ToShadow,
                                                                  ToPattern);
     else
@@ -3397,7 +3424,6 @@ Decl *ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
   return ToShadow;
 }
 
-
 Decl *ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
@@ -3412,8 +3438,8 @@ Decl *ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
   if (!ToComAncestor)
     return nullptr;
 
-  NamespaceDecl *ToNominated = cast_or_null<NamespaceDecl>(
-        Importer.Import(D->getNominatedNamespace()));
+  auto *ToNominated = cast_or_null<NamespaceDecl>(
+      Importer.Import(D->getNominatedNamespace()));
   if (!ToNominated)
     return nullptr;
 
@@ -3481,7 +3507,6 @@ Decl *ASTNodeImporter::VisitUnresolvedUsingTypenameDecl(
   return ToUsing;
 }
 
-
 bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From, 
                                        ObjCInterfaceDecl *To,
                                        ImportDefinitionKind Kind) {
@@ -3542,8 +3567,7 @@ bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
                                          FromProtoEnd = From->protocol_end();
        FromProto != FromProtoEnd;
        ++FromProto, ++FromProtoLoc) {
-    ObjCProtocolDecl *ToProto
-      = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
+    auto *ToProto = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
     if (!ToProto)
       return true;
     Protocols.push_back(ToProto);
@@ -3561,8 +3585,8 @@ bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
   
   // If we have an @implementation, import it as well.
   if (From->getImplementation()) {
-    ObjCImplementationDecl *Impl = cast_or_null<ObjCImplementationDecl>(
-                                     Importer.Import(From->getImplementation()));
+    auto *Impl = cast_or_null<ObjCImplementationDecl>(
+        Importer.Import(From->getImplementation()));
     if (!Impl)
       return true;
     
@@ -3583,8 +3607,8 @@ ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
 
   SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
   for (auto fromTypeParam : *list) {
-    auto toTypeParam = cast_or_null<ObjCTypeParamDecl>(
-                         Importer.Import(fromTypeParam));
+    auto *toTypeParam = cast_or_null<ObjCTypeParamDecl>(
+        Importer.Import(fromTypeParam));
     if (!toTypeParam)
       return nullptr;
 
@@ -3624,11 +3648,11 @@ Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
   ObjCInterfaceDecl *MergeWithIface = nullptr;
   SmallVector<NamedDecl *, 2> FoundDecls;
   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
-  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-    if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
+  for (auto *FoundDecl : FoundDecls) {
+    if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
       continue;
     
-    if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecls[I])))
+    if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl)))
       break;
   }
   
@@ -3657,8 +3681,8 @@ Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
 }
 
 Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
-  ObjCCategoryDecl *Category = cast_or_null<ObjCCategoryDecl>(
-                                        Importer.Import(D->getCategoryDecl()));
+  auto *Category = cast_or_null<ObjCCategoryDecl>(
+      Importer.Import(D->getCategoryDecl()));
   if (!Category)
     return nullptr;
 
@@ -3696,8 +3720,8 @@ Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
 
 Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
   // Find the corresponding interface.
-  ObjCInterfaceDecl *Iface = cast_or_null<ObjCInterfaceDecl>(
-                                       Importer.Import(D->getClassInterface()));
+  auto *Iface = cast_or_null<ObjCInterfaceDecl>(
+      Importer.Import(D->getClassInterface()));
   if (!Iface)
     return nullptr;
 
@@ -3786,9 +3810,8 @@ Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
   // Check whether we have already imported this property.
   SmallVector<NamedDecl *, 2> FoundDecls;
   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
-  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-    if (ObjCPropertyDecl *FoundProp
-                                = dyn_cast<ObjCPropertyDecl>(FoundDecls[I])) {
+  for (auto *FoundDecl : FoundDecls) {
+    if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {
       // Check property types.
       if (!Importer.IsStructurallyEquivalent(D->getType(),
                                              FoundProp->getType())) {
@@ -3842,8 +3865,8 @@ Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
 }
 
 Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
-  ObjCPropertyDecl *Property = cast_or_null<ObjCPropertyDecl>(
-                                        Importer.Import(D->getPropertyDecl()));
+  auto *Property = cast_or_null<ObjCPropertyDecl>(
+      Importer.Import(D->getPropertyDecl()));
   if (!Property)
     return nullptr;
 
@@ -3859,7 +3882,7 @@ Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
       return nullptr;
   }
 
-  ObjCImplDecl *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
+  auto *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
   if (!InImpl)
     return nullptr;
 
@@ -4000,8 +4023,8 @@ Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
   // If this record has a definition in the translation unit we're coming from,
   // but this particular declaration is not that definition, import the
   // definition and map to that.
-  CXXRecordDecl *Definition 
-    = cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
+  auto *Definition =
+      cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
   if (Definition && Definition != D->getTemplatedDecl()) {
     Decl *ImportedDef
       = Importer.Import(Definition->getDescribedClassTemplate());
@@ -4026,13 +4049,12 @@ Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
     SmallVector<NamedDecl *, 4> ConflictingDecls;
     SmallVector<NamedDecl *, 2> FoundDecls;
     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
-    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-      if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
+    for (auto *FoundDecl : FoundDecls) {
+      if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
         continue;
       
-      Decl *Found = FoundDecls[I];
-      if (ClassTemplateDecl *FoundTemplate 
-                                        = dyn_cast<ClassTemplateDecl>(Found)) {
+      Decl *Found = FoundDecl;
+      if (auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Found)) {
         if (IsStructuralMatch(D, FoundTemplate)) {
           // The class templates structurally match; call it the same template.
           // FIXME: We may be filling in a forward declaration here. Handle
@@ -4043,7 +4065,7 @@ Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
         }         
       }
       
-      ConflictingDecls.push_back(FoundDecls[I]);
+      ConflictingDecls.push_back(FoundDecl);
     }
     
     if (!ConflictingDecls.empty()) {
@@ -4059,8 +4081,8 @@ Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
   CXXRecordDecl *FromTemplated = D->getTemplatedDecl();
 
   // Create the declaration that is being templated.
-  CXXRecordDecl *ToTemplated = cast_or_null<CXXRecordDecl>(
-        Importer.Import(FromTemplated));
+  auto *ToTemplated = cast_or_null<CXXRecordDecl>(
+      Importer.Import(FromTemplated));
   if (!ToTemplated)
     return nullptr;
 
@@ -4109,8 +4131,8 @@ Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
     return Importer.Imported(D, ImportedDef);
   }
 
-  ClassTemplateDecl *ClassTemplate
-    = cast_or_null<ClassTemplateDecl>(Importer.Import(
+  auto *ClassTemplate =
+      cast_or_null<ClassTemplateDecl>(Importer.Import(
                                                  D->getSpecializedTemplate()));
   if (!ClassTemplate)
     return nullptr;
@@ -4158,9 +4180,8 @@ Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
     }
   } else {
     // Create a new specialization.
-    if (ClassTemplatePartialSpecializationDecl *PartialSpec =
-        dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
-
+    if (auto *PartialSpec =
+            dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
       // Import TemplateArgumentListInfo
       TemplateArgumentListInfo ToTAInfo;
       const auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
@@ -4236,7 +4257,7 @@ Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
   // from,
   // but this particular declaration is not that definition, import the
   // definition and map to that.
-  VarDecl *Definition =
+  auto *Definition =
       cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
   if (Definition && Definition != D->getTemplatedDecl()) {
     Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
@@ -4262,12 +4283,12 @@ Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
   SmallVector<NamedDecl *, 4> ConflictingDecls;
   SmallVector<NamedDecl *, 2> FoundDecls;
   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
-  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-    if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
+  for (auto *FoundDecl : FoundDecls) {
+    if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
       continue;
 
-    Decl *Found = FoundDecls[I];
-    if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) {
+    Decl *Found = FoundDecl;
+    if (auto *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) {
       if (IsStructuralMatch(D, FoundTemplate)) {
         // The variable templates structurally match; call it the same template.
         Importer.Imported(D->getTemplatedDecl(),
@@ -4276,7 +4297,7 @@ Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
       }
     }
 
-    ConflictingDecls.push_back(FoundDecls[I]);
+    ConflictingDecls.push_back(FoundDecl);
   }
 
   if (!ConflictingDecls.empty()) {
@@ -4340,7 +4361,7 @@ Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
     return Importer.Imported(D, ImportedDef);
   }
 
-  VarTemplateDecl *VarTemplate = cast_or_null<VarTemplateDecl>(
+  auto *VarTemplate = cast_or_null<VarTemplateDecl>(
       Importer.Import(D->getSpecializedTemplate()));
   if (!VarTemplate)
     return nullptr;
@@ -4387,7 +4408,6 @@ Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
       }
     }
   } else {
-
     // Import the type.
     QualType T = Importer.Import(D->getType());
     if (T.isNull())
@@ -4430,7 +4450,6 @@ Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
         ToPartial->setMemberSpecialization();
 
       D2 = ToPartial;
-
     } else { // Full specialization
       D2 = VarTemplateSpecializationDecl::Create(
           Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo,
@@ -4491,12 +4510,11 @@ Decl *ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
     unsigned IDNS = Decl::IDNS_Ordinary;
     SmallVector<NamedDecl *, 2> FoundDecls;
     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
-    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
-      if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
+    for (auto *FoundDecl : FoundDecls) {
+      if (!FoundDecl->isInIdentifierNamespace(IDNS))
         continue;
 
-      if (FunctionTemplateDecl *FoundFunction =
-              dyn_cast<FunctionTemplateDecl>(FoundDecls[I])) {
+      if (auto *FoundFunction = dyn_cast<FunctionTemplateDecl>(FoundDecl)) {
         if (FoundFunction->hasExternalFormalLinkage() &&
             D->hasExternalFormalLinkage()) {
           if (IsStructuralMatch(D, FoundFunction)) {
@@ -4514,7 +4532,7 @@ Decl *ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
   if (!Params)
     return nullptr;
 
-  FunctionDecl *TemplatedFD =
+  auto *TemplatedFD =
       cast_or_null<FunctionDecl>(Importer.Import(D->getTemplatedDecl()));
   if (!TemplatedFD)
     return nullptr;
@@ -4550,12 +4568,11 @@ DeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) {
                               NumDecls);
 }
 
- Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
-   Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
-     << S->getStmtClassName();
-   return nullptr;
- }
-
+Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
+  Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
+    << S->getStmtClassName();
+  return nullptr;
+}
 
 Stmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
   SmallVector<IdentifierInfo *, 4> Names;
@@ -4578,8 +4595,8 @@ Stmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
 
   SmallVector<StringLiteral *, 4> Clobbers;
   for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
-    StringLiteral *Clobber = cast_or_null<StringLiteral>(
-          Importer.Import(S->getClobberStringLiteral(I)));
+    auto *Clobber = cast_or_null<StringLiteral>(
+        Importer.Import(S->getClobberStringLiteral(I)));
     if (!Clobber)
       return nullptr;
     Clobbers.push_back(Clobber);
@@ -4587,16 +4604,16 @@ Stmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
 
   SmallVector<StringLiteral *, 4> Constraints;
   for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
-    StringLiteral *Output = cast_or_null<StringLiteral>(
-          Importer.Import(S->getOutputConstraintLiteral(I)));
+    auto *Output = cast_or_null<StringLiteral>(
+        Importer.Import(S->getOutputConstraintLiteral(I)));
     if (!Output)
       return nullptr;
     Constraints.push_back(Output);
   }
 
   for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
-    StringLiteral *Input = cast_or_null<StringLiteral>(
-          Importer.Import(S->getInputConstraintLiteral(I)));
+    auto *Input = cast_or_null<StringLiteral>(
+        Importer.Import(S->getInputConstraintLiteral(I)));
     if (!Input)
       return nullptr;
     Constraints.push_back(Input);
@@ -4609,8 +4626,8 @@ Stmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
   if (ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
     return nullptr;
 
-  StringLiteral *AsmStr = cast_or_null<StringLiteral>(
-        Importer.Import(S->getAsmString()));
+  auto *AsmStr = cast_or_null<StringLiteral>(
+      Importer.Import(S->getAsmString()));
   if (!AsmStr)
     return nullptr;
 
@@ -4632,7 +4649,7 @@ Stmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
 
 Stmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
   DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup());
-  for (Decl *ToD : ToDG) {
+  for (auto *ToD : ToDG) {
     if (!ToD)
       return nullptr;
   }
@@ -4648,7 +4665,7 @@ Stmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) {
 }
 
 Stmt *ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
-  llvm::SmallVector<Stmt *, 8> ToStmts(S->size());
+  SmallVector<Stmt *, 8> ToStmts(S->size());
 
   if (ImportContainerChecked(S->body(), ToStmts))
     return nullptr;
@@ -4672,7 +4689,7 @@ Stmt *ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
   SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc());
   SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc());
   SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
-  CaseStmt *ToStmt = new (Importer.getToContext())
+  auto *ToStmt = new (Importer.getToContext())
       CaseStmt(ToLHS, ToRHS, ToCaseLoc, ToEllipsisLoc, ToColonLoc);
   ToStmt->setSubStmt(ToSubStmt);
   return ToStmt;
@@ -4690,8 +4707,7 @@ Stmt *ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
 
 Stmt *ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
   SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc());
-  LabelDecl *ToLabelDecl =
-    cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
+  auto *ToLabelDecl = cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
   if (!ToLabelDecl && S->getDecl())
     return nullptr;
   Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
@@ -4710,7 +4726,7 @@ Stmt *ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
     [&_ToContext](const Attr *A) -> const Attr * {
       return A->clone(_ToContext);
     });
-  for (const Attr *ToA : ToAttrs) {
+  for (const auto *ToA : ToAttrs) {
     if (!ToA)
       return nullptr;
   }
@@ -4765,7 +4781,7 @@ Stmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
   Expr *ToCondition = Importer.Import(S->getCond());
   if (!ToCondition && S->getCond())
     return nullptr;
-  SwitchStmt *ToStmt = new (Importer.getToContext()) SwitchStmt(
+  auto *ToStmt = new (Importer.getToContext()) SwitchStmt(
                          Importer.getToContext(), ToInit,
                          ToConditionVariable, ToCondition);
   Stmt *ToBody = Importer.Import(S->getBody());
@@ -4777,7 +4793,7 @@ Stmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
   SwitchCase *LastChainedSwitchCase = nullptr;
   for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
        SC = SC->getNextSwitchCase()) {
-    SwitchCase *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
+    auto *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
     if (!ToSC)
       return nullptr;
     if (LastChainedSwitchCase)
@@ -4894,8 +4910,8 @@ Stmt *ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
   Expr *ToRetExpr = Importer.Import(S->getRetValue());
   if (!ToRetExpr && S->getRetValue())
     return nullptr;
-  VarDecl *NRVOCandidate = const_cast<VarDecl*>(S->getNRVOCandidate());
-  VarDecl *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
+  auto *NRVOCandidate = const_cast<VarDecl *>(S->getNRVOCandidate());
+  auto *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
   if (!ToNRVOCandidate && NRVOCandidate)
     return nullptr;
   return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr,
@@ -4937,15 +4953,15 @@ Stmt *ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
 }
 
 Stmt *ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
-  DeclStmt *ToRange =
+  auto *ToRange =
     dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt()));
   if (!ToRange && S->getRangeStmt())
     return nullptr;
-  DeclStmt *ToBegin =
+  auto *ToBegin =
     dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginStmt()));
   if (!ToBegin && S->getBeginStmt())
     return nullptr;
-  DeclStmt *ToEnd =
+  auto *ToEnd =
     dyn_cast_or_null<DeclStmt>(Importer.Import(S->getEndStmt()));
   if (!ToEnd && S->getEndStmt())
     return nullptr;
@@ -4955,7 +4971,7 @@ Stmt *ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
   Expr *ToInc = Importer.Import(S->getInc());
   if (!ToInc && S->getInc())
     return nullptr;
-  DeclStmt *ToLoopVar =
+  auto *ToLoopVar =
     dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt()));
   if (!ToLoopVar && S->getLoopVarStmt())
     return nullptr;
@@ -5100,7 +5116,6 @@ Expr *ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
         Importer.Import(E->getRParenLoc()), T, E->isMicrosoftABI());
 }
 
-
 Expr *ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
@@ -5115,8 +5130,7 @@ Expr *ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
   if (T.isNull())
     return nullptr;
 
-  StringLiteral *SL = cast_or_null<StringLiteral>(
-        Importer.Import(E->getFunctionName()));
+  auto *SL = cast_or_null<StringLiteral>(Importer.Import(E->getFunctionName()));
   if (!SL && E->getFunctionName())
     return nullptr;
 
@@ -5125,7 +5139,7 @@ Expr *ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
 }
 
 Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
-  ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
+  auto *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
   if (!ToD)
     return nullptr;
 
@@ -5140,7 +5154,6 @@ Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
   if (T.isNull())
     return nullptr;
 
-
   TemplateArgumentListInfo ToTAInfo;
   TemplateArgumentListInfo *ResInfo = nullptr;
   if (E->hasExplicitTemplateArgs()) {
@@ -5192,14 +5205,14 @@ ASTNodeImporter::ImportDesignator(const Designator &D) {
 
 
 Expr *ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *DIE) {
-  Expr *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit()));
+  auto *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit()));
   if (!Init)
     return nullptr;
 
   SmallVector<Expr *, 4> IndexExprs(DIE->getNumSubExprs() - 1);
   // List elements from the second, the first is Init itself
   for (unsigned I = 1, E = DIE->getNumSubExprs(); I < E; I++) {
-    if (Expr *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I))))
+    if (auto *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I))))
       IndexExprs[I - 1] = Arg;
     else
       return nullptr;
@@ -5211,7 +5224,7 @@ Expr *ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *DIE) {
                     return ImportDesignator(D);
                   });
 
-  for (const Designator &D : DIE->designators())
+  for (const auto &D : DIE->designators())
     if (D.isFieldDesignator() && !D.getFieldName())
       return nullptr;
 
@@ -5312,7 +5325,7 @@ Expr *ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
   if (T.isNull())
     return nullptr;
 
-  LabelDecl *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel()));
+  auto *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel()));
   if (!ToLabel)
     return nullptr;
 
@@ -5347,8 +5360,8 @@ Expr *ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
   if (T.isNull())
     return nullptr;
 
-  CompoundStmt *ToSubStmt = cast_or_null<CompoundStmt>(
-        Importer.Import(E->getSubStmt()));
+  auto *ToSubStmt = cast_or_null<CompoundStmt>(
+      Importer.Import(E->getSubStmt()));
   if (!ToSubStmt && E->getSubStmt())
     return nullptr;
 
@@ -5452,8 +5465,8 @@ Expr *ASTNodeImporter::VisitBinaryConditionalOperator(
   if (!Cond)
     return nullptr;
 
-  OpaqueValueExpr *OpaqueValue = cast_or_null<OpaqueValueExpr>(
-        Importer.Import(E->getOpaqueValue()));
+  auto *OpaqueValue = cast_or_null<OpaqueValueExpr>(
+      Importer.Import(E->getOpaqueValue()));
   if (!OpaqueValue)
     return nullptr;
 
@@ -5611,7 +5624,7 @@ Expr *ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
 
   switch (E->getStmtClass()) {
   case Stmt::CStyleCastExprClass: {
-    CStyleCastExpr *CCE = cast<CStyleCastExpr>(E);
+    auto *CCE = cast<CStyleCastExpr>(E);
     return CStyleCastExpr::Create(Importer.getToContext(), T,
                                   E->getValueKind(), E->getCastKind(),
                                   SubExpr, &BasePath, TInfo,
@@ -5620,7 +5633,7 @@ Expr *ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
   }
 
   case Stmt::CXXFunctionalCastExprClass: {
-    CXXFunctionalCastExpr *FCE = cast<CXXFunctionalCastExpr>(E);
+    auto *FCE = cast<CXXFunctionalCastExpr>(E);
     return CXXFunctionalCastExpr::Create(Importer.getToContext(), T,
                                          E->getValueKind(), TInfo,
                                          E->getCastKind(), SubExpr, &BasePath,
@@ -5629,7 +5642,7 @@ Expr *ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
   }
 
   case Stmt::ObjCBridgedCastExprClass: {
-      ObjCBridgedCastExpr *OCE = cast<ObjCBridgedCastExpr>(E);
+      auto *OCE = cast<ObjCBridgedCastExpr>(E);
       return new (Importer.getToContext()) ObjCBridgedCastExpr(
             Importer.Import(OCE->getLParenLoc()), OCE->getBridgeKind(),
             E->getCastKind(), Importer.Import(OCE->getBridgeKeywordLoc()),
@@ -5639,7 +5652,7 @@ Expr *ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
     break; // just fall through
   }
 
-  CXXNamedCastExpr *Named = cast<CXXNamedCastExpr>(E);
+  auto *Named = cast<CXXNamedCastExpr>(E);
   SourceLocation ExprLoc = Importer.Import(Named->getOperatorLoc()),
       RParenLoc = Importer.Import(Named->getRParenLoc());
   SourceRange Brackets = Importer.Import(Named->getAngleBrackets());
@@ -5697,7 +5710,7 @@ Expr *ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *OE) {
       break;
     }
     case OffsetOfNode::Field: {
-      FieldDecl *FD = cast_or_null<FieldDecl>(Importer.Import(Node.getField()));
+      auto *FD = cast_or_null<FieldDecl>(Importer.Import(Node.getField()));
       if (!FD)
         return nullptr;
       Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), FD,
@@ -5768,8 +5781,7 @@ Expr *ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
 }
 
 Expr *ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
-  ParmVarDecl *Param = cast_or_null<ParmVarDecl>(
-        Importer.Import(E->getParam()));
+  auto *Param = cast_or_null<ParmVarDecl>(Importer.Import(E->getParam()));
   if (!Param)
     return nullptr;
 
@@ -5811,7 +5823,6 @@ Expr *ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE) {
   if (T.isNull())
     return nullptr;
 
-
   TypeSourceInfo *TInfo = Importer.Import(CE->getTypeSourceInfo());
   if (!TInfo)
     return nullptr;
@@ -5842,7 +5853,7 @@ ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
   if (!TempE)
     return nullptr;
 
-  ValueDecl *ExtendedBy = cast_or_null<ValueDecl>(
+  auto *ExtendedBy = cast_or_null<ValueDecl>(
         Importer.Import(const_cast<ValueDecl *>(E->getExtendingDecl())));
   if (!ExtendedBy && E->getExtendingDecl())
     return nullptr;
@@ -5893,7 +5904,6 @@ Expr *ASTNodeImporter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
       Length, PartialArguments);
 }
 
-
 Expr *ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *CE) {
   QualType T = Importer.Import(CE->getType());
   if (T.isNull())
@@ -5903,12 +5913,12 @@ Expr *ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *CE) {
   if (ImportContainerChecked(CE->placement_arguments(), PlacementArgs))
     return nullptr;
 
-  FunctionDecl *OperatorNewDecl = cast_or_null<FunctionDecl>(
+  auto *OperatorNewDecl = cast_or_null<FunctionDecl>(
         Importer.Import(CE->getOperatorNew()));
   if (!OperatorNewDecl && CE->getOperatorNew())
     return nullptr;
 
-  FunctionDecl *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
+  auto *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
         Importer.Import(CE->getOperatorDelete()));
   if (!OperatorDeleteDecl && CE->getOperatorDelete())
     return nullptr;
@@ -5943,7 +5953,7 @@ Expr *ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
   if (T.isNull())
     return nullptr;
 
-  FunctionDecl *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
+  auto *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
         Importer.Import(E->getOperatorDelete()));
   if (!OperatorDeleteDecl && E->getOperatorDelete())
     return nullptr;
@@ -5967,7 +5977,7 @@ Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
   if (T.isNull())
     return nullptr;
 
-  CXXConstructorDecl *ToCCD =
+  auto *ToCCD =
     dyn_cast_or_null<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
   if (!ToCCD)
     return nullptr;
@@ -6051,7 +6061,7 @@ Expr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
   if (!ToBase && E->getBase())
     return nullptr;
 
-  ValueDecl *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl()));
+  auto *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl()));
   if (!ToMember && E->getMemberDecl())
     return nullptr;
 
@@ -6079,7 +6089,6 @@ Expr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
 
 Expr *ASTNodeImporter::VisitCXXPseudoDestructorExpr(
     CXXPseudoDestructorExpr *E) {
-
   Expr *BaseE = Importer.Import(E->getBase());
   if (!BaseE)
     return nullptr;
@@ -6152,10 +6161,9 @@ Expr *ASTNodeImporter::VisitCXXDependentScopeMemberExpr(
 
 Expr *ASTNodeImporter::VisitCXXUnresolvedConstructExpr(
     CXXUnresolvedConstructExpr *CE) {
-
   unsigned NumArgs = CE->arg_size();
 
-  llvm::SmallVector<Expr *, 8> ToArgs(NumArgs);
+  SmallVector<Expr *, 8> ToArgs(NumArgs);
   if (ImportArrayChecked(CE->arg_begin(), CE->arg_end(), ToArgs.begin()))
     return nullptr;
 
@@ -6166,7 +6174,7 @@ Expr *ASTNodeImporter::VisitCXXUnresolvedConstructExpr(
 }
 
 Expr *ASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
-  CXXRecordDecl *NamingClass =
+  auto *NamingClass =
       cast_or_null<CXXRecordDecl>(Importer.Import(E->getNamingClass()));
   if (E->getNamingClass() && !NamingClass)
     return nullptr;
@@ -6180,8 +6188,8 @@ Expr *ASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
   ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);
 
   UnresolvedSet<8> ToDecls;
-  for (Decl *D : E->decls()) {
-    if (NamedDecl *To = cast_or_null<NamedDecl>(Importer.Import(D)))
+  for (auto *D : E->decls()) {
+    if (auto *To = cast_or_null<NamedDecl>(Importer.Import(D)))
       ToDecls.addDecl(To);
     else
       return nullptr;
@@ -6218,12 +6226,11 @@ Expr *ASTNodeImporter::VisitCallExpr(CallExpr *E) {
     return nullptr;
 
   unsigned NumArgs = E->getNumArgs();
-  llvm::SmallVector<Expr *, 2> ToArgs(NumArgs);
+  SmallVector<Expr *, 2> ToArgs(NumArgs);
   if (ImportContainerChecked(E->arguments(), ToArgs))
      return nullptr;
 
-  Expr **ToArgs_Copied = new (Importer.getToContext()) 
-    Expr*[NumArgs];
+  auto **ToArgs_Copied = new (Importer.getToContext()) Expr*[NumArgs];
 
   for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai)
     ToArgs_Copied[ai] = ToArgs[ai];
@@ -6307,13 +6314,12 @@ Expr *ASTNodeImporter::VisitLambdaExpr(LambdaExpr *LE) {
                             LE->containsUnexpandedParameterPack());
 }
 
-
 Expr *ASTNodeImporter::VisitInitListExpr(InitListExpr *ILE) {
   QualType T = Importer.Import(ILE->getType());
   if (T.isNull())
     return nullptr;
 
-  llvm::SmallVector<Expr *, 4> Exprs(ILE->getNumInits());
+  SmallVector<Expr *, 4> Exprs(ILE->getNumInits());
   if (ImportContainerChecked(ILE->inits(), Exprs))
     return nullptr;
 
@@ -6331,15 +6337,14 @@ Expr *ASTNodeImporter::VisitInitListExpr(InitListExpr *ILE) {
   }
 
   if (FieldDecl *FromFD = ILE->getInitializedFieldInUnion()) {
-    FieldDecl *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD));
+    auto *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD));
     if (!ToFD)
       return nullptr;
     To->setInitializedFieldInUnion(ToFD);
   }
 
   if (InitListExpr *SyntForm = ILE->getSyntacticForm()) {
-    InitListExpr *ToSyntForm = cast_or_null<InitListExpr>(
-          Importer.Import(SyntForm));
+    auto *ToSyntForm = cast_or_null<InitListExpr>(Importer.Import(SyntForm));
     if (!ToSyntForm)
       return nullptr;
     To->setSyntacticForm(ToSyntForm);
@@ -6377,8 +6382,7 @@ Expr *ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
 }
 
 Expr *ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
-  FieldDecl *ToField = llvm::dyn_cast_or_null<FieldDecl>(
-      Importer.Import(DIE->getField()));
+  auto *ToField = dyn_cast_or_null<FieldDecl>(Importer.Import(DIE->getField()));
   if (!ToField && DIE->getField())
     return nullptr;
 
@@ -6420,14 +6424,13 @@ Expr *ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
   }
 }
 
-
 Expr *ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
     SubstNonTypeTemplateParmExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
-  NonTypeTemplateParmDecl *Param = cast_or_null<NonTypeTemplateParmDecl>(
+  auto *Param = cast_or_null<NonTypeTemplateParmDecl>(
         Importer.Import(E->getParameter()));
   if (!Param)
     return nullptr;
@@ -6494,19 +6497,18 @@ void ASTNodeImporter::ImportOverrides(CXXMethodDecl *ToMethod,
 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
                          ASTContext &FromContext, FileManager &FromFileManager,
                          bool MinimalImport)
-  : ToContext(ToContext), FromContext(FromContext),
-    ToFileManager(ToFileManager), FromFileManager(FromFileManager),
-    Minimal(MinimalImport), LastDiagFromFrom(false)
-{
+    : ToContext(ToContext), FromContext(FromContext),
+      ToFileManager(ToFileManager), FromFileManager(FromFileManager),
+      Minimal(MinimalImport) {
   ImportedDecls[FromContext.getTranslationUnitDecl()]
     = ToContext.getTranslationUnitDecl();
 }
 
-ASTImporter::~ASTImporter() { }
+ASTImporter::~ASTImporter() = default;
 
 QualType ASTImporter::Import(QualType FromT) {
   if (FromT.isNull())
-    return QualType();
+    return {};
 
   const Type *fromTy = FromT.getTypePtr();
   
@@ -6575,11 +6577,11 @@ Decl *ASTImporter::Import(Decl *FromD) {
   // Record the imported declaration.
   ImportedDecls[FromD] = ToD;
   
-  if (TagDecl *FromTag = dyn_cast<TagDecl>(FromD)) {
+  if (auto *FromTag = dyn_cast<TagDecl>(FromD)) {
     // Keep track of anonymous tags that have an associated typedef.
     if (FromTag->getTypedefNameForAnonDecl())
       AnonTagsWithPendingTypedefs.push_back(FromTag);
-  } else if (TypedefNameDecl *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) {
+  } else if (auto *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) {
     // When we've finished transforming a typedef, see whether it was the
     // typedef for an anonymous tag.
     for (SmallVectorImpl<TagDecl *>::iterator
@@ -6587,7 +6589,7 @@ Decl *ASTImporter::Import(Decl *FromD) {
             FromTagEnd = AnonTagsWithPendingTypedefs.end();
          FromTag != FromTagEnd; ++FromTag) {
       if ((*FromTag)->getTypedefNameForAnonDecl() == FromTypedef) {
-        if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) {
+        if (auto *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) {
           // We found the typedef for an anonymous tag; link them.
           ToTag->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(ToD));
           AnonTagsWithPendingTypedefs.erase(FromTag);
@@ -6604,14 +6606,14 @@ DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
   if (!FromDC)
     return FromDC;
 
-  DeclContext *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
+  auto *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
   if (!ToDC)
     return nullptr;
 
   // When we're using a record/enum/Objective-C class/protocol as a context, we 
   // need it to have a definition.
-  if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
-    RecordDecl *FromRecord = cast<RecordDecl>(FromDC);
+  if (auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
+    auto *FromRecord = cast<RecordDecl>(FromDC);
     if (ToRecord->isCompleteDefinition()) {
       // Do nothing.
     } else if (FromRecord->isCompleteDefinition()) {
@@ -6620,8 +6622,8 @@ DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
     } else {
       CompleteDecl(ToRecord);
     }
-  } else if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
-    EnumDecl *FromEnum = cast<EnumDecl>(FromDC);
+  } else if (auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
+    auto *FromEnum = cast<EnumDecl>(FromDC);
     if (ToEnum->isCompleteDefinition()) {
       // Do nothing.
     } else if (FromEnum->isCompleteDefinition()) {
@@ -6630,8 +6632,8 @@ DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
     } else {
       CompleteDecl(ToEnum);
     }    
-  } else if (ObjCInterfaceDecl *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
-    ObjCInterfaceDecl *FromClass = cast<ObjCInterfaceDecl>(FromDC);
+  } else if (auto *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
+    auto *FromClass = cast<ObjCInterfaceDecl>(FromDC);
     if (ToClass->getDefinition()) {
       // Do nothing.
     } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
@@ -6640,8 +6642,8 @@ DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
     } else {
       CompleteDecl(ToClass);
     }
-  } else if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
-    ObjCProtocolDecl *FromProto = cast<ObjCProtocolDecl>(FromDC);
+  } else if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
+    auto *FromProto = cast<ObjCProtocolDecl>(FromDC);
     if (ToProto->getDefinition()) {
       // Do nothing.
     } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
@@ -6696,14 +6698,14 @@ NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
     return nullptr;
 
   case NestedNameSpecifier::Namespace:
-    if (NamespaceDecl *NS = 
-          cast_or_null<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
+    if (auto *NS = 
+            cast_or_null<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
       return NestedNameSpecifier::Create(ToContext, prefix, NS);
     }
     return nullptr;
 
   case NestedNameSpecifier::NamespaceAlias:
-    if (NamespaceAliasDecl *NSAD = 
+    if (auto *NSAD = 
           cast_or_null<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
       return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
     }
@@ -6713,7 +6715,7 @@ NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
     return NestedNameSpecifier::GlobalSpecifier(ToContext);
 
   case NestedNameSpecifier::Super:
-    if (CXXRecordDecl *RD =
+    if (auto *RD =
             cast_or_null<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) {
       return NestedNameSpecifier::SuperSpecifier(ToContext, RD);
     }
@@ -6809,22 +6811,20 @@ NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
 TemplateName ASTImporter::Import(TemplateName From) {
   switch (From.getKind()) {
   case TemplateName::Template:
-    if (TemplateDecl *ToTemplate
-                = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
+    if (auto *ToTemplate =
+            cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
       return TemplateName(ToTemplate);
       
-    return TemplateName();
+    return {};
       
   case TemplateName::OverloadedTemplate: {
     OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
     UnresolvedSet<2> ToTemplates;
-    for (OverloadedTemplateStorage::iterator I = FromStorage->begin(),
-                                             E = FromStorage->end();
-         I != E; ++I) {
-      if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I))) 
+    for (auto *I : *FromStorage) {
+      if (auto *To = cast_or_null<NamedDecl>(Import(I))) 
         ToTemplates.addDecl(To);
       else
-        return TemplateName();
+        return {};
     }
     return ToContext.getOverloadedTemplateName(ToTemplates.begin(), 
                                                ToTemplates.end());
@@ -6834,22 +6834,22 @@ TemplateName ASTImporter::Import(TemplateName From) {
     QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
     NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
     if (!Qualifier)
-      return TemplateName();
+      return {};
     
-    if (TemplateDecl *ToTemplate
-        = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
+    if (auto *ToTemplate =
+            cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
       return ToContext.getQualifiedTemplateName(Qualifier, 
                                                 QTN->hasTemplateKeyword(), 
                                                 ToTemplate);
-    
-    return TemplateName();
+
+    return {};
   }
   
   case TemplateName::DependentTemplate: {
     DependentTemplateName *DTN = From.getAsDependentTemplateName();
     NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
     if (!Qualifier)
-      return TemplateName();
+      return {};
     
     if (DTN->isIdentifier()) {
       return ToContext.getDependentTemplateName(Qualifier, 
@@ -6862,13 +6862,14 @@ TemplateName ASTImporter::Import(TemplateName From) {
   case TemplateName::SubstTemplateTemplateParm: {
     SubstTemplateTemplateParmStorage *subst
       = From.getAsSubstTemplateTemplateParm();
-    TemplateTemplateParmDecl *param
-      = cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
+    auto *param =
+        cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
     if (!param)
-      return TemplateName();
+      return {};
 
     TemplateName replacement = Import(subst->getReplacement());
-    if (replacement.isNull()) return TemplateName();
+    if (replacement.isNull())
+      return {};
     
     return ToContext.getSubstTemplateTemplateParm(param, replacement);
   }
@@ -6876,17 +6877,17 @@ TemplateName ASTImporter::Import(TemplateName From) {
   case TemplateName::SubstTemplateTemplateParmPack: {
     SubstTemplateTemplateParmPackStorage *SubstPack
       = From.getAsSubstTemplateTemplateParmPack();
-    TemplateTemplateParmDecl *Param
-      = cast_or_null<TemplateTemplateParmDecl>(
-                                        Import(SubstPack->getParameterPack()));
+    auto *Param =
+        cast_or_null<TemplateTemplateParmDecl>(
+            Import(SubstPack->getParameterPack()));
     if (!Param)
-      return TemplateName();
+      return {};
     
     ASTNodeImporter Importer(*this);
     TemplateArgument ArgPack 
       = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
     if (ArgPack.isNull())
-      return TemplateName();
+      return {};
     
     return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
   }
@@ -6897,7 +6898,7 @@ TemplateName ASTImporter::Import(TemplateName From) {
 
 SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
   if (FromLoc.isInvalid())
-    return SourceLocation();
+    return {};
 
   SourceManager &FromSM = FromContext.getSourceManager();
   
@@ -6909,7 +6910,7 @@ SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
   SourceManager &ToSM = ToContext.getSourceManager();
   FileID ToFileID = Import(Decomposed.first);
   if (ToFileID.isInvalid())
-    return SourceLocation();
+    return {};
   SourceLocation ret = ToSM.getLocForStartOfFile(ToFileID)
                            .getLocWithOffset(Decomposed.second);
   return ret;
@@ -6943,7 +6944,7 @@ FileID ASTImporter::Import(FileID FromID) {
     // than mmap the files several times.
     const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName());
     if (!Entry)
-      return FileID();
+      return {};
     ToID = ToSM.createFileID(Entry, ToIncludeLoc, 
                              FromSLoc.getFile().getFileCharacteristic());
   } else {
@@ -6956,8 +6957,7 @@ FileID ASTImporter::Import(FileID FromID) {
     ToID = ToSM.createFileID(std::move(ToBuf),
                              FromSLoc.getFile().getFileCharacteristic());
   }
-  
-  
+
   ImportedFileIDs[FromID] = ToID;
   return ToID;
 }
@@ -6978,8 +6978,7 @@ CXXCtorInitializer *ASTImporter::Import(CXXCtorInitializer *From) {
         From->isPackExpansion() ? Import(From->getEllipsisLoc())
                                 : SourceLocation());
   } else if (From->isMemberInitializer()) {
-    FieldDecl *ToField =
-        llvm::cast_or_null<FieldDecl>(Import(From->getMember()));
+    auto *ToField = cast_or_null<FieldDecl>(Import(From->getMember()));
     if (!ToField && From->getMember())
       return nullptr;
 
@@ -6987,7 +6986,7 @@ CXXCtorInitializer *ASTImporter::Import(CXXCtorInitializer *From) {
         ToContext, ToField, Import(From->getMemberLocation()),
         Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
   } else if (From->isIndirectMemberInitializer()) {
-    IndirectFieldDecl *ToIField = llvm::cast_or_null<IndirectFieldDecl>(
+    auto *ToIField = cast_or_null<IndirectFieldDecl>(
         Import(From->getIndirectMember()));
     if (!ToIField && From->getIndirectMember())
       return nullptr;
@@ -7008,7 +7007,6 @@ CXXCtorInitializer *ASTImporter::Import(CXXCtorInitializer *From) {
   }
 }
 
-
 CXXBaseSpecifier *ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
   auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
   if (Pos != ImportedCXXBaseSpecifiers.end())
@@ -7029,10 +7027,10 @@ void ASTImporter::ImportDefinition(Decl *From) {
   if (!To)
     return;
   
-  if (DeclContext *FromDC = cast<DeclContext>(From)) {
+  if (auto *FromDC = cast<DeclContext>(From)) {
     ASTNodeImporter Importer(*this);
       
-    if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(To)) {
+    if (auto *ToRecord = dyn_cast<RecordDecl>(To)) {
       if (!ToRecord->getDefinition()) {
         Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord, 
                                   ASTNodeImporter::IDK_Everything);
@@ -7040,7 +7038,7 @@ void ASTImporter::ImportDefinition(Decl *From) {
       }      
     }
 
-    if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(To)) {
+    if (auto *ToEnum = dyn_cast<EnumDecl>(To)) {
       if (!ToEnum->getDefinition()) {
         Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum, 
                                   ASTNodeImporter::IDK_Everything);
@@ -7048,7 +7046,7 @@ void ASTImporter::ImportDefinition(Decl *From) {
       }      
     }
     
-    if (ObjCInterfaceDecl *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
+    if (auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
       if (!ToIFace->getDefinition()) {
         Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
                                   ASTNodeImporter::IDK_Everything);
@@ -7056,7 +7054,7 @@ void ASTImporter::ImportDefinition(Decl *From) {
       }
     }
 
-    if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
+    if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
       if (!ToProto->getDefinition()) {
         Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
                                   ASTNodeImporter::IDK_Everything);
@@ -7070,7 +7068,7 @@ void ASTImporter::ImportDefinition(Decl *From) {
 
 DeclarationName ASTImporter::Import(DeclarationName FromName) {
   if (!FromName)
-    return DeclarationName();
+    return {};
 
   switch (FromName.getNameKind()) {
   case DeclarationName::Identifier:
@@ -7084,7 +7082,7 @@ DeclarationName ASTImporter::Import(DeclarationName FromName) {
   case DeclarationName::CXXConstructorName: {
     QualType T = Import(FromName.getCXXNameType());
     if (T.isNull())
-      return DeclarationName();
+      return {};
 
     return ToContext.DeclarationNames.getCXXConstructorName(
                                                ToContext.getCanonicalType(T));
@@ -7093,24 +7091,24 @@ DeclarationName ASTImporter::Import(DeclarationName FromName) {
   case DeclarationName::CXXDestructorName: {
     QualType T = Import(FromName.getCXXNameType());
     if (T.isNull())
-      return DeclarationName();
+      return {};
 
     return ToContext.DeclarationNames.getCXXDestructorName(
                                                ToContext.getCanonicalType(T));
   }
 
   case DeclarationName::CXXDeductionGuideName: {
-    TemplateDecl *Template = cast_or_null<TemplateDecl>(
+    auto *Template = cast_or_null<TemplateDecl>(
         Import(FromName.getCXXDeductionGuideTemplate()));
     if (!Template)
-      return DeclarationName();
+      return {};
     return ToContext.DeclarationNames.getCXXDeductionGuideName(Template);
   }
 
   case DeclarationName::CXXConversionFunctionName: {
     QualType T = Import(FromName.getCXXNameType());
     if (T.isNull())
-      return DeclarationName();
+      return {};
 
     return ToContext.DeclarationNames.getCXXConversionFunctionName(
                                                ToContext.getCanonicalType(T));
@@ -7146,7 +7144,7 @@ IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
 
 Selector ASTImporter::Import(Selector FromSel) {
   if (FromSel.isNull())
-    return Selector();
+    return {};
 
   SmallVector<IdentifierInfo *, 4> Idents;
   Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
@@ -7180,28 +7178,28 @@ DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
 }
 
 void ASTImporter::CompleteDecl (Decl *D) {
-  if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
+  if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
     if (!ID->getDefinition())
       ID->startDefinition();
   }
-  else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
+  else if (auto *PD = dyn_cast<ObjCProtocolDecl>(D)) {
     if (!PD->getDefinition())
       PD->startDefinition();
   }
-  else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
+  else if (auto *TD = dyn_cast<TagDecl>(D)) {
     if (!TD->getDefinition() && !TD->isBeingDefined()) {
       TD->startDefinition();
       TD->setCompleteDefinition(true);
     }
   }
   else {
-    assert (0 && "CompleteDecl called on a Decl that can't be completed");
+    assert(0 && "CompleteDecl called on a Decl that can't be completed");
   }
 }
 
 Decl *ASTImporter::Imported(Decl *From, Decl *To) {
   if (From->hasAttrs()) {
-    for (Attr *FromAttr : From->getAttrs())
+    for (auto *FromAttr : From->getAttrs())
       To->addAttr(FromAttr->clone(To->getASTContext()));
   }
   if (From->isUsed()) {
-- 
2.7.4