Grammatical corrections for compound modifiers

Author: DePasqualeOrg

CHANGELOG.md

@@ -276,7 +276,7 @@ And the module structure to support such applications looks like this:
 
 * [SE-0430][]:
 
-  Region Based Isolation is now extended to enable the application of an
+  Region-Based Isolation is now extended to enable the application of an
   explicit `sending` annotation to function parameters and results. A function
   parameter or result that is annotated with `sending` is required to be
   disconnected at the function boundary and thus possesses the capability of
@@ -314,7 +314,7 @@ And the module structure to support such applications looks like this:
 
   func useValue() {
     let x = NonSendableType()
-    let a = await MyActor(x) // Error without Region Based Isolation!
+    let a = await MyActor(x) // Error without Region-Based Isolation!
   }
   ```
 

docs/SIL.rst

@@ -699,7 +699,7 @@ autorelease in the callee.
   - A generic type that conforms to Actor or AnyActor.
 
   and must be the actor instance that a function is isolated to. Importantly
-  this means that global actor isolated nominal types are never
+  this means that global-actor-isolated nominal types are never
   ``@sil_isolated``. Only one parameter can ever be marked as ``@sil_isolated``
   since a function cannot be isolated to multiple actors at the same time.
 

include/swift/AST/DiagnosticsSIL.def

@@ -935,10 +935,10 @@ NOTE(sil_referencebinding_inout_binding_here, none,
       ())
 
 //===----------------------------------------------------------------------===//
-//                  MARK: Region Based Isolation Diagnostics
+//                  MARK: Region-Based Isolation Diagnostics
 //===----------------------------------------------------------------------===//
 
-// READ THIS: Please when adding diagnostics for region based isolation, keep
+// READ THIS: Please when adding diagnostics for region-based isolation, keep
 // them ordered in sections depending on which emitter uses it. It makes it
 // easier for people unfamiliar with the code to quickly see which diagnostics
 // are used by which of the SendNonSendable emitters use.
@@ -947,7 +947,7 @@ NOTE(sil_referencebinding_inout_binding_here, none,
 // Misc
 
 ERROR(regionbasedisolation_unknown_pattern, none,
-      "pattern that the region based isolation checker does not understand how to check. Please file a bug",
+      "pattern that the region-based isolation checker does not understand how to check. Please file a bug",
       ())
 NOTE(regionbasedisolation_maybe_race, none,
      "access can happen concurrently", ())
@@ -1059,13 +1059,13 @@ NOTE(regionbasedisolation_typed_transferneversendable_via_arg_callee, none,
 // Error that is only used when the send non sendable emitter cannot discover any
 // information to give a better diagnostic.
 ERROR(regionbasedisolation_task_or_actor_isolated_transferred, none,
-      "task or actor isolated value cannot be sent", ())
+      "task or actor-isolated value cannot be sent", ())
 
 //===
 // InOut Sending Emitter
 
 NOTE(regionbasedisolation_inout_sending_must_be_reinitialized, none,
-     "'inout sending' parameter must be reinitialized before function exit with a non-actor isolated value",
+     "'inout sending' parameter must be reinitialized before function exit with a non-actor-isolated value",
      ())
 ERROR(regionbasedisolation_inout_sending_cannot_be_actor_isolated, none,
       "'inout sending' parameter %0 cannot be %1at end of function",

include/swift/AST/DiagnosticsSema.def

@@ -5609,7 +5609,7 @@ ERROR(actor_isolated_witness,none,
      "requirement",
      (bool, ActorIsolation, const ValueDecl *, ActorIsolation))
 ERROR(actor_cannot_conform_to_global_actor_protocol,none,
-      "actor %0 cannot conform to global actor isolated protocol %1",
+      "actor %0 cannot conform to global-actor-isolated protocol %1",
       (Type, Type))
 NOTE(protocol_isolated_to_global_actor_here,none,
      "%0 is isolated to global actor %1 here", (Type, Type))

include/swift/Option/FrontendOptions.td

@@ -1395,7 +1395,7 @@ def disable_experimental_parser_round_trip : Flag<["-"],
 
 def disable_sending_args_and_results_with_region_isolation : Flag<["-"],
   "disable-sending-args-and-results-with-region-based-isolation">,
-  HelpText<"Disable sending args and results when region based isolation is enabled. Only enabled with asserts">,
+  HelpText<"Disable sending args and results when region-based isolation is enabled. Only enabled with asserts">,
   Flags<[HelpHidden]>;
 
 def scanner_module_validation: Flag<["-"], "scanner-module-validation">,

include/swift/SILOptimizer/Analysis/RegionAnalysis.h

@@ -303,15 +303,15 @@ class RegionAnalysisValueMap {
   RegionAnalysisValueMap(SILFunction *fn) : fn(fn) { }
 
   /// Returns the value for this instruction if it isn't a fake "represenative
-  /// value" to inject actor isolatedness. Asserts in such a case.
+  /// value" to inject actor isolation. Asserts in such a case.
   SILValue getRepresentative(Element trackableValueID) const;
 
   /// Returns the value for this instruction. If it is a fake "representative
   /// value" returns an empty SILValue.
   SILValue maybeGetRepresentative(Element trackableValueID) const;
 
   /// Returns the value for this instruction if it isn't a fake "represenative
-  /// value" to inject actor isolatedness. Asserts in such a case.
+  /// value" to inject actor isolation. Asserts in such a case.
   RepresentativeValue getRepresentativeValue(Element trackableValueID) const;
 
   /// Returns the fake "representative value" for this element if it

include/swift/SILOptimizer/PassManager/Passes.def

@@ -278,7 +278,7 @@ PASS(IVInfoPrinter, "iv-info-printer",
 PASS(LowerHopToActor, "lower-hop-to-actor",
      "Lower hop_to_executor instructions with actor operands")
 PASS(OptimizeHopToExecutor, "optimize-hop-to-executor",
-     "Optimize hop_to_executor instructions for actor isolated code")
+     "Optimize hop_to_executor instructions for actor-isolated code")
 PASS(InstCount, "inst-count",
      "Record SIL Instruction, Block, and Function Counts as LLVM Statistics")
 PASS(JumpThreadSimplifyCFG, "jumpthread-simplify-cfg",

include/swift/SILOptimizer/Utils/PartitionUtils.h

@@ -92,7 +92,7 @@ class TransferringOperandToStateMap;
 /// The representative value of the equivalence class that makes up a tracked
 /// value.
 ///
-/// We use a wrapper struct here so that we can inject "fake" actor isolated
+/// We use a wrapper struct here so that we can inject "fake" actor-isolated
 /// values into the regions of values that become merged into an actor by
 /// calling a function without a non-sendable result.
 class RepresentativeValue {
@@ -102,8 +102,8 @@ class RepresentativeValue {
 
   /// If this is set to a SILValue then it is the actual represented value. If
   /// it is set to a SILInstruction, then this is a "fake" representative value
-  /// used to inject actor isolatedness. The instruction stored is the
-  /// instruction that introduced the actor isolated-ness.
+  /// used to inject actor isolation. The instruction stored is the
+  /// instruction that introduced the actor isolation.
   InnerType value;
 
 public:

include/swift/SILOptimizer/Utils/SILIsolationInfo.h

@@ -445,7 +445,7 @@ class SILIsolationInfo {
   /// for the isolated values if any to not match.
   ///
   /// This is useful if one has two non-Sendable values projected from the same
-  /// actor or global actor isolated value. E.x.: two different ref_element_addr
+  /// actor or global-actor-isolated value. E.x.: two different ref_element_addr
   /// from the same actor.
   bool hasSameIsolation(const SILIsolationInfo &other) const;
 

lib/AST/Decl.cpp

@@ -11373,7 +11373,7 @@ ActorIsolation::forActorInstanceParameter(Expr *actor,
     return ActorIsolation::forNonisolated(/*unsafe*/false);
 
   // An isolated value of `<global actor type>.shared` is statically
-  // global actor isolated.
+  // global-actor-isolated.
   if (auto *memberRef = dyn_cast<MemberRefExpr>(actor)) {
     // Check that the member declaration witnesses the `shared`
     // requirement of the `GlobalActor` protocol.

lib/DriverTool/sil_opt_main.cpp

@@ -788,7 +788,7 @@ int sil_opt_main(ArrayRef<const char *> argv, void *MainAddr) {
   }
 
   // If we have strict concurrency set as a feature and were told to turn off
-  // region based isolation... do so now.
+  // region-based isolation... do so now.
   if (Invocation.getLangOptions().hasFeature(Feature::StrictConcurrency)) {
     Invocation.getLangOptions().enableFeature(Feature::RegionBasedIsolation);
   }

lib/SILGen/SILGenApply.cpp

@@ -62,7 +62,7 @@ FunctionTypeInfo SILGenFunction::getClosureTypeInfo(AbstractClosureExpr *expr) {
   auto fnType = cast<AnyFunctionType>(expr->getType()->getCanonicalType());
 
   // If we have a closure expr that has inherits actor context, work around AST
-  // issues that causes us to be able to get non-Sendable actor isolated
+  // issues that causes us to be able to get non-Sendable actor-isolated
   // closures.
   if (auto *ce = dyn_cast<ClosureExpr>(expr)) {
     if (ce->inheritsActorContext() && fnType->isAsync() &&

lib/SILGen/SILGenConcurrency.cpp

@@ -85,7 +85,7 @@ void SILGenFunction::emitExpectedExecutor() {
       !F.isDefer();
 
   // FIXME: Avoid loading and checking the expected executor if concurrency is
-  // unavailable. This is specifically relevant for MainActor isolated contexts,
+  // unavailable. This is specifically relevant for MainActor-isolated contexts,
   // which are allowed to be available on OSes where concurrency is not
   // available. rdar://106827064
 

lib/SILGen/SILGenConstructor.cpp

@@ -581,7 +581,7 @@ static void emitImplicitValueConstructor(SILGenFunction &SGF,
 // FIXME: the callers of ctorHopsInjectedByDefiniteInit is not correct (rdar://87485045)
 // we must still set the SGF.ExpectedExecutor field to say that we must
 // hop to the executor after every apply in the constructor. This seems to
-// happen for the main actor isolated async inits, but not for the plain ones,
+// happen for the MainActor-isolated async inits, but not for the plain ones,
 // where 'self' is not going to directly be the instance. We have to extend the
 // ExecutorBreadcrumb class to detect whether it needs to do a load or not
 // in it's emit method.

lib/SILGen/SILGenFunction.h

@@ -730,7 +730,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   FunctionTypeInfo getFunctionTypeInfo(CanAnyFunctionType fnType);
 
   /// A helper method that calls getFunctionTypeInfo that also marks global
-  /// actor isolated async closures that are not sendable as sendable.
+  /// actor-isolated async closures that are not sendable as sendable.
   FunctionTypeInfo getClosureTypeInfo(AbstractClosureExpr *expr);
 
   bool isEmittingTopLevelCode() { return IsEmittingTopLevelCode; }

lib/SILOptimizer/Analysis/RegionAnalysis.cpp

@@ -1219,7 +1219,7 @@ struct PartitionOpBuilder {
                            lookupValueID(srcOperand->get()), srcOperand));
   }
 
-  /// Mark \p value artifically as being part of an actor isolated region by
+  /// Mark \p value artifically as being part of an actor-isolated region by
   /// introducing a new fake actor introducing representative and merging them.
   void addActorIntroducingInst(SILValue sourceValue, Operand *sourceOperand,
                                SILIsolationInfo actorIsolation) {
@@ -1271,7 +1271,7 @@ struct PartitionOpBuilder {
 namespace {
 
 enum class TranslationSemantics {
-  /// An instruction that does not affect region based state or if it does we
+  /// An instruction that does not affect region-based state or if it does we
   /// would like to error on some other use. An example would be something
   /// like end_borrow, inject_enum_addr, or alloc_global. We do not produce
   /// any partition op.
@@ -1908,7 +1908,7 @@ class PartitionOpTranslator {
   void translateSILPartialApply(PartialApplyInst *pai) {
     // First check if our partial apply is Sendable and not global actor
     // isolated. In such a case, we will have emitted an earlier warning in Sema
-    // and can return early. If we have a global actor isolated partial_apply,
+    // and can return early. If we have a global-actor-isolated partial_apply,
     // we can be looser and can use region isolation since we know that the
     // Sendable closure will be executed serially due to the closure having to
     // run on the global actor queue meaning that we do not have to worry about

lib/SILOptimizer/Mandatory/TransferNonSendable.cpp

@@ -502,7 +502,7 @@ struct InOutSendingNotDisconnectedInfo {
   /// The 'inout sending' param that we are emitting an error for.
   SILValue inoutSendingParam;
 
-  /// The dynamic actor isolated region info of our 'inout sending' value's
+  /// The dynamic actor-isolated region info of our 'inout sending' value's
   /// region at the terminator inst.
   SILDynamicMergedIsolationInfo actorIsolatedRegionInfo;
 
@@ -1099,7 +1099,7 @@ struct UseAfterTransferDiagnosticInferrer::AutoClosureWalker : ASTWalker {
           continue;
         }
 
-        // Otherwise, we are calling an actor isolated function in the async
+        // Otherwise, we are calling an actor-isolated function in the async
         // let. Emit a better error.
 
         // See if we can find a valueDecl/name for our callee so we can
@@ -2523,7 +2523,7 @@ struct DiagnosticEvaluator final
       // Otherwise, just use the actual value.
       //
       // TODO: We are eventually going to want to be able to say that it is b/c
-      // of the actor isolated parameter. Maybe we should put in the actual
+      // of the actor-isolated parameter. Maybe we should put in the actual
       // region isolation info here.
       self->transferredNonTransferrable.emplace_back(
           partitionOp.getSourceOp(),

lib/SILOptimizer/Utils/RegionIsolation.cpp

@@ -26,7 +26,7 @@ LoggingFlag swift::regionisolation::ENABLE_LOGGING;
 static llvm::cl::opt<LoggingFlag, true> // The parser
     RegionBasedIsolationLog(
         "sil-regionbasedisolation-log",
-        llvm::cl::desc("Enable logging for SIL region based isolation "
+        llvm::cl::desc("Enable logging for SIL region-based isolation "
                        "diagnostics"),
         llvm::cl::Hidden,
         llvm::cl::values(

lib/SILOptimizer/Utils/SILIsolationInfo.cpp

@@ -535,8 +535,8 @@ SILIsolationInfo SILIsolationInfo::get(SILInstruction *inst) {
 
     // Then check if we have something that is nonisolated unsafe.
     if (isolation.isNonisolatedUnsafe()) {
-      // First check if our function_ref is a method of a global actor isolated
-      // type. In such a case, we create a global actor isolated
+      // First check if our function_ref is a method of a global-actor-isolated
+      // type. In such a case, we create a global-actor-isolated
       // nonisolated(unsafe) so that if we assign the value to another variable,
       // the variable still says that it is the appropriate global actor
       // isolated thing.
@@ -667,7 +667,7 @@ SILIsolationInfo SILIsolationInfo::get(SILInstruction *inst) {
     }
   }
 
-  // See if we have a struct_extract from a global actor isolated type.
+  // See if we have a struct_extract from a global-actor-isolated type.
   if (auto *sei = dyn_cast<StructExtractInst>(inst)) {
     auto varIsolation = swift::getActorIsolation(sei->getField());
     if (auto isolation =
@@ -688,12 +688,12 @@ SILIsolationInfo SILIsolationInfo::get(SILInstruction *inst) {
         varIsolation.isNonisolatedUnsafe());
   }
 
-  // See if we have an unchecked_enum_data from a global actor isolated type.
+  // See if we have an unchecked_enum_data from a global-actor-isolated type.
   if (auto *uedi = dyn_cast<UncheckedEnumDataInst>(inst)) {
     return SILIsolationInfo::getGlobalActorIsolated(uedi, uedi->getEnumDecl());
   }
 
-  // See if we have an unchecked_enum_data from a global actor isolated type.
+  // See if we have an unchecked_enum_data from a global-actor-isolated type.
   if (auto *utedi = dyn_cast<UncheckedTakeEnumDataAddrInst>(inst)) {
     return SILIsolationInfo::getGlobalActorIsolated(utedi,
                                                     utedi->getEnumDecl());
@@ -713,7 +713,7 @@ SILIsolationInfo SILIsolationInfo::get(SILInstruction *inst) {
     }
   }
 
-  // See if we have a convert function from a Sendable actor isolated function,
+  // See if we have a convert function from a Sendable actor-isolated function,
   // we want to treat the result of the convert function as being actor isolated
   // so that we cannot escape the value.
   //
@@ -818,7 +818,7 @@ SILIsolationInfo SILIsolationInfo::get(SILArgument *arg) {
   if (!SILIsolationInfo::isNonSendableType(arg->getType(), arg->getFunction()))
     return {};
 
-  // Handle a switch_enum from a global actor isolated type.
+  // Handle a switch_enum from a global-actor-isolated type.
   if (auto *phiArg = dyn_cast<SILPhiArgument>(arg)) {
     if (auto *singleTerm = phiArg->getSingleTerminator()) {
       if (auto *swi = dyn_cast<SwitchEnumInst>(singleTerm)) {
@@ -866,7 +866,7 @@ SILIsolationInfo SILIsolationInfo::get(SILArgument *arg) {
     // disconnected so we can construct the actor value. Users cannot write
     // allocator functions so we just need to worry about compiler generated
     // code. In the case of a non-actor, we can only have an allocator that is
-    // global actor isolated, so we will never hit this code path.
+    // global-actor-isolated, so we will never hit this code path.
     if (declRef.kind == SILDeclRef::Kind::Allocator) {
       if (fArg->getFunction()->getActorIsolation().isActorInstanceIsolated()) {
         return SILIsolationInfo::getDisconnected(false /*nonisolated(unsafe)*/);
@@ -1018,7 +1018,7 @@ bool SILIsolationInfo::hasSameIsolation(const SILIsolationInfo &other) const {
     // If either have an actor instance, and the actor instance doesn't match,
     // return false.
     //
-    // This ensures that cases like comparing two global actor isolated things
+    // This ensures that cases like comparing two global-actor-isolated things
     // do not hit this path.
     //
     // It also catches cases where we have a missing actor instance.

lib/Sema/ConstraintSystem.cpp

@@ -7572,7 +7572,7 @@ ConstraintSystem::inferKeyPathLiteralCapability(KeyPathExpr *keyPath) {
       case ActorIsolation::Erased:
         llvm_unreachable("storage cannot have opaque isolation");
 
-      // A reference to an actor isolated state make key path non-Sendable.
+      // A reference to an actor-isolated state make key path non-Sendable.
       case ActorIsolation::ActorInstance:
       case ActorIsolation::GlobalActor:
         isSendable = false;