[clang][NFC][AST] rename the ImportError to ASTImportError

[phyBrackets]

Summary

this patch is the continuation of my previous patch regarding the ImportError in ASTImportError.h

[martong]

What are the benefits of this renaming? I mean is there a name clash? Do we have another kind of "import" in Clang or in some of the dependent projects, don't we?

[phyBrackets]

In D125340#3505723, @martong wrote:

What are the benefits of this renaming? I mean is there a name clash? Do we have another kind of "import" in Clang or in some of the dependent projects, don't we?

AS it suggested by @balazske in the previous patch , and I also think if we moved the ImportError into it's own header then it's better to be named as ASTImportError .

[balazske]

Initially the ImportError was very related to ASTImporter but now the class is used at other less related places and files. ImportError is a too generic name for this unless it can be used at any other "import" in clang which is not the case (the class can be extended with other special data about the import error). Maybe the whole ASTImporter should go into a new namespace, specially if ASTImporter.cpp would be split into parts?

[balazske]

I found one other place in LibASTImporter.rst where ImportError is used. LLDB should be checked too.

[phyBrackets]

In D125340#3506210, @balazske wrote:

I found one other place in LibASTImporter.rst where ImportError is used. LLDB should be checked too.

Yeah , I update the file LibASTImporter.rst, I'm not sure if there is need to change the ImportError that are used in lldb ?

[martong]

Yeah, okay, this patch makes sense now that I've seen a clash with python's ImportError . I've checked lldb c++ files and ImportError is not used. LGTM.

[balazske]

LLDB should be at least compilable after the change. If it has an internal ImportError we must not change it. If it uses the renamed class we should rename it, or make an "using" alias and no rename (but not this is the best solution).

[steakhal]

Conflict markers fixed by 6ccc2733e72017999a94c10147a71ff595286080.

