Merge remote-tracking branch 'origin/main' into rebranch

swift-ci · swift-ci · commit f7babf2d25fd · 2025-07-16T21:35:19.000-07:00
diff --git a/include/swift/AST/AvailabilityConstraint.h b/include/swift/AST/AvailabilityConstraint.h
@@ -174,6 +174,12 @@ enum class AvailabilityConstraintFlag : uint8_t {
   /// Include constraints for all domains, regardless of whether they are active
   /// or relevant to type checking.
   IncludeAllDomains = 1 << 1,
+
+  /// By default, non-type declarations that are universally unavailable are
+  /// always diagnosed, regardless of whether the context of the reference
+  /// is also universally unavailable. If this flag is set, though, those
+  /// references are allowed.
+  AllowUniversallyUnavailableInCompatibleContexts = 1 << 2,
 };
 using AvailabilityConstraintFlags = OptionSet<AvailabilityConstraintFlag>;
 
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -1264,6 +1264,9 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// representation, i.e. whether it is representable as a single,
   /// possibly nil pointer that can be unknown-retained and
   /// unknown-released.
+  /// This does not include C++ imported `SWIFT_SHARED_REFERENCE` classes.
+  /// They act as Swift classes but are not compatible with Swift's
+  /// retain/release runtime functions.
   bool hasRetainablePointerRepresentation();
 
   /// Given that this type is a reference type, which kind of reference
