[Module interface] Retain #if's with feature checks in inline bodies.

Author: DougGregor

include/swift/Basic/Features.def

@@ -43,5 +43,6 @@ LANGUAGE_FEATURE(RethrowsProtocol, 0, "@rethrows protocol", true)
 LANGUAGE_FEATURE(GlobalActors, 0, "Global actors", langOpts.EnableExperimentalConcurrency)
 LANGUAGE_FEATURE(BuiltinJob, 0, "Builtin.Job type", true)
 LANGUAGE_FEATURE(Sendable, 0, "Sendable and @Sendable", true)
+LANGUAGE_FEATURE(BuiltinContinuation, 0, "Continuation builtins", true)
 
 #undef LANGUAGE_FEATURE

lib/AST/ASTPrinter.cpp

@@ -2720,6 +2720,10 @@ static bool usesFeatureBuiltinJob(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureBuiltinContinuation(Decl *decl) {
+  return false;
+}
+
 /// Determine the set of "new" features used on a given declaration.
 ///
 /// Note: right now, all features we check for are "new". At some point, we'll

lib/AST/InlinableText.cpp

@@ -11,8 +11,9 @@
 //===----------------------------------------------------------------------===//
 #include "InlinableText.h"
 #include "swift/AST/ASTContext.h"
-#include "swift/AST/ASTWalker.h"
 #include "swift/AST/ASTNode.h"
+#include "swift/AST/ASTVisitor.h"
+#include "swift/AST/ASTWalker.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Expr.h"
 #include "swift/Parse/Lexer.h"
@@ -43,6 +44,40 @@ getEffectiveEndLoc(SourceManager &sourceMgr, const IfConfigClause *clause,
 }
 
 namespace {
+
+class IsFeatureCheck : public ASTWalker {
+public:
+  bool foundFeature = false;
+
+  std::pair<bool, Expr *> walkToExprPre(Expr *expr) override {
+    if (auto unresolved = dyn_cast<UnresolvedDeclRefExpr>(expr)) {
+      if (unresolved->getName().getBaseName().userFacingName().startswith("$"))
+        foundFeature = true;
+    }
+
+    return { !foundFeature, expr };
+  }
+};
+
+bool clauseIsFeatureCheck(Expr *cond) {
+  IsFeatureCheck checker;
+  cond->walk(checker);
+  return checker.foundFeature;
+}
+
+/// Whether any of the clauses here involves a feature check
+/// (e.g., $AsyncAwait).
+bool anyClauseIsFeatureCheck(ArrayRef<IfConfigClause> clauses) {
+  for (const auto &clause : clauses) {
+    if (Expr *cond = clause.Cond) {
+      if (clauseIsFeatureCheck(cond))
+        return true;
+    }
+  }
+
+  return false;
+}
+
 /// A walker that searches through #if declarations, finding all text that does
 /// not contribute to the final evaluated AST.
 ///
@@ -93,6 +128,13 @@ struct ExtractInactiveRanges : public ASTWalker {
       return false;
     }
 
+    // If the clause is checking for a particular feature with $, keep
+    // the whole thing.
+    if (anyClauseIsFeatureCheck(icd->getClauses())) {
+      addRange(start, end);
+      return false;
+    }
+
     // Ignore range from beginning of '#if', '#elseif', or '#else' to the
     // beginning of the elements of this clause.
     auto elementsBegin = clause->Loc;

stdlib/public/Concurrency/PartialAsyncTask.swift

@@ -44,7 +44,11 @@ public struct UnsafeContinuation<T, E: Error> {
   /// able to reschedule it.
   @_alwaysEmitIntoClient
   public func resume(returning value: __owned T) where E == Never {
+    #if compiler(>=5.5) && $BuiltinContinuation
     Builtin.resumeNonThrowingContinuationReturning(context, value)
+    #else
+    fatalError("Swift compiler is incompatible with this SDK version")
+    #endif
   }
 
   /// Resume the task awaiting the continuation by having it return normally
@@ -61,7 +65,11 @@ public struct UnsafeContinuation<T, E: Error> {
   /// able to reschedule it.
   @_alwaysEmitIntoClient
   public func resume(returning value: __owned T) {
+    #if compiler(>=5.5) && $BuiltinContinuation
     Builtin.resumeThrowingContinuationReturning(context, value)
+    #else
+    fatalError("Swift compiler is incompatible with this SDK version")
+    #endif
   }
 
   /// Resume the task awaiting the continuation by having it throw an error
@@ -78,7 +86,11 @@ public struct UnsafeContinuation<T, E: Error> {
   /// able to reschedule it.
   @_alwaysEmitIntoClient
   public func resume(throwing error: __owned E) {
+#if compiler(>=5.5) && $BuiltinContinuation
     Builtin.resumeThrowingContinuationThrowing(context, error)
+#else
+    fatalError("Swift compiler is incompatible with this SDK version")
+#endif
   }
 }