Merge pull request #5423 from swiftwasm/release/5.8

[pull] swiftwasm-release/5.8 from release/5.8

Author: kateinoigakukun

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")

include/swift/Basic/TaggedUnion.h

@@ -57,22 +57,24 @@ class TaggedUnionBase<KindHelper, Members,
 
   TaggedUnionBase(Kind theKind) : TheKind(theKind) {}
 
+  template <typename T>
+  static constexpr const bool constructible =
+      TaggedUnionImpl::is_member_constructible<Members, T>();
+
 public:
   /// Construct the union with a value of the given type, which must
   /// (ignoring references) be one of the declared members of the union.
   template <class T>
   TaggedUnionBase(T &&value,
-                  typename std::enable_if<
-                    TaggedUnionImpl::is_member_constructible<Members, T>(),
-                    TaggedUnionImpl::Empty>::type = {}) {
+                  typename std::enable_if<constructible<T>,
+                                          TaggedUnionImpl::Empty>::type = {}) {
     using TargetType = TaggedUnionImpl::simplify_member_type<T>;
     TheKind = StorageType::template kindForMember<TargetType>();
     Storage.template emplace<TargetType>(TheKind, std::forward<T>(value));
   }
 
   template <class T>
-  typename std::enable_if<TaggedUnionImpl::is_member_constructible<Members, T>(),
-                          TaggedUnionBase &>::type
+  typename std::enable_if<constructible<T>, TaggedUnionBase &>::type
   operator=(T &&value) {
     using TargetType = TaggedUnionImpl::simplify_member_type<T>;
     TheKind = StorageType::template kindForMember<TargetType>();
@@ -155,12 +157,15 @@ class TaggedUnionBase<KindHelper, Members, /*NonTrivial*/ true, /*HasVoid*/ fals
 
   TaggedUnionBase(typename super::Kind kind) : super(kind) {}
 
+  template <typename T>
+  static constexpr const bool constructible =
+      TaggedUnionImpl::is_member_constructible<Members, T>();
+
 public:
   template <class T>
   TaggedUnionBase(T &&value,
-                  typename std::enable_if<
-                    TaggedUnionImpl::is_member_constructible<Members, T>(),
-                    TaggedUnionImpl::Empty>::type = {})
+                  typename std::enable_if<constructible<T>,
+                                          TaggedUnionImpl::Empty>::type = {})
     : super(std::forward<T>(value)) {}
 
   // We want to either define or delete all the special members.
@@ -236,12 +241,15 @@ class TaggedUnionBase<KindHelper, Members, NonTrivial, /*HasVoid*/ true>
     return super::StorageType::template kindForMember<void>();
   }
 
+  template <typename T>
+  static constexpr const bool constructible =
+      TaggedUnionImpl::is_member_constructible<Members, T>();
+
 public:
   template <class T>
   TaggedUnionBase(T &&value,
-                  typename std::enable_if<
-                    TaggedUnionImpl::is_member_constructible<Members, T>(),
-                    TaggedUnionImpl::Empty>::type = {})
+                  typename std::enable_if<constructible<T>,
+                                          TaggedUnionImpl::Empty>::type = {})
     : super(std::forward<T>(value)) {}
 
   /// Construct the union in the empty state.

stdlib/public/runtime/WeakReference.h

