Merge pull request #40193 from CodaFi/sequential-access-patterns

CodaFi · web-flow · commit 1faf7edbd6b9 · 2021-11-17T13:19:31.000-08:00
Model Sequence Archetypes
diff --git a/include/swift/AST/TypeNodes.def b/include/swift/AST/TypeNodes.def
@@ -148,7 +148,8 @@ ABSTRACT_TYPE(Substitutable, Type)
     ALWAYS_CANONICAL_TYPE(OpaqueTypeArchetype, ArchetypeType)
     ALWAYS_CANONICAL_TYPE(OpenedArchetype, ArchetypeType)
     ALWAYS_CANONICAL_TYPE(NestedArchetype, ArchetypeType)
-    TYPE_RANGE(Archetype, PrimaryArchetype, NestedArchetype)
+    ALWAYS_CANONICAL_TYPE(SequenceArchetype, ArchetypeType)
+    TYPE_RANGE(Archetype, PrimaryArchetype, SequenceArchetype)
   TYPE(GenericTypeParam, SubstitutableType)
   TYPE_RANGE(Substitutable, PrimaryArchetype, GenericTypeParam)
 TYPE(DependentMember, Type)
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -124,7 +124,8 @@ class RecursiveTypeProperties {
     HasTypeVariable      = 0x01,
 
     /// This type expression contains a context-dependent archetype, either a
-    /// PrimaryArchetypeType or OpenedArchetypeType.
+    /// \c PrimaryArchetypeType, \c OpenedArchetypeType, or
+    /// \c SequenceArchetype.
     HasArchetype         = 0x02,
 
     /// This type expression contains a GenericTypeParamType.
@@ -5683,6 +5684,50 @@ CanArchetypeType getParent() const {
 }
 END_CAN_TYPE_WRAPPER(NestedArchetypeType, ArchetypeType)
 
+/// An archetype that represents an opaque element of a type sequence in context.
+///
+/// \code
+/// struct Foo<@_typeSequence Ts> { var xs: @_typeSequence Ts }
+/// func foo<@_typeSequence T>(_ xs: T...) where T: P {  }
+/// \endcode
+class SequenceArchetypeType final
+    : public ArchetypeType,
+      private ArchetypeTrailingObjects<SequenceArchetypeType> {
+  friend TrailingObjects;
+  friend ArchetypeType;
+
+  GenericEnvironment *Environment;
+
+public:
+  /// getNew - Create a new sequence archetype with the given name.
+  ///
+  /// The ConformsTo array will be minimized then copied into the ASTContext
+  /// by this routine.
+  static CanTypeWrapper<SequenceArchetypeType>
+  get(const ASTContext &Ctx, GenericEnvironment *GenericEnv,
+      GenericTypeParamType *InterfaceType,
+      SmallVectorImpl<ProtocolDecl *> &ConformsTo, Type Superclass,
+      LayoutConstraint Layout);
+
+  /// Retrieve the generic environment in which this archetype resides.
+  GenericEnvironment *getGenericEnvironment() const { return Environment; }
+
+  GenericTypeParamType *getInterfaceType() const {
+    return cast<GenericTypeParamType>(InterfaceType.getPointer());
+  }
+
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::SequenceArchetype;
+  }
+
+private:
+  SequenceArchetypeType(const ASTContext &Ctx, GenericEnvironment *GenericEnv,
+                        Type InterfaceType, ArrayRef<ProtocolDecl *> ConformsTo,
+                        Type Superclass, LayoutConstraint Layout);
+};
+BEGIN_CAN_TYPE_WRAPPER(SequenceArchetypeType, ArchetypeType)
+END_CAN_TYPE_WRAPPER(SequenceArchetypeType, ArchetypeType)
+
 template<typename Type>
 const Type *ArchetypeType::getSubclassTrailingObjects() const {
   if (auto contextTy = dyn_cast<PrimaryArchetypeType>(this)) {
@@ -5697,6 +5742,9 @@ const Type *ArchetypeType::getSubclassTrailingObjects() const {
   if (auto childTy = dyn_cast<NestedArchetypeType>(this)) {
     return childTy->getTrailingObjects<Type>();
   }
+  if (auto childTy = dyn_cast<SequenceArchetypeType>(this)) {
+    return childTy->getTrailingObjects<Type>();
+  }
   llvm_unreachable("unhandled ArchetypeType subclass?");
 }
   
diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp
@@ -3732,6 +3732,13 @@ namespace {
       printArchetypeNestedTypes(T);
       PrintWithColorRAII(OS, ParenthesisColor) << ')';
     }
+    void visitSequenceArchetypeType(SequenceArchetypeType *T, StringRef label) {
+      printArchetypeCommon(T, "sequence_archetype_type", label);
+      printField("name", T->getFullName());
+      OS << "\n";
+      printArchetypeNestedTypes(T);
+      PrintWithColorRAII(OS, ParenthesisColor) << ')';
+    }
 
     void visitGenericTypeParamType(GenericTypeParamType *T, StringRef label) {
       printCommon(label, "generic_type_param_type");
diff --git a/lib/AST/ASTMangler.cpp b/lib/AST/ASTMangler.cpp
@@ -1293,6 +1293,7 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
       // type ::= archetype
     case TypeKind::PrimaryArchetype:
     case TypeKind::OpenedArchetype:
+    case TypeKind::SequenceArchetype:
       llvm_unreachable("Cannot mangle free-standing archetypes");
 
     case TypeKind::OpaqueTypeArchetype: {
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -5397,6 +5397,10 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     }
   }
 
+  void visitSequenceArchetypeType(SequenceArchetypeType *T) {
+    printArchetypeCommon(T, T->getInterfaceType()->getDecl());
+  }
+
   void visitGenericTypeParamType(GenericTypeParamType *T) {
     if (T->getDecl() == nullptr) {
       // If we have an alternate name for this type, use it.
diff --git a/lib/AST/ASTVerifier.cpp b/lib/AST/ASTVerifier.cpp
@@ -618,8 +618,13 @@ class Verifier : public ASTWalker {
           }
 
           // Get the archetype's generic signature.
-          auto rootPrimary = cast<PrimaryArchetypeType>(root);
-          auto *archetypeEnv = rootPrimary->getGenericEnvironment();
+          GenericEnvironment *archetypeEnv;
+          if (auto seq = dyn_cast<SequenceArchetypeType>(root)) {
+            archetypeEnv = seq->getGenericEnvironment();
+          } else {
+            auto rootPrimary = cast<PrimaryArchetypeType>(root);
+            archetypeEnv = rootPrimary->getGenericEnvironment();
+          }
           auto archetypeSig = archetypeEnv->getGenericSignature();
 
           auto genericCtx = Generics.back();
diff --git a/lib/AST/GenericEnvironment.cpp b/lib/AST/GenericEnvironment.cpp
@@ -167,6 +167,11 @@ GenericEnvironment::getOrCreateArchetypeFromInterfaceType(Type depType) {
                                          requirements.protos, superclass,
                                          requirements.layout);
     parentArchetype->registerNestedType(depMemTy->getName(), result);
+  } else if (genericParam->isTypeSequence()) {
+    result = SequenceArchetypeType::get(ctx, this, genericParam,
+                                        requirements.protos, superclass,
+                                        requirements.layout);
+    addMapping(genericParam, result);
   } else {
     result = PrimaryArchetypeType::getNew(ctx, this, genericParam,
                                           requirements.protos, superclass,
diff --git a/lib/AST/SubstitutionMap.cpp b/lib/AST/SubstitutionMap.cpp
@@ -249,7 +249,8 @@ Type SubstitutionMap::lookupSubstitution(CanSubstitutableType type) const {
   // If we have an archetype, map out of the context so we can compute a
   // conformance access path.
   if (auto archetype = dyn_cast<ArchetypeType>(type)) {
-    if (!isa<PrimaryArchetypeType>(archetype))
+    if (!isa<PrimaryArchetypeType>(archetype) &&
+        !isa<SequenceArchetypeType>(archetype))
       return Type();
 
     type = cast<GenericTypeParamType>(
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -184,6 +184,7 @@ bool CanType::isReferenceTypeImpl(CanType type, const GenericSignatureImpl *sig,
   case TypeKind::OpenedArchetype:
   case TypeKind::NestedArchetype:
   case TypeKind::OpaqueTypeArchetype:
+  case TypeKind::SequenceArchetype:
     return cast<ArchetypeType>(type)->requiresClass();
   case TypeKind::Protocol:
     return cast<ProtocolType>(type)->requiresClass();
@@ -3062,6 +3063,9 @@ GenericEnvironment *ArchetypeType::getGenericEnvironment() const {
   if (auto opaque = dyn_cast<OpaqueTypeArchetypeType>(root)) {
     return opaque->getGenericEnvironment();
   }
+  if (auto opaque = dyn_cast<SequenceArchetypeType>(root)) {
+    return opaque->getGenericEnvironment();
+  }
   llvm_unreachable("unhandled root archetype kind?!");
 }
 
@@ -3145,6 +3149,17 @@ OpaqueTypeArchetypeType::OpaqueTypeArchetypeType(OpaqueTypeDecl *OpaqueDecl,
 {
 }
 
+SequenceArchetypeType::SequenceArchetypeType(
+    const ASTContext &Ctx, GenericEnvironment *GenericEnv, Type InterfaceType,
+    ArrayRef<ProtocolDecl *> ConformsTo, Type Superclass,
+    LayoutConstraint Layout)
+    : ArchetypeType(TypeKind::SequenceArchetype, Ctx,
+                    RecursiveTypeProperties::HasArchetype, InterfaceType,
+                    ConformsTo, Superclass, Layout),
+      Environment(GenericEnv) {
+  assert(cast<GenericTypeParamType>(InterfaceType.getPointer())->isTypeSequence());
+}
+
 GenericSignature OpaqueTypeArchetypeType::getBoundSignature() const {
   return Environment->getGenericSignature();
 }
@@ -3459,6 +3474,29 @@ PrimaryArchetypeType::getNew(const ASTContext &Ctx,
       Ctx, GenericEnv, InterfaceType, ConformsTo, Superclass, Layout));
 }
 
+CanSequenceArchetypeType
+SequenceArchetypeType::get(const ASTContext &Ctx,
+                           GenericEnvironment *GenericEnv,
+                           GenericTypeParamType *InterfaceType,
+                           SmallVectorImpl<ProtocolDecl *> &ConformsTo,
+                           Type Superclass, LayoutConstraint Layout) {
+  assert(!Superclass || Superclass->getClassOrBoundGenericClass());
+  assert(GenericEnv && "missing generic environment for archetype");
+
+  // Gather the set of protocol declarations to which this archetype conforms.
+  ProtocolType::canonicalizeProtocols(ConformsTo);
+
+  auto arena = AllocationArena::Permanent;
+  void *mem =
+      Ctx.Allocate(SequenceArchetypeType::totalSizeToAlloc<ProtocolDecl *, Type,
+                                                           LayoutConstraint>(
+                       ConformsTo.size(), Superclass ? 1 : 0, Layout ? 1 : 0),
+                   alignof(SequenceArchetypeType), arena);
+
+  return CanSequenceArchetypeType(::new (mem) SequenceArchetypeType(
+      Ctx, GenericEnv, InterfaceType, ConformsTo, Superclass, Layout));
+}
+
 bool ArchetypeType::requiresClass() const {
   if (auto layout = getLayoutConstraint())
     return layout->isClass();
@@ -4125,6 +4163,9 @@ static Type substType(Type derivedType,
     if (isa<PrimaryArchetypeType>(substOrig))
       return ErrorType::get(type);
 
+    if (isa<SequenceArchetypeType>(substOrig))
+      return ErrorType::get(type);
+
     // Opened existentials cannot be substituted in this manner,
     // but if they appear in the original type this is not an
     // error.
@@ -4534,6 +4575,7 @@ case TypeKind::Id:
 #include "swift/AST/TypeNodes.def"
   case TypeKind::PrimaryArchetype:
   case TypeKind::OpenedArchetype:
+  case TypeKind::SequenceArchetype:
   case TypeKind::Error:
   case TypeKind::Unresolved:
   case TypeKind::TypeVariable:
@@ -5279,7 +5321,8 @@ ReferenceCounting TypeBase::getReferenceCounting() {
   case TypeKind::PrimaryArchetype:
   case TypeKind::OpenedArchetype:
   case TypeKind::NestedArchetype:
-  case TypeKind::OpaqueTypeArchetype: {
+  case TypeKind::OpaqueTypeArchetype:
+  case TypeKind::SequenceArchetype: {
     auto archetype = cast<ArchetypeType>(type);
     auto layout = archetype->getLayoutConstraint();
     (void)layout;
diff --git a/lib/IRGen/Fulfillment.cpp b/lib/IRGen/Fulfillment.cpp
@@ -68,6 +68,7 @@ static bool isLeafTypeMetadata(CanType type) {
   case TypeKind::OpenedArchetype:
   case TypeKind::NestedArchetype:
   case TypeKind::OpaqueTypeArchetype:
+  case TypeKind::SequenceArchetype:
   case TypeKind::GenericTypeParam:
   case TypeKind::DependentMember:
     return true;
diff --git a/lib/IRGen/GenType.cpp b/lib/IRGen/GenType.cpp
@@ -1801,14 +1801,15 @@ const TypeInfo &TypeConverter::getCompleteTypeInfo(CanType T) {
 
 ArchetypeType *TypeConverter::getExemplarArchetype(ArchetypeType *t) {
   // Get the primary archetype.
-  auto primary = dyn_cast<PrimaryArchetypeType>(t->getRoot());
-  
+  auto root = t->getRoot();
+
   // If there is no primary (IOW, it's an opened archetype), the archetype is
   // an exemplar.
-  if (!primary) return t;
-  
+  if (!isa<PrimaryArchetypeType>(root) && !isa<VariadicSequenceType>(root))
+    return t;
+
   // Retrieve the generic environment of the archetype.
-  auto genericEnv = primary->getGenericEnvironment();
+  auto genericEnv = root->getGenericEnvironment();
 
   // Dig out the canonical generic environment.
   auto genericSig = genericEnv->getGenericSignature();
@@ -2103,6 +2104,7 @@ const TypeInfo *TypeConverter::convertType(CanType ty) {
   case TypeKind::OpenedArchetype:
   case TypeKind::NestedArchetype:
   case TypeKind::OpaqueTypeArchetype:
+  case TypeKind::SequenceArchetype:
     return convertArchetypeType(cast<ArchetypeType>(ty));
   case TypeKind::Class:
   case TypeKind::Enum:
@@ -2557,8 +2559,10 @@ void IRGenFunction::setDynamicSelfMetadata(CanType selfClass,
 
 #ifndef NDEBUG
 bool TypeConverter::isExemplarArchetype(ArchetypeType *arch) const {
-  auto primary = dyn_cast<PrimaryArchetypeType>(arch->getRoot());
-  if (!primary) return true;
+  auto primary = arch->getRoot();
+  if (!isa<PrimaryArchetypeType>(primary) &&
+      !isa<SequenceArchetypeType>(primary))
+    return true;
   auto genericEnv = primary->getGenericEnvironment();
 
   // Dig out the canonical generic environment.
diff --git a/lib/IRGen/IRGenDebugInfo.cpp b/lib/IRGen/IRGenDebugInfo.cpp
@@ -851,6 +851,11 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
           return true;
         }
 
+        if (auto *archetypeTy = t->getAs<SequenceArchetypeType>()) {
+          Sig = archetypeTy->getGenericEnvironment()->getGenericSignature();
+          return true;
+        }
+
         return false;
       });
 
@@ -1518,7 +1523,8 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
     case TypeKind::OpaqueTypeArchetype:
     case TypeKind::PrimaryArchetype:
     case TypeKind::OpenedArchetype:
-    case TypeKind::NestedArchetype: {
+    case TypeKind::NestedArchetype:
+    case TypeKind::SequenceArchetype: {
       auto *Archetype = BaseTy->castTo<ArchetypeType>();
       AssociatedTypeDecl *assocType = nullptr;
       if (auto nested = dyn_cast<NestedArchetypeType>(Archetype))
diff --git a/lib/IRGen/LocalTypeData.cpp b/lib/IRGen/LocalTypeData.cpp
@@ -336,7 +336,7 @@ static void maybeEmitDebugInfoForLocalTypeData(IRGenFunction &IGF,
   auto type = dyn_cast<ArchetypeType>(key.Type);
   if (!type)
     return;
-  if (!isa<PrimaryArchetypeType>(type))
+  if (!isa<PrimaryArchetypeType>(type) && !isa<SequenceArchetypeType>(type))
     return;
 
   auto *typeParam = type->getInterfaceType()->castTo<GenericTypeParamType>();
diff --git a/lib/IRGen/Outlining.cpp b/lib/IRGen/Outlining.cpp
@@ -118,7 +118,8 @@ irgen::getTypeAndGenericSignatureForManglingOutlineFunction(SILType type) {
     loweredType.findIf([&env](Type t) -> bool {
         if (auto arch = t->getAs<ArchetypeType>()) {
           auto root = arch->getRoot();
-          if (!isa<PrimaryArchetypeType>(root))
+          if (!isa<PrimaryArchetypeType>(root) &&
+              !isa<VariadicSequenceType>(root))
             return false;
           env = root->getGenericEnvironment();
           return true;
diff --git a/lib/SIL/Verifier/SILVerifier.cpp b/lib/SIL/Verifier/SILVerifier.cpp
@@ -86,8 +86,8 @@ static llvm::cl::opt<bool> AllowCriticalEdges("allow-critical-edges",
 /// Returns true if A is an opened existential type or is equal to an
 /// archetype from F's generic context.
 static bool isArchetypeValidInFunction(ArchetypeType *A, const SILFunction *F) {
-  auto root = dyn_cast<PrimaryArchetypeType>(A->getRoot());
-  if (!root)
+  auto root = A->getRoot();
+  if (!isa<PrimaryArchetypeType>(root) && !isa<SequenceArchetypeType>(root))
     return true;
   if (isa<OpenedArchetypeType>(A->getRoot()))
     return true;
diff --git a/lib/SILOptimizer/Utils/Generics.cpp b/lib/SILOptimizer/Utils/Generics.cpp
@@ -1095,6 +1095,10 @@ shouldBePartiallySpecialized(Type Replacement,
       if (auto Primary = dyn_cast<PrimaryArchetypeType>(Archetype->getRoot())) {
         UsedArchetypes.insert(Primary);
       }
+
+      if (auto Seq = dyn_cast<SequenceArchetypeType>(Archetype->getRoot())) {
+        UsedArchetypes.insert(Seq);
+      }
     }
   });
 
@@ -1321,6 +1325,10 @@ void FunctionSignaturePartialSpecializer::collectUsedCallerArchetypes(
         if (auto Primary = dyn_cast<PrimaryArchetypeType>(Archetype->getRoot())) {
           UsedCallerArchetypes.insert(Primary);
         }
+
+        if (auto Seq = dyn_cast<SequenceArchetypeType>(Archetype->getRoot())) {
+          UsedCallerArchetypes.insert(Seq);
+        }
       }
     });
   }
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -6685,6 +6685,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
   case TypeKind::OpenedArchetype:
   case TypeKind::NestedArchetype:
   case TypeKind::OpaqueTypeArchetype:
+  case TypeKind::SequenceArchetype:
     if (!cast<ArchetypeType>(desugaredFromType)->requiresClass())
       break;
     LLVM_FALLTHROUGH;
@@ -7004,6 +7005,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
   case TypeKind::OpenedArchetype:
   case TypeKind::NestedArchetype:
   case TypeKind::OpaqueTypeArchetype:
+  case TypeKind::SequenceArchetype:
   case TypeKind::GenericTypeParam:
   case TypeKind::DependentMember:
   case TypeKind::Function:
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
diff --git a/lib/Serialization/DeclTypeRecordNodes.def b/lib/Serialization/DeclTypeRecordNodes.def
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
diff --git a/lib/Serialization/ModuleFormat.h b/lib/Serialization/ModuleFormat.h
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp

Original file line number	Diff line number	Diff line change
`@@ -5397,6 +5397,10 @@ class TypePrinter : public TypeVisitor<TypePrinter> {`
`5397`	`5397`	`}`
`5398`	`5398`	`}`
`5399`	`5399`
	`5400`	`+ void visitSequenceArchetypeType(SequenceArchetypeType *T) {`
	`5401`	`+ printArchetypeCommon(T, T->getInterfaceType()->getDecl());`
	`5402`	`+ }`
	`5403`	`+`
`5400`	`5404`	`void visitGenericTypeParamType(GenericTypeParamType *T) {`
`5401`	`5405`	`if (T->getDecl() == nullptr) {`
`5402`	`5406`	`// If we have an alternate name for this type, use it.`