[AST] NFC: Add a convenient way to create implicit NonisolatedAttrs

Author: xedin

include/swift/AST/Attr.h

@@ -2978,14 +2978,9 @@ class NonisolatedAttr final : public DeclAttribute {
                   NonIsolatedModifier modifier, bool implicit)
       : DeclAttribute(DeclAttrKind::Nonisolated, atLoc, range, implicit) {
     Bits.NonisolatedAttr.Modifier = static_cast<unsigned>(modifier);
+    assert((getModifier() == modifier) && "not enough bits for modifier");
   }
 
-  NonisolatedAttr(bool unsafe, bool implicit)
-      : NonisolatedAttr({}, {},
-                        unsafe ? NonIsolatedModifier::Unsafe
-                               : NonIsolatedModifier::None,
-                        implicit) {}
-
   NonIsolatedModifier getModifier() const {
     return static_cast<NonIsolatedModifier>(Bits.NonisolatedAttr.Modifier);
   }
@@ -2995,6 +2990,13 @@ class NonisolatedAttr final : public DeclAttribute {
     return getModifier() == NonIsolatedModifier::NonSending;
   }
 
+  static NonisolatedAttr *
+  createImplicit(ASTContext &ctx,
+                 NonIsolatedModifier modifier = NonIsolatedModifier::None) {
+    return new (ctx) NonisolatedAttr(/*atLoc*/ {}, /*range*/ {}, modifier,
+                                     /*implicit=*/true);
+  }
+
   static bool classof(const DeclAttribute *DA) {
     return DA->getKind() == DeclAttrKind::Nonisolated;
   }

lib/ClangImporter/ImportDecl.cpp

@@ -8810,8 +8810,7 @@ ClangImporter::Implementation::importSwiftAttrAttributes(Decl *MappedDecl) {
       // Hard-code @actorIndependent, until Objective-C clients start
       // using nonisolated.
       if (swiftAttr->getAttribute() == "@actorIndependent") {
-        auto attr = new (SwiftContext)
-            NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true);
+        auto attr = NonisolatedAttr::createImplicit(SwiftContext);
         MappedDecl->getAttrs().add(attr);
         continue;
       }
@@ -8944,8 +8943,8 @@ ClangImporter::Implementation::importSwiftAttrAttributes(Decl *MappedDecl) {
       auto *mappedVar = cast<VarDecl>(MappedDecl);
       if (mappedVar->isStatic() && mappedVar->isLet() &&
           isNSNotificationName(cast<clang::ValueDecl>(ClangDecl)->getType())) {
-        MappedDecl->getAttrs().add(new (SwiftContext) NonisolatedAttr(
-            /*unsafe=*/false, /*implicit=*/true));
+        MappedDecl->getAttrs().add(
+            NonisolatedAttr::createImplicit(SwiftContext));
       }
     }
   }

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -436,9 +436,7 @@ ValueDecl *SwiftDeclSynthesizer::createConstant(Identifier name,
 
   // Mark the function transparent so that we inline it away completely.
   func->getAttrs().add(new (C) TransparentAttr(/*implicit*/ true));
-  auto nonisolatedAttr =
-      new (C) NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true);
-  var->getAttrs().add(nonisolatedAttr);
+  var->getAttrs().add(NonisolatedAttr::createImplicit(C));
 
   // Set the function up as the getter.
   ImporterImpl.makeComputed(var, func, nullptr);

lib/Sema/CSGen.cpp

@@ -4585,8 +4585,8 @@ generateForEachStmtConstraints(ConstraintSystem &cs, DeclContext *dc,
   // non-`Sendable` state across the isolation boundary. `next()` should
   // inherit the isolation of the caller, but for now, use the opt out.
   if (isAsync) {
-    auto *nonisolated = new (ctx)
-        NonisolatedAttr(/*unsafe=*/true, /*implicit=*/true);
+    auto *nonisolated =
+        NonisolatedAttr::createImplicit(ctx, NonIsolatedModifier::Unsafe);
     makeIteratorVar->getAttrs().add(nonisolated);
   }
 

lib/Sema/CodeSynthesis.cpp

@@ -1738,8 +1738,7 @@ bool swift::addNonIsolatedToSynthesized(NominalTypeDecl *nominal,
     return false;
 
   ASTContext &ctx = nominal->getASTContext();
-  value->getAttrs().add(
-      new (ctx) NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true));
+  value->getAttrs().add(NonisolatedAttr::createImplicit(ctx));
   return true;
 }
 

lib/Sema/CodeSynthesisDistributedActor.cpp

@@ -110,8 +110,7 @@ static VarDecl *addImplicitDistributedActorIDProperty(
       nominal);
 
   // mark as nonisolated, allowing access to it from everywhere
-  propDecl->getAttrs().add(
-      new (C) NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true));
+  propDecl->getAttrs().add(NonisolatedAttr::createImplicit(C));
   // mark as @_compilerInitialized, since we synthesize the initializing
   // assignment during SILGen.
   propDecl->getAttrs().add(
@@ -161,8 +160,7 @@ static VarDecl *addImplicitDistributedActorActorSystemProperty(
       nominal);
 
   // mark as nonisolated, allowing access to it from everywhere
-  propDecl->getAttrs().add(
-      new (C) NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true));
+  propDecl->getAttrs().add(NonisolatedAttr::createImplicit(C));
 
   auto idProperty = nominal->getDistributedActorIDProperty();
   // If the id was not yet synthesized, we need to ensure that eventually