clang/include/clang/AST/ASTImportError.h

 
 #ifndef LLVM_CLANG_AST_ASTIMPORTERROR_H
 #define LLVM_CLANG_AST_ASTIMPORTERROR_H
 
 #include "llvm/Support/Error.h"
 
 namespace clang {
 
+<<<<<<< HEAD
+class ASTImportError : public llvm::ErrorInfo<ASTImportError> {
+=======
 class ImportError : public llvm::ErrorInfo<ImportError> {
+>>>>>>> 4bf928bce44adda059aba715664c41462536d483
 public:
   /// \brief Kind of error when importing an AST component.
   enum ErrorKind {
     NameConflict,         /// Naming ambiguity (likely ODR violation).
     UnsupportedConstruct, /// Not supported node or case.
     Unknown               /// Other error.
   };
 
   ErrorKind Error;
 
   static char ID;
 
+<<<<<<< HEAD
+  ASTImportError() : Error(Unknown) {}
+  ASTImportError(const ASTImportError &Other) : Error(Other.Error) {}
+  ASTImportError &operator=(const ASTImportError &Other) {
+    Error = Other.Error;
+    return *this;
+  }
+  ASTImportError(ErrorKind Error) : Error(Error) {}
+=======
   ImportError() : Error(Unknown) {}
   ImportError(const ImportError &Other) : Error(Other.Error) {}
   ImportError &operator=(const ImportError &Other) {
     Error = Other.Error;
     return *this;
   }
   ImportError(ErrorKind Error) : Error(Error) {}
+>>>>>>> 4bf928bce44adda059aba715664c41462536d483
 
   std::string toString() const;
 
   void log(llvm::raw_ostream &OS) const override;
   std::error_code convertToErrorCode() const override;
 };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_ASTIMPORTERROR_H

clang/include/clang/AST/ASTImporter.h

private:
     llvm::DenseMap<Decl *, Decl *> ImportedDecls;
 
     /// Mapping from the already-imported declarations in the "from"
     /// context to the error status of the import of that declaration.
     /// This map contains only the declarations that were not correctly
     /// imported. The same declaration may or may not be included in
     /// ImportedDecls. This map is updated continuously during imports and never
     /// cleared (like ImportedDecls).
-    llvm::DenseMap<Decl *, ImportError> ImportDeclErrors;
+    llvm::DenseMap<Decl *, ASTImportError> ImportDeclErrors;
 
     /// Mapping from the already-imported declarations in the "to"
     /// context to the corresponding declarations in the "from" context.
     llvm::DenseMap<Decl *, Decl *> ImportedFromDecls;
 
     /// Mapping from the already-imported statements in the "from"
     /// context to the corresponding statements in the "to" context.
     llvm::DenseMap<Stmt *, Stmt *> ImportedStmts;
public:
     /// happens especially for anonymous structs.  If the original of the second
     /// RecordDecl can be found, we can complete it without the need for
     /// importation, eliminating this loop.
     virtual Decl *GetOriginalDecl(Decl *To) { return nullptr; }
 
     /// Return if import of the given declaration has failed and if yes
     /// the kind of the problem. This gives the first error encountered with
     /// the node.
-    llvm::Optional<ImportError> getImportDeclErrorIfAny(Decl *FromD) const;
+    llvm::Optional<ASTImportError> getImportDeclErrorIfAny(Decl *FromD) const;
 
     /// Mark (newly) imported declaration with error.
-    void setImportDeclError(Decl *From, ImportError Error);
+    void setImportDeclError(Decl *From, ASTImportError Error);
 
     /// Determine whether the given types are structurally
     /// equivalent.
     bool IsStructurallyEquivalent(QualType From, QualType To,
                                   bool Complain = true);
 
     /// Determine the index of a field in its parent record.
     /// F should be a field (or indirect field) declaration.
     /// \returns The index of the field in its parent context (starting from 0).
     /// On error `None` is returned (parent context is non-record).
     static llvm::Optional<unsigned> getFieldIndex(Decl *F);
   };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_ASTIMPORTER_H

clang/include/clang/AST/ASTImporterSharedState.h

class ASTImporterSharedState {
   std::unique_ptr<ASTImporterLookupTable> LookupTable;
 
   /// Mapping from the already-imported declarations in the "to"
   /// context to the error status of the import of that declaration.
   /// This map contains only the declarations that were not correctly
   /// imported. The same declaration may or may not be included in
   /// ImportedFromDecls. This map is updated continuously during imports and
   /// never cleared (like ImportedFromDecls).
-  llvm::DenseMap<Decl *, ImportError> ImportErrors;
+  llvm::DenseMap<Decl *, ASTImportError> ImportErrors;
 
   /// Set of the newly created declarations.
   llvm::DenseSet<Decl *> NewDecls;
 
   // FIXME put ImportedFromDecls here!
   // And from that point we can better encapsulate the lookup table.
 
 public:
public:
   }
 
   void removeDeclFromLookup(Decl *D) {
     if (LookupTable)
       if (auto *ND = dyn_cast<NamedDecl>(D))
         LookupTable->remove(ND);
   }
 
-  llvm::Optional<ImportError> getImportDeclErrorIfAny(Decl *ToD) const {
+  llvm::Optional<ASTImportError> getImportDeclErrorIfAny(Decl *ToD) const {
     auto Pos = ImportErrors.find(ToD);
     if (Pos != ImportErrors.end())
       return Pos->second;
     else
-      return Optional<ImportError>();
+      return Optional<ASTImportError>();
   }
 
-  void setImportDeclError(Decl *To, ImportError Error) {
+  void setImportDeclError(Decl *To, ASTImportError Error) {
     ImportErrors[To] = Error;
   }
 
   bool isNewDecl(const Decl *ToD) const { return NewDecls.count(ToD); }
 
   void markAsNewDecl(Decl *ToD) { NewDecls.insert(ToD); }
 };
 
 } // namespace clang
 #endif // LLVM_CLANG_AST_ASTIMPORTERSHAREDSTATE_H

clang/lib/AST/ASTImporter.cpp

namespace clang {
   using ExpectedTypePtr = llvm::Expected<const Type *>;
   using ExpectedType = llvm::Expected<QualType>;
   using ExpectedStmt = llvm::Expected<Stmt *>;
   using ExpectedExpr = llvm::Expected<Expr *>;
   using ExpectedDecl = llvm::Expected<Decl *>;
   using ExpectedSLoc = llvm::Expected<SourceLocation>;
   using ExpectedName = llvm::Expected<DeclarationName>;
 
-  std::string ImportError::toString() const {
+  std::string ASTImportError::toString() const {
     // FIXME: Improve error texts.
     switch (Error) {
     case NameConflict:
       return "NameConflict";
     case UnsupportedConstruct:
       return "UnsupportedConstruct";
     case Unknown:
       return "Unknown error";
     }
     llvm_unreachable("Invalid error code.");
     return "Invalid error code.";
   }
 
-  void ImportError::log(raw_ostream &OS) const {
-    OS << toString();
-  }
+  void ASTImportError::log(raw_ostream &OS) const { OS << toString(); }
 
-  std::error_code ImportError::convertToErrorCode() const {
+  std::error_code ASTImportError::convertToErrorCode() const {
     llvm_unreachable("Function not implemented.");
   }
 
-  char ImportError::ID;
+  char ASTImportError::ID;
 
   template <class T>
   SmallVector<Decl *, 2>
   getCanonicalForwardRedeclChain(Redeclarable<T>* D) {
     SmallVector<Decl *, 2> Redecls;
     for (auto *R : D->getFirstDecl()->redecls()) {
       if (R != D->getFirstDecl())
         Redecls.push_back(R);

 // Import Types
 //----------------------------------------------------------------------------
 
 using namespace clang;
 
 ExpectedType ASTNodeImporter::VisitType(const Type *T) {
   Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
     << T->getTypeClassName();
-  return make_error<ImportError>(ImportError::UnsupportedConstruct);
+  return make_error<ASTImportError>(ASTImportError::UnsupportedConstruct);
 }
 
 ExpectedType ASTNodeImporter::VisitAtomicType(const AtomicType *T){
   ExpectedType UnderlyingTypeOrErr = import(T->getValueType());
   if (!UnderlyingTypeOrErr)
     return UnderlyingTypeOrErr.takeError();
 
   return Importer.getToContext().getAtomicType(*UnderlyingTypeOrErr);
if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
     };
     for (const ParmVarDecl *P : FunDecl->parameters()) {
       const Type *LeafT =
           getLeafPointeeType(P->getType().getCanonicalType().getTypePtr());
       auto *RT = dyn_cast<RecordType>(LeafT);
       if (RT && RT->getDecl() == D) {
         Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
             << D->getDeclKindName();
-        return make_error<ImportError>(ImportError::UnsupportedConstruct);
+        return make_error<ASTImportError>(ASTImportError::UnsupportedConstruct);
       }
     }
   }
 
   // Import the context of this declaration.
   if (Error Err = ImportDeclContext(D, DC, LexicalDC))
     return Err;
 
StructuralEquivalenceContext Ctx(
       Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
       false, Complain);
   return Ctx.IsEquivalent(From, To);
 }
 
 ExpectedDecl ASTNodeImporter::VisitDecl(Decl *D) {
   Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
     << D->getDeclKindName();
-  return make_error<ImportError>(ImportError::UnsupportedConstruct);
+  return make_error<ASTImportError>(ASTImportError::UnsupportedConstruct);
 }
 
 ExpectedDecl ASTNodeImporter::VisitImportDecl(ImportDecl *D) {
   Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
       << D->getDeclKindName();
-  return make_error<ImportError>(ImportError::UnsupportedConstruct);
+  return make_error<ASTImportError>(ASTImportError::UnsupportedConstruct);
 }
 
 ExpectedDecl ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) {
   // Import the context of this declaration.
   DeclContext *DC, *LexicalDC;
   if (Error Err = ImportDeclContext(D, DC, LexicalDC))
     return std::move(Err);
 
if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
       }
 
       // FIXME: Why is this case not handled with calling HandleNameConflict?
       Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
         << Name << D->getType() << FoundField->getType();
       Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
         << FoundField->getType();
 
-      return make_error<ImportError>(ImportError::NameConflict);
+      return make_error<ASTImportError>(ASTImportError::NameConflict);
     }
   }
 
   Error Err = Error::success();
   auto ToType = importChecked(Err, D->getType());
   auto ToTInfo = importChecked(Err, D->getTypeSourceInfo());
   auto ToBitWidth = importChecked(Err, D->getBitWidth());
   auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
if (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
         continue;
 
       // FIXME: Why is this case not handled with calling HandleNameConflict?
       Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
         << Name << D->getType() << FoundField->getType();
       Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
         << FoundField->getType();
 
-      return make_error<ImportError>(ImportError::NameConflict);
+      return make_error<ASTImportError>(ASTImportError::NameConflict);
     }
   }
 
   // Import the type.
   auto TypeOrErr = import(D->getType());
   if (!TypeOrErr)
     return TypeOrErr.takeError();
 
