IRGen: Destroy enums with deinit when they have one.

Author: jckarter

lib/IRGen/GenEnum.cpp

@@ -628,6 +628,10 @@ namespace {
     void consume(IRGenFunction &IGF, Explosion &src,
                  Atomicity atomicity,
                  SILType T) const override {
+      if (tryEmitConsumeUsingDeinit(IGF, src, T)) {
+        return;
+      }
+
       if (getLoadableSingleton())
         getLoadableSingleton()->consume(IGF, src, atomicity,
                                         getSingletonType(IGF.IGM, T));
@@ -639,6 +643,10 @@ namespace {
 
     void destroy(IRGenFunction &IGF, Address addr, SILType T,
                  bool isOutlined) const override {
+      if (tryEmitDestroyUsingDeinit(IGF, addr, T)) {
+        return;
+      }
+                 
       if (getSingleton() &&
           !getSingleton()->isTriviallyDestroyable(ResilienceExpansion::Maximal)) {
         if (!ElementsAreABIAccessible) {
@@ -2660,6 +2668,9 @@ namespace {
 
     void consume(IRGenFunction &IGF, Explosion &src,
                  Atomicity atomicity, SILType T) const override {
+      if (tryEmitConsumeUsingDeinit(IGF, src, T)) {
+        return;
+      }
       assert(TIK >= Loadable);
 
       switch (CopyDestroyKind) {
@@ -2784,6 +2795,10 @@ namespace {
 
     void destroy(IRGenFunction &IGF, Address addr, SILType T,
                  bool isOutlined) const override {
+      if (tryEmitDestroyUsingDeinit(IGF, addr, T)) {
+        return;
+      }
+
       if (CopyDestroyKind == TriviallyDestroyable) {
         return;
       }
@@ -4663,6 +4678,9 @@ namespace {
 
     void consume(IRGenFunction &IGF, Explosion &src,
                  Atomicity atomicity, SILType T) const override {
+      if (tryEmitConsumeUsingDeinit(IGF, src, T)) {
+        return;
+      }
       assert(TIK >= Loadable);
       switch (CopyDestroyKind) {
       case TriviallyDestroyable:
@@ -5006,6 +5024,10 @@ namespace {
 
     void destroy(IRGenFunction &IGF, Address addr, SILType T,
                  bool isOutlined) const override {
+      if (tryEmitDestroyUsingDeinit(IGF, addr, T)) {
+        return;
+      }
+
       if (CopyDestroyKind == TriviallyDestroyable) {
         return;
       }

lib/IRGen/GenType.cpp

@@ -2861,13 +2861,12 @@ static bool tryEmitDeinitCall(IRGenFunction &IGF,
   auto ty = T.getASTType();
   auto nominal = ty->getAnyNominal();
   // We are only concerned with move-only type deinits here.
-  if (!nominal || isa<ClassDecl>(nominal)) {
+  if (!nominal || !nominal->getValueTypeDestructor()) {
     return false;
   }
 
   auto deinit = IGF.getSILModule().lookUpMoveOnlyDeinit(nominal);
-  if (!deinit)
-    return false;
+  assert(deinit && "type has a deinit declared in AST but SIL deinit record is not present!");
 
   // The deinit should take a single value parameter of the nominal type, either
   // by @owned or indirect @in convention.

test/IRGen/moveonly_deinit.sil

@@ -143,12 +143,28 @@ entry(%b : $*MOStruct):
   return undef : $()
 }
 
+// CHECK-LABEL: define{{.*}}@destroy_enum_value(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    trunc
+// CHECK-NEXT:    zext
+// CHECK-NEXT:    call{{.*}}@destroy_enum(
+// CHECK-NEXT:    ret void
 sil @destroy_enum_value : $@convention(thin) (@owned MOEnum) -> () {
 entry(%b : $MOEnum):
   release_value %b : $MOEnum
   return undef : $()
 }
 
+// CHECK-LABEL: define{{.*}}@destroy_enum_value_indirect(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    bitcast
+// CHECK-NEXT:    load
+// CHECK-NEXT:    getelementptr
+// CHECK-NEXT:    bitcast
+// CHECK-NEXT:    load
+// CHECK-NEXT:    zext
+// CHECK-NEXT:    call{{.*}}@destroy_enum(
+// CHECK-NEXT:    ret void
 sil @destroy_enum_value_indirect : $@convention(thin) (@in MOEnum) -> () {
 entry(%b : $*MOEnum):
   destroy_addr %b : $*MOEnum
@@ -167,7 +183,7 @@ entry(%b : $MOComboStruct):
 
 // CHECK: define{{.*}}@[[COMBO_STRUCT_OUTLINED_DESTROY]](
 // CHECK:   call {{.*}} @destroy_struct
-// CH/ECK:   call {{.*}} @destroy_enum
+// CHECK:   call {{.*}} @destroy_enum
 // CHECK:   call {{.*}} @swift_release
 // CHECK:   ret {{.*}} %0
 
@@ -190,7 +206,7 @@ entry(%b : $MOComboEnum):
 // CHECK:      [[STRUCT]]:
 // CHECK:        call {{.*}} @destroy_struct
 // CHECK:      [[ENUM]]:
-// C/HECK:        call {{.*}} @destroy_enum
+// CHECK:        call {{.*}} @destroy_enum
 // CHECK:      [[CLASS]]:
 // CHECK:        call {{.*}} @swift_release
 
@@ -199,7 +215,7 @@ entry(%b : $MOComboEnum):
 
 // CHECK:       define{{.*}}@[[BOX_STRUCT_DESTRUCTOR]](
 // CHECK:        call {{.*}} @destroy_struct
-// C/HECK:        call {{.*}} @destroy_enum
+// CHECK:        call {{.*}} @destroy_enum
 // CHECK:        call {{.*}} @swift_release
 sil @box_struct : $@convention(thin) (@owned MOComboStruct) -> Builtin.NativeObject {
 entry(%0 : $MOComboStruct):
@@ -230,10 +246,10 @@ sil_moveonlydeinit MOSingleRefcountLikeStruct { @destroy_single_refcount_like_st
 // CHECK-LABEL: define {{.*}} @"{{.*}}8MOStructVwxx"
 // CHECK:         call {{.*}} @destroy_struct(
 // CHECK-LABEL: define {{.*}} @"{{.*}}6MOEnumOwxx"
-// C/HECK:         call {{.*}} @destroy_enum(
+// CHECK:         call {{.*}} @destroy_enum(
 // CHECK-LABEL: define {{.*}} @"{{.*}}13MOComboStructVwxx"
 // CHECK:         call {{.*}} @destroy_struct(
-// C/HECK:         call {{.*}} @destroy_enum(
+// CHECK:         call {{.*}} @destroy_enum(
 // CHECK:         call {{.*}} @swift_retain(
 // CHECK-LABEL: define {{.*}} @"{{.*}}11MOComboEnumOwxx"
 // CHECK:         call {{.*}} @[[COMBO_ENUM_OUTLINED_DESTROY]]