Merge pull request #41673 from tshortli/inlining-availability-checking

Add -target-min-inlining-version to aid type checking for inlinable functions in resilient libraries

Author: tshortli

include/swift/AST/Availability.h

@@ -220,6 +220,10 @@ class AvailabilityContext {
   /// deployment target.
   static AvailabilityContext forDeploymentTarget(ASTContext &Ctx);
 
+  /// Creates a context that imposes the constraints of the ASTContext's
+  /// inlining target (i.e. minimum inlining version).
+  static AvailabilityContext forInliningTarget(ASTContext &Ctx);
+
   /// Creates a context that imposes no constraints.
   ///
   /// \see isAlwaysAvailable

include/swift/AST/TypeRefinementContext.h

@@ -58,6 +58,12 @@ class TypeRefinementContext : public ASTAllocated<TypeRefinementContext> {
     /// function declaration or the contents of a class declaration).
     Decl,
 
+    /// The context was introduced by a resilience boundary; that is, we are in
+    /// a module with library evolution enabled and the parent context's
+    /// contents can be visible to the module's clients, but this context's
+    /// contents are not.
+    ResilienceBoundary,
+
     /// The context was introduced for the Then branch of an IfStmt.
     IfStmtThenBranch,
 
@@ -102,7 +108,10 @@ class TypeRefinementContext : public ASTAllocated<TypeRefinementContext> {
 
   public:
     IntroNode(SourceFile *SF) : IntroReason(Reason::Root), SF(SF) {}
-    IntroNode(Decl *D) : IntroReason(Reason::Decl), D(D) {}
+    IntroNode(Decl *D, Reason introReason = Reason::Decl)
+        : IntroReason(introReason), D(D) {
+      (void)getAsDecl();    // check that assertion succeeds
+    }
     IntroNode(IfStmt *IS, bool IsThen) :
     IntroReason(IsThen ? Reason::IfStmtThenBranch : Reason::IfStmtElseBranch),
                 IS(IS) {}
@@ -122,7 +131,8 @@ class TypeRefinementContext : public ASTAllocated<TypeRefinementContext> {
     }
 
     Decl *getAsDecl() const {
-      assert(IntroReason == Reason::Decl);
+      assert(IntroReason == Reason::Decl ||
+             IntroReason == Reason::ResilienceBoundary);
       return D;
     }
 
@@ -182,7 +192,14 @@ class TypeRefinementContext : public ASTAllocated<TypeRefinementContext> {
                                               const AvailabilityContext &Info,
                                               const AvailabilityContext &ExplicitInfo,
                                               SourceRange SrcRange);
-  
+
+  /// Create a refinement context for the given declaration.
+  static TypeRefinementContext *
+  createForResilienceBoundary(ASTContext &Ctx, Decl *D,
+                              TypeRefinementContext *Parent,
+                              const AvailabilityContext &Info,
+                              SourceRange SrcRange);
+
   /// Create a refinement context for the Then branch of the given IfStmt.
   static TypeRefinementContext *
   createForIfStmtThen(ASTContext &Ctx, IfStmt *S, TypeRefinementContext *Parent,

include/swift/Basic/LangOptions.h

@@ -134,6 +134,13 @@ namespace swift {
     /// The SDK canonical name, if known.
     std::string SDKName;
 
+    /// The lowest target OS version that code in this module may be inlined
+    /// into. In resilient modules, this should match the minimum
+    /// deployment target of the *first* resilient version of the module, since
+    /// clients may need to interoperate with versions as far back as that
+    /// deployment target.
+    llvm::VersionTuple MinimumInliningTargetVersion;
+
     /// The alternate name to use for the entry point instead of main.
     std::string entryPointFunctionName = "main";
 

include/swift/Basic/Platform.h

@@ -55,6 +55,9 @@ namespace swift {
   bool triplesAreValidForZippering(const llvm::Triple &target,
                                    const llvm::Triple &targetVariant);
 
+  const Optional<llvm::VersionTuple>
+  minimumABIStableOSVersionForTriple(const llvm::Triple &triple);
+
   /// Returns true if the given triple represents an OS that has all the
   /// "built-in" ABI-stable libraries (stdlib and _Concurrency)
   /// (eg. in /usr/lib/swift).

include/swift/Frontend/DiagnosticVerifier.h

@@ -132,7 +132,7 @@ class DiagnosticVerifier : public DiagnosticConsumer {
   /// unexpected ones.
   Result verifyFile(unsigned BufferID);
 
-  bool checkForFixIt(const ExpectedFixIt &Expected,
+  bool checkForFixIt(const std::vector<ExpectedFixIt> &ExpectedAlts,
                      const CapturedDiagnosticInfo &D, unsigned BufferID) const;
 
   // Render the verifier syntax for a given set of fix-its.

include/swift/Option/Options.td

@@ -1156,6 +1156,11 @@ def disable_clang_target : Flag<["-"], "disable-clang-target">,
   Flags<[NewDriverOnlyOption]>,
   HelpText<"Disable a separately specified target triple for Clang instance to use">;
 
+def min_inlining_target_version : Separate<["-"], "target-min-inlining-version">,
+  Flags<[FrontendOption, ModuleInterfaceOptionIgnorable]>,
+  HelpText<"Require inlinable code with no '@available' attribute to back-deploy "
+           "to this version of the '-target' OS">;
+
 def profile_generate : Flag<["-"], "profile-generate">,
   Flags<[FrontendOption, NoInteractiveOption]>,
   HelpText<"Generate instrumented code to collect execution counts">;

lib/AST/Availability.cpp

@@ -30,6 +30,11 @@ AvailabilityContext AvailabilityContext::forDeploymentTarget(ASTContext &Ctx) {
       VersionRange::allGTE(Ctx.LangOpts.getMinPlatformVersion()));
 }
 
+AvailabilityContext AvailabilityContext::forInliningTarget(ASTContext &Ctx) {
+  return AvailabilityContext(
+      VersionRange::allGTE(Ctx.LangOpts.MinimumInliningTargetVersion));
+}
+
 namespace {
 
 /// The inferred availability required to access a group of declarations

lib/AST/TypeRefinementContext.cpp

@@ -64,6 +64,20 @@ TypeRefinementContext::createForDecl(ASTContext &Ctx, Decl *D,
       TypeRefinementContext(Ctx, D, Parent, SrcRange, Info, ExplicitInfo);
 }
 
+TypeRefinementContext *
+TypeRefinementContext::createForResilienceBoundary(ASTContext &Ctx, Decl *D,
+                                TypeRefinementContext *Parent,
+                                const AvailabilityContext &Info,
+                                SourceRange SrcRange) {
+  assert(D);
+  assert(Parent);
+  return new (Ctx)
+      TypeRefinementContext(Ctx, IntroNode(D, Reason::ResilienceBoundary),
+                            Parent, SrcRange, Info,
+                            AvailabilityContext::alwaysAvailable());
+
+}
+
 TypeRefinementContext *
 TypeRefinementContext::createForIfStmtThen(ASTContext &Ctx, IfStmt *S,
                                            TypeRefinementContext *Parent,
@@ -170,6 +184,7 @@ void TypeRefinementContext::dump(raw_ostream &OS, SourceManager &SrcMgr) const {
 SourceLoc TypeRefinementContext::getIntroductionLoc() const {
   switch (getReason()) {
   case Reason::Decl:
+  case Reason::ResilienceBoundary:
     return Node.getAsDecl()->getLoc();
 
   case Reason::IfStmtThenBranch:
@@ -283,6 +298,7 @@ TypeRefinementContext::getAvailabilityConditionVersionSourceRange(
       Node.getAsWhileStmt()->getCond(), Platform, Version);
 
   case Reason::Root:
+  case Reason::ResilienceBoundary:
     return SourceRange();
   }
 
@@ -296,13 +312,16 @@ void TypeRefinementContext::print(raw_ostream &OS, SourceManager &SrcMgr,
 
   OS << " versions=" << AvailabilityInfo.getOSVersion().getAsString();
 
-  if (getReason() == Reason::Decl) {
+  if (getReason() == Reason::Decl
+      || getReason() == Reason::ResilienceBoundary) {
     Decl *D = Node.getAsDecl();
     OS << " decl=";
     if (auto VD = dyn_cast<ValueDecl>(D)) {
       OS << VD->getName();
     } else if (auto *ED = dyn_cast<ExtensionDecl>(D)) {
       OS << "extension." << ED->getExtendedType().getString();
+    } else if (isa<TopLevelCodeDecl>(D)) {
+      OS << "<top-level-code>";
     }
   }
 
@@ -312,6 +331,10 @@ void TypeRefinementContext::print(raw_ostream &OS, SourceManager &SrcMgr,
     R.print(OS, SrcMgr, /*PrintText=*/false);
   }
 
+  if (!ExplicitAvailabilityInfo.isAlwaysAvailable())
+    OS << " explicit_versions="
+       << ExplicitAvailabilityInfo.getOSVersion().getAsString();
+
   for (TypeRefinementContext *Child : Children) {
     OS << '\n';
     Child->print(OS, SrcMgr, Indent + 2);
@@ -332,6 +355,9 @@ StringRef TypeRefinementContext::getReasonName(Reason R) {
   case Reason::Decl:
     return "decl";
 
+  case Reason::ResilienceBoundary:
+    return "resilience_boundary";
+
   case Reason::IfStmtThenBranch:
     return "if_then";
 

lib/Basic/Platform.cpp

@@ -79,6 +79,20 @@ bool swift::triplesAreValidForZippering(const llvm::Triple &target,
   return false;
 }
 
+const Optional<llvm::VersionTuple>
+swift::minimumABIStableOSVersionForTriple(const llvm::Triple &triple) {
+  if (triple.isMacOSX())
+    return llvm::VersionTuple(10, 14, 4);
+
+  if (triple.isiOS() /* including tvOS */)
+    return llvm::VersionTuple(12, 2);
+
+  if (triple.isWatchOS())
+    return llvm::VersionTuple(5, 2);
+
+  return None;
+}
+
 bool swift::tripleRequiresRPathForSwiftLibrariesInOS(
     const llvm::Triple &triple) {
   if (triple.isMacOSX()) {

lib/Frontend/CompilerInvocation.cpp

@@ -800,29 +800,63 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     Diags.diagnose(SourceLoc(), diag::error_unsupported_target_os, TargetArgOS);
   }
 
-  // Parse the SDK version.
-  if (Arg *A = Args.getLastArg(options::OPT_target_sdk_version)) {
-    auto vers = version::Version::parseVersionString(
-      A->getValue(), SourceLoc(), &Diags);
-    if (vers.hasValue()) {
-      Opts.SDKVersion = *vers;
-    } else {
-      Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value,
-                     A->getAsString(Args), A->getValue());
-    }
-  }
+  // First, set up default minimum inlining target versions.
+  auto getDefaultMinimumInliningTargetVersion =
+      [&](const llvm::Triple &triple) -> llvm::VersionTuple {
+#if SWIFT_DEFAULT_TARGET_MIN_INLINING_VERSION_TO_ABI
+    // In ABI-stable modules, default to the version where the target's ABI
+    // was first frozen; older versions will use that one's backwards
+    // compatibility libraries.
+    if (FrontendOpts.EnableLibraryEvolution)
+      if (auto abiStability = minimumABIStableOSVersionForTriple(triple))
+        // FIXME: Should we raise it to the minimum supported OS version for
+        //        architectures which were born ABI-stable?
+        return *abiStability;
+#endif
+
+    // In ABI-unstable modules, we will never have to interoperate with
+    // older versions of the module, so we should default to the minimum
+    // deployment target.
+    unsigned major, minor, patch;
+    if (triple.isMacOSX())
+      triple.getMacOSXVersion(major, minor, patch);
+    else
+      triple.getOSVersion(major, minor, patch);
+    return llvm::VersionTuple(major, minor, patch);
+  };
 
-  // Parse the target variant SDK version.
-  if (Arg *A = Args.getLastArg(options::OPT_target_variant_sdk_version)) {
-    auto vers = version::Version::parseVersionString(
-      A->getValue(), SourceLoc(), &Diags);
-    if (vers.hasValue()) {
-      Opts.VariantSDKVersion = *vers;
-    } else {
-      Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value,
-                     A->getAsString(Args), A->getValue());
-    }
-  }
+  Opts.MinimumInliningTargetVersion =
+      getDefaultMinimumInliningTargetVersion(Opts.Target);
+
+  // Parse OS version number arguments.
+  auto parseVersionArg = [&](OptSpecifier opt) -> Optional<llvm::VersionTuple> {
+    Arg *A = Args.getLastArg(opt);
+    if (!A)
+      return None;
+
+    if (StringRef(A->getValue()) == "target")
+      return Opts.getMinPlatformVersion();
+    if (StringRef(A->getValue()) == "abi")
+      return minimumABIStableOSVersionForTriple(Opts.Target);
+
+    if (auto vers = version::Version::parseVersionString(A->getValue(),
+                                                         SourceLoc(), &Diags))
+      return (llvm::VersionTuple)*vers;
+
+    Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value,
+                   A->getAsString(Args), A->getValue());
+    return None;
+  };
+
+  if (auto vers = parseVersionArg(OPT_min_inlining_target_version))
+    // FIXME: Should we diagnose if it's below the default?
+    Opts.MinimumInliningTargetVersion = *vers;
+
+  if (auto vers = parseVersionArg(OPT_target_sdk_version))
+    Opts.SDKVersion = *vers;
+
+  if (auto vers = parseVersionArg(OPT_target_variant_sdk_version))
+    Opts.VariantSDKVersion = *vers;
 
   // Get the SDK name.
   if (Arg *A = Args.getLastArg(options::OPT_target_sdk_name)) {