if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
         return FoundIvar;
       }
 
       Importer.ToDiag(Loc, diag::warn_odr_ivar_type_inconsistent)
         << Name << D->getType() << FoundIvar->getType();
       Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
         << FoundIvar->getType();
 
-      return make_error<ImportError>(ImportError::NameConflict);
+      return make_error<ASTImportError>(ASTImportError::NameConflict);
     }
   }
 
   Error Err = Error::success();
   auto ToType = importChecked(Err, D->getType());
   auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
   auto ToBitWidth = importChecked(Err, D->getBitWidth());
   auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
                                              FoundMethod->getReturnType())) {
         Importer.ToDiag(Loc, diag::warn_odr_objc_method_result_type_inconsistent)
             << D->isInstanceMethod() << Name << D->getReturnType()
             << FoundMethod->getReturnType();
         Importer.ToDiag(FoundMethod->getLocation(),
                         diag::note_odr_objc_method_here)
           << D->isInstanceMethod() << Name;
 
-        return make_error<ImportError>(ImportError::NameConflict);
+        return make_error<ASTImportError>(ASTImportError::NameConflict);
       }
 
       // Check the number of parameters.
       if (D->param_size() != FoundMethod->param_size()) {
         Importer.ToDiag(Loc, diag::warn_odr_objc_method_num_params_inconsistent)
           << D->isInstanceMethod() << Name
           << D->param_size() << FoundMethod->param_size();
         Importer.ToDiag(FoundMethod->getLocation(),
                         diag::note_odr_objc_method_here)
           << D->isInstanceMethod() << Name;
 
-        return make_error<ImportError>(ImportError::NameConflict);
+        return make_error<ASTImportError>(ASTImportError::NameConflict);
       }
 
       // Check parameter types.
       for (ObjCMethodDecl::param_iterator P = D->param_begin(),
              PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
            P != PEnd; ++P, ++FoundP) {
         if (!Importer.IsStructurallyEquivalent((*P)->getType(),
                                                (*FoundP)->getType())) {
           Importer.FromDiag((*P)->getLocation(),
                             diag::warn_odr_objc_method_param_type_inconsistent)
             << D->isInstanceMethod() << Name
             << (*P)->getType() << (*FoundP)->getType();
           Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
             << (*FoundP)->getType();
 
-          return make_error<ImportError>(ImportError::NameConflict);
+          return make_error<ASTImportError>(ASTImportError::NameConflict);
         }
       }
 
       // Check variadic/non-variadic.
       // Check the number of parameters.
       if (D->isVariadic() != FoundMethod->isVariadic()) {
         Importer.ToDiag(Loc, diag::warn_odr_objc_method_variadic_inconsistent)
           << D->isInstanceMethod() << Name;
         Importer.ToDiag(FoundMethod->getLocation(),
                         diag::note_odr_objc_method_here)
           << D->isInstanceMethod() << Name;
 
-        return make_error<ImportError>(ImportError::NameConflict);
+        return make_error<ASTImportError>(ASTImportError::NameConflict);
       }
 
       // FIXME: Any other bits we need to merge?
       return Importer.MapImported(D, FoundMethod);
     }
   }
 
   Error Err = Error::success();
if ((Super && !Impl->getSuperClass()) ||
       if (D->getSuperClass())
         Importer.FromDiag(D->getLocation(),
                           diag::note_odr_objc_superclass)
         << D->getSuperClass()->getDeclName();
       else
         Importer.FromDiag(D->getLocation(),
                           diag::note_odr_objc_missing_superclass);
 
-      return make_error<ImportError>(ImportError::NameConflict);
+      return make_error<ASTImportError>(ASTImportError::NameConflict);
     }
   }
 
   // Import all of the members of this @implementation.
   if (Error Err = ImportDeclContext(D))
     return std::move(Err);
 
   return Impl;
if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {
       // Check property types.
       if (!Importer.IsStructurallyEquivalent(D->getType(),
                                              FoundProp->getType())) {
         Importer.ToDiag(Loc, diag::warn_odr_objc_property_type_inconsistent)
           << Name << D->getType() << FoundProp->getType();
         Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
           << FoundProp->getType();
 
-        return make_error<ImportError>(ImportError::NameConflict);
+        return make_error<ASTImportError>(ASTImportError::NameConflict);
       }
 
       // FIXME: Check property attributes, getters, setters, etc.?
 
       // Consider these properties to be equivalent.
       Importer.MapImported(D, FoundProp);
       return FoundProp;
     }
if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
         << Property->getDeclName()
         << (ToImpl->getPropertyImplementation()
                                               == ObjCPropertyImplDecl::Dynamic);
       Importer.FromDiag(D->getLocation(),
                         diag::note_odr_objc_property_impl_kind)
         << D->getPropertyDecl()->getDeclName()
         << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
 
