[ASTImporter] Change the return result of Decl import to Optional

[a_sidorin]

Summary

This is a small step to simplify ASTImporter internals and make them more robust. As it was discussed in the mailing lists, the following changes are included:

• Introduced helper methods importNonNull() and importNullable() with LLVM_NODISCARD attribute. These methods are used to avoid redundant casting and to simplify checks for import return result. LLVM_NODISCARD will also print a warning every time a return result of import is unchecked.
• The return result of Import*Decl() methods is changed to Optional<Decl *>. The value of nullptr doesn't signal an error anymore (as it should be); None object are used instead in case of import failure. I hope that the need for dereferencing the result will remind about the need to check it first.
• ASTimporter and its clients are changed to use the new API. The patch for LLDB is coming soon. Some unchecked imports were found and fixed.

Unfortunately, the patch became very big. However, most changes are same. The code became a bit smaller and, as it looks to me, a bit more readable.

[balazske]

This change is in conflict with our similar patch to introduce error handling in ASTImporter. That patch would be a much bigger one, because (almost) every import can fail, return of every Import (not only Decl) is changed from X to Expected<X>. After every import (inside the import functions too) the result needs to be checked always for error.

[martong]

Hi Aleksei,

Thank you for this patch.
With Balazs, we are working on something similar, but with a different, fine grained error value mechanism. Unfortunately we were not aware of that you have been working on error handling, and we didn't say that we are working on error handling recently, I am terribly sorry about this.

From the CSA perspective, we realized that there may be several different error cases which has to be handled differently in CrossTranslationUnit.cpp.
For example, there are unsupported constructs which we do not support to import (like a struct definition as a parameter of a function).
Another example is when there is a name conflict between the decl in the "From" context and the decl in the "To" context, this usually means an ODR error.
We have to handle these errors in a different way after we imported one function during CTU analysis.
The fact that there may be more than one kind of errors yields for the use of the designated LLVM types: Error and Expected<T>. A simple Optional is probably not generic enough.

I find the importNonNull and generally the new family of import functions useful, but I am not sure how they could cooperate with Expected<T>. Especially, I have some concerns with output parameters.
If we have an Expected<T> as a result type, then there is no way to acquire the T if there was an error. However, when we have output parameters, then even if there was an error some output params could have been set ... and those can be reused even after the return. If error handling is not proper on the callee site then we may continue with stale values, which is not possible if we use Expected<T> as a return value.

Do you think we can hold back this patch for a few days until Balazs prepares the Expected<T> based version? Then I think we could compare the patches and we could merge the best from the two of them.

[martong]

Do you think we can hold back this patch for a few days until Balazs prepares the Expected<T> based version? Then I think we could compare the patches and we could merge the best from the two of them.

I mean, once Balazs is also ready, then we can create a combined patch which holds the good things from both of yours and his patches.

[martong]

Roughly, this is the direction where we are heading with Expected<T>:
https://github.com/Ericsson/clang/pull/457/commits/783b7f5cce9de589a5c3c3ae983398cf499077ec

(If you are interested, here is our whole thought process:
https://github.com/Ericsson/clang/pull/457)

[a_sidorin]

Hello Gabor and Balazs,

With Balazs, we are working on something similar, but with a different, fine grained error value mechanism. Unfortunately we were not aware of that you have been working on error handling, and we didn't say that we are working on error handling recently, I am terribly sorry about this.

That's a bit disappointing because I was thinking that the status of error handling strategy discussion and implementation is reflected in the mailing list. But well, let's think what we can do about this.

From the CSA perspective, we realized that there may be several different error cases which has to be handled differently in CrossTranslationUnit.cpp.
For example, there are unsupported constructs which we do not support to import (like a struct definition as a parameter of a function).
Another example is when there is a name conflict between the decl in the "From" context and the decl in the "To" context, this usually means an ODR error.
We have to handle these errors in a different way after we imported one function during CTU analysis.
The fact that there may be more than one kind of errors yields for the use of the designated LLVM types: Error and Expected<T>. A simple Optional is probably not generic enough.

Yes, I was thinking about it too. The reason why I chose Optional was that ASTImporter clients don't use the error kind. If you have any plans on changing this, Expected is a preferred approach.

I find the importNonNull and generally the new family of import functions useful, but I am not sure how they could cooperate with Expected<T>. Especially, I have some concerns with output parameters.
If we have an Expected<T> as a result type, then there is no way to acquire the T if there was an error. However, when we have output parameters, then even if there was an error some output params could have been set ... and those can be reused even after the return. If error handling is not proper on the callee site then we may continue with stale values, which is not possible if we use Expected<T> as a return value.

If I understand you correctly, importNonNull and importNullable should work with Expected pretty well. Changing import*Into return result to Error can partially help in avoiding usage of an unchecked result. These functions already guarantee that their parameters are changed only if the internal import was successful.

Do you think we can hold back this patch for a few days until Balazs prepares the Expected<T> based version? Then I think we could compare the patches and we could merge the best from the two of them.

Sure.

[martong]

Yes, I was thinking about it too. The reason why I chose Optional was that ASTImporter clients don't use the error kind. If you have any plans on changing this, Expected is a preferred approach.

Yes, we plan to submit a patch to LLDB too which would apply the use of Expected<T>.

If I understand you correctly, importNonNull and importNullable should work with Expected pretty well.

Yes, that's right.

Changing import*Into return result to Error can partially help in avoiding usage of an unchecked result. These functions already guarantee that their parameters are changed only if the internal import was successful.

Yes I agree, that Error can help, and I also agree that this help is just partial.
If we change importNonNullInto to has an Error return value

template <typename DeclTy>
LLVM_NODISCARD Error importNonNullInto(DeclTy *&ToD, Decl *FromD) {
  if (auto Res = Importer.Import(FromD)) {
    ToD = cast<DeclTy>(*Res);
    return make_error<SomeError>();
  }
  return Error::success();
}

then on the call site, on the branch where whe handle the error we may make mistakes like this:

CXXRecordDecl *ToTemplated = nullptr;
if (Err = importNonNullInto(ToTemplated, FromTemplated)) {
  foo(ToTemplated->hasDefinition()); // Undefined Behaviour!
  return Err;
}

If we do not use output parameters, only Expected<T>, then this could not happen.
Expected<T>.get() aborts if there was an error.

[martong]

Here is the Expected<T> based patch: https://reviews.llvm.org/D51633

[a_sidorin]

Another version has been committed (D51633).

include/clang/AST/ASTImporter.h

public:
     /// \returns the equivalent attribute in the "to" context.
     Attr *Import(const Attr *FromAttr);
 
     /// Import the given declaration from the "from" context into the
     /// "to" context.
     ///
     /// \returns the equivalent declaration in the "to" context, or a NULL type
     /// if an error occurred.
-    Decl *Import(Decl *FromD);
-    Decl *Import(const Decl *FromD) {
+    Optional<Decl *> Import(Decl *FromD);
+    Optional<Decl *> Import(const Decl *FromD) {
       return Import(const_cast<Decl *>(FromD));
     }
 
+    template <typename T> Optional<T *> importNonNull(T *From) {
+      if (auto Imported = Import(From))
+        return cast<T>(*Imported);
+      return None;
+    }
+
+    template <typename T> Optional<T *> importNullable(T *From) {
+      if (auto Imported = Import(From))
+        return cast_or_null<T>(*Imported);
+      return None;
+    }
+
     /// Return the copy of the given declaration in the "to" context if
     /// it has already been imported from the "from" context.  Otherwise return
     /// NULL.
     Decl *GetAlreadyImportedOrNull(Decl *FromD);
 
     /// Import the given declaration context from the "from"
     /// AST context into the "to" AST context.
     ///

lib/AST/ASTImporter.cpp

for (auto *R : D->getFirstDecl()->redecls()) {
       if (R != D->getFirstDecl())
         Redecls.push_back(R);
     }
     Redecls.push_back(D->getFirstDecl());
     std::reverse(Redecls.begin(), Redecls.end());
     return Redecls;
   }
 
-  SmallVector<Decl*, 2> getCanonicalForwardRedeclChain(Decl* D) {
+  SmallVector<Decl *, 2> getCanonicalForwardRedeclChain(Decl* D) {
     // Currently only FunctionDecl is supported
     auto FD = cast<FunctionDecl>(D);
     return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
   }
 
   void updateFlags(const Decl *From, Decl *To) {
     // Check if some flags or attrs are new in 'From' and copy into 'To'.
     // FIXME: Other flags or attrs?
     if (From->isUsed(false) && !To->isUsed(false))
       To->setIsUsed();
   }
 
+  using OptionalDecl = Optional<Decl *>;
+
   class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType>,
-                          public DeclVisitor<ASTNodeImporter, Decl *>,
+                          public DeclVisitor<ASTNodeImporter, OptionalDecl>,
                           public StmtVisitor<ASTNodeImporter, Stmt *> {
     ASTImporter &Importer;
 
     // Wrapper for an overload set.
     template <typename ToDeclT> struct CallOverloadedCreateFun {
       template <typename... Args>
       auto operator()(Args &&... args)
           -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
void InitializeImportedDecl(Decl *FromD, Decl *ToD) {
       if (FromD->isImplicit())
         ToD->setImplicit();
     }
 
   public:
     explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) {}
 
     using TypeVisitor<ASTNodeImporter, QualType>::Visit;
-    using DeclVisitor<ASTNodeImporter, Decl *>::Visit;
+    using DeclVisitor<ASTNodeImporter, OptionalDecl>::Visit;
     using StmtVisitor<ASTNodeImporter, Stmt *>::Visit;
 
     // Importing types
     QualType VisitType(const Type *T);
     QualType VisitAtomicType(const AtomicType *T);
     QualType VisitBuiltinType(const BuiltinType *T);
     QualType VisitDecayedType(const DecayedType *T);
     QualType VisitComplexType(const ComplexType *T);
public:
 
     // Importing declarations
     bool ImportDeclParts(NamedDecl *D, DeclContext *&DC,
                          DeclContext *&LexicalDC, DeclarationName &Name,
                          NamedDecl *&ToD, SourceLocation &Loc);
     void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
     void ImportDeclarationNameLoc(const DeclarationNameInfo &From,
                                   DeclarationNameInfo& To);
-    void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
+    LLVM_NODISCARD bool ImportDeclContext(DeclContext *FromDC,
+                                          bool ForceImport = false);
     void ImportImplicitMethods(const CXXRecordDecl *From, CXXRecordDecl *To);
 
     bool ImportCastPath(CastExpr *E, CXXCastPath &Path);
 
     using Designator = DesignatedInitExpr::Designator;
 
     Designator ImportDesignator(const Designator &D);
 
enum ImportDefinitionKind {
       IDK_Basic
     };
 
     bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
       return IDK == IDK_Everything ||
              (IDK == IDK_Default && !Importer.isMinimalImport());
     }
 
+    LLVM_NODISCARD bool setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To);
+
     bool ImportDefinition(RecordDecl *From, RecordDecl *To,
                           ImportDefinitionKind Kind = IDK_Default);
     bool ImportDefinition(VarDecl *From, VarDecl *To,
                           ImportDefinitionKind Kind = IDK_Default);
     bool ImportDefinition(EnumDecl *From, EnumDecl *To,
                           ImportDefinitionKind Kind = IDK_Default);
     bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
                           ImportDefinitionKind Kind = IDK_Default);
bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
                            bool Complain = true);
     bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
     bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
     bool IsStructuralMatch(FunctionTemplateDecl *From,
                            FunctionTemplateDecl *To);
     bool IsStructuralMatch(FunctionDecl *From, FunctionDecl *To);
     bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
     bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
-    Decl *VisitDecl(Decl *D);
-    Decl *VisitEmptyDecl(EmptyDecl *D);
-    Decl *VisitAccessSpecDecl(AccessSpecDecl *D);
-    Decl *VisitStaticAssertDecl(StaticAssertDecl *D);
-    Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D);
-    Decl *VisitNamespaceDecl(NamespaceDecl *D);
-    Decl *VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
-    Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
-    Decl *VisitTypedefDecl(TypedefDecl *D);
-    Decl *VisitTypeAliasDecl(TypeAliasDecl *D);
-    Decl *VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
-    Decl *VisitLabelDecl(LabelDecl *D);
-    Decl *VisitEnumDecl(EnumDecl *D);
-    Decl *VisitRecordDecl(RecordDecl *D);
-    Decl *VisitEnumConstantDecl(EnumConstantDecl *D);
-    Decl *VisitFunctionDecl(FunctionDecl *D);
-    Decl *VisitCXXMethodDecl(CXXMethodDecl *D);
-    Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D);
-    Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D);
-    Decl *VisitCXXConversionDecl(CXXConversionDecl *D);
-    Decl *VisitFieldDecl(FieldDecl *D);
-    Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D);
-    Decl *VisitFriendDecl(FriendDecl *D);
-    Decl *VisitObjCIvarDecl(ObjCIvarDecl *D);
-    Decl *VisitVarDecl(VarDecl *D);
-    Decl *VisitImplicitParamDecl(ImplicitParamDecl *D);
-    Decl *VisitParmVarDecl(ParmVarDecl *D);
-    Decl *VisitObjCMethodDecl(ObjCMethodDecl *D);
-    Decl *VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
-    Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D);
-    Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D);
-    Decl *VisitLinkageSpecDecl(LinkageSpecDecl *D);
-    Decl *VisitUsingDecl(UsingDecl *D);
-    Decl *VisitUsingShadowDecl(UsingShadowDecl *D);
-    Decl *VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
-    Decl *VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
-    Decl *VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
+    OptionalDecl VisitDecl(Decl *D);
+    OptionalDecl VisitEmptyDecl(EmptyDecl *D);
+    OptionalDecl VisitAccessSpecDecl(AccessSpecDecl *D);
+    OptionalDecl VisitStaticAssertDecl(StaticAssertDecl *D);
+    OptionalDecl VisitTranslationUnitDecl(TranslationUnitDecl *D);
+    OptionalDecl VisitNamespaceDecl(NamespaceDecl *D);
+    OptionalDecl VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
+    OptionalDecl VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
+    OptionalDecl VisitTypedefDecl(TypedefDecl *D);
+    OptionalDecl VisitTypeAliasDecl(TypeAliasDecl *D);
+    OptionalDecl VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
+    OptionalDecl VisitLabelDecl(LabelDecl *D);
+    OptionalDecl VisitEnumDecl(EnumDecl *D);
+    OptionalDecl VisitRecordDecl(RecordDecl *D);
+    OptionalDecl VisitEnumConstantDecl(EnumConstantDecl *D);
+    OptionalDecl VisitFunctionDecl(FunctionDecl *D);
+    OptionalDecl VisitCXXMethodDecl(CXXMethodDecl *D);
+    OptionalDecl VisitCXXConstructorDecl(CXXConstructorDecl *D);
+    OptionalDecl VisitCXXDestructorDecl(CXXDestructorDecl *D);
+    OptionalDecl VisitCXXConversionDecl(CXXConversionDecl *D);
+    OptionalDecl VisitFieldDecl(FieldDecl *D);
+    OptionalDecl VisitIndirectFieldDecl(IndirectFieldDecl *D);
+    OptionalDecl VisitFriendDecl(FriendDecl *D);
+    OptionalDecl VisitObjCIvarDecl(ObjCIvarDecl *D);
+    OptionalDecl VisitVarDecl(VarDecl *D);
+    OptionalDecl VisitImplicitParamDecl(ImplicitParamDecl *D);
+    OptionalDecl VisitParmVarDecl(ParmVarDecl *D);
+    OptionalDecl VisitObjCMethodDecl(ObjCMethodDecl *D);
+    OptionalDecl VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
+    OptionalDecl VisitObjCCategoryDecl(ObjCCategoryDecl *D);
+    OptionalDecl VisitObjCProtocolDecl(ObjCProtocolDecl *D);
+    OptionalDecl VisitLinkageSpecDecl(LinkageSpecDecl *D);
+    OptionalDecl VisitUsingDecl(UsingDecl *D);
+    OptionalDecl VisitUsingShadowDecl(UsingShadowDecl *D);
+    OptionalDecl VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
+    OptionalDecl VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
+    OptionalDecl
+    VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
 
     ObjCTypeParamList *ImportObjCTypeParamList(ObjCTypeParamList *list);
-    Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
-    Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
-    Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D);
-    Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D);
-    Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
-    Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
-    Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
-    Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
-    Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
-    Decl *VisitClassTemplateSpecializationDecl(
-                                            ClassTemplateSpecializationDecl *D);
-    Decl *VisitVarTemplateDecl(VarTemplateDecl *D);
-    Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
-    Decl *VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
+    OptionalDecl VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
+    OptionalDecl VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
+    OptionalDecl VisitObjCImplementationDecl(ObjCImplementationDecl *D);
+    OptionalDecl VisitObjCPropertyDecl(ObjCPropertyDecl *D);
+    OptionalDecl VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
+    OptionalDecl VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
+    OptionalDecl VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
+    OptionalDecl VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
+    OptionalDecl VisitClassTemplateDecl(ClassTemplateDecl *D);
+    OptionalDecl
+    VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D);
+    OptionalDecl VisitVarTemplateDecl(VarTemplateDecl *D);
+    OptionalDecl
+    VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
+    OptionalDecl VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
 
     // Importing statements
-    DeclGroupRef ImportDeclGroup(DeclGroupRef DG);
+    Optional<DeclGroupRef> ImportDeclGroup(DeclGroupRef DG);
 
     Stmt *VisitStmt(Stmt *S);
     Stmt *VisitGCCAsmStmt(GCCAsmStmt *S);
     Stmt *VisitDeclStmt(DeclStmt *S);
     Stmt *VisitNullStmt(NullStmt *S);
     Stmt *VisitCompoundStmt(CompoundStmt *S);
     Stmt *VisitCaseStmt(CaseStmt *S);
     Stmt *VisitDefaultStmt(DefaultStmt *S);
void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin) {
 
       ASTImporter &ImporterRef = Importer;
       std::transform(Ibegin, Iend, Obegin,
                      [&ImporterRef](ItemT From) -> ItemT {
                        return ImporterRef.Import(From);
                      });
     }
 
-    template<typename IIter, typename OIter>
-    bool ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
+    template <typename T>
+    using ImportResType =
+        decltype(std::declval<ASTImporter>().Import(std::declval<T>()));
+
+    template <typename ItemT, typename ImportResT,
+              typename std::enable_if<std::is_pointer<ImportResT>::value>::type
+                  * = nullptr>
+    ItemT *convert(bool &Failed, ItemT *From) {
+      if (auto To = Importer.Import(From))
+        return To;
+      Failed = true;
+      return nullptr;
+    }
+
+    template <typename ItemT, typename ImportResT,
+              typename std::enable_if<!std::is_pointer<ImportResT>::value>::type
+                  * = nullptr>
+    ItemT *convert(bool &Failed, ItemT *From) {
+      if (auto To = Importer.Import(From))
+        return cast_or_null<ItemT>(*To);
+      Failed = true;
+      return nullptr;
+    }
+
+    template <typename IIter, typename OIter>
+    LLVM_NODISCARD bool ImportArrayChecked(IIter Ibegin, IIter Iend,
+                                           OIter Obegin) {
       using ItemT = typename std::remove_reference<decltype(**Obegin)>::type;
+      using ImportResTy = ImportResType<ItemT *>;
 
-      ASTImporter &ImporterRef = Importer;
       bool Failed = false;
-      std::transform(Ibegin, Iend, Obegin,
-                     [&ImporterRef, &Failed](ItemT *From) -> ItemT * {
-                       auto *To = cast_or_null<ItemT>(ImporterRef.Import(From));
-                       if (!To && From)
-                         Failed = true;
-                       return To;
-                     });
+      std::transform(Ibegin, Iend, Obegin, [this, &Failed](ItemT *From) {
+        return convert<ItemT, ImportResTy>(Failed, From);
       return Failed;
     }
 
-    template<typename InContainerTy, typename OutContainerTy>
-    bool ImportContainerChecked(const InContainerTy &InContainer,
+    template <typename InContainerTy, typename OutContainerTy>
+    LLVM_NODISCARD bool ImportContainerChecked(const InContainerTy &InContainer,
                                                OutContainerTy &OutContainer) {
       return ImportArrayChecked(InContainer.begin(), InContainer.end(),
                                 OutContainer.begin());
     }
 
-    template<typename InContainerTy, typename OIter>
-    bool ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) {
+    template <typename InContainerTy, typename OIter>
+    LLVM_NODISCARD bool ImportArrayChecked(const InContainerTy &InContainer,
+                                           OIter Obegin) {
       return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin);
     }
 
     // Importing overrides.
-    void ImportOverrides(CXXMethodDecl *ToMethod, CXXMethodDecl *FromMethod);
+    LLVM_NODISCARD bool ImportOverrides(CXXMethodDecl *ToMethod,
+                                        CXXMethodDecl *FromMethod);
 
     FunctionDecl *FindFunctionTemplateSpecialization(FunctionDecl *FromFD);
+
+    /// Helper for importing Decls into variables.
+    template <typename DeclTy>
+    LLVM_NODISCARD bool importNullableInto(DeclTy *&ToD, Decl *FromD) {
+      if (auto Res = Importer.Import(FromD)) {
+        ToD = cast_or_null<DeclTy>(*Res);
+        return false;
+      }
+      return true;
+    }
+
+    template <typename DeclTy>
+    LLVM_NODISCARD bool importNonNullInto(DeclTy *&ToD, Decl *FromD) {
+      if (auto Res = Importer.Import(FromD)) {
+        ToD = cast<DeclTy>(*Res);
+        return false;
+      }
+      return true;
+    }
+
+    /// Helper for importing Decls as Optionals.
+    template <typename DeclTy>
+    Optional<DeclTy *> importNullable(DeclTy *FromD) {
+      return Importer.importNullable(FromD);
+    }
+
+    template <typename DeclTy>
+    Optional<DeclTy *> importNonNull(DeclTy *FromD) {
+      return Importer.importNonNull(FromD);
+    }
   };
 
 template <typename InContainerTy>
 bool ASTNodeImporter::ImportTemplateArgumentListInfo(
     SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
     const InContainerTy &Container, TemplateArgumentListInfo &Result) {
   TemplateArgumentListInfo ToTAInfo(Importer.Import(FromLAngleLoc),
                                     Importer.Import(FromRAngleLoc));

 }
 
 std::tuple<FunctionTemplateDecl *, ASTNodeImporter::OptionalTemplateArgsTy>
 ASTNodeImporter::ImportFunctionTemplateWithTemplateArgsFromSpecialization(
     FunctionDecl *FromFD) {
   assert(FromFD->getTemplatedKind() ==
          FunctionDecl::TK_FunctionTemplateSpecialization);
   auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
-  auto *Template = cast_or_null<FunctionTemplateDecl>(
-      Importer.Import(FTSInfo->getTemplate()));
+  auto Template = importNonNull(FTSInfo->getTemplate());
+  if (!Template)
+    return {nullptr, None};
 
   // Import template arguments.
   auto TemplArgs = FTSInfo->TemplateArguments->asArray();
   TemplateArgsTy ToTemplArgs;
   if (ImportTemplateArguments(TemplArgs.data(), TemplArgs.size(),
                               ToTemplArgs)) // Error during import.
-    return std::make_tuple(Template, OptionalTemplateArgsTy());
+    return {nullptr, None};
 
-  return std::make_tuple(Template, ToTemplArgs);
+  return std::make_tuple(*Template, ToTemplArgs);
 }
 
 } // namespace clang
 
 //----------------------------------------------------------------------------
 // Import Types
 //----------------------------------------------------------------------------
 
QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
   ToEPI.Variadic = FromEPI.Variadic;
   ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
   ToEPI.TypeQuals = FromEPI.TypeQuals;
   ToEPI.RefQualifier = FromEPI.RefQualifier;
   ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type;
   ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;
   ToEPI.ExceptionSpec.NoexceptExpr =
       Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr);
-  ToEPI.ExceptionSpec.SourceDecl = cast_or_null<FunctionDecl>(
-      Importer.Import(FromEPI.ExceptionSpec.SourceDecl));
-  ToEPI.ExceptionSpec.SourceTemplate = cast_or_null<FunctionDecl>(
-      Importer.Import(FromEPI.ExceptionSpec.SourceTemplate));
+
+  if (importNullableInto(ToEPI.ExceptionSpec.SourceDecl,
+                         FromEPI.ExceptionSpec.SourceDecl))
+    return {};
+
+  if (importNullableInto(ToEPI.ExceptionSpec.SourceTemplate,
+                         FromEPI.ExceptionSpec.SourceTemplate))
+    return {};
 
   return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
 }
 
 QualType ASTNodeImporter::VisitUnresolvedUsingType(
     const UnresolvedUsingType *T) {
-  const auto *ToD =
-      cast_or_null<UnresolvedUsingTypenameDecl>(Importer.Import(T->getDecl()));
-  if (!ToD)
-    return {};
-
-  auto *ToPrevD =
-      cast_or_null<UnresolvedUsingTypenameDecl>(
-        Importer.Import(T->getDecl()->getPreviousDecl()));
-  if (!ToPrevD && T->getDecl()->getPreviousDecl())
+  UnresolvedUsingTypenameDecl *ToD, *ToPrevD, *FromD = T->getDecl();
+  if (importNonNullInto(ToD, FromD) ||
+      importNullableInto(ToPrevD, FromD->getPreviousDecl()))
     return {};
 
   return Importer.getToContext().getTypeDeclType(ToD, ToPrevD);
 }
 
 QualType ASTNodeImporter::VisitParenType(const ParenType *T) {
   QualType ToInnerType = Importer.Import(T->getInnerType());
   if (ToInnerType.isNull())
     return {};
 
   return Importer.getToContext().getParenType(ToInnerType);
 }
 
 QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
-  auto *ToDecl =
-      dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
-  if (!ToDecl)
-    return {};
-
-  return Importer.getToContext().getTypeDeclType(ToDecl);
+  if (auto ToDecl = importNonNull(T->getDecl()))
+    return Importer.getToContext().getTypeDeclType(*ToDecl);
 }
 
 QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
   Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
   if (!ToExpr)
     return {};
 
   return Importer.getToContext().getTypeOfExprType(ToExpr);
QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
   }
 
   return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(),
                                              /*IsDependent*/false);
 }
 
 QualType ASTNodeImporter::VisitInjectedClassNameType(
     const InjectedClassNameType *T) {
-  auto *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl()));
-  if (!D)
+  auto ToD = importNonNull(T->getDecl());
+  if (!ToD)
     return {};
 
   QualType InjType = Importer.Import(T->getInjectedSpecializationType());
   if (InjType.isNull())
     return {};
 
   // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
   // See comments in InjectedClassNameType definition for details
   // return Importer.getToContext().getInjectedClassNameType(D, InjType);
   enum {
     TypeAlignmentInBits = 4,
     TypeAlignment = 1 << TypeAlignmentInBits
   };
 
   return QualType(new (Importer.getToContext(), TypeAlignment)
-                  InjectedClassNameType(D, InjType), 0);
+                  InjectedClassNameType(*ToD, InjType), 0);
 }
 
 QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
-  auto *ToDecl = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
-  if (!ToDecl)
-    return {};
-
-  return Importer.getToContext().getTagDeclType(ToDecl);
+  if (auto ToDecl = importNonNull(T->getDecl()))
+    return Importer.getToContext().getTagDeclType(*ToDecl);
 }
 
 QualType ASTNodeImporter::VisitEnumType(const EnumType *T) {
-  auto *ToDecl = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
-  if (!ToDecl)
-    return {};
-
-  return Importer.getToContext().getTagDeclType(ToDecl);
+  if (auto ToDecl = importNonNull(T->getDecl()))
+    return Importer.getToContext().getTagDeclType(*ToDecl);
 }
 
 QualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
   QualType FromModifiedType = T->getModifiedType();
   QualType FromEquivalentType = T->getEquivalentType();
   QualType ToModifiedType;
   QualType ToEquivalentType;
 
QualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
   }
 
   return Importer.getToContext().getAttributedType(T->getAttrKind(),
     ToModifiedType, ToEquivalentType);
 }
 
 QualType ASTNodeImporter::VisitTemplateTypeParmType(
     const TemplateTypeParmType *T) {
-  auto *ParmDecl =
-      cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl()));
-  if (!ParmDecl && T->getDecl())
-    return {};
-
+  if (auto ParmDecl = importNullable(T->getDecl()))
     return Importer.getToContext().getTemplateTypeParmType(
-        T->getDepth(), T->getIndex(), T->isParameterPack(), ParmDecl);
+        T->getDepth(), T->getIndex(), T->isParameterPack(), *ParmDecl);
+  return {};
 }
 
 QualType ASTNodeImporter::VisitSubstTemplateTypeParmType(
     const SubstTemplateTypeParmType *T) {
   const auto *Replaced =
       cast_or_null<TemplateTypeParmType>(Importer.Import(
         QualType(T->getReplacedParameter(), 0)).getTypePtr());
   if (!Replaced)
if (T->getQualifier()) {
     if (!ToQualifier)
       return {};
   }
 
   QualType ToNamedType = Importer.Import(T->getNamedType());
   if (ToNamedType.isNull())
     return {};
 
-  TagDecl *OwnedTagDecl =
-      cast_or_null<TagDecl>(Importer.Import(T->getOwnedTagDecl()));
-  if (!OwnedTagDecl && T->getOwnedTagDecl())
+  auto OwnedTagDecl = importNullable(T->getOwnedTagDecl());
+  if (!OwnedTagDecl)
     return {};
 
   return Importer.getToContext().getElaboratedType(T->getKeyword(),
                                                    ToQualifier, ToNamedType,
-                                                   OwnedTagDecl);
+                                                   *OwnedTagDecl);
 }
 
 QualType ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) {
   QualType Pattern = Importer.Import(T->getPattern());
   if (Pattern.isNull())
     return {};
 
   return Importer.getToContext().getPackExpansionType(Pattern,
QualType ASTNodeImporter::VisitDependentNameType(const DependentNameType *T) {
   if (!Canon.isNull())
     Canon = Canon.getCanonicalType();
 
   return Importer.getToContext().getDependentNameType(T->getKeyword(), NNS,
                                                       Name, Canon);
 }
 
 QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
-  auto *Class =
-      dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
-  if (!Class)
-    return {};
-
-  return Importer.getToContext().getObjCInterfaceType(Class);
+  if (auto Class = importNonNull(T->getDecl()))
+    return Importer.getToContext().getObjCInterfaceType(*Class);
 }
 
 QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
   QualType ToBaseType = Importer.Import(T->getBaseType());
   if (ToBaseType.isNull())
     return {};
 
   SmallVector<QualType, 4> TypeArgs;
   for (auto TypeArg : T->getTypeArgsAsWritten()) {
     QualType ImportedTypeArg = Importer.Import(TypeArg);
     if (ImportedTypeArg.isNull())
       return {};
 
     TypeArgs.push_back(ImportedTypeArg);
   }
 
-  SmallVector<ObjCProtocolDecl *, 4> Protocols;
-  for (auto *P : T->quals()) {
-    auto *Protocol = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
-    if (!Protocol)
-      return {};
-    Protocols.push_back(Protocol);
-  }
+  SmallVector<ObjCProtocolDecl *, 4> Protocols(T->getNumProtocols());
+  if (ImportContainerChecked(T->quals(), Protocols))
 
   return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs,
                                                    Protocols,
                                                    T->isKindOfTypeAsWritten());
 }
 
 QualType
 ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC,
   return false;
 }
 
 void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
   if (!FromD)
     return;
 
   if (!ToD) {
-    ToD = Importer.Import(FromD);
-    if (!ToD)
-      return;
+    if (auto ImportRes = importNonNull(FromD))
+      ToD = *ImportRes;
+    else
+      return; // FIXME: Return None
   }
 
   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);
       }
     }
case DeclarationName::CXXConversionFunctionName: {
     TypeSourceInfo *FromTInfo = From.getNamedTypeInfo();
     To.setNamedTypeInfo(Importer.Import(FromTInfo));
     return;
   }
   }
   llvm_unreachable("Unknown name kind.");
 }
 
-void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
+bool ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
   if (Importer.isMinimalImport() && !ForceImport) {
-    Importer.ImportContext(FromDC);
-    return;
+    if (FromDC && !Importer.ImportContext(FromDC))
+      return true;
+    return false;
   }
 
   for (auto *From : FromDC->decls())
-    Importer.Import(From);
+    if (!Importer.Import(From))
+      return true;
+
+  return false;
 }
 
 void ASTNodeImporter::ImportImplicitMethods(
     const CXXRecordDecl *From, CXXRecordDecl *To) {
   assert(From->isCompleteDefinition() && To->getDefinition() == To &&
       "Import implicit methods to or from non-definition");
 
   for (CXXMethodDecl *FromM : From->methods())
     if (FromM->isImplicit())
       Importer.Import(FromM);
 }
 
-static void setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To,
-                               ASTImporter &Importer) {
+bool ASTNodeImporter::setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To) {
   if (TypedefNameDecl *FromTypedef = From->getTypedefNameForAnonDecl()) {
-    auto *ToTypedef =
-      cast_or_null<TypedefNameDecl>(Importer.Import(FromTypedef));
-    assert (ToTypedef && "Failed to import typedef of an anonymous structure");
-
-    To->setTypedefNameForAnonDecl(ToTypedef);
+    if (auto ToTypedef = importNonNull(FromTypedef)) {
+      To->setTypedefNameForAnonDecl(*ToTypedef);
+      return false;
+    } else {
+      return true;
+    }
   }
+  return false;
 }
 
 bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To,
                                        ImportDefinitionKind Kind) {
   if (To->getDefinition() || To->isBeingDefined()) {
     if (Kind == IDK_Everything)
-      ImportDeclContext(From, /*ForceImport=*/true);
+      return ImportDeclContext(From, /*ForceImport=*/true);
 
     return false;
   }
 
   To->startDefinition();
 
-  setTypedefNameForAnonDecl(From, To, Importer);
+  if (setTypedefNameForAnonDecl(From, To))
+    return true;
   
   // Add base classes.
   if (auto *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
     auto *FromCXX = cast<CXXRecordDecl>(From);
 
     struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
     struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
     ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor;
     ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers;
for (const auto &Base1 : FromCXX->bases()) {
                                    Importer.Import(Base1.getTypeSourceInfo()),
                                        EllipsisLoc));
     }
     if (!Bases.empty())
       ToCXX->setBases(Bases.data(), Bases.size());
   }
 
   if (shouldForceImportDeclContext(Kind))
-    ImportDeclContext(From, /*ForceImport=*/true);
+    if (ImportDeclContext(From, /*ForceImport=*/true))
+      return true;
 
   To->completeDefinition();
   return false;
 }
 
 bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To,
                                        ImportDefinitionKind Kind) {
   if (To->getAnyInitializer())
     return false;
 
   // FIXME: Can we really import any initializer? Alternatively, we could force
   // ourselves to import every declaration of a variable and then only use
   // getInit() here.
   To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
 
   // FIXME: Other bits to merge?
 
   return false;
 }
 
 bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To,
                                        ImportDefinitionKind Kind) {
   if (To->getDefinition() || To->isBeingDefined()) {
     if (Kind == IDK_Everything)
-      ImportDeclContext(From, /*ForceImport=*/true);
+      return ImportDeclContext(From, /*ForceImport=*/true);
     return false;
   }
 
   To->startDefinition();
 
-  setTypedefNameForAnonDecl(From, To, Importer);
+  if (setTypedefNameForAnonDecl(From, To))
+    return true;
 
   QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
   if (T.isNull())
     return true;
 
   QualType ToPromotionType = Importer.Import(From->getPromotionType());
   if (ToPromotionType.isNull())
     return true;
 
   if (shouldForceImportDeclContext(Kind))
-    ImportDeclContext(From, /*ForceImport=*/true);
+    if (ImportDeclContext(From, /*ForceImport=*/true))
+      return true;
 
   // FIXME: we might need to merge the number of positive or negative bits
   // if the enumerator lists don't match.
   To->completeDefinition(T, ToPromotionType,
                          From->getNumPositiveBits(),
                          From->getNumNegativeBits());
   return false;
 }
ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
   case TemplateArgument::Integral: {
     QualType ToType = Importer.Import(From.getIntegralType());
     if (ToType.isNull())
       return {};
     return TemplateArgument(From, ToType);
   }
 
   case TemplateArgument::Declaration: {
-    auto *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
+    auto To = importNonNull(From.getAsDecl());
     QualType ToType = Importer.Import(From.getParamTypeForDecl());
     if (!To || ToType.isNull())
       return {};
-    return TemplateArgument(To, ToType);
+    return TemplateArgument(*To, ToType);
   }
 
   case TemplateArgument::NullPtr: {
     QualType ToType = Importer.Import(From.getNullPtrType());
     if (ToType.isNull())
       return {};
     return TemplateArgument(ToType, /*isNullPtr*/true);
   }
bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
                                         VarTemplateDecl *To) {
   StructuralEquivalenceContext Ctx(Importer.getFromContext(),
                                    Importer.getToContext(),
                                    Importer.getNonEquivalentDecls(),
                                    getStructuralEquivalenceKind(Importer));
   return Ctx.IsEquivalent(From, To);
 }
 
-Decl *ASTNodeImporter::VisitDecl(Decl *D) {
+OptionalDecl ASTNodeImporter::VisitDecl(Decl *D) {
   Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
     << D->getDeclKindName();
-  return nullptr;
+  return None;
 }
 
-Decl *ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) {
+OptionalDecl ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) {
   // Import the context of this declaration.
   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
   if (!DC)
-    return nullptr;
+    return None;
 
   DeclContext *LexicalDC = DC;
   if (D->getDeclContext() != D->getLexicalDeclContext()) {
     LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
     if (!LexicalDC)
-      return nullptr;
+      return None;
   }
 
   // Import the location of this declaration.
   SourceLocation Loc = Importer.Import(D->getLocation());
 
   EmptyDecl *ToD;
   if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, Loc))
     return ToD;
 
   ToD->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToD);
   return ToD;
 }
 
-Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
-  TranslationUnitDecl *ToD =
-    Importer.getToContext().getTranslationUnitDecl();
-
+OptionalDecl ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
+  TranslationUnitDecl *ToD = Importer.getToContext().getTranslationUnitDecl();
   Importer.MapImported(D, ToD);
-
   return ToD;
 }
 
-Decl *ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
+OptionalDecl ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
   SourceLocation Loc = Importer.Import(D->getLocation());
   SourceLocation ColonLoc = Importer.Import(D->getColonLoc());
 
   // Import the context of this declaration.
   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
   if (!DC)
-    return nullptr;
+    return None;
 
   AccessSpecDecl *ToD;
   if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), D->getAccess(),
                               DC, Loc, ColonLoc))
     return ToD;
 
   // Lexical DeclContext and Semantic DeclContext
   // is always the same for the accessSpec.
   ToD->setLexicalDeclContext(DC);
   DC->addDeclInternal(ToD);
 
   return ToD;
 }
 
-Decl *ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
+OptionalDecl ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
   if (!DC)
-    return nullptr;
+    return None;
 
   DeclContext *LexicalDC = DC;
 
   // Import the location of this declaration.
   SourceLocation Loc = Importer.Import(D->getLocation());
 
   Expr *AssertExpr = Importer.Import(D->getAssertExpr());
   if (!AssertExpr)
-    return nullptr;
+    return None;
 
   StringLiteral *FromMsg = D->getMessage();
   auto *ToMsg = cast_or_null<StringLiteral>(Importer.Import(FromMsg));
   if (!ToMsg && FromMsg)
-    return nullptr;
+    return None;
 
   StaticAssertDecl *ToD;
   if (GetImportedOrCreateDecl(
           ToD, D, Importer.getToContext(), DC, Loc, AssertExpr, ToMsg,
           Importer.Import(D->getRParenLoc()), D->isFailed()))
     return ToD;
 
   ToD->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToD);
   return ToD;
 }
 
-Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
+OptionalDecl ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
   // Import the major distinguishing characteristics of this namespace.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   NamespaceDecl *MergeWithNamespace = nullptr;
   if (!Name) {
     // This is an anonymous namespace. Adopt an existing anonymous
     // namespace if we can.
     // FIXME: Not testable.
if (!Name) {
       if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
         TU->setAnonymousNamespace(ToNamespace);
       else
         cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
     }
   }
   Importer.MapImported(D, ToNamespace);
 
-  ImportDeclContext(D);
+  if (ImportDeclContext(D))
+    return None;
 
   return ToNamespace;
 }
 
-Decl *ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
+OptionalDecl ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
   // Import the major distinguishing characteristics of this namespace.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *LookupD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc))
-    return nullptr;
+    return None;
   if (LookupD)
     return LookupD;
 
   // NOTE: No conflict resolution is done for namespace aliases now.
 
-  auto *TargetDecl = cast_or_null<NamespaceDecl>(
-      Importer.Import(D->getNamespace()));
+  auto TargetDecl = importNonNull(D->getNamespace());
   if (!TargetDecl)
-    return nullptr;
+    return None;
 
   IdentifierInfo *ToII = Importer.Import(D->getIdentifier());
   if (!ToII)
-    return nullptr;
+    return None;
 
   NestedNameSpecifierLoc ToQLoc = Importer.Import(D->getQualifierLoc());
   if (D->getQualifierLoc() && !ToQLoc)
-    return nullptr;
+    return None;
 
   NamespaceAliasDecl *ToD;
   if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC,
                               Importer.Import(D->getNamespaceLoc()),
                               Importer.Import(D->getAliasLoc()), ToII, ToQLoc,
                               Importer.Import(D->getTargetNameLoc()),
-                              TargetDecl))
+                              *TargetDecl))
     return ToD;
 
   ToD->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToD);
 
   return ToD;
 }
 
-Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
+OptionalDecl ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D,
+                                                   bool IsAlias) {
   // Import the major distinguishing characteristics of this typedef.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   // If this typedef is not in block scope, determine whether we've
   // seen a typedef with the same name (that we can merge with) or any
   // other entity by that name (which name lookup could conflict with).
   if (!DC->isFunctionOrMethod()) {
     SmallVector<NamedDecl *, 4> ConflictingDecls;
for (auto *FoundDecl : FoundDecls) {
       ConflictingDecls.push_back(FoundDecl);
     }
 
     if (!ConflictingDecls.empty()) {
       Name = Importer.HandleNameConflict(Name, DC, IDNS,
                                          ConflictingDecls.data(),
                                          ConflictingDecls.size());
       if (!Name)
-        return nullptr;
+        return None;
     }
   }
 
   // Import the underlying type of this typedef;
   QualType T = Importer.Import(D->getUnderlyingType());
   if (T.isNull())
-    return nullptr;
+    return None;
 
   // Create the new typedef node.
   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
   SourceLocation StartL = Importer.Import(D->getLocStart());
 
   TypedefNameDecl *ToTypedef;
   if (IsAlias) {
     if (GetImportedOrCreateDecl<TypeAliasDecl>(
OptionalDecl ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D,
   // Templated declarations should not appear in DeclContext.
   TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(D) : nullptr;
   if (!FromAlias || !FromAlias->getDescribedAliasTemplate())
     LexicalDC->addDeclInternal(ToTypedef);
 
   return ToTypedef;
 }
 
-Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
+OptionalDecl ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
   return VisitTypedefNameDecl(D, /*IsAlias=*/false);
 }
 
-Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
+OptionalDecl ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
   return VisitTypedefNameDecl(D, /*IsAlias=*/true);
 }
 
-Decl *ASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
+OptionalDecl
+ASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
   // Import the major distinguishing characteristics of this typedef.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *FoundD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, FoundD, Loc))
-    return nullptr;
+    return None;
   if (FoundD)
     return FoundD;
 
   // If this typedef is not in block scope, determine whether we've
   // seen a typedef with the same name (that we can merge with) or any
   // other entity by that name (which name lookup could conflict with).
   if (!DC->isFunctionOrMethod()) {
     SmallVector<NamedDecl *, 4> ConflictingDecls;
     unsigned IDNS = Decl::IDNS_Ordinary;
     SmallVector<NamedDecl *, 2> FoundDecls;
     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
     for (auto *FoundDecl : FoundDecls) {
       if (!FoundDecl->isInIdentifierNamespace(IDNS))
         continue;
       if (auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl))
         return Importer.MapImported(D, FoundAlias);
       ConflictingDecls.push_back(FoundDecl);
     }
 
     if (!ConflictingDecls.empty()) {
       Name = Importer.HandleNameConflict(Name, DC, IDNS,
                                          ConflictingDecls.data(),
                                          ConflictingDecls.size());
       if (!Name)
-        return nullptr;
+        return None;
     }
   }
 
   TemplateParameterList *Params = ImportTemplateParameterList(
         D->getTemplateParameters());
   if (!Params)
-    return nullptr;
+    return None;
 
-  auto *TemplDecl = cast_or_null<TypeAliasDecl>(
-        Importer.Import(D->getTemplatedDecl()));
+  auto TemplDecl = importNonNull(D->getTemplatedDecl());
   if (!TemplDecl)
