Merge pull request #62016 from slavapestov/shape-requirements-misc

Mangling for shape requirements, and related fixes

Author: slavapestov

docs/ABI/Mangling.rst

@@ -887,6 +887,8 @@ now codified into the ABI; the index 0 is therefore reserved.
   requirement ::= type assoc-type-list 'RM' GENERIC-PARAM-INDEX LAYOUT-CONSTRAINT    // layout requirement on associated type at depth
   requirement ::= type substitution 'RM' LAYOUT-CONSTRAINT                           // layout requirement with substitution
 
+  requirement ::= type 'Rh' GENERIC-PARAM-INDEX                     // same-shape requirement (only supported on a generic parameter)
+
   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

include/swift/AST/DiagnosticsSema.def

@@ -5144,6 +5144,10 @@ ERROR(tuple_duplicate_label,none,
 ERROR(multiple_ellipsis_in_tuple,none,
       "only a single element can be variadic", ())
 
+ERROR(expansion_not_same_shape,none,
+      "variadic expansion %0 requires that %1 and %2 have the same shape",
+      (Type, Type, Type))
+
 ERROR(enum_element_ellipsis,none,
       "variadic enum cases are not supported", ())
 ERROR(unlabeled_parameter_following_variadic_parameter,none,

include/swift/AST/Types.h

@@ -661,7 +661,7 @@ class alignas(1 << TypeAlignInBits) TypeBase
 
   /// Retrieve the set of type parameter packs that occur within this type.
   void getTypeParameterPacks(
-      SmallVectorImpl<Type> &rootParameterPacks) const;
+      SmallVectorImpl<Type> &rootParameterPacks);
 
   /// Replace opened archetypes with the given root with their most
   /// specific non-dependent upper bounds throughout this type.
@@ -1290,6 +1290,18 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// Error.
   bool isExistentialWithError();
 
+  /// Returns the reduced shape of the type, which represents an equivalence
+  /// class for the same-shape generic requirement:
+  ///
+  /// - The shape of a scalar type is always the empty tuple type ().
+  /// - The shape of a pack archetype is computed from the generic signature
+  ///   using same-shape requirements.
+  /// - The shape of a pack type is computed recursively from its elements.
+  ///
+  /// Two types satisfy a same-shape requirement if their reduced shapes are
+  /// equal as canonical types.
+  CanType getReducedShape();
+
   SWIFT_DEBUG_DUMP;
   void dump(raw_ostream &os, unsigned indent = 0) const;
 
@@ -6028,7 +6040,7 @@ class PackArchetypeType final
       LayoutConstraint Layout);
 
   // Returns the reduced shape type for this pack archetype.