-      return make_error<ImportError>(ImportError::NameConflict);
+      return make_error<ASTImportError>(ASTImportError::NameConflict);
     }
 
     // For @synthesize, check that we have the same
     if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
         Ivar != ToImpl->getPropertyIvarDecl()) {
       Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
                       diag::warn_odr_objc_synthesize_ivar_inconsistent)
         << Property->getDeclName()
         << ToImpl->getPropertyIvarDecl()->getDeclName()
         << Ivar->getDeclName();
       Importer.FromDiag(D->getPropertyIvarDeclLoc(),
                         diag::note_odr_objc_synthesize_ivar_here)
         << D->getPropertyIvarDecl()->getDeclName();
 
-      return make_error<ImportError>(ImportError::NameConflict);
+      return make_error<ASTImportError>(ASTImportError::NameConflict);
     }
 
     // Merge the existing implementation with the new implementation.
     Importer.MapImported(D, ToImpl);
   }
 
   return ToImpl;
 }
if (IsStructuralMatch(D, PrevDecl)) {
         // TODO Import instantiated exception specifications.
         //
         // Generally, ASTCommon.h/DeclUpdateKind enum gives a very good hint
         // what else could be fused during an AST merge.
         return PrevDefinition;
       }
     } else { // ODR violation.
       // FIXME HandleNameConflict
-      return make_error<ImportError>(ImportError::NameConflict);
+      return make_error<ASTImportError>(ASTImportError::NameConflict);
     }
   }
 
   // Import the location of this declaration.
   ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
   if (!BeginLocOrErr)
     return BeginLocOrErr.takeError();
   ExpectedSLoc IdLocOrErr = import(D->getLocation());

 
 //----------------------------------------------------------------------------
 // Import Statements
 //----------------------------------------------------------------------------
 
 ExpectedStmt ASTNodeImporter::VisitStmt(Stmt *S) {
   Importer.FromDiag(S->getBeginLoc(), diag::err_unsupported_ast_node)
       << S->getStmtClassName();
-  return make_error<ImportError>(ImportError::UnsupportedConstruct);
+  return make_error<ASTImportError>(ASTImportError::UnsupportedConstruct);
 }
 
 
 ExpectedStmt ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
   if (Importer.returnWithErrorInTest())
