[Sema] Warn about 'Any' to 'any Sendable' override

Until Swift 6, warn about overriding Any property in parent class to any Sendable

Author: angela-laar

lib/AST/Type.cpp

@@ -898,6 +898,25 @@ unsigned int TypeBase::getOptionalityDepth() {
 }
 
 Type TypeBase::stripConcurrency(bool recurse, bool dropGlobalActor) {
+  if (auto *arrayTy = dyn_cast<ArraySliceType>(this)) {
+      auto newBaseTy =
+          arrayTy->getBaseType()->stripConcurrency(recurse, dropGlobalActor);
+      return newBaseTy->isEqual(arrayTy->getBaseType())
+                 ? Type(this)
+                 : ArraySliceType::get(newBaseTy);
+    }
+
+    if (auto *dictTy = dyn_cast<DictionaryType>(this)) {
+      auto keyTy = dictTy->getKeyType();
+      auto strippedKeyTy = keyTy->stripConcurrency(recurse, dropGlobalActor);
+      auto valueTy = dictTy->getValueType();
+      auto strippedValueTy = valueTy->stripConcurrency(recurse, dropGlobalActor);
+
+      return keyTy->isEqual(strippedKeyTy) && valueTy->isEqual(strippedValueTy)
+                 ? Type(this)
+                 : DictionaryType::get(strippedKeyTy, strippedValueTy);
+    }
+
   // Look through optionals.
   if (Type optionalObject = getOptionalObjectType()) {
     Type newOptionalObject =
@@ -1083,25 +1102,6 @@ Type TypeBase::stripConcurrency(bool recurse, bool dropGlobalActor) {
     return anyChanged ? TupleType::get(elts, getASTContext()) : Type(this);
   }
 
-  if (auto *arrayTy = dyn_cast<ArraySliceType>(this)) {
-    auto newBaseTy =
-        arrayTy->getBaseType()->stripConcurrency(recurse, dropGlobalActor);
-    return newBaseTy->isEqual(arrayTy->getBaseType())
-               ? Type(this)
-               : ArraySliceType::get(newBaseTy);
-  }
-
-  if (auto *dictTy = dyn_cast<DictionaryType>(this)) {
-    auto keyTy = dictTy->getKeyType();
-    auto strippedKeyTy = keyTy->stripConcurrency(recurse, dropGlobalActor);
-    auto valueTy = dictTy->getValueType();
-    auto strippedValueTy = valueTy->stripConcurrency(recurse, dropGlobalActor);
-
-    return keyTy->isEqual(strippedKeyTy) && valueTy->isEqual(strippedValueTy)
-               ? Type(this)
-               : DictionaryType::get(strippedKeyTy, strippedValueTy);
-  }
-
   return Type(this);
 }
 

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1202,6 +1202,8 @@ bool OverrideMatcher::checkOverride(ValueDecl *baseDecl,
   // If this is an exact type match, we're successful!
   Type declTy = getDeclComparisonType();
   Type owningTy = dc->getDeclaredInterfaceType();
+  bool mismatchedOnSendability =
+      attempt == OverrideCheckingAttempt::MismatchedSendability;
   auto isClassContext = classDecl != nullptr;
   if (declIUOAttr == matchDeclIUOAttr && declTy->isEqual(baseTy)) {
     // Nothing to do.
@@ -1263,17 +1265,42 @@ bool OverrideMatcher::checkOverride(ValueDecl *baseDecl,
     CanType parentPropertyCanTy =
       parentPropertyTy->getReducedType(
         decl->getInnermostDeclContext()->getGenericSignatureOfContext());
-    if (!propertyTy->matches(parentPropertyCanTy,
-                             TypeMatchFlags::AllowOverride)) {
-      diags.diagnose(property, diag::override_property_type_mismatch,
-                     property->getName(), propertyTy, parentPropertyTy);
-      noteFixableMismatchedTypes(decl, baseDecl);
-      diags.diagnose(baseDecl, diag::property_override_here);
-      return true;
+
+    auto options = TypeMatchFlags::AllowOverride;
+    if (!propertyTy->matches(parentPropertyCanTy, options)) {
+      // The perfect match failed
+      bool failed = true;
+      if (baseDecl->preconcurrency() &&
+          (attempt == OverrideCheckingAttempt::PerfectMatch ||
+           attempt == OverrideCheckingAttempt::MismatchedSendability)) {
+        propertyTy = propertyTy->stripConcurrency(/*recursive=*/true,
+                                                  /*dropGlobalActor=*/true);
+        parentPropertyCanTy =
+        Type(parentPropertyCanTy)->stripConcurrency(/*recursive=*/true,
+                                               /*dropGlobalActor=*/true)->getCanonicalType();
+
+        parentPropertyTy =
+        parentPropertyTy->stripConcurrency(/*recursive=*/true,
+                                               /*dropGlobalActor=*/true);
+
+
+        if (propertyTy->matches(parentPropertyCanTy, options)) {
+          mismatchedOnSendability = true;
+          failed = false;
+        }
+      }
+
+      if (failed) {
+        diags.diagnose(property, diag::override_property_type_mismatch,
+                       property->getName(), propertyTy, parentPropertyTy);
+        noteFixableMismatchedTypes(decl, baseDecl);
+        diags.diagnose(baseDecl, diag::property_override_here);
+        return true;
+      }
     }
 
     // Differing only in Optional vs. ImplicitlyUnwrappedOptional is fine.
-    bool IsSilentDifference = false;
+    bool IsSilentDifference = mismatchedOnSendability;
     if (auto propertyTyNoOptional = propertyTy->getOptionalObjectType())
       if (auto parentPropertyTyNoOptional =
               parentPropertyTy->getOptionalObjectType())
@@ -1293,7 +1320,7 @@ bool OverrideMatcher::checkOverride(ValueDecl *baseDecl,
   if (emittedMatchError)
     return true;
 
-  if (attempt == OverrideCheckingAttempt::MismatchedSendability) {
+  if (mismatchedOnSendability) {
     SendableCheckContext fromContext(decl->getDeclContext(),
                                      SendableCheck::Explicit);
     auto baseDeclClass = baseDecl->getDeclContext()->getSelfClassDecl();

test/Concurrency/predates_concurrency.swift

@@ -249,3 +249,21 @@ extension MainActorPreconcurrency: NotIsolated {
     }
   }
 }
+
+
+open class Parent {
+    init(userInfo: [String : Any]) {
+        self.userInfo = userInfo
+    }
+
+  @preconcurrency open var userInfo : [String : any Sendable] // expected-note {{overridden declaration is here}}
+}
+
+class Child : Parent {
+    override var userInfo: [String : Any] { // expected-warning {{declaration 'userInfo' has a type with different sendability from any potential overrides; this is an error in the Swift 6 language mode}}
+        get {
+            [:]
+        }
+        set {}
+    }
+}