-    return nullptr;
+    return None;
 
   TypeAliasTemplateDecl *ToAlias;
   if (GetImportedOrCreateDecl(ToAlias, D, Importer.getToContext(), DC, Loc,
-                              Name, Params, TemplDecl))
+                              Name, Params, *TemplDecl))
     return ToAlias;
 
-  TemplDecl->setDescribedAliasTemplate(ToAlias);
+  (*TemplDecl)->setDescribedAliasTemplate(ToAlias);
 
   ToAlias->setAccess(D->getAccess());
   ToAlias->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToAlias);
   return ToAlias;
 }
 
-Decl *ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
+OptionalDecl ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
   // Import the major distinguishing characteristics of this label.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   assert(LexicalDC->isFunctionOrMethod());
 
   LabelDecl *ToLabel;
   if (D->isGnuLocal()
           ? GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC,
                                     Importer.Import(D->getLocation()),
                                     Name.getAsIdentifierInfo(),
                                     Importer.Import(D->getLocStart()))
           : GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC,
                                     Importer.Import(D->getLocation()),
                                     Name.getAsIdentifierInfo()))
     return ToLabel;
 
   auto *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt()));
   if (!Label)
-    return nullptr;
+    return None;
 
   ToLabel->setStmt(Label);
   ToLabel->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToLabel);
   return ToLabel;
 }
 
-Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
+OptionalDecl ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
   // Import the major distinguishing characteristics of this enum.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   // Figure out what enum name we're looking for.
   unsigned IDNS = Decl::IDNS_Tag;
   DeclarationName SearchName = Name;
   if (!SearchName && D->getTypedefNameForAnonDecl()) {
     SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
OptionalDecl ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
   D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
   D2->setAccess(D->getAccess());
   D2->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(D2);
 
   // Import the integer type.
   QualType ToIntegerType = Importer.Import(D->getIntegerType());
   if (ToIntegerType.isNull())
-    return nullptr;
+    return None;
   D2->setIntegerType(ToIntegerType);
 
   // Import the definition
   if (D->isCompleteDefinition() && ImportDefinition(D, D2))
-    return nullptr;
+    return None;
 
   return D2;
 }
 
-Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
+OptionalDecl ASTNodeImporter::VisitRecordDecl(RecordDecl *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.
   TagDecl *Definition = D->getDefinition();
   if (Definition && Definition != D &&
       // In contrast to a normal CXXRecordDecl, the implicit
       // CXXRecordDecl of ClassTemplateSpecializationDecl is its redeclaration.
       // The definition of the implicit CXXRecordDecl in this case is the
       // ClassTemplateSpecializationDecl itself. Thus, we start with an extra
       // condition in order to be able to import the implict Decl.
       !D->isImplicit()) {
-    Decl *ImportedDef = Importer.Import(Definition);
+    auto ImportedDef = Importer.Import(Definition);
     if (!ImportedDef)
-      return nullptr;
+      return None;
 
-    return Importer.MapImported(D, ImportedDef);
+    return Importer.MapImported(D, *ImportedDef);
   }
 
   // Import the major distinguishing characteristics of this record.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   // Figure out what structure name we're looking for.
   unsigned IDNS = Decl::IDNS_Tag;
   DeclarationName SearchName = Name;
   if (!SearchName && D->getTypedefNameForAnonDecl()) {
     SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
if (!D2) {
     if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
       if (DCXX->isLambda()) {
         TypeSourceInfo *TInfo = Importer.Import(DCXX->getLambdaTypeInfo());
         if (GetImportedOrCreateSpecialDecl(
                 D2CXX, CXXRecordDecl::CreateLambda, D, Importer.getToContext(),
                 DC, TInfo, Loc, DCXX->isDependentLambda(),
                 DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
           return D2CXX;
-        Decl *CDecl = Importer.Import(DCXX->getLambdaContextDecl());
-        if (DCXX->getLambdaContextDecl() && !CDecl)
-          return nullptr;
-        D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), CDecl);
+        if (auto ToCDecl = importNullable(DCXX->getLambdaContextDecl()))
+          D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), *ToCDecl);
+        else
+          return None;
+
       } else if (DCXX->isInjectedClassName()) {
         // We have to be careful to do a similar dance to the one in
         // Sema::ActOnStartCXXMemberDeclarations
         CXXRecordDecl *const PrevDecl = nullptr;
         const bool DelayTypeCreation = true;
         if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(),
                                     D->getTagKind(), DC, StartLoc, Loc,
                                     Name.getAsIdentifierInfo(), PrevDecl,
                                     DelayTypeCreation))
           return D2CXX;
         Importer.getToContext().getTypeDeclType(
             D2CXX, dyn_cast<CXXRecordDecl>(DC));
       } else {
         if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(),
                                     D->getTagKind(), DC, StartLoc, Loc,
                                     Name.getAsIdentifierInfo(),
                                     cast_or_null<CXXRecordDecl>(PrevDecl)))
           return D2CXX;
       }
 
       D2 = D2CXX;
       D2->setAccess(D->getAccess());
       D2->setLexicalDeclContext(LexicalDC);
-      if (!DCXX->getDescribedClassTemplate() || DCXX->isImplicit())
+
+      auto *FromDescribed = DCXX->getDescribedClassTemplate();
+      if (!FromDescribed || DCXX->isImplicit())
         LexicalDC->addDeclInternal(D2);
 
-      if (ClassTemplateDecl *FromDescribed =
-          DCXX->getDescribedClassTemplate()) {
-        auto *ToDescribed = cast_or_null<ClassTemplateDecl>(
-            Importer.Import(FromDescribed));
+      if (FromDescribed) {
+        auto ToDescribed = importNonNull(FromDescribed);
         if (!ToDescribed)
-          return nullptr;
-        D2CXX->setDescribedClassTemplate(ToDescribed);
+          return None;
+
+        D2CXX->setDescribedClassTemplate(*ToDescribed);
+
         if (!DCXX->isInjectedClassName()) {
           // In a record describing a template the type should be an
           // InjectedClassNameType (see Sema::CheckClassTemplate). Update the
           // previously set type to the correct value here (ToDescribed is not
           // available at record create).
           // FIXME: The previous type is cleared but not removed from
           // ASTContext's internal storage.
           CXXRecordDecl *Injected = nullptr;
           for (NamedDecl *Found : D2CXX->noload_lookup(Name)) {
             auto *Record = dyn_cast<CXXRecordDecl>(Found);
             if (Record && Record->isInjectedClassName()) {
               Injected = Record;
               break;
             }
           }
           D2CXX->setTypeForDecl(nullptr);
           Importer.getToContext().getInjectedClassNameType(D2CXX,
-              ToDescribed->getInjectedClassNameSpecialization());
+              (*ToDescribed)->getInjectedClassNameSpecialization());
           if (Injected) {
             Injected->setTypeForDecl(nullptr);
             Importer.getToContext().getTypeDeclType(Injected, D2CXX);
           }
         }
-      } else if (MemberSpecializationInfo *MemberInfo =
-                   DCXX->getMemberSpecializationInfo()) {
-        TemplateSpecializationKind SK =
-            MemberInfo->getTemplateSpecializationKind();
-        CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass();
-        auto *ToInst =
-            cast_or_null<CXXRecordDecl>(Importer.Import(FromInst));
-        if (FromInst && !ToInst)
-          return nullptr;
-        D2CXX->setInstantiationOfMemberClass(ToInst, SK);
+
+      } else if (auto *MemberInfo = DCXX->getMemberSpecializationInfo()) {
+        auto SK = MemberInfo->getTemplateSpecializationKind();
+        auto ToInst = importNonNull(DCXX->getInstantiatedFromMemberClass());
+        if (!ToInst)
+          return None;
+
+        D2CXX->setInstantiationOfMemberClass(*ToInst, SK);
         D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation(
               Importer.Import(MemberInfo->getPointOfInstantiation()));
       }
+
     } else {
       if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(),
                                   D->getTagKind(), DC, StartLoc, Loc,
                                   Name.getAsIdentifierInfo(), PrevDecl))
         return D2;
       D2->setLexicalDeclContext(LexicalDC);
       LexicalDC->addDeclInternal(D2);
     }
 
     D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
     if (D->isAnonymousStructOrUnion())
       D2->setAnonymousStructOrUnion(true);
   }
 
   Importer.MapImported(D, D2);
 
   if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default))
-    return nullptr;
+    return None;
 
   return D2;
 }
 
-Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
+OptionalDecl ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
   // Import the major distinguishing characteristics of this enumerator.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   QualType T = Importer.Import(D->getType());
   if (T.isNull())
-    return nullptr;
+    return None;
 
   // Determine whether there are any other declarations with the same name and
   // in the same context.
   if (!LexicalDC->isFunctionOrMethod()) {
     SmallVector<NamedDecl *, 4> ConflictingDecls;
     unsigned IDNS = Decl::IDNS_Ordinary;
     SmallVector<NamedDecl *, 2> FoundDecls;
     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
for (auto *FoundDecl : FoundDecls) {
       ConflictingDecls.push_back(FoundDecl);
     }
 
     if (!ConflictingDecls.empty()) {
       Name = Importer.HandleNameConflict(Name, DC, IDNS,
                                          ConflictingDecls.data(),
                                          ConflictingDecls.size());
       if (!Name)
-        return nullptr;
+        return None;
     }
   }
 
   Expr *Init = Importer.Import(D->getInitExpr());
   if (D->getInitExpr() && !Init)
-    return nullptr;
+    return None;
 
   EnumConstantDecl *ToEnumerator;
   if (GetImportedOrCreateDecl(
           ToEnumerator, D, Importer.getToContext(), cast<EnumDecl>(DC), Loc,
           Name.getAsIdentifierInfo(), T, Init, D->getInitVal()))
     return ToEnumerator;
 
   ToEnumerator->setAccess(D->getAccess());
   ToEnumerator->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToEnumerator);
   return ToEnumerator;
 }
 
 bool ASTNodeImporter::ImportTemplateInformation(FunctionDecl *FromFD,
                                                 FunctionDecl *ToFD) {
   switch (FromFD->getTemplatedKind()) {
   case FunctionDecl::TK_NonTemplate:
   case FunctionDecl::TK_FunctionTemplate:
     return false;
 
   case FunctionDecl::TK_MemberSpecialization: {
-    auto *InstFD = cast_or_null<FunctionDecl>(
-          Importer.Import(FromFD->getInstantiatedFromMemberFunction()));
+    auto InstFD = importNonNull(FromFD->getInstantiatedFromMemberFunction());
     if (!InstFD)
       return true;
 
     TemplateSpecializationKind TSK = FromFD->getTemplateSpecializationKind();
     SourceLocation POI = Importer.Import(
           FromFD->getMemberSpecializationInfo()->getPointOfInstantiation());
-    ToFD->setInstantiationOfMemberFunction(InstFD, TSK);
+    ToFD->setInstantiationOfMemberFunction(*InstFD, TSK);
     ToFD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
     return false;
   }
 
   case FunctionDecl::TK_FunctionTemplateSpecialization: {
     FunctionTemplateDecl* Template;
     OptionalTemplateArgsTy ToTemplArgs;
     std::tie(Template, ToTemplArgs) =
case FunctionDecl::TK_FunctionTemplateSpecialization: {
     return false;
   }
 
   case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
     auto *FromInfo = FromFD->getDependentSpecializationInfo();
     UnresolvedSet<8> TemplDecls;
     unsigned NumTemplates = FromInfo->getNumTemplates();
     for (unsigned I = 0; I < NumTemplates; I++) {
-      if (auto *ToFTD = cast_or_null<FunctionTemplateDecl>(
-              Importer.Import(FromInfo->getTemplate(I))))
-        TemplDecls.addDecl(ToFTD);
+      if (auto ToFTD = importNonNull(FromInfo->getTemplate(I)))
+        TemplDecls.addDecl(*ToFTD);
       else
         return true;
     }
 
     // Import TemplateArgumentListInfo.
     TemplateArgumentListInfo ToTAInfo;
     if (ImportTemplateArgumentListInfo(
             FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(),
             llvm::makeArrayRef(FromInfo->getTemplateArgs(),
                                FromInfo->getNumTemplateArgs()),
             ToTAInfo))
       return true;
 
     ToFD->setDependentTemplateSpecialization(Importer.getToContext(),
                                              TemplDecls, ToTAInfo);
     return false;
   }
   }
   llvm_unreachable("All cases should be covered!");
 }
 
 FunctionDecl *
 ASTNodeImporter::FindFunctionTemplateSpecialization(FunctionDecl *FromFD) {
-  FunctionTemplateDecl* Template;
+  FunctionTemplateDecl *Template;
   OptionalTemplateArgsTy ToTemplArgs;
   std::tie(Template, ToTemplArgs) =
       ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
-  if (!Template || !ToTemplArgs)
+  if (!Template)
     return nullptr;
 
   void *InsertPos = nullptr;
   auto *FoundSpec = Template->findSpecialization(*ToTemplArgs, InsertPos);
   return FoundSpec;
 }
 
-Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
-
-  SmallVector<Decl*, 2> Redecls = getCanonicalForwardRedeclChain(D);
-  auto RedeclIt = Redecls.begin();
+OptionalDecl ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
+  SmallVector<Decl *, 2> Redecls = getCanonicalForwardRedeclChain(D);
+  auto RedeclIt = Redecls.begin(), RedeclsEnd = Redecls.end();
   // Import the first part of the decl chain. I.e. import all previous
   // declarations starting from the canonical decl.
-  for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt)
-    if (!Importer.Import(*RedeclIt))
+  for (; RedeclIt != RedeclsEnd && *RedeclIt != D; ++RedeclIt)
+    if (!importNonNull(*RedeclIt))
       return nullptr;
   assert(*RedeclIt == D);
 
   // Import the major distinguishing characteristics of this function.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   const FunctionDecl *FoundByLookup = nullptr;
   FunctionTemplateDecl *FromFT = D->getDescribedFunctionTemplate();
 
   // If this is a function template specialization, then try to find the same
   // existing specialization in the "to" context. The localUncachedLookup
for (auto *FoundDecl : FoundDecls) {
       ConflictingDecls.push_back(FoundDecl);
     }
 
     if (!ConflictingDecls.empty()) {
       Name = Importer.HandleNameConflict(Name, DC, IDNS,
                                          ConflictingDecls.data(),
                                          ConflictingDecls.size());
       if (!Name)
-        return nullptr;
-    }
+        return None;
+    }    
   }
 
   DeclarationNameInfo NameInfo(Name, Loc);
   // Import additional name location/type info.
   ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
 
   QualType FromTy = D->getType();
   bool usedDifferentExceptionSpec = false;
if (FromEPI.ExceptionSpec.SourceDecl ||
           FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI);
       usedDifferentExceptionSpec = true;
     }
   }
 
   // Import the type.
   QualType T = Importer.Import(FromTy);
   if (T.isNull())
-    return nullptr;
+    return None;
 
   // Import the function parameters.
-  SmallVector<ParmVarDecl *, 8> Parameters;
-  for (auto P : D->parameters()) {
-    auto *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
-    if (!ToP)
-      return nullptr;
-
-    Parameters.push_back(ToP);
-  }
+  SmallVector<ParmVarDecl *, 8> Parameters(D->getNumParams());
+  if (ImportContainerChecked(D->parameters(), Parameters))
+    return None;
 
   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
   if (D->getTypeSourceInfo() && !TInfo)
-    return nullptr;
+    return None;
 
   // Create the imported function.
   FunctionDecl *ToFunction = nullptr;
   SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart());
   if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
     if (GetImportedOrCreateDecl<CXXConstructorDecl>(
             ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
             InnerLocStart, NameInfo, T, TInfo, FromConstructor->isExplicit(),
             D->isInlineSpecified(), D->isImplicit(), D->isConstexpr()))
       return ToFunction;
     if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
-      SmallVector<CXXCtorInitializer *, 4> CtorInitializers;
-      for (auto *I : FromConstructor->inits()) {
-        auto *ToI = cast_or_null<CXXCtorInitializer>(Importer.Import(I));
-        if (!ToI && I)
-          return nullptr;
-        CtorInitializers.push_back(ToI);
-      }
+      SmallVector<CXXCtorInitializer *, 4> CtorInitializers(NumInitializers);
+      if (ImportContainerChecked(FromConstructor->inits(), CtorInitializers))
+        return None;
+
       auto **Memory =
           new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
       std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
       auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
       ToCtor->setCtorInitializers(Memory);
       ToCtor->setNumCtorInitializers(NumInitializers);
     }
   } else if (isa<CXXDestructorDecl>(D)) {
if (auto ProtoLoc =
         ProtoLoc.setParam(I, Parameters[I]);
     }
   }
 
   if (usedDifferentExceptionSpec) {
     // Update FunctionProtoType::ExtProtoInfo.
     QualType T = Importer.Import(D->getType());
     if (T.isNull())
-      return nullptr;
+      return None;
     ToFunction->setType(T);
   }
 
   // Import the describing template function, if any.
   if (FromFT)
     if (!Importer.Import(FromFT))
       return nullptr;
 
   if (D->doesThisDeclarationHaveABody()) {
     if (Stmt *FromBody = D->getBody()) {
       if (Stmt *ToBody = Importer.Import(FromBody)) {
         ToFunction->setBody(ToBody);
       }
     }
   }
 
   // FIXME: Other bits to merge?
 
   // If it is a template, import all related things.
   if (ImportTemplateInformation(D, ToFunction))
-    return nullptr;
+    return None;
 
   bool IsFriend = D->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend);
 
   // TODO Can we generalize this approach to other AST nodes as well?
   if (D->getDeclContext()->containsDeclAndLoad(D))
     DC->addDeclInternal(ToFunction);
   if (DC != LexicalDC && D->getLexicalDeclContext()->containsDeclAndLoad(D))
     LexicalDC->addDeclInternal(ToFunction);
OptionalDecl ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
   }
 
   // Import the rest of the chain. I.e. import all subsequent declarations.
   for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt)
     if (!Importer.Import(*RedeclIt))
       return nullptr;
 
   if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
-    ImportOverrides(cast<CXXMethodDecl>(ToFunction), FromCXXMethod);
+    if (ImportOverrides(cast<CXXMethodDecl>(ToFunction), FromCXXMethod))
+      return None;
 
   return ToFunction;
 }
 
-Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
+OptionalDecl ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
   return VisitFunctionDecl(D);
 }
 
-Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
+OptionalDecl ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
   return VisitCXXMethodDecl(D);
 }
 
-Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
+OptionalDecl ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
   return VisitCXXMethodDecl(D);
 }
 
-Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
+OptionalDecl ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
   return VisitCXXMethodDecl(D);
 }
 
 static unsigned getFieldIndex(Decl *F) {
   auto *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
   if (!Owner)
     return 0;
 
   unsigned Index = 1;
   for (const auto *D : Owner->noload_decls()) {
     if (D == F)
       return Index;
 
     if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
       ++Index;
   }
 
   return Index;
 }
 
-Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
+OptionalDecl ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
   // Import the major distinguishing characteristics of a variable.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   // Determine whether we've already imported this field.
   SmallVector<NamedDecl *, 2> FoundDecls;
   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
   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;
 
       if (Importer.IsStructurallyEquivalent(D->getType(),
                                             FoundField->getType())) {
         Importer.MapImported(D, FoundField);
         return FoundField;
       }
 
       Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
         << Name << D->getType() << FoundField->getType();
       Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
         << FoundField->getType();
-      return nullptr;
+      return None;
     }
   }
 
   // Import the type.
   QualType T = Importer.Import(D->getType());
   if (T.isNull())
-    return nullptr;
+    return None;
 
   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
   Expr *BitWidth = Importer.Import(D->getBitWidth());
   if (!BitWidth && D->getBitWidth())
-    return nullptr;
+    return None;
 
   FieldDecl *ToField;
   if (GetImportedOrCreateDecl(ToField, D, Importer.getToContext(), DC,
                               Importer.Import(D->getInnerLocStart()), Loc,
                               Name.getAsIdentifierInfo(), T, TInfo, BitWidth,
                               D->isMutable(), D->getInClassInitStyle()))
     return ToField;
 
   ToField->setAccess(D->getAccess());
   ToField->setLexicalDeclContext(LexicalDC);
   if (Expr *FromInitializer = D->getInClassInitializer()) {
     Expr *ToInitializer = Importer.Import(FromInitializer);
     if (ToInitializer)
       ToField->setInClassInitializer(ToInitializer);
     else
-      return nullptr;
+      return None;
   }
   ToField->setImplicit(D->isImplicit());
   LexicalDC->addDeclInternal(ToField);
   return ToField;
 }
 
-Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
+OptionalDecl ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
   // Import the major distinguishing characteristics of a variable.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   // 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 (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
if (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
       // If there are more anonymous fields to check, continue.
       if (!Name && I < N-1)
         continue;
 
       Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
         << Name << D->getType() << FoundField->getType();
       Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
         << FoundField->getType();
-      return nullptr;
+      return None;
     }
   }
 
   // Import the type.
   QualType T = Importer.Import(D->getType());
   if (T.isNull())
-    return nullptr;
+    return None;
 
   auto **NamedChain =
     new (Importer.getToContext()) NamedDecl*[D->getChainingSize()];
 
-  unsigned i = 0;
-  for (auto *PI : D->chain()) {
-    Decl *D = Importer.Import(PI);
-    if (!D)
-      return nullptr;
-    NamedChain[i++] = cast<NamedDecl>(D);
-  }
+  if (ImportArrayChecked(D->chain(), &NamedChain[0]))
+    return None;
 
   llvm::MutableArrayRef<NamedDecl *> CH = {NamedChain, D->getChainingSize()};
   IndirectFieldDecl *ToIndirectField;
   if (GetImportedOrCreateDecl(ToIndirectField, D, Importer.getToContext(), DC,
                               Loc, Name.getAsIdentifierInfo(), T, CH))
     // FIXME here we leak `NamedChain` which is allocated before
     return ToIndirectField;
 
   for (const auto *A : D->attrs())
     ToIndirectField->addAttr(Importer.Import(A));
 
   ToIndirectField->setAccess(D->getAccess());
   ToIndirectField->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToIndirectField);
   return ToIndirectField;
 }
 
-Decl *ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
+OptionalDecl ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
   // Import the major distinguishing characteristics of a declaration.
   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
   DeclContext *LexicalDC = D->getDeclContext() == D->getLexicalDeclContext()
       ? DC : Importer.ImportContext(D->getLexicalDeclContext());
   if (!DC || !LexicalDC)
