Track 'release/5.5' to resolve merge conflict.

Author: amartini51

lib/IDE/Refactoring.cpp

@@ -622,6 +622,11 @@ PropertyWrapperBackingPropertyTypeRequest::evaluate(
   if (!type)
     return Type();
 
+  // If the declaration came from a module file, there's no need to
+  // compute the auxiliary variables.
+  if (!var->getDeclContext()->getParentSourceFile())
+    return type;
+
   // Set the interface type of each synthesized declaration.
   auto auxiliaryVars = var->getPropertyWrapperAuxiliaryVariables();
   auxiliaryVars.backingVar->setInterfaceType(type);

lib/Sema/TypeCheckPropertyWrapper.cpp

@@ -14,6 +14,9 @@ import Swift
 @_implementationOnly import _SwiftConcurrencyShims
 
 /// A unit of scheduleable work.
+///
+/// Unless you're implementing a scheduler,
+/// you don't generally interact with partial tasks directly.
 @available(SwiftStdlib 5.5, *)
 @frozen
 public struct PartialAsyncTask {

stdlib/public/Concurrency/PartialAsyncTask.swift

@@ -15,18 +15,18 @@ import Swift
 
 // ==== Task Cancellation ------------------------------------------------------
 
-/// Execute an operation with cancellation handler which will immediately be
-/// invoked if the current task is cancelled.
+/// Execute an operation with a cancellation handler that's immediately
+/// invoked if the current task is canceled.
 ///
 /// This differs from the operation cooperatively checking for cancellation
 /// and reacting to it in that the cancellation handler is _always_ and
-/// _immediately_ invoked when the task is cancelled. For example, even if the
-/// operation is running code which never checks for cancellation, a cancellation
-/// handler still would run and give us a chance to run some cleanup code.
+/// _immediately_ invoked when the task is canceled. For example, even if the
+/// operation is running code that never checks for cancellation, a cancellation
+/// handler still runs and provides a chance to run some cleanup code.
 ///
-/// Does not check for cancellation, and always executes the passed `operation`.
+/// Doesn't check for cancellation, and always executes the passed `operation`.
 ///
-/// This function returns instantly and will never suspend.
+/// This function returns immediately and never suspends.
 @available(SwiftStdlib 5.5, *)
 public func withTaskCancellationHandler<T>(
   handler: @Sendable () -> (),
@@ -49,10 +49,10 @@ public func withTaskCancellationHandler<T>(
 @available(SwiftStdlib 5.5, *)
 extension Task {
 
-  /// Returns `true` if the task is cancelled, and should stop executing.
+  /// A Boolean value that indicates whether
+  /// the current task should stop executing.
   ///
-  /// If no current `Task` is available, returns `false`, as outside of a task
-  /// context no task cancellation may be observed.
+  /// If there is no current task, the value of this property is `false`.
   ///
   /// - SeeAlso: `checkCancellation()`
   public static var isCancelled: Bool {
@@ -61,26 +61,17 @@ extension Task {
      }
   }
 
-  /// Returns `true` if the task is cancelled, and should stop executing.
+  /// A Boolean value that indicates whether the task should stop executing.
   ///
   /// - SeeAlso: `checkCancellation()`
   @available(*, deprecated, message: "Storing `Task` instances has been deprecated and will be removed soon. Use the static 'Task.isCancelled' instead.")
   public var isCancelled: Bool {
     _taskIsCancelled(_task)
   }
 
-  /// Check if the task is cancelled and throw an `CancellationError` if it was.
+  /// Throws a cancellation error if the current task was canceled.
   ///
-  /// It is intentional that no information is passed to the task about why it
-  /// was cancelled. A task may be cancelled for many reasons, and additional
-  /// reasons may accrue / after the initial cancellation (for example, if the
-  /// task fails to immediately exit, it may pass a deadline).
-  ///
-  /// The goal of cancellation is to allow tasks to be cancelled in a
-  /// lightweight way, not to be a secondary method of inter-task communication.
-  ///
-  /// ### Suspension
-  /// This function returns instantly and will never suspend.
+  /// The error is always an instance of `Task.CancellationError`.
   ///
   /// - SeeAlso: `isCancelled()`
   public static func checkCancellation() throws {
@@ -97,10 +88,12 @@ extension Task {
     try await withTaskCancellationHandler(handler: handler, operation: operation)
   }
 
-  /// The default cancellation thrown when a task is cancelled.
+  /// The default error thrown by a canceled task.
   ///
-  /// This error is also thrown automatically by `Task.checkCancellation()`,
-  /// if the current task has been cancelled.
+  /// The `Task.checkCancellation()` method throws this error
+  /// if the current task has been canceled.
+  /// You can throw this error in your cancellation-checking code,
+  /// or another more specific error if needed.
   public struct CancellationError: Error {
     // no extra information, cancellation is intended to be light-weight
     public init() {}