-  Type getShape() const;
+  CanType getReducedShape() const;
 
   static bool classof(const TypeBase *T) {
     return T->getKind() == TypeKind::PackArchetype;
@@ -6481,6 +6493,8 @@ class PackType final : public TypeBase, public llvm::FoldingSetNode,
 
   PackType *flattenPackTypes();
 
+  CanTypeWrapper<PackType> getReducedShape();
+
 public:
   void Profile(llvm::FoldingSetNodeID &ID) const {
     Profile(ID, getElementTypes());
@@ -6553,6 +6567,8 @@ class PackExpansionType : public TypeBase, public llvm::FoldingSetNode {
 
   PackExpansionType *expand();
 
+  CanType getReducedShape();
+
 public:
   void Profile(llvm::FoldingSetNodeID &ID) {
     Profile(ID, getPatternType(), getCountType());

include/swift/Demangling/DemangleNodes.def

@@ -59,6 +59,7 @@ NODE(DependentGenericConformanceRequirement)
 NODE(DependentGenericParamCount)
 NODE(DependentGenericParamType)
 NODE(DependentGenericSameTypeRequirement)
+NODE(DependentGenericSameShapeRequirement)
 NODE(DependentGenericLayoutRequirement)
 NODE(DependentGenericSignature)
 NODE(DependentGenericType)

lib/AST/ASTMangler.cpp

@@ -2912,8 +2912,6 @@ void ASTMangler::appendRequirement(const Requirement &reqt,
   Type FirstTy = reqt.getFirstType()->getCanonicalType();
 
   switch (reqt.getKind()) {
-  case RequirementKind::SameShape:
-    llvm_unreachable("Same-shape requirement not supported here");
   case RequirementKind::Layout:
     break;
   case RequirementKind::Conformance: {
@@ -2925,7 +2923,8 @@ void ASTMangler::appendRequirement(const Requirement &reqt,
     appendProtocolName(reqt.getProtocolDecl());
   } break;
   case RequirementKind::Superclass:
-  case RequirementKind::SameType: {
+  case RequirementKind::SameType:
+  case RequirementKind::SameShape: {
     Type SecondTy = reqt.getSecondType();
     appendType(SecondTy->getCanonicalType(), sig);
     break;
@@ -2957,7 +2956,7 @@ void ASTMangler::appendRequirement(const Requirement &reqt,
     assert(gpBase);
     switch (reqt.getKind()) {
       case RequirementKind::SameShape:
-        llvm_unreachable("Same-shape requirement not supported here");
+        llvm_unreachable("Same-shape requirement with a dependent member type?");
       case RequirementKind::Conformance:
         return appendOpWithGenericParamIndex(isAssocTypeAtDepth ? "RP" : "Rp",
                                              gpBase, lhsBaseIsProtocolSelf);
@@ -2977,8 +2976,6 @@ void ASTMangler::appendRequirement(const Requirement &reqt,
   }
   GenericTypeParamType *gpBase = FirstTy->castTo<GenericTypeParamType>();
   switch (reqt.getKind()) {
-    case RequirementKind::SameShape:
-      llvm_unreachable("Same-shape requirement not supported here");
     case RequirementKind::Conformance:
       return appendOpWithGenericParamIndex("R", gpBase);
     case RequirementKind::Layout:
@@ -2989,6 +2986,8 @@ void ASTMangler::appendRequirement(const Requirement &reqt,
       return appendOpWithGenericParamIndex("Rb", gpBase);
     case RequirementKind::SameType:
       return appendOpWithGenericParamIndex("Rs", gpBase);
+    case RequirementKind::SameShape:
+      return appendOpWithGenericParamIndex("Rh", gpBase);
   }
   llvm_unreachable("bad requirement type");
 }

lib/AST/ASTPrinter.cpp

@@ -1787,22 +1787,26 @@ void PrintAST::printSingleDepthOfGenericSignature(
 }
 
 void PrintAST::printRequirement(const Requirement &req) {
-  printTransformedType(req.getFirstType());
   switch (req.getKind()) {
   case RequirementKind::SameShape:
-    Printer << ".shape == ";
+    Printer << "((";
+    printTransformedType(req.getFirstType());
+    Printer << ", ";
     printTransformedType(req.getSecondType());
-    Printer << ".shape";
+    Printer << ")...) : Any";
     return;
   case RequirementKind::Layout:
+    printTransformedType(req.getFirstType());
     Printer << " : ";
     req.getLayoutConstraint()->print(Printer, Options);
     return;
   case RequirementKind::Conformance:
   case RequirementKind::Superclass:
+    printTransformedType(req.getFirstType());
     Printer << " : ";
     break;
   case RequirementKind::SameType:
+    printTransformedType(req.getFirstType());
     Printer << " == ";
     break;
   }

lib/AST/CMakeLists.txt

@@ -77,6 +77,7 @@ add_swift_host_library(swiftAST STATIC
   ProtocolConformance.cpp
   ProtocolConformanceRef.cpp
   RawComment.cpp
+  Requirement.cpp
   RequirementEnvironment.cpp
   RequirementMachine/ConcreteContraction.cpp
   RequirementMachine/ConcreteTypeWitness.cpp

lib/AST/GenericSignature.cpp

@@ -741,173 +741,6 @@ void swift::simple_display(raw_ostream &out, GenericSignature sig) {
     out << "NULL";
 }
 
-bool Requirement::hasError() const {
-  if (getFirstType()->hasError())
-    return true;
-
-  if (getKind() != RequirementKind::Layout && getSecondType()->hasError())
-    return true;
-
-  return false;
-}
-
-bool Requirement::isCanonical() const {
-  if (!getFirstType()->isCanonical())
-    return false;
-
-  switch (getKind()) {
-  case RequirementKind::SameShape:
-  case RequirementKind::Conformance:
-  case RequirementKind::SameType:
-  case RequirementKind::Superclass:
-    if (!getSecondType()->isCanonical())
-      return false;
-    break;
-
-  case RequirementKind::Layout:
-    break;
-  }
-
-  return true;
-}
-
-/// Get the canonical form of this requirement.
-Requirement Requirement::getCanonical() const {
-  Type firstType = getFirstType()->getCanonicalType();
-
-  switch (getKind()) {
-  case RequirementKind::SameShape:
-  case RequirementKind::Conformance:
-  case RequirementKind::SameType:
-  case RequirementKind::Superclass: {
-    Type secondType = getSecondType()->getCanonicalType();
-    return Requirement(getKind(), firstType, secondType);
-  }
-
-  case RequirementKind::Layout:
-    return Requirement(getKind(), firstType, getLayoutConstraint());
-  }
-  llvm_unreachable("Unhandled RequirementKind in switch");
-}
-
-ProtocolDecl *Requirement::getProtocolDecl() const {
-  assert(getKind() == RequirementKind::Conformance);
-  return getSecondType()->castTo<ProtocolType>()->getDecl();
-}
-
-bool
-Requirement::isSatisfied(ArrayRef<Requirement> &conditionalRequirements,
-                         bool allowMissing) const {
-  switch (getKind()) {
-  case RequirementKind::SameShape:
-    llvm_unreachable("Same-shape requirements not supported here");
-
-  case RequirementKind::Conformance: {
-    auto *proto = getProtocolDecl();
-    auto *module = proto->getParentModule();
-    auto conformance = module->lookupConformance(
-        getFirstType(), proto, allowMissing);
-    if (!conformance)
-      return false;
-
-    conditionalRequirements = conformance.getConditionalRequirements();
-    return true;
-  }
-
-  case RequirementKind::Layout: {
-    if (auto *archetypeType = getFirstType()->getAs<ArchetypeType>()) {
-      auto layout = archetypeType->getLayoutConstraint();
-      return (layout && layout.merge(getLayoutConstraint()));
-    }
-
-    if (getLayoutConstraint()->isClass())
-      return getFirstType()->satisfiesClassConstraint();
-
-    // TODO: Statically check other layout constraints, once they can
-    // be spelled in Swift.
-    return true;
-  }
-
-  case RequirementKind::Superclass:
-    return getSecondType()->isExactSuperclassOf(getFirstType());
-
-  case RequirementKind::SameType:
-    return getFirstType()->isEqual(getSecondType());
-  }
-
-  llvm_unreachable("Bad requirement kind");
-}
-
-bool Requirement::canBeSatisfied() const {
-  switch (getKind()) {
-  case RequirementKind::SameShape:
-    llvm_unreachable("Same-shape requirements not supported here");
-
-  case RequirementKind::Conformance:
-    return getFirstType()->is<ArchetypeType>();
-
-  case RequirementKind::Layout: {
-    if (auto *archetypeType = getFirstType()->getAs<ArchetypeType>()) {
-      auto layout = archetypeType->getLayoutConstraint();
-      return (!layout || layout.merge(getLayoutConstraint()));
-    }
-
-    return false;
-  }
-
-  case RequirementKind::Superclass:
-    return (getFirstType()->isBindableTo(getSecondType()) ||
-            getSecondType()->isBindableTo(getFirstType()));
-
-  case RequirementKind::SameType:
-    return (getFirstType()->isBindableTo(getSecondType()) ||
-            getSecondType()->isBindableTo(getFirstType()));
-  }
-
-  llvm_unreachable("Bad requirement kind");
-}
-
-/// Determine the canonical ordering of requirements.
-static unsigned getRequirementKindOrder(RequirementKind kind) {
-  switch (kind) {
-  case RequirementKind::SameShape: return 4;
-  case RequirementKind::Conformance: return 2;
-  case RequirementKind::Superclass: return 0;
-  case RequirementKind::SameType: return 3;
-  case RequirementKind::Layout: return 1;
-  }
-  llvm_unreachable("unhandled kind");
-}
-
-/// Linear order on requirements in a generic signature.
-int Requirement::compare(const Requirement &other) const {
-  int compareLHS =
-    compareDependentTypes(getFirstType(), other.getFirstType());
-
-  if (compareLHS != 0)
-    return compareLHS;
-
-  int compareKind = (getRequirementKindOrder(getKind()) -
-                     getRequirementKindOrder(other.getKind()));
-
-  if (compareKind != 0)
-    return compareKind;
-
-  // We should only have multiple conformance requirements.
-  if (getKind() != RequirementKind::Conformance) {
-    llvm::errs() << "Unordered generic requirements\n";
-    llvm::errs() << "LHS: "; dump(llvm::errs()); llvm::errs() << "\n";
-    llvm::errs() << "RHS: "; other.dump(llvm::errs()); llvm::errs() << "\n";
-    abort();
-  }
-
-  int compareProtos =
-    TypeDecl::compare(getProtocolDecl(), other.getProtocolDecl());
-  assert(compareProtos != 0 && "Duplicate conformance requirements");
-
-  return compareProtos;
-}
-
 /// Compare two associated types.
 int swift::compareAssociatedTypes(AssociatedTypeDecl *assocType1,
                                   AssociatedTypeDecl *assocType2) {