Merge pull request swiftlang#4672 from swiftwasm/release/5.7

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

Author: kateinoigakukun

docs/ABI/Mangling.rst

@@ -102,6 +102,11 @@ The following symbolic reference kinds are currently implemented:
      metadata-access-function ::= '\x09' .{4}  // Reference points directly to metadata access function that can be invoked to produce referenced object
    #endif
 
+   #if SWIFT_RUNTIME_VERISON >= 5.7
+     symbolic-extended-existential-type-shape ::= '\x0A' .{4} // Reference points directly to an ExtendedExistentialTypeShape
+     symbolic-extended-existential-type-shape ::= '\x0B' .{4} // Reference points directly to a NonUniqueExtendedExistentialTypeShape
+   #endif
+
 A mangled name may also include ``\xFF`` bytes, which are only used for
 alignment padding. They do not affect what the mangled name references and can
 be skipped over and ignored.
@@ -637,7 +642,7 @@ Types
   type ::= protocol-list 'p'                 // existential type
   type ::= protocol-list superclass 'Xc'     // existential type with superclass
   type ::= protocol-list 'Xl'                // existential type with AnyObject
-  type ::= protocol-list 'y' (type* '_')* type* retroactive-conformance* 'XP'   // parameterized protocol type
+  type ::= protocol-list requirement* '_' 'XP'   // constrained existential type
   type ::= type-list 't'                     // tuple
   type ::= type generic-signature 'u'        // generic type
   type ::= 'x'                               // generic param, depth=0, idx=0
@@ -653,6 +658,10 @@ Types
     type ::= type assoc-type-list 'QX' // associated type relative to base `type`
   #endif
 
+  #if SWIFT_RUNTIME_VERSION >= 5.7
+    type ::= symbolic-extended-existential-type-shape type* retroactive-conformance* 'Xj'
+  #endif
+
   protocol-list ::= protocol '_' protocol*
   protocol-list ::= empty-list
 
@@ -878,6 +887,7 @@ now codified into the ABI; the index 0 is therefore reserved.
   GENERIC-PARAM-INDEX ::= 'z'                // depth = 0,   idx = 0
   GENERIC-PARAM-INDEX ::= INDEX              // depth = 0,   idx = N+1
   GENERIC-PARAM-INDEX ::= 'd' INDEX INDEX    // depth = M+1, idx = N
+  GENERIC-PARAM-INDEX ::= 's'                // depth = 0,   idx = 0; Constrained existential 'Self' type
 
   LAYOUT-CONSTRAINT ::= 'N'  // NativeRefCountedObject
   LAYOUT-CONSTRAINT ::= 'R'  // RefCountedObject

include/swift/AST/ASTDemangler.h

