Sema: Allow calls to @_unavailableInEmbedded functions in compatible contexts.

Treat `@_unavailableInEmbedded` as if it were `@available(Embedded,
unavailable)` and apply platform compatibility logic in the availability
checker. Revert back to disallowing calls to universally unavailable functions
(`@available(*, unavailable)`) in all contexts.

Author: tshortli

include/swift/AST/AvailabilityContext.h

@@ -44,19 +44,19 @@ class AvailabilityContext {
 
   AvailabilityContext(const Storage *info) : Info(info) { assert(info); };
 
-public:
-  /// Retrieves the default `AvailabilityContext`, which is maximally available.
-  /// The platform availability range will be set to the deployment target (or
-  /// minimum inlining target when applicable).
-  static AvailabilityContext getDefault(ASTContext &ctx);
-
   /// Retrieves a uniqued `AvailabilityContext` with the given platform
   /// availability parameters.
   static AvailabilityContext
   get(const AvailabilityRange &platformAvailability,
       std::optional<PlatformKind> unavailablePlatform, bool deprecated,
       ASTContext &ctx);
 
+public:
+  /// Retrieves the default `AvailabilityContext`, which is maximally available.
+  /// The platform availability range will be set to the deployment target (or
+  /// minimum inlining target when applicable).
+  static AvailabilityContext getDefault(ASTContext &ctx);
+
   /// Returns the range of platform versions which may execute code in the
   /// availability context, starting at its introduction version.
   AvailabilityRange getPlatformRange() const;
@@ -74,6 +74,9 @@ class AvailabilityContext {
   /// Returns true if this context is deprecated on the current platform.
   bool isDeprecated() const;
 
+  /// Returns true if this context is `@_unavailableInEmbedded`.
+  bool isUnavailableInEmbedded() const;
+
   /// Constrain with another `AvailabilityContext`.
   void constrainWithContext(const AvailabilityContext &other, ASTContext &ctx);
 

include/swift/AST/AvailabilityContextStorage.h

@@ -36,6 +36,9 @@ struct AvailabilityContext::PlatformInfo {
   /// platform.
   unsigned IsUnavailable : 1;
 
+  /// Whether or not the context is `@_unavailableInEmbedded`.
+  unsigned IsUnavailableInEmbedded : 1;
+
   /// Whether or not the context is considered deprecated on the current
   /// platform.
   unsigned IsDeprecated : 1;
@@ -57,6 +60,7 @@ struct AvailabilityContext::PlatformInfo {
   void Profile(llvm::FoldingSetNodeID &ID) const {
     Range.getRawVersionRange().Profile(ID);
     ID.AddBoolean(IsUnavailable);
+    ID.AddBoolean(IsUnavailableInEmbedded);
     ID.AddInteger(static_cast<uint8_t>(UnavailablePlatform));
     ID.AddBoolean(IsDeprecated);
   }

lib/AST/AvailabilityContext.cpp

@@ -42,6 +42,8 @@ bool AvailabilityContext::PlatformInfo::constrainWith(
   isConstrained |= constrainRange(Range, other.Range);
   if (other.IsUnavailable) {
     isConstrained |= constrainUnavailability(other.UnavailablePlatform);
+    isConstrained |=
+        CONSTRAIN_BOOL(IsUnavailableInEmbedded, other.IsUnavailableInEmbedded);
   }
   isConstrained |= CONSTRAIN_BOOL(IsDeprecated, other.IsDeprecated);
 
@@ -55,8 +57,11 @@ bool AvailabilityContext::PlatformInfo::constrainWith(const Decl *decl) {
   if (auto range = AvailabilityInference::annotatedAvailableRange(decl))
     isConstrained |= constrainRange(Range, *range);
 
-  if (auto *attr = decl->getAttrs().getUnavailable(ctx))
+  if (auto *attr = decl->getAttrs().getUnavailable(ctx)) {
     isConstrained |= constrainUnavailability(attr->Platform);
+    isConstrained |=
+        CONSTRAIN_BOOL(IsUnavailableInEmbedded, attr->isForEmbedded());
+  }
 
   isConstrained |=
       CONSTRAIN_BOOL(IsDeprecated, decl->getAttrs().isDeprecated(ctx));
@@ -104,6 +109,9 @@ bool AvailabilityContext::PlatformInfo::isContainedIn(
         inheritsAvailabilityFromPlatform(UnavailablePlatform,
                                          other.UnavailablePlatform))
       return false;
+
+    if (IsUnavailableInEmbedded && !other.IsUnavailableInEmbedded)
+      return false;
   }
 
   if (!IsDeprecated && other.IsDeprecated)
@@ -120,6 +128,7 @@ AvailabilityContext AvailabilityContext::getDefault(ASTContext &ctx) {
   PlatformInfo platformInfo{AvailabilityRange::forInliningTarget(ctx),
                             PlatformKind::none,
                             /*IsUnavailable*/ false,
+                            /*IsUnavailableInEmbedded*/ false,
                             /*IsDeprecated*/ false};
   return AvailabilityContext(Storage::get(platformInfo, ctx));
 }
@@ -132,7 +141,8 @@ AvailabilityContext::get(const AvailabilityRange &platformAvailability,
                             unavailablePlatform.has_value()
                                 ? *unavailablePlatform
                                 : PlatformKind::none,
-                            unavailablePlatform.has_value(), deprecated};
+                            unavailablePlatform.has_value(),
+                            /*IsUnavailableInEmbedded*/ false, deprecated};
   return AvailabilityContext(Storage::get(platformInfo, ctx));
 }
 
@@ -147,6 +157,10 @@ AvailabilityContext::getUnavailablePlatformKind() const {
   return std::nullopt;
 }
 
+bool AvailabilityContext::isUnavailableInEmbedded() const {
+  return Info->Platform.IsUnavailableInEmbedded;
+}
+
 bool AvailabilityContext::isDeprecated() const {
   return Info->Platform.IsDeprecated;
 }

lib/Sema/TypeCheckAvailability.cpp

@@ -364,19 +364,20 @@ static bool isInsideCompatibleUnavailableDeclaration(
   if (!referencedPlatform)
     return false;
 
-  if (!attr->isUnconditionallyUnavailable()) {
+  if (!attr->isUnconditionallyUnavailable())
     return false;
-  }
 
-  // Unless in embedded Swift mode, refuse calling unavailable functions from
-  // unavailable code, but allow the use of types.
+  // Refuse calling universally unavailable functions from unavailable code,
+  // but allow the use of types.
   PlatformKind platform = attr->Platform;
-  if (!D->getASTContext().LangOpts.hasFeature(Feature::Embedded)) {
-    if (platform == PlatformKind::none && !isa<TypeDecl>(D) &&
-        !isa<ExtensionDecl>(D)) {
-      return false;
-    }
-  }
+  if (platform == PlatformKind::none && !attr->isForEmbedded() &&
+      !isa<TypeDecl>(D) && !isa<ExtensionDecl>(D))
+    return false;
+
+  // @_unavailableInEmbedded declarations may be used in contexts that are
+  // also @_unavailableInEmbedded.
+  if (attr->isForEmbedded())
+    return availabilityContext.isUnavailableInEmbedded();
 
   return (*referencedPlatform == platform ||
           inheritsAvailabilityFromPlatform(platform, *referencedPlatform));

test/embedded/availability.swift

@@ -12,11 +12,11 @@ public struct UniverallyUnavailable {}
 
 @_unavailableInEmbedded
 public func unavailable_in_embedded() { }
-// expected-note@-1 {{'unavailable_in_embedded()' has been explicitly marked unavailable here}}
+// expected-note@-1 2 {{'unavailable_in_embedded()' has been explicitly marked unavailable here}}
 
 @available(*, unavailable, message: "always unavailable")
 public func universally_unavailable() { }
-// expected-note@-1 {{'universally_unavailable()' has been explicitly marked unavailable here}}
+// expected-note@-1 3 {{'universally_unavailable()' has been explicitly marked unavailable here}}
 
 @_unavailableInEmbedded
 public func unused() { } // no error
@@ -50,7 +50,7 @@ public func also_unavailable_in_embedded(
   _ uu: UniverallyUnavailable // FIXME: should be an error
 ) {
   unavailable_in_embedded() // OK
-  universally_unavailable() // FIXME: should be an error
+  universally_unavailable() // expected-error {{'universally_unavailable()' is unavailable: always unavailable}}
   has_unavailable_in_embedded_overload(.init()) // FIXME: should be ambiguous
   has_universally_unavailable_overload(.init()) // not ambiguous, selects available overload
 }
@@ -60,8 +60,8 @@ public func also_universally_unavailable(
   _ uie: UnavailableInEmbedded, // OK
   _ uu: UniverallyUnavailable // OK
 ) {
-  unavailable_in_embedded() // FIXME: should be an error
-  universally_unavailable() // FIXME: should be an error
+  unavailable_in_embedded() // expected-error {{'unavailable_in_embedded()' is unavailable: unavailable in embedded Swift}}
+  universally_unavailable() // expected-error {{'universally_unavailable()' is unavailable: always unavailable}}
   has_unavailable_in_embedded_overload(.init()) // not ambiguous, selects available overload
   has_universally_unavailable_overload(.init()) // not ambiguous, selects available overload
 }