Implement SE-0075: CanImport

This implementation required a compromise between parser
performance and AST structuring.  On the one hand, Parse
must be fast in order to keep things in the IDE zippy, on
the other we must hit the disk to properly resolve 'canImport'
conditions and inject members of the active clause into the AST.
Additionally, a Parse-only pass may not provide platform-specific
information to the compiler invocation and so may mistakenly
activate or de-activate branches in the if-configuration decl.

The compromise is to perform condition evaluation only when
continuing on to semantic analysis.  This keeps the parser quick
and avoids the unpacking that parse does for active conditions
while still retaining the ability to see through to an active
condition when we know we're moving on to semantic analysis anyways.

Author: CodaFi

include/swift/AST/ASTContext.h

@@ -262,6 +262,9 @@ class ASTContext {
   llvm::DenseMap<const Pattern *, DeclContext *>
     DelayedPatternContexts;
 
+  /// Cache of module names that fail the 'canImport' test in this context.
+  llvm::SmallPtrSet<Identifier, 8> FailedModuleImportNames;
+  
 public:
   /// \brief Retrieve the allocator for the given arena.
   llvm::BumpPtrAllocator &

include/swift/Basic/LangOptions.h

@@ -43,8 +43,9 @@ namespace swift {
     Endianness,
     /// Runtime support (_ObjC or _Native)
     Runtime,
+    /// Conditional import of module
+    CanImport,
   };
-  enum { NumPlatformConditionKind = 4 };
 
   /// Describes which Swift 3 Objective-C inference warnings should be
   /// emitted.
@@ -341,8 +342,7 @@ namespace swift {
     }
 
   private:
-    llvm::SmallVector<std::pair<PlatformConditionKind, std::string>,
-                      NumPlatformConditionKind>
+    llvm::SmallVector<std::pair<PlatformConditionKind, std::string>, 4>
         PlatformConditionValues;
     llvm::SmallVector<std::string, 2> CustomConditionalCompilationFlags;
   };

include/swift/Frontend/Frontend.h

@@ -426,7 +426,9 @@ class CompilerInstance {
 
   /// Parses the input file but does no type-checking or module imports.
   /// Note that this only supports parsing an invocation with a single file.
-  void performParseOnly();
+  ///
+  ///
+  void performParseOnly(bool EvaluateConditionals = false);
 
   /// Frees up the ASTContext and SILModule objects that this instance is
   /// holding on.

include/swift/Parse/PersistentParserState.h

@@ -98,7 +98,9 @@ class PersistentParserState {
   };
 
   bool InPoundLineEnvironment = false;
-
+  // FIXME: When condition evaluation moves to a later phase, remove this bit
+  // and adjust the client call 'performParseOnly'.
+  bool PerformConditionEvaluation = true;
 private:
   ScopeInfo ScopeInfo;
   typedef llvm::DenseMap<AbstractFunctionDecl *,

lib/AST/ASTContext.cpp

@@ -1458,12 +1458,18 @@ bool ASTContext::canImportModule(std::pair<Identifier, SourceLoc> ModulePath) {
   if (getLoadedModule(ModulePath) != nullptr)
     return true;
 
+  // If we've failed loading this module before, don't look for it again.
+  if (FailedModuleImportNames.count(ModulePath.first))
+    return false;
+
   // Otherwise, ask the module loaders.
   for (auto &importer : Impl.ModuleLoaders) {
     if (importer->canImportModule(ModulePath)) {
       return true;
     }
   }
+
+  FailedModuleImportNames.insert(ModulePath.first);
   return false;
 }
 

lib/Basic/LangOptions.cpp

@@ -98,6 +98,10 @@ checkPlatformConditionSupported(PlatformConditionKind Kind, StringRef Value,
   case PlatformConditionKind::Runtime:
     return contains(SupportedConditionalCompilationRuntimes, Value,
                     suggestions);
+  case PlatformConditionKind::CanImport:
+    // All importable names are valid.
+    // FIXME: Perform some kind of validation of the string?
+    return true;
   }
   llvm_unreachable("Unhandled enum value");
 }

lib/Frontend/Frontend.cpp

@@ -581,7 +581,7 @@ void CompilerInstance::performSema() {
         finishTypeChecking(*SF);
 }
 
