deinit-devirtualization: completely de-compose non-copyable destroys

Even if the destroyed value doesn't have a deinit.
This fixes a false alarm when a non-copyable value ends its lifetime in a function with performance annotations.

rdar://117002721

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Utilities/Devirtualization.swift

@@ -30,7 +30,7 @@ func devirtualizeDeinits(of destroy: DestroyAddrInst, _ context: some MutatingCo
 
 private func devirtualize(destroy: some DevirtualizableDestroy, _ context: some MutatingContext) -> Bool {
   let type = destroy.type
-  guard type.isMoveOnly && type.selfOrAnyFieldHasValueDeinit(in: destroy.parentFunction) else {
+  if !type.isMoveOnly {
     return true
   }
   precondition(type.isNominal, "non-copyable non-nominal types not supported, yet")
@@ -47,9 +47,12 @@ private func devirtualize(destroy: some DevirtualizableDestroy, _ context: some
     // the struct fields or enum cases.
     if type.isStruct {
       result = destroy.devirtualizeStructFields(context)
-    } else {
-      precondition(type.isEnum, "unknown nominal value type")
+    } else if type.isEnum {
       result = destroy.devirtualizeEnumPayloads(context)
+    } else {
+      precondition(type.isClass, "unknown non-copyable type")
+      // A class reference cannot be further de-composed.
+      return true
     }
   }
   context.erase(instruction: destroy)

test/SILOptimizer/devirt_deinits.sil

@@ -47,6 +47,11 @@ import SwiftShims
   deinit
 }
 
+@_moveOnly struct S5 {
+  @_hasStorage let a: Int
+  @_hasStorage let b: AnyObject
+}
+
 // CHECK-LABEL: sil [ossa] @test_simple_struct :
 // CHECK:         [[D:%.*]] = function_ref @s1_deinit
 // CHECK:         apply [[D]](%0) : $@convention(method) (@owned S1) -> ()
@@ -72,6 +77,17 @@ bb0(%0 : @owned $StrWithoutDeinit):
   return %r : $()
 }
 
+// CHECK-LABEL: sil [ossa] @test_no_deinit :
+// CHECK:         ({{%.*}}, [[S2:%.*]]) = destructure_struct %0
+// CHECK-NEXT:    destroy_value [[S2]]
+// CHECK-NEXT:    tuple ()
+// CHECK:       } // end sil function 'test_no_deinit'
+sil [ossa] @test_no_deinit : $@convention(thin) (@owned S5) -> () {
+bb0(%0 : @owned $S5):
+  destroy_value %0 : $S5
+  %r = tuple()
+  return %r : $()
+}
 // CHECK-LABEL: sil [ossa] @test_indirect_deinit_arg :
 // CHECK:         [[D:%.*]] = function_ref @s3_deinit
 // CHECK:         [[S:%.*]] = alloc_stack $S3<Int>

test/SILOptimizer/moveonly_deinit_devirtualization.sil

@@ -284,7 +284,9 @@ bb2(%4 : $Builtin.Int32):
 
 
 bb3(%6 : @owned $(Klass, Klass)):
-  destroy_value %6 : $(Klass, Klass)
+  (%7, %8) = destructure_tuple %6 : $(Klass, Klass)
+  destroy_value %7 : $Klass
+  destroy_value %8 : $Klass
   br bb6
 
 bb4(%9 : $(Builtin.Int64, Builtin.Int64)):

test/SILOptimizer/moveonly_deinit_devirtualization_library_evolution.sil

@@ -285,7 +285,10 @@ bb2:
 
 bb3:
   %6 = unchecked_take_enum_data_addr %0 : $*NonTrivialMoveOnlyEnum, #NonTrivialMoveOnlyEnum.third
-  destroy_addr %6 : $*(Klass, Klass)
+  %7 = tuple_element_addr %6 : $*(Klass, Klass), 0
+  %8 = tuple_element_addr %6 : $*(Klass, Klass), 1
+  destroy_addr %7 : $*Klass
+  destroy_addr %8 : $*Klass
   br bb6
 
 bb4:

test/SILOptimizer/performance-annotations.swift

@@ -471,3 +471,12 @@ func useOfExistentialNoRuntime() -> P {
   Str(x: 1) // expected-error {{Using type 'any P' can cause metadata allocation or locks}}
 }
 
+public struct NonCopyable: ~Copyable {
+  var value: Int
+}
+
+@_noAllocation
+public func testNonCopyable(_ foo: consuming NonCopyable) {
+  let _ = foo.value
+}
+