Merge pull request swiftlang#68421 from apple/embedded-availability

[embedded] Add an interim attr to mark declarations as unavailable in embedded Swift

Author: swift-ci

lib/Frontend/CompilerInvocation.cpp

@@ -1316,9 +1316,13 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   }
   Opts.BypassResilienceChecks |= Args.hasArg(OPT_bypass_resilience);
 
-  if (FrontendOpts.EnableLibraryEvolution && Opts.hasFeature(Feature::Embedded)) {
-    Diags.diagnose(SourceLoc(), diag::evolution_with_embedded);
-    HadError = true;
+  if (Opts.hasFeature(Feature::Embedded)) {
+    Opts.UnavailableDeclOptimizationMode = UnavailableDeclOptimization::Complete;
+
+    if (FrontendOpts.EnableLibraryEvolution) {
+      Diags.diagnose(SourceLoc(), diag::evolution_with_embedded);
+      HadError = true;
+    }
   }
 
   if (auto A = Args.getLastArg(OPT_checked_async_objc_bridging)) {

lib/Parse/ParseDecl.cpp

@@ -4154,6 +4154,25 @@ ParserStatus Parser::parseDeclAttribute(
     return makeParserSuccess();
   }
 
+  // Rewrite @_unavailableInEmbedded into @available(*, unavailable) when in
+  // embedded Swift mode, or into nothing when in regular mode.
+  if (DK == DAK_Count && Tok.getText() == "_unavailableInEmbedded") {
+    SourceLoc attrLoc = consumeToken();
+    if (Context.LangOpts.hasFeature(Feature::Embedded)) {
+      StringRef Message = "unavailable in embedded Swift", Renamed;
+      auto attr = new (Context) AvailableAttr(AtLoc, SourceRange(AtLoc, attrLoc),
+                  PlatformKind::none,
+                  Message, Renamed, /*RenameDecl=*/nullptr,
+                  llvm::VersionTuple(), SourceRange(),
+                  llvm::VersionTuple(), SourceRange(),
+                  llvm::VersionTuple(), SourceRange(),
+                  PlatformAgnosticAvailabilityKind::Unavailable,
+                  /*Implicit=*/false, /*IsSPI=*/false);
+      Attributes.add(attr);
+    }
+    return makeParserSuccess();
+  }
+
   if (DK != DAK_Count && !DeclAttribute::shouldBeRejectedByParser(DK)) {
     return parseNewDeclAttribute(Attributes, AtLoc, DK, isFromClangAttribute);
   }

lib/Sema/TypeCheckAvailability.cpp

@@ -345,12 +345,14 @@ static bool isInsideCompatibleUnavailableDeclaration(
     return false;
   }
 
-  // Refuse calling unavailable functions from unavailable code,
-  // but allow the use of types.
+  // Unless in embedded Swift mode, refuse calling unavailable functions from
+  // unavailable code, but allow the use of types.
   PlatformKind platform = attr->Platform;
-  if (platform == PlatformKind::none && !isa<TypeDecl>(D) &&
-      !isa<ExtensionDecl>(D)) {
-    return false;
+  if (!D->getASTContext().LangOpts.hasFeature(Feature::Embedded)) {
+    if (platform == PlatformKind::none && !isa<TypeDecl>(D) &&
+        !isa<ExtensionDecl>(D)) {
+      return false;
+    }
   }
 
   return (*referencedPlatform == platform ||

test/embedded/availability-code-removal.swift

@@ -0,0 +1,22 @@
+// This test is checking that usage of an existential (which is normally
+// disallowed in embedded Swift and flagged in IRGen) is left undiagnosed
+// because the context is @_unavailableInEmbedded.
+//
+// The breakdown of that is
+// - (1) @_unavailableInEmbedded makes the declaration unavailable,
+// - (2) unavailable function bodies is removed in embedded Swift,
+// - (3) the test() function is not reported by the existential checker.
+
+// RUN: %target-swift-frontend -emit-ir %s -parse-stdlib | %FileCheck %s --check-prefix CHECK-A
+// RUN: %target-swift-frontend -emit-ir %s -parse-stdlib -enable-experimental-feature Embedded | %FileCheck %s --check-prefix CHECK-B
+
+public protocol Player {}
+struct Concrete: Player {}
+
+@_unavailableInEmbedded
+public func test() -> any Player {
+  Concrete() // no error because we're in unavailable-in-embedded context
+}
+
+// CHECK-A: $s4main4testAA6Player_pyF
+// CHECK-B-NOT: $s4main4testAA6Player_pyF

test/embedded/availability.swift

@@ -0,0 +1,22 @@
+// Building with regular Swift should succeed
+// RUN: %target-swift-emit-ir %s -parse-stdlib
+
+// Building with embedded Swift should produce unavailability errors
+// RUN: %target-typecheck-verify-swift -parse-stdlib -enable-experimental-feature Embedded
+
+@_unavailableInEmbedded
+public func embedded() { }
+public func regular() {
+	embedded() // expected-error {{'embedded()' is unavailable: unavailable in embedded Swift}}
+	// expected-note@-3 {{'embedded()' has been explicitly marked unavailable here}}
+}
+
+@_unavailableInEmbedded
+public func unused() { } // no error
+
+@_unavailableInEmbedded
+public func called_from_unavailable() { }
+@_unavailableInEmbedded
+public func also_embedded() { 
+	called_from_unavailable() // no error
+}