[NFC] TypeLowering: add CustomDeinit.

Teach SIL type lowering to recursively track custom vs. default deinit status.

Determine whether each type recursively only has default deinitialization. This
includes any recursive deinitializers that may be invoked by releasing a
reference held by this type.

If a type only has default deinitialization, then the deinitializer cannot
have any semantically-visible side effects. It cannot write to any memory

Author: atrick

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -118,6 +118,14 @@ public struct Type : TypeProperties, CustomStringConvertible, NoReflectionChildr
     return CanonicalType(bridged: bridged.getApproximateFormalPackType());
   }
 
+  /// True if destroying a value of this type might invoke a custom deinitialer
+  /// with side effects. This includes any recursive deinitializers that may be
+  /// invoked by releasing a reference. False if this only has default
+  /// deinitialization.
+  public func mayHaveCustomDeinit(in function: Function) -> Bool {
+    return bridged.mayHaveCustomDeinit(function.bridged)
+  }
+
   //===--------------------------------------------------------------------===//
   //                Properties of lowered `SILFunctionType`s
   //===--------------------------------------------------------------------===//

include/swift/SIL/SILBridging.h

@@ -292,6 +292,7 @@ struct BridgedType {
   BRIDGED_INLINE bool isAddressableForDeps(BridgedFunction f) const;
   BRIDGED_INLINE SWIFT_IMPORT_UNSAFE BridgedASTType getRawLayoutSubstitutedLikeType() const;
   BRIDGED_INLINE SWIFT_IMPORT_UNSAFE BridgedASTType getRawLayoutSubstitutedCountType() const;
+  BRIDGED_INLINE bool mayHaveCustomDeinit(BridgedFunction f) const;
   BRIDGED_INLINE SwiftInt getCaseIdxOfEnumType(BridgedStringRef name) const;
   static BRIDGED_INLINE SwiftInt getNumBoxFields(BridgedCanType boxTy);
   static SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedType getBoxFieldType(BridgedCanType boxTy,

include/swift/SIL/SILBridgingImpl.h

@@ -406,6 +406,10 @@ BridgedASTType BridgedType::getRawLayoutSubstitutedCountType() const {
   return {unbridged().getRawLayoutSubstitutedCountType().getPointer()};
 }
 
+bool BridgedType::mayHaveCustomDeinit(BridgedFunction f) const {
+  return unbridged().mayHaveCustomDeinit(*f.getFunction());
+}
+
 SwiftInt BridgedType::getCaseIdxOfEnumType(BridgedStringRef name) const {
   return unbridged().getCaseIdxOfEnumType(name.unbridged());
 }

include/swift/SIL/SILType.h

@@ -962,6 +962,12 @@ class SILType {
   /// lifetime-dependent value.
   bool isAddressableForDeps(const SILFunction &function) const;
 
+  /// True if destroying a value of this type might invoke a custom deinitialer
+  /// with side effects. This includes any recursive deinitializers that may be
+  /// invoked by releasing a reference. False if this only has default
+  /// deinitialization.
+  bool mayHaveCustomDeinit(const SILFunction &function) const;
+
   /// Returns true if this type is an actor type. Returns false if this is any
   /// other type. This includes distributed actors. To check for distributed
   /// actors and actors, use isAnyActor().

include/swift/SIL/SILTypeProperties.h

@@ -116,6 +116,18 @@ enum HasRawLayout_t : bool {
   HasRawLayout = true
 };
 
+/// Does this type only have default deinitialization or might it invoke a
+/// custom deinitialer with side effects? This includes any recursive
+/// deinitializers that may be invoked by releasing a reference.
+///
+/// If a type only has default deinitialization, then the deinitializer cannot
+/// have any semantically-visible side effects. It cannot write to any memory
+/// reachable from another object that won't be freed during deinitialization.
+enum MayHaveCustomDeinit_t : bool {
+  HasOnlyDefaultDeinit = false,
+  MayHaveCustomDeinit = true,
+};
+
 class SILTypeProperties {
   // These are chosen so that bitwise-or merges the flags properly.
   //
@@ -132,6 +144,7 @@ class SILTypeProperties {
     HasPackFlag                    = 1 << 8,
     AddressableForDependenciesFlag = 1 << 9,
     HasRawLayoutFlag               = 1 << 10,
+    CustomDeinitFlag               = 1 << 11,
   };
   // clang-format on
 
@@ -150,7 +163,8 @@ class SILTypeProperties {
       HasRawPointer_t hasRawPointer = DoesNotHaveRawPointer,
       IsLexical_t isLexical = IsNotLexical, HasPack_t hasPack = HasNoPack,
       IsAddressableForDependencies_t isAFD = IsNotAddressableForDependencies,
-      HasRawLayout_t hasRawLayout = DoesNotHaveRawLayout)
+      HasRawLayout_t hasRawLayout = DoesNotHaveRawLayout,
+      MayHaveCustomDeinit_t customDeinit = HasOnlyDefaultDeinit)
       : Flags((isTrivial ? 0U : NonTrivialFlag) |
               (isFixedABI ? 0U : NonFixedABIFlag) |
               (isAddressOnly ? AddressOnlyFlag : 0U) |
@@ -160,7 +174,8 @@ class SILTypeProperties {
               (isLexical ? LexicalFlag : 0U) |
               (hasPack ? HasPackFlag : 0U) |
               (isAFD ? AddressableForDependenciesFlag : 0U) |
-              (hasRawLayout ? HasRawLayoutFlag : 0U)) {}
+              (hasRawLayout ? HasRawLayoutFlag : 0U) |
+              (customDeinit ? CustomDeinitFlag : 0U)) {}
 
   constexpr bool operator==(SILTypeProperties p) const {
     return Flags == p.Flags;
@@ -183,13 +198,16 @@ class SILTypeProperties {
 
   static constexpr SILTypeProperties forReference() {
     return {IsNotTrivial, IsFixedABI, IsNotAddressOnly, IsNotResilient,
-            IsNotTypeExpansionSensitive, DoesNotHaveRawPointer, IsLexical};
+            IsNotTypeExpansionSensitive, DoesNotHaveRawPointer, IsLexical,
+            HasNoPack, IsNotAddressableForDependencies, DoesNotHaveRawLayout,
+            MayHaveCustomDeinit};
   }
 
   static constexpr SILTypeProperties forOpaque() {
     return {IsNotTrivial, IsNotFixedABI, IsAddressOnly, IsNotResilient,
             IsNotTypeExpansionSensitive, HasRawPointer, IsLexical,
-            HasNoPack, IsAddressableForDependencies, HasRawLayout};
+            HasNoPack, IsAddressableForDependencies, HasRawLayout,
+            MayHaveCustomDeinit};
   }
 
   static constexpr SILTypeProperties forResilient() {
@@ -240,6 +258,9 @@ class SILTypeProperties {
   HasRawLayout_t isOrContainsRawLayout() const {
     return HasRawLayout_t((Flags & HasRawLayoutFlag) != 0);
   }
+  MayHaveCustomDeinit_t mayHaveCustomDeinit() const {
+    return MayHaveCustomDeinit_t((Flags & CustomDeinitFlag) != 0);
+  }
 
   void setNonTrivial() { Flags |= NonTrivialFlag; }
   void setIsOrContainsRawPointer() { Flags |= HasRawPointerFlag; }
@@ -262,6 +283,10 @@ class SILTypeProperties {
   void setHasRawLayout() {
     Flags |= HasRawLayoutFlag;
   }
+  void setCustomDeinit(MayHaveCustomDeinit_t hasCustomDeinit) {
+    Flags = (Flags & ~CustomDeinitFlag)
+      | (hasCustomDeinit ? CustomDeinitFlag : 0);
+  }
 };
 
 } // end namespace swift

include/swift/SIL/TypeLowering.h

@@ -198,6 +198,10 @@ class TypeLowering {
     return Properties.isTypeExpansionSensitive();
   }
 
+  IsInfiniteType_t isInfinite() const {
+    return Properties.isInfinite();
+  }
+
   /// Should a value of this type have its lifetime tied to its lexical scope?
   bool isLexical() const {
     return Properties.isLexical();
@@ -596,6 +600,17 @@ class TypeConverter {
         return isa<FunctionType>(type) && type->hasTypeParameter();
       });
     }
+
+    friend bool operator==(const TypeKey &lhs,
+                           const TypeKey &rhs) {
+      return lhs.OrigType == rhs.OrigType && lhs.SubstType == rhs.SubstType
+        && lhs.expansionContext == rhs.expansionContext
+        && lhs.IsCacheable == rhs.IsCacheable;
+    }
+    friend bool operator!=(const TypeKey &lhs,
+                           const TypeKey &rhs) {
+      return !(lhs == rhs);
+    }
   };
 
   friend struct llvm::DenseMapInfo<CachingTypeKey>;
@@ -661,6 +676,13 @@ class TypeConverter {
   llvm::DenseMap<SILDeclRef, TypeExpansionContext>
     CaptureTypeExpansionContexts;
 
+  /// True while lowering a non-layout type.
+  bool isLoweringNonLayoutType = false;
+
+  /// True if this lowering should be cached.
+  ///
+  bool isCacheableLowering(const TypeLowering *tl);
+
   CanAnyFunctionType makeConstantInterfaceType(SILDeclRef constant);
 
   // Types converted during foreign bridging.
@@ -733,6 +755,28 @@ class TypeConverter {
     }
   };
 
+  // Wraps lowering of any type that does not contribute to the layout of its
+  // parent type. Avoids caching incomplete 'isInfinite' properties for types
+  // with complete layouts.
+  class NonLayoutTypeRAII {
+    TypeConverter &TC;
+
+  public:
+    const bool wasLoweringNonFieldType;
+
+    NonLayoutTypeRAII(TypeConverter &TC)
+      : TC(TC), wasLoweringNonFieldType(TC.isLoweringNonLayoutType)
+    {
+      TC.isLoweringNonLayoutType = true;
+    }
+    NonLayoutTypeRAII(const NonLayoutTypeRAII &) = delete;
+    NonLayoutTypeRAII &operator=(const NonLayoutTypeRAII &) = delete;
+
+    ~NonLayoutTypeRAII() {
+      TC.isLoweringNonLayoutType = wasLoweringNonFieldType;
+    }
+  };
+
   /// Return the CaptureKind to use when capturing a decl.
   CaptureKind getDeclCaptureKind(CapturedValue capture,
                                  TypeExpansionContext expansion);

lib/SIL/IR/SILType.cpp

@@ -1373,6 +1373,13 @@ SILType::getConcurrencyDiagnosticBehavior(SILFunction *fn) const {
   return getASTType()->getConcurrencyDiagnosticBehaviorLimit(fromDC);
 }
 
+bool SILType::mayHaveCustomDeinit(const SILFunction &function) const {
+  auto contextType =
+    hasTypeParameter() ? function.mapTypeIntoContext(*this) : *this;
+  auto properties = function.getTypeProperties(contextType);
+  return properties.mayHaveCustomDeinit();
+}
+
 namespace swift::test {
 // Arguments:
 // - SILValue: value

lib/SIL/IR/TypeLowering.cpp

@@ -258,6 +258,8 @@ namespace {
     }
 
     RetTy handleReference(CanType type) {
+      // TODO: Consider final classes with no user deinit to be
+      // HasOnlyDefaultDeinit.
       return handleReference(type, SILTypeProperties::forReference());
     }
 
@@ -754,6 +756,7 @@ namespace {
     RetTy
     visitArchetypeType(CanArchetypeType type, AbstractionPattern origType,
                        IsTypeExpansionSensitive_t isSensitive) {
+      // TODO: Add a HasOnlyDefaultDeinit "layout protocol".
       auto LayoutInfo = type->getLayoutConstraint();
       if (LayoutInfo) {
         if (LayoutInfo->isFixedSizeTrivial()) {
@@ -2625,6 +2628,9 @@ namespace {
       if (origType.isNoncopyable(structType)) {
         properties.setNonTrivial();
         properties.setLexical(IsLexical);
+        if (D->getValueTypeDestructor()) {
+          properties.setCustomDeinit(MayHaveCustomDeinit);
+        }
         if (properties.isAddressOnly())
           return handleMoveOnlyAddressOnly(structType, properties);
         return new (TC) MoveOnlyLoadableStructTypeLowering(
@@ -2635,6 +2641,13 @@ namespace {
       if (!origType.isEscapable(structType)) {
         properties.setNonTrivial();
       }
+      // Merge the CustomDeinit properties of the type parameters.
+      if (hasConditionalDefaultDeinit(structType, D)) {
+        auto genericProps = classifyTypeParameters(structType, TC, Expansion);
+        if (genericProps.mayHaveCustomDeinit() == HasOnlyDefaultDeinit) {
+          properties.setCustomDeinit(HasOnlyDefaultDeinit);
+        }
+      }
       return handleAggregateByProperties<LoadableStructTypeLowering>(structType,
                                                                     properties);
     }
@@ -2728,6 +2741,9 @@ namespace {
       if (origType.isNoncopyable(enumType)) {
         properties.setNonTrivial();
         properties.setLexical(IsLexical);
+        if (D->getValueTypeDestructor()) {
+          properties.setCustomDeinit(MayHaveCustomDeinit);
+        }
         if (properties.isAddressOnly())
           return handleMoveOnlyAddressOnly(enumType, properties);
         return new (TC)
@@ -2769,6 +2785,43 @@ namespace {
       }
       return new (TC) LoadableLoweringClass(type, props, Expansion);
     }
+
+  private:
+    bool hasConditionalDefaultDeinit(CanType type, StructDecl *structDecl) {
+      if (type->isArray() || type->is_ArrayBuffer()
+          || type->is_ContiguousArrayBuffer() || type->isDictionary()) {
+        return true;
+      }
+      if (ProtocolDecl *DestructorSafeContainer =
+          TC.Context.getProtocol(KnownProtocolKind::DestructorSafeContainer)) {
+        return bool(lookupConformance(type, DestructorSafeContainer));
+      }
+      return false;
+    }
+
+    // Merge the type properties of all the generic parameters. Useful for
+    // summarizing the properties of indirectly stored types, such as Array
+    // elements. Only non-layout flags, such as CustomDeinitFlag are relevant in
+    // the result.
+    //
+    // This may return an incomplete 'isInfinite' lowering on self-recursion. In
+    // this case, the non-layout flags have their default values.
+    SILTypeProperties classifyTypeParameters(CanType type, TypeConverter &tc,
+                                             TypeExpansionContext expansion) {
+      TypeConverter::NonLayoutTypeRAII nonLayoutLowering(tc);
+      SILTypeProperties props;
+      if (auto bgt = dyn_cast<BoundGenericType>(type)) {
+        for (auto paramType : bgt->getGenericArgs()) {
+          // Use an opaque abstraction pattern for the element type because
+          // abstraction does not apply to the generic parameter itself.
+          AbstractionPattern origElementType = AbstractionPattern::getOpaque();
+          auto &lowering = tc.getTypeLowering(origElementType, paramType,
+                                              expansion);
+          props.addSubobject(lowering.getRecursiveProperties());
+        }
+      }
+      return props;
+    }
   };
 } // end anonymous namespace
 
@@ -2823,7 +2876,22 @@ void TypeConverter::removeNullEntry(const TypeKey &k) {
 void TypeConverter::insert(const TypeKey &k, const TypeLowering *tl) {
   if (!k.isCacheable()) return;
 
-  LoweredTypes[k.getCachingKey()] = tl;
+  if (isCacheableLowering(tl)) {
+    LoweredTypes[k.getCachingKey()] = tl;
+    if (k == k.getKeyForMinimalExpansion())
+      return;
+  }
+#ifndef NDEBUG
+  removeNullEntry(k.getKeyForMinimalExpansion());
+#endif
+}
+
+// Infinite lowerings are incomplete. They are only cached when they
+// correspond to a self-recursive layout, which can never have a complete
+// lowering. Avoid caching an infinite non-layout lowering so that the
+// complete layout can be lowered later.
+bool TypeConverter::isCacheableLowering(const TypeLowering *tl) {
+  return !tl || !isLoweringNonLayoutType || !tl->isInfinite();
 }
 
 /// Lower each of the elements of the substituted type according to
@@ -2981,9 +3049,6 @@ TypeConverter::getTypeLowering(AbstractionPattern origType,
     insert(key.getKeyForMinimalExpansion(), lowering);
   } else {
     insert(key, lowering);
-#ifndef NDEBUG
-    removeNullEntry(key.getKeyForMinimalExpansion());
-#endif
   }
 
 #ifndef NDEBUG
@@ -3168,7 +3233,7 @@ void TypeConverter::verifyLowering(const TypeLowering &lowering,
                                    AbstractionPattern origType,
                                    CanType substType,
                                    TypeExpansionContext forExpansion) {
-  if (TypeLoweringDisableVerification) {
+  if (TypeLoweringDisableVerification || !isCacheableLowering(&lowering)) {
     return;
   }
   verifyLexicalLowering(lowering, origType, substType, forExpansion);
@@ -3815,9 +3880,6 @@ const TypeLowering &TypeConverter::getTypeLoweringForLoweredType(
     insert(key.getKeyForMinimalExpansion(), lowering);
   else {
     insert(key, lowering);
-#ifndef NDEBUG
-    removeNullEntry(key.getKeyForMinimalExpansion());
-#endif
   }
 
   return *lowering;
@@ -5499,6 +5561,10 @@ void TypeLowering::print(llvm::raw_ostream &os) const {
      << ".\n"
      << "isLexical: " << BOOL(Properties.isLexical()) << ".\n"
      << "isOrContainsPack: " << BOOL(Properties.isOrContainsPack()) << ".\n"
+     << "isAddressableForDependencies: "
+     << BOOL(Properties.isAddressableForDependencies()) << ".\n"
+     << "hasOnlyDefaultDeinit: "
+     << BOOL(Properties.mayHaveCustomDeinit() == HasOnlyDefaultDeinit) << ".\n"
      << "\n";
 }
 

lib/SILOptimizer/Analysis/DestructorAnalysis.cpp

@@ -9,6 +9,10 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
+//
+// TODO: This pass is about to be removed because TypeLowering's CustomDeinit
+// property is superior.
+//===----------------------------------------------------------------------===//
 
 #include "swift/SILOptimizer/Analysis/DestructorAnalysis.h"
 #include "swift/SIL/SILInstruction.h"