@@ -739,8 +737,7 @@ static FuncDecl *createSameSignatureDistributedThunkDecl(DeclContext *DC,
 
   thunk->setSynthesized(true);
   thunk->setDistributedThunk(true);
-  thunk->getAttrs().add(
-      new (C) NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true));
+  thunk->getAttrs().add(NonisolatedAttr::createImplicit(C));
 
   return thunk;
 }

lib/Sema/DerivedConformance/DerivedConformanceActor.cpp

@@ -147,8 +147,7 @@ static ValueDecl *deriveActor_unownedExecutor(DerivedConformance &derived) {
   property->getAttrs().add(new (ctx) SemanticsAttr(SEMANTICS_DEFAULT_ACTOR,
                                                    SourceLoc(), SourceRange(),
                                                    /*implicit*/ true));
-  property->getAttrs().add(
-      new (ctx) NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true));
+  property->getAttrs().add(NonisolatedAttr::createImplicit(ctx));
 
   // Make the property implicitly final.
   property->getAttrs().add(new (ctx) FinalAttr(/*IsImplicit=*/true));

lib/Sema/DerivedConformance/DerivedConformanceCaseIterable.cpp

@@ -105,8 +105,7 @@ ValueDecl *DerivedConformance::deriveCaseIterable(ValueDecl *requirement) {
       SynthesizedIntroducer::Var, Context.Id_allCases, returnTy,
       /*isStatic=*/true, /*isFinal=*/true);
 
-  propDecl->getAttrs().add(
-              new (C) NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true));
+  propDecl->getAttrs().add(NonisolatedAttr::createImplicit(C));
 
   // Define the getter.
   auto *getterDecl = addGetterToReadOnlyDerivedProperty(propDecl);

lib/Sema/DerivedConformance/DerivedConformanceDistributedActor.cpp

@@ -465,8 +465,7 @@ static ValueDecl *deriveDistributedActor_id(DerivedConformance &derived) {
       /*isStatic=*/false, /*isFinal=*/true);
 
   // mark as nonisolated, allowing access to it from everywhere
-  propDecl->getAttrs().add(
-      new (C) NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true));
+  propDecl->getAttrs().add(NonisolatedAttr::createImplicit(C));
 
   derived.addMemberToConformanceContext(pbDecl, /*insertAtHead=*/true);
   derived.addMemberToConformanceContext(propDecl, /*insertAtHead=*/true);
@@ -496,8 +495,7 @@ static ValueDecl *deriveDistributedActor_actorSystem(
       propertyType, /*isStatic=*/false, /*isFinal=*/true);
 
   // mark as nonisolated, allowing access to it from everywhere
-  propDecl->getAttrs().add(
-      new (C) NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true));
+  propDecl->getAttrs().add(NonisolatedAttr::createImplicit(C));
 
   // IMPORTANT: `id` MUST be the first field of a distributed actor, and
   // `actorSystem` MUST be the second field, because for a remote instance
@@ -795,8 +793,7 @@ static ValueDecl *deriveDistributedActor_unownedExecutor(DerivedConformance &der
   property->getAttrs().add(new (ctx) SemanticsAttr(SEMANTICS_DEFAULT_ACTOR,
                                                    SourceLoc(), SourceRange(),
                                                    /*implicit*/ true));
-  property->getAttrs().add(
-      new (ctx) NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true));
+  property->getAttrs().add(NonisolatedAttr::createImplicit(ctx));
 
   // Make the property implicitly final.
   property->getAttrs().add(new (ctx) FinalAttr(/*IsImplicit=*/true));

lib/Sema/DerivedConformance/DerivedConformanceEquatableHashable.cpp

@@ -555,8 +555,7 @@ deriveHashable_hashInto(
   // The derived hash(into:) for an actor must be non-isolated.
   if (!addNonIsolatedToSynthesized(derived, hashDecl) &&
       derived.Nominal->isActor())
-    hashDecl->getAttrs().add(
-        new (C) NonisolatedAttr(/*unsafe*/ false, /*implicit*/ true));
+    hashDecl->getAttrs().add(NonisolatedAttr::createImplicit(C));
 
   derived.addMembersToConformanceContext({hashDecl});
 
@@ -912,8 +911,7 @@ static ValueDecl *deriveHashable_hashValue(DerivedConformance &derived) {
   // The derived hashValue of an actor must be nonisolated.
   if (!addNonIsolatedToSynthesized(derived, hashValueDecl) &&
       derived.Nominal->isActor())
-    hashValueDecl->getAttrs().add(
-        new (C) NonisolatedAttr(/*unsafe*/ false, /*implicit*/ true));
+    hashValueDecl->getAttrs().add(NonisolatedAttr::createImplicit(C));
 
   Pattern *hashValuePat =
       NamedPattern::createImplicit(C, hashValueDecl, intType);

lib/Sema/TypeCheckConcurrency.cpp

@@ -5691,8 +5691,10 @@ static void addAttributesForActorIsolation(ValueDecl *value,
     break;
   case ActorIsolation::Nonisolated:
   case ActorIsolation::NonisolatedUnsafe: {
-    value->getAttrs().add(new (ctx) NonisolatedAttr(
-        isolation == ActorIsolation::NonisolatedUnsafe, /*implicit=*/true));
+    value->getAttrs().add(NonisolatedAttr::createImplicit(
+        ctx, isolation == ActorIsolation::NonisolatedUnsafe
+                 ? NonIsolatedModifier::Unsafe
+                 : NonIsolatedModifier::None));
     break;
   }
   case ActorIsolation::GlobalActor: {