-    return nullptr;
+    return None;
 
   // Determine whether we've already imported this decl.
   // FriendDecl is not a NamedDecl so we cannot use localUncachedLookup.
   auto *RD = cast<CXXRecordDecl>(DC);
   FriendDecl *ImportedFriend = RD->getFirstFriend();
 
   while (ImportedFriend) {
     if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) {
       if (IsStructuralMatch(D->getFriendDecl(), ImportedFriend->getFriendDecl(),
                             /*Complain=*/false))
         return Importer.MapImported(D, ImportedFriend);
 
     } else if (D->getFriendType() && ImportedFriend->getFriendType()) {
       if (Importer.IsStructurallyEquivalent(
             D->getFriendType()->getType(),
             ImportedFriend->getFriendType()->getType(), true))
         return Importer.MapImported(D, ImportedFriend);
     }
     ImportedFriend = ImportedFriend->getNextFriend();
   }
 
   // Not found. Create it.
   FriendDecl::FriendUnion ToFU;
   if (NamedDecl *FriendD = D->getFriendDecl()) {
-    auto *ToFriendD = cast_or_null<NamedDecl>(Importer.Import(FriendD));
+    auto ToFriendD = importNonNull(FriendD);
     if (ToFriendD && FriendD->getFriendObjectKind() != Decl::FOK_None &&
         !(FriendD->isInIdentifierNamespace(Decl::IDNS_NonMemberOperator)))
-      ToFriendD->setObjectOfFriendDecl(false);
+      (*ToFriendD)->setObjectOfFriendDecl(false);
 
-    ToFU = ToFriendD;
+    ToFU = *ToFriendD;
   }  else // The friend is a type, not a decl.
     ToFU = Importer.Import(D->getFriendType());
   if (!ToFU)
-    return nullptr;
+    return None;
 
   SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists);
   auto **FromTPLists = D->getTrailingObjects<TemplateParameterList *>();
   for (unsigned I = 0; I < D->NumTPLists; I++) {
     TemplateParameterList *List = ImportTemplateParameterList(FromTPLists[I]);
     if (!List)
-      return nullptr;
+      return None;
     ToTPLists[I] = List;
   }
 
   FriendDecl *FrD;
   if (GetImportedOrCreateDecl(FrD, D, Importer.getToContext(), DC,
                               Importer.Import(D->getLocation()), ToFU,
                               Importer.Import(D->getFriendLoc()), ToTPLists))
     return FrD;
 
   FrD->setAccess(D->getAccess());
   FrD->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(FrD);
   return FrD;
 }
 
-Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
+OptionalDecl ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
   // Import the major distinguishing characteristics of an ivar.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   // Determine whether we've already imported this ivar
   SmallVector<NamedDecl *, 2> FoundDecls;
   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
   for (auto *FoundDecl : FoundDecls) {
     if (auto *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
       if (Importer.IsStructurallyEquivalent(D->getType(),
                                             FoundIvar->getType())) {
         Importer.MapImported(D, FoundIvar);
         return FoundIvar;
       }
 
       Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
         << Name << D->getType() << FoundIvar->getType();
       Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
         << FoundIvar->getType();
-      return nullptr;
+      return None;
     }
   }
 
   // Import the type.
   QualType T = Importer.Import(D->getType());
   if (T.isNull())
-    return nullptr;
+    return None;
 
   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
   Expr *BitWidth = Importer.Import(D->getBitWidth());
   if (!BitWidth && D->getBitWidth())
-    return nullptr;
+    return None;
 
   ObjCIvarDecl *ToIvar;
   if (GetImportedOrCreateDecl(
           ToIvar, D, Importer.getToContext(), cast<ObjCContainerDecl>(DC),
           Importer.Import(D->getInnerLocStart()), Loc,
           Name.getAsIdentifierInfo(), T, TInfo, D->getAccessControl(), BitWidth,
           D->getSynthesize()))
     return ToIvar;
 
   ToIvar->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToIvar);
   return ToIvar;
 }
 
-Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
+OptionalDecl ASTNodeImporter::VisitVarDecl(VarDecl *D) {
   // Import the major distinguishing characteristics of a variable.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   // Try to find a variable in our own ("to") context with the same name and
   // in the same context as the variable we're importing.
   if (D->isFileVarDecl()) {
     VarDecl *MergeWithVar = nullptr;
     SmallVector<NamedDecl *, 4> ConflictingDecls;
for (auto *FoundDecl : FoundDecls) {
           const ArrayType *TArray
             = Importer.getToContext().getAsArrayType(D->getType());
           if (FoundArray && TArray) {
             if (isa<IncompleteArrayType>(FoundArray) &&
                 isa<ConstantArrayType>(TArray)) {
               // Import the type.
               QualType T = Importer.Import(D->getType());
               if (T.isNull())
-                return nullptr;
+                return None;
 
               FoundVar->setType(T);
               MergeWithVar = FoundVar;
               break;
             } else if (isa<IncompleteArrayType>(TArray) &&
                        isa<ConstantArrayType>(FoundArray)) {
               MergeWithVar = FoundVar;
               break;
if (MergeWithVar) {
       return MergeWithVar;
     }
 
     if (!ConflictingDecls.empty()) {
       Name = Importer.HandleNameConflict(Name, DC, IDNS,
                                          ConflictingDecls.data(),
                                          ConflictingDecls.size());
       if (!Name)
-        return nullptr;
+        return None;
     }
   }
 
   // Import the type.
   QualType T = Importer.Import(D->getType());
   if (T.isNull())
-    return nullptr;
+    return None;
 
   // Create the imported variable.
   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
   VarDecl *ToVar;
   if (GetImportedOrCreateDecl(ToVar, D, Importer.getToContext(), DC,
                               Importer.Import(D->getInnerLocStart()), Loc,
                               Name.getAsIdentifierInfo(), T, TInfo,
                               D->getStorageClass()))
     return ToVar;
 
   ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
   ToVar->setAccess(D->getAccess());
   ToVar->setLexicalDeclContext(LexicalDC);
 
   // Templated declarations should never appear in the enclosing DeclContext.
   if (!D->getDescribedVarTemplate())
     LexicalDC->addDeclInternal(ToVar);
 
   // Merge the initializer.
   if (ImportDefinition(D, ToVar))
-    return nullptr;
+    return None;
 
   if (D->isConstexpr())
     ToVar->setConstexpr(true);
 
   return ToVar;
 }
 
-Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
+OptionalDecl ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
   // Parameters are created in the translation unit's context, then moved
   // into the function declaration's context afterward.
   DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
 
   // Import the name of this declaration.
   DeclarationName Name = Importer.Import(D->getDeclName());
   if (D->getDeclName() && !Name)
-    return nullptr;
+    return None;
 
   // Import the location of this declaration.
   SourceLocation Loc = Importer.Import(D->getLocation());
 
   // Import the parameter's type.
   QualType T = Importer.Import(D->getType());
   if (T.isNull())
-    return nullptr;
+    return None;
 
   // Create the imported parameter.
   ImplicitParamDecl *ToParm = nullptr;
   if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC, Loc,
                               Name.getAsIdentifierInfo(), T,
                               D->getParameterKind()))
     return ToParm;
   return ToParm;
 }
 
-Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
+OptionalDecl ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
   // Parameters are created in the translation unit's context, then moved
   // into the function declaration's context afterward.
   DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
 
   // Import the name of this declaration.
   DeclarationName Name = Importer.Import(D->getDeclName());
   if (D->getDeclName() && !Name)
-    return nullptr;
+    return None;
 
   // Import the location of this declaration.
   SourceLocation Loc = Importer.Import(D->getLocation());
 
   // Import the parameter's type.
   QualType T = Importer.Import(D->getType());
   if (T.isNull())
-    return nullptr;
+    return None;
 
   // Create the imported parameter.
   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
   ParmVarDecl *ToParm;
   if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC,
                               Importer.Import(D->getInnerLocStart()), Loc,
                               Name.getAsIdentifierInfo(), T, TInfo,
                               D->getStorageClass(),
OptionalDecl ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
   } else if (D->hasUnparsedDefaultArg()) {
     ToParm->setUnparsedDefaultArg();
   } else if (D->hasDefaultArg()) {
     FromDefArg = D->getDefaultArg();
     ToDefArg = Importer.Import(FromDefArg);
     ToParm->setDefaultArg(ToDefArg);
   }
   if (FromDefArg && !ToDefArg)
-    return nullptr;
+    return None;
 
   if (D->isObjCMethodParameter()) {
     ToParm->setObjCMethodScopeInfo(D->getFunctionScopeIndex());
     ToParm->setObjCDeclQualifier(D->getObjCDeclQualifier());
   } else {
     ToParm->setScopeInfo(D->getFunctionScopeDepth(),
                          D->getFunctionScopeIndex());
   }
 
   return ToParm;
 }
 
-Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
+OptionalDecl ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
   // Import the major distinguishing characteristics of a method.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   SmallVector<NamedDecl *, 2> FoundDecls;
   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
   for (auto *FoundDecl : FoundDecls) {
     if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
       if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
         continue;
 
       // Check return types.
       if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
                                              FoundMethod->getReturnType())) {
         Importer.ToDiag(Loc, diag::err_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 nullptr;
+        return None;
       }
 
       // Check the number of parameters.
       if (D->param_size() != FoundMethod->param_size()) {
         Importer.ToDiag(Loc, diag::err_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 nullptr;
+        return None;
       }
 
       // 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::err_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 nullptr;
+          return None;
         }
       }
 
       // Check variadic/non-variadic.
       // Check the number of parameters.
       if (D->isVariadic() != FoundMethod->isVariadic()) {
         Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
           << D->isInstanceMethod() << Name;
         Importer.ToDiag(FoundMethod->getLocation(),
                         diag::note_odr_objc_method_here)
           << D->isInstanceMethod() << Name;
-        return nullptr;
+        return None;
       }
 
       // FIXME: Any other bits we need to merge?
       return Importer.MapImported(D, FoundMethod);
     }
   }
 
   // Import the result type.
   QualType ResultTy = Importer.Import(D->getReturnType());
   if (ResultTy.isNull())
-    return nullptr;
+    return None;
 
   TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
 
   ObjCMethodDecl *ToMethod;
   if (GetImportedOrCreateDecl(
           ToMethod, D, Importer.getToContext(), Loc,
           Importer.Import(D->getLocEnd()), Name.getObjCSelector(), ResultTy,
           ReturnTInfo, DC, D->isInstanceMethod(), D->isVariadic(),
           D->isPropertyAccessor(), D->isImplicit(), D->isDefined(),
           D->getImplementationControl(), D->hasRelatedResultType()))
     return ToMethod;
 
   // FIXME: When we decide to merge method definitions, we'll need to
   // deal with implicit parameters.
 
   // Import the parameters
-  SmallVector<ParmVarDecl *, 5> ToParams;
-  for (auto *FromP : D->parameters()) {
-    auto *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
-    if (!ToP)
-      return nullptr;
-
-    ToParams.push_back(ToP);
-  }
+  SmallVector<ParmVarDecl *, 5> ToParams(D->param_size());
+  if (ImportContainerChecked(D->parameters(), ToParams))
+    return None;
 
   // Set the parameters.
   for (auto *ToParam : ToParams) {
     ToParam->setOwningFunction(ToMethod);
     ToMethod->addDeclInternal(ToParam);
   }
 
   SmallVector<SourceLocation, 12> SelLocs;
   D->getSelectorLocs(SelLocs);
   for (auto &Loc : SelLocs)
     Loc = Importer.Import(Loc);
 
   ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
 
   ToMethod->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToMethod);
   return ToMethod;
 }
 
-Decl *ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
+OptionalDecl ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
   // Import the major distinguishing characteristics of a category.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo());
   if (!BoundInfo)
-    return nullptr;
+    return None;
 
   ObjCTypeParamDecl *Result;
   if (GetImportedOrCreateDecl(
           Result, D, Importer.getToContext(), DC, D->getVariance(),
           Importer.Import(D->getVarianceLoc()), D->getIndex(),
           Importer.Import(D->getLocation()), Name.getAsIdentifierInfo(),
           Importer.Import(D->getColonLoc()), BoundInfo))
     return Result;
 
   Result->setLexicalDeclContext(LexicalDC);
   return Result;
 }
 
-Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
+OptionalDecl ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
   // Import the major distinguishing characteristics of a category.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
-  auto *ToInterface =
-      cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
+  auto ToInterface = importNonNull(D->getClassInterface());
   if (!ToInterface)
-    return nullptr;
+    return None;
 
   // Determine if we've already encountered this category.
   ObjCCategoryDecl *MergeWithCategory
-    = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
+    = (*ToInterface)->FindCategoryDeclaration(Name.getAsIdentifierInfo());
   ObjCCategoryDecl *ToCategory = MergeWithCategory;
   if (!ToCategory) {
 
     if (GetImportedOrCreateDecl(ToCategory, D, Importer.getToContext(), DC,
                                 Importer.Import(D->getAtStartLoc()), Loc,
                                 Importer.Import(D->getCategoryNameLoc()),
-                                Name.getAsIdentifierInfo(), ToInterface,
+                                Name.getAsIdentifierInfo(), *ToInterface,
                                 /*TypeParamList=*/nullptr,
                                 Importer.Import(D->getIvarLBraceLoc()),
                                 Importer.Import(D->getIvarRBraceLoc())))
       return ToCategory;
 
     ToCategory->setLexicalDeclContext(LexicalDC);
     LexicalDC->addDeclInternal(ToCategory);
     // Import the type parameter list after calling Imported, to avoid
     // loops when bringing in their DeclContext.
     ToCategory->setTypeParamList(ImportObjCTypeParamList(
                                    D->getTypeParamList()));
 
     // Import protocols
     SmallVector<ObjCProtocolDecl *, 4> Protocols;
     SmallVector<SourceLocation, 4> ProtocolLocs;
-    ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
-      = D->protocol_loc_begin();
-    for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
-                                          FromProtoEnd = D->protocol_end();
-         FromProto != FromProtoEnd;
-         ++FromProto, ++FromProtoLoc) {
-      auto *ToProto =
-          cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
+    auto FromProtoLoc = D->protocol_loc_begin();
+    for (auto FromProto = D->protocol_begin(), FromProtoEnd = D->protocol_end();
+         FromProto != FromProtoEnd; ++FromProto, ++FromProtoLoc) {
+      auto ToProto = importNonNull(*FromProto);
       if (!ToProto)
-        return nullptr;
-      Protocols.push_back(ToProto);
+        return None;
+      Protocols.push_back(*ToProto);
       ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
     }
 
     // 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.MapImported(D, ToCategory);
   }
 
   // Import all of the members of this category.
-  ImportDeclContext(D);
+  if (ImportDeclContext(D))
+    return None;
 
   // If we have an implementation, import it as well.
   if (D->getImplementation()) {
-    auto *Impl =
-        cast_or_null<ObjCCategoryImplDecl>(
-                                       Importer.Import(D->getImplementation()));
+    auto Impl = importNonNull(D->getImplementation());
     if (!Impl)
-      return nullptr;
+      return None;
 
-    ToCategory->setImplementation(Impl);
+    ToCategory->setImplementation(*Impl);
   }
 
   return ToCategory;
 }
 
 bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From,
                                        ObjCProtocolDecl *To,
                                        ImportDefinitionKind Kind) {
   if (To->getDefinition()) {
     if (shouldForceImportDeclContext(Kind))
-      ImportDeclContext(From);
+      return ImportDeclContext(From);
     return false;
   }
 
   // Start the protocol definition
   To->startDefinition();
 
   // Import protocols
   SmallVector<ObjCProtocolDecl *, 4> Protocols;
   SmallVector<SourceLocation, 4> ProtocolLocs;
   ObjCProtocolDecl::protocol_loc_iterator
   FromProtoLoc = From->protocol_loc_begin();
-  for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
-                                        FromProtoEnd = From->protocol_end();
-       FromProto != FromProtoEnd;
-       ++FromProto, ++FromProtoLoc) {
-    auto *ToProto = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
+  for (auto FromProto = From->protocol_begin(),
+       FromProto != FromProtoEnd; ++FromProto, ++FromProtoLoc) {
+    auto ToProto = importNullable(*FromProto);
     if (!ToProto)
       return true;
-    Protocols.push_back(ToProto);
+    Protocols.push_back(*ToProto);
     ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
   }
 
   // FIXME: If we're merging, make sure that the protocol list is the same.
   To->setProtocolList(Protocols.data(), Protocols.size(),
                       ProtocolLocs.data(), Importer.getToContext());
 
   if (shouldForceImportDeclContext(Kind)) {
     // Import all of the members of this protocol.
-    ImportDeclContext(From, /*ForceImport=*/true);
+    return ImportDeclContext(From, /*ForceImport=*/true);
   }
   return false;
 }
 
-Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
-  // If this protocol has a definition in the translation unit we're coming
+OptionalDecl ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
+  // If this protocol 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.
   ObjCProtocolDecl *Definition = D->getDefinition();
   if (Definition && Definition != D) {
-    Decl *ImportedDef = Importer.Import(Definition);
+    auto ImportedDef = importNonNull(Definition);
     if (!ImportedDef)
-      return nullptr;
+      return None;
 
-    return Importer.MapImported(D, ImportedDef);
+    return Importer.MapImported(D, *ImportedDef);
   }
 
   // Import the major distinguishing characteristics of a protocol.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   ObjCProtocolDecl *MergeWithProtocol = nullptr;
   SmallVector<NamedDecl *, 2> FoundDecls;
   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
   for (auto *FoundDecl : FoundDecls) {
     if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
if (GetImportedOrCreateDecl(ToProto, D, Importer.getToContext(), DC,
       return ToProto;
     ToProto->setLexicalDeclContext(LexicalDC);
     LexicalDC->addDeclInternal(ToProto);
   }
 
   Importer.MapImported(D, ToProto);
 
   if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto))
-    return nullptr;
+    return None;
 
   return ToProto;
 }
 
-Decl *ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
+OptionalDecl ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
   DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
 
   SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
   SourceLocation LangLoc = Importer.Import(D->getLocation());
 
   bool HasBraces = D->hasBraces();
 
   LinkageSpecDecl *ToLinkageSpec;
   if (GetImportedOrCreateDecl(ToLinkageSpec, D, Importer.getToContext(), DC,
                               ExternLoc, LangLoc, D->getLanguage(), HasBraces))
     return ToLinkageSpec;
 
   if (HasBraces) {
     SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
     ToLinkageSpec->setRBraceLoc(RBraceLoc);
   }
 
   ToLinkageSpec->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToLinkageSpec);
 
   return ToLinkageSpec;
 }
 
-Decl *ASTNodeImporter::VisitUsingDecl(UsingDecl *D) {
+OptionalDecl ASTNodeImporter::VisitUsingDecl(UsingDecl *D) {
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD = nullptr;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   DeclarationNameInfo NameInfo(Name,
                                Importer.Import(D->getNameInfo().getLoc()));
   ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
 
   UsingDecl *ToUsing;
   if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
                               Importer.Import(D->getUsingLoc()),
                               Importer.Import(D->getQualifierLoc()), NameInfo,
                               D->hasTypename()))
     return ToUsing;
 
   ToUsing->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToUsing);
 
   if (NamedDecl *FromPattern =
       Importer.getFromContext().getInstantiatedFromUsingDecl(D)) {
-    if (auto *ToPattern =
-            dyn_cast_or_null<NamedDecl>(Importer.Import(FromPattern)))
-      Importer.getToContext().setInstantiatedFromUsingDecl(ToUsing, ToPattern);
+    if (auto ToPattern = importNonNull(FromPattern))
+      Importer.getToContext().setInstantiatedFromUsingDecl(ToUsing, *ToPattern);
     else
-      return nullptr;
+      return None;
   }
 
   for (auto *FromShadow : D->shadows()) {
-    if (auto *ToShadow =
-            dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromShadow)))
-      ToUsing->addShadowDecl(ToShadow);
+    if (auto ToShadow = importNonNull(FromShadow))
+      ToUsing->addShadowDecl(*ToShadow);
     else
       // FIXME: We return a nullptr here but the definition is already created
       // and available with lookups. How to fix this?..
-      return nullptr;
+      return None;
   }
   return ToUsing;
 }
 
-Decl *ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
+OptionalDecl ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD = nullptr;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
-  auto *ToUsing = dyn_cast_or_null<UsingDecl>(
-      Importer.Import(D->getUsingDecl()));
+  auto ToUsing = importNonNull(D->getUsingDecl());
   if (!ToUsing)
-    return nullptr;
+    return None;
 
-  auto *ToTarget = dyn_cast_or_null<NamedDecl>(
-      Importer.Import(D->getTargetDecl()));
+  auto ToTarget = importNonNull(D->getTargetDecl());
   if (!ToTarget)
-    return nullptr;
+    return None;
 
   UsingShadowDecl *ToShadow;
   if (GetImportedOrCreateDecl(ToShadow, D, Importer.getToContext(), DC, Loc,
-                              ToUsing, ToTarget))
+                              *ToUsing, *ToTarget))
     return ToShadow;
 
   ToShadow->setLexicalDeclContext(LexicalDC);
   ToShadow->setAccess(D->getAccess());
 
   if (UsingShadowDecl *FromPattern =
       Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) {
-    if (auto *ToPattern =
-            dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromPattern)))
+    if (auto ToPattern = importNonNull(FromPattern))
       Importer.getToContext().setInstantiatedFromUsingShadowDecl(ToShadow,
-                                                                 ToPattern);
+                                                                 *ToPattern);
     else
       // FIXME: We return a nullptr here but the definition is already created
       // and available with lookups. How to fix this?..
-      return nullptr;
+      return None;
   }
 
   LexicalDC->addDeclInternal(ToShadow);
 
   return ToShadow;
 }
 
-Decl *ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
+OptionalDecl ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD = nullptr;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   DeclContext *ToComAncestor = Importer.ImportContext(D->getCommonAncestor());
   if (!ToComAncestor)
-    return nullptr;
+    return None;
 
-  auto *ToNominated = cast_or_null<NamespaceDecl>(
-      Importer.Import(D->getNominatedNamespace()));
+  auto ToNominated = importNullable(D->getNominatedNamespace());
   if (!ToNominated)
-    return nullptr;
+    return None;
 
   UsingDirectiveDecl *ToUsingDir;
   if (GetImportedOrCreateDecl(ToUsingDir, D, Importer.getToContext(), DC,
                               Importer.Import(D->getUsingLoc()),
                               Importer.Import(D->getNamespaceKeyLocation()),
                               Importer.Import(D->getQualifierLoc()),
                               Importer.Import(D->getIdentLocation()),
-                              ToNominated, ToComAncestor))
+                              *ToNominated, ToComAncestor))
     return ToUsingDir;
 
   ToUsingDir->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToUsingDir);
 
   return ToUsingDir;
 }
 
