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

Implemented as custom parsing logic instead of a proper attribute because we want it to be rewritten at parse time (into nothing in regular Swift mode, and into unconditional unavailable attr in embedded Swift mode), no serialization, printing, etc.

Author: kubamracek

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,9 @@
+// RUN: %target-swift-frontend -emit-ir %s -parse-stdlib -enable-experimental-feature Embedded
+
+public protocol Player {}
+struct Concrete: Player {}
+
+@_unavailableInEmbedded
+public func test() -> any Player {
+  Concrete() // no error because we're in unavailable-in-embedded context
+}

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
+}