Merge pull request #4538 from swiftwasm/release/5.7

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

Author: kateinoigakukun

lib/AST/ASTPrinter.cpp

@@ -144,6 +144,7 @@ PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
       PrintOptions::FunctionRepresentationMode::Full;
   result.AlwaysTryPrintParameterLabels = true;
   result.PrintSPIs = printSPIs;
+  result.PrintExplicitAny = true;
 
   // We should print __consuming, __owned, etc for the module interface file.
   result.SkipUnderscoredKeywords = false;

lib/Demangling/Remangler.cpp

@@ -3327,7 +3327,7 @@ ManglingError Remangler::mangleOpaqueType(Node *node, unsigned depth) {
   if (trySubstitution(node, entry))
     return ManglingError::Success;
 
-  DEMANGLER_ASSERT(node->getNumChildren() >= 2, node);
+  DEMANGLER_ASSERT(node->getNumChildren() >= 3, node);
   RETURN_IF_ERROR(mangle(node->getChild(0), depth + 1));
   auto boundGenerics = node->getChild(2);
   for (unsigned i = 0; i < boundGenerics->getNumChildren(); ++i) {

lib/IDE/SwiftSourceDocInfo.cpp

@@ -310,10 +310,12 @@ static Expr *extractNameExpr(Expr *Fn) {
 
 std::pair<bool, ArgumentList *>
 NameMatcher::walkToArgumentListPre(ArgumentList *ArgList) {
-  auto Labels = getCallArgLabelRanges(getSourceMgr(), ArgList,
-                                      LabelRangeEndAt::BeforeElemStart);
-  tryResolve(Parent, ArgList->getStartLoc(), LabelRangeType::CallArg,
+  if (!ArgList->isImplicit()) {
+    auto Labels = getCallArgLabelRanges(getSourceMgr(), ArgList,
+                                        LabelRangeEndAt::BeforeElemStart);
+    tryResolve(Parent, ArgList->getStartLoc(), LabelRangeType::CallArg,
              Labels.first, Labels.second);
+  }
   if (isDone())
     return {false, ArgList};
 

lib/IRGen/GenHeap.cpp

@@ -534,6 +534,9 @@ llvm::Value *IRGenFunction::emitUnmanagedAlloc(const HeapLayout &layout,
                                                const llvm::Twine &name,
                                            llvm::Constant *captureDescriptor,
                                            const HeapNonFixedOffsets *offsets) {
+  if (layout.isKnownEmpty())
+    return IGM.RefCountedNull;
+
   llvm::Value *metadata = layout.getPrivateMetadata(IGM, captureDescriptor);
   llvm::Value *size, *alignMask;
   if (offsets) {
@@ -1505,7 +1508,10 @@ class FixedBoxTypeInfoBase : public BoxTypeInfo {
 public:
   FixedBoxTypeInfoBase(IRGenModule &IGM, HeapLayout &&layout)
     : BoxTypeInfo(IGM), layout(std::move(layout))
-  {}
+  {
+    // Empty layouts should always use EmptyBoxTypeInfo instead
+    assert(!layout.isKnownEmpty());
+  }
 
   OwnedAddress
   allocate(IRGenFunction &IGF, SILType boxedType, GenericEnvironment *env,

lib/SILGen/SILGenDistributed.cpp

@@ -64,17 +64,12 @@ static void initializeProperty(SILGenFunction &SGF, SILLocation loc,
     SGF.B.createCopyAddr(loc, value, fieldAddr, IsNotTake, IsInitialization);
   } else {
     if (value->getType().isAddress()) {
-      value = SGF.B.createTrivialLoadOr(
-          loc, value, LoadOwnershipQualifier::Take);
+      SGF.emitSemanticLoadInto(loc, value, SGF.F.getTypeLowering(value->getType()),
+          fieldAddr, SGF.getTypeLowering(loweredType), IsTake, IsInitialization);
     } else {
       value = SGF.B.emitCopyValueOperation(loc, value);
-    }
-
-    SGF.B.emitStoreValueOperation(
+      SGF.B.emitStoreValueOperation(
         loc, value, fieldAddr, StoreOwnershipQualifier::Init);
-
-    if (value->getType().isAddress()) {
-      SGF.B.createDestroyAddr(loc, value);
     }
   }
 }

lib/SILOptimizer/Transforms/AccessEnforcementWMO.cpp

@@ -164,7 +164,7 @@ class GlobalAccessRemoval {
   void perform();
 
 protected:
-  void visitInstruction(SILInstruction *I);
+  bool visitInstruction(SILInstruction *I);
   void recordAccess(SILInstruction *beginAccess, DisjointAccessLocationKey key,
                     AccessStorage::Kind storageKind, bool hasNoNestedConflict);
   void removeNonreentrantAccess();
@@ -180,27 +180,33 @@ void GlobalAccessRemoval::perform() {
       continue;
 
     for (auto &BB : F) {
-      for (auto &I : BB)
-        visitInstruction(&I);
+      for (auto &I : BB) {
+        if (!visitInstruction(&I))
+          return;
+      }
     }
   }
   removeNonreentrantAccess();
 }
 
-void GlobalAccessRemoval::visitInstruction(SILInstruction *I) {
+bool GlobalAccessRemoval::visitInstruction(SILInstruction *I) {
   if (auto *BAI = dyn_cast<BeginAccessInst>(I)) {
     auto storageAndBase = AccessStorageWithBase::compute(BAI->getSource());
+    if (!storageAndBase.base)
+      return false;
     auto key = getDisjointAccessLocation(storageAndBase);
     recordAccess(BAI, key, storageAndBase.storage.getKind(),
                  BAI->hasNoNestedConflict());
-    return;
+    return true;
   }
   if (auto *BUAI = dyn_cast<BeginUnpairedAccessInst>(I)) {
     auto storageAndBase = AccessStorageWithBase::compute(BUAI->getSource());
+    if (!storageAndBase.base)
+      return false;
     auto key = getDisjointAccessLocation(storageAndBase);
     recordAccess(BUAI, key, storageAndBase.storage.getKind(),
                  BUAI->hasNoNestedConflict());
-    return;
+    return true;
   }
   if (auto *KPI = dyn_cast<KeyPathInst>(I)) {
     for (const KeyPathPatternComponent &component :
@@ -219,8 +225,8 @@ void GlobalAccessRemoval::visitInstruction(SILInstruction *I) {
         break;
       }
     }
-    return;
   }
+  return true;
 }
 
 // Record an access in the disjointAccessMap.

lib/Sema/CSClosure.cpp

@@ -50,8 +50,32 @@ class TypeVariableRefFinder : public ASTWalker {
 
   std::pair<bool, Expr *> walkToExprPre(Expr *expr) override {
     if (auto *DRE = dyn_cast<DeclRefExpr>(expr)) {
-      if (auto type = CS.getTypeIfAvailable(DRE->getDecl()))
+      auto *decl = DRE->getDecl();
+
+      if (auto type = CS.getTypeIfAvailable(DRE->getDecl())) {
+        // If this is not one of the closure parameters which
+        // is inferrable from the body, let's replace type
+        // variables with errors to avoid bringing external
+        // information to the element component.
+        if (type->hasTypeVariable() && !isa<ParamDecl>(decl)) {
+          // If there are type variables left in the simplified version,
+          // it means that this is an invalid external declaration
+          // relative to this element's context.
+          if (CS.simplifyType(type)->hasTypeVariable()) {
+            auto transformedTy = type.transform([&](Type type) {
+              if (auto *typeVar = type->getAs<TypeVariableType>()) {
+                return ErrorType::get(CS.getASTContext());
+              }
+              return type;
+            });
+
+            CS.setType(decl, transformedTy);
+            return {true, expr};
+          }
+        }
+
         inferVariables(type);
+      }
     }
 
     return {true, expr};

lib/Sema/CSStep.h

@@ -781,6 +781,9 @@ class ConjunctionStep : public BindingStep<ConjunctionElementProducer> {
   class SolverSnapshot {
     ConstraintSystem &CS;
 
+    /// The conjunction this snapshot belongs to.
+    Constraint *Conjunction;
+
     Optional<llvm::SaveAndRestore<DeclContext *>> DC = None;
 
     llvm::SetVector<TypeVariableType *> TypeVars;
@@ -794,8 +797,9 @@ class ConjunctionStep : public BindingStep<ConjunctionElementProducer> {
 
   public:
     SolverSnapshot(ConstraintSystem &cs, Constraint *conjunction)
-        : CS(cs), TypeVars(std::move(cs.TypeVariables)) {
-      auto *locator = conjunction->getLocator();
+        : CS(cs), Conjunction(conjunction),
+          TypeVars(std::move(cs.TypeVariables)) {
+      auto *locator = Conjunction->getLocator();
       // If this conjunction represents a closure, we need to
       // switch declaration context over to it.
       if (locator->directlyAt<ClosureExpr>()) {
@@ -820,7 +824,7 @@ class ConjunctionStep : public BindingStep<ConjunctionElementProducer> {
       IsolationScope = std::make_unique<Scope>(CS);
 
       // Apply solution inferred for the conjunction.
-      CS.applySolution(solution);
+      applySolution(solution);
 
       // Add constraints to the graph after solution
       // has been applied to make sure that all type
@@ -855,6 +859,36 @@ class ConjunctionStep : public BindingStep<ConjunctionElementProducer> {
       for (auto &constraint : CS.InactiveConstraints)
         CG.addConstraint(&constraint);
     }
+
+    void applySolution(const Solution &solution) {
+      CS.applySolution(solution);
+
+      if (!CS.shouldAttemptFixes())
+        return;
+
+      // If inference succeeded, we are done.
+      auto score = solution.getFixedScore();
+      if (score.Data[SK_Fix] == 0)
+        return;
+
+      // If this conjunction represents a closure and inference
+      // has failed, let's bind all of unresolved type variables
+      // in its interface type to holes to avoid extraneous
+      // fixes produced by outer context.
+
+      auto locator = Conjunction->getLocator();
+      if (locator->directlyAt<ClosureExpr>()) {
+        auto closureTy =
+            CS.getClosureType(castToExpr<ClosureExpr>(locator->getAnchor()));
+
+        CS.simplifyType(closureTy).visit([&](Type componentTy) {
+          if (auto *typeVar = componentTy->getAs<TypeVariableType>()) {
+            CS.assignFixedType(
+                typeVar, PlaceholderType::get(CS.getASTContext(), typeVar));
+          }
+        });
+      }
+    }
   };
 
   /// Best solution solver reached so far.

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,14 +426,12 @@ 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
+  // nonisolated let id: Self.ID // Self.ActorSystem.ActorID
   // ```
   auto propertyType = getDistributedActorIDType(derived.Nominal);
 
@@ -448,7 +446,8 @@ static ValueDecl *deriveDistributedActor_id(DerivedConformance &derived) {
   propDecl->getAttrs().add(
       new (C) NonisolatedAttr(/*IsImplicit=*/true));
 
-  derived.addMembersToConformanceContext({ propDecl, pbDecl });
+  derived.addMemberToConformanceContext(pbDecl, /*insertAtHead=*/true);
+  derived.addMemberToConformanceContext(propDecl, /*insertAtHead=*/true);
   return propDecl;
 }
 
@@ -460,8 +459,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 +475,17 @@ 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();
+  assert(id && "id must be synthesized first, so it is the first field of any "
+               "distributed actor (followed by actorSystem)");
+
+  derived.addMemberToConformanceContext(pbDecl, /*hint=*/id);
+  derived.addMemberToConformanceContext(propDecl, /*hint=*/id);
+
   return propDecl;
 }