-Decl *ASTNodeImporter::VisitUnresolvedUsingValueDecl(
-    UnresolvedUsingValueDecl *D) {
+OptionalDecl
+ASTNodeImporter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD = nullptr;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
-  DeclarationNameInfo NameInfo(Name, Importer.Import(D->getNameInfo().getLoc()));
+  DeclarationNameInfo NameInfo(Name,
+                               Importer.Import(D->getNameInfo().getLoc()));
   ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
 
   UnresolvedUsingValueDecl *ToUsingValue;
   if (GetImportedOrCreateDecl(ToUsingValue, D, Importer.getToContext(), DC,
                               Importer.Import(D->getUsingLoc()),
                               Importer.Import(D->getQualifierLoc()), NameInfo,
                               Importer.Import(D->getEllipsisLoc())))
     return ToUsingValue;
 
   ToUsingValue->setAccess(D->getAccess());
   ToUsingValue->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToUsingValue);
 
   return ToUsingValue;
 }
 
-Decl *ASTNodeImporter::VisitUnresolvedUsingTypenameDecl(
+OptionalDecl ASTNodeImporter::VisitUnresolvedUsingTypenameDecl(
     UnresolvedUsingTypenameDecl *D) {
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD = nullptr;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   UnresolvedUsingTypenameDecl *ToUsing;
   if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
                               Importer.Import(D->getUsingLoc()),
                               Importer.Import(D->getTypenameLoc()),
                               Importer.Import(D->getQualifierLoc()), Loc, Name,
                               Importer.Import(D->getEllipsisLoc())))
     return ToUsing;
 
   ToUsing->setAccess(D->getAccess());
   ToUsing->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToUsing);
 
   return ToUsing;
 }
 
 bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
                                        ObjCInterfaceDecl *To,
                                        ImportDefinitionKind Kind) {
   if (To->getDefinition()) {
     // Check consistency of superclass.
     ObjCInterfaceDecl *FromSuper = From->getSuperClass();
-    if (FromSuper) {
-      FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
-      if (!FromSuper)
+    if (FromSuper)
+      // Not a typo. We update FromSuper variable itself.
+      if (importNonNullInto(FromSuper, FromSuper))
         return true;
-    }
 
     ObjCInterfaceDecl *ToSuper = To->getSuperClass();
     if ((bool)FromSuper != (bool)ToSuper ||
         (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
       Importer.ToDiag(To->getLocation(),
                       diag::err_odr_objc_superclass_inconsistent)
         << To->getDeclName();
       if (ToSuper)
         Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
           << To->getSuperClass()->getDeclName();
       else
         Importer.ToDiag(To->getLocation(),
                         diag::note_odr_objc_missing_superclass);
       if (From->getSuperClass())
         Importer.FromDiag(From->getSuperClassLoc(),
                           diag::note_odr_objc_superclass)
         << From->getSuperClass()->getDeclName();
       else
         Importer.FromDiag(From->getLocation(),
                           diag::note_odr_objc_missing_superclass);
     }
 
     if (shouldForceImportDeclContext(Kind))
-      ImportDeclContext(From);
+      return ImportDeclContext(From);
     return false;
   }
 
   // Start the definition.
   To->startDefinition();
 
   // If this class has a superclass, import it.
   if (From->getSuperClass()) {
     TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo());
     if (!SuperTInfo)
       return true;
 
     To->setSuperClass(SuperTInfo);
   }
 
   // Import protocols
   SmallVector<ObjCProtocolDecl *, 4> Protocols;
   SmallVector<SourceLocation, 4> ProtocolLocs;
   ObjCInterfaceDecl::protocol_loc_iterator
   FromProtoLoc = From->protocol_loc_begin();
 
-  for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
-                                         FromProtoEnd = From->protocol_end();
-       FromProto != FromProtoEnd;
-       ++FromProto, ++FromProtoLoc) {
-    auto *ToProto = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
+  for (auto FromProto = From->protocol_begin(),
+       FromProto != FromProtoEnd; ++FromProto, ++FromProtoLoc) {
+    auto ToProto = importNonNull(*FromProto);
     if (!ToProto)
       return true;
-    Protocols.push_back(ToProto);
+    Protocols.push_back(*ToProto);
     ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
   }
 
   // FIXME: If we're merging, make sure that the protocol list is the same.
   To->setProtocolList(Protocols.data(), Protocols.size(),
                       ProtocolLocs.data(), Importer.getToContext());
 
   // Import categories. When the categories themselves are imported, they'll
   // hook themselves into this interface.
   for (auto *Cat : From->known_categories())
-    Importer.Import(Cat);
+    if (!importNonNull(Cat))
+      return true;
 
   // If we have an @implementation, import it as well.
   if (From->getImplementation()) {
-    auto *Impl = cast_or_null<ObjCImplementationDecl>(
-        Importer.Import(From->getImplementation()));
-    if (!Impl)
+    if (auto Impl = importNonNull(From->getImplementation()))
+      To->setImplementation(*Impl);
+    else
       return true;
-
-    To->setImplementation(Impl);
   }
 
   if (shouldForceImportDeclContext(Kind)) {
     // Import all of the members of this class.
-    ImportDeclContext(From, /*ForceImport=*/true);
+    return ImportDeclContext(From, /*ForceImport=*/true);
   }
   return false;
 }
 
 ObjCTypeParamList *
 ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
   if (!list)
     return nullptr;
 
-  SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
-  for (auto fromTypeParam : *list) {
-    auto *toTypeParam = cast_or_null<ObjCTypeParamDecl>(
-        Importer.Import(fromTypeParam));
-    if (!toTypeParam)
-      return nullptr;
+  SmallVector<ObjCTypeParamDecl *, 4> toTypeParams(list->size());
+  if (ImportContainerChecked(*list, toTypeParams))
 
-    toTypeParams.push_back(toTypeParam);
-  }
-
   return ObjCTypeParamList::create(Importer.getToContext(),
                                    Importer.Import(list->getLAngleLoc()),
                                    toTypeParams,
                                    Importer.Import(list->getRAngleLoc()));
 }
 
-Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
+OptionalDecl ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
   // If this class 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.
   ObjCInterfaceDecl *Definition = D->getDefinition();
   if (Definition && Definition != D) {
-    Decl *ImportedDef = Importer.Import(Definition);
+    auto ImportedDef = importNonNull(Definition);
     if (!ImportedDef)
-      return nullptr;
+      return None;
 
-    return Importer.MapImported(D, ImportedDef);
+    return Importer.MapImported(D, *ImportedDef);
   }
 
   // Import the major distinguishing characteristics of an @interface.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   // Look for an existing interface with the same name.
   ObjCInterfaceDecl *MergeWithIface = nullptr;
   SmallVector<NamedDecl *, 2> FoundDecls;
   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
   for (auto *FoundDecl : FoundDecls) {
OptionalDecl ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
   }
   Importer.MapImported(D, ToIface);
   // Import the type parameter list after calling Imported, to avoid
   // loops when bringing in their DeclContext.
   ToIface->setTypeParamList(ImportObjCTypeParamList(
                               D->getTypeParamListAsWritten()));
 
   if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface))
-    return nullptr;
+    return None;
 
   return ToIface;
 }
 
-Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
-  auto *Category = cast_or_null<ObjCCategoryDecl>(
-      Importer.Import(D->getCategoryDecl()));
-  if (!Category)
-    return nullptr;
+OptionalDecl
+ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
+  ObjCCategoryDecl *Category = nullptr;
+  if (importNonNullInto(Category, D->getCategoryDecl()))
+    return None;
 
   ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
   if (!ToImpl) {
     DeclContext *DC = Importer.ImportContext(D->getDeclContext());
     if (!DC)
-      return nullptr;
+      return None;
 
     SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
     if (GetImportedOrCreateDecl(
             ToImpl, D, Importer.getToContext(), DC,
             Importer.Import(D->getIdentifier()), Category->getClassInterface(),
             Importer.Import(D->getLocation()),
             Importer.Import(D->getAtStartLoc()), CategoryNameLoc))
       return ToImpl;
 
     DeclContext *LexicalDC = DC;
     if (D->getDeclContext() != D->getLexicalDeclContext()) {
       LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
       if (!LexicalDC)
-        return nullptr;
+        return None;
 
       ToImpl->setLexicalDeclContext(LexicalDC);
     }
 
     LexicalDC->addDeclInternal(ToImpl);
     Category->setImplementation(ToImpl);
   }
 
   Importer.MapImported(D, ToImpl);
-  ImportDeclContext(D);
+
+  if (ImportDeclContext(D))
+    return None;
+
   return ToImpl;
 }
 
-Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
+OptionalDecl
+ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
   // Find the corresponding interface.
-  auto *Iface = cast_or_null<ObjCInterfaceDecl>(
-      Importer.Import(D->getClassInterface()));
-  if (!Iface)
-    return nullptr;
+  ObjCInterfaceDecl *Iface = nullptr;
+  if (importNonNullInto(Iface, D->getClassInterface()))
+    return None;
 
   // Import the superclass, if any.
   ObjCInterfaceDecl *Super = nullptr;
-  if (D->getSuperClass()) {
-    Super = cast_or_null<ObjCInterfaceDecl>(
-                                          Importer.Import(D->getSuperClass()));
-    if (!Super)
-      return nullptr;
-  }
+  if (importNullableInto(Super, D->getSuperClass()))
+    return None;
 
   ObjCImplementationDecl *Impl = Iface->getImplementation();
   if (!Impl) {
     // We haven't imported an implementation yet. Create a new @implementation
     // now.
     if (GetImportedOrCreateDecl(Impl, D, Importer.getToContext(),
                                 Importer.ImportContext(D->getDeclContext()),
                                 Iface, Super, Importer.Import(D->getLocation()),
                                 Importer.Import(D->getAtStartLoc()),
                                 Importer.Import(D->getSuperClassLoc()),
                                 Importer.Import(D->getIvarLBraceLoc()),
                                 Importer.Import(D->getIvarRBraceLoc())))
       return Impl;
 
     if (D->getDeclContext() != D->getLexicalDeclContext()) {
       DeclContext *LexicalDC
         = Importer.ImportContext(D->getLexicalDeclContext());
       if (!LexicalDC)
-        return nullptr;
+        return None;
       Impl->setLexicalDeclContext(LexicalDC);
     }
 
     // Associate the implementation with the class it implements.
     Iface->setImplementation(Impl);
     Importer.MapImported(D, Iface->getImplementation());
   } else {
     Importer.MapImported(D, Iface->getImplementation());
if ((Super && !Impl->getSuperClass()) ||
                         diag::note_odr_objc_missing_superclass);
       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 nullptr;
+      return None;
     }
   }
 
   // Import all of the members of this @implementation.
-  ImportDeclContext(D);
+  if (ImportDeclContext(D))
+    return None;
 
   return Impl;
 }
 
-Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
+OptionalDecl ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
   // Import the major distinguishing characteristics of an @property.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   // Check whether we have already imported this property.
   SmallVector<NamedDecl *, 2> FoundDecls;
   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
   for (auto *FoundDecl : FoundDecls) {
     if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {
       // Check property types.
       if (!Importer.IsStructurallyEquivalent(D->getType(),
                                              FoundProp->getType())) {
         Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
           << Name << D->getType() << FoundProp->getType();
         Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
           << FoundProp->getType();
-        return nullptr;
+        return None;
       }
 
       // FIXME: Check property attributes, getters, setters, etc.?
 
       // Consider these properties to be equivalent.
       Importer.MapImported(D, FoundProp);
       return FoundProp;
     }
   }
 
   // Import the type.
   TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo());
   if (!TSI)
-    return nullptr;
+    return None;
 
   // Create the new property.
   ObjCPropertyDecl *ToProperty;
   if (GetImportedOrCreateDecl(
           ToProperty, D, Importer.getToContext(), DC, Loc,
           Name.getAsIdentifierInfo(), Importer.Import(D->getAtLoc()),
           Importer.Import(D->getLParenLoc()), Importer.Import(D->getType()),
           TSI, D->getPropertyImplementation()))
     return ToProperty;
 
   ToProperty->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToProperty);
 
   ToProperty->setPropertyAttributes(D->getPropertyAttributes());
   ToProperty->setPropertyAttributesAsWritten(
                                       D->getPropertyAttributesAsWritten());
   ToProperty->setGetterName(Importer.Import(D->getGetterName()),
                             Importer.Import(D->getGetterNameLoc()));
   ToProperty->setSetterName(Importer.Import(D->getSetterName()),
                             Importer.Import(D->getSetterNameLoc()));
-  ToProperty->setGetterMethodDecl(
-     cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
-  ToProperty->setSetterMethodDecl(
-     cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
-  ToProperty->setPropertyIvarDecl(
-       cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
+
+  if (auto ToGetter = importNullable(D->getGetterMethodDecl()))
+    ToProperty->setGetterMethodDecl(*ToGetter);
+  else
+    return None;
+
+  if (auto ToSetter = importNullable(D->getSetterMethodDecl()))
+    ToProperty->setSetterMethodDecl(*ToSetter);
+  else
+    return None;
+
+  if (auto ToIvar = importNullable(D->getPropertyIvarDecl()))
+    ToProperty->setPropertyIvarDecl(*ToIvar);
+  else
+    return None;
+
   return ToProperty;
 }
 
-Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
-  auto *Property = cast_or_null<ObjCPropertyDecl>(
-      Importer.Import(D->getPropertyDecl()));
-  if (!Property)
-    return nullptr;
+OptionalDecl
+ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
+  ObjCPropertyDecl *Property = nullptr;
+  if (importNonNullInto(Property, D->getPropertyDecl()))
+    return None;
 
   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
   if (!DC)
-    return nullptr;
+    return None;
 
   // Import the lexical declaration context.
   DeclContext *LexicalDC = DC;
   if (D->getDeclContext() != D->getLexicalDeclContext()) {
     LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
     if (!LexicalDC)
-      return nullptr;
+      return None;
   }
 
   auto *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
   if (!InImpl)
-    return nullptr;
+    return None;
 
   // Import the ivar (for an @synthesize).
   ObjCIvarDecl *Ivar = nullptr;
-  if (D->getPropertyIvarDecl()) {
-    Ivar = cast_or_null<ObjCIvarDecl>(
-                                    Importer.Import(D->getPropertyIvarDecl()));
-    if (!Ivar)
-      return nullptr;
-  }
+  if (importNullableInto(Ivar, D->getPropertyIvarDecl()))
+    return None;
 
   ObjCPropertyImplDecl *ToImpl
     = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
                                    Property->getQueryKind());
   if (!ToImpl) {
     if (GetImportedOrCreateDecl(ToImpl, D, Importer.getToContext(), DC,
                                 Importer.Import(D->getLocStart()),
                                 Importer.Import(D->getLocation()), Property,
if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
                       diag::err_odr_objc_property_impl_kind_inconsistent)
         << 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 nullptr;
+      return None;
     }
 
     // For @synthesize, check that we have the same
     if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
         Ivar != ToImpl->getPropertyIvarDecl()) {
       Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
                       diag::err_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 nullptr;
+      return None;
     }
 
     // Merge the existing implementation with the new implementation.
     Importer.MapImported(D, ToImpl);
   }
 
   return ToImpl;
 }
 
-Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
+OptionalDecl
+ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
   // For template arguments, we adopt the translation unit as our declaration
   // context. This context will be fixed when the actual template declaration
   // is created.
 
   // FIXME: Import default argument.
   TemplateTypeParmDecl *ToD = nullptr;
   (void)GetImportedOrCreateDecl(
       ToD, D, Importer.getToContext(),
       Importer.getToContext().getTranslationUnitDecl(),
       Importer.Import(D->getLocStart()), Importer.Import(D->getLocation()),
       D->getDepth(), D->getIndex(), Importer.Import(D->getIdentifier()),
       D->wasDeclaredWithTypename(), D->isParameterPack());
   return ToD;
 }
 
-Decl *
+OptionalDecl
 ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
   // Import the name of this declaration.
   DeclarationName Name = Importer.Import(D->getDeclName());
   if (D->getDeclName() && !Name)
-    return nullptr;
+    return None;
 
   // Import the location of this declaration.
   SourceLocation Loc = Importer.Import(D->getLocation());
 
   // Import the type of this declaration.
   QualType T = Importer.Import(D->getType());
   if (T.isNull())
-    return nullptr;
+    return None;
 
   // Import type-source information.
   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
   if (D->getTypeSourceInfo() && !TInfo)
-    return nullptr;
+    return None;
 
   // FIXME: Import default argument.
 
   NonTypeTemplateParmDecl *ToD = nullptr;
   (void)GetImportedOrCreateDecl(
       ToD, D, Importer.getToContext(),
       Importer.getToContext().getTranslationUnitDecl(),
       Importer.Import(D->getInnerLocStart()), Loc, D->getDepth(),
       D->getPosition(), Name.getAsIdentifierInfo(), T, D->isParameterPack(),
       TInfo);
   return ToD;
 }
 
-Decl *
+OptionalDecl
 ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
   // Import the name of this declaration.
   DeclarationName Name = Importer.Import(D->getDeclName());
   if (D->getDeclName() && !Name)
-    return nullptr;
+    return None;
 
   // Import the location of this declaration.
   SourceLocation Loc = Importer.Import(D->getLocation());
 
   // Import template parameters.
   TemplateParameterList *TemplateParams
     = ImportTemplateParameterList(D->getTemplateParameters());
   if (!TemplateParams)
-    return nullptr;
+    return None;
 
   // FIXME: Import default argument.
 
   TemplateTemplateParmDecl *ToD = nullptr;
   (void)GetImportedOrCreateDecl(
       ToD, D, Importer.getToContext(),
       Importer.getToContext().getTranslationUnitDecl(), Loc, D->getDepth(),
       D->getPosition(), D->isParameterPack(), Name.getAsIdentifierInfo(),
       TemplateParams);
   return ToD;
 }
 
 // Returns the definition for a (forward) declaration of a ClassTemplateDecl, if
 // it has any definition in the redecl chain.
 static ClassTemplateDecl *getDefinition(ClassTemplateDecl *D) {
   CXXRecordDecl *ToTemplatedDef = D->getTemplatedDecl()->getDefinition();
   if (!ToTemplatedDef)
     return nullptr;
   ClassTemplateDecl *TemplateWithDef =
       ToTemplatedDef->getDescribedClassTemplate();
   return TemplateWithDef;
 }
 
-Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
+OptionalDecl 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.
   auto *Definition =
       cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
   if (Definition && Definition != D->getTemplatedDecl()) {
-    Decl *ImportedDef
-      = Importer.Import(Definition->getDescribedClassTemplate());
+    auto ImportedDef = importNonNull(Definition->getDescribedClassTemplate());
     if (!ImportedDef)
-      return nullptr;
+      return None;
 
-    return Importer.MapImported(D, ImportedDef);
+    return Importer.MapImported(D, *ImportedDef);
   }
 
   // Import the major distinguishing characteristics of this class template.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   // We may already have a template of the same name; try to find and match it.
   if (!DC->isFunctionOrMethod()) {
     SmallVector<NamedDecl *, 4> ConflictingDecls;
     SmallVector<NamedDecl *, 2> FoundDecls;
     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
if (!DC->isFunctionOrMethod()) {
 
     if (!ConflictingDecls.empty()) {
       Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
                                          ConflictingDecls.data(),
                                          ConflictingDecls.size());
     }
 
     if (!Name)
-      return nullptr;
+      return None;
   }
 
   CXXRecordDecl *FromTemplated = D->getTemplatedDecl();
 
   // Create the declaration that is being templated.
-  auto *ToTemplated = cast_or_null<CXXRecordDecl>(
-      Importer.Import(FromTemplated));
-  if (!ToTemplated)
-    return nullptr;
+  CXXRecordDecl *ToTemplated = nullptr;
+  if (importNonNullInto(ToTemplated, FromTemplated))
+    return None;
 
   // Create the class template declaration itself.
   TemplateParameterList *TemplateParams =
       ImportTemplateParameterList(D->getTemplateParameters());
   if (!TemplateParams)
-    return nullptr;
+    return None;
 
   ClassTemplateDecl *D2;
   if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, Loc, Name,
                               TemplateParams, ToTemplated))
     return D2;
 
   ToTemplated->setDescribedClassTemplate(D2);
 
   D2->setAccess(D->getAccess());
   D2->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(D2);
 
   if (FromTemplated->isCompleteDefinition() &&
       !ToTemplated->isCompleteDefinition()) {
     // FIXME: Import definition!
   }
 
   return D2;
 }
 
-Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
-                                          ClassTemplateSpecializationDecl *D) {
+OptionalDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl(
   // 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.
   TagDecl *Definition = D->getDefinition();
   if (Definition && Definition != D) {
-    Decl *ImportedDef = Importer.Import(Definition);
+    auto ImportedDef = importNonNull(Definition);
     if (!ImportedDef)
-      return nullptr;
+      return None;
 
-    return Importer.MapImported(D, ImportedDef);
+    return Importer.MapImported(D, *ImportedDef);
   }
 
-  auto *ClassTemplate =
-      cast_or_null<ClassTemplateDecl>(Importer.Import(
-                                                 D->getSpecializedTemplate()));
-  if (!ClassTemplate)
-    return nullptr;
+  ClassTemplateDecl *ClassTemplate = nullptr;
+  if (importNonNullInto(ClassTemplate, D->getSpecializedTemplate()))
+    return None;
 
   // Import the context of this declaration.
   DeclContext *DC = ClassTemplate->getDeclContext();
   if (!DC)
-    return nullptr;
+    return None;
 
   DeclContext *LexicalDC = DC;
   if (D->getDeclContext() != D->getLexicalDeclContext()) {
     LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
     if (!LexicalDC)
-      return nullptr;
+      return None;
   }
 
   // Import the location of this declaration.
   SourceLocation StartLoc = Importer.Import(D->getLocStart());
   SourceLocation IdLoc = Importer.Import(D->getLocation());
 
   // Import template arguments.
   SmallVector<TemplateArgument, 2> TemplateArgs;
   if (ImportTemplateArguments(D->getTemplateArgs().data(),
                               D->getTemplateArgs().size(),
                               TemplateArgs))
-    return nullptr;
+    return None;
 
   // Try to find an existing specialization with these template arguments.
   void *InsertPos = nullptr;
   ClassTemplateSpecializationDecl *D2
     = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
   if (D2) {
     // We already have a class template specialization with these template
     // arguments.
OptionalDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl(
   } else {
     // Create a new specialization.
     if (auto *PartialSpec =
             dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
       // Import TemplateArgumentListInfo
       TemplateArgumentListInfo ToTAInfo;
       const auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
       if (ImportTemplateArgumentListInfo(ASTTemplateArgs, ToTAInfo))
-        return nullptr;
+        return None;
 
       QualType CanonInjType = Importer.Import(
             PartialSpec->getInjectedSpecializationType());
       if (CanonInjType.isNull())
-        return nullptr;
+        return None;
       CanonInjType = CanonInjType.getCanonicalType();
 
       TemplateParameterList *ToTPList = ImportTemplateParameterList(
             PartialSpec->getTemplateParameters());
       if (!ToTPList && PartialSpec->getTemplateParameters())
-        return nullptr;
+        return None;
 
       if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
               D2, D, Importer.getToContext(), D->getTagKind(), DC, StartLoc,
               IdLoc, ToTPList, ClassTemplate,
               llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()),
               ToTAInfo, CanonInjType, nullptr))
         return D2;
 
if (D2) {
     ClassTemplate->AddSpecialization(D2, InsertPos);
 
     // Import the qualifier, if any.
     D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
 
     if (auto *TSI = D->getTypeAsWritten()) {
       TypeSourceInfo *TInfo = Importer.Import(TSI);
       if (!TInfo)
-        return nullptr;
+        return None;
+
       D2->setTypeAsWritten(TInfo);
       D2->setTemplateKeywordLoc(Importer.Import(D->getTemplateKeywordLoc()));
       D2->setExternLoc(Importer.Import(D->getExternLoc()));
     }
 
     SourceLocation POI = Importer.Import(D->getPointOfInstantiation());
     if (POI.isValid())
       D2->setPointOfInstantiation(POI);
     else if (D->getPointOfInstantiation().isValid())
-      return nullptr;
+      return None;
 
     D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());
 
     // Set the context of this specialization/instantiation.
     D2->setLexicalDeclContext(LexicalDC);
 
     // Add to the DC only if it was an explicit specialization/instantiation.
     if (D2->isExplicitInstantiationOrSpecialization()) {
       LexicalDC->addDeclInternal(D2);
     }
   }
   if (D->isCompleteDefinition() && ImportDefinition(D, D2))
-    return nullptr;
+    return None;
 
   return D2;
 }
 
-Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
+OptionalDecl ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
   // If this variable 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.
   auto *Definition =
       cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
   if (Definition && Definition != D->getTemplatedDecl()) {
-    Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
+    auto ImportedDef = importNonNull(Definition->getDescribedVarTemplate());
     if (!ImportedDef)
-      return nullptr;
+      return None;
 
-    return Importer.MapImported(D, ImportedDef);
+    return Importer.MapImported(D, *ImportedDef);
   }
 
   // Import the major distinguishing characteristics of this variable template.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
   if (ToD)
     return ToD;
 
   // We may already have a template of the same name; try to find and match it.
   assert(!DC->isFunctionOrMethod() &&
          "Variable templates cannot be declared at function scope");
   SmallVector<NamedDecl *, 4> ConflictingDecls;
   SmallVector<NamedDecl *, 2> FoundDecls;
OptionalDecl ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
 
   if (!ConflictingDecls.empty()) {
     Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
                                        ConflictingDecls.data(),
                                        ConflictingDecls.size());
   }
 
   if (!Name)
-    return nullptr;
+    return None;
 
   VarDecl *DTemplated = D->getTemplatedDecl();
 
   // Import the type.
   QualType T = Importer.Import(DTemplated->getType());
   if (T.isNull())
-    return nullptr;
+    return None;
 
   // Create the declaration that is being templated.
-  auto *ToTemplated = dyn_cast_or_null<VarDecl>(Importer.Import(DTemplated));
-  if (!ToTemplated)
-    return nullptr;
+  VarDecl *ToTemplated = nullptr;
+  if (importNonNullInto(ToTemplated, DTemplated))
+    return None;
 
   // Create the variable template declaration itself.
   TemplateParameterList *TemplateParams =
       ImportTemplateParameterList(D->getTemplateParameters());
   if (!TemplateParams)
-    return nullptr;
+    return None;
 
   VarTemplateDecl *ToVarTD;
   if (GetImportedOrCreateDecl(ToVarTD, D, Importer.getToContext(), DC, Loc,
                               Name, TemplateParams, ToTemplated))
     return ToVarTD;
 
   ToTemplated->setDescribedVarTemplate(ToVarTD);
 
   ToVarTD->setAccess(D->getAccess());
   ToVarTD->setLexicalDeclContext(LexicalDC);
   LexicalDC->addDeclInternal(ToVarTD);
 
   if (DTemplated->isThisDeclarationADefinition() &&
       !ToTemplated->isThisDeclarationADefinition()) {
     // FIXME: Import definition!
   }
 
   return ToVarTD;
 }
 
-Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
+OptionalDecl ASTNodeImporter::VisitVarTemplateSpecializationDecl(
     VarTemplateSpecializationDecl *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.
   VarDecl *Definition = D->getDefinition();
   if (Definition && Definition != D) {
-    Decl *ImportedDef = Importer.Import(Definition);
+    auto ImportedDef = importNonNull(Definition);
     if (!ImportedDef)
-      return nullptr;
+      return None;
 
-    return Importer.MapImported(D, ImportedDef);
+    return Importer.MapImported(D, *ImportedDef);
   }
 
-  auto *VarTemplate = cast_or_null<VarTemplateDecl>(
-      Importer.Import(D->getSpecializedTemplate()));
-  if (!VarTemplate)
-    return nullptr;
+  VarTemplateDecl *VarTemplate = nullptr;
+  if (importNonNullInto(VarTemplate, D->getSpecializedTemplate()))
+    return None;
 
   // Import the context of this declaration.
   DeclContext *DC = VarTemplate->getDeclContext();
   if (!DC)
-    return nullptr;
+    return None;
 
   DeclContext *LexicalDC = DC;
   if (D->getDeclContext() != D->getLexicalDeclContext()) {
     LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
     if (!LexicalDC)
-      return nullptr;
+      return None;
   }
 
   // Import the location of this declaration.
   SourceLocation StartLoc = Importer.Import(D->getLocStart());
   SourceLocation IdLoc = Importer.Import(D->getLocation());
 
   // Import template arguments.
   SmallVector<TemplateArgument, 2> TemplateArgs;
   if (ImportTemplateArguments(D->getTemplateArgs().data(),
                               D->getTemplateArgs().size(), TemplateArgs))
-    return nullptr;
+    return None;
 
   // Try to find an existing specialization with these template arguments.
   void *InsertPos = nullptr;
   VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
       TemplateArgs, InsertPos);
   if (D2) {
     // We already have a variable template specialization with these template
     // arguments.
 
     // FIXME: Check for specialization vs. instantiation errors.
 
     if (VarDecl *FoundDef = D2->getDefinition()) {
       if (!D->isThisDeclarationADefinition() ||
           IsStructuralMatch(D, FoundDef)) {
         // The record types structurally match, or the "from" translation
         // unit only had a forward declaration anyway; call it the same
         // variable.
         return Importer.MapImported(D, FoundDef);
       }
     }
   } else {
     // Import the type.
     QualType T = Importer.Import(D->getType());
     if (T.isNull())
-      return nullptr;
+      return None;
 
     TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
     if (D->getTypeSourceInfo() && !TInfo)
-      return nullptr;
+      return None;
 
     TemplateArgumentListInfo ToTAInfo;
     if (ImportTemplateArgumentListInfo(D->getTemplateArgsInfo(), ToTAInfo))
-      return nullptr;
+      return None;
 
     using PartVarSpecDecl = VarTemplatePartialSpecializationDecl;
     // Create a new specialization.
     if (auto *FromPartial = dyn_cast<PartVarSpecDecl>(D)) {
       // Import TemplateArgumentListInfo
       TemplateArgumentListInfo ArgInfos;
       const auto *FromTAArgsAsWritten = FromPartial->getTemplateArgsAsWritten();
       // NOTE: FromTAArgsAsWritten and template parameter list are non-null.
       if (ImportTemplateArgumentListInfo(*FromTAArgsAsWritten, ArgInfos))
-        return nullptr;
+        return None;
 
       TemplateParameterList *ToTPList = ImportTemplateParameterList(
             FromPartial->getTemplateParameters());
       if (!ToTPList)
-        return nullptr;
+        return None;
 
       PartVarSpecDecl *ToPartial;
       if (GetImportedOrCreateDecl(ToPartial, D, Importer.getToContext(), DC,
                                   StartLoc, IdLoc, ToTPList, VarTemplate, T,
                                   TInfo, D->getStorageClass(), TemplateArgs,
                                   ArgInfos))
         return ToPartial;
 
       auto *FromInst = FromPartial->getInstantiatedFromMember();
-      auto *ToInst = cast_or_null<PartVarSpecDecl>(Importer.Import(FromInst));
-      if (FromInst && !ToInst)
-        return nullptr;
+      auto ToInst = importNullable(FromInst);
+      if (!ToInst)
+        return None;
 
-      ToPartial->setInstantiatedFromMember(ToInst);
+      ToPartial->setInstantiatedFromMember(*ToInst);
       if (FromPartial->isMemberSpecialization())
         ToPartial->setMemberSpecialization();
 
       D2 = ToPartial;
     } else { // Full specialization
       if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, StartLoc,
                                   IdLoc, VarTemplate, T, TInfo,
                                   D->getStorageClass(), TemplateArgs))
OptionalDecl ASTNodeImporter::VisitVarTemplateSpecializationDecl(
   }
 
   // NOTE: isThisDeclarationADefinition() can return DeclarationOnly even if
   // declaration has initializer. Should this be fixed in the AST?.. Anyway,
   // we have to check the declaration for initializer - otherwise, it won't be
   // imported.
   if ((D->isThisDeclarationADefinition() || D->hasInit()) &&
       ImportDefinition(D, D2))
-    return nullptr;
+    return None;
 
   return D2;
 }
 
-Decl *ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
+OptionalDecl
+ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
 
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
-    return nullptr;
+    return None;
 
   if (ToD)
     return ToD;
 
   // Try to find a function in our own ("to") context with the same name, same
   // type, and in the same context as the function we're importing.
   if (!LexicalDC->isFunctionOrMethod()) {
     unsigned IDNS = Decl::IDNS_Ordinary;
for (auto *FoundDecl : FoundDecls) {
         }
       }
     }
   }
 
   TemplateParameterList *Params =
       ImportTemplateParameterList(D->getTemplateParameters());
   if (!Params)
-    return nullptr;
+    return None;
 
-  auto *TemplatedFD =
-      cast_or_null<FunctionDecl>(Importer.Import(D->getTemplatedDecl()));
+  auto TemplatedFD = importNonNull(D->getTemplatedDecl());
   if (!TemplatedFD)
-    return nullptr;
+    return None;
 
   FunctionTemplateDecl *ToFunc;
   if (GetImportedOrCreateDecl(ToFunc, D, Importer.getToContext(), DC, Loc, Name,
-                              Params, TemplatedFD))
+                              Params, *TemplatedFD))
     return ToFunc;
 
-  TemplatedFD->setDescribedFunctionTemplate(ToFunc);
+  (*TemplatedFD)->setDescribedFunctionTemplate(ToFunc);
   ToFunc->setAccess(D->getAccess());
   ToFunc->setLexicalDeclContext(LexicalDC);
 
   LexicalDC->addDeclInternal(ToFunc);
   return ToFunc;
 }
 
 //----------------------------------------------------------------------------
 // Import Statements
 //----------------------------------------------------------------------------
 
-DeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) {
+Optional<DeclGroupRef> ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) {
   if (DG.isNull())
     return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
+
   size_t NumDecls = DG.end() - DG.begin();
   SmallVector<Decl *, 1> ToDecls(NumDecls);
-  auto &_Importer = this->Importer;
-  std::transform(DG.begin(), DG.end(), ToDecls.begin(),
-    [&_Importer](Decl *D) -> Decl * {
-      return _Importer.Import(D);
-    });
-  return DeclGroupRef::Create(Importer.getToContext(),
-                              ToDecls.begin(),
+  if (ImportContainerChecked(DG, ToDecls))
+    return None;
+
+  return DeclGroupRef::Create(Importer.getToContext(), ToDecls.begin(),
                               NumDecls);
 }
 
 Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
   Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
     << S->getStmtClassName();
   return nullptr;
 }
return new (Importer.getToContext()) GCCAsmStmt(
         Exprs.data(),
         AsmStr,
         S->getNumClobbers(),
         Clobbers.data(),
         Importer.Import(S->getRParenLoc()));
 }
 
 Stmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
-  DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup());
-  for (auto *ToD : ToDG) {
-    if (!ToD)
-      return nullptr;
-  }
+  auto ToDG = ImportDeclGroup(S->getDeclGroup());
+  if (!ToDG)
+
   SourceLocation ToStartLoc = Importer.Import(S->getStartLoc());
   SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
-  return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc);
+  return new (Importer.getToContext()) DeclStmt(*ToDG, ToStartLoc, ToEndLoc);
 }
 
 Stmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) {
   SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
   return new (Importer.getToContext()) NullStmt(ToSemiLoc,
                                                 S->hasLeadingEmptyMacro());
 }
 
Stmt *ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
   if (!ToSubStmt && S->getSubStmt())
     return nullptr;
   return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc,
                                                    ToSubStmt);
 }
 
 Stmt *ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
   SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc());
-  auto *ToLabelDecl = cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
-  if (!ToLabelDecl && S->getDecl())
+  auto ToLabelDecl = importNonNull(S->getDecl());
+  if (!ToLabelDecl)
     return nullptr;
+
   Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
   if (!ToSubStmt && S->getSubStmt())
     return nullptr;
-  return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl,
+  return new (Importer.getToContext()) LabelStmt(ToIdentLoc, *ToLabelDecl,
                                                  ToSubStmt);
 }
 
 Stmt *ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
   SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc());
   ArrayRef<const Attr*> FromAttrs(S->getAttrs());
   SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
   if (ImportContainerChecked(FromAttrs, ToAttrs))
     return nullptr;
   Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
   if (!ToSubStmt && S->getSubStmt())
     return nullptr;
   return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc,
                                 ToAttrs, ToSubStmt);
 }
 
 Stmt *ASTNodeImporter::VisitIfStmt(IfStmt *S) {
   SourceLocation ToIfLoc = Importer.Import(S->getIfLoc());
   Stmt *ToInit = Importer.Import(S->getInit());
   if (!ToInit && S->getInit())
     return nullptr;
-  VarDecl *ToConditionVariable = nullptr;
-  if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
-    ToConditionVariable =
-      dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
-    if (!ToConditionVariable)
-      return nullptr;
-  }
+
+  auto ToConditionVariable = importNullable(S->getConditionVariable());
+
   Expr *ToCondition = Importer.Import(S->getCond());
   if (!ToCondition && S->getCond())
     return nullptr;
   Stmt *ToThenStmt = Importer.Import(S->getThen());
   if (!ToThenStmt && S->getThen())
     return nullptr;
   SourceLocation ToElseLoc = Importer.Import(S->getElseLoc());
   Stmt *ToElseStmt = Importer.Import(S->getElse());
   if (!ToElseStmt && S->getElse())
     return nullptr;
   return new (Importer.getToContext()) IfStmt(Importer.getToContext(),
                                               ToIfLoc, S->isConstexpr(),
                                               ToInit,
-                                              ToConditionVariable,
+                                              *ToConditionVariable,
                                               ToCondition, ToThenStmt,
                                               ToElseLoc, ToElseStmt);
 }
 
 Stmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
   Stmt *ToInit = Importer.Import(S->getInit());
   if (!ToInit && S->getInit())
     return nullptr;
-  VarDecl *ToConditionVariable = nullptr;
-  if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
-    ToConditionVariable =
-      dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
-    if (!ToConditionVariable)
-      return nullptr;
-  }
+
+  auto ToConditionVariable = importNullable(S->getConditionVariable());
+
   Expr *ToCondition = Importer.Import(S->getCond());
   if (!ToCondition && S->getCond())
     return nullptr;
   auto *ToStmt = new (Importer.getToContext()) SwitchStmt(
                          Importer.getToContext(), ToInit,
-                         ToConditionVariable, ToCondition);
+                         *ToConditionVariable, ToCondition);
   Stmt *ToBody = Importer.Import(S->getBody());
   if (!ToBody && S->getBody())
     return nullptr;
   ToStmt->setBody(ToBody);
   ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc()));
   // Now we have to re-chain the cases.
   SwitchCase *LastChainedSwitchCase = nullptr;
   for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
        SC = SC->getNextSwitchCase()) {
     auto *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
     if (!ToSC)
       return nullptr;
     if (LastChainedSwitchCase)
       LastChainedSwitchCase->setNextSwitchCase(ToSC);
     else
       ToStmt->setSwitchCaseList(ToSC);
     LastChainedSwitchCase = ToSC;
   }
   return ToStmt;
 }
 
 Stmt *ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {
-  VarDecl *ToConditionVariable = nullptr;
-  if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
-    ToConditionVariable =
-      dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
-    if (!ToConditionVariable)
-      return nullptr;
-  }
+  auto ToConditionVariable = importNullable(S->getConditionVariable());
+
   Expr *ToCondition = Importer.Import(S->getCond());
   if (!ToCondition && S->getCond())
     return nullptr;
   Stmt *ToBody = Importer.Import(S->getBody());
   if (!ToBody && S->getBody())
     return nullptr;
   SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
   return new (Importer.getToContext()) WhileStmt(Importer.getToContext(),
-                                                 ToConditionVariable,
+                                                 *ToConditionVariable,
                                                  ToCondition, ToBody,
                                                  ToWhileLoc);
 }
 
 Stmt *ASTNodeImporter::VisitDoStmt(DoStmt *S) {
   Stmt *ToBody = Importer.Import(S->getBody());
   if (!ToBody && S->getBody())
     return nullptr;

 
 Stmt *ASTNodeImporter::VisitForStmt(ForStmt *S) {
   Stmt *ToInit = Importer.Import(S->getInit());
   if (!ToInit && S->getInit())
     return nullptr;
   Expr *ToCondition = Importer.Import(S->getCond());
   if (!ToCondition && S->getCond())
     return nullptr;
-  VarDecl *ToConditionVariable = nullptr;
-  if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
-    ToConditionVariable =
-      dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
-    if (!ToConditionVariable)
-      return nullptr;
-  }
+
+  auto ToConditionVariable = importNullable(S->getConditionVariable());
+
   Expr *ToInc = Importer.Import(S->getInc());
   if (!ToInc && S->getInc())
     return nullptr;
   Stmt *ToBody = Importer.Import(S->getBody());
   if (!ToBody && S->getBody())
     return nullptr;
   SourceLocation ToForLoc = Importer.Import(S->getForLoc());
   SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc());
   SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
   return new (Importer.getToContext()) ForStmt(Importer.getToContext(),
                                                ToInit, ToCondition,
-                                               ToConditionVariable,
+                                               *ToConditionVariable,
                                                ToInc, ToBody,
                                                ToForLoc, ToLParenLoc,
                                                ToRParenLoc);
 }
 
 Stmt *ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
-  LabelDecl *ToLabel = nullptr;
-  if (LabelDecl *FromLabel = S->getLabel()) {
-    ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel));
-    if (!ToLabel)
-      return nullptr;
-  }
+  auto ToLabel = importNullable(S->getLabel());
+
   SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
   SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc());
-  return new (Importer.getToContext()) GotoStmt(ToLabel,
-                                                ToGotoLoc, ToLabelLoc);
+  return new (Importer.getToContext())
+      GotoStmt(*ToLabel, ToGotoLoc, ToLabelLoc);
 }
 
 Stmt *ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
   SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
   SourceLocation ToStarLoc = Importer.Import(S->getStarLoc());
   Expr *ToTarget = Importer.Import(S->getTarget());
   if (!ToTarget && S->getTarget())
     return nullptr;
Stmt *ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
   return new (Importer.getToContext()) BreakStmt(ToBreakLoc);
 }
 
 Stmt *ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
   SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc());
   Expr *ToRetExpr = Importer.Import(S->getRetValue());
   if (!ToRetExpr && S->getRetValue())
     return nullptr;
-  auto *NRVOCandidate = const_cast<VarDecl *>(S->getNRVOCandidate());
-  auto *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
-  if (!ToNRVOCandidate && NRVOCandidate)
+
+  auto ToNRVOCandidate = importNullable(S->getNRVOCandidate());
+  if (!ToNRVOCandidate)
     return nullptr;
+
   return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr,
-                                                  ToNRVOCandidate);
+                                                  *ToNRVOCandidate);
 }
 
 Stmt *ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
   SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc());
-  VarDecl *ToExceptionDecl = nullptr;
-  if (VarDecl *FromExceptionDecl = S->getExceptionDecl()) {
-    ToExceptionDecl =
-      dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
-    if (!ToExceptionDecl)
-      return nullptr;
-  }
+
+  auto ToExceptionDecl = importNullable(S->getExceptionDecl());
+
   Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock());
   if (!ToHandlerBlock && S->getHandlerBlock())
     return nullptr;
   return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc,
-                                                    ToExceptionDecl,
+                                                    *ToExceptionDecl,
                                                     ToHandlerBlock);
 }
 
 Stmt *ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
   SourceLocation ToTryLoc = Importer.Import(S->getTryLoc());
   Stmt *ToTryBlock = Importer.Import(S->getTryBlock());
   if (!ToTryBlock && S->getTryBlock())
     return nullptr;
return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem,
                                                              ToCollect,
                                                              ToBody, ToForLoc,
                                                              ToRParenLoc);
 }
 
 Stmt *ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
   SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc());
   SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
-  VarDecl *ToExceptionDecl = nullptr;
-  if (VarDecl *FromExceptionDecl = S->getCatchParamDecl()) {
-    ToExceptionDecl =
-      dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
-    if (!ToExceptionDecl)
+
+  auto ToExceptionDecl = importNullable(S->getCatchParamDecl());
       return nullptr;
-  }
+
   Stmt *ToBody = Importer.Import(S->getCatchBody());
   if (!ToBody && S->getCatchBody())
     return nullptr;
   return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc,
                                                        ToRParenLoc,
-                                                       ToExceptionDecl,
+                                                       *ToExceptionDecl,
                                                        ToBody);
 }
 
 Stmt *ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
   SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc());
   Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody());
   if (!ToAtFinallyStmt && S->getFinallyBody())
     return nullptr;
Expr *ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
   if (!SL && E->getFunctionName())
     return nullptr;
 
   return new (Importer.getToContext()) PredefinedExpr(
         Importer.Import(E->getLocStart()), T, E->getIdentType(), SL);
 }
 
 Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
-  auto *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
+  auto ToD = importNonNull(E->getDecl());
   if (!ToD)
     return nullptr;
 
   NamedDecl *FoundD = nullptr;
-  if (E->getDecl() != E->getFoundDecl()) {
-    FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
-    if (!FoundD)
+  if (E->getDecl() != E->getFoundDecl())
+    if (importNonNullInto(FoundD, E->getFoundDecl()))
       return nullptr;
-  }
 
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
   TemplateArgumentListInfo ToTAInfo;
   TemplateArgumentListInfo *ResInfo = nullptr;
   if (E->hasExplicitTemplateArgs()) {
     if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
       return nullptr;
     ResInfo = &ToTAInfo;
   }
 
