Merge pull request #77316 from tshortli/unavailable-in-embedded

Sema: Allow calls to @_unavailableInEmbedded functions in compatible 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;
@@ -49,24 +52,15 @@ struct AvailabilityContext::PlatformInfo {
   /// availability is more restrictive. Returns true if any field was updated.
   bool constrainWith(const Decl *decl);
 
-  bool constrainRange(const AvailabilityRange &other) {
-    if (!other.isContainedIn(Range))
-      return false;
-
-    Range = other;
-    return true;
-  }
-
   bool constrainUnavailability(std::optional<PlatformKind> unavailablePlatform);
 
-  bool constrainDeprecated(bool deprecated);
-
   /// Returns true if `other` is as available or is more available.
   bool isContainedIn(const PlatformInfo &other) const;
 
   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

@@ -18,14 +18,34 @@
 
 using namespace swift;
 
+// Defined as a macro because you can't take the reference of a bitfield.
+#define CONSTRAIN_BOOL(_old, _new)                                             \
+  [&]() {                                                                      \
+    if (_old || !_new)                                                         \
+      return false;                                                            \
+    _old = true;                                                               \
+    return true;                                                               \
+  }()
+
+static bool constrainRange(AvailabilityRange &existing,
+                           const AvailabilityRange &other) {
+  if (!other.isContainedIn(existing))
+    return false;
+
+  existing = other;
+  return true;
+}
+
 bool AvailabilityContext::PlatformInfo::constrainWith(
     const PlatformInfo &other) {
   bool isConstrained = false;
-  isConstrained |= constrainRange(other.Range);
+  isConstrained |= constrainRange(Range, other.Range);
   if (other.IsUnavailable) {
     isConstrained |= constrainUnavailability(other.UnavailablePlatform);
+    isConstrained |=
+        CONSTRAIN_BOOL(IsUnavailableInEmbedded, other.IsUnavailableInEmbedded);
   }
-  isConstrained |= constrainDeprecated(other.IsDeprecated);
+  isConstrained |= CONSTRAIN_BOOL(IsDeprecated, other.IsDeprecated);
 
   return isConstrained;
 }
@@ -35,13 +55,16 @@ bool AvailabilityContext::PlatformInfo::constrainWith(const Decl *decl) {
   auto &ctx = decl->getASTContext();
 
   if (auto range = AvailabilityInference::annotatedAvailableRange(decl))
-    isConstrained |= constrainRange(*range);
+    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());
+  }
 
-  if (!IsDeprecated)
-    isConstrained |= constrainDeprecated(decl->getAttrs().isDeprecated(ctx));
+  isConstrained |=
+      CONSTRAIN_BOOL(IsDeprecated, decl->getAttrs().isDeprecated(ctx));
 
   return isConstrained;
 }
@@ -72,14 +95,6 @@ bool AvailabilityContext::PlatformInfo::constrainUnavailability(
   return true;
 }
 
-bool AvailabilityContext::PlatformInfo::constrainDeprecated(bool deprecated) {
-  if (IsDeprecated || !deprecated)
-    return false;
-
-  IsDeprecated = true;
-  return true;
-}
-
 bool AvailabilityContext::PlatformInfo::isContainedIn(
     const PlatformInfo &other) const {
   if (!Range.isContainedIn(other.Range))
@@ -94,6 +109,9 @@ bool AvailabilityContext::PlatformInfo::isContainedIn(
         inheritsAvailabilityFromPlatform(UnavailablePlatform,
                                          other.UnavailablePlatform))
       return false;
+
+    if (IsUnavailableInEmbedded && !other.IsUnavailableInEmbedded)
+      return false;
   }
 
   if (!IsDeprecated && other.IsDeprecated)
@@ -110,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));
 }
@@ -122,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));
 }
 
@@ -137,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;
 }
