Merge pull request #42041 from DougGregor/derive-nonisolated-witnesses

Author: DougGregor

lib/Sema/CodeSynthesis.cpp

@@ -331,6 +331,7 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
 
   if (ICK == ImplicitConstructorKind::Memberwise) {
     ctor->setIsMemberwiseInitializer();
+    addNonIsolatedToSynthesized(decl, ctor);
   }
 
   // If we are defining a default initializer for a class that has a superclass,
@@ -1526,3 +1527,12 @@ void swift::addFixedLayoutAttr(NominalTypeDecl *nominal) {
   // Add `@_fixed_layout` to the nominal.
   nominal->getAttrs().add(new (C) FixedLayoutAttr(/*Implicit*/ true));
 }
+
+void swift::addNonIsolatedToSynthesized(
+    NominalTypeDecl *nominal, ValueDecl *value) {
+  if (!getActorIsolation(nominal).isActorIsolated())
+    return;
+
+  ASTContext &ctx = nominal->getASTContext();
+  value->getAttrs().add(new (ctx) NonisolatedAttr(/*isImplicit=*/true));
+}

lib/Sema/CodeSynthesis.h

@@ -77,6 +77,9 @@ bool hasLetStoredPropertyWithInitialValue(NominalTypeDecl *nominal);
 /// Add `@_fixed_layout` attribute to the nominal type, if possible.
 void addFixedLayoutAttr(NominalTypeDecl *nominal);
 
+/// Add 'nonisolated' to the synthesized declaration when needed.
+void addNonIsolatedToSynthesized(NominalTypeDecl *nominal, ValueDecl *value);
+
 } // end namespace swift
 
 #endif

lib/Sema/DerivedConformanceCodable.cpp

@@ -15,6 +15,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "CodeSynthesis.h"
 #include "TypeChecker.h"
 #include "llvm/ADT/STLExtras.h"
 #include "swift/AST/Decl.h"
@@ -1247,6 +1248,8 @@ static FuncDecl *deriveEncodable_encode(DerivedConformance &derived) {
     encodeDecl->getAttrs().add(attr);
   }
 
+  addNonIsolatedToSynthesized(derived.Nominal, encodeDecl);
+
   encodeDecl->copyFormalAccessFrom(derived.Nominal,
                                    /*sourceIsParentContext*/ true);
 
@@ -1866,6 +1869,8 @@ static ValueDecl *deriveDecodable_init(DerivedConformance &derived) {
     initDecl->getAttrs().add(reqAttr);
   }
 
+  addNonIsolatedToSynthesized(derived.Nominal, initDecl);
+
   initDecl->copyFormalAccessFrom(derived.Nominal,
                                  /*sourceIsParentContext*/ true);
 
@@ -2042,6 +2047,12 @@ 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/DerivedConformanceComparable.cpp

@@ -15,6 +15,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "CodeSynthesis.h"
 #include "TypeChecker.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Stmt.h"
@@ -275,6 +276,8 @@ deriveComparable_lt(
     return nullptr;
   }
 
+  addNonIsolatedToSynthesized(derived.Nominal, comparableDecl);
+
   comparableDecl->setBodySynthesizer(bodySynthesizer);
 
   comparableDecl->copyFormalAccessFrom(derived.Nominal, /*sourceIsParentContext*/ true);

lib/Sema/DerivedConformanceEquatableHashable.cpp

@@ -15,6 +15,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "CodeSynthesis.h"
 #include "TypeChecker.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Stmt.h"
