SIL: Detect and bail out on infinite aggregates.

Sema diagnoses obvious cases of value types defined in terms of themselves,
but it can't catch cases that arise as a result of generic substitution,
such as if a generic struct has a field of associated type that becomes the
same as the struct type itself. SIL may end up handling these types, even
though they can't be instantiated (the runtime will complain and crash if
the metadata is requested), either during SILGen because they were written
in source code, or as a result of generic specialization during optimization.
SIL thus can't rely on diagnostics preventing such types from appearing, so
it needs to be able to continue gracefully when they show up. Add checks
in type lowering for when a struct or enum lowering ends up depending on
itself, and generate an infinite type lowering that's opaque and address-only.

Fixes rdar://80310017

Author: jckarter

include/swift/SIL/TypeLowering.h

@@ -153,6 +153,13 @@ enum IsTypeExpansionSensitive_t : bool {
   IsTypeExpansionSensitive = true
 };
 
+/// Is the type infinitely defined in terms of itself? (Such types can never
+/// be concretely instantiated, but may still arise from generic specialization.)
+enum IsInfiniteType_t : bool {
+  IsNotInfiniteType = false,
+  IsInfiniteType = true,
+};
+
 /// Extended type information used by SIL.
 class TypeLowering {
 public:
@@ -164,6 +171,7 @@ class TypeLowering {
       AddressOnlyFlag            = 1 << 2,
       ResilientFlag              = 1 << 3,
       TypeExpansionSensitiveFlag = 1 << 4,
+      InfiniteFlag               = 1 << 5,
     };
 
     uint8_t Flags;
@@ -224,6 +232,9 @@ class TypeLowering {
       return IsTypeExpansionSensitive_t(
           (Flags & TypeExpansionSensitiveFlag) != 0);
     }
+    IsInfiniteType_t isInfinite() const {
+      return IsInfiniteType_t((Flags & InfiniteFlag) != 0);
+    }
 
     void setNonTrivial() { Flags |= NonTrivialFlag; }
     void setNonFixedABI() { Flags |= NonFixedABIFlag; }
@@ -233,6 +244,7 @@ class TypeLowering {
       Flags = (Flags & ~TypeExpansionSensitiveFlag) |
               (isTypeExpansionSensitive ? TypeExpansionSensitiveFlag : 0);
     }
+    void setInfinite() { Flags |= InfiniteFlag; }
   };
 
 private:
