Merge pull request #4523 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

SwiftCompilerSources/Sources/SIL/BasicBlock.swift

@@ -25,7 +25,7 @@ final public class BasicBlock : ListNode, CustomStringConvertible, HasName {
   public var function: Function { SILBasicBlock_getFunction(bridged).function }
 
   public var description: String {
-    var s = SILBasicBlock_debugDescription(bridged)
+    let s = SILBasicBlock_debugDescription(bridged)
     return String(cString: s.c_str())
   }
 

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -21,7 +21,7 @@ final public class Function : CustomStringConvertible, HasName {
   }
 
   final public var description: String {
-    var s = SILFunction_debugDescription(bridged)
+    let s = SILFunction_debugDescription(bridged)
     return String(cString: s.c_str())
   }
 

SwiftCompilerSources/Sources/SIL/GlobalVariable.swift

@@ -19,7 +19,7 @@ final public class GlobalVariable : CustomStringConvertible, HasName {
   }
 
   public var description: String {
-    var s = SILGlobalVariable_debugDescription(bridged)
+    let s = SILGlobalVariable_debugDescription(bridged)
     return String(cString: s.c_str())
   }
 

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -38,7 +38,7 @@ public class Instruction : ListNode, CustomStringConvertible, Hashable {
   final public var function: Function { block.function }
 
   final public var description: String {
-    var s = SILNode_debugDescription(bridgedNode)
+    let s = SILNode_debugDescription(bridgedNode)
     return String(cString: s.c_str())
   }
 
@@ -136,7 +136,7 @@ public class SingleValueInstruction : Instruction, Value {
 
 public final class MultipleValueInstructionResult : Value {
   final public var description: String {
-    var s = SILNode_debugDescription(bridgedNode)
+    let s = SILNode_debugDescription(bridgedNode)
     return String(cString: s.c_str())
   }
 

SwiftCompilerSources/Sources/SIL/Value.swift

@@ -21,7 +21,7 @@ public protocol Value : AnyObject, CustomStringConvertible {
 
 extension Value {
   public var description: String {
-    var s = SILNode_debugDescription(bridgedNode)
+    let s = SILNode_debugDescription(bridgedNode)
     return String(cString: s.c_str())
   }
 

include/swift/Runtime/Heap.h

@@ -29,7 +29,7 @@ namespace swift {
 // Never returns nil. The returned memory is uninitialized. 
 //
 // An "alignment mask" is just the alignment (a power of 2) minus 1.
-SWIFT_RETURNS_NONNULL SWIFT_RUNTIME_EXPORT
+SWIFT_RETURNS_NONNULL SWIFT_NODISCARD SWIFT_RUNTIME_EXPORT
 void *swift_slowAlloc(size_t bytes, size_t alignMask);
 
 // If the caller cannot promise to zero the object during destruction,
@@ -53,7 +53,7 @@ void swift_slowDealloc(void *ptr, size_t bytes, size_t alignMask);
 /// This function is capable of returning well-aligned memory even on platforms
 /// that do not implement the C++17 "over-aligned new" feature.
 template <typename T, typename... Args>
-SWIFT_RETURNS_NONNULL
+SWIFT_RETURNS_NONNULL SWIFT_NODISCARD
 static inline T *swift_cxx_newObject(Args &&... args) {
   auto result = reinterpret_cast<T *>(swift_slowAlloc(sizeof(T),
                                                       alignof(T) - 1));

include/swift/Runtime/HeapObject.h

@@ -61,7 +61,7 @@ struct OpaqueValue;
 ///
 /// POSSIBILITIES: The argument order is fair game.  It may be useful
 /// to have a variant which guarantees zero-initialized memory.
-SWIFT_RETURNS_NONNULL SWIFT_RUNTIME_EXPORT
+SWIFT_RETURNS_NONNULL SWIFT_NODISCARD SWIFT_RUNTIME_EXPORT
 HeapObject *swift_allocObject(HeapMetadata const *metadata,
                               size_t requiredSize,
                               size_t requiredAlignmentMask);
@@ -117,7 +117,7 @@ BoxPair swift_makeBoxUnique(OpaqueValue *buffer, Metadata const *type,
                                     size_t alignMask);
 
 /// Returns the address of a heap object representing all empty box types.
-SWIFT_RETURNS_NONNULL SWIFT_RUNTIME_EXPORT
+SWIFT_RETURNS_NONNULL SWIFT_NODISCARD SWIFT_RUNTIME_EXPORT
 HeapObject* swift_allocEmptyBox();
 
 /// Atomically increments the retain count of an object.

include/swift/Runtime/Metadata.h

@@ -307,7 +307,7 @@ swift_getGenericMetadata(MetadataRequest request,
 ///   - installing new v-table entries and overrides; and
 ///   - registering the class with the runtime under ObjC interop.
 /// Most of this work can be achieved by calling swift_initClassMetadata.
-SWIFT_RETURNS_NONNULL SWIFT_RUNTIME_EXPORT
+SWIFT_RETURNS_NONNULL SWIFT_NODISCARD SWIFT_RUNTIME_EXPORT
 ClassMetadata *
 swift_allocateGenericClassMetadata(const ClassDescriptor *description,
                                    const void *arguments,
@@ -316,7 +316,7 @@ swift_allocateGenericClassMetadata(const ClassDescriptor *description,
 /// Allocate a generic value metadata object.  This is intended to be
 /// called by the metadata instantiation function of a generic struct or
 /// enum.
-SWIFT_RETURNS_NONNULL SWIFT_RUNTIME_EXPORT
+SWIFT_RETURNS_NONNULL SWIFT_NODISCARD SWIFT_RUNTIME_EXPORT
 ValueMetadata *
 swift_allocateGenericValueMetadata(const ValueTypeDescriptor *description,
                                    const void *arguments,

lib/AST/DistributedDecl.cpp

@@ -472,7 +472,6 @@ bool AbstractFunctionDecl::isDistributedActorSystemRemoteCall(bool isVoidReturn)
   if (!invocationParam->isInOut()) {
     return false;
   }
-
   // --- Check parameter: throwing: Err.Type
   auto thrownTypeParam = params->get(3);
   if (thrownTypeParam->getArgumentName() != C.Id_throwing) {

lib/Sema/TypeCheckAvailability.cpp

@@ -79,6 +79,19 @@ bool swift::isExported(const ValueDecl *VD) {
   return false;
 }
 
+static bool hasConformancesToPublicProtocols(const ExtensionDecl *ED) {
+  auto protocols = ED->getLocalProtocols(ConformanceLookupKind::OnlyExplicit);
+  for (const ProtocolDecl *PD : protocols) {
+    AccessScope scope =
+        PD->getFormalAccessScope(/*useDC*/ nullptr,
+                                 /*treatUsableFromInlineAsPublic*/ true);
+    if (scope.isPublic())
+      return true;
+  }
+
+  return false;
+}
+
 bool swift::isExported(const ExtensionDecl *ED) {
   // An extension can only be exported if it extends an exported type.
   if (auto *NTD = ED->getExtendedNominal()) {
@@ -94,14 +107,8 @@ bool swift::isExported(const ExtensionDecl *ED) {
 
   // If the extension declares a conformance to a public protocol then the
   // extension is exported.
-  auto protocols = ED->getLocalProtocols(ConformanceLookupKind::OnlyExplicit);
-  for (const ProtocolDecl *PD : protocols) {
-    AccessScope scope =
-      PD->getFormalAccessScope(/*useDC*/nullptr,
-                               /*treatUsableFromInlineAsPublic*/true);
-    if (scope.isPublic())
-      return true;
-  }
+  if (hasConformancesToPublicProtocols(ED))
+    return true;
 
   return false;
 }
@@ -313,7 +320,7 @@ static bool hasActiveAvailableAttribute(Decl *D,
   return getActiveAvailableAttribute(D, AC);
 }
 
-static bool bodyIsResilienceBoundary(Decl *D) {
+static bool shouldConstrainBodyToDeploymentTarget(Decl *D) {
   // The declaration contains code...
   if (auto afd = dyn_cast<AbstractFunctionDecl>(D)) {
     // And it has a location so we can check it...
@@ -526,9 +533,7 @@ class TypeRefinementContextBuilder : private ASTWalker {
     AvailabilityContext DeclInfo = ExplicitDeclInfo;
     DeclInfo.intersectWith(getCurrentTRC()->getAvailabilityInfo());
 
-    // If the entire declaration is surrounded by a resilience boundary, it is
-    // also constrained by the deployment target.
-    if (signatureIsResilienceBoundary(D))
+    if (shouldConstrainSignatureToDeploymentTarget(D))
       DeclInfo.intersectWith(AvailabilityContext::forDeploymentTarget(Context));
 
     SourceRange Range = refinementSourceRangeForDecl(D);
@@ -562,9 +567,10 @@ class TypeRefinementContextBuilder : private ASTWalker {
     }
 
     // No need to introduce a context if the declaration does not have an
-    // availability attribute and the signature is not a resilience boundary.
+    // availability attribute and the signature does not constrain availability
+    // to the deployment target.
     if (!hasActiveAvailableAttribute(D, Context) &&
-        !signatureIsResilienceBoundary(D)) {
+        !shouldConstrainSignatureToDeploymentTarget(D)) {
       return false;
     }
 
@@ -581,12 +587,23 @@ class TypeRefinementContextBuilder : private ASTWalker {
     return true;
   }
 
-  /// A declaration's signature is a resilience boundary if the entire
-  /// declaration--not just the body--is not ABI-public and it's in a context
-  /// where ABI-public declarations would be available below the minimum
-  /// deployment target.
-  bool signatureIsResilienceBoundary(Decl *D) {
-    return !isCurrentTRCContainedByDeploymentTarget() && !::isExported(D);
+  /// Checks whether the entire declaration, including its signature, should be
+  /// constrained to the deployment target. Generally public API declarations
+  /// are not constrained since they appear in the interface of the module and
+  /// may be consumed by clients with lower deployment targets, but there are
+  /// some exceptions.
+  bool shouldConstrainSignatureToDeploymentTarget(Decl *D) {
+    if (isCurrentTRCContainedByDeploymentTarget())
+      return false;
+
+    // As a convenience, SPI decls and explicitly unavailable decls are
+    // constrained to the deployment target. There's not much benefit to
+    // checking these declarations at a lower availability version floor since
+    // neither can be used by API clients.
+    if (D->isSPI() || AvailableAttr::isUnavailable(D))
+      return true;
+
+    return !::isExported(D);
   }
 
   /// Returns the source range which should be refined by declaration. This
@@ -633,14 +650,14 @@ class TypeRefinementContextBuilder : private ASTWalker {
   }
 
   bool bodyIntroducesNewContext(Decl *D) {
-    // Are we already effectively in a resilience boundary? If not, adding one
-    // wouldn't change availability.
+    // Are we already constrained by the deployment target? If not, adding a
+    // new context wouldn't change availability.
     if (isCurrentTRCContainedByDeploymentTarget())
       return false;
 
-    // If we're in a function, is its body a resilience boundary?
+    // If we're in a function, check if it ought to use the deployment target.
     if (auto afd = dyn_cast<AbstractFunctionDecl>(D))
-      return bodyIsResilienceBoundary(afd);
+      return shouldConstrainBodyToDeploymentTarget(afd);
 
     // The only other case we care about is top-level code.
     return isa<TopLevelCodeDecl>(D);
@@ -4089,14 +4106,7 @@ void swift::checkExplicitAvailability(Decl *decl) {
       return false;
     });
 
-    auto protocols = extension->getLocalProtocols(ConformanceLookupKind::OnlyExplicit);
-    auto hasProtocols = std::any_of(protocols.begin(), protocols.end(),
-                                    [](const ProtocolDecl *PD) -> bool {
-      AccessScope scope =
-        PD->getFormalAccessScope(/*useDC*/nullptr,
-                                 /*treatUsableFromInlineAsPublic*/true);
-      return scope.isPublic();
-    });
+    auto hasProtocols = hasConformancesToPublicProtocols(extension);
 
     if (!hasMembers && !hasProtocols) return;
 

lib/Serialization/DeserializeSIL.cpp

@@ -1346,7 +1346,6 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
   ONEOPERAND_ONETYPE_INST(RefTo##Name) \
   ONEOPERAND_ONETYPE_INST(Name##ToRef)
 #include "swift/AST/ReferenceStorage.def"
-  ONEOPERAND_ONETYPE_INST(UncheckedRefCast)
   ONEOPERAND_ONETYPE_INST(UncheckedAddrCast)
   ONEOPERAND_ONETYPE_INST(UncheckedTrivialBitCast)
   ONEOPERAND_ONETYPE_INST(UncheckedBitwiseCast)
@@ -2670,6 +2669,17 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
         failureBB);
     break;
   }
+  case SILInstructionKind::UncheckedRefCastInst: {
+    assert(RecordKind == SIL_ONE_TYPE_ONE_OPERAND &&
+           "Layout should be OneTypeOneOperand.");
+    auto *urc = Builder.createUncheckedRefCast(Loc,
+        getLocalValue(ValID, getSILType(MF->getType(TyID2),
+                                        (SILValueCategory)TyCategory2, Fn)),
+        getSILType(MF->getType(TyID), (SILValueCategory)TyCategory, Fn));
+    urc->setForwardingOwnershipKind(decodeValueOwnership(Attr));
+    ResultInst = urc;
+    break;
+  }
   case SILInstructionKind::UncheckedRefCastAddrInst: {
     CanType sourceType = MF->getType(ListOfValues[0])->getCanonicalType();
     // ignore attr.

lib/Serialization/ModuleFormat.h

@@ -56,7 +56,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 688; // SILBoxType extensions
+const uint16_t SWIFTMODULE_VERSION_MINOR = 689; // cast ownership serialization
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///

lib/Serialization/SILFormat.h

@@ -331,7 +331,7 @@ namespace sil_block {
   using SILOneTypeOneOperandLayout = BCRecordLayout<
     SIL_ONE_TYPE_ONE_OPERAND,
     SILInstOpCodeField,
-    BCFixed<1>,          // Optional attribute
+    BCFixed<2>,          // Optional attribute
     TypeIDField,
     SILTypeCategoryField,
     TypeIDField,

lib/Serialization/SerializeSIL.cpp

@@ -1756,6 +1756,8 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
     if (SI.getKind() == SILInstructionKind::ConvertFunctionInst) {
       if (cast<ConvertFunctionInst>(SI).withoutActuallyEscaping())
         attrs |= 0x01;
+    } else if (auto *refCast = dyn_cast<UncheckedRefCastInst>(&SI)) {
+      attrs = encodeValueOwnership(refCast->getOwnershipKind());
     }
     writeConversionLikeInstruction(cast<SingleValueInstruction>(&SI), attrs);
     break;

stdlib/public/Distributed/DistributedActorSystem.swift

@@ -12,7 +12,12 @@
 import Swift
 import _Concurrency
 
-/// A distributed actor system
+/// A distributed actor system is what enables all functionality of distributed actors.
+///
+/// Distributed actors must always be associated with a concrete distributed actor system,
+/// and do so by declaring a `typealias ActorSystem = ...`, or by having a module wide
+/// `typealias DefaultDistributedActorSystem` declared which then applies to all distributed
+/// actors that do not declare a specific type alias in their bodies.
 @available(SwiftStdlib 5.7, *)
 public protocol DistributedActorSystem: Sendable {
   /// The identity used by actors that communicate via this transport