Merge pull request #81784 from atrick/typelower-customdeinit

atrick · web-flow · commit 09c828cbcbf1 · 2025-11-12T02:42:39.000-08:00
TypeLowering: add Type.hasCustomDeinit
diff --git a/SwiftCompilerSources/Sources/SIL/Type.swift b/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
   //===--------------------------------------------------------------------===//
diff --git a/include/swift/SIL/SILBridging.h b/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,
diff --git a/include/swift/SIL/SILBridgingImpl.h b/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());
 }
diff --git a/include/swift/SIL/SILType.h b/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().
diff --git a/include/swift/SIL/SILTypeProperties.h b/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
diff --git a/include/swift/SIL/TypeLowering.h b/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);
diff --git a/lib/SIL/IR/SILType.cpp b/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
diff --git a/lib/SIL/IR/TypeLowering.cpp b/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";
 }
 
diff --git a/lib/SILOptimizer/Analysis/DestructorAnalysis.cpp b/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"
diff --git a/test/SIL/type_lowering_unit.sil b/test/SIL/type_lowering_unit.sil
diff --git a/test/SILOptimizer/type_lowering_resilience.swift b/test/SILOptimizer/type_lowering_resilience.swift

Original file line number	Diff line number	Diff line change
`@@ -406,6 +406,10 @@ BridgedASTType BridgedType::getRawLayoutSubstitutedCountType() const {`
`406`	`406`	`return {unbridged().getRawLayoutSubstitutedCountType().getPointer()};`
`407`	`407`	`}`
`408`	`408`
	`409`	`+bool BridgedType::mayHaveCustomDeinit(BridgedFunction f) const {`
	`410`	`+ return unbridged().mayHaveCustomDeinit(*f.getFunction());`
	`411`	`+}`
	`412`	`+`
`409`	`413`	`SwiftInt BridgedType::getCaseIdxOfEnumType(BridgedStringRef name) const {`
`410`	`414`	`return unbridged().getCaseIdxOfEnumType(name.unbridged());`
`411`	`415`	`}`