[Concurrency] Don't skip conformance derivation for types with isolated stored

properties.

Otherwise, types that rely on derived conformances to Equatable and friends will
fail to compile if a library adds a `@preconcurrency @MainActor` annotation. There
is no need to prevent conformance derivation, because the actor isolation checker
still runs on derived witnesses and will diagnose any concurrecy violations (with
appropriate downgrading behavior for `@preconcurrency`).

Author: hborla

include/swift/AST/DiagnosticsSema.def

@@ -5564,6 +5564,9 @@ ERROR(isolation_macro_experimental,none,
 NOTE(in_derived_conformance, none,
      "in derived conformance to %0",
      (Type))
+NOTE(in_derived_witness, none,
+     "in %0 %1 for derived conformance to %2",
+     (DescriptiveDeclKind, DeclName, Type))
 ERROR(non_sendable_param_type,none,
       "non-sendable type %0 %select{passed in call to %3 %kind2|"
       "exiting %3 context in call to non-isolated %kind2|"

lib/Sema/DerivedConformanceCodable.cpp

@@ -2086,12 +2086,6 @@ static bool canDeriveCodable(NominalTypeDecl *NTD,
     return false;
   }
 
-  // Actor-isolated structs and classes cannot derive encodable/decodable
-  // unless all of their stored properties are immutable.
-  if ((isa<StructDecl>(NTD) || isa<ClassDecl>(NTD)) &&
-      memberwiseAccessorsRequireActorIsolation(NTD))
-    return false;
-
   return true;
 }
 

lib/Sema/DerivedConformanceEquatableHashable.cpp

@@ -50,11 +50,6 @@ static bool canDeriveConformance(DeclContext *DC,
                DC, structDecl, protocol).empty())
       return false;
 
