[cherry-pick] [5.8] Build lsan with -gline-tables-only

.github/CODEOWNERS

@@ -1,44 +1,2 @@
-# Lines starting with '#' are comments.
-# Each line is a file pattern followed by one or more owners.
-# Order is important. The last matching pattern has the most precedence.
-
-# Owners of ASTGen
-lib/ASTGen @zoecarver @CodaFi
-
-# Dependency scanning
-include/swift/DependencyScan                 @artemcm
-lib/AST/ModuleLoader.cpp                     @artemcm
-lib/DependencyScan                           @artemcm
-lib/Frontend/ModuleInterfaceLoader.cpp       @artemcm
-lib/Serialization/SerializedModuleLoader.cpp @artemcm
-test/ScanDependencies                        @artemcm
-
-# Driver
-include/swift/Driver @artemcm
-lib/Driver           @artemcm
-test/Driver          @artemcm
-
-# Owners of the parser
-include/swift/Parse @ahoppen @bnbarham @CodaFi @DougGregor @rintaro
-lib/Parse           @ahoppen @bnbarham @CodaFi @DougGregor @rintaro
-test/Parse          @ahoppen @bnbarham @CodaFi @DougGregor @rintaro
-
-SwiftCompilerSources @eeckstein
-
-# C++ Interop
-include/swift/ClangImporter @zoecarver @hyp @egorzhdan
-include/swift/PrintAsClang  @zoecarver @hyp @egorzhdan
-lib/ClangImporter           @zoecarver @hyp @egorzhdan
-lib/PrintAsClang            @zoecarver @hyp @egorzhdan
-stdlib/public/Cxx           @zoecarver @hyp @egorzhdan
-test/Interop                @zoecarver @hyp @egorzhdan
-
-# Threading implementation
-include/swift/Threading @al45tair
-lib/Threading           @al45tair
-
-# Windows support
-cmake/**/*Windows*    @compnerd
-lib/Basic/Windows     @compnerd
-stdlib/public/Windows @compnerd
-utils/*windows*       @compnerd
+# For the release branch @apple/swift5-branch-managers needs to approve the changes
+* @apple/swift5-branch-managers

CHANGELOG.md

@@ -4,6 +4,33 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 
 ## Swift 5.8
 
+* [SE-0376][]:
+
+  The `@backDeployed(before:)` attribute may now be used to extend the availability of a function to OS releases prior to the introduction of that function as ABI.
+
+  For example, suppose that `struct Temperature` was introduced in a macOS SDK framework in macOS 12. Later in macOS 13 the framework authors decided to add a `degreesFahrenheit` property as a convenience:
+
+  ```swift
+  @available(macOS 12, *)
+  public struct Temperature {
+    public var degreesCelsius: Double
+
+    // ...
+  }
+
+  extension Temperature {
+    @available(macOS 12, *)
+    @backDeployed(before: macOS 13)
+    public var degreesFahrenheit: Double {
+      return (degreesCelsius * 9 / 5) + 32
+    }
+  }
+  ```
+
+  Adding the `@backDeployed` attribute to `degreesFahrenheit` enables the framework author to make this new declaration available to apps with a minimum deployment target of macOS 12, even though the ABI entry point for `degreesFahrenheit` is only present in macOS 13 and up.
+
+  When a function with `@backDeployed` is called, the compiler wraps the invocation of the function in a thunk. The thunk checks whether the library entry point for the declaration is available at runtime, and invokes it if it is. Otherwise, a copy of the function that was emitted into the client is called instead.
+
 * [#56139][]:
 
   Сollection downcasts in cast patterns are now supported. For example:
@@ -9611,6 +9638,7 @@ using the `.dynamicType` member to retrieve the type of an expression should mig
 [SE-0362]: <https://github.com/apple/swift-evolution/blob/main/proposals/0362-piecemeal-future-features.md>
 [SE-0365]: <https://github.com/apple/swift-evolution/blob/main/proposals/0365-implicit-self-weak-capture.md>
 [SE-0370]: <https://github.com/apple/swift-evolution/blob/main/proposals/0370-pointer-family-initialization-improvements.md>
+[SE-0376]: <https://github.com/apple/swift-evolution/blob/main/proposals/0376-function-back-deployment.md>
 
 [#42697]: <https://github.com/apple/swift/issues/42697>
 [#42728]: <https://github.com/apple/swift/issues/42728>

CMakeLists.txt

@@ -268,7 +268,7 @@ set(SWIFT_ANALYZE_CODE_COVERAGE FALSE CACHE STRING
 # SWIFT_VERSION is deliberately /not/ cached so that an existing build directory
 # can be reused when a new version of Swift comes out (assuming the user hasn't
 # manually set it as part of their own CMake configuration).
-set(SWIFT_VERSION "5.8")
+set(SWIFT_VERSION "5.8.1")
 
 set(SWIFT_VENDOR "" CACHE STRING
     "The vendor name of the Swift compiler")
@@ -440,16 +440,16 @@ set(SWIFT_DARWIN_STDLIB_INSTALL_NAME_DIR "/usr/lib/swift" CACHE STRING
 set(SWIFT_DARWIN_STDLIB_PRIVATE_INSTALL_NAME_DIR "@rpath" CACHE STRING
     "The directory of the install_name for the private standard library dylibs")
 
-set(SWIFT_DARWIN_DEPLOYMENT_VERSION_OSX "10.9" CACHE STRING
+set(SWIFT_DARWIN_DEPLOYMENT_VERSION_OSX "10.13" CACHE STRING
     "Minimum deployment target version for OS X")
 
-set(SWIFT_DARWIN_DEPLOYMENT_VERSION_IOS "7.0" CACHE STRING
+set(SWIFT_DARWIN_DEPLOYMENT_VERSION_IOS "11.0" CACHE STRING
     "Minimum deployment target version for iOS")
 
-set(SWIFT_DARWIN_DEPLOYMENT_VERSION_TVOS "9.0" CACHE STRING
+set(SWIFT_DARWIN_DEPLOYMENT_VERSION_TVOS "11.0" CACHE STRING
     "Minimum deployment target version for tvOS")
 
-set(SWIFT_DARWIN_DEPLOYMENT_VERSION_WATCHOS "2.0" CACHE STRING
+set(SWIFT_DARWIN_DEPLOYMENT_VERSION_WATCHOS "4.0" CACHE STRING
     "Minimum deployment target version for watchOS")
 
 #
@@ -1188,8 +1188,8 @@ else()
     add_subdirectory(stdlib/public/BackDeployConcurrency)
   endif()
 
-  # Some tools (e.g. swift-reflection-dump) rely on a host swiftReflection, so
-  # ensure we build that when building tools.
+  # Some tools (e.g. swift-reflection-dump) rely on a host swiftRemoteInspection,
+  # so ensure we build that when building tools.
   if(SWIFT_INCLUDE_TOOLS)
     add_subdirectory(stdlib/public/SwiftShims/swift/shims)
   endif()

CODEOWNERS

@@ -0,0 +1 @@
+* @apple/swift5-branch-managers

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -810,7 +810,10 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
         switch effect.kind {
         case .escapingToReturn(let toPath, let exclusive):
           if exclusive && path.projectionPath.matches(pattern: toPath) {
-            let arg = apply.arguments[effect.argumentIndex]
+            guard let callerArgIdx = apply.callerArgIndex(calleeArgIndex: effect.argumentIndex) else {
+              return .abortWalk
+            }
+            let arg = apply.arguments[callerArgIdx]
 
             let p = Path(projectionPath: effect.pathPattern, followStores: path.followStores, knownType: nil)
             if walkUp(addressOrValue: arg, path: p) == .abortWalk {

SwiftCompilerSources/Sources/SIL/Location.swift

@@ -12,11 +12,24 @@
 
 import SILBridging
 
-public struct Location {
+public struct Location: Equatable, CustomStringConvertible {
   let bridged: swift.SILDebugLocation
-
+
+  public var description: String {
+    let stdString = SILLocation_debugDescription(bridged)
+    return String(_cxxString: stdString)
+  }
+
   /// Keeps the debug scope but marks it as auto-generated.
   public var autoGenerated: Location {
     Location(bridged: SILLocation_getAutogeneratedLocation(bridged))
   }
+
+  public static func ==(lhs: Location, rhs: Location) -> Bool {
+    SILLocation_equal(lhs.bridged, rhs.bridged)
+  }
+
+  public func hasSameSourceLocation(as other: Location) -> Bool {
+    SILLocation_hasSameSourceLocation(bridged, other.bridged)
+  }
 }

cmake/modules/SwiftConfigureSDK.cmake

@@ -84,6 +84,14 @@ function(remove_sdk_unsupported_archs name os sdk_path architectures_var)
       # 32-bit iOS simulator is not listed explicitly in SDK settings.
       message(STATUS "Assuming ${name} SDK at ${sdk_path} supports architecture ${arch}")
       list(APPEND architectures ${arch})
+    elseif(arch STREQUAL "armv7k" AND os STREQUAL "watchos")
+      # 32-bit watchOS is not listed explicitly in SDK settings.
+      message(STATUS "Assuming ${name} SDK at ${sdk_path} supports architecture ${arch}")
+      list(APPEND architectures ${arch})
+    elseif(arch STREQUAL "i386" AND os STREQUAL "watchsimulator")
+      # 32-bit watchOS simulator is not listed explicitly in SDK settings.
+      message(STATUS "Assuming ${name} SDK at ${sdk_path} supports architecture ${arch}")
+      list(APPEND architectures ${arch})
     else()
       message(STATUS "${name} SDK at ${sdk_path} does not support architecture ${arch}")
     endif()

docs/ABI/Mangling.rst

@@ -653,6 +653,7 @@ Types
   type ::= assoc-type-name 'Qz'                      // shortcut for 'Qyz'
   type ::= assoc-type-list 'QY' GENERIC-PARAM-INDEX  // associated type at depth
   type ::= assoc-type-list 'QZ'                      // shortcut for 'QYz'
+  type ::= opaque-type-decl-name bound-generic-args 'Qo' INDEX // opaque type
 
   type ::= pattern-type count-type 'Qp'      // pack expansion type
   type ::= pack-element-list 'QP'            // pack type

docs/ReferenceGuides/UnderscoredAttributes.md

@@ -53,17 +53,7 @@ Adding this attribute to a type leads to remarks being emitted for all methods.
 
 ## `@_backDeploy(before: ...)`
 
-Causes the body of a function to be emitted into the module interface to be
-available for emission into clients with deployment targets lower than the
-ABI availability of the function. When the client's deployment target is
-before the function's ABI availability, the compiler replaces calls to that
-function with a call to a thunk that checks at runtime whether the original
-library function is available. If the original is available then it is
-called. Otherwise, the fallback copy of the function that was emitted into the
-client is called instead.
-
-For more details, see the [pitch thread](https://forums.swift.org/t/pitch-function-back-deployment/55769/)
-in the forums.
+The spelling of `@backDeployed(before:)` prior to the acceptance of [SE-0376](https://github.com/apple/swift-evolution/blob/main/proposals/0376-function-back-deployment.md).
 
 ## `@_borrowed`
 

include/swift/ABI/MetadataValues.h

@@ -2383,6 +2383,24 @@ enum class TaskOptionRecordKind : uint8_t {
   RunInline = UINT8_MAX,
 };
 
+/// Flags for TaskGroup.
+class TaskGroupFlags : public FlagSet<uint32_t> {
+public:
+  enum {
+    // 8 bits are reserved for future use
+    /// Request the TaskGroup to immediately release completed tasks,
+    /// and not store their results. This also effectively disables `next()`.
+    TaskGroup_DiscardResults = 8,
+  };
+
+  explicit TaskGroupFlags(uint32_t bits) : FlagSet(bits) {}
+  constexpr TaskGroupFlags() {}
+
+  FLAGSET_DEFINE_FLAG_ACCESSORS(TaskGroup_DiscardResults,
+                                isDiscardResults,
+                                setIsDiscardResults)
+};
+
 /// Flags for cancellation records.
 class TaskStatusRecordFlags : public FlagSet<size_t> {
 public:

include/swift/ABI/TaskGroup.h

@@ -54,6 +54,14 @@ class alignas(Alignment_TaskGroup) TaskGroup {
 
   // Provide accessor for task group's status record
   TaskGroupTaskStatusRecord *getTaskRecord();
+
+  /// The group is a `TaskGroup` that accumulates results.
+  bool isAccumulatingResults() {
+    return !isDiscardingResults();
+  }
+
+  /// The group is a `DiscardingTaskGroup` that discards results.
+  bool isDiscardingResults();
 };
 
 } // end namespace swift

include/swift/ABI/TaskStatus.h

@@ -51,7 +51,9 @@ class TaskStatusRecord {
   TaskStatusRecord(const TaskStatusRecord &) = delete;
   TaskStatusRecord &operator=(const TaskStatusRecord &) = delete;
 
-  TaskStatusRecordKind getKind() const { return Flags.getKind(); }
+  TaskStatusRecordKind getKind() const {
+    return Flags.getKind();
+  }
 
   TaskStatusRecord *getParent() const { return Parent; }
 
@@ -179,8 +181,7 @@ class TaskGroupTaskStatusRecord : public TaskStatusRecord {
   TaskGroupTaskStatusRecord()
       : TaskStatusRecord(TaskStatusRecordKind::TaskGroup),
         FirstChild(nullptr),
-        LastChild(nullptr) {
-  }
+        LastChild(nullptr) {}
 
   TaskGroupTaskStatusRecord(AsyncTask *child)
       : TaskStatusRecord(TaskStatusRecordKind::TaskGroup),
@@ -189,7 +190,8 @@ class TaskGroupTaskStatusRecord : public TaskStatusRecord {
     assert(!LastChild || !LastChild->childFragment()->getNextChild());
   }
 
-  TaskGroup *getGroup() { return reinterpret_cast<TaskGroup *>(this); }
+  /// Get the task group this record is associated with.
+  TaskGroup *getGroup();
 
   /// Return the first child linked by this record.  This may be null;
   /// if not, it (and all of its successors) are guaranteed to satisfy

include/swift/AST/ActorIsolation.h

@@ -160,6 +160,8 @@ class ActorIsolation {
     return getKind() == GlobalActor || getKind() == GlobalActorUnsafe;
   }
 
+  bool isMainActor() const;
+
   bool isDistributedActor() const;
 
   Type getGlobalActor() const {
@@ -238,6 +240,26 @@ bool isSameActorIsolated(ValueDecl *value, DeclContext *dc);
 /// Determines whether this function's body uses flow-sensitive isolation.
 bool usesFlowSensitiveIsolation(AbstractFunctionDecl const *fn);
 
+/// Check if it is safe for the \c globalActor qualifier to be removed from
+/// \c ty, when the function value of that type is isolated to that actor.
+///
+/// In general this is safe in a narrow but common case: a global actor
+/// qualifier can be dropped from a function type while in a DeclContext
+/// isolated to that same actor, as long as the value is not Sendable.
+///
+/// \param dc the innermost context in which the cast to remove the global actor
+///           is happening.
+/// \param globalActor global actor that was dropped from \c ty.
+/// \param ty a function type where \c globalActor was removed from it.
+/// \param getClosureActorIsolation function that knows how to produce accurate
+///        information about the isolation of a closure.
+/// \return true if it is safe to drop the global-actor qualifier.
+bool safeToDropGlobalActor(
+                DeclContext *dc, Type globalActor, Type ty,
+                llvm::function_ref<ClosureActorIsolation(AbstractClosureExpr *)>
+                    getClosureActorIsolation =
+                        _getRef__AbstractClosureExpr_getActorIsolation());
+
 void simple_display(llvm::raw_ostream &out, const ActorIsolation &state);
 
 } // end namespace swift

include/swift/AST/Attr.h

@@ -2214,15 +2214,12 @@ class UnavailableFromAsyncAttr : public DeclAttribute {
 
 /// The @_backDeploy(...) attribute, used to make function declarations available
 /// for back deployment to older OSes via emission into the client binary.
-class BackDeployAttr: public DeclAttribute {
+class BackDeployedAttr : public DeclAttribute {
 public:
-  BackDeployAttr(SourceLoc AtLoc, SourceRange Range,
-                 PlatformKind Platform,
-                 const llvm::VersionTuple Version,
-                 bool Implicit)
-    : DeclAttribute(DAK_BackDeploy, AtLoc, Range, Implicit),
-      Platform(Platform),
-      Version(Version) {}
+  BackDeployedAttr(SourceLoc AtLoc, SourceRange Range, PlatformKind Platform,
+                   const llvm::VersionTuple Version, bool Implicit)
+      : DeclAttribute(DAK_BackDeployed, AtLoc, Range, Implicit),
+        Platform(Platform), Version(Version) {}
 
   /// The platform the symbol is available for back deployment on.
   const PlatformKind Platform;
@@ -2234,7 +2231,7 @@ class BackDeployAttr: public DeclAttribute {
   bool isActivePlatform(const ASTContext &ctx) const;
 
   static bool classof(const DeclAttribute *DA) {
-    return DA->getKind() == DAK_BackDeploy;
+    return DA->getKind() == DAK_BackDeployed;
   }
 };
 
@@ -2367,6 +2364,10 @@ class DeclAttributes {
   /// otherwise.
   const AvailableAttr *getNoAsync(const ASTContext &ctx) const;
 
+  /// Returns the `@backDeployed` attribute that is active for the current
+  /// platform.
+  const BackDeployedAttr *getBackDeployed(const ASTContext &ctx) const;
+
   SWIFT_DEBUG_DUMPER(dump(const Decl *D = nullptr));
   void print(ASTPrinter &Printer, const PrintOptions &Options,
              const Decl *D = nullptr) const;

include/swift/AST/Availability.h

@@ -24,6 +24,7 @@
 
 namespace swift {
 class ASTContext;
+class AvailableAttr;
 class Decl;
 
 /// A lattice of version ranges of the form [x.y.z, +Inf).
@@ -344,6 +345,11 @@ class AvailabilityInference {
   ///  We assume a declaration without an annotation is always available.
   static AvailabilityContext availableRange(const Decl *D, ASTContext &C);
 
+  /// Returns the attribute that should be used to determine the availability
+  /// range of the given declaration, or nullptr if there is none.
+  static const AvailableAttr *attrForAnnotatedAvailableRange(const Decl *D,
+                                                             ASTContext &Ctx);
+
   /// Returns the context for which the declaration
   /// is annotated as available, or None if the declaration
   /// has no availability annotation.

include/swift/AST/Builtins.def

@@ -793,6 +793,10 @@ BUILTIN_MISC_OPERATION(ResumeThrowingContinuationThrowing,
 BUILTIN_MISC_OPERATION(CreateTaskGroup,
                        "createTaskGroup", "", Special)
 
+/// Create a task group, with options.
+BUILTIN_MISC_OPERATION(CreateTaskGroupWithFlags,
+                       "createTaskGroupWithFlags", "", Special)
+
 /// Destroy a task group.
 BUILTIN_MISC_OPERATION(DestroyTaskGroup,
                        "destroyTaskGroup", "", Special)