Merge pull request #4394 from swiftwasm/release/5.6

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

Author: MaxDesiatov

include/swift/ABI/TaskStatus.h

@@ -164,14 +164,21 @@ class ChildTaskStatusRecord : public TaskStatusRecord {
 /// and are only tracked by their respective `TaskGroupTaskStatusRecord`.
 class TaskGroupTaskStatusRecord : public TaskStatusRecord {
   AsyncTask *FirstChild;
+  AsyncTask *LastChild;
 
 public:
   TaskGroupTaskStatusRecord()
-      : TaskStatusRecord(TaskStatusRecordKind::TaskGroup), FirstChild(nullptr) {
+      : TaskStatusRecord(TaskStatusRecordKind::TaskGroup),
+        FirstChild(nullptr),
+        LastChild(nullptr) {
   }
 
   TaskGroupTaskStatusRecord(AsyncTask *child)
-      : TaskStatusRecord(TaskStatusRecordKind::TaskGroup), FirstChild(child) {}
+      : TaskStatusRecord(TaskStatusRecordKind::TaskGroup),
+        FirstChild(child),
+        LastChild(child) {
+    assert(!LastChild || !LastChild->childFragment()->getNextChild());
+  }
 
   TaskGroup *getGroup() { return reinterpret_cast<TaskGroup *>(this); }
 
@@ -185,38 +192,28 @@ class TaskGroupTaskStatusRecord : public TaskStatusRecord {
     assert(child->hasGroupChildFragment());
     assert(child->groupChildFragment()->getGroup() == getGroup());
 
+    auto oldLastChild = LastChild;
+    LastChild = child;
+    
     if (!FirstChild) {
       // This is the first child we ever attach, so store it as FirstChild.
       FirstChild = child;
       return;
     }
 
-    // We need to traverse the siblings to find the last one and add the child
-    // there.
-    // FIXME: just set prepend to the current head, no need to traverse.
-
-    auto cur = FirstChild;
-    while (cur) {
-      // no need to check hasChildFragment, all tasks we store here have them.
-      auto fragment = cur->childFragment();
-      if (auto next = fragment->getNextChild()) {
-        cur = next;
-      } else {
-        // we're done searching and `cur` is the last
-        break;
-      }
-    }
-
-    cur->childFragment()->setNextChild(child);
+    oldLastChild->childFragment()->setNextChild(child);
   }
 
   void detachChild(AsyncTask *child) {
     assert(child && "cannot remove a null child from group");
     if (FirstChild == child) {
       FirstChild = getNextChildTask(child);
+      if (FirstChild == nullptr) {
+        LastChild = nullptr;
+      }
       return;
     }
-
+    
     AsyncTask *prev = FirstChild;
     // Remove the child from the linked list, i.e.:
     //     prev -> afterPrev -> afterChild
@@ -230,6 +227,9 @@ class TaskGroupTaskStatusRecord : public TaskStatusRecord {
       if (afterPrev == child) {
         auto afterChild = getNextChildTask(child);
         prev->childFragment()->setNextChild(afterChild);
+        if (child == LastChild) {
+          LastChild = prev;
+        }
         return;
       }
 

include/swift/AST/ActorIsolation.h

@@ -109,6 +109,20 @@ class ActorIsolation {
 
   bool isIndependent() const { return kind == Independent; }
 
+  bool isActorIsolated() const {
+    switch (getKind()) {
+    case ActorInstance:
+    case DistributedActorInstance:
+    case GlobalActor:
+    case GlobalActorUnsafe:
+      return true;
+
+    case Unspecified:
+    case Independent:
+      return false;
+    }
+  }
+
   NominalTypeDecl *getActor() const {
     assert(getKind() == ActorInstance || getKind() == DistributedActorInstance);
     return actor;

include/swift/AST/DiagnosticsSema.def

@@ -4475,10 +4475,6 @@ ERROR(global_actor_from_nonactor_context,none,
       "%0 %1 isolated to global actor %2 can not be %select{referenced|mutated|used 'inout'}4"
       " from %select{this|a non-isolated}3%select{| synchronous}5 context",
       (DescriptiveDeclKind, DeclName, Type, bool, unsigned, bool))
-ERROR(global_actor_from_initializing_expr,none,
-      "expression requiring global actor %0 cannot appear in "
-        "default-value expression of %1 %2",
-      (Type, DescriptiveDeclKind, DeclName))
 ERROR(actor_isolated_call,none,
       "call to %0 function in a synchronous %1 context",
       (ActorIsolation, ActorIsolation))

lib/AST/Decl.cpp

@@ -8667,24 +8667,9 @@ ActorIsolation swift::getActorIsolationOfContext(DeclContext *dc) {
   if (auto *vd = dyn_cast_or_null<ValueDecl>(dc->getAsDecl()))
     return getActorIsolation(vd);
 
-  // In the context of the initializing or default-value expression of a
-  // stored property, the isolation varies between global and type members:
-  //   - For a static stored property, the isolation matches the VarDecl.
-  //   - For a field of a nominal type, the expression is not isolated.
-  // Without this distinction, a nominal can have non-async initializers
-  // with various kinds of isolation, so an impossible constraint can be
-  // created. See SE-0327 for details.
-  if (auto *var = dc->getNonLocalVarDecl()) {
-
-    // Isolation officially changes, as described above, in Swift 6+
-    if (dc->getASTContext().isSwiftVersionAtLeast(6) &&
-        var->isInstanceMember() &&
-        !var->getAttrs().hasAttribute<LazyAttr>()) {
-      return ActorIsolation::forUnspecified();
-    }
-
+  if (auto *var = dc->getNonLocalVarDecl())
      return getActorIsolation(var);
-  }
+
 
   if (auto *closure = dyn_cast<AbstractClosureExpr>(dc)) {
     switch (auto isolation = closure->getActorIsolation()) {

lib/AST/GenericSignatureBuilder.cpp

@@ -3988,8 +3988,16 @@ ConstraintResult GenericSignatureBuilder::expandConformanceRequirement(
                                             ProtocolDecl *proto,
                                             const RequirementSource *source,
                                             bool onlySameTypeConstraints) {
-  auto protocolSubMap = SubstitutionMap::getProtocolSubstitutions(
-      proto, selfType.getDependentType(*this), ProtocolConformanceRef(proto));
+  auto selfTy = selfType.getDependentType(*this);
+
+  auto subst = [&](Requirement req) -> Optional<Requirement> {
+    return req.subst(
+        [&](SubstitutableType *t) -> Type {
+          assert(isa<GenericTypeParamType>(t));
+          return selfTy;
+        },
+        MakeAbstractConformanceForGenericType());
+  };
 
   // Use the requirement signature to avoid rewalking the entire protocol.  This
   // cannot compute the requirement signature directly, because that may be
@@ -4003,7 +4011,7 @@ ConstraintResult GenericSignatureBuilder::expandConformanceRequirement(
       if (onlySameTypeConstraints && req.getKind() != RequirementKind::SameType)
         continue;
 
-      auto substReq = req.subst(protocolSubMap);
+      auto substReq = subst(req);
       auto reqResult = substReq
                            ? addRequirement(*substReq, innerSource, nullptr)
                            : ConstraintResult::Conflicting;
@@ -4032,8 +4040,9 @@ ConstraintResult GenericSignatureBuilder::expandConformanceRequirement(
 
         auto innerSource = FloatingRequirementSource::viaProtocolRequirement(
             source, proto, reqRepr->getSeparatorLoc(), /*inferred=*/false);
-        addRequirement(req, reqRepr, innerSource,
-                       &protocolSubMap, nullptr);
+
+        if (auto substReq = subst(req))
+          addRequirement(*substReq, reqRepr, innerSource, nullptr);
         return false;
       });
 
@@ -4146,7 +4155,7 @@ ConstraintResult GenericSignatureBuilder::expandConformanceRequirement(
                     source, proto, SourceLoc(), /*inferred=*/true);
 
     auto rawReq = Requirement(RequirementKind::SameType, firstType, secondType);
-    if (auto req = rawReq.subst(protocolSubMap))
+    if (auto req = subst(rawReq))
       addRequirement(*req, inferredSameTypeSource, proto->getParentModule());
   };
 
@@ -4174,8 +4183,10 @@ ConstraintResult GenericSignatureBuilder::expandConformanceRequirement(
 
           auto innerSource = FloatingRequirementSource::viaProtocolRequirement(
               source, proto, reqRepr->getSeparatorLoc(), /*inferred=*/false);
-          addRequirement(req, reqRepr, innerSource, &protocolSubMap,
-                         /*inferForModule=*/nullptr);
+          if (auto substReq = subst(req)) {
+            addRequirement(*substReq, reqRepr, innerSource,
+                           /*inferForModule=*/nullptr);
+          }
           return false;
         });
 
@@ -5160,28 +5171,19 @@ ConstraintResult
 GenericSignatureBuilder::addRequirement(const Requirement &req,
                                         FloatingRequirementSource source,
                                         ModuleDecl *inferForModule) {
-  return addRequirement(req, nullptr, source, nullptr, inferForModule);
+  return addRequirement(req, nullptr, source, inferForModule);
 }
 
 ConstraintResult
 GenericSignatureBuilder::addRequirement(const Requirement &req,
                                         const RequirementRepr *reqRepr,
                                         FloatingRequirementSource source,
-                                        const SubstitutionMap *subMap,
                                         ModuleDecl *inferForModule) {
-  // Local substitution for types in the requirement.
-  auto subst = [&](Type t) {
-    if (subMap)
-      return t.subst(*subMap);
-
-    return t;
-  };
-
-  auto firstType = subst(req.getFirstType());
+  auto firstType = req.getFirstType();
   switch (req.getKind()) {
   case RequirementKind::Superclass:
   case RequirementKind::Conformance: {
-    auto secondType = subst(req.getSecondType());
+    auto secondType = req.getSecondType();
 
     if (inferForModule) {
       inferRequirements(*inferForModule, firstType,
@@ -5209,7 +5211,7 @@ GenericSignatureBuilder::addRequirement(const Requirement &req,
   }
 
   case RequirementKind::SameType: {
-    auto secondType = subst(req.getSecondType());
+    auto secondType = req.getSecondType();
 
     if (inferForModule) {
       inferRequirements(*inferForModule, firstType,
@@ -8697,8 +8699,8 @@ InferredGenericSignatureRequest::evaluate(
         }
       }
 
-      builder.addRequirement(req, reqRepr, source, nullptr,
-                              lookupDC->getParentModule());
+      builder.addRequirement(req, reqRepr, source,
+                             lookupDC->getParentModule());
       return false;
     };
 

lib/AST/GenericSignatureBuilder.h

@@ -570,7 +570,6 @@ class GenericSignatureBuilder {
   ConstraintResult addRequirement(const Requirement &req,
                                   const RequirementRepr *reqRepr,
                                   FloatingRequirementSource source,
-                                  const SubstitutionMap *subMap,
                                   ModuleDecl *inferForModule);
 
   /// Add all of a generic signature's parameters and requirements.

lib/AST/RequirementMachine/PropertyUnification.cpp

@@ -491,9 +491,9 @@ void PropertyMap::concretizeNestedTypesFromConcreteParent(
       continue;
     }
 
-    // FIXME: Maybe this can happen if the concrete type is an
-    // opaque result type?
-    assert(!conformance.isAbstract());
+    // This can happen if the concrete type is an opaque result type.
+    if (conformance.isAbstract())
+      continue;
 
     auto *concrete = conformance.getConcrete();
 

lib/AST/TypeRepr.cpp

@@ -183,6 +183,8 @@ void AttributedTypeRepr::printAttrs(ASTPrinter &Printer,
     Printer.printSimpleAttr("@autoclosure") << " ";
   if (hasAttr(TAK_escaping))
     Printer.printSimpleAttr("@escaping") << " ";
+  if (hasAttr(TAK_Sendable))
+    Printer.printSimpleAttr("@Sendable") << " ";
   if (hasAttr(TAK_noDerivative))
     Printer.printSimpleAttr("@noDerivative") << " ";
 

lib/IRGen/MetadataRequest.cpp

@@ -1670,8 +1670,12 @@ namespace {
       }
 
       auto layout = type.getExistentialLayout();
-      
-      auto protocols = layout.getProtocols();
+
+      SmallVector<ProtocolType *, 4> protocols;
+      for (auto proto : layout.getProtocols()) {
+        if (!proto->getDecl()->isMarkerProtocol())
+          protocols.push_back(proto);
+      }
 
       // Collect references to the protocol descriptors.
       auto descriptorArrayTy

lib/SILGen/SILGenProlog.cpp

@@ -314,7 +314,7 @@ struct ArgumentInitHelper {
     assert(type->isMaterializable());
 
     ++ArgNo;
-    if (PD->hasName()) {
+    if (PD->hasName() || PD->isIsolated()) {
       makeArgumentIntoBinding(type, &*f.begin(), PD);
       return;
     }