-    return make_error<ImportError>(ImportError::UnsupportedConstruct);
+    return make_error<ASTImportError>(ASTImportError::UnsupportedConstruct);
   SmallVector<IdentifierInfo *, 4> Names;
   for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
     IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
     // ToII is nullptr when no symbolic name is given for output operand
     // see ParseStmtAsm::ParseAsmOperandsOpt
     Names.push_back(ToII);
   }
 

 }
 
 //----------------------------------------------------------------------------
 // Import Expressions
 //----------------------------------------------------------------------------
 ExpectedStmt ASTNodeImporter::VisitExpr(Expr *E) {
   Importer.FromDiag(E->getBeginLoc(), diag::err_unsupported_ast_node)
       << E->getStmtClassName();
-  return make_error<ImportError>(ImportError::UnsupportedConstruct);
+  return make_error<ASTImportError>(ASTImportError::UnsupportedConstruct);
 }
 
 ExpectedStmt ASTNodeImporter::VisitSourceLocExpr(SourceLocExpr *E) {
   Error Err = Error::success();
   auto ToType = importChecked(Err, E->getType());
   auto BLoc = importChecked(Err, E->getBeginLoc());
   auto RParenLoc = importChecked(Err, E->getEndLoc());
   if (Err)
case Stmt::ObjCBridgedCastExprClass: {
     if (!ToBridgeKeywordLocOrErr)
       return ToBridgeKeywordLocOrErr.takeError();
     return new (Importer.getToContext()) ObjCBridgedCastExpr(
         *ToLParenLocOrErr, OCE->getBridgeKind(), E->getCastKind(),
         *ToBridgeKeywordLocOrErr, ToTypeInfoAsWritten, ToSubExpr);
   }
   default:
     llvm_unreachable("Cast expression of unsupported type!");
-    return make_error<ImportError>(ImportError::UnsupportedConstruct);
+    return make_error<ASTImportError>(ASTImportError::UnsupportedConstruct);
   }
 }
 
 ExpectedStmt ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *E) {
   SmallVector<OffsetOfNode, 4> ToNodes;
   for (int I = 0, N = E->getNumComponents(); I < N; ++I) {
     const OffsetOfNode &FromNode = E->getComponent(I);
 
return CXXReinterpretCastExpr::Create(
         Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
         ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
   } else if (isa<CXXConstCastExpr>(E)) {
     return CXXConstCastExpr::Create(
         Importer.getToContext(), ToType, VK, ToSubExpr, ToTypeInfoAsWritten,
         ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
   } else {
     llvm_unreachable("Unknown cast type");
-    return make_error<ImportError>();
+    return make_error<ASTImportError>();
   }
 }
 
 ExpectedStmt ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
     SubstNonTypeTemplateParmExpr *E) {
   Error Err = Error::success();
   auto ToType = importChecked(Err, E->getType());
   auto ToExprLoc = importChecked(Err, E->getExprLoc());

 ASTImporter::Import(ExprWithCleanups::CleanupObject From) {
   if (auto *CLE = From.dyn_cast<CompoundLiteralExpr *>()) {
     if (Expected<Expr *> R = Import(CLE))
       return ExprWithCleanups::CleanupObject(cast<CompoundLiteralExpr>(*R));
   }
 
   // FIXME: Handle BlockDecl when we implement importing BlockExpr in
   //        ASTNodeImporter.
-  return make_error<ImportError>(ImportError::UnsupportedConstruct);
+  return make_error<ASTImportError>(ASTImportError::UnsupportedConstruct);
 }
 
 ExpectedTypePtr ASTImporter::Import(const Type *FromT) {
   if (!FromT)
     return FromT;
 
   // Check whether we've already imported this type.
   llvm::DenseMap<const Type *, const Type *>::iterator Pos =
Expected<Decl *> ASTImporter::Import(Decl *FromD) {
   // Push FromD to the stack, and remove that when we return.
   ImportPath.push(FromD);
   auto ImportPathBuilder =
       llvm::make_scope_exit([this]() { ImportPath.pop(); });
 
   // Check whether there was a previous failed import.
   // If yes return the existing error.
   if (auto Error = getImportDeclErrorIfAny(FromD))
-    return make_error<ImportError>(*Error);
+    return make_error<ASTImportError>(*Error);
 
   // Check whether we've already imported this declaration.
   Decl *ToD = GetAlreadyImportedOrNull(FromD);
   if (ToD) {
     // Already imported (possibly from another TU) and with an error.
     if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
       setImportDeclError(FromD, *Error);
-      return make_error<ImportError>(*Error);
+      return make_error<ASTImportError>(*Error);
     }
 
     // If FromD has some updated flags after last import, apply it.
     updateFlags(FromD, ToD);
     // If we encounter a cycle during an import then we save the relevant part
     // of the import path associated to the Decl.
     if (ImportPath.hasCycleAtBack())
       SavedImportPaths[FromD].push_back(ImportPath.copyCycleAtBack());
if (Pos != ImportedDecls.end()) {
       // FIXME: AST may contain remaining references to the failed object.
       // However, the ImportDeclErrors in the shared state contains all the
       // failed objects together with their error.
     }
 
     // Error encountered for the first time.
     // After takeError the error is not usable any more in ToDOrErr.
     // Get a copy of the error object (any more simple solution for this?).
-    ImportError ErrOut;
+    ASTImportError ErrOut;
     handleAllErrors(ToDOrErr.takeError(),
-                    [&ErrOut](const ImportError &E) { ErrOut = E; });
+                    [&ErrOut](const ASTImportError &E) { ErrOut = E; });
     setImportDeclError(FromD, ErrOut);
     // Set the error for the mapped to Decl, which is in the "to" context.
     if (Pos != ImportedDecls.end())
       SharedState->setImportDeclError(Pos->second, ErrOut);
 
     // Set the error for all nodes which have been created before we
     // recognized the error.
     for (const auto &Path : SavedImportPaths[FromD]) {
for (const auto &Path : SavedImportPaths[FromD]) {
           SharedState->setImportDeclError(Ii->second, ErrOut);
           // FIXME Should we remove these Decls from the LookupTable,
           // and from ImportedFromDecls?
       }
     }
     SavedImportPaths.erase(FromD);
 
     // Do not return ToDOrErr, error was taken out of it.
-    return make_error<ImportError>(ErrOut);
+    return make_error<ASTImportError>(ErrOut);
   }
 
   ToD = *ToDOrErr;
 
   // FIXME: Handle the "already imported with error" case. We can get here
   // nullptr only if GetImportedOrCreateDecl returned nullptr (after a
   // previously failed create was requested).
   // Later GetImportedOrCreateDecl can be updated to return the error.
   if (!ToD) {
     auto Err = getImportDeclErrorIfAny(FromD);
     assert(Err);
-    return make_error<ImportError>(*Err);
+    return make_error<ASTImportError>(*Err);
   }
 
   // We could import from the current TU without error.  But previously we
   // already had imported a Decl as `ToD` from another TU (with another
   // ASTImporter object) and with an error.
   if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
     setImportDeclError(FromD, *Error);
-    return make_error<ImportError>(*Error);
+    return make_error<ASTImportError>(*Error);
   }
 
   // Make sure that ImportImpl registered the imported decl.
   assert(ImportedDecls.count(FromD) != 0 && "Missing call to MapImported?");
 
   if (FromD->hasAttrs())
     for (const Attr *FromAttr : FromD->getAttrs()) {
       auto ToAttrOrErr = Import(FromAttr);
if (FromSLoc.isExpansion()) {
     }
 
     if (ToID.isInvalid() || IsBuiltin) {
       // FIXME: We want to re-use the existing MemoryBuffer!
       llvm::Optional<llvm::MemoryBufferRef> FromBuf =
           Cache->getBufferOrNone(FromContext.getDiagnostics(),
                                  FromSM.getFileManager(), SourceLocation{});
       if (!FromBuf)
-        return llvm::make_error<ImportError>(ImportError::Unknown);
+        return llvm::make_error<ASTImportError>(ASTImportError::Unknown);
 
       std::unique_ptr<llvm::MemoryBuffer> ToBuf =
           llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
                                                FromBuf->getBufferIdentifier());
       ToID = ToSM.createFileID(std::move(ToBuf),
                                FromSLoc.getFile().getFileCharacteristic());
     }
   }