@@ -156,7 +180,7 @@ void AvailabilityContext::constrainWithDecl(const Decl *decl) {
 void AvailabilityContext::constrainWithPlatformRange(
     const AvailabilityRange &platformRange, ASTContext &ctx) {
   PlatformInfo platformAvailability{Info->Platform};
-  if (!platformAvailability.constrainRange(platformRange))
+  if (!constrainRange(platformAvailability.Range, platformRange))
     return;
 
   Info = Storage::get(platformAvailability, ctx);
@@ -167,7 +191,7 @@ void AvailabilityContext::constrainWithDeclAndPlatformRange(
   PlatformInfo platformAvailability{Info->Platform};
   bool isConstrained = false;
   isConstrained |= platformAvailability.constrainWith(decl);
-  isConstrained |= platformAvailability.constrainRange(platformRange);
+  isConstrained |= constrainRange(platformAvailability.Range, platformRange);
 
   if (!isConstrained)
     return;

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));

stdlib/public/Concurrency/TaskLocal.swift

@@ -311,7 +311,7 @@ public final class TaskLocal<Value: Sendable>: Sendable, CustomStringConvertible
 
     @available(*, unavailable, message: "use '$myTaskLocal.withValue(_:do:)' instead")
     set {
-      fatalError("Illegal attempt to set a \(Self.self) value, use `withValue(...) { ... }` instead.")
+      fatalError("Illegal attempt to set a TaskLocal value, use `withValue(...) { ... }` instead.")
     }
   }
 

test/Sema/availability.swift

@@ -3,8 +3,12 @@
 @available(*, unavailable)
 func unavailable_foo() {} // expected-note {{'unavailable_foo()' has been explicitly marked unavailable here}}
 
+@_unavailableInEmbedded // no-op without -enable-experimental-feature Embedded
+public func unavailable_in_embedded() { }
+
 func test() {
   unavailable_foo() // expected-error {{'unavailable_foo()' is unavailable}}
+  unavailable_in_embedded() // ok
 }
 
 @available(*,unavailable,message: "use 'Int' instead")

test/embedded/availability.swift

@@ -1,24 +1,67 @@
-// Building with regular Swift should succeed
-// RUN: %target-swift-emit-ir %s -parse-stdlib  -wmo
-
-// Building with embedded Swift should produce unavailability errors
-// RUN: %target-typecheck-verify-swift -parse-stdlib -enable-experimental-feature Embedded  -wmo
+// RUN: %target-typecheck-verify-swift -parse-stdlib -enable-experimental-feature Embedded
 
 // REQUIRES: swift_in_compiler
 
 @_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}}
-}
+public struct UnavailableInEmbedded {}
+// expected-note@-1 {{'UnavailableInEmbedded' has been explicitly marked unavailable here}}
+
+@available(*, unavailable, message: "always unavailable")
+public struct UniverallyUnavailable {}
+// expected-note@-1 {{'UniverallyUnavailable' has been explicitly marked unavailable here}}
+
+@_unavailableInEmbedded
+public func unavailable_in_embedded() { }
+// 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 3 {{'universally_unavailable()' has been explicitly marked unavailable here}}
 
 @_unavailableInEmbedded
 public func unused() { } // no error
 
+public struct S1 {}
+public struct S2 {}
+
 @_unavailableInEmbedded
-public func called_from_unavailable() { }
+public func has_unavailable_in_embedded_overload(_ s1: S1) { }
+
+public func has_unavailable_in_embedded_overload(_ s2: S2) { }
+
+@available(*, unavailable)
+public func has_universally_unavailable_overload(_ s1: S1) { }
+
+public func has_universally_unavailable_overload(_ s2: S2) { }
+
+public func available(
+  _ uie: UnavailableInEmbedded, // expected-error {{'UnavailableInEmbedded' is unavailable: unavailable in embedded Swift}}
+  _ uu: UniverallyUnavailable // expected-error {{'UniverallyUnavailable' is unavailable: always unavailable}}
+) {
+  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())
+  has_universally_unavailable_overload(.init()) // not ambiguous, selects available overload
+}
+
 @_unavailableInEmbedded
-public func also_embedded() { 
-	called_from_unavailable() // no error
+public func also_unavailable_in_embedded(
+  _ uie: UnavailableInEmbedded, // OK
+  _ uu: UniverallyUnavailable // FIXME: should be an error
+) {
+  unavailable_in_embedded() // OK
+  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
+}
+
+@available(*, unavailable)
+public func also_universally_unavailable(
+  _ uie: UnavailableInEmbedded, // OK
+  _ uu: UniverallyUnavailable // OK
+) {
+  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
 }