@@ -720,6 +732,9 @@ class TypeConverter {
 
   CanGenericSignature CurGenericSignature;
 
+  /// Stack of types currently being lowered as part of an aggregate.
+  llvm::SetVector<CanType> AggregateFieldsBeingLowered;
+  
   /// Mapping for types independent on contextual generic parameters.
   llvm::DenseMap<CachingTypeKey, const TypeLowering *> LoweredTypes;
 
@@ -767,6 +782,31 @@ class TypeConverter {
   CanGenericSignature getCurGenericSignature() const {
     return CurGenericSignature;
   }
+  
+  // RAII type used when lowering nominal aggregate types (structs and enums)
+  // to catch self-recursion. Although Sema tries to catch direct circularity
+  // in value type definitions, it can't catch circularity that arises from
+  // generic substitutions. SIL may however be exposed to these circularities
+  // at any point by substituting bound generic types either during SILGen or
+  // after passes that perform generic specialization.
+  class LowerAggregateTypeRAII {
+    TypeConverter &TC;
+    
+  public:
+    // True if the aggregate about to be lowered is already being lowered,
+    // indicating a circularity.
+    const bool IsInfinite;
+    
+    LowerAggregateTypeRAII(TypeConverter &TC, CanType aggregate)
+      : TC(TC), IsInfinite(!TC.AggregateFieldsBeingLowered.insert(aggregate))
+    {}
+    
+    ~LowerAggregateTypeRAII() {
+      if (!IsInfinite) {
+        TC.AggregateFieldsBeingLowered.pop_back();
+      }
+    }
+  };
 
   class GenericContextRAII {
     TypeConverter &TC;

lib/IRGen/GenStruct.cpp

@@ -1290,7 +1290,13 @@ const TypeInfo *TypeConverter::convertStructType(TypeBase *key, CanType type,
   // All resilient structs have the same opaque lowering, since they are
   // indistinguishable as values --- except that we have to track
   // ABI-accessibility.
-  if (IGM.isResilient(D, ResilienceExpansion::Maximal)) {
+  //
+  // Treat infinitely-sized types as resilient as well, since they can never
+  // be concretized.
+  if (IGM.isResilient(D, ResilienceExpansion::Maximal)
+      || IGM.getSILTypes().getTypeLowering(SILType::getPrimitiveAddressType(type),
+                                            TypeExpansionContext::minimal())
+            .getRecursiveProperties().isInfinite()) {
     auto structAccessible =
       IsABIAccessible_t(IGM.getSILModule().isTypeMetadataAccessible(type));
     return &getResilientStructTypeInfo(structAccessible);

lib/SIL/IR/SILType.cpp

@@ -109,6 +109,11 @@ bool SILType::isTrivial(const SILFunction &F) const {
 }
 
 bool SILType::isEmpty(const SILFunction &F) const {
+  // Infinite types are never empty.
+  if (F.getTypeLowering(*this).getRecursiveProperties().isInfinite()) {
+    return false;
+  }
+  
   if (auto tupleTy = getAs<TupleType>()) {
     // A tuple is empty if it either has no elements or if all elements are
     // empty.

lib/SIL/IR/TypeLowering.cpp

@@ -1686,6 +1686,15 @@ namespace {
       auto silType = SILType::getPrimitiveObjectType(type);
       return new (TC) OpaqueValueTypeLowering(silType, properties, Expansion);
     }
+    
+    TypeLowering *handleInfinite(CanType type,
+                                 RecursiveProperties properties) {
+      // Infinite types cannot actually be instantiated, so treat them as
+      // opaque for code generation purposes.
+      properties.setAddressOnly();
+      properties.setInfinite();
+      return handleAddressOnly(type, properties);
+    }
 
 #define ALWAYS_LOADABLE_CHECKED_REF_STORAGE(Name, ...) \
     TypeLowering * \
@@ -1779,6 +1788,12 @@ namespace {
 
       properties = mergeIsTypeExpansionSensitive(isSensitive, properties);
 
+      // Bail out if the struct layout relies on itself.
+      TypeConverter::LowerAggregateTypeRAII loweringStruct(TC, structType);
+      if (loweringStruct.IsInfinite) {
+        return handleInfinite(structType, properties);
+      }
+
       if (handleResilience(structType, D, properties))
         return handleAddressOnly(structType, properties);
 
@@ -1821,6 +1836,12 @@ namespace {
 
       properties = mergeIsTypeExpansionSensitive(isSensitive, properties);
 
+      // Bail out if the enum layout relies on itself.
+      TypeConverter::LowerAggregateTypeRAII loweringEnum(TC, enumType);
+      if (loweringEnum.IsInfinite) {
+        return handleInfinite(enumType, properties);
+      }
+
       if (handleResilience(enumType, D, properties))
         return handleAddressOnly(enumType, properties);
 

test/SILGen/infinite_type_from_generic_substitution.swift

@@ -0,0 +1,37 @@
+// RUN: %target-swift-emit-sil -verify %s
+
+protocol P {
+    associatedtype A
+}
+
+struct S<T: P> {
+    var s: T.A
+}
+
+struct SR: P {
+    typealias A = S<SR>
+}
+
+struct SU<T: P> {
+    var x: S<T>
+}
+
+func foo(x: SU<SR>) -> SU<SR> { return x }
+func bar(x: S<SR>) -> S<SR> { return x }
+func bas(x: S<SR>) -> S<SR> { return x.s }
+
+enum E<T: P> {
+    case recursive(T.A)
+    case blah
+}
+
+struct ER: P {
+    typealias A = E<ER>
+}
+
+enum EU<T: P> {
+    case x(E<T>)
+}
+
+func zim(x: EU<ER>) -> EU<ER> { return x }
+func zang(x: E<ER>) -> E<ER> { return x }