@@ -119,7 +119,11 @@ class ASTBuilder {
 
   Type createProtocolTypeFromDecl(ProtocolDecl *protocol);
 
-  Type createParameterizedProtocolType(Type base, ArrayRef<Type> args);
+  Type createConstrainedExistentialType(Type base,
+                                        ArrayRef<BuiltRequirement> constraints);
+
+  Type createSymbolicExtendedExistentialType(NodePointer shapeNode,
+                                             ArrayRef<Type> genArgs);
 
   Type createExistentialMetatypeType(Type instance,
                      Optional<Demangle::ImplMetatypeRepresentation> repr=None);

include/swift/AST/ASTMangler.h

@@ -16,6 +16,7 @@
 #include "swift/Basic/Mangler.h"
 #include "swift/AST/Types.h"
 #include "swift/AST/Decl.h"
+#include "swift/Basic/TaggedUnion.h"
 
 namespace clang {
 class NamedDecl;
@@ -79,8 +80,50 @@ class ASTMangler : public Mangler {
   bool RespectOriginallyDefinedIn = true;
 
 public:
-  using SymbolicReferent = llvm::PointerUnion<const NominalTypeDecl *,
-                                              const OpaqueTypeDecl *>;
+  class SymbolicReferent {
+  public:
+    enum Kind {
+      NominalType,
+      OpaqueType,
+      ExtendedExistentialTypeShape,
+    };
+  private:
+    // TODO: make a TaggedUnion variant that works with an explicit
+    // kind instead of requiring this redundant kind storage.
+    TaggedUnion<const NominalTypeDecl *,
+                const OpaqueTypeDecl *,
+                Type>
+      storage;
+    Kind kind;
+
+    SymbolicReferent(Kind kind, Type type) : storage(type), kind(kind) {}
+  public:
+    SymbolicReferent(const NominalTypeDecl *decl)
+       : storage(decl), kind(NominalType) {}
+    SymbolicReferent(const OpaqueTypeDecl *decl)
+       : storage(decl), kind(OpaqueType) {}
+    static SymbolicReferent forExtendedExistentialTypeShape(Type type) {
+      return SymbolicReferent(ExtendedExistentialTypeShape, type);
+    }
+
+    Kind getKind() const { return kind; }
+
+    bool isNominalType() const { return kind == NominalType; }
+    const NominalTypeDecl *getNominalType() const {
+      assert(kind == NominalType);
+      return storage.get<const NominalTypeDecl *>();
+    }
+
+    const OpaqueTypeDecl *getOpaqueType() const {
+      assert(kind == OpaqueType);
+      return storage.get<const OpaqueTypeDecl *>();
+    }
+
+    Type getType() const {
+      assert(kind == ExtendedExistentialTypeShape);
+      return storage.get<Type>();
+    }
+  };
 protected:
 
   /// If set, the mangler calls this function to determine whether to symbolic
@@ -90,8 +133,8 @@ class ASTMangler : public Mangler {
 
   bool canSymbolicReference(SymbolicReferent referent) {
     // Marker protocols cannot ever be symbolically referenced.
-    if (auto nominal = referent.dyn_cast<const NominalTypeDecl *>()) {
-      if (auto proto = dyn_cast<ProtocolDecl>(nominal)) {
+    if (referent.isNominalType()) {
+      if (auto proto = dyn_cast<ProtocolDecl>(referent.getNominalType())) {
         if (proto->isMarkerProtocol())
           return false;
       }
@@ -343,7 +386,8 @@ class ASTMangler : public Mangler {
                                         bool &isAssocTypeAtDepth);
 
   void appendOpWithGenericParamIndex(StringRef,
-                                     const GenericTypeParamType *paramTy);
+                                     const GenericTypeParamType *paramTy,
+                                     bool baseIsProtocolSelf = false);
 
   /// Mangles a sugared type iff we are mangling for the debugger.
   template <class T> void appendSugaredType(Type type,
@@ -444,8 +488,17 @@ class ASTMangler : public Mangler {
   bool appendGenericSignature(GenericSignature sig,
                               GenericSignature contextSig = nullptr);
 
-  void appendRequirement(const Requirement &reqt,
-                         GenericSignature sig);
+  /// Append a requirement to the mangling.
+  ///
+  /// \param reqt The requirement to mangle
+  /// \param sig  The generic signature.
+  /// \param lhsBaseIsProtocolSelf If \c true, mangle the base of the left-hand
+  /// side of the constraint with a special protocol 'Self' sentinel node. This
+  /// supports distinguishing requirements rooted at 'Self' in constrained
+  /// existentials from ambient generic parameters that would otherwise be
+  /// at e.g. (0, 0) as well.
+  void appendRequirement(const Requirement &reqt, GenericSignature sig,
+                         bool lhsBaseIsProtocolSelf = false);
 
   void appendGenericSignatureParts(GenericSignature sig,
                                    ArrayRef<CanTypeWrapper<GenericTypeParamType>> params,
@@ -511,6 +564,10 @@ class ASTMangler : public Mangler {
                                           GenericSignature sig);
   void appendOpParamForLayoutConstraint(LayoutConstraint Layout);
 
+  void appendSymbolicExtendedExistentialType(SymbolicReferent shapeReferent,
+                                             Type type,
+                                             GenericSignature sig,
+                                             const ValueDecl *forDecl);
   void appendSymbolicReference(SymbolicReferent referent);
 
   void appendOpaqueDeclName(const OpaqueTypeDecl *opaqueDecl);
@@ -521,6 +578,9 @@ class ASTMangler : public Mangler {
                                    Demangle::AutoDiffFunctionKind kind,
                                    const AutoDiffConfig &config);
   void appendIndexSubset(IndexSubset *indexSubset);
+
+  void appendConstrainedExistential(Type base, GenericSignature sig,
+                                    const ValueDecl *forDecl);
 };
 
 } // end namespace Mangle

include/swift/AST/DiagnosticsSema.def

@@ -288,9 +288,12 @@ FIXIT(insert_closure_return_type_placeholder,
 NOTE(use_of_anon_closure_param,none,
      "anonymous closure parameter %0 is used here", (Identifier))
 
-ERROR(incorrect_explicit_closure_result,none,
+ERROR(incorrect_explicit_closure_result_vs_contextual_type,none,
       "declared closure result %0 is incompatible with contextual type %1",
       (Type, Type))
+ERROR(incorrect_explicit_closure_result_vs_return_type,none,
+      "declared closure result %0 is incompatible with return type %1",
+      (Type, Type))
 
 ERROR(unsupported_closure_attr,none,
       "%select{attribute |}0 '%1' is not supported on a closure",

include/swift/AST/Types.h

@@ -6529,6 +6529,8 @@ inline bool TypeBase::isClassExistentialType() {
     return pt->requiresClass();
   if (auto pct = dyn_cast<ProtocolCompositionType>(T))
     return pct->requiresClass();
+  if (auto ppt = dyn_cast<ParameterizedProtocolType>(T))
+    return ppt->requiresClass();
   if (auto existential = dyn_cast<ExistentialType>(T))
     return existential->requiresClass();
   return false;

include/swift/Demangling/DemangleNodes.def

@@ -98,6 +98,9 @@ NODE(FunctionSignatureSpecializationReturn)
 NODE(FunctionSignatureSpecializationParamKind)
 NODE(FunctionSignatureSpecializationParamPayload)
 NODE(FunctionType)
+NODE(ConstrainedExistential)
+NODE(ConstrainedExistentialRequirementList)
+NODE(ConstrainedExistentialSelf)
 NODE(GenericPartialSpecialization)
 NODE(GenericPartialSpecializationNotReAbstracted)
 NODE(GenericProtocolWitnessTable)
@@ -170,7 +173,6 @@ NODE(EscapingObjCBlock)
 CONTEXT_NODE(OtherNominalType)
 CONTEXT_NODE(OwningAddressor)
 CONTEXT_NODE(OwningMutableAddressor)
-NODE(ParameterizedProtocol)
 NODE(PartialApplyForwarder)
 NODE(PartialApplyObjCForwarder)
 NODE(PostfixOperator)
@@ -337,6 +339,9 @@ NODE(BackDeploymentThunk)
 NODE(BackDeploymentFallback)
 NODE(ExtendedExistentialTypeShape)
 NODE(Uniquable)
+NODE(UniqueExtendedExistentialTypeShapeSymbolicReference)
+NODE(NonUniqueExtendedExistentialTypeShapeSymbolicReference)
+NODE(SymbolicExtendedExistentialType)
 
 #undef CONTEXT_NODE
 #undef NODE

include/swift/Demangling/Demangler.h

@@ -343,6 +343,10 @@ enum class SymbolicReferenceKind : uint8_t {
   /// A symbolic reference to an accessor function, which can be executed in
   /// the process to get a pointer to the referenced entity.
   AccessorFunctionReference,
+  /// A symbolic reference to a unique extended existential type shape.
+  UniqueExtendedExistentialTypeShape,
+  /// A symbolic reference to a non-unique extended existential type shape.
+  NonUniqueExtendedExistentialTypeShape,
 };
 
 using SymbolicReferenceResolver_t = NodePointer (SymbolicReferenceKind,
@@ -516,6 +520,7 @@ class Demangler : public NodeFactory {
                                     const Vector<NodePointer> &TypeLists,
                                     size_t TypeListIdx);
   NodePointer popAnyProtocolConformanceList();
+  NodePointer popRetroactiveConformances();
   NodePointer demangleRetroactiveConformance();
   NodePointer demangleInitializer();
   NodePointer demangleImplParamConvention(Node::Kind ConvKind);
@@ -530,6 +535,7 @@ class Demangler : public NodeFactory {
   NodePointer demangleAssociatedTypeSimple(NodePointer GenericParamIdx);
   NodePointer demangleAssociatedTypeCompound(NodePointer GenericParamIdx);
   NodePointer demangleExtendedExistentialShape(char kind);
+  NodePointer demangleSymbolicExtendedExistentialType();
 
   NodePointer popAssocTypeName();
   NodePointer popAssocTypePath();
@@ -580,6 +586,8 @@ class Demangler : public NodeFactory {
   NodePointer demangleIndexSubset();
   NodePointer demangleDifferentiableFunctionType();
 
+  NodePointer demangleConstrainedExistentialRequirementList();
+
   bool demangleBoundGenerics(Vector<NodePointer> &TypeListList,
                              NodePointer &RetroactiveConformances);
 

include/swift/Demangling/TypeDecoder.h

@@ -547,18 +547,8 @@ class TypeDecoder {
                                     Node->getNumChildren());
 
       llvm::SmallVector<BuiltType, 8> args;
-
-      const auto &genericArgs = Node->getChild(1);
-      if (genericArgs->getKind() != NodeKind::TypeList)
-        return MAKE_NODE_TYPE_ERROR0(genericArgs, "is not TypeList");
-
-      for (auto genericArg : *genericArgs) {
-        auto paramType = decodeMangledType(genericArg, depth + 1,
-                                           /*forRequirement=*/false);
-        if (paramType.isError())
-          return paramType;
-        args.push_back(paramType.getType());
-      }
+      if (auto error = decodeGenericArgs(Node->getChild(1), depth+1, args))
+        return *error;
 
       auto ChildNode = Node->getChild(0);
       if (ChildNode->getKind() == NodeKind::Type &&
@@ -665,6 +655,18 @@ class TypeDecoder {
                                      "had a different kind when re-checked");
       }
     }
+    case NodeKind::SymbolicExtendedExistentialType: {
+      if (Node->getNumChildren() < 2)
+        return MAKE_NODE_TYPE_ERROR0(Node, "not enough children");
+
+      auto shapeNode = Node->getChild(0);
+      llvm::SmallVector<BuiltType, 8> args;
+      if (auto error = decodeGenericArgs(Node->getChild(1), depth + 1, args))
+        return *error;
+
+      return Builder.createSymbolicExtendedExistentialType(shapeNode, args);
+    }
+
     case NodeKind::ProtocolList:
     case NodeKind::ProtocolListWithAnyObject:
     case NodeKind::ProtocolListWithClass: {
@@ -713,7 +715,7 @@ class TypeDecoder {
                                                    forRequirement);
     }
 
-    case NodeKind::ParameterizedProtocol: {
+    case NodeKind::ConstrainedExistential: {
       if (Node->getNumChildren() < 2)
         return MAKE_NODE_TYPE_ERROR(Node,
                                     "fewer children (%zu) than required (2)",
@@ -723,23 +725,20 @@ class TypeDecoder {
       if (protocolType.isError())
         return protocolType;
 
-      llvm::SmallVector<BuiltType, 8> args;
+      llvm::SmallVector<BuiltRequirement, 8> requirements;
 
-      const auto &genericArgs = Node->getChild(1);
-      if (genericArgs->getKind() != NodeKind::TypeList)
-        return MAKE_NODE_TYPE_ERROR0(genericArgs, "is not TypeList");
+      auto *reqts = Node->getChild(1);
+      if (reqts->getKind() != NodeKind::ConstrainedExistentialRequirementList)
+        return MAKE_NODE_TYPE_ERROR0(reqts, "is not requirement list");
 
-      for (auto genericArg : *genericArgs) {
-        auto paramType = decodeMangledType(genericArg, depth + 1,
-                                           /*forRequirement=*/false);
-        if (paramType.isError())
-          return paramType;
-        args.push_back(paramType.getType());
-      }
+      decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,
+                        BuilderType>(reqts, requirements, Builder);
 
-      return Builder.createParameterizedProtocolType(protocolType.getType(),
-                                                     args);
+      return Builder.createConstrainedExistentialType(protocolType.getType(),
+                                                      requirements);
     }
+    case NodeKind::ConstrainedExistentialSelf:
+      return Builder.createGenericTypeParameterType(/*depth*/ 0, /*index*/ 0);
 
     case NodeKind::Protocol:
     case NodeKind::ProtocolSymbolicReference: {
@@ -1383,6 +1382,22 @@ return {}; // Not Implemented!
     return false;
   }
 
+  llvm::Optional<TypeLookupError>
+  decodeGenericArgs(Demangle::NodePointer node, unsigned depth,
+                    llvm::SmallVectorImpl<BuiltType> &args) {
+    if (node->getKind() != NodeKind::TypeList)
+      return MAKE_NODE_TYPE_ERROR0(node, "is not TypeList");
+
+    for (auto genericArg : *node) {
+      auto paramType = decodeMangledType(genericArg, depth,
+                                         /*forRequirement=*/false);
+      if (paramType.isError())
+        return *paramType.getError();
+      args.push_back(paramType.getType());
+    }
+    return llvm::None;
+  }
+
   llvm::Optional<TypeLookupError>
   decodeMangledTypeDecl(Demangle::NodePointer node, unsigned depth,
                         BuiltTypeDecl &typeDecl, BuiltType &parent,