Opaque types are only invariant when they involve same-type constraints.

An opaque type is only invariant with respect to the existential Self
when the constraints on the opaque type involve Self. Such constraints
are not expressible in the type-erased value, so treat them as
invariant. This loosens the restriction on using members of protocol
type that return an opaque type, such that (e.g.) the following is
still well-formed:

    protocol P { }
    protocol Q { }

    extension P {
      func getQ() -> some Q { ... }
    }

    func test(p: any P) {
      let q = p.getQ() // formerly an error, now returns an "any Q"
    }

However, this does not permit uses of members such as:

    extension P {
      func getCollection() -> some Collection<Self> { ... } // error
    }

because the type system cannot express the corresponding existential
type `any Collection<Self>`.

Author: DougGregor

lib/AST/Decl.cpp

@@ -3914,10 +3914,29 @@ findExistentialSelfReferences(CanGenericSignature existentialSig, Type type,
     return info;
   }
 
-  // Opaque result types of protocol extension members contain an invariant
-  // reference to 'Self'.
-  if (type->is<OpaqueTypeArchetypeType>())
-    return SelfReferenceInfo::forSelfRef(TypePosition::Invariant);
+  // If the signature of an opaque result type has a same-type constraint
+  // that refereces Self, it's invariant.
+  if (auto opaque = type->getAs<OpaqueTypeArchetypeType>()) {
+    auto info = SelfReferenceInfo();
+    auto opaqueSig = opaque->getDecl()->getOpaqueInterfaceGenericSignature();
+    for (const auto &req : opaqueSig.getRequirements()) {
+      switch (req.getKind()) {
+      case RequirementKind::Conformance:
+      case RequirementKind::Layout:
+      case RequirementKind::Superclass:
+        continue;
+
+      case RequirementKind::SameType:
+        info |= findExistentialSelfReferences(
+            existentialSig, req.getFirstType(), TypePosition::Invariant);
+        info |= findExistentialSelfReferences(
+            existentialSig, req.getSecondType(), TypePosition::Invariant);
+        break;
+      }
+    }
+
+    return info;
+  }
 
   // Protocol compositions preserve variance.
   if (auto *existential = type->getAs<ExistentialType>())

lib/Sema/ConstraintSystem.cpp

@@ -1813,7 +1813,7 @@ static Type typeEraseCovariantExistentialSelfReferences(Type refTy,
 
       // Opaque types whose substitutions involve this type parameter are
       // erased to their upper bound.
-      if (auto opaque = dyn_cast<OpaqueTypeArchetypeType>(type.getPointer())) {
+      if (auto opaque = dyn_cast<OpaqueTypeArchetypeType>(t)) {
         for (auto replacementType :
                  opaque->getSubstitutions().getReplacementTypes()) {
           if (hasErasedGenericParameter(replacementType)) {

test/Constraints/opened_existentials.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift -enable-experimental-opened-existential-types -enable-parametrized-protocol-types -enable-experimental-opaque-parameters
+// RUN: %target-typecheck-verify-swift -enable-experimental-opened-existential-types -enable-parameterized-protocol-types
 
 protocol Q { }
 
@@ -77,3 +77,22 @@ func useReverseIt(_ c: any CollectionOf) {
   let c = reverseIt(c)
   let _: Int = c // expected-error{{cannot convert value of type 'CollectionOf' to specified type 'Int'}}
 }
+
+/// --- Opening existentials when returning opaque types.
+extension P {
+  func getQ() -> some Q {
+    let a: A? = nil
+    return a!
+  }
+
+  func getCollectionOf() -> some CollectionOf<A> {
+    return [] as [A]
+  }
+}
+
+func testReturningOpaqueTypes(p: any P) {
+  let q = p.getQ()
+  let _: Int = q  // expected-error{{cannot convert value of type 'Q' to specified type 'Int'}}
+
+  p.getCollectionOf() // expected-error{{member 'getCollectionOf' cannot be used on value of protocol type 'P'; use a generic constraint instead}}
+}

test/decl/protocol/existential_member_accesses_self_assoctype.swift

@@ -343,7 +343,7 @@ do {
 
     arg.invariantSelf1(0) // expected-error {{member 'invariantSelf1' cannot be used on value of protocol type 'P1'; use a generic constraint instead}}
     if #available(macOS 10.15, *) {
-      arg.invariantSelf1_1() // expected-error {{member 'invariantSelf1_1' cannot be used on value of protocol type 'P1'; use a generic constraint instead}}
+      _ = arg.invariantSelf1_1()
     }
     arg.invariantSelf2(0) // expected-error {{member 'invariantSelf2' cannot be used on value of protocol type 'P1'; use a generic constraint instead}}
     arg.invariantSelf3(0) // expected-error {{member 'invariantSelf3' cannot be used on value of protocol type 'P1'; use a generic constraint instead}}
@@ -392,7 +392,7 @@ do {
 
     arg.invariantSelfProp1 // expected-error {{member 'invariantSelfProp1' cannot be used on value of protocol type 'P1'; use a generic constraint instead}}
     if #available(macOS 10.15, *) {
-      arg.invariantSelfProp1_1 // expected-error {{member 'invariantSelfProp1_1' cannot be used on value of protocol type 'P1'; use a generic constraint instead}}
+      _ = arg.invariantSelfProp1_1
     }
     arg.invariantSelfProp2 // expected-error {{member 'invariantSelfProp2' cannot be used on value of protocol type 'P1'; use a generic constraint instead}}
     arg.invariantSelfProp3 // expected-error {{member 'invariantSelfProp3' cannot be used on value of protocol type 'P1'; use a generic constraint instead}}

test/type/opaque.swift

@@ -503,10 +503,11 @@ extension OpaqueProtocol {
 }
 
 func takesOpaqueProtocol(existential: OpaqueProtocol) {
-  // this is not allowed:
-  _ = existential.asSome // expected-error{{member 'asSome' cannot be used on value of protocol type 'OpaqueProtocol'; use a generic constraint instead}}
-  _ = existential.getAsSome() // expected-error{{member 'getAsSome' cannot be used on value of protocol type 'OpaqueProtocol'; use a generic constraint instead}}
-  _ = existential[0] // expected-error{{member 'subscript' cannot be used on value of protocol type 'OpaqueProtocol'; use a generic constraint instead}}
+  // These are okay because we erase to the opaque type bound
+  let a = existential.asSome
+  let _: Int = a // expected-error{{cannot convert value of type 'OpaqueProtocol' to specified type 'Int'}}
+  _ = existential.getAsSome()
+  _ = existential[0]
 }
 
 func takesOpaqueProtocol<T : OpaqueProtocol>(generic: T) {