Optimize Condition Resolution (#6279)

* Pack the bits for IfConfigDecls into Decl

* Don't open symbols into a module when evaluating canImport statements

The module loaders now have API to check whether a given module can be
imported without importing the referenced module.  This provides a
significant speed boost to condition resolution and no longer
introduces symbols from the referenced module into the current context
without the user explicitly requesting it.

The definition of ‘canImport’ does not necessarily mean that a full
import without error is possible, merely that the path to the import is
visible to the compiler and the module is loadable in some form or
another.

Note that this means this check is insufficient to guarantee that you
are on one platform or another.  For those kinds of checks, use
‘os(OSNAME)’.

Author: CodaFi

include/swift/AST/ASTContext.h

@@ -580,6 +580,13 @@ class ASTContext {
   /// Does nothing in non-asserts (NDEBUG) builds.
   void verifyAllLoadedModules() const;
 
+  /// \brief Check whether the module with a given name can be imported without
+  /// importing it.
+  ///
+  /// Note that even if this check succeeds, errors may still occur if the
+  /// module is loaded in full.
+  bool canImportModule(std::pair<Identifier, SourceLoc> ModulePath);
+
   /// \returns a module with a given name that was already loaded.  If the
   /// module was not loaded, returns nullptr.
   ModuleDecl *getLoadedModule(

include/swift/AST/Decl.h

@@ -578,6 +578,20 @@ class alignas(1 << DeclAlignInBits) Decl {
   enum { NumExtensionDeclBits = NumDeclBits + 6 };
   static_assert(NumExtensionDeclBits <= 32, "fits in an unsigned");
 
+  class IfConfigDeclBitfields {
+    friend class IfConfigDecl;
+    unsigned : NumDeclBits;
+
+    /// Whether this decl is missing its closing '#endif'.
+    unsigned HadMissingEnd : 1;
+
+    /// Whether this condition has been resolved either statically by Parse or
+    /// later by Condition Resolution.
+    unsigned HasBeenResolved : 1;
+  };
+  enum { NumIfConfigDeclBits = NumDeclBits + 2 };
+  static_assert(NumIfConfigDeclBits <= 32, "fits in an unsigned");
+
 protected:
   union {
     DeclBitfields DeclBits;
@@ -601,6 +615,7 @@ class alignas(1 << DeclAlignInBits) Decl {
     PrecedenceGroupDeclBitfields PrecedenceGroupDeclBits;
     ImportDeclBitfields ImportDeclBits;
     ExtensionDeclBitfields ExtensionDeclBits;
+    IfConfigDeclBitfields IfConfigDeclBits;
     uint32_t OpaqueBits;
   };
 
@@ -1931,14 +1946,16 @@ class IfConfigDecl : public Decl {
   /// The array is ASTContext allocated.
   ArrayRef<IfConfigDeclClause> Clauses;
   SourceLoc EndLoc;
-  bool HadMissingEnd;
-  bool HasBeenResolved = false;
+
 public:
 
   IfConfigDecl(DeclContext *Parent, ArrayRef<IfConfigDeclClause> Clauses,
                SourceLoc EndLoc, bool HadMissingEnd)
-    : Decl(DeclKind::IfConfig, Parent), Clauses(Clauses),
-      EndLoc(EndLoc), HadMissingEnd(HadMissingEnd) {}
+    : Decl(DeclKind::IfConfig, Parent), Clauses(Clauses), EndLoc(EndLoc)
+  {
+    IfConfigDeclBits.HadMissingEnd = HadMissingEnd;
+    IfConfigDeclBits.HasBeenResolved = false;
+  }
 
   ArrayRef<IfConfigDeclClause> getClauses() const { return Clauses; }
 
@@ -1955,13 +1972,13 @@ class IfConfigDecl : public Decl {
     return {};
   }
 
-  bool isResolved() const { return HasBeenResolved; }
-  void setResolved() { HasBeenResolved = true; }
+  bool isResolved() const { return IfConfigDeclBits.HasBeenResolved; }
+  void setResolved() { IfConfigDeclBits.HasBeenResolved = true; }
 
   SourceLoc getEndLoc() const { return EndLoc; }
   SourceLoc getLoc() const { return Clauses[0].Loc; }
 
-  bool hadMissingEnd() const { return HadMissingEnd; }
+  bool hadMissingEnd() const { return IfConfigDeclBits.HadMissingEnd; }
 
   SourceRange getSourceRange() const;
 

include/swift/AST/ModuleLoader.h

@@ -74,6 +74,13 @@ class ModuleLoader {
 public:
   virtual ~ModuleLoader() = default;
 
+  /// \brief Check whether the module with a given name can be imported without
+  /// importing it.
+  ///
+  /// Note that even if this check succeeds, errors may still occur if the
+  /// module is loaded in full.
+  virtual bool canImportModule(std::pair<Identifier, SourceLoc> named) = 0;
+
   /// \brief Import a module with the given module path.
   ///
   /// \param importLoc The location of the 'import' keyword.

include/swift/ClangImporter/ClangImporter.h

@@ -94,6 +94,13 @@ class ClangImporter final : public ClangModuleLoader {
 
   ~ClangImporter();
 
+  /// \brief Check whether the module with a given name can be imported without
+  /// importing it.
+  ///
+  /// Note that even if this check succeeds, errors may still occur if the
+  /// module is loaded in full.
+  virtual bool canImportModule(std::pair<Identifier, SourceLoc> named) override;
+
   /// \brief Import a module with the given module path.
   ///
   /// Clang modules will be imported using the Objective-C ARC dialect,

include/swift/Sema/SourceLoader.h

@@ -48,6 +48,13 @@ class SourceLoader : public ModuleLoader {
   SourceLoader &operator=(const SourceLoader &) = delete;
   SourceLoader &operator=(SourceLoader &&) = delete;
 
+  /// \brief Check whether the module with a given name can be imported without
+  /// importing it.
+  ///
+  /// Note that even if this check succeeds, errors may still occur if the
+  /// module is loaded in full.
+  virtual bool canImportModule(std::pair<Identifier, SourceLoc> named) override;
+
   /// \brief Import a module with the given module path.
   ///
   /// \param importLoc The location of the 'import' keyword.

include/swift/Serialization/SerializedModuleLoader.h

@@ -48,6 +48,13 @@ class SerializedModuleLoader : public ModuleLoader {
   SerializedModuleLoader &operator=(const SerializedModuleLoader &) = delete;
   SerializedModuleLoader &operator=(SerializedModuleLoader &&) = delete;
 
+  /// \brief Check whether the module with a given name can be imported without
+  /// importing it.
+  ///
+  /// Note that even if this check succeeds, errors may still occur if the
+  /// module is loaded in full.
+  virtual bool canImportModule(std::pair<Identifier, SourceLoc> named) override;
+
   /// \brief Import a module with the given module path.
   ///
   /// \param importLoc The location of the 'import' keyword.

lib/AST/ASTContext.cpp

@@ -1263,6 +1263,20 @@ GenericEnvironment *ASTContext::getOrCreateCanonicalGenericEnvironment(
   return env;
 }
 
+bool ASTContext::canImportModule(std::pair<Identifier, SourceLoc> ModulePath) {
+  // If this module has already been successfully imported, it is importable.
+  if (getLoadedModule(ModulePath) != nullptr)
+    return true;
+
+  // Otherwise, ask the module loaders.
+  for (auto &importer : Impl.ModuleLoaders) {
+    if (importer->canImportModule(ModulePath)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 Module *
 ASTContext::getModule(ArrayRef<std::pair<Identifier, SourceLoc>> ModulePath) {
   assert(!ModulePath.empty());

lib/ClangImporter/ClangImporter.cpp

@@ -1022,6 +1022,23 @@ bool ClangImporter::isModuleImported(const clang::Module *M) {
   return M->NameVisibility == clang::Module::NameVisibilityKind::AllVisible;
 }
 
+bool ClangImporter::canImportModule(std::pair<Identifier, SourceLoc> moduleID) {
+  // Look up the top-level module to see if it exists.
+  // FIXME: This only works with top-level modules.
+  auto &clangHeaderSearch = Impl.getClangPreprocessor().getHeaderSearchInfo();
+  clang::Module *clangModule =
+    clangHeaderSearch.lookupModule(moduleID.first.str());
+  if (!clangModule) {
+    return false;
+  }
+
+  clang::Module::Requirement r;
+  clang::Module::UnresolvedHeaderDirective mh;
+  clang::Module *m;
+  auto &ctx = Impl.getClangASTContext();
+  return clangModule->isAvailable(ctx.getLangOpts(), getTargetInfo(), r, mh, m);
+}
+
 Module *ClangImporter::loadModule(
     SourceLoc importLoc,
     ArrayRef<std::pair<Identifier, SourceLoc>> path) {

lib/Parse/ConditionResolver.cpp

@@ -59,8 +59,7 @@ namespace {
 
     ConditionClauseResolver(SmallVectorImpl<Decl *> &ExtraTLCDs,
                             SourceFile &SF)
-    : NDF(SF), ExtraTLCDs(ExtraTLCDs), SF(SF),
-    Context(SF.getASTContext()) {}
+      : NDF(SF), ExtraTLCDs(ExtraTLCDs), SF(SF), Context(SF.getASTContext()) {}
 
     void resolveClausesAndInsertMembers(IterableDeclContext *Nom,
                                         IfConfigDecl *Cond) {
@@ -69,9 +68,9 @@ namespace {
         // Evaluate conditions until we find the active clause.
         DiagnosticTransaction DT(Context.Diags);
         auto classification =
-        Parser::classifyConditionalCompilationExpr(clause.Cond, Context,
-                                                   Context.Diags,
-                                                   /*fullCheck*/ true);
+          Parser::classifyConditionalCompilationExpr(clause.Cond, Context,
+                                                     Context.Diags,
+                                                     /*fullCheck*/ true);
         DT.abort();
         if (clause.Cond && !classification.getValueOr(false)) {
           continue;

lib/Parse/ParseStmt.cpp

@@ -1789,8 +1789,8 @@ Parser::classifyConditionalCompilationExpr(Expr *condition,
           if (!fullCheck) {
             return None;
           }
-          return
-            Context.getModule({ { argumentIdent, UDRE->getLoc() } }) != nullptr;
+
+          return Context.canImportModule({ argumentIdent, UDRE->getLoc() });
         }
 
         if (!fullCheck) {