Merge remote-tracking branch 'apple/main' into swiftwasm

Author: kateinoigakukun

docs/AndroidBuild.md

@@ -34,7 +34,7 @@ git clone https://github.com/apple/swift-corelibs-xctest swift-corelibs-xctest
 git clone https://github.com/compnerd/swift-build swift-build
 ```
 
-## 1. Acquire the lastest toolchain and dependencies
+## 1. Acquire the latest toolchain and dependencies
 
 1. Download the toolchain, ICU, libxml2, and curl for android from
    [Azure](https://dev.azure.com/compnerd/swift-build) into `S:\b\a\Library`.

docs/CppInteroperability/CppInteroperabilityManifesto.md

@@ -500,7 +500,7 @@ accepts an address.
 
 C++ has complex overload resolution rules, in part to support certain API design
 patterns. Some API design patterns appeared as a consequence of overload
-resolution rules. Therefore, in C++ an "API atom" is an an overload set, not an
+resolution rules. Therefore, in C++ an "API atom" is an overload set, not an
 individual function ([CppCon 2018: Titus Winters "Modern C++ Design (part 1 of
 2)"](https://www.youtube.com/watch?v=xTdeZ4MxbKo)). The same is also the case in
 Swift, so, fundamentally, there is no impedance mismatch here.
@@ -938,7 +938,7 @@ be handled in Swift.
 
 While it is possible to [propagate C++ exceptions](#exceptions) thrown by normal
 member functions to Swift code, special member functions are different as they
-used used to implement value witnesses, which are called by the compiler
+used to implement value witnesses, which are called by the compiler
 implicitly. Therefore, either such exceptions have to be mapped to fatal errors
 (as we do for other unhandled C++ exceptions), or calls to such special member
 functions must be prevented statically.
@@ -2337,7 +2337,7 @@ different APIs across specializations of the same class. All instantiations of a
 generic type in Swift have the API described in the generic declaration (with
 type parameters substituted), plus applicable conditional extensions.
 
-C++ templates support non-type template parameters, template template
+C++ templates support non-type template parameters, template
 parameters, and parameter packs (variadic generics), all of which are not
 supported in Swift.
 

docs/CppInteroperability/InteropOddities.md

@@ -1,23 +1,23 @@
 # C++ Interoperability Oddities
 
-C++ APIs may have slightly different behavior than other C++ APIs. This is a general catch-all document where these 
+C++ APIs may have slightly different behavior than other C++ APIs. This is a general catch-all document where these
 oddities are recorded along with a few other things that are good to know when using C++ interop.
 
 **Parameters with reference types**
 
-Parameters that have mutable reference types are bridged as inout. Parameters with immutable reference types (const ref) 
-are bridged as value types. ⚠️ This will change as soon as Swift has a way to represent immutable borrows. ⚠️ 
+Parameters that have mutable reference types are bridged as inout. Parameters with immutable reference types (const ref)
+are bridged as value types. ⚠️ This will change as soon as Swift has a way to represent immutable borrows. ⚠️
 
 **Lifetimes**
 
-Currently, lifetimes are extended to the end of the lexical scope if any unsafe pointers are used in that scope. TODO: 
-this should be updated to extend lifetimes whenever a C++ type is used in that scope. Currently, if there is no 
-unsafe pointer used in the scope, then normal Swift lifetime rules apply.   
+Currently, lifetimes are extended to the end of the lexical scope if any unsafe pointers are used in that scope. TODO:
+this should be updated to extend lifetimes whenever a C++ type is used in that scope. Currently, if there is no
+unsafe pointer used in the scope, then normal Swift lifetime rules apply.
 
 **Borrowing Self**
 
-For mutating methods, self is borrowed and the access to self lasts for the duration of the call. For non-mutating 
-methods, the access to self is currently instantanious. ⚠️ In the very near future we plan to borrow self in both cases. 
+For mutating methods, self is borrowed and the access to self lasts for the duration of the call. For non-mutating
+methods, the access to self is currently instantaneous. ⚠️ In the very near future we plan to borrow self in both cases.
 This will be a source breaking change from what native Swift methods do. ⚠️
 
-_More to come soon :)_
+_More to come soon :)_

docs/SILMemoryAccess.md

@@ -293,7 +293,7 @@ scope:
 end_access %access : $*S
 ```
 