diff --git a/include/swift/SIL/SILType.h b/include/swift/SIL/SILType.h
@@ -419,6 +419,9 @@ class SILType {
   
   /// Returns true if the referenced type is guaranteed to have a
   /// single-retainable-pointer representation.
+  /// This does not include C++ imported `SWIFT_SHARED_REFERENCE` classes.
+  /// They act as Swift classes but are not compatible with Swift's
+  /// retain/release runtime functions.
   bool hasRetainablePointerRepresentation() const {
     return getASTType()->hasRetainablePointerRepresentation();
   }
diff --git a/lib/AST/AvailabilityConstraint.cpp b/lib/AST/AvailabilityConstraint.cpp
@@ -118,11 +118,16 @@ DeclAvailabilityConstraints::getPrimaryConstraint() const {
 }
 
 static bool canIgnoreConstraintInUnavailableContexts(
-    const Decl *decl, const AvailabilityConstraint &constraint) {
+    const Decl *decl, const AvailabilityConstraint &constraint,
+    const AvailabilityConstraintFlags flags) {
   auto domain = constraint.getDomain();
 
   switch (constraint.getReason()) {
   case AvailabilityConstraint::Reason::UnconditionallyUnavailable:
+    if (flags.contains(AvailabilityConstraintFlag::
+                           AllowUniversallyUnavailableInCompatibleContexts))
+      return true;
+
     // Always reject uses of universally unavailable declarations, regardless
     // of context, since there are no possible compilation configurations in
     // which they are available. However, make an exception for types and
@@ -162,11 +167,12 @@ static bool canIgnoreConstraintInUnavailableContexts(
 static bool
 shouldIgnoreConstraintInContext(const Decl *decl,
                                 const AvailabilityConstraint &constraint,
-                                const AvailabilityContext &context) {
+                                const AvailabilityContext &context,
+                                const AvailabilityConstraintFlags flags) {
   if (!context.isUnavailable())
     return false;
 
-  if (!canIgnoreConstraintInUnavailableContexts(decl, constraint))
+  if (!canIgnoreConstraintInUnavailableContexts(decl, constraint, flags))
     return false;
 
   return context.containsUnavailableDomain(constraint.getDomain());
@@ -256,7 +262,7 @@ static void getAvailabilityConstraintsForDecl(
   // declaration is unconditionally unavailable in a domain for which
   // the context is already unavailable.
   llvm::erase_if(constraints, [&](const AvailabilityConstraint &constraint) {
-    return shouldIgnoreConstraintInContext(decl, constraint, context);
+    return shouldIgnoreConstraintInContext(decl, constraint, context, flags);
   });
 }
 
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -2844,6 +2844,11 @@ static bool hasRetainablePointerRepresentation(CanType type) {
     type = objType;
   }
 
+  // C++ imported `SWIFT_SHARED_REFERENCE` classes are not compatible with
+  // Swift's retain/release runtime functions.
+  if (type.isForeignReferenceType())
+    return false;
+
   return isBridgeableObjectType(type);
 }
 
diff --git a/lib/Sema/ConstraintSystem.cpp b/lib/Sema/ConstraintSystem.cpp
@@ -4997,11 +4997,7 @@ bool ConstraintSystem::isReadOnlyKeyPathComponent(
   // If the setter is unavailable, then the keypath ought to be read-only
   // in this context.
   if (auto setter = storage->getOpaqueAccessor(AccessorKind::Set)) {
-    // FIXME: [availability] Fully unavailable setters should cause the key path
-    // to be readonly too.
-    auto constraint =
-        getUnsatisfiedAvailabilityConstraint(setter, DC, referenceLoc);
-    if (constraint && constraint->isPotentiallyAvailable())
+    if (getUnsatisfiedAvailabilityConstraint(setter, DC, referenceLoc))
       return true;
   }
 
diff --git a/lib/Sema/TypeCheckAvailability.cpp b/lib/Sema/TypeCheckAvailability.cpp
@@ -1771,8 +1771,17 @@ std::optional<AvailabilityConstraint>
 swift::getUnsatisfiedAvailabilityConstraint(const Decl *decl,
                                             const DeclContext *referenceDC,
                                             SourceLoc referenceLoc) {
+  AvailabilityConstraintFlags flags;
+
+  // In implicit code, allow references to universally unavailable declarations
+  // as long as the context is also universally unavailable.
+  if (referenceLoc.isInvalid())
+    flags |= AvailabilityConstraintFlag::
+        AllowUniversallyUnavailableInCompatibleContexts;
+
   return getAvailabilityConstraintsForDecl(
-             decl, AvailabilityContext::forLocation(referenceLoc, referenceDC))
+             decl, AvailabilityContext::forLocation(referenceLoc, referenceDC),
+             flags)
       .getPrimaryConstraint();
 }
 
diff --git a/lib/Sema/TypeCheckStorage.cpp b/lib/Sema/TypeCheckStorage.cpp
@@ -1063,7 +1063,7 @@ getPropertyWrapperLValueness(VarDecl *var) {
 ///     - Wrapped: \c self._member.wrappedValue
 ///     - Composition: \c self._member.wrappedValue.wrappedValue….wrappedValue
 ///     - Projected: \c self._member.projectedValue
-///     - Enclosed instance: \c Wrapper[_enclosedInstance: self, …]
+///     - Enclosed instance: \c Wrapper[_enclosingInstance: self, …]
 static Expr *buildStorageReference(AccessorDecl *accessor,
                                    AbstractStorageDecl *storage,
                                    TargetImpl target,
diff --git a/test/Availability/availability_accessors.swift b/test/Availability/availability_accessors.swift
@@ -63,14 +63,14 @@ struct BaseStruct<T> {
   var unavailableSetter: T {
     get { fatalError() }
     @available(*, unavailable)
-    set { fatalError() } // expected-note 38 {{setter for 'unavailableSetter' has been explicitly marked unavailable here}}
+    set { fatalError() } // expected-note 33 {{setter for 'unavailableSetter' has been explicitly marked unavailable here}}
   }
 
   var unavailableGetterAndSetter: T {
     @available(*, unavailable)
     get { fatalError() } // expected-note 67 {{getter for 'unavailableGetterAndSetter' has been explicitly marked unavailable here}}
     @available(*, unavailable)
-    set { fatalError() } // expected-note 38 {{setter for 'unavailableGetterAndSetter' has been explicitly marked unavailable here}}
+    set { fatalError() } // expected-note 33 {{setter for 'unavailableGetterAndSetter' has been explicitly marked unavailable here}}
   }
 }
 
@@ -318,17 +318,17 @@ func testKeyPathAssignments_Struct(_ someValue: StructValue) {
   a[keyPath: \.[takesInOut(&x.unavailableGetter.a.b)]] = 0 // expected-error {{getter for 'unavailableGetter' is unavailable}}
   a[keyPath: \.[takesInOut(&x.unavailableGetter[0].b)]] = 0 // expected-error {{getter for 'unavailableGetter' is unavailable}}
 
-  x[keyPath: \.unavailableSetter] = someValue // expected-error {{setter for 'unavailableSetter' is unavailable}}
-  x[keyPath: \.unavailableSetter.a] = someValue.a // expected-error {{setter for 'unavailableSetter' is unavailable}}
-  x[keyPath: \.unavailableSetter[0]] = someValue.a // expected-error {{setter for 'unavailableSetter' is unavailable}}
-  x[keyPath: \.unavailableSetter[0].b] = 1 // expected-error {{setter for 'unavailableSetter' is unavailable}}
+  x[keyPath: \.unavailableSetter] = someValue // expected-error {{cannot assign through subscript: key path is read-only}}
+  x[keyPath: \.unavailableSetter.a] = someValue.a // expected-error {{cannot assign through subscript: key path is read-only}}
+  x[keyPath: \.unavailableSetter[0]] = someValue.a // expected-error {{cannot assign through subscript: key path is read-only}}
+  x[keyPath: \.unavailableSetter[0].b] = 1 // expected-error {{cannot assign through subscript: key path is read-only}}
   a[keyPath: \.[takesInOut(&x.unavailableSetter.a.b)]] = 0 // expected-error {{setter for 'unavailableSetter' is unavailable}}
   a[keyPath: \.[takesInOut(&x.unavailableSetter[0].b)]] = 0 // expected-error {{setter for 'unavailableSetter' is unavailable}}
 
-  x[keyPath: \.unavailableGetterAndSetter] = someValue // expected-error {{setter for 'unavailableGetterAndSetter' is unavailable}}
-  x[keyPath: \.unavailableGetterAndSetter.a] = someValue.a // expected-error {{setter for 'unavailableGetterAndSetter' is unavailable}}
-  x[keyPath: \.unavailableGetterAndSetter[0]] = someValue.a // expected-error {{setter for 'unavailableGetterAndSetter' is unavailable}}
-  x[keyPath: \.unavailableGetterAndSetter[0].b] = 1 // expected-error {{setter for 'unavailableGetterAndSetter' is unavailable}}
+  x[keyPath: \.unavailableGetterAndSetter] = someValue // expected-error {{cannot assign through subscript: key path is read-only}}
+  x[keyPath: \.unavailableGetterAndSetter.a] = someValue.a // expected-error {{cannot assign through subscript: key path is read-only}}
+  x[keyPath: \.unavailableGetterAndSetter[0]] = someValue.a // expected-error {{cannot assign through subscript: key path is read-only}}
+  x[keyPath: \.unavailableGetterAndSetter[0].b] = 1 // expected-error {{cannot assign through subscript: key path is read-only}}
   a[keyPath: \.[takesInOut(&x.unavailableGetterAndSetter.a.b)]] = 0 // expected-error {{getter for 'unavailableGetterAndSetter' is unavailable}} expected-error {{setter for 'unavailableGetterAndSetter' is unavailable}}
   a[keyPath: \.[takesInOut(&x.unavailableGetterAndSetter[0].b)]] = 0 // expected-error {{getter for 'unavailableGetterAndSetter' is unavailable}} expected-error {{setter for 'unavailableGetterAndSetter' is unavailable}}
 }
@@ -352,7 +352,7 @@ func testKeyPathAssignments_Class(_ someValue: ClassValue) {
   a[keyPath: \.[takesInOut(&x.unavailableGetter.a.b)]] = 0 // expected-error {{getter for 'unavailableGetter' is unavailable}}
   a[keyPath: \.[takesInOut(&x.unavailableGetter[0].b)]] = 0 // expected-error {{getter for 'unavailableGetter' is unavailable}}
 
-  x[keyPath: \.unavailableSetter] = someValue // expected-error {{setter for 'unavailableSetter' is unavailable}}
+  x[keyPath: \.unavailableSetter] = someValue // expected-error {{cannot assign through subscript: key path is read-only}}
   // FIXME: spurious unavailable setter error
   x[keyPath: \.unavailableSetter.a] = someValue.a // expected-error {{setter for 'unavailableSetter' is unavailable}}
   // FIXME: spurious unavailable setter error
@@ -362,7 +362,7 @@ func testKeyPathAssignments_Class(_ someValue: ClassValue) {
   a[keyPath: \.[takesInOut(&x.unavailableSetter.a.b)]] = 0
   a[keyPath: \.[takesInOut(&x.unavailableSetter[0].b)]] = 0
 
-  x[keyPath: \.unavailableGetterAndSetter] = someValue // expected-error {{setter for 'unavailableGetterAndSetter' is unavailable}}
+  x[keyPath: \.unavailableGetterAndSetter] = someValue // expected-error {{cannot assign through subscript: key path is read-only}}
   x[keyPath: \.unavailableGetterAndSetter.a] = someValue.a // expected-error {{setter for 'unavailableGetterAndSetter' is unavailable}}
   x[keyPath: \.unavailableGetterAndSetter[0]] = someValue.a // expected-error {{setter for 'unavailableGetterAndSetter' is unavailable}}
   // FIXME: spurious unavailable setter error
diff --git a/test/Availability/property_wrapper_availability.swift b/test/Availability/property_wrapper_availability.swift
@@ -186,3 +186,36 @@ func unavailableOnMacOSFunc(
   @WrappedValueUnavailableOnMacOS var unavailableWrappedValueLocal = S()
   @WrappedValueAvailable51 var wrappedValueAavailable51 = S()
 }
+
+@propertyWrapper
+struct Observable<Value> {
+  private var stored: Value
+
+  init(wrappedValue: Value) {
+    self.stored = wrappedValue
+  }
+
+  var wrappedValue: Value {
+    get { fatalError() }
+    set { fatalError() }
+  }
+
+  static subscript<EnclosingSelf>(
+      _enclosingInstance observed: EnclosingSelf,
+      wrapped wrappedKeyPath: ReferenceWritableKeyPath<EnclosingSelf, Value>,
+      storage storageKeyPath: ReferenceWritableKeyPath<EnclosingSelf, Self>
+    ) -> Value {
+    get { fatalError() }
+    set { fatalError() }
+  }
+}
+
+@available(macOS, unavailable)
+class UnavailableOnMacOSObserved {
+  @Observable var observedProperty = 17
+}
+
+@available(*, unavailable)
+class UniversallyUnavailableObserved {
+  @Observable var observedProperty = 17
+}
diff --git a/test/Interop/Cxx/foreign-reference/array-of-classes.swift b/test/Interop/Cxx/foreign-reference/array-of-classes.swift
@@ -0,0 +1,66 @@
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+// RUN: %swiftc_driver -O -I %t/Inputs  %t/test.swift -cxx-interoperability-mode=default -I %swift_src_root/lib/ClangImporter/SwiftBridging -o %t/a.out
+// RUN: %target-codesign %t/a.out
+// RUN: %target-run %t/a.out | %FileCheck %s
+
+// REQUIRES: executable_test
+// UNSUPPORTED: back_deployment_runtime
+
+// Metadata for foreign reference types is not supported on Windows.
+// UNSUPPORTED: OS=windows-msvc
+
+//--- Inputs/module.modulemap
+
+module Test {
+    header "reftype.h"
+    requires cplusplus
+}
+
+//--- Inputs/reftype.h
+
+#include "swift/bridging"
+
+class RefType {
+public:
+    static RefType* _Nonnull makeRefType() SWIFT_RETURNS_RETAINED {
+        return new RefType();
+    }
+
+private:
+    RefType() : _refCount(1) {
+    }
+    RefType(const RefType&) = delete;
+    RefType& operator=(const RefType&) = delete;
+    ~RefType() {
+    }
+    
+    inline friend void retainRefType(RefType* _Nonnull x) {
+        x->_refCount += 1;
+
+    }
+    inline friend void releaseRefType(RefType* _Nonnull x) {
+        x->_refCount -= 1;
+        if (x->_refCount == 0) {
+            delete x;
+        }
+    }
+    
+    int _refCount;
+} SWIFT_SHARED_REFERENCE(retainRefType, releaseRefType);
+
+//--- test.swift
+
+import Test
+
+@inline(never)
+func go() {
+    let x: RefType = RefType.makeRefType()
+    var y: [RefType] = []
+    y.append(x)
+// CHECK: 1
+    print(y.count)
+}
+
+go()
+
diff --git a/test/expr/unary/keypath/keypath-availability.swift b/test/expr/unary/keypath/keypath-availability.swift

Original file line number	Diff line number	Diff line change
`@@ -419,6 +419,9 @@ class SILType {`
`419`	`419`
`420`	`420`	`/// Returns true if the referenced type is guaranteed to have a`
`421`	`421`	`/// single-retainable-pointer representation.`
	`422`	+ /// This does not include C++ imported `SWIFT_SHARED_REFERENCE` classes.
	`423`	`+ /// They act as Swift classes but are not compatible with Swift's`
	`424`	`+ /// retain/release runtime functions.`
`422`	`425`	`bool hasRetainablePointerRepresentation() const {`
`423`	`426`	`return getASTType()->hasRetainablePointerRepresentation();`
`424`	`427`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2844,6 +2844,11 @@ static bool hasRetainablePointerRepresentation(CanType type) {`
`2844`	`2844`	`type = objType;`
`2845`	`2845`	`}`
`2846`	`2846`
	`2847`	+ // C++ imported `SWIFT_SHARED_REFERENCE` classes are not compatible with
	`2848`	`+ // Swift's retain/release runtime functions.`
	`2849`	`+ if (type.isForeignReferenceType())`
	`2850`	`+ return false;`
	`2851`	`+`
`2847`	`2852`	`return isBridgeableObjectType(type);`
`2848`	`2853`	`}`
`2849`	`2854`