Merge pull request #5295 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

include/swift/AST/DiagnosticsSema.def

@@ -6855,12 +6855,9 @@ ERROR(moveonly_copyable_type_that_contains_moveonly_type, none,
 NOTE(moveonly_copyable_type_that_contains_moveonly_type_location, none,
      "contained move-only %0 '%1.%2'",
      (DescriptiveDeclKind, StringRef, StringRef))
-ERROR(moveonly_cannot_conform_to_protocol, none,
-     "move-only %0 %1 cannot conform yet to any protocols",
-     (DescriptiveDeclKind, DeclName))
-ERROR(moveonly_cannot_conform_to_protocol_with_name, none,
-     "move-only %0 %1 cannot conform to protocol %2",
-     (DescriptiveDeclKind, DeclName, DeclName))
+ERROR(moveonly_cannot_conform_to_type, none,
+     "move-only %0 %1 cannot conform to %2",
+     (DescriptiveDeclKind, DeclName, Type))
 ERROR(moveonly_non_final_class_cannot_contain_moveonly_field, none,
      "non-final classes containing move only fields is not yet supported", ())
 

lib/AST/ProtocolConformance.cpp

@@ -1056,6 +1056,13 @@ void NominalTypeDecl::prepareConformanceTable() const {
     if (!proto)
       return;
 
+    // No synthesized conformances for move-only nominals.
+    if (isMoveOnly()) {
+      // assumption is Sendable gets synthesized elsewhere.
+      assert(!proto->isSpecificProtocol(KnownProtocolKind::Sendable));
+      return;
+    }
+
     if (protocols.count(proto) == 0) {
       ConformanceTable->addSynthesizedConformance(
           mutableThis, proto, mutableThis);

lib/Refactoring/Refactoring.cpp

@@ -8595,6 +8595,50 @@ bool RefactoringActionExpandMacro::isApplicable(const ResolvedCursorInfo &Info,
   return !getMacroExpansionBuffers(Diag.SourceMgr, Info).empty();
 }
 
+/// Given the expanded code for a particular macro, perform whitespace
+/// adjustments to make the refactoring more.
+static StringRef adjustMacroExpansionWhitespace(
+    GeneratedSourceInfo::Kind kind, StringRef expandedCode,
+    llvm::SmallString<64> &scratch
+) {
+  scratch.clear();
+
+  switch (kind) {
+  case GeneratedSourceInfo::ExpressionMacroExpansion:
+  case GeneratedSourceInfo::FreestandingDeclMacroExpansion:
+    return expandedCode;
+
+  case GeneratedSourceInfo::AccessorMacroExpansion:
+      // For accessor macros, wrap curly braces around the buffer contents.
+    scratch += "{\n";
+    scratch += expandedCode;
+    scratch += "\n}";
+    return scratch;
+
+  case GeneratedSourceInfo::MemberAttributeMacroExpansion:
+      // For member-attribute macros, add a space at the end.
+    scratch += expandedCode;
+    scratch += " ";
+    return scratch;
+
+  case GeneratedSourceInfo::PeerMacroExpansion:
+      // For peers, add a newline to create some separation.
+    scratch += "\n";
+    LLVM_FALLTHROUGH;
+
+  case GeneratedSourceInfo::MemberMacroExpansion:
+      // For members, add a newline.
+    scratch += "\n";
+    scratch += expandedCode;
+    scratch += "\n";
+    return scratch;
+
+  case GeneratedSourceInfo::ReplacedFunctionBody:
+  case GeneratedSourceInfo::PrettyPrinted:
+    return expandedCode;
+  }
+}
+
 bool RefactoringActionExpandMacro::performChange() {
   auto bufferIDs = getMacroExpansionBuffers(SM, CursorInfo);
   if (bufferIDs.empty())
@@ -8637,15 +8681,11 @@ bool RefactoringActionExpandMacro::performChange() {
 
       auto afterLeftBraceLoc = Lexer::getLocForEndOfToken(SM, leftBraceLoc);
       originalSourceRange = CharSourceRange(afterLeftBraceLoc, 0);
-    } else if (generatedInfo->kind ==
-                   GeneratedSourceInfo::AccessorMacroExpansion) {
-      // For accessor macros, wrap curly braces around the buffer contents.
-      scratchBuffer += "{\n";
-      scratchBuffer += rewrittenBuffer;
-      scratchBuffer += "\n}";
-      rewrittenBuffer = scratchBuffer;
     }
 
+    rewrittenBuffer = adjustMacroExpansionWhitespace(
+        generatedInfo->kind, rewrittenBuffer, scratchBuffer);
+
     EditConsumer.accept(SM, originalSourceRange, rewrittenBuffer);
 
     if (generatedInfo->attachedMacroCustomAttr && !attachedMacroAttr)

lib/SIL/Utils/OwnershipUtils.cpp

@@ -1779,8 +1779,6 @@ bool swift::visitForwardedGuaranteedOperands(
       || isa<OwnershipForwardingMultipleValueInstruction>(inst)
       || isa<MoveOnlyWrapperToCopyableValueInst>(inst)
       || isa<CopyableToMoveOnlyWrapperValueInst>(inst)) {
-    assert(inst->getNumRealOperands() == 1
-           && "forwarding instructions must have a single real operand");
     assert(!isa<SingleValueInstruction>(inst)
            || !BorrowedValue(cast<SingleValueInstruction>(inst))
                   && "forwarded operand cannot begin a borrow scope");

lib/Sema/CSApply.cpp

@@ -7804,18 +7804,27 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, Type openedType,
         auto *body = args->getExpr(1);
         auto bodyTy = cs.getType(body)->getWithoutSpecifierType();
         auto bodyFnTy = bodyTy->castTo<FunctionType>();
-        auto escapableParams = bodyFnTy->getParams();
         auto resultType = bodyFnTy->getResult();
 
         // The body is immediately called, so is obviously noescape.
+        // Coerce the argument function to be escaping even if it happens to
+        // be nonescaping, since we need the dynamic state of the escaping
+        // closure to do the dynamic noescape check.
+        auto bodyArgFnTy = bodyFnTy->getParams()[0].getPlainType()
+          ->castTo<FunctionType>();
+          
+        bodyArgFnTy = cast<FunctionType>(
+          bodyArgFnTy->withExtInfo(bodyArgFnTy->getExtInfo().withNoEscape(false)));
         bodyFnTy = cast<FunctionType>(
-          bodyFnTy->withExtInfo(bodyFnTy->getExtInfo().withNoEscape()));
+          FunctionType::get(bodyFnTy->getParams()[0].withType(bodyArgFnTy),
+                            bodyFnTy->getResult())
+            ->withExtInfo(bodyFnTy->getExtInfo().withNoEscape()));
         body = coerceToType(body, bodyFnTy, locator);
         assert(body && "can't make nonescaping?!");
 
         auto escapable = new (ctx)
             OpaqueValueExpr(apply->getFn()->getSourceRange(), Type());
-        cs.setType(escapable, escapableParams[0].getOldType());
+        cs.setType(escapable, bodyArgFnTy);
 
         auto *argList = ArgumentList::forImplicitUnlabeled(ctx, {escapable});
         auto callSubExpr = CallExpr::createImplicit(ctx, body, argList);

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2586,7 +2586,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     // FIXME(kavon): see if these can be integrated into other parts of Sema
     diagnoseCopyableTypeContainingMoveOnlyType(ED);
-    diagnoseMoveOnlyNominalDeclDoesntConformToProtocols(ED);
+    diagnoseIncompatibleProtocolsForMoveOnlyType(ED);
 
     checkExplicitAvailability(ED);
 
@@ -2645,7 +2645,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     // are not move only.
     diagnoseCopyableTypeContainingMoveOnlyType(SD);
 
-    diagnoseMoveOnlyNominalDeclDoesntConformToProtocols(SD);
+    diagnoseIncompatibleProtocolsForMoveOnlyType(SD);
   }
 
   /// Check whether the given properties can be @NSManaged in this class.
@@ -2747,21 +2747,53 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     }
   }
 
-  void diagnoseMoveOnlyNominalDeclDoesntConformToProtocols(
-      NominalTypeDecl *nomDecl) {
-    if (!nomDecl->isMoveOnly())
-      return;
+  /// check to see if a move-only type can ever conform to the given type.
+  /// \returns true iff a diagnostic was emitted because it was not compatible
+  static bool diagnoseIncompatibleWithMoveOnlyType(SourceLoc loc,
+                                                 NominalTypeDecl *moveonlyType,
+                                                 Type type) {
+    assert(type && "got an empty type?");
+    assert(moveonlyType->isMoveOnly());
 
-    for (auto *prot : nomDecl->getLocalProtocols()) {
+    auto canType = type->getCanonicalType();
+    if (auto prot = canType->getAs<ProtocolType>()) {
       // Permit conformance to marker protocol Sendable.
-      if (prot->isSpecificProtocol(KnownProtocolKind::Sendable)) {
-        assert(prot->isMarkerProtocol());
-        continue;
+      if (prot->getDecl()->isSpecificProtocol(KnownProtocolKind::Sendable)) {
+        assert(prot->getDecl()->isMarkerProtocol());
+        return false;
       }
+    }
 
-      nomDecl->diagnose(diag::moveonly_cannot_conform_to_protocol_with_name,
-                        nomDecl->getDescriptiveKind(),
-                        nomDecl->getBaseName(), prot->getBaseName());
+    auto &ctx = moveonlyType->getASTContext();
+    ctx.Diags.diagnose(loc,
+                       diag::moveonly_cannot_conform_to_type,
+                       moveonlyType->getDescriptiveKind(),
+                       moveonlyType->getBaseName(),
+                       type);
+    return true;
+  }
+
+  static void diagnoseIncompatibleProtocolsForMoveOnlyType(Decl *decl) {
+    if (auto *nomDecl = dyn_cast<NominalTypeDecl>(decl)) {
+      if (!nomDecl->isMoveOnly())
+        return;
+
+      // go over the all protocols directly conformed-to by this nominal
+      for (auto *prot : nomDecl->getLocalProtocols())
+        diagnoseIncompatibleWithMoveOnlyType(nomDecl->getLoc(), nomDecl,
+                                             prot->getDeclaredInterfaceType());
+
+    } else if (auto *extension = dyn_cast<ExtensionDecl>(decl)) {
+      if (auto *nomDecl = extension->getExtendedNominal()) {
+        if (!nomDecl->isMoveOnly())
+          return;
+
+        // go over the all types directly conformed-to by the extension
+        for (auto entry : extension->getInherited()) {
+          diagnoseIncompatibleWithMoveOnlyType(extension->getLoc(), nomDecl,
+                                               entry.getType());
+        }
+      }
     }
   }
 
@@ -2928,7 +2960,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     maybeDiagnoseClassWithoutInitializers(CD);
 
-    diagnoseMoveOnlyNominalDeclDoesntConformToProtocols(CD);
+    diagnoseIncompatibleProtocolsForMoveOnlyType(CD);
 
     // Ban non-final classes from having move only fields.
     if (!CD->isFinal()) {
@@ -3404,11 +3436,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     if (nominal->isDistributedActor())
       TypeChecker::checkDistributedActor(SF, nominal);
 
-    // If we have a move only type and allow it to extend any protocol, error.
-    if (nominal->isMoveOnly() && ED->getInherited().size()) {
-      ED->diagnose(diag::moveonly_cannot_conform_to_protocol,
-                   nominal->getDescriptiveKind(), nominal->getBaseName());
-    }
+    diagnoseIncompatibleProtocolsForMoveOnlyType(ED);
 
     TypeChecker::checkReflectionMetadataAttributes(ED);
   }

stdlib/public/core/Runtime.swift

@@ -131,16 +131,19 @@ func _stdlib_atomicInitializeARCRef(
   object target: UnsafeMutablePointer<AnyObject?>,
   desired: AnyObject
 ) -> Bool {
+  // Note: this assumes that AnyObject? is layout-compatible with a RawPointer
+  // that simply points to the same memory.
   var expected: UnsafeRawPointer?
-  let desiredPtr = Unmanaged.passRetained(desired).toOpaque()
+  let unmanaged = Unmanaged.passRetained(desired)
+  let desiredPtr = unmanaged.toOpaque()
   let rawTarget = UnsafeMutableRawPointer(target).assumingMemoryBound(
     to: Optional<UnsafeRawPointer>.self)
   let wonRace = _stdlib_atomicCompareExchangeStrongPtr(
     object: rawTarget, expected: &expected, desired: desiredPtr)
   if !wonRace {
     // Some other thread initialized the value.  Balance the retain that we
     // performed on 'desired'.
-    Unmanaged.passUnretained(desired).release()
+    unmanaged.release()
   }
   return wonRace
 }
@@ -157,6 +160,44 @@ func _stdlib_atomicLoadARCRef(
   return nil
 }
 
+@_transparent
+@_alwaysEmitIntoClient
+@discardableResult
+public func _stdlib_atomicAcquiringInitializeARCRef<T: AnyObject>(
+  object target: UnsafeMutablePointer<T?>,
+  desired: __owned T
+) -> Unmanaged<T> {
+  // Note: this assumes that AnyObject? is layout-compatible with a RawPointer
+  // that simply points to the same memory, and that `nil` is represented by an
+  // all-zero bit pattern.
+  let unmanaged = Unmanaged.passRetained(desired)
+  let desiredPtr = unmanaged.toOpaque()
+
+  let (value, won) = Builtin.cmpxchg_acqrel_acquire_Word(
+    target._rawValue,
+    0._builtinWordValue,
+    Builtin.ptrtoint_Word(desiredPtr._rawValue))
+
+  if Bool(won) { return unmanaged }
+
+  // Some other thread initialized the value before us. Balance the retain that
+  // we performed on 'desired', and return what we loaded.
+  unmanaged.release()
+  let ptr = UnsafeRawPointer(Builtin.inttoptr_Word(value))
+  return Unmanaged<T>.fromOpaque(ptr)
+}
+
+@_alwaysEmitIntoClient
+@_transparent
+public func _stdlib_atomicAcquiringLoadARCRef<T: AnyObject>(
+  object target: UnsafeMutablePointer<T?>
+) -> Unmanaged<T>? {
+  let value = Builtin.atomicload_acquire_Word(target._rawValue)
+  if Int(value) == 0 { return nil }
+  let opaque = UnsafeRawPointer(Builtin.inttoptr_Word(value))
+  return Unmanaged<T>.fromOpaque(opaque)
+}
+
 //===----------------------------------------------------------------------===//
 // Conversion of primitive types to `String`
 //===----------------------------------------------------------------------===//

stdlib/public/core/StringStorage.swift

@@ -719,8 +719,18 @@ extension __SharedStringStorage {
 
 // Get and populate breadcrumbs
 extension _StringGuts {
+  /// Atomically load and return breadcrumbs, populating them if necessary.
+  ///
+  /// This emits aquire/release barriers to avoid access reordering trouble.
+  ///
+  /// This returns an unmanaged +0 reference to allow accessing breadcrumbs
+  /// without incurring retain/release operations.
   @_effects(releasenone)
-  internal func getBreadcrumbsPtr() -> UnsafePointer<_StringBreadcrumbs> {
+  internal func loadUnmanagedBreadcrumbs() -> Unmanaged<_StringBreadcrumbs> {
+    // FIXME: Returning Unmanaged emulates the original implementation (that
+    // used to return a nonatomic pointer), but it may be an unnecessary
+    // complication. (UTF-16 transcoding seems expensive enough not to worry
+    // about retain overhead.)
     _internalInvariant(hasBreadcrumbs)
 
     let mutPtr: UnsafeMutablePointer<_StringBreadcrumbs?>
@@ -731,25 +741,12 @@ extension _StringGuts {
         Builtin.addressof(&_object.sharedStorage._breadcrumbs))
     }
 
-    if _slowPath(mutPtr.pointee == nil) {
-      populateBreadcrumbs(mutPtr)
+    if let breadcrumbs = _stdlib_atomicAcquiringLoadARCRef(object: mutPtr) {
+      return breadcrumbs
     }
-
-    _internalInvariant(mutPtr.pointee != nil)
-    // assuming optional class reference and class reference can alias
-    return UnsafeRawPointer(mutPtr).assumingMemoryBound(to: _StringBreadcrumbs.self)
-  }
-
-  @inline(never) // slow-path
-  @_effects(releasenone)
-  internal func populateBreadcrumbs(
-    _ mutPtr: UnsafeMutablePointer<_StringBreadcrumbs?>
-  ) {
-    // Thread-safe compare-and-swap
-    let crumbs = _StringBreadcrumbs(String(self))
-    _stdlib_atomicInitializeARCRef(
-      object: UnsafeMutableRawPointer(mutPtr).assumingMemoryBound(to: Optional<AnyObject>.self),
-      desired: crumbs)
+    let desired = _StringBreadcrumbs(String(self))
+    return _stdlib_atomicAcquiringInitializeARCRef(
+      object: mutPtr, desired: desired)
   }
 }
 

stdlib/public/core/StringStorageBridge.swift

@@ -48,6 +48,9 @@ extension _AbstractStringStorage {
   ) {
     _precondition(aRange.location >= 0 && aRange.length >= 0,
                   "Range out of bounds")
+    // Note: `count` is counting UTF-8 code units, while `aRange` is measured in
+    // UTF-16 offsets. This precondition is a necessary, but not sufficient test
+    // for validity. (More precise checks are done in UTF16View._nativeCopy.)
     _precondition(aRange.location + aRange.length <= Int(count),
                   "Range out of bounds")