-    // If the struct is actor-isolated, we cannot derive Equatable/Hashable
-    // conformance if any of the stored properties are mutable.
-    if (memberwiseAccessorsRequireActorIsolation(structDecl))
-      return false;
-
     return true;
   }
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -3909,38 +3909,61 @@ namespace {
         bool preconcurrencyContext =
           result.options.contains(ActorReferenceResult::Flags::Preconcurrency);
 
-          if (ctx.LangOpts.hasFeature(Feature::GroupActorErrors)) {
-            IsolationError mismatch = IsolationError(loc, Diagnostic(diag::actor_isolated_non_self_reference,
-                                                                        decl,
-                                                                        useKind,
-                                                                        refKind + 1, refGlobalActor,
-                                                                        result.isolation));
-
-            auto iter = refErrors.find(std::make_pair(refKind,result.isolation));
-            if (iter != refErrors.end()){
-              iter->second.push_back(mismatch);
-            } else {
-              DiagnosticList list;
-              list.push_back(mismatch);
-              auto keyPair = std::make_pair(refKind,result.isolation);
-              refErrors.insert(std::make_pair(keyPair, list));
+        Type derivedConformanceType;
+        DeclName requirementName;
+        if (loc.isInvalid()) {
+          auto *decl = getDeclContext()->getAsDecl();
+          if (decl && decl->isImplicit()) {
+            auto *parentDC = decl->getDeclContext();
+            loc = parentDC->getAsDecl()->getLoc();
+
+            if (auto *implements = decl->getAttrs().getAttribute<ImplementsAttr>()) {
+              derivedConformanceType =
+                  implements->getProtocol(parentDC)->getDeclaredInterfaceType();
+              requirementName = implements->getMemberName();
             }
+          }
+        }
+
+        if (ctx.LangOpts.hasFeature(Feature::GroupActorErrors)) {
+          IsolationError mismatch = IsolationError(loc,
+              Diagnostic(diag::actor_isolated_non_self_reference,
+                  decl, useKind, refKind + 1, refGlobalActor,
+                  result.isolation));
+
+          auto iter = refErrors.find(std::make_pair(refKind,result.isolation));
+          if (iter != refErrors.end()) {
+            iter->second.push_back(mismatch);
           } else {
-            ctx.Diags.diagnose(
-                               loc, diag::actor_isolated_non_self_reference,
-                               decl,
-                               useKind,
-                               refKind + 1, refGlobalActor,
-                               result.isolation)
-            .warnUntilSwiftVersionIf(preconcurrencyContext, 6);
-
-            noteIsolatedActorMember(decl, context);
-            if (result.isolation.isGlobalActor()) {
-              missingGlobalActorOnContext(
-                                       const_cast<DeclContext *>(getDeclContext()),
-                                       result.isolation.getGlobalActor(), DiagnosticBehavior::Note);
-            }
+            DiagnosticList list;
+            list.push_back(mismatch);
+            auto keyPair = std::make_pair(refKind,result.isolation);
+            refErrors.insert(std::make_pair(keyPair, list));
           }
+        } else {
+          ctx.Diags.diagnose(
+              loc, diag::actor_isolated_non_self_reference,
+              decl, useKind,
+              refKind + 1, refGlobalActor,
+              result.isolation)
+          .warnUntilSwiftVersionIf(preconcurrencyContext, 6);
+
+          if (derivedConformanceType) {
+            auto *decl = dyn_cast<ValueDecl>(getDeclContext()->getAsDecl());
+            ctx.Diags.diagnose(loc, diag::in_derived_witness,
+                               decl->getDescriptiveKind(),
+                               requirementName,
+                               derivedConformanceType);
+          }
+
+          noteIsolatedActorMember(decl, context);
+          if (result.isolation.isGlobalActor()) {
+            missingGlobalActorOnContext(
+                const_cast<DeclContext *>(getDeclContext()),
+                result.isolation.getGlobalActor(), DiagnosticBehavior::Note);
+          }
+        }
+
         return true;
       }
     }

test/Concurrency/derived_conformances_nonisolated.swift

@@ -1,6 +1,4 @@
 // RUN: %target-swift-frontend  -disable-availability-checking -strict-concurrency=complete -parse-as-library %s -emit-sil -o /dev/null -verify
-// RUN: %target-swift-frontend  -disable-availability-checking -strict-concurrency=complete -parse-as-library %s -emit-sil -o /dev/null -verify -strict-concurrency=targeted
-// RUN: %target-swift-frontend  -disable-availability-checking -strict-concurrency=complete -parse-as-library %s -emit-sil -o /dev/null -verify -strict-concurrency=complete
 // RUN: %target-swift-frontend  -disable-availability-checking -strict-concurrency=complete -parse-as-library %s -emit-sil -o /dev/null -verify -strict-concurrency=complete -enable-experimental-feature RegionBasedIsolation
 
 // REQUIRES: concurrency
@@ -12,18 +10,28 @@ struct X1: Equatable, Hashable, Codable {
   let y: String
 }
 
-// expected-error@+5{{type 'X2' does not conform to protocol 'Encodable'}}
-// expected-error@+4{{type 'X2' does not conform to protocol 'Decodable'}}
-// expected-error@+3{{type 'X2' does not conform to protocol 'Equatable'}}
-// expected-error@+2{{type 'X2' does not conform to protocol 'Hashable'}}
+// expected-error@+5 3{{main actor-isolated property 'y' can not be referenced from a non-isolated context}}
+// expected-note@+4{{in static method '==' for derived conformance to 'Equatable'}}
+// expected-error@+3{{main actor-isolated property 'y' can not be referenced from a non-isolated context}}
+// expected-note@+2{{in static method '==' for derived conformance to 'Equatable'}}
 @MainActor
 struct X2: Equatable, Hashable, Codable {
   let x: Int
-  var y: String
+  var y: String // expected-note 4 {{property declared here}}
 }
 
 @MainActor
 enum X3: Hashable, Comparable, Codable {
   case a
   case b(Int)
 }
+
+// expected-warning@+5{{main actor-isolated property 'y' can not be referenced from a non-isolated context}}
+// expected-note@+4{{in static method '==' for derived conformance to 'Equatable'}}
+// expected-warning@+3{{main actor-isolated property 'y' can not be referenced from a non-isolated context}}
+// expected-note@+2{{in static method '==' for derived conformance to 'Equatable'}}
+@preconcurrency @MainActor
+struct X4: Equatable {
+  let x: Int
+  var y: String // expected-note 2 {{property declared here}}
+}