-  DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
-                                         Importer.Import(E->getQualifierLoc()),
-                                   Importer.Import(E->getTemplateKeywordLoc()),
-                                         ToD,
-                                        E->refersToEnclosingVariableOrCapture(),
-                                         Importer.Import(E->getLocation()),
-                                         T, E->getValueKind(),
-                                         FoundD, ResInfo);
+  DeclRefExpr *DRE = DeclRefExpr::Create(
+      Importer.getToContext(), Importer.Import(E->getQualifierLoc()),
+      Importer.Import(E->getTemplateKeywordLoc()), *ToD,
+      Importer.Import(E->getLocation()), T, E->getValueKind(), FoundD,
+      ResInfo);
+
   if (E->hadMultipleCandidates())
     DRE->setHadMultipleCandidates(true);
   return DRE;
 }
 
 Expr *ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
return new (Importer.getToContext()) AtomicExpr(
         Importer.Import(E->getRParenLoc()));
 }
 
 Expr *ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
-  auto *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel()));
+  auto ToLabel = importNonNull(E->getLabel());
   if (!ToLabel)
     return nullptr;
 
   return new (Importer.getToContext()) AddrLabelExpr(
         Importer.Import(E->getAmpAmpLoc()), Importer.Import(E->getLabelLoc()),
-        ToLabel, T);
+        *ToLabel, T);
 }
 
 Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
   Expr *SubExpr = Importer.Import(E->getSubExpr());
   if (!SubExpr)
     return nullptr;
 
   return new (Importer.getToContext())
for (int I = 0, E = OE->getNumComponents(); I < E; ++I) {
     case OffsetOfNode::Base: {
       CXXBaseSpecifier *BS = Importer.Import(Node.getBase());
       if (!BS && Node.getBase())
         return nullptr;
       Nodes.push_back(OffsetOfNode(BS));
       break;
     }
     case OffsetOfNode::Field: {
-      auto *FD = cast_or_null<FieldDecl>(Importer.Import(Node.getField()));
+      auto FD = importNonNull(Node.getField());
       if (!FD)
         return nullptr;
-      Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), FD,
+
+      Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), *FD,
                                    Importer.Import(Node.getLocEnd())));
       break;
     }
     case OffsetOfNode::Identifier: {
       IdentifierInfo *ToII = Importer.Import(Node.getFieldName());
       if (!ToII)
         return nullptr;
       Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), ToII,
if (!SubExpr && E->getSubExpr())
     return nullptr;
 
   return new (Importer.getToContext()) CXXThrowExpr(
         SubExpr, T, Importer.Import(E->getThrowLoc()),
         E->isThrownVariableInScope());
 }
 
 Expr *ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
-  auto *Param = cast_or_null<ParmVarDecl>(Importer.Import(E->getParam()));
-  if (!Param)
-    return nullptr;
-
+  if (auto Param = importNonNull(E->getParam()))
     return CXXDefaultArgExpr::Create(
-        Importer.getToContext(), Importer.Import(E->getUsedLocation()), Param);
+        Importer.getToContext(), Importer.Import(E->getUsedLocation()), *Param);
+
+  return nullptr;
 }
 
 Expr *ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
   TypeSourceInfo *TypeInfo = Importer.Import(E->getTypeSourceInfo());
   if (!TypeInfo)
     return nullptr;
 
   return new (Importer.getToContext()) CXXScalarValueInitExpr(
         T, TypeInfo, Importer.Import(E->getRParenLoc()));
 }
 
 Expr *ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
   Expr *SubExpr = Importer.Import(E->getSubExpr());
   if (!SubExpr)
     return nullptr;
 
-  auto *Dtor = cast_or_null<CXXDestructorDecl>(
-        Importer.Import(const_cast<CXXDestructorDecl *>(
-                          E->getTemporary()->getDestructor())));
+  auto Dtor = importNonNull(E->getTemporary()->getDestructor());
   if (!Dtor)
     return nullptr;
 
   ASTContext &ToCtx = Importer.getToContext();
-  CXXTemporary *Temp = CXXTemporary::Create(ToCtx, Dtor);
+  CXXTemporary *Temp = CXXTemporary::Create(ToCtx, *Dtor);
   return CXXBindTemporaryExpr::Create(ToCtx, Temp, SubExpr);
 }
 
 Expr *ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE) {
   QualType T = Importer.Import(CE->getType());
   if (T.isNull())
     return nullptr;
 
   TypeSourceInfo *TInfo = Importer.Import(CE->getTypeSourceInfo());
   if (!TInfo)
     return nullptr;
 
   SmallVector<Expr *, 8> Args(CE->getNumArgs());
   if (ImportContainerChecked(CE->arguments(), Args))
     return nullptr;
 
-  auto *Ctor = cast_or_null<CXXConstructorDecl>(
-        Importer.Import(CE->getConstructor()));
+  auto Ctor = importNonNull(CE->getConstructor());
   if (!Ctor)
     return nullptr;
 
   return new (Importer.getToContext()) CXXTemporaryObjectExpr(
-      Importer.getToContext(), Ctor, T, TInfo, Args,
+      Importer.getToContext(), *Ctor, T, TInfo, Args,
       Importer.Import(CE->getParenOrBraceRange()), CE->hadMultipleCandidates(),
       CE->isListInitialization(), CE->isStdInitListInitialization(),
       CE->requiresZeroInitialization());
 }
 
 Expr *
 ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
   Expr *TempE = Importer.Import(E->GetTemporaryExpr());
   if (!TempE)
     return nullptr;
 
-  auto *ExtendedBy = cast_or_null<ValueDecl>(
-        Importer.Import(const_cast<ValueDecl *>(E->getExtendingDecl())));
-  if (!ExtendedBy && E->getExtendingDecl())
+  auto ExtendedBy = importNullable(E->getExtendingDecl());
+  if (!ExtendedBy)
     return nullptr;
 
-  auto *ToMTE =  new (Importer.getToContext()) MaterializeTemporaryExpr(
+  auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr(
         T, TempE, E->isBoundToLvalueReference());
 
   // FIXME: Should ManglingNumber get numbers associated with 'to' context?
-  ToMTE->setExtendingDecl(ExtendedBy, E->getManglingNumber());
+  ToMTE->setExtendingDecl(*ExtendedBy, E->getManglingNumber());
   return ToMTE;
 }
 
 Expr *ASTNodeImporter::VisitPackExpansionExpr(PackExpansionExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
   Expr *Pattern = Importer.Import(E->getPattern());
   if (!Pattern)
     return nullptr;
 
   return new (Importer.getToContext()) PackExpansionExpr(
         T, Pattern, Importer.Import(E->getEllipsisLoc()),
         E->getNumExpansions());
 }
 
 Expr *ASTNodeImporter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
-  auto *Pack = cast_or_null<NamedDecl>(Importer.Import(E->getPack()));
+  auto Pack = importNonNull(E->getPack());
   if (!Pack)
     return nullptr;
 
   Optional<unsigned> Length;
-
   if (!E->isValueDependent())
     Length = E->getPackLength();
 
   SmallVector<TemplateArgument, 8> PartialArguments;
   if (E->isPartiallySubstituted()) {
     if (ImportTemplateArguments(E->getPartialArguments().data(),
                                 E->getPartialArguments().size(),
                                 PartialArguments))
       return nullptr;
   }
 
   return SizeOfPackExpr::Create(
-      Importer.getToContext(), Importer.Import(E->getOperatorLoc()), Pack,
+      Importer.getToContext(), Importer.Import(E->getOperatorLoc()), *Pack,
       Importer.Import(E->getPackLoc()), Importer.Import(E->getRParenLoc()),
       Length, PartialArguments);
 }
 
 Expr *ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *CE) {
   QualType T = Importer.Import(CE->getType());
   if (T.isNull())
     return nullptr;
 
   SmallVector<Expr *, 4> PlacementArgs(CE->getNumPlacementArgs());
   if (ImportContainerChecked(CE->placement_arguments(), PlacementArgs))
     return nullptr;
 
-  auto *OperatorNewDecl = cast_or_null<FunctionDecl>(
-        Importer.Import(CE->getOperatorNew()));
-  if (!OperatorNewDecl && CE->getOperatorNew())
+  auto OperatorNewDecl = importNullable(CE->getOperatorNew());
+  if (!OperatorNewDecl)
     return nullptr;
 
-  auto *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
-        Importer.Import(CE->getOperatorDelete()));
-  if (!OperatorDeleteDecl && CE->getOperatorDelete())
+  auto OperatorDeleteDecl = importNullable(CE->getOperatorDelete());
+  if (!OperatorDeleteDecl)
     return nullptr;
 
   Expr *ToInit = Importer.Import(CE->getInitializer());
   if (!ToInit && CE->getInitializer())
     return nullptr;
 
   TypeSourceInfo *TInfo = Importer.Import(CE->getAllocatedTypeSourceInfo());
   if (!TInfo)
     return nullptr;
 
   Expr *ToArrSize = Importer.Import(CE->getArraySize());
   if (!ToArrSize && CE->getArraySize())
     return nullptr;
 
   return new (Importer.getToContext()) CXXNewExpr(
         Importer.getToContext(),
         CE->isGlobalNew(),
-        OperatorNewDecl, OperatorDeleteDecl,
+        *OperatorNewDecl, *OperatorDeleteDecl,
         CE->passAlignment(),
         CE->doesUsualArrayDeleteWantSize(),
         PlacementArgs,
         Importer.Import(CE->getTypeIdParens()),
         ToArrSize, CE->getInitializationStyle(), ToInit, T, TInfo,
         Importer.Import(CE->getSourceRange()),
         Importer.Import(CE->getDirectInitRange()));
 }
 
 Expr *ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
-  auto *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
-        Importer.Import(E->getOperatorDelete()));
-  if (!OperatorDeleteDecl && E->getOperatorDelete())
+  auto OperatorDeleteDecl = importNullable(E->getOperatorDelete());
+  if (!OperatorDeleteDecl)
     return nullptr;
 
   Expr *ToArg = Importer.Import(E->getArgument());
   if (!ToArg && E->getArgument())
     return nullptr;
 
   return new (Importer.getToContext()) CXXDeleteExpr(
         T, E->isGlobalDelete(),
         E->isArrayForm(),
         E->isArrayFormAsWritten(),
         E->doesUsualArrayDeleteWantSize(),
-        OperatorDeleteDecl,
+        *OperatorDeleteDecl,
         ToArg,
         Importer.Import(E->getLocStart()));
 }
 
 Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
-  auto *ToCCD =
-    dyn_cast_or_null<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
+  auto ToCCD = importNonNull(E->getConstructor());
   if (!ToCCD)
     return nullptr;
 
   SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
   if (ImportContainerChecked(E->arguments(), ToArgs))
     return nullptr;
 
   return CXXConstructExpr::Create(Importer.getToContext(), T,
                                   Importer.Import(E->getLocation()),
-                                  ToCCD, E->isElidable(),
+                                  *ToCCD, E->isElidable(),
                                   ToArgs, E->hadMultipleCandidates(),
                                   E->isListInitialization(),
                                   E->isStdInitListInitialization(),
                                   E->requiresZeroInitialization(),
                                   E->getConstructionKind(),
                                   Importer.Import(E->getParenOrBraceRange()));
 }
 
 Expr *ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *EWC) {
   Expr *SubExpr = Importer.Import(EWC->getSubExpr());
   if (!SubExpr && EWC->getSubExpr())
     return nullptr;
 
   SmallVector<ExprWithCleanups::CleanupObject, 8> Objs(EWC->getNumObjects());
-  for (unsigned I = 0, E = EWC->getNumObjects(); I < E; I++)
-    if (ExprWithCleanups::CleanupObject Obj =
-        cast_or_null<BlockDecl>(Importer.Import(EWC->getObject(I))))
-      Objs[I] = Obj;
+  for (unsigned I = 0, E = EWC->getNumObjects(); I < E; I++) {
+    if (auto ImportedBlock = importNonNull(EWC->getObject(I)))
+      Objs[I] = *ImportedBlock;
     else
       return nullptr;
+  }
 
   return ExprWithCleanups::Create(Importer.getToContext(),
                                   SubExpr, EWC->cleanupsHaveSideEffects(),
                                   Objs);
 }
 
 Expr *ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
   QualType T = Importer.Import(E->getType());
Expr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
   Expr *ToBase = Importer.Import(E->getBase());
   if (!ToBase && E->getBase())
     return nullptr;
 
-  auto *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl()));
-  if (!ToMember && E->getMemberDecl())
+  auto ToMember = importNonNull(E->getMemberDecl());
+  if (!ToMember)
     return nullptr;
 
-  auto *ToDecl =
-      dyn_cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl()));
-  if (!ToDecl && E->getFoundDecl().getDecl())
+  auto ToDecl = importNullable(E->getFoundDecl().getDecl());
+  if (!ToDecl)
     return nullptr;
 
   DeclAccessPair ToFoundDecl =
-      DeclAccessPair::make(ToDecl, E->getFoundDecl().getAccess());
+      DeclAccessPair::make(*ToDecl, E->getFoundDecl().getAccess());
 
   DeclarationNameInfo ToMemberNameInfo(
     Importer.Import(E->getMemberNameInfo().getName()),
     Importer.Import(E->getMemberNameInfo().getLoc()));
 
   if (E->hasExplicitTemplateArgs()) {
     return nullptr; // FIXME: handle template arguments
   }
 
   return MemberExpr::Create(Importer.getToContext(), ToBase,
                             E->isArrow(),
                             Importer.Import(E->getOperatorLoc()),
                             Importer.Import(E->getQualifierLoc()),
                             Importer.Import(E->getTemplateKeywordLoc()),
-                            ToMember, ToFoundDecl, ToMemberNameInfo,
+                            *ToMember, ToFoundDecl, ToMemberNameInfo,
                             nullptr, T, E->getValueKind(),
                             E->getObjectKind());
 }
 
 Expr *ASTNodeImporter::VisitCXXPseudoDestructorExpr(
     CXXPseudoDestructorExpr *E) {
   Expr *BaseE = Importer.Import(E->getBase());
   if (!BaseE)
Expr *ASTNodeImporter::VisitCXXDependentScopeMemberExpr(
 
   DeclarationName Name = Importer.Import(E->getMember());
   if (!E->getMember().isEmpty() && Name.isEmpty())
     return nullptr;
 
   DeclarationNameInfo MemberNameInfo(Name, Importer.Import(E->getMemberLoc()));
   // Import additional name location/type info.
   ImportDeclarationNameLoc(E->getMemberNameInfo(), MemberNameInfo);
-  auto ToFQ = Importer.Import(E->getFirstQualifierFoundInScope());
-  if (!ToFQ && E->getFirstQualifierFoundInScope())
+  auto ToFQ = importNullable(E->getFirstQualifierFoundInScope());
+  if (!ToFQ)
     return nullptr;
 
   return CXXDependentScopeMemberExpr::Create(
       Importer.getToContext(), Base, BaseType, E->isArrow(),
       Importer.Import(E->getOperatorLoc()),
       Importer.Import(E->getQualifierLoc()),
-      Importer.Import(E->getTemplateKeywordLoc()),
-      cast_or_null<NamedDecl>(ToFQ), MemberNameInfo, ResInfo);
+      Importer.Import(E->getTemplateKeywordLoc()), *ToFQ, MemberNameInfo,
+      ResInfo);
 }
 
 Expr *
 ASTNodeImporter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
   DeclarationName Name = Importer.Import(E->getDeclName());
   if (!E->getDeclName().isEmpty() && Name.isEmpty())
     return nullptr;
 
Expr *ASTNodeImporter::VisitCXXUnresolvedConstructExpr(
 
   return CXXUnresolvedConstructExpr::Create(
       Importer.getToContext(), Importer.Import(CE->getTypeSourceInfo()),
       Importer.Import(CE->getLParenLoc()), llvm::makeArrayRef(ToArgs),
       Importer.Import(CE->getRParenLoc()));
 }
 
 Expr *ASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
-  auto *NamingClass =
-      cast_or_null<CXXRecordDecl>(Importer.Import(E->getNamingClass()));
-  if (E->getNamingClass() && !NamingClass)
+  auto NamingClass = importNullable(E->getNamingClass());
+  if (E->getNamingClass())
     return nullptr;
 
   DeclarationName Name = Importer.Import(E->getName());
   if (E->getName() && !Name)
     return nullptr;
 
   DeclarationNameInfo NameInfo(Name, Importer.Import(E->getNameLoc()));
   // Import additional name location/type info.
   ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);
 
   UnresolvedSet<8> ToDecls;
   for (auto *D : E->decls()) {
-    if (auto *To = cast_or_null<NamedDecl>(Importer.Import(D)))
-      ToDecls.addDecl(To);
+    if (auto To = importNonNull(D))
+      ToDecls.addDecl(*To);
     else
       return nullptr;
   }
 
   TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
   if (E->hasExplicitTemplateArgs()) {
     if (ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
                                        E->template_arguments(), ToTAInfo))
       return nullptr;
     ResInfo = &ToTAInfo;
   }
 
   if (ResInfo || E->getTemplateKeywordLoc().isValid())
     return UnresolvedLookupExpr::Create(
-        Importer.getToContext(), NamingClass,
+        Importer.getToContext(), *NamingClass,
         Importer.Import(E->getQualifierLoc()),
         Importer.Import(E->getTemplateKeywordLoc()), NameInfo, E->requiresADL(),
         ResInfo, ToDecls.begin(), ToDecls.end());
 
   return UnresolvedLookupExpr::Create(
-      Importer.getToContext(), NamingClass,
+      Importer.getToContext(), *NamingClass,
       Importer.Import(E->getQualifierLoc()), NameInfo, E->requiresADL(),
       E->isOverloaded(), ToDecls.begin(), ToDecls.end());
 }
 
 Expr *ASTNodeImporter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
   DeclarationName Name = Importer.Import(E->getName());
   if (!E->getName().isEmpty() && Name.isEmpty())
     return nullptr;
   DeclarationNameInfo NameInfo(Name, Importer.Import(E->getNameLoc()));
   // Import additional name location/type info.
   ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);
 
   QualType BaseType = Importer.Import(E->getType());
   if (!E->getType().isNull() && BaseType.isNull())
     return nullptr;
 
   UnresolvedSet<8> ToDecls;
-  for (Decl *D : E->decls()) {
-    if (NamedDecl *To = cast_or_null<NamedDecl>(Importer.Import(D)))
-      ToDecls.addDecl(To);
+  for (auto I = E->decls_begin(), End = E->decls_end(); I != End; ++I) {
+    if (auto To = importNonNull(I.getDecl()))
+      ToDecls.addDecl(*To, I.getAccess());
     else
       return nullptr;
   }
 
   TemplateArgumentListInfo ToTAInfo;
   TemplateArgumentListInfo *ResInfo = nullptr;
   if (E->hasExplicitTemplateArgs()) {
     if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
return new (Importer.getToContext())
     CallExpr(Importer.getToContext(), ToCallee,
              llvm::makeArrayRef(ToArgs_Copied, NumArgs), T, E->getValueKind(),
              Importer.Import(E->getRParenLoc()));
 }
 
 Optional<LambdaCapture>
 ASTNodeImporter::ImportLambdaCapture(const LambdaCapture &From) {
   VarDecl *Var = nullptr;
-  if (From.capturesVariable()) {
-    Var = cast_or_null<VarDecl>(Importer.Import(From.getCapturedVar()));
-    if (!Var)
+  if (From.capturesVariable())
+    if (!importNonNull(From.getCapturedVar()))
       return None;
-  }
 
   return LambdaCapture(Importer.Import(From.getLocation()), From.isImplicit(),
                        From.getCaptureKind(), Var,
                        From.isPackExpansion()
                          ? Importer.Import(From.getEllipsisLoc())
                          : SourceLocation());
 }
 
 Expr *ASTNodeImporter::VisitLambdaExpr(LambdaExpr *LE) {
   CXXRecordDecl *FromClass = LE->getLambdaClass();
-  auto *ToClass = dyn_cast_or_null<CXXRecordDecl>(Importer.Import(FromClass));
-  if (!ToClass)
+  CXXRecordDecl *ToClass = nullptr;
+  if (importNonNullInto(ToClass, FromClass))
     return nullptr;
 
   // NOTE: lambda classes are created with BeingDefined flag set up.
   // It means that ImportDefinition doesn't work for them and we should fill it
   // manually.
-  if (ToClass->isBeingDefined()) {
-    for (auto FromField : FromClass->fields()) {
-      auto *ToField = cast_or_null<FieldDecl>(Importer.Import(FromField));
-      if (!ToField)
+  if (ToClass->isBeingDefined())
+    for (auto *FromField : FromClass->fields())
+      if (!importNonNull(FromField))
         return nullptr;
-    }
-  }
 
-  auto *ToCallOp = dyn_cast_or_null<CXXMethodDecl>(
-        Importer.Import(LE->getCallOperator()));
-  if (!ToCallOp)
+  if (!importNonNull(LE->getCallOperator()))
     return nullptr;
 
   ToClass->completeDefinition();
 
   unsigned NumCaptures = LE->capture_size();
   SmallVector<LambdaCapture, 8> Captures;
   Captures.reserve(NumCaptures);
   for (const auto &FromCapture : LE->captures()) {
Expr *ASTNodeImporter::VisitInitListExpr(InitListExpr *ILE) {
   if (ILE->hasArrayFiller()) {
     Expr *Filler = Importer.Import(ILE->getArrayFiller());
     if (!Filler)
       return nullptr;
     To->setArrayFiller(Filler);
   }
 
   if (FieldDecl *FromFD = ILE->getInitializedFieldInUnion()) {
-    auto *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD));
+    auto ToFD = importNonNull(FromFD);
     if (!ToFD)
       return nullptr;
-    To->setInitializedFieldInUnion(ToFD);
+    To->setInitializedFieldInUnion(*ToFD);
   }
 
   if (InitListExpr *SyntForm = ILE->getSyntacticForm()) {
     auto *ToSyntForm = cast_or_null<InitListExpr>(Importer.Import(SyntForm));
     if (!ToSyntForm)
       return nullptr;
     To->setSyntacticForm(ToSyntForm);
   }

 }
 
 Expr *ASTNodeImporter::VisitCXXInheritedCtorInitExpr(
     CXXInheritedCtorInitExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
-  auto *Ctor = cast_or_null<CXXConstructorDecl>(Importer.Import(
-      E->getConstructor()));
+  auto Ctor = importNonNull(E->getConstructor());
   if (!Ctor)
     return nullptr;
 
   return new (Importer.getToContext()) CXXInheritedCtorInitExpr(
-      Importer.Import(E->getLocation()), T, Ctor,
+      Importer.Import(E->getLocation()), T, *Ctor,
       E->constructsVBase(), E->inheritedFromVBase());
 }
 
 Expr *ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
   QualType ToType = Importer.Import(E->getType());
   if (ToType.isNull())
     return nullptr;
 

 Expr *ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
   QualType ToType = Importer.Import(E->getType());
   if (ToType.isNull())
     return nullptr;
   return new (Importer.getToContext()) ArrayInitIndexExpr(ToType);
 }
 
 Expr *ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