@@ -175,8 +175,9 @@ class WeakReference {
   HeapObject *nativeTakeStrongFromBits(WeakReferenceBits bits) {
     auto side = bits.getNativeOrNull();
     if (side) {
+      auto obj = side->tryRetain();
       side->decrementWeak();
-      return side->tryRetain();
+      return obj;
     } else {
       return nullptr;
     }

stdlib/toolchain/Compatibility56/Concurrency/Actor.cpp

@@ -8,6 +8,9 @@
 #include "swift/Runtime/Casting.h"
 #include "Runtime/Threading/ThreadLocal.h"
 
+#include <Availability.h>
+#include <TargetConditionals.h>
+
 #include <atomic>
 #include <new>
 
@@ -146,3 +149,47 @@ void swift::adoptTaskVoucher(AsyncTask *task) {
 void swift::restoreTaskVoucher(AsyncTask *task) {
   ExecutorTrackingInfo::current()->restoreVoucher(task);
 }
+
+static swift_once_t voucherDisableCheckOnce;
+static bool vouchersDisabled;
+
+namespace {
+  struct _SwiftNSOperatingSystemVersion{
+    intptr_t majorVersion;
+    intptr_t minorVersion;
+    intptr_t patchVersion;
+  };
+}
+
+extern "C"
+_SwiftNSOperatingSystemVersion
+_swift_stdlib_operatingSystemVersion() __attribute__((const));
+
+static void _initializeVouchersDisabled(void *ctxt) {
+  auto osVersion = _swift_stdlib_operatingSystemVersion();
+  #if TARGET_OS_WATCH
+  vouchersDisabled = (
+    osVersion.majorVersion == 8 &&
+    osVersion.minorVersion >= 0 && osVersion.minorVersion < 3
+  );
+  #elif TARGET_OS_IPHONE
+  vouchersDisabled = (
+    osVersion.majorVersion == 15 &&
+    osVersion.minorVersion >= 0 && osVersion.minorVersion < 2
+  );
+  #elif TARGET_OS_OSX
+  vouchersDisabled = (
+    osVersion.majorVersion == 12 &&
+    osVersion.minorVersion >= 0 && osVersion.minorVersion < 1
+  );
+  #else
+  vouchersDisabled = false;
+  #endif
+}
+
+bool VoucherManager::vouchersAreDisabled() {
+  swift_once(&voucherDisableCheckOnce,
+             &_initializeVouchersDisabled,
+             nullptr);
+  return vouchersDisabled;
+}

stdlib/toolchain/Compatibility56/include/Concurrency/VoucherSupport.h

@@ -31,6 +31,12 @@ class VoucherManager {
   /// async work.
   llvm::Optional<voucher_t> OriginalVoucher;
 
+  /// Determine whether vouchers are disabled entirely. This evaluates
+  /// true on platforms whose concurrency library does not support the
+  /// propagation of vouchers, in which case all of the operations of
+  /// this class must be no-ops.
+  static bool vouchersAreDisabled();
+
 public:
   VoucherManager() {
     SWIFT_TASK_DEBUG_LOG("[%p] Constructing VoucherManager", this);
@@ -41,6 +47,9 @@ class VoucherManager {
   /// VoucherManager object is destroyed. It may also be called in other
   /// places to restore the original voucher and reset the VoucherManager.
   void leave() {
+    if (vouchersAreDisabled())
+      return;
+
     if (OriginalVoucher) {
       SWIFT_TASK_DEBUG_LOG("[%p] Restoring original voucher %p", this,
                            *OriginalVoucher);
@@ -62,6 +71,9 @@ class VoucherManager {
   /// this is permanent. For Tasks, the voucher must be restored using
   /// restoreVoucher if the task suspends.
   void swapToJob(Job *job) {
+    if (vouchersAreDisabled())
+      return;
+
     SWIFT_TASK_DEBUG_LOG("[%p] Swapping jobs to %p", this, job);
     assert(job);
     assert(job->Voucher != SWIFT_DEAD_VOUCHER);
@@ -99,6 +111,9 @@ class VoucherManager {
   // Take the current thread's adopted voucher and place it back into the task
   // that previously owned it, re-adopting the thread's original voucher.
   void restoreVoucher(AsyncTask *task) {
+    if (vouchersAreDisabled())
+      return;
+
     SWIFT_TASK_DEBUG_LOG("[%p] Restoring %svoucher on task %p", this,
                          OriginalVoucher ? "" : "missing ", task);
     assert(OriginalVoucher);

test/Serialization/Recovery/types-5-to-4.swift

@@ -16,8 +16,8 @@ import Lib
 func requiresConformance(_: B_RequiresConformance<B_ConformsToProto>) {}
 func requiresConformance(_: B_RequiresConformance<C_RelyOnConformanceImpl.Assoc>) {}
 
-class Sub: Base {} // expected-error {{cannot inherit from class 'Base' (compiled with Swift 5.8) because it has overridable members that could not be loaded in Swift 4.1.50}}
-class Impl: Proto {} // expected-error {{type 'Impl' cannot conform to protocol 'Proto' (compiled with Swift 5.8) because it has requirements that could not be loaded in Swift 4.1.50}}
+class Sub: Base {} // expected-error {{cannot inherit from class 'Base' (compiled with Swift 5.8.1) because it has overridable members that could not be loaded in Swift 4.1.50}}
+class Impl: Proto {} // expected-error {{type 'Impl' cannot conform to protocol 'Proto' (compiled with Swift 5.8.1) because it has requirements that could not be loaded in Swift 4.1.50}}
 
 #else // TEST
 

test/SourceKit/Misc/compiler_version.swift

@@ -2,4 +2,4 @@
 
 // CHECK: key.version_major: 5
 // CHECK: key.version_minor: 8
-// CHECK: key.version_patch: 0
+// CHECK: key.version_patch: 1

utils/build-script-impl

@@ -2689,12 +2689,13 @@ for host in "${ALL_HOSTS[@]}"; do
                     fi
 
                     with_pushd "${LIBICU_BUILD_DIR}" \
-                        call env CXXFLAGS=-fPIC "${LIBICU_SOURCE_DIR}"/icu4c/source/runConfigureICU Linux \
+                        call env CXXFLAGS=-fPIC LDFLAGS='-Wl,-rpath=\$$ORIGIN' \
+                        "${LIBICU_SOURCE_DIR}"/icu4c/source/runConfigureICU Linux \
                         ${icu_build_variant_arg} --prefix=${ICU_TMPINSTALL} \
                         ${libicu_enable_debug} \
                         --enable-renaming --with-library-suffix=swift \
                         --libdir=${ICU_TMPLIBDIR} \
-                        --enable-shared --enable-static --enable-rpath \
+                        --enable-shared --enable-static \
                         --enable-strict --disable-icuio \
                         --disable-plugins --disable-dyload --disable-extras \
                         --disable-samples --disable-layoutex --with-data-packaging=auto

utils/build_swift/build_swift/defaults.py

@@ -46,7 +46,7 @@
 CMAKE_GENERATOR = 'Ninja'
 
 COMPILER_VENDOR = 'none'
-SWIFT_USER_VISIBLE_VERSION = Version('5.8')
+SWIFT_USER_VISIBLE_VERSION = Version('5.8.1')
 CLANG_USER_VISIBLE_VERSION = Version('13.0.0')
 SWIFT_ANALYZE_CODE_COVERAGE = 'false'