if (From->isBaseInitializer()) {
     if (!ToTInfoOrErr)
       return ToTInfoOrErr.takeError();
 
     return new (ToContext)
         CXXCtorInitializer(ToContext, *ToTInfoOrErr, *LParenLocOrErr,
                            *ToExprOrErr, *RParenLocOrErr);
   } else {
     // FIXME: assert?
-    return make_error<ImportError>();
+    return make_error<ASTImportError>();
   }
 }
 
 Expected<CXXBaseSpecifier *>
 ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
   auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
   if (Pos != ImportedCXXBaseSpecifiers.end())
     return Pos->second;

 
 Expected<DeclarationName> ASTImporter::HandleNameConflict(DeclarationName Name,
                                                           DeclContext *DC,
                                                           unsigned IDNS,
                                                           NamedDecl **Decls,
                                                           unsigned NumDecls) {
   if (ODRHandling == ODRHandlingType::Conservative)
     // Report error at any name conflict.
-    return make_error<ImportError>(ImportError::NameConflict);
+    return make_error<ASTImportError>(ASTImportError::NameConflict);
   else
     // Allow to create the new Decl with the same name.
     return Name;
 }
 
 DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
   if (LastDiagFromFrom)
     ToContext.getDiagnostics().notePriorDiagnosticFrom(
Decl *ASTImporter::MapImported(Decl *From, Decl *To) {
   // In the case of TypedefNameDecl we create the Decl first and only then we
   // import and set its DeclContext. So, the DC is still not set when we reach
   // here from GetImportedOrCreateDecl.
   if (To->getDeclContext())
     AddToLookupTable(To);
   return To;
 }
 
-llvm::Optional<ImportError>
+llvm::Optional<ASTImportError>
 ASTImporter::getImportDeclErrorIfAny(Decl *FromD) const {
   auto Pos = ImportDeclErrors.find(FromD);
   if (Pos != ImportDeclErrors.end())
     return Pos->second;
   else
-    return Optional<ImportError>();
+    return Optional<ASTImportError>();
 }
 
-void ASTImporter::setImportDeclError(Decl *From, ImportError Error) {
+void ASTImporter::setImportDeclError(Decl *From, ASTImportError Error) {
   auto InsertRes = ImportDeclErrors.insert({From, Error});
   (void)InsertRes;
   // Either we set the error for the first time, or we already had set one and
   // now we want to set the same error.
   assert(InsertRes.second || InsertRes.first->second.Error == Error.Error);
 }
 
 bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,

clang/lib/CrossTU/CrossTranslationUnit.cpp

CrossTranslationUnitContext::importDefinitionImpl(const T *D, ASTUnit *Unit) {
   assert(hasBodyOrInit(D) && "Decls to be imported should have body or init.");
 
   assert(&D->getASTContext() == &Unit->getASTContext() &&
          "ASTContext of Decl and the unit should match.");
   ASTImporter &Importer = getOrCreateASTImporter(Unit);
 
   auto ToDeclOrError = Importer.Import(D);
   if (!ToDeclOrError) {
-    handleAllErrors(ToDeclOrError.takeError(),
-                    [&](const ImportError &IE) {
-                      switch (IE.Error) {
-                      case ImportError::NameConflict:
-                        ++NumNameConflicts;
-                         break;
-                      case ImportError::UnsupportedConstruct:
-                        ++NumUnsupportedNodeFound;
-                        break;
-                      case ImportError::Unknown:
-                        llvm_unreachable("Unknown import error happened.");
-                        break;
-                      }
-                    });
+    handleAllErrors(ToDeclOrError.takeError(), [&](const ASTImportError &IE) {
+      case ASTImportError::NameConflict:
+      case ASTImportError::UnsupportedConstruct:
+      case ASTImportError::Unknown:
     return llvm::make_error<IndexError>(index_error_code::failed_import);
   }
   auto *ToDecl = cast<T>(*ToDeclOrError);
   assert(hasBodyOrInit(ToDecl) && "Imported Decl should have body or init.");
   ++NumGetCTUSuccess;
 
   // Parent map is invalidated after changing the AST.
   ToDecl->getASTContext().getParentMapContext().clear();

clang/unittests/AST/ASTImporterFixtures.h

testImport(const std::string &FromCode,
     // The node being imported should match in the same way as
     // the result node.
     internal::BindableMatcher<NodeType> WrapperMatcher(VerificationMatcher);
     EXPECT_TRUE(Verifier.match(ToImport, WrapperMatcher));
 
     auto Imported = importNode(FromAST.get(), ToAST.get(), Importer, ToImport);
     if (!Imported) {
       std::string ErrorText;
-      handleAllErrors(
-          Imported.takeError(),
-          [&ErrorText](const ImportError &Err) { ErrorText = Err.message(); });
+      handleAllErrors(Imported.takeError(),
+                      [&ErrorText](const ASTImportError &Err) {
+                        ErrorText = Err.message();
+                      });
       return testing::AssertionFailure()
              << "Import failed, error: \"" << ErrorText << "\"!";
     }
 
     return Verifier.match(*Imported, WrapperMatcher);
   }
 
   template <typename NodeType>
if (ValOrErr)
     return ::testing::AssertionSuccess() << "Expected<> contains no error.";
   else
     return ::testing::AssertionFailure()
            << "Expected<> contains error: " << toString(ValOrErr.takeError());
 }
 
 template <class T>
 ::testing::AssertionResult isImportError(llvm::Expected<T> &ValOrErr,
-                                         ImportError::ErrorKind Kind) {
+                                         ASTImportError::ErrorKind Kind) {
   if (ValOrErr) {
     return ::testing::AssertionFailure() << "Expected<> is expected to contain "
                                             "error but does contain value \""
                                          << (*ValOrErr) << "\"";
   } else {
     std::ostringstream OS;
     bool Result = false;
     auto Err = llvm::handleErrors(
-        ValOrErr.takeError(), [&OS, &Result, Kind](clang::ImportError &IE) {
+        ValOrErr.takeError(), [&OS, &Result, Kind](clang::ASTImportError &IE) {
           if (IE.Error == Kind) {
             Result = true;
             OS << "Expected<> contains an ImportError " << IE.toString();
           } else {
             OS << "Expected<> contains an ImportError " << IE.toString()
                << " instead of kind " << Kind;
           }
         });

clang/unittests/AST/ASTImporterODRStrategiesTest.cpp

if (auto *ImportedF = dyn_cast<FunctionDecl>(ImportedD))
         return;
 
     EXPECT_FALSE(ImportedD->getPreviousDecl());
   }
 
   // Check that a Decl was not imported because of NameConflict.
   static void CheckImportNameConflict(llvm::Expected<Decl *> &Result,
                                       Decl *ToTU, Decl *ToD) {
-    EXPECT_TRUE(isImportError(Result, ImportError::NameConflict));
+    EXPECT_TRUE(isImportError(Result, ASTImportError::NameConflict));
     EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 1u);
   }
 
   // Check that a Decl was not imported because lookup found the same decl.
   static void CheckImportFoundExisting(llvm::Expected<Decl *> &Result,
                                       Decl *ToTU, Decl *ToD) {
     ASSERT_TRUE(isSuccess(Result));
     EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 1u);

clang/unittests/AST/ASTImporterTest.cpp

void test_block__capture_null() {
       }();
     })";
   Decl *FromTU = getTuDecl(Code, Lang_CXX03);
   auto *FromBlock = FirstDeclMatcher<BlockDecl>().match(FromTU, blockDecl());
   ASSERT_TRUE(FromBlock);
 
   auto ToBlockOrError = importOrError(FromBlock, Lang_CXX03);
 
-  const auto ExpectUnsupportedConstructError = [](const ImportError &Error) {
-    EXPECT_EQ(ImportError::UnsupportedConstruct, Error.Error);
+  const auto ExpectUnsupportedConstructError = [](const ASTImportError &Error) {
+    EXPECT_EQ(ASTImportError::UnsupportedConstruct, Error.Error);
   };
   llvm::handleAllErrors(ToBlockOrError.takeError(),
                         ExpectUnsupportedConstructError);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportParmVarDecl) {
   const auto *Code = R"(
     template <typename T> struct Wrapper {
TEST_P(ErrorHandlingTest, ErrorHappensBeforeCreatingANewNode) {
 
   // The original Decl is kept, no new decl is created.
   EXPECT_EQ(DeclCounter<ClassTemplateSpecializationDecl>().match(
                 ToTU, classTemplateSpecializationDecl(hasName("X"))),
             1u);
 
   // But an error is set to the counterpart in the "from" context.
   ASTImporter *Importer = findFromTU(FromSpec)->Importer.get();
-  Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromSpec);
+  Optional<ASTImportError> OptErr = Importer->getImportDeclErrorIfAny(FromSpec);
   ASSERT_TRUE(OptErr);
-  EXPECT_EQ(OptErr->Error, ImportError::NameConflict);
+  EXPECT_EQ(OptErr->Error, ASTImportError::NameConflict);
 }
 
 // Check a case when a new AST node is created but not linked to the AST before
 // encountering the error.
 TEST_P(ErrorHandlingTest,
        ErrorHappensAfterCreatingTheNodeButBeforeLinkingThatToTheAST) {
   TranslationUnitDecl *FromTU = getTuDecl(
       std::string("void foo() { ") + ErroneousStmt + " }", Lang_CXX03);
   auto *FromFoo = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("foo")));
 
   FunctionDecl *ImportedFoo = Import(FromFoo, Lang_CXX03);
   EXPECT_FALSE(ImportedFoo);
 
   TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   // Created, but not linked.
   EXPECT_EQ(
       DeclCounter<FunctionDecl>().match(ToTU, functionDecl(hasName("foo"))),
       0u);
 
   ASTImporter *Importer = findFromTU(FromFoo)->Importer.get();
-  Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromFoo);
+  Optional<ASTImportError> OptErr = Importer->getImportDeclErrorIfAny(FromFoo);
   ASSERT_TRUE(OptErr);
-  EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
+  EXPECT_EQ(OptErr->Error, ASTImportError::UnsupportedConstruct);
 }
 
 // Check a case when a new AST node is created and linked to the AST before
 // encountering the error. The error is set for the counterpart of the nodes in
 // the "from" context.
 TEST_P(ErrorHandlingTest, ErrorHappensAfterNodeIsCreatedAndLinked) {
   TranslationUnitDecl *FromTU = getTuDecl(std::string(R"(
       void f();
EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, functionDecl(hasName("f"))),
             1u);
   // Match the fwd decl.
   auto *ToProto =
       FirstDeclMatcher<FunctionDecl>().match(ToTU, functionDecl(hasName("f")));
   EXPECT_TRUE(ToProto);
   // An error is set to the counterpart in the "from" context both for the fwd
   // decl and the definition.
   ASTImporter *Importer = findFromTU(FromProto)->Importer.get();
-  Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromProto);
+  Optional<ASTImportError> OptErr =
+      Importer->getImportDeclErrorIfAny(FromProto);
   ASSERT_TRUE(OptErr);
-  EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
+  EXPECT_EQ(OptErr->Error, ASTImportError::UnsupportedConstruct);
   OptErr = Importer->getImportDeclErrorIfAny(FromDef);
   ASSERT_TRUE(OptErr);
-  EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
+  EXPECT_EQ(OptErr->Error, ASTImportError::UnsupportedConstruct);
 }
 
 // An error should be set for a class if we cannot import one member.
 TEST_P(ErrorHandlingTest, ErrorIsPropagatedFromMemberToClass) {
   TranslationUnitDecl *FromTU = getTuDecl(std::string(R"(
       class X {
         void f() { )") + ErroneousStmt + R"( } // This member has the error
                                                // during import.
         void ok();        // The error should not prevent importing this.
       };                  // An error will be set for X too.
       )",
                                           Lang_CXX03);
   auto *FromX = FirstDeclMatcher<CXXRecordDecl>().match(
       FromTU, cxxRecordDecl(hasName("X")));
   CXXRecordDecl *ImportedX = Import(FromX, Lang_CXX03);
 
   // An error is set for X.
   EXPECT_FALSE(ImportedX);
   ASTImporter *Importer = findFromTU(FromX)->Importer.get();
-  Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromX);
+  Optional<ASTImportError> OptErr = Importer->getImportDeclErrorIfAny(FromX);
   ASSERT_TRUE(OptErr);