@@ -45,9 +46,16 @@ static bool canDeriveConformance(DeclContext *DC,
   if (auto structDecl = dyn_cast<StructDecl>(target)) {
     // All stored properties of the struct must conform to the protocol. If
     // there are no stored properties, we will vaccously return true.
-    return DerivedConformance::storedPropertiesNotConformingToProtocol(
-               DC, structDecl, protocol)
-        .empty();
+    if (!DerivedConformance::storedPropertiesNotConformingToProtocol(
+               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;
   }
 
   return false;
@@ -426,6 +434,8 @@ deriveEquatable_eq(
     return nullptr;
   }
 
+  addNonIsolatedToSynthesized(derived.Nominal, eqDecl);
+
   eqDecl->setBodySynthesizer(bodySynthesizer);
 
   eqDecl->copyFormalAccessFrom(derived.Nominal, /*sourceIsParentContext*/ true);
@@ -544,7 +554,7 @@ deriveHashable_hashInto(
       /*Throws=*/false,
       /*GenericParams=*/nullptr, params, returnType, parentDC);
   hashDecl->setBodySynthesizer(bodySynthesizer);
-
+  addNonIsolatedToSynthesized(derived.Nominal, hashDecl);
   hashDecl->copyFormalAccessFrom(derived.Nominal,
                                  /*sourceIsParentContext=*/true);
 
@@ -881,6 +891,7 @@ static ValueDecl *deriveHashable_hashValue(DerivedConformance &derived) {
                     SourceLoc(), C.Id_hashValue, parentDC);
   hashValueDecl->setInterfaceType(intType);
   hashValueDecl->setSynthesized();
+  addNonIsolatedToSynthesized(derived.Nominal, hashValueDecl);
 
   ParameterList *params = ParameterList::createEmpty(C);
 
@@ -896,7 +907,6 @@ static ValueDecl *deriveHashable_hashValue(DerivedConformance &derived) {
   getterDecl->setBodySynthesizer(&deriveBodyHashable_hashValue);
   getterDecl->setSynthesized();
   getterDecl->setIsTransparent(false);
-
   getterDecl->copyFormalAccessFrom(derived.Nominal,
                                    /*sourceIsParentContext*/ true);
 

lib/Sema/DerivedConformanceError.cpp

@@ -15,6 +15,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "CodeSynthesis.h"
 #include "TypeChecker.h"
 #include "DerivedConformances.h"
 #include "swift/AST/Decl.h"
@@ -100,6 +101,7 @@ deriveBridgedNSError_enum_nsErrorDomain(
       DerivedConformance::SynthesizedIntroducer::Var,
       derived.Context.Id_nsErrorDomain, stringTy, stringTy, /*isStatic=*/true,
       /*isFinal=*/true);
+  addNonIsolatedToSynthesized(derived.Nominal, propDecl);
 
   // Define the getter.
   auto getterDecl = derived.addGetterToReadOnlyDerivedProperty(

lib/Sema/DerivedConformanceRawRepresentable.cpp

@@ -15,6 +15,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "CodeSynthesis.h"
 #include "TypeChecker.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Stmt.h"
@@ -168,6 +169,7 @@ static VarDecl *deriveRawRepresentable_raw(DerivedConformance &derived) {
       DerivedConformance::SynthesizedIntroducer::Var, C.Id_rawValue,
       rawInterfaceType, rawType, /*isStatic=*/false,
       /*isFinal=*/false);
+  addNonIsolatedToSynthesized(enumDecl, propDecl);
 
   // Define the getter.
   auto getterDecl = DerivedConformance::addGetterToReadOnlyDerivedProperty(
@@ -432,7 +434,7 @@ deriveRawRepresentable_init(DerivedConformance &derived) {
 
   initDecl->setImplicit();
   initDecl->setBodySynthesizer(&deriveBodyRawRepresentable_init);
-
+  addNonIsolatedToSynthesized(enumDecl, initDecl);
   initDecl->copyFormalAccessFrom(enumDecl, /*sourceIsParentContext*/true);
 
   // If the containing module is not resilient, make sure clients can construct

lib/Sema/DerivedConformances.cpp

@@ -502,7 +502,6 @@ DerivedConformance::declareDerivedPropertyGetter(VarDecl *property,
     property->getInterfaceType(), parentDC);
   getterDecl->setImplicit();
   getterDecl->setIsTransparent(false);
-
   getterDecl->copyFormalAccessFrom(property);
 
 
@@ -887,3 +886,18 @@ VarDecl *DerivedConformance::indexedVarDecl(char prefixChar, int index, Type typ
   varDecl->setInterfaceType(type);
   return varDecl;
 }
+
+bool swift::memberwiseAccessorsRequireActorIsolation(NominalTypeDecl *nominal) {
+  if (!getActorIsolation(nominal).isActorIsolated())
+    return false;
+
+  for (auto property : nominal->getStoredProperties()) {
+    if (!property->isUserAccessible())
+      continue;
+
+    if (!property->isLet())
+      return true;
+  }
+
+  return false;
+}

lib/Sema/DerivedConformances.h

@@ -442,6 +442,12 @@ class DerivedConformance {
   static VarDecl *indexedVarDecl(char prefixChar, int index, Type type,
                                  DeclContext *varContext);
 };
+
+/// Determine whether any "memberwise" accessors, which walk through the
+/// stored properties of the given nominal type, require actor isolation
+/// because they involve mutable state.
+bool memberwiseAccessorsRequireActorIsolation(NominalTypeDecl *nominal);
+
 } // namespace swift
 
 #endif

lib/Sema/TypeCheckConcurrency.cpp

@@ -3554,11 +3554,11 @@ static Optional<MemberIsolationPropagation> getMemberIsolationPropagation(
   case DeclKind::Param:
   case DeclKind::Module:
   case DeclKind::Destructor:
+  case DeclKind::EnumCase:
+  case DeclKind::EnumElement:
     return None;
 
   case DeclKind::PatternBinding:
-  case DeclKind::EnumCase:
-  case DeclKind::EnumElement:
     return MemberIsolationPropagation::GlobalActor;
 
   case DeclKind::Constructor:

test/Concurrency/derived_conformances_nonisolated.swift

@@ -0,0 +1,24 @@
+// RUN: %target-typecheck-verify-swift  -disable-availability-checking -warn-concurrency -parse-as-library
+// REQUIRES: concurrency
+
+@MainActor
+struct X1: Equatable, Hashable, Codable {
+  let x: Int
+  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'}}
+@MainActor
+struct X2: Equatable, Hashable, Codable {
+  let x: Int
+  var y: String
+}
+
+@MainActor
+enum X3: Hashable, Comparable, Codable {
+  case a
+  case b(Int)
+}