-void CompilerInstance::performParseOnly() {
+void CompilerInstance::performParseOnly(bool EvaluateConditionals) {
   const InputFileKind Kind = Invocation.getInputKind();
   ModuleDecl *MainModule = getMainModule();
   Context->LoadedModules[MainModule->getName()] = MainModule;
@@ -608,6 +608,7 @@ void CompilerInstance::performParseOnly() {
   }
 
   PersistentParserState PersistentState;
+  PersistentState.PerformConditionEvaluation = EvaluateConditionals;
   // Parse all the library files.
   for (auto BufferID : BufferIDs) {
     if (BufferID == MainBufferID)

lib/Parse/ParseIfConfig.cpp

@@ -36,6 +36,7 @@ Optional<PlatformConditionKind> getPlatformConditionKind(StringRef Name) {
     .Case("arch", PlatformConditionKind::Arch)
     .Case("_endian", PlatformConditionKind::Endianness)
     .Case("_runtime", PlatformConditionKind::Runtime)
+    .Case("canImport", PlatformConditionKind::CanImport)
     .Default(None);
 }
 
@@ -289,7 +290,7 @@ class ValidateIfConfigCondition :
       return E;
     }
 
-    // ( 'os' | 'arch' | '_endian' | '_runtime' ) '(' identifier ')''
+    // ( 'os' | 'arch' | '_endian' | '_runtime' | 'canImport') '(' identifier ')''
     auto Kind = getPlatformConditionKind(*KindName);
     if (!Kind.hasValue()) {
       D.diagnose(E->getLoc(), diag::unsupported_platform_condition_expression);
@@ -331,6 +332,8 @@ class ValidateIfConfigCondition :
         DiagName = "architecture"; break;
       case PlatformConditionKind::Endianness:
         DiagName = "endianness"; break;
+      case PlatformConditionKind::CanImport:
+        DiagName = "import conditional"; break;
       case PlatformConditionKind::Runtime:
         llvm_unreachable("handled above");
       }
@@ -450,6 +453,9 @@ class EvaluateIfConfigCondition :
           Str, SourceLoc(), nullptr).getValue();
       auto thisVersion = Ctx.LangOpts.EffectiveLanguageVersion;
       return thisVersion >= Val;
+    } else if (KindName == "canImport") {
+      auto Str = extractExprSource(Ctx.SourceMgr, Arg);
+      return Ctx.canImportModule({ Ctx.getIdentifier(Str) , E->getLoc()  });
     }
 
     auto Val = getDeclRefStr(Arg);
@@ -567,9 +573,10 @@ ParserResult<IfConfigDecl> Parser::parseIfConfig(
     Expr *Condition = nullptr;
     bool isActive = false;
 
-    // Parse and evaluate the directive.
+    // Parse the condition.  Evaluate it to determine the active
+    // clause unless we're doing a parse-only pass.
     if (isElse) {
-      isActive = !foundActive;
+      isActive = !foundActive && State->PerformConditionEvaluation;
     } else {
       llvm::SaveAndRestore<bool> S(InPoundIfEnvironment, true);
       ParserResult<Expr> Result = parseExprSequence(diag::expected_expr,
@@ -582,8 +589,9 @@ ParserResult<IfConfigDecl> Parser::parseIfConfig(
         // Error in the condition;
         isActive = false;
         isVersionCondition = false;
-      } else if (!foundActive) {
-        // Evaluate the condition only if we haven't found any active one.
+      } else if (!foundActive && State->PerformConditionEvaluation) {
+        // Evaluate the condition only if we haven't found any active one and
+        // we're not in parse-only mode.
         isActive = evaluateIfConfigCondition(Condition, Context);
         isVersionCondition = isVersionIfConfigCondition(Condition);
       }

test/ClangImporter/MixedSource/can_import_objc_idempotent.swift

@@ -13,7 +13,6 @@
 // RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -I %S/../Inputs/custom-modules -typecheck %s -verify
 
 // REQUIRES: objc_interop
-// REQUIRES: can_import
 
 // Test that 'canImport(Foo)' directives do not open symbols from 'Foo' into the
 // current module.  Only an 'import Foo' statement should do this.

test/ClangImporter/can_import_missing_requirement.swift

@@ -1,7 +1,6 @@
 // RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -I %S/Inputs/missing-requirement %s -verify
 
 // REQUIRES: objc_interop
-// REQUIRES: can_import
 
 class Unique {}