-  EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
+  EXPECT_EQ(OptErr->Error, ASTImportError::UnsupportedConstruct);
 
   // An error is set for f().
   auto *FromF = FirstDeclMatcher<CXXMethodDecl>().match(
       FromTU, cxxMethodDecl(hasName("f")));
   OptErr = Importer->getImportDeclErrorIfAny(FromF);
   ASSERT_TRUE(OptErr);
-  EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
+  EXPECT_EQ(OptErr->Error, ASTImportError::UnsupportedConstruct);
   // And any subsequent import should fail.
   CXXMethodDecl *ImportedF = Import(FromF, Lang_CXX03);
   EXPECT_FALSE(ImportedF);
 
   // There is an error set for the other member too.
   auto *FromOK = FirstDeclMatcher<CXXMethodDecl>().match(
       FromTU, cxxMethodDecl(hasName("ok")));
   OptErr = Importer->getImportDeclErrorIfAny(FromOK);
TEST_P(ErrorHandlingTest, ErrorPropagatesThroughImportCycles) {
   EXPECT_FALSE(Import(FromA, Lang_CXX03));
   // But we should be able to import the independent B.
   EXPECT_TRUE(Import(FromB, Lang_CXX03));
   // And the namespace.
   EXPECT_TRUE(Import(FromNS, Lang_CXX03));
 
   // An error is set to the templated CXXRecordDecl of F.
   ASTImporter *Importer = findFromTU(FromFRD)->Importer.get();
-  Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromFRD);
+  Optional<ASTImportError> OptErr = Importer->getImportDeclErrorIfAny(FromFRD);
   EXPECT_TRUE(OptErr);
 
   // An error is set to A.
   OptErr = Importer->getImportDeclErrorIfAny(FromA);
   EXPECT_TRUE(OptErr);
 
   // There is no error set to B.
   OptErr = Importer->getImportDeclErrorIfAny(FromB);
