Sema: Don't allow opaque return types to reference DynamicSelfType [5.7]

include/swift/AST/DiagnosticsSema.def

@@ -4244,6 +4244,9 @@ NOTE(opaque_type_underlying_type_candidate_here,none,
 ERROR(opaque_type_self_referential_underlying_type,none,
       "function opaque return type was inferred as %0, which defines the "
       "opaque type in terms of itself", (Type))
+ERROR(opaque_type_cannot_contain_dynamic_self,none,
+      "function with opaque return type cannot return "
+      "the covariant 'Self' type of a class", ())
 ERROR(opaque_type_var_no_init,none,
       "property declares an opaque return type, but has no initializer "
       "expression from which to infer an underlying type", ())

lib/Sema/MiscDiagnostics.cpp

@@ -2815,20 +2815,26 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
 
   std::pair<bool, Expr *> walkToExprPre(Expr *E) override {
     if (auto underlyingToOpaque = dyn_cast<UnderlyingToOpaqueExpr>(E)) {
-      auto key =
-          underlyingToOpaque->substitutions.getCanonical().getOpaqueValue();
+      auto subMap = underlyingToOpaque->substitutions;
 
+      auto key = subMap.getCanonical().getOpaqueValue();
       auto isUnique = UniqueSignatures.insert(key).second;
 
       auto candidate =
-          std::make_tuple(underlyingToOpaque->getSubExpr(),
-                          underlyingToOpaque->substitutions, isUnique);
+          std::make_tuple(underlyingToOpaque->getSubExpr(), subMap, isUnique);
 
       if (isSelfReferencing(candidate)) {
         HasInvalidReturn = true;
         return {false, nullptr};
       }
 
+      if (subMap.hasDynamicSelf()) {
+        Ctx.Diags.diagnose(E->getLoc(),
+                           diag::opaque_type_cannot_contain_dynamic_self);
+        HasInvalidReturn = true;
+        return {false, nullptr};
+      }
+
       Candidates.push_back({CurrentAvailability, candidate});
       return {false, E};
     }

test/type/opaque_return_dynamic_self.swift

@@ -0,0 +1,36 @@
+// RUN: %target-typecheck-verify-swift -disable-availability-checking
+
+protocol P {
+  init()
+}
+
+extension P {
+  static func opaqueProtocolExtensionFunc() -> some P { return Self() }
+}
+
+class C: P {
+  required init() {}
+
+  static func opaqueFunc1() -> some P {
+    return Self()
+    // expected-error@-1 {{function with opaque return type cannot return the covariant 'Self' type of a class}}
+  }
+
+  static func opaqueFunc2() -> some P {
+    return Self.opaqueProtocolExtensionFunc()
+    // expected-error@-1 {{function with opaque return type cannot return the covariant 'Self' type of a class}}
+  }
+
+  var opaqueProperty: some P {
+    return Self()
+    // expected-error@-1 {{function with opaque return type cannot return the covariant 'Self' type of a class}}
+  }
+
+  subscript() -> some P {
+    return Self()
+    // expected-error@-1 {{function with opaque return type cannot return the covariant 'Self' type of a class}}
+  }
+
+  var opaqueStoredProperty: some P = Self()
+  // expected-error@-1 {{covariant 'Self' type cannot be referenced from a stored property initializer}}
+}