-  auto *ToField = dyn_cast_or_null<FieldDecl>(Importer.Import(DIE->getField()));
-  if (!ToField && DIE->getField())
+  auto ToField = importNonNull(DIE->getField());
+  if (!ToField)
     return nullptr;
 
   return CXXDefaultInitExpr::Create(
-      Importer.getToContext(), Importer.Import(DIE->getLocStart()), ToField);
+      Importer.getToContext(), Importer.Import(DIE->getLocStart()), *ToField);
 }
 
 Expr *ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
   QualType ToType = Importer.Import(E->getType());
   if (ToType.isNull() && !E->getType().isNull())
     return nullptr;
   ExprValueKind VK = E->getValueKind();
   CastKind CK = E->getCastKind();

 }
 
 Expr *ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
     SubstNonTypeTemplateParmExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
-  auto *Param = cast_or_null<NonTypeTemplateParmDecl>(
-        Importer.Import(E->getParameter()));
+  auto Param = importNonNull(E->getParameter());
   if (!Param)
     return nullptr;
 
   Expr *Replacement = Importer.Import(E->getReplacement());
   if (!Replacement)
     return nullptr;
 
   return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr(
-        T, E->getValueKind(), Importer.Import(E->getExprLoc()), Param,
+        T, E->getValueKind(), Importer.Import(E->getExprLoc()), *Param,
         Replacement);
 }
 
 Expr *ASTNodeImporter::VisitTypeTraitExpr(TypeTraitExpr *E) {
   QualType ToType = Importer.Import(E->getType());
   if (ToType.isNull())
     return nullptr;
 
Expr *ASTNodeImporter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
   Expr *Op = Importer.Import(E->getExprOperand());
   if (!Op)
     return nullptr;
 
   return new (Importer.getToContext())
       CXXTypeidExpr(ToType, Op, Importer.Import(E->getSourceRange()));
 }
 
-void ASTNodeImporter::ImportOverrides(CXXMethodDecl *ToMethod,
+bool ASTNodeImporter::ImportOverrides(CXXMethodDecl *ToMethod,
                                       CXXMethodDecl *FromMethod) {
   for (auto *FromOverriddenMethod : FromMethod->overridden_methods())
-    ToMethod->addOverriddenMethod(
-      cast<CXXMethodDecl>(Importer.Import(const_cast<CXXMethodDecl*>(
-                                            FromOverriddenMethod))));
+    if (auto ToOverriddenMethod = importNonNull(FromOverriddenMethod))
+      ToMethod->addOverriddenMethod(*ToOverriddenMethod);
+    else
+      return true;
+  return false;
 }
 
 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
                          ASTContext &FromContext, FileManager &FromFileManager,
                          bool MinimalImport)
     : ToContext(ToContext), FromContext(FromContext),
       ToFileManager(ToFileManager), FromFileManager(FromFileManager),
       Minimal(MinimalImport) {
if (Pos != ImportedDecls.end()) {
     // FIXME: move this call to ImportDeclParts().
     ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD, ToD);
     return ToD;
   } else {
     return nullptr;
   }
 }
 
-Decl *ASTImporter::Import(Decl *FromD) {
+OptionalDecl ASTImporter::Import(Decl *FromD) {
   if (!FromD)
+    // The only case where returning nullptr instead of None is valid.
     return nullptr;
 
   ASTNodeImporter Importer(*this);
 
   // Check whether we've already imported this declaration.
-  Decl *ToD = GetAlreadyImportedOrNull(FromD);
-  if (ToD) {
+  Decl *AlreadyImported = GetAlreadyImportedOrNull(FromD);
+  if (AlreadyImported) {
     // If FromD has some updated flags after last import, apply it
-    updateFlags(FromD, ToD);
-    return ToD;
+    updateFlags(FromD, AlreadyImported);
+    return AlreadyImported;
   }
 
   // Import the type.
-  ToD = Importer.Visit(FromD);
+  auto ToD = Importer.Visit(FromD);
   if (!ToD)
-    return nullptr;
+    return None;
 
   // Notify subclasses.
-  Imported(FromD, ToD);
+  Imported(FromD, *ToD);
 
   return ToD;
 }
 
 DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
   if (!FromDC)
     return FromDC;
 
-  auto *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
-  if (!ToDC)
+  auto ToD = Import(cast<Decl>(FromDC));
+  if (!ToD)
     return nullptr;
 
+  auto *ToDC = cast<DeclContext>(*ToD);
+
   // When we're using a record/enum/Objective-C class/protocol as a context, we
   // need it to have a definition.
   if (auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
     auto *FromRecord = cast<RecordDecl>(FromDC);
     if (ToRecord->isCompleteDefinition()) {
       // Do nothing.
     } else if (FromRecord->isCompleteDefinition()) {
       ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord,
Stmt *ASTImporter::Import(Stmt *FromS) {
   ImportedStmts[FromS] = ToS;
   return ToS;
 }
 
 NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
   if (!FromNNS)
     return nullptr;
 
-  NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
+  NestedNameSpecifier *Prefix = Import(FromNNS->getPrefix());
 
   switch (FromNNS->getKind()) {
   case NestedNameSpecifier::Identifier:
     if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
-      return NestedNameSpecifier::Create(ToContext, prefix, II);
+      return NestedNameSpecifier::Create(ToContext, Prefix, II);
     }
     return nullptr;
 
   case NestedNameSpecifier::Namespace:
-    if (auto *NS =
-            cast_or_null<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
-      return NestedNameSpecifier::Create(ToContext, prefix, NS);
-    }
+    if (auto NS = importNonNull(FromNNS->getAsNamespace()))
+      return NestedNameSpecifier::Create(ToContext, Prefix, *NS);
     return nullptr;
 
   case NestedNameSpecifier::NamespaceAlias:
-    if (auto *NSAD =
-          cast_or_null<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
-      return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
-    }
+    if (auto NSAD = importNonNull(FromNNS->getAsNamespaceAlias()))
+      return NestedNameSpecifier::Create(ToContext, Prefix, *NSAD);
     return nullptr;
 
   case NestedNameSpecifier::Global:
     return NestedNameSpecifier::GlobalSpecifier(ToContext);
 
   case NestedNameSpecifier::Super:
-    if (auto *RD =
-            cast_or_null<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) {
-      return NestedNameSpecifier::SuperSpecifier(ToContext, RD);
-    }
+    if (auto RD = importNonNull(FromNNS->getAsRecordDecl()))
+      return NestedNameSpecifier::SuperSpecifier(ToContext, *RD);
     return nullptr;
 
   case NestedNameSpecifier::TypeSpec:
   case NestedNameSpecifier::TypeSpecWithTemplate: {
       QualType T = Import(QualType(FromNNS->getAsType(), 0u));
       if (!T.isNull()) {
         bool bTemplate = FromNNS->getKind() ==
                          NestedNameSpecifier::TypeSpecWithTemplate;
-        return NestedNameSpecifier::Create(ToContext, prefix,
+        return NestedNameSpecifier::Create(ToContext, Prefix,
                                            bTemplate, T.getTypePtr());
       }
     }
       return nullptr;
   }
 
   llvm_unreachable("Invalid nested name specifier kind");
 }
NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
   }
 
   return Builder.getWithLocInContext(getToContext());
 }
 
 TemplateName ASTImporter::Import(TemplateName From) {
   switch (From.getKind()) {
   case TemplateName::Template:
-    if (auto *ToTemplate =
-            cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
-      return TemplateName(ToTemplate);
-
+    if (auto ToTemplate = importNonNull(From.getAsTemplateDecl()))
+      return TemplateName(*ToTemplate);
     return {};
 
   case TemplateName::OverloadedTemplate: {
     OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
     UnresolvedSet<2> ToTemplates;
     for (auto *I : *FromStorage) {
-      if (auto *To = cast_or_null<NamedDecl>(Import(I)))
-        ToTemplates.addDecl(To);
+      if (auto To = importNonNull(I))
+        ToTemplates.addDecl(*To);
       else
         return {};
     }
     return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
                                                ToTemplates.end());
   }
 
   case TemplateName::QualifiedTemplate: {
     QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
     NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
     if (!Qualifier)
       return {};
 
-    if (auto *ToTemplate =
-            cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
-      return ToContext.getQualifiedTemplateName(Qualifier,
-                                                QTN->hasTemplateKeyword(),
-                                                ToTemplate);
-
+    if (auto ToTemplate = importNonNull(From.getAsTemplateDecl()))
+      return ToContext.getQualifiedTemplateName(
+          Qualifier, QTN->hasTemplateKeyword(), *ToTemplate);
     return {};
   }
 
   case TemplateName::DependentTemplate: {
     DependentTemplateName *DTN = From.getAsDependentTemplateName();
     NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
     if (!Qualifier)
       return {};
 
     if (DTN->isIdentifier()) {
       return ToContext.getDependentTemplateName(Qualifier,
                                                 Import(DTN->getIdentifier()));
     }
 
     return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
   }
 
   case TemplateName::SubstTemplateTemplateParm: {
-    SubstTemplateTemplateParmStorage *subst
-      = From.getAsSubstTemplateTemplateParm();
-    auto *param =
-        cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
-    if (!param)
+    auto *Subst = From.getAsSubstTemplateTemplateParm();
+    auto Param = importNonNull(Subst->getParameter());
+    if (!Param)
       return {};
 
-    TemplateName replacement = Import(subst->getReplacement());
-    if (replacement.isNull())
+    TemplateName Replacement = Import(Subst->getReplacement());
+    if (Replacement.isNull())
       return {};
 
-    return ToContext.getSubstTemplateTemplateParm(param, replacement);
+    return ToContext.getSubstTemplateTemplateParm(*Param, Replacement);
   }
 
   case TemplateName::SubstTemplateTemplateParmPack: {
     SubstTemplateTemplateParmPackStorage *SubstPack
       = From.getAsSubstTemplateTemplateParmPack();
-    auto *Param =
-        cast_or_null<TemplateTemplateParmDecl>(
-            Import(SubstPack->getParameterPack()));
+    auto Param = importNonNull(SubstPack->getParameterPack());
     if (!Param)
       return {};
 
     ASTNodeImporter Importer(*this);
     TemplateArgument ArgPack
       = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
     if (ArgPack.isNull())
       return {};
 
-    return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
+    return ToContext.getSubstTemplateTemplateParmPack(*Param, ArgPack);
   }
   }
 
   llvm_unreachable("Invalid template name kind");
 }
 
 SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
   if (FromLoc.isInvalid())
if (From->isBaseInitializer()) {
     if (!ToTInfo && From->getTypeSourceInfo())
       return nullptr;
 
     return new (ToContext) CXXCtorInitializer(
         ToContext, ToTInfo, From->isBaseVirtual(), Import(From->getLParenLoc()),
         ToExpr, Import(From->getRParenLoc()),
         From->isPackExpansion() ? Import(From->getEllipsisLoc())
                                 : SourceLocation());
+
   } else if (From->isMemberInitializer()) {
-    auto *ToField = cast_or_null<FieldDecl>(Import(From->getMember()));
-    if (!ToField && From->getMember())
+    auto ToField = importNonNull(From->getMember());
+    if (!ToField)
       return nullptr;
 
     return new (ToContext) CXXCtorInitializer(
-        ToContext, ToField, Import(From->getMemberLocation()),
+        ToContext, *ToField, Import(From->getMemberLocation()),
         Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
+
   } else if (From->isIndirectMemberInitializer()) {
-    auto *ToIField = cast_or_null<IndirectFieldDecl>(
-        Import(From->getIndirectMember()));
-    if (!ToIField && From->getIndirectMember())
+    auto ToIField = importNonNull(From->getIndirectMember());
+    if (!ToIField)
       return nullptr;
 
     return new (ToContext) CXXCtorInitializer(
-        ToContext, ToIField, Import(From->getMemberLocation()),
+        ToContext, *ToIField, Import(From->getMemberLocation()),
         Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
+
   } else if (From->isDelegatingInitializer()) {
     TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
     if (!ToTInfo && From->getTypeSourceInfo())
       return nullptr;
 
     return new (ToContext)
         CXXCtorInitializer(ToContext, ToTInfo, Import(From->getLParenLoc()),
                            ToExpr, Import(From->getRParenLoc()));
CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier(
         BaseSpec->getAccessSpecifierAsWritten(),
         Import(BaseSpec->getTypeSourceInfo()),
         Import(BaseSpec->getEllipsisLoc()));
   ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
   return Imported;
 }
 
 void ASTImporter::ImportDefinition(Decl *From) {
-  Decl *To = Import(From);
-  if (!To)
-    return;
+  auto ImportRes = Import(From);
+  if (!ImportRes)
+    return; // FIXME: Notify caller about error happened.
+
+  auto *To = *ImportRes;
 
   if (auto *FromDC = cast<DeclContext>(From)) {
     ASTNodeImporter Importer(*this);
 
     if (auto *ToRecord = dyn_cast<RecordDecl>(To)) {
       if (!ToRecord->getDefinition()) {
         Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
                                   ASTNodeImporter::IDK_Everything);
if (auto *FromDC = cast<DeclContext>(From)) {
     if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
       if (!ToProto->getDefinition()) {
         Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
                                   ASTNodeImporter::IDK_Everything);
         return;
       }
     }
 
-    Importer.ImportDeclContext(FromDC, true);
+    if (Importer.ImportDeclContext(FromDC, true))
+      return; // FIXME: return true
   }
 }
 
 DeclarationName ASTImporter::Import(DeclarationName FromName) {
   if (!FromName)
     return {};
 
   switch (FromName.getNameKind()) {
case DeclarationName::CXXDestructorName: {
     if (T.isNull())
       return {};
 
     return ToContext.DeclarationNames.getCXXDestructorName(
                                                ToContext.getCanonicalType(T));
   }
 
   case DeclarationName::CXXDeductionGuideName: {
-    auto *Template = cast_or_null<TemplateDecl>(
-        Import(FromName.getCXXDeductionGuideTemplate()));
-    if (!Template)
-      return {};
-    return ToContext.DeclarationNames.getCXXDeductionGuideName(Template);
+    if (auto Template = importNonNull(FromName.getCXXDeductionGuideTemplate()))
+      return ToContext.DeclarationNames.getCXXDeductionGuideName(*Template);
   }
 
   case DeclarationName::CXXConversionFunctionName: {
     QualType T = Import(FromName.getCXXNameType());
     if (T.isNull())
       return {};
 
     return ToContext.DeclarationNames.getCXXConversionFunctionName(

lib/AST/ExternalASTMerger.cpp

bool ExternalASTMerger::FindExternalVisibleDeclsByName(const DeclContext *DC,
 
   if (Candidates.empty())
     return false;
 
   Decls.reserve(Candidates.size());
   for (const Candidate &C : Candidates) {
     Decl *LookupRes = C.first.get();
     ASTImporter *Importer = C.second;
-    NamedDecl *ND = cast_or_null<NamedDecl>(Importer->Import(LookupRes));
+    auto ImportRes = Importer->Import(LookupRes);
+    assert(ImportRes);
+    NamedDecl *ND = cast_or_null<NamedDecl>(*ImportRes);
     assert(ND);
     // If we don't import specialization, they are not available via lookup
     // because the lookup result is imported TemplateDecl and it does not
     // reference its specializations until they are imported explicitly.
     bool IsSpecImportFailed =
         importSpecializationsIfNeeded(LookupRes, Importer);
     assert(!IsSpecImportFailed);
     (void)IsSpecImportFailed;
     Decls.push_back(ND);
   }
   SetExternalVisibleDeclsForName(DC, Name, Decls);
   return true;
 }
 
 void ExternalASTMerger::FindExternalLexicalDecls(
     const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
     SmallVectorImpl<Decl *> &Result) {
   ForEachMatchingDC(DC, [&](ASTImporter &Forward, ASTImporter &Reverse,
                             Source<const DeclContext *> SourceDC) -> bool {
     for (const Decl *SourceDecl : SourceDC.get()->decls()) {
       if (IsKindWeWant(SourceDecl->getKind())) {
-        Decl *ImportedDecl = Forward.Import(const_cast<Decl *>(SourceDecl));
-        assert(!ImportedDecl || IsSameDC(ImportedDecl->getDeclContext(), DC));
+        auto ImportedDecl = Forward.Import(SourceDecl);
+        assert(!ImportedDecl ||
+               IsSameDC((*ImportedDecl)->getDeclContext(), DC));
         (void)ImportedDecl;
       }
     }
     return false;
   });
 }
 

lib/CrossTU/CrossTranslationUnit.cpp

if (FnUnitCacheEntry == FunctionASTUnitMap.end()) {
     Unit = FnUnitCacheEntry->second;
   }
   return Unit;
 }
 
 llvm::Expected<const FunctionDecl *>
 CrossTranslationUnitContext::importDefinition(const FunctionDecl *FD) {
   ASTImporter &Importer = getOrCreateASTImporter(FD->getASTContext());
-  auto *ToDecl =
-      cast<FunctionDecl>(Importer.Import(const_cast<FunctionDecl *>(FD)));
+  auto Imported = Importer.Import(const_cast<FunctionDecl *>(FD));
+  if (!Imported)
+    return llvm::make_error<IndexError>(index_error_code::failed_import);
+
+  auto *ToDecl = cast<FunctionDecl>(*Imported);
   assert(ToDecl->hasBody());
   assert(FD->hasBody() && "Functions already imported should have body.");
   return ToDecl;
 }
 
 ASTImporter &
 CrossTranslationUnitContext::getOrCreateASTImporter(ASTContext &From) {
   auto I = ASTUnitImporterMap.find(From.getTranslationUnitDecl());

lib/Frontend/ASTMerge.cpp

for (unsigned I = 0, N = ASTFiles.size(); I != N; ++I) {
     TranslationUnitDecl *TU = Unit->getASTContext().getTranslationUnitDecl();
     for (auto *D : TU->decls()) {
       // Don't re-import __va_list_tag, __builtin_va_list.
       if (const auto *ND = dyn_cast<NamedDecl>(D))
         if (IdentifierInfo *II = ND->getIdentifier())
           if (II->isStr("__va_list_tag") || II->isStr("__builtin_va_list"))
             continue;
 
-      Decl *ToD = Importer.Import(D);
+      auto ToD = Importer.Import(D);
     
       if (ToD) {
-        DeclGroupRef DGR(ToD);
+        DeclGroupRef DGR(*ToD);
         CI.getASTConsumer().HandleTopLevelDecl(DGR);
       }
     }
   }
 
   AdaptedAction->ExecuteAction();
   CI.getDiagnostics().getClient()->EndSourceFile();
 }

unittests/AST/ASTImporterTest.cpp

NodeType importNode(ASTUnit *From, ASTUnit *To, ASTImporter &Importer,
 
     // Add 'From' file to virtual file system so importer can 'find' it
     // while importing SourceLocations. It is safe to add same file multiple
     // times - it just isn't replaced.
     StringRef FromFileName = From->getMainFileName();
     createVirtualFileIfNeeded(To, FromFileName,
                               From->getBufferForFile(FromFileName));
 
-    auto Imported = Importer.Import(Node);
+    auto ImportRes = Importer.Import(Node);
+    EXPECT_TRUE(ImportRes);
+
+    auto Imported = *ImportRes;
 
     // This should dump source locations and assert if some source locations
     // were not imported.
     SmallString<1024> ImportChecker;
     llvm::raw_svector_ostream ToNothing(ImportChecker);
     ToCtx.getTranslationUnitDecl()->print(ToNothing);
 
     // This traverses the AST to catch certain bugs like poorly or not
void lazyInitImporter(ASTUnit *ToAST) {
         Importer.reset(new ASTImporter(
             ToAST->getASTContext(), ToAST->getFileManager(),
             Unit->getASTContext(), Unit->getFileManager(), false));
       }
       assert(&ToAST->getASTContext() == &Importer->getToContext());
       createVirtualFileIfNeeded(ToAST, FileName, Code);
     }
 
-    Decl *import(ASTUnit *ToAST, Decl *FromDecl) {
+    Optional<Decl *> import(ASTUnit *ToAST, Decl *FromDecl) {
       lazyInitImporter(ToAST);
       return Importer->Import(FromDecl);
      }
 
     QualType import(ASTUnit *ToAST, QualType FromType) {
       lazyInitImporter(ToAST);
       return Importer->Import(FromType);
     }
assert(ImportedII && "Declaration with the given identifier "
                          "should be specified in test!");
     DeclarationName ImportDeclName(ImportedII);
     SmallVector<NamedDecl *, 4> FoundDecls;
     FromCtx.getTranslationUnitDecl()->localUncachedLookup(ImportDeclName,
                                                           FoundDecls);
 
     assert(FoundDecls.size() == 1);
 
-    Decl *Imported = FromTU.import(ToAST.get(), FoundDecls.front());
+    auto Imported = FromTU.import(ToAST.get(), FoundDecls.front());
 
     assert(Imported);
-    return std::make_tuple(*FoundDecls.begin(), Imported);
+    return std::make_tuple(*FoundDecls.begin(), *Imported);
   }
 
   // Creates a TU decl for the given source code which can be used as a From
   // context.  May be called several times in a given test (with different file
   // name).
   TranslationUnitDecl *getTuDecl(StringRef SrcCode, Language Lang,
                                  StringRef FileName = "input.cc") {
     assert(
TranslationUnitDecl *getToTuDecl(StringRef ToSrcCode, Language ToLang) {
     ToAST->enableSourceFileDiagnostics();
 
     return ToAST->getASTContext().getTranslationUnitDecl();
   }
 
   // Import the given Decl into the ToCtx.
   // May be called several times in a given test.
   // The different instances of the param From may have different ASTContext.
-  Decl *Import(Decl *From, Language ToLang) {
+  Decl * Import(Decl *From, Language ToLang) {
     lazyInitToAST(ToLang);
     TU *FromTU = findFromTU(From);
-    return FromTU->import(ToAST.get(), From);
+    auto Imported = FromTU->import(ToAST.get(), From);
+    return Imported ? *Imported : nullptr;
   }
 
   QualType ImportType(QualType FromType, Decl *TUDecl, Language ToLang) {
     lazyInitToAST(ToLang);
     TU *FromTU = findFromTU(TUDecl);
     return FromTU->import(ToAST.get(), FromType);
    }