TranslationUnitDecl *FromTU = getTuDecl(std::string(R"(
                                           Lang_CXX03);
   auto *FromX = FirstDeclMatcher<NamespaceDecl>().match(
       FromTU, namespaceDecl(hasName("X")));
   NamespaceDecl *ImportedX = Import(FromX, Lang_CXX03);
 
   // There is no error set for X.
   EXPECT_TRUE(ImportedX);
   ASTImporter *Importer = findFromTU(FromX)->Importer.get();
-  Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromX);
+  Optional<ASTImportError> OptErr = Importer->getImportDeclErrorIfAny(FromX);
   ASSERT_FALSE(OptErr);
 
   // An error is set for f().
   auto *FromF = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("f")));
   OptErr = Importer->getImportDeclErrorIfAny(FromF);
   ASSERT_TRUE(OptErr);
-  EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
+  EXPECT_EQ(OptErr->Error, ASTImportError::UnsupportedConstruct);
   // And any subsequent import should fail.
   FunctionDecl *ImportedF = Import(FromF, Lang_CXX03);
   EXPECT_FALSE(ImportedF);
 
   // There is no error set for ok().
   auto *FromOK = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("ok")));
   OptErr = Importer->getImportDeclErrorIfAny(FromOK);
TranslationUnitDecl *FromTU = getTuDecl(std::string(R"(
                                             Lang_CXX03);
     auto *FromX = FirstDeclMatcher<CXXRecordDecl>().match(
         FromTU, cxxRecordDecl(hasName("X")));
     CXXRecordDecl *ImportedX = Import(FromX, Lang_CXX03);
 
     // An error is set for X ...
     EXPECT_FALSE(ImportedX);
     ASTImporter *Importer = findFromTU(FromX)->Importer.get();
-    Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromX);
+    Optional<ASTImportError> OptErr = Importer->getImportDeclErrorIfAny(FromX);
     ASSERT_TRUE(OptErr);
-    EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
+    EXPECT_EQ(OptErr->Error, ASTImportError::UnsupportedConstruct);
   }
   // ... but the node had been created.
   auto *ToXDef = FirstDeclMatcher<CXXRecordDecl>().match(
       ToTU, cxxRecordDecl(hasName("X"), isDefinition()));
   // An error is set for "ToXDef" in the shared state.
-  Optional<ImportError> OptErr =
+  Optional<ASTImportError> OptErr =
       SharedStatePtr->getImportDeclErrorIfAny(ToXDef);
   ASSERT_TRUE(OptErr);
-  EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
+  EXPECT_EQ(OptErr->Error, ASTImportError::UnsupportedConstruct);
 
   auto *ToXFwd = FirstDeclMatcher<CXXRecordDecl>().match(
       ToTU, cxxRecordDecl(hasName("X"), unless(isDefinition())));
   // An error is NOT set for the fwd Decl of X in the shared state.
   OptErr = SharedStatePtr->getImportDeclErrorIfAny(ToXFwd);
   ASSERT_FALSE(OptErr);
 
   // Try to import  X again but from another TU.
// Try to import  X again but from another TU.
     // definition in the "to" context. We can reach the existing definition via
     // the found fwd Decl. That existing definition is structurally equivalent
     // (we check only the fields) with this one we want to import, so we return
     // with the existing definition, which is erroneous (one method is missing).
 
     // The import should fail.
     EXPECT_FALSE(ImportedX);
     ASTImporter *Importer = findFromTU(FromX)->Importer.get();
-    Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromX);
+    Optional<ASTImportError> OptErr = Importer->getImportDeclErrorIfAny(FromX);
     // And an error is set for this new X in the "from" ctx.
     ASSERT_TRUE(OptErr);
-    EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
+    EXPECT_EQ(OptErr->Error, ASTImportError::UnsupportedConstruct);
   }
 }
 
 TEST_P(ErrorHandlingTest, ImportOfOverriddenMethods) {
   auto MatchFooA =
       functionDecl(hasName("foo"), hasAncestor(cxxRecordDecl(hasName("A"))));
   auto MatchFooB =
       functionDecl(hasName("foo"), hasAncestor(cxxRecordDecl(hasName("B"))));
TranslationUnitDecl *FromTU = getTuDecl(std::string(R"(
                                           Lang_CXX11);
   auto *FromFooA = FirstDeclMatcher<FunctionDecl>().match(FromTU, MatchFooA);
   auto *FromFooB = FirstDeclMatcher<FunctionDecl>().match(FromTU, MatchFooB);
   auto *FromFooC = FirstDeclMatcher<FunctionDecl>().match(FromTU, MatchFooC);
 
   EXPECT_FALSE(Import(FromFooA, Lang_CXX11));
   ASTImporter *Importer = findFromTU(FromFooA)->Importer.get();
   auto CheckError = [&Importer](Decl *FromD) {
-    Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromD);
+    Optional<ASTImportError> OptErr = Importer->getImportDeclErrorIfAny(FromD);
     ASSERT_TRUE(OptErr);
-    EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
+    EXPECT_EQ(OptErr->Error, ASTImportError::UnsupportedConstruct);
   };
   CheckError(FromFooA);
   EXPECT_FALSE(Import(FromFooB, Lang_CXX11));
   CheckError(FromFooB);
   EXPECT_FALSE(Import(FromFooC, Lang_CXX11));
   CheckError(FromFooC);
 }