-Note that is is possible to have a nested access scope on the address
+Note that it is possible to have a nested access scope on the address
 of a struct field, which may show up as an access of
 struct_element_addr after inlining. The rule is that access
 projections cannot occur outside of the outermost access scope within
@@ -396,7 +396,7 @@ instructions may reference the same variable. To find all global uses,
 the client must independently find all global variable references
 within the function. Clients that need to know which SILValue base was
 discovered during use-def traversal in all cases can make use of
-`AccessStorageWithBase` or `AccessPathWithBase`. 
+`AccessStorageWithBase` or `AccessPathWithBase`.
 
 ### AccessPath
 

include/swift/AST/TypeRefinementContext.h

@@ -58,11 +58,11 @@ class TypeRefinementContext : public ASTAllocated<TypeRefinementContext> {
     /// function declaration or the contents of a class declaration).
     Decl,
 
-    /// The context was introduced by a resilience boundary; that is, we are in
+    /// The context was introduced by an API boundary; that is, we are in
     /// a module with library evolution enabled and the parent context's
     /// contents can be visible to the module's clients, but this context's
     /// contents are not.
-    ResilienceBoundary,
+    APIBoundary,
 
     /// The context was introduced for the Then branch of an IfStmt.
     IfStmtThenBranch,
@@ -131,8 +131,7 @@ class TypeRefinementContext : public ASTAllocated<TypeRefinementContext> {
     }
 
     Decl *getAsDecl() const {
-      assert(IntroReason == Reason::Decl ||
-             IntroReason == Reason::ResilienceBoundary);
+      assert(IntroReason == Reason::Decl || IntroReason == Reason::APIBoundary);
       return D;
     }
 
@@ -195,10 +194,8 @@ class TypeRefinementContext : public ASTAllocated<TypeRefinementContext> {
 
   /// Create a refinement context for the given declaration.
   static TypeRefinementContext *
-  createForResilienceBoundary(ASTContext &Ctx, Decl *D,
-                              TypeRefinementContext *Parent,
-                              const AvailabilityContext &Info,
-                              SourceRange SrcRange);
+  createForAPIBoundary(ASTContext &Ctx, Decl *D, TypeRefinementContext *Parent,
+                       const AvailabilityContext &Info, SourceRange SrcRange);
 
   /// Create a refinement context for the Then branch of the given IfStmt.
   static TypeRefinementContext *

lib/AST/DistributedDecl.cpp

@@ -472,6 +472,7 @@ 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/AST/TypeRefinementContext.cpp

@@ -64,18 +64,14 @@ TypeRefinementContext::createForDecl(ASTContext &Ctx, Decl *D,
       TypeRefinementContext(Ctx, D, Parent, SrcRange, Info, ExplicitInfo);
 }
 
-TypeRefinementContext *
-TypeRefinementContext::createForResilienceBoundary(ASTContext &Ctx, Decl *D,
-                                TypeRefinementContext *Parent,
-                                const AvailabilityContext &Info,
-                                SourceRange SrcRange) {
+TypeRefinementContext *TypeRefinementContext::createForAPIBoundary(
+    ASTContext &Ctx, Decl *D, TypeRefinementContext *Parent,
+    const AvailabilityContext &Info, SourceRange SrcRange) {
   assert(D);
   assert(Parent);
-  return new (Ctx)
-      TypeRefinementContext(Ctx, IntroNode(D, Reason::ResilienceBoundary),
-                            Parent, SrcRange, Info,
-                            AvailabilityContext::alwaysAvailable());
-
+  return new (Ctx) TypeRefinementContext(
+      Ctx, IntroNode(D, Reason::APIBoundary), Parent, SrcRange, Info,
+      AvailabilityContext::alwaysAvailable());
 }
 
 TypeRefinementContext *
@@ -184,7 +180,7 @@ void TypeRefinementContext::dump(raw_ostream &OS, SourceManager &SrcMgr) const {
 SourceLoc TypeRefinementContext::getIntroductionLoc() const {
   switch (getReason()) {
   case Reason::Decl:
-  case Reason::ResilienceBoundary:
+  case Reason::APIBoundary:
     return Node.getAsDecl()->getLoc();
 
   case Reason::IfStmtThenBranch:
@@ -298,7 +294,7 @@ TypeRefinementContext::getAvailabilityConditionVersionSourceRange(
       Node.getAsWhileStmt()->getCond(), Platform, Version);
 
   case Reason::Root:
-  case Reason::ResilienceBoundary:
+  case Reason::APIBoundary:
     return SourceRange();
   }
 
@@ -312,8 +308,7 @@ void TypeRefinementContext::print(raw_ostream &OS, SourceManager &SrcMgr,
 
   OS << " versions=" << AvailabilityInfo.getOSVersion().getAsString();
 
-  if (getReason() == Reason::Decl
-      || getReason() == Reason::ResilienceBoundary) {
+  if (getReason() == Reason::Decl || getReason() == Reason::APIBoundary) {
     Decl *D = Node.getAsDecl();
     OS << " decl=";
     if (auto VD = dyn_cast<ValueDecl>(D)) {
@@ -355,8 +350,8 @@ StringRef TypeRefinementContext::getReasonName(Reason R) {
   case Reason::Decl:
     return "decl";
 
-  case Reason::ResilienceBoundary:
-    return "resilience_boundary";
+  case Reason::APIBoundary:
+    return "api_boundary";
 
   case Reason::IfStmtThenBranch:
     return "if_then";

lib/Sema/CodeSynthesisDistributedActor.cpp

@@ -117,9 +117,17 @@ static VarDecl *addImplicitDistributedActorIDProperty(
   propDecl->getAttrs().add(
       new (C) CompilerInitializedAttr(/*IsImplicit=*/true));
 
-  nominal->addMember(propDecl);
-  nominal->addMember(pbDecl);
-
+  // IMPORTANT: The `id` MUST be the first field of any distributed actor,
+  // because when we allocate remote proxy instances, we don't allocate memory
+  // for anything except the first two fields: id and actorSystem, so they
+  // MUST be those fields.
+  //
+  // Their specific order also matters, because it is enforced this way in IRGen
+  // and how we emit them in AST MUST match what IRGen expects or cross-module
+  // things could be using wrong offsets and manifest as reading trash memory on
+  // id or system accesses.
+  nominal->addMember(propDecl, /*hint=*/nullptr, /*insertAtHead=*/true);
+  nominal->addMember(pbDecl, /*hint=*/nullptr, /*insertAtHead=*/true);
   return propDecl;
 }
 

lib/Sema/DerivedConformanceDistributedActor.cpp

@@ -426,32 +426,6 @@ static FuncDecl *deriveDistributedActorSystem_invokeHandlerOnReturn(
 /******************************* PROPERTIES ***********************************/
 /******************************************************************************/
 
-// TODO(distributed): make use of this after all, but FORCE it?
-static ValueDecl *deriveDistributedActor_id(DerivedConformance &derived) {
-  assert(derived.Nominal->isDistributedActor());
-  auto &C = derived.Context;
-
-  // ```
-  // nonisolated
-  // let id: Self.ID // Self.ActorSystem.ActorID
-  // ```
-  auto propertyType = getDistributedActorIDType(derived.Nominal);
-
-  VarDecl *propDecl;
-  PatternBindingDecl *pbDecl;
-  std::tie(propDecl, pbDecl) = derived.declareDerivedProperty(
-      DerivedConformance::SynthesizedIntroducer::Let, C.Id_id, propertyType,
-      propertyType,
-      /*isStatic=*/false, /*isFinal=*/true);
-
-  // mark as nonisolated, allowing access to it from everywhere
-  propDecl->getAttrs().add(
-      new (C) NonisolatedAttr(/*IsImplicit=*/true));
-
-  derived.addMembersToConformanceContext({ propDecl, pbDecl });
-  return propDecl;
-}
-
 static ValueDecl *deriveDistributedActor_actorSystem(
     DerivedConformance &derived) {
   auto &C = derived.Context;
@@ -460,8 +434,7 @@ static ValueDecl *deriveDistributedActor_actorSystem(
   assert(classDecl && derived.Nominal->isDistributedActor());
 
   // ```
-  // nonisolated
-  // let actorSystem: ActorSystem
+  // nonisolated let actorSystem: ActorSystem
   // ```
   // (no need for @actorIndependent because it is an immutable let)
   auto propertyType = getDistributedActorSystemType(classDecl);
@@ -477,7 +450,14 @@ static ValueDecl *deriveDistributedActor_actorSystem(
   propDecl->getAttrs().add(
       new (C) NonisolatedAttr(/*IsImplicit=*/true));
 
-  derived.addMembersToConformanceContext({ propDecl, pbDecl });
+  // IMPORTANT: `id` MUST be the first field of a distributed actor, and
+  // `actorSystem` MUST be the second field, because for a remote instance
+  // we don't allocate memory after those two fields, so their order is very
+  // important. The `hint` below makes sure the system is inserted right after.
+  auto id = derived.Nominal->getDistributedActorIDProperty();
+  derived.addMemberToConformanceContext(pbDecl, /*hint=*/id);
+  derived.addMemberToConformanceContext(propDecl, /*hint=*/id);
+
   return propDecl;
 }
 
@@ -571,11 +551,14 @@ deriveDistributedActorType_SerializationRequirement(
 
 ValueDecl *DerivedConformance::deriveDistributedActor(ValueDecl *requirement) {
   if (auto var = dyn_cast<VarDecl>(requirement)) {
-    if (var->getName() == Context.Id_id)
-      return deriveDistributedActor_id(*this);
-
     if (var->getName() == Context.Id_actorSystem)
       return deriveDistributedActor_actorSystem(*this);
+
+    if (var->getName() == Context.Id_id)
+      llvm_unreachable("DistributedActor.id MUST be synthesized earlier, "
+                       "because it is forced by the Identifiable conformance. "
+                       "If we attempted to do synthesis here, the earlier phase "
+                       "failed and something is wrong: please report a bug.");
   }
 
   if (auto func = dyn_cast<FuncDecl>(requirement)) {

lib/Sema/DerivedConformances.cpp

@@ -51,6 +51,18 @@ void DerivedConformance::addMembersToConformanceContext(
     IDC->addMember(child);
 }
 
+void DerivedConformance::addMemberToConformanceContext(
+    Decl *member, Decl *hint) {
+  auto IDC = cast<IterableDeclContext>(ConformanceDecl);
+  IDC->addMember(member, hint, /*insertAtHead=*/false);
+}
+
+void DerivedConformance::addMemberToConformanceContext(
+    Decl *member, bool insertAtHead) {
+  auto IDC = cast<IterableDeclContext>(ConformanceDecl);
+  IDC->addMember(member, /*hint=*/nullptr, insertAtHead);
+}
+
 Type DerivedConformance::getProtocolType() const {
   return Protocol->getDeclaredInterfaceType();
 }
@@ -325,10 +337,6 @@ ValueDecl *DerivedConformance::getDerivableRequirement(NominalTypeDecl *nominal,
     if (name.isSimpleName(ctx.Id_unownedExecutor))
       return getRequirement(KnownProtocolKind::Actor);
 
-    // DistributedActor.id
-    if(name.isSimpleName(ctx.Id_id))
-      return getRequirement(KnownProtocolKind::DistributedActor);
-
     // DistributedActor.actorSystem
     if(name.isSimpleName(ctx.Id_actorSystem))
       return getRequirement(KnownProtocolKind::DistributedActor);