Cache failed clang::Decl's so we can avoid reparsing

Author: thomassw66

lib/ClangImporter/ClangImporter.cpp

@@ -3342,7 +3342,8 @@ std::string ClangImporter::getClangModuleHash() const {
 }
 
 Decl *ClangImporter::importDeclCached(const clang::NamedDecl *ClangDecl) {
-  return Impl.importDeclCached(ClangDecl, Impl.CurrentVersion);
+  return Impl.importDeclCached(ClangDecl, Impl.CurrentVersion)
+      .getValueOr(nullptr);
 }
 
 void ClangImporter::printStatistics() const {

lib/ClangImporter/ImportDecl.cpp

@@ -4587,7 +4587,8 @@ namespace {
 
       // While importing the DeclContext, we might have imported the decl
       // itself.
-      if (auto Known = Impl.importDeclCached(decl, getVersion()))
+      if (auto Known =
+              Impl.importDeclCached(decl, getVersion()).getValueOr(nullptr))
         return Known;
 
       ImportedName importedName;
@@ -5615,7 +5616,8 @@ namespace {
 
       // While importing the DeclContext, we might have imported the decl
       // itself.
-      if (auto Known = Impl.importDeclCached(decl, getVersion()))
+      if (auto Known =
+              Impl.importDeclCached(decl, getVersion()).getValueOr(nullptr))
         return Known;
 
       return importObjCPropertyDecl(decl, dc);
@@ -8271,16 +8273,16 @@ void SwiftDeclConverter::importInheritedConstructors(
   }
 }
 
-Decl *ClangImporter::Implementation::importDeclCached(
-    const clang::NamedDecl *ClangDecl,
-    ImportNameVersion version,
+Optional<Decl *> ClangImporter::Implementation::importDeclCached(
+    const clang::NamedDecl *ClangDecl, ImportNameVersion version,
     bool UseCanonical) {
-  auto Known = ImportedDecls.find(
-    { UseCanonical? ClangDecl->getCanonicalDecl(): ClangDecl, version });
+  std::pair<const clang::Decl *, Version> Key = {
+      UseCanonical ? ClangDecl->getCanonicalDecl() : ClangDecl, version};
+  auto Known = ImportedDecls.find(Key);
   if (Known != ImportedDecls.end())
     return Known->second;
 
-  return nullptr;
+  return None;
 }
 
 /// Checks if we don't need to import the typedef itself.  If the typedef
@@ -9021,12 +9023,11 @@ Decl *ClangImporter::Implementation::importDeclAndCacheImpl(
                                     Instance->getSourceManager(), "importing");
 
   auto Canon = cast<clang::NamedDecl>(UseCanonicalDecl? ClangDecl->getCanonicalDecl(): ClangDecl);
-
-  if (auto Known = importDeclCached(Canon, version, UseCanonicalDecl)) {
-    if (!SuperfluousTypedefsAreTransparent &&
-        SuperfluousTypedefs.count(Canon))
+  if (Optional<Decl *> Known =
+          importDeclCached(Canon, version, UseCanonicalDecl)) {
+    if (!SuperfluousTypedefsAreTransparent && SuperfluousTypedefs.count(Canon))
       return nullptr;
-    return Known;
+    return Known.getValue();
   }
 
   bool TypedefIsSuperfluous = false;
@@ -9035,8 +9036,10 @@ Decl *ClangImporter::Implementation::importDeclAndCacheImpl(
   startedImportingEntity();
   Decl *Result = importDeclImpl(ClangDecl, version, TypedefIsSuperfluous,
                                 HadForwardDeclaration);
-  if (!Result)
+  if (!Result) {
+    ImportedDecls[{Canon, version}] = nullptr;
     return nullptr;
+  }
 
   if (TypedefIsSuperfluous) {
     SuperfluousTypedefs.insert(Canon);

lib/ClangImporter/ImporterImpl.h

@@ -415,7 +415,8 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   llvm::SmallDenseMap<ModuleDecl *, SourceFile *> ClangSwiftAttrSourceFiles;
 
 public:
-  /// Mapping of already-imported declarations.
+  /// Mapping of already-imported declarations. If the import failed then it
+  /// maps to nullptr.
   llvm::DenseMap<std::pair<const clang::Decl *, Version>, Decl *> ImportedDecls;
 
   /// The set of "special" typedef-name declarations, which are
@@ -851,8 +852,9 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
 
   /// If we already imported a given decl, return the corresponding Swift decl.
   /// Otherwise, return nullptr.
-  Decl *importDeclCached(const clang::NamedDecl *ClangDecl, Version version,
-                         bool UseCanonicalDecl = true);
+  Optional<Decl *> importDeclCached(const clang::NamedDecl *ClangDecl,
+                                    Version version,
+                                    bool UseCanonicalDecl = true);
 
   Decl *importDeclImpl(const clang::NamedDecl *ClangDecl, Version version,
                        bool &TypedefIsSuperfluous, bool &HadForwardDeclaration);

lib/ClangImporter/Serializability.cpp

@@ -66,7 +66,8 @@ class SerializationPathFinder {
 
   StableSerializationPath findImportedPath(const clang::NamedDecl *decl) {
     // We've almost certainly imported this declaration, look for it.
-    if (auto swiftDecl = Impl.importDeclCached(decl, Impl.CurrentVersion)) {
+    if (auto swiftDecl = Impl.importDeclCached(decl, Impl.CurrentVersion)
+                             .getValueOr(nullptr)) {
       // The serialization code doesn't allow us to cross-reference
       // typealias declarations directly.  We could fix that, but it's
       // easier to just avoid doing so and fall into the external-path code.