Parser: teach canImport to take an additional parameter indicating the minimum module version

nkcsgexi · nkcsgexi · commit bbe5b83de91b · 2021-05-02T17:47:44.000-07:00
canImport should be able to take an additional parameter labeled by either version or
underlyingVersion. We need underlyingVersion for clang modules with Swift overlays because they
have separate version numbers. The library users are usually interested in checking the importability
of the underlying clang module instead of its Swift overlay.

Part of rdar://73992299
diff --git a/include/swift/AST/ASTContext.h b/include/swift/AST/ASTContext.h
@@ -892,7 +892,9 @@ class ASTContext final {
   ///
   /// Note that even if this check succeeds, errors may still occur if the
   /// module is loaded in full.
-  bool canImportModuleImpl(ImportPath::Element ModulePath) const;
+  bool canImportModuleImpl(ImportPath::Element ModulePath,
+                           llvm::VersionTuple version,
+                           bool underlyingVersion) const;
 public:
   namelookup::ImportCache &getImportCache() const;
 
@@ -921,8 +923,12 @@ class ASTContext final {
   ///
   /// Note that even if this check succeeds, errors may still occur if the
   /// module is loaded in full.
-  bool canImportModule(ImportPath::Element ModulePath);
-  bool canImportModule(ImportPath::Element ModulePath) const;
+  bool canImportModule(ImportPath::Element ModulePath,
+                       llvm::VersionTuple version = llvm::VersionTuple(),
+                       bool underlyingVersion = false);
+  bool canImportModule(ImportPath::Element ModulePath,
+                       llvm::VersionTuple version = llvm::VersionTuple(),
+                       bool underlyingVersion = false) const;
 
   /// \returns a module with a given name that was already loaded.  If the
   /// module was not loaded, returns nullptr.
diff --git a/include/swift/AST/DiagnosticsParse.def b/include/swift/AST/DiagnosticsParse.def
@@ -1772,6 +1772,12 @@ WARNING(likely_simulator_platform_condition,none,
       "use 'targetEnvironment(simulator)' instead",
       ())
 
+ERROR(canimport_two_parameters, none, "canImport can take only two parameters", ())
+
+ERROR(canimport_label, none, "2nd parameter of canImport should be labeled as version or underlyingVersion", ())
+
+ERROR(canimport_version, none, "cannot parse module version: %0", (StringRef))
+
 //------------------------------------------------------------------------------
 // MARK: Availability query parsing diagnostics
 //------------------------------------------------------------------------------
diff --git a/include/swift/AST/ModuleLoader.h b/include/swift/AST/ModuleLoader.h
@@ -27,6 +27,7 @@
 #include "swift/Basic/SourceLoc.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/TinyPtrVector.h"
+#include "llvm/Support/VersionTuple.h"
 #include <system_error>
 
 namespace llvm {
@@ -199,7 +200,9 @@ class ModuleLoader {
   ///
   /// Note that even if this check succeeds, errors may still occur if the
   /// module is loaded in full.
-  virtual bool canImportModule(ImportPath::Element named) = 0;
+  virtual bool canImportModule(ImportPath::Element named,
+                               llvm::VersionTuple version,
+                               bool underlyingVersion) = 0;
 
   /// Import a module with the given module path.
   ///
diff --git a/include/swift/ClangImporter/ClangImporter.h b/include/swift/ClangImporter/ClangImporter.h
@@ -186,7 +186,8 @@ class ClangImporter final : public ClangModuleLoader {
   ///
   /// Note that even if this check succeeds, errors may still occur if the
   /// module is loaded in full.
-  virtual bool canImportModule(ImportPath::Element named) override;
+  virtual bool canImportModule(ImportPath::Element named, llvm::VersionTuple version,
+                               bool underlyingVersion) override;
 
   /// Import a module with the given module path.
   ///
diff --git a/include/swift/Frontend/ModuleInterfaceLoader.h b/include/swift/Frontend/ModuleInterfaceLoader.h
@@ -150,7 +150,8 @@ class ExplicitSwiftModuleLoader: public SerializedModuleLoaderBase {
                   std::unique_ptr<llvm::MemoryBuffer> *ModuleSourceInfoBuffer,
                   bool IsFramework) override;
 
-  bool canImportModule(ImportPath::Element mID) override;
+  bool canImportModule(ImportPath::Element mID, llvm::VersionTuple version,
+                       bool underlyingVersion) override;
 
   bool isCached(StringRef DepPath) override { return false; };
 
diff --git a/include/swift/Sema/SourceLoader.h b/include/swift/Sema/SourceLoader.h
@@ -57,7 +57,9 @@ class SourceLoader : public ModuleLoader {
   ///
   /// Note that even if this check succeeds, errors may still occur if the
   /// module is loaded in full.
-  virtual bool canImportModule(ImportPath::Element named) override;
+  virtual bool canImportModule(ImportPath::Element named,
+                               llvm::VersionTuple version,
+                               bool underlyingVersion) override;
 
   /// Import a module with the given module path.
   ///
diff --git a/include/swift/Serialization/SerializedModuleLoader.h b/include/swift/Serialization/SerializedModuleLoader.h
@@ -166,7 +166,9 @@ class SerializedModuleLoaderBase : public ModuleLoader {
   ///
   /// Note that even if this check succeeds, errors may still occur if the
   /// module is loaded in full.
-  virtual bool canImportModule(ImportPath::Element named) override;
+  virtual bool canImportModule(ImportPath::Element named,
+                               llvm::VersionTuple version,
+                               bool underlyingVersion) override;
 
   /// Import a module with the given module path.
   ///
@@ -274,7 +276,8 @@ class MemoryBufferSerializedModuleLoader : public SerializedModuleLoaderBase {
 public:
   virtual ~MemoryBufferSerializedModuleLoader();
 
-  bool canImportModule(ImportPath::Element named) override;
+  bool canImportModule(ImportPath::Element named, llvm::VersionTuple version,
+                       bool underlyingVersion) override;
   ModuleDecl *
   loadModule(SourceLoc importLoc,
              ImportPath::Module path) override;
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
@@ -1955,7 +1955,9 @@ bool ASTContext::shouldPerformTypoCorrection() {
   return NumTypoCorrections <= LangOpts.TypoCorrectionLimit;
 }
 
-bool ASTContext::canImportModuleImpl(ImportPath::Element ModuleName) const {
+bool ASTContext::canImportModuleImpl(ImportPath::Element ModuleName,
+                                     llvm::VersionTuple version,
+                                     bool underlyingVersion) const {
   // If this module has already been successfully imported, it is importable.
   if (getLoadedModule(ImportPath::Module::Builder(ModuleName).get()) != nullptr)
     return true;
@@ -1966,25 +1968,29 @@ bool ASTContext::canImportModuleImpl(ImportPath::Element ModuleName) const {
 
   // Otherwise, ask the module loaders.
   for (auto &importer : getImpl().ModuleLoaders) {
-    if (importer->canImportModule(ModuleName)) {
+    if (importer->canImportModule(ModuleName, version, underlyingVersion)) {
       return true;
     }
   }
 
   return false;
 }
 
-bool ASTContext::canImportModule(ImportPath::Element ModuleName) {
-  if (canImportModuleImpl(ModuleName)) {
+bool ASTContext::canImportModule(ImportPath::Element ModuleName,
+                                 llvm::VersionTuple version,
+                                 bool underlyingVersion) {
+  if (canImportModuleImpl(ModuleName, version, underlyingVersion)) {
     return true;
   } else {
     FailedModuleImportNames.insert(ModuleName.Item);
     return false;
   }
 }
 
-bool ASTContext::canImportModule(ImportPath::Element ModuleName) const {
-  return canImportModuleImpl(ModuleName);
+bool ASTContext::canImportModule(ImportPath::Element ModuleName,
+                                 llvm::VersionTuple version,
+                                 bool underlyingVersion) const {
+  return canImportModuleImpl(ModuleName, version, underlyingVersion);
 }
 
 ModuleDecl *
diff --git a/lib/ClangImporter/ClangImporter.cpp b/lib/ClangImporter/ClangImporter.cpp
@@ -1731,7 +1731,9 @@ bool ClangImporter::isModuleImported(const clang::Module *M) {
   return M->NameVisibility == clang::Module::NameVisibilityKind::AllVisible;
 }
 
-bool ClangImporter::canImportModule(ImportPath::Element moduleID) {
+bool ClangImporter::canImportModule(ImportPath::Element moduleID,
+                                    llvm::VersionTuple version,
+                                    bool underlyingVersion) {
   // Look up the top-level module to see if it exists.
   // FIXME: This only works with top-level modules.
   auto &clangHeaderSearch = Impl.getClangPreprocessor().getHeaderSearchInfo();
diff --git a/lib/Frontend/ModuleInterfaceLoader.cpp b/lib/Frontend/ModuleInterfaceLoader.cpp
@@ -1629,7 +1629,7 @@ std::error_code ExplicitSwiftModuleLoader::findModuleFilesInDirectory(
 }
 
 bool ExplicitSwiftModuleLoader::canImportModule(
-    ImportPath::Element mID) {
+    ImportPath::Element mID, llvm::VersionTuple version, bool underlyingVersion) {
   StringRef moduleName = mID.Item.str();
   auto it = Impl.ExplicitModuleMap.find(moduleName);
   // If no provided explicit module matches the name, then it cannot be imported.
diff --git a/lib/Parse/ParseIfConfig.cpp b/lib/Parse/ParseIfConfig.cpp
@@ -76,6 +76,57 @@ static bool isValidVersion(const version::Version &Version,
   llvm_unreachable("unsupported unary operator");
 }
 
+static llvm::VersionTuple getCanImportVersion(TupleExpr *te,
+                                              DiagnosticEngine *D,
+                                              bool &underlyingVersion) {
+  llvm::VersionTuple result;
+  if (te->getElements().size() != 2) {
+    if (D) {
+      D->diagnose(te->getLoc(), diag::canimport_two_parameters);
+    }
+    return result;
+  }
+  auto label = te->getElementName(1);
+  auto subE = te->getElement(1);
+  if (label.str() == "version") {
+    underlyingVersion = false;
+  } else if (label.str() == "underlyingVersion") {
+    underlyingVersion = true;
+  } else {
+    if (D) {
+      D->diagnose(subE->getLoc(), diag::canimport_label);
+    }
+    return result;
+  }
+  if (auto *nle = dyn_cast<NumberLiteralExpr>(subE)) {
+    auto digits = nle->getDigitsText();
+    if (result.tryParse(digits)) {
+      if (D) {
+        D->diagnose(nle->getLoc(), diag::canimport_version, digits);
+      }
+    }
+  }
+  return result;
+}
+
+static Expr *getSingleSubExp(Expr *exp, StringRef kindName,
+                             DiagnosticEngine *D) {
+  if (auto *pe = dyn_cast<ParenExpr>(exp)) {
+    return pe->getSubExpr();
+  }
+  if (kindName == "canImport") {
+    if (auto *te = dyn_cast<TupleExpr>(exp)) {
+      bool underlyingVersion;
+      if (D) {
+        // Diagnose canImport syntax
+        (void)getCanImportVersion(te, D, underlyingVersion);
+      }
+      return te->getElement(0);
+    }
+  }
+  return nullptr;
+}
+
 /// The condition validator.
 class ValidateIfConfigCondition :
   public ExprVisitor<ValidateIfConfigCondition, Expr*> {
@@ -208,13 +259,11 @@ class ValidateIfConfigCondition :
       return nullptr;
     }
 
-    auto *ArgP = dyn_cast<ParenExpr>(E->getArg());
-    if (!ArgP) {
+    Expr *Arg = getSingleSubExp(E->getArg(), *KindName, &D);
+    if (!Arg) {
       D.diagnose(E->getLoc(), diag::platform_condition_expected_one_argument);
       return nullptr;
     }
-    Expr *Arg = ArgP->getSubExpr();
-
     // '_compiler_version' '(' string-literal ')'
     if (*KindName == "_compiler_version") {
       auto SLE = dyn_cast<StringLiteralExpr>(Arg);
@@ -424,8 +473,7 @@ class EvaluateIfConfigCondition :
 
   bool visitCallExpr(CallExpr *E) {
     auto KindName = getDeclRefStr(E->getFn());
-    auto *Arg = cast<ParenExpr>(E->getArg())->getSubExpr();
-
+    auto *Arg = getSingleSubExp(E->getArg(), KindName, nullptr);
     if (KindName == "_compiler_version") {
       auto Str = cast<StringLiteralExpr>(Arg)->getValue();
       auto Val = version::Version::parseCompilerVersionString(
@@ -450,7 +498,13 @@ class EvaluateIfConfigCondition :
       }
     } else if (KindName == "canImport") {
       auto Str = extractExprSource(Ctx.SourceMgr, Arg);
-      return Ctx.canImportModule({ Ctx.getIdentifier(Str) , E->getLoc()  });
+      bool underlyingModule = false;
+      llvm::VersionTuple version;
+      if (auto *te = dyn_cast<TupleExpr>(E->getArg())) {
+        version = getCanImportVersion(te, nullptr, underlyingModule);
+      }
+      return Ctx.canImportModule({ Ctx.getIdentifier(Str) , E->getLoc() },
+                                 version, underlyingModule);
     }
 
     auto Val = getDeclRefStr(Arg);
diff --git a/lib/Sema/SourceLoader.cpp b/lib/Sema/SourceLoader.cpp
@@ -62,7 +62,9 @@ void SourceLoader::collectVisibleTopLevelModuleNames(
   // TODO: Implement?
 }
 
-bool SourceLoader::canImportModule(ImportPath::Element ID) {
+bool SourceLoader::canImportModule(ImportPath::Element ID,
+                                   llvm::VersionTuple version,
+                                   bool underlyingVersion) {
   // Search the memory buffers to see if we can find this file on disk.
   FileOrError inputFileOrError = findModule(Ctx, ID.Item.str(),
                                             ID.Loc);
diff --git a/lib/Serialization/ModuleDependencyScanner.cpp b/lib/Serialization/ModuleDependencyScanner.cpp
@@ -192,7 +192,8 @@ Optional<ModuleDependencies> SerializedModuleLoaderBase::getModuleDependencies(
   assert(isa<PlaceholderSwiftModuleScanner>(scanners[0].get()) &&
          "Expected PlaceholderSwiftModuleScanner as the first dependency scanner loader.");
   for (auto &scanner : scanners) {
-    if (scanner->canImportModule({moduleId, SourceLoc()})) {
+    if (scanner->canImportModule({moduleId, SourceLoc()},
+                                 llvm::VersionTuple(), false)) {
       // Record the dependencies.
       cache.recordDependencies(moduleName, *(scanner->dependencies));
       return std::move(scanner->dependencies);
diff --git a/lib/Serialization/SerializedModuleLoader.cpp b/lib/Serialization/SerializedModuleLoader.cpp
@@ -948,7 +948,7 @@ void swift::serialization::diagnoseSerializedASTLoadFailure(
 }
 
 bool SerializedModuleLoaderBase::canImportModule(
-    ImportPath::Element mID) {
+    ImportPath::Element mID, llvm::VersionTuple version, bool underlyingVersion) {
   // Look on disk.
   SmallVector<char, 0> *unusedModuleInterfacePath = nullptr;
   std::unique_ptr<llvm::MemoryBuffer> *unusedModuleBuffer = nullptr;
@@ -962,7 +962,7 @@ bool SerializedModuleLoaderBase::canImportModule(
 }
 
 bool MemoryBufferSerializedModuleLoader::canImportModule(
-    ImportPath::Element mID) {
+    ImportPath::Element mID, llvm::VersionTuple version, bool underlyingVersion) {
   // See if we find it in the registered memory buffers.
   return MemoryBuffers.count(mID.Item.str());
 }
diff --git a/test/Parse/ifconfig_expr.swift b/test/Parse/ifconfig_expr.swift
@@ -125,3 +125,33 @@ func ifconfigExprInExpr(baseExpr: MyStruct) {
 #endif
   )
 }
+
+func canImportVersioned() {
+#if canImport(A, version: 2)
+  let a = 1
+#endif
+
+#if canImport(A, version: 2.2)
+  let a = 1
+#endif
+
+#if canImport(A, underlyingVersion: 4)
+  let a = 1
+#endif
+
+#if canImport(A, underlyingVersion: 2.200)
+  let a = 1
+#endif
+
+#if canImport(A, unknown: 2.2) // expected-error {{2nd parameter of canImport should be labeled as version or underlyingVersion}}
+  let a = 1
+#endif
+
+#if canImport(A, 2.2) // expected-error {{2nd parameter of canImport should be labeled as version or underlyingVersion}}
+  let a = 1
+#endif
+
+#if canImport(A, 2.2, 1.1) // expected-error {{canImport can take only two parameters}}
+  let a = 1
+#endif
+}

Original file line number	Diff line number	Diff line change
`@@ -1955,7 +1955,9 @@ bool ASTContext::shouldPerformTypoCorrection() {`
`1955`	`1955`	`return NumTypoCorrections <= LangOpts.TypoCorrectionLimit;`
`1956`	`1956`	`}`
`1957`	`1957`
`1958`		`-bool ASTContext::canImportModuleImpl(ImportPath::Element ModuleName) const {`
	`1958`	`+bool ASTContext::canImportModuleImpl(ImportPath::Element ModuleName,`
	`1959`	`+ llvm::VersionTuple version,`
	`1960`	`+ bool underlyingVersion) const {`
`1959`	`1961`	`// If this module has already been successfully imported, it is importable.`
`1960`	`1962`	`if (getLoadedModule(ImportPath::Module::Builder(ModuleName).get()) != nullptr)`
`1961`	`1963`	`return true;`
`@@ -1966,25 +1968,29 @@ bool ASTContext::canImportModuleImpl(ImportPath::Element ModuleName) const {`
`1966`	`1968`
`1967`	`1969`	`// Otherwise, ask the module loaders.`
`1968`	`1970`	`for (auto &importer : getImpl().ModuleLoaders) {`
`1969`		`- if (importer->canImportModule(ModuleName)) {`
	`1971`	`+ if (importer->canImportModule(ModuleName, version, underlyingVersion)) {`
`1970`	`1972`	`return true;`
`1971`	`1973`	`}`
`1972`	`1974`	`}`
`1973`	`1975`
`1974`	`1976`	`return false;`
`1975`	`1977`	`}`
`1976`	`1978`
`1977`		`-bool ASTContext::canImportModule(ImportPath::Element ModuleName) {`
`1978`		`- if (canImportModuleImpl(ModuleName)) {`
	`1979`	`+bool ASTContext::canImportModule(ImportPath::Element ModuleName,`
	`1980`	`+ llvm::VersionTuple version,`
	`1981`	`+ bool underlyingVersion) {`
	`1982`	`+ if (canImportModuleImpl(ModuleName, version, underlyingVersion)) {`
`1979`	`1983`	`return true;`
`1980`	`1984`	`} else {`
`1981`	`1985`	`FailedModuleImportNames.insert(ModuleName.Item);`
`1982`	`1986`	`return false;`
`1983`	`1987`	`}`
`1984`	`1988`	`}`
`1985`	`1989`
`1986`		`-bool ASTContext::canImportModule(ImportPath::Element ModuleName) const {`
`1987`		`- return canImportModuleImpl(ModuleName);`
	`1990`	`+bool ASTContext::canImportModule(ImportPath::Element ModuleName,`
	`1991`	`+ llvm::VersionTuple version,`
	`1992`	`+ bool underlyingVersion) const {`
	`1993`	`+ return canImportModuleImpl(ModuleName, version, underlyingVersion);`
`1988`	`1994`	`}`
`1989`	`1995`
`1990`	`1996`	`ModuleDecl *`
Original file line number	Diff line number	Diff line change
`@@ -1629,7 +1629,7 @@ std::error_code ExplicitSwiftModuleLoader::findModuleFilesInDirectory(`
`1629`	`1629`	`}`
`1630`	`1630`
`1631`	`1631`	`bool ExplicitSwiftModuleLoader::canImportModule(`
`1632`		`- ImportPath::Element mID) {`
	`1632`	`+ ImportPath::Element mID, llvm::VersionTuple version, bool underlyingVersion) {`
`1633`	`1633`	`StringRef moduleName = mID.Item.str();`
`1634`	`1634`	`auto it = Impl.ExplicitModuleMap.find(moduleName);`
`1635`	`1635`	`// If no provided explicit module matches the name, then it cannot be imported.`