Prevent FunctionSignatureOpts to explode arguments if its type only has a single field.

This could happen in case the argument type is an enum and if one of the enum payloads has multiple non-trivial fields and only one of the values is released before the return.

Author: eeckstein

include/swift/SILOptimizer/Utils/FunctionSignatureOptUtils.h

@@ -104,6 +104,12 @@ struct ArgumentDescriptor {
     if (!canOptimizeLiveArg())
       return false;
 
+    // See if the projection tree consists of potentially multiple levels of
+    // structs containing one field. In such a case, there is no point in
+    // exploding the argument.
+    if (ProjTree.isSingleton())
+      return false;
+
     // If this argument is @owned and we can not find all the releases for it
     // try to explode it, maybe we can find some of the releases and O2G some
     // of its components.
@@ -114,12 +120,6 @@ struct ArgumentDescriptor {
         ERM.hasSomeReleasesForArgument(Arg))
       return true;
 
-    // See if the projection tree consists of potentially multiple levels of
-    // structs containing one field. In such a case, there is no point in
-    // exploding the argument.
-    if (ProjTree.isSingleton())
-      return false;
-
     size_t explosionSize = ProjTree.liveLeafCount();
     return explosionSize >= 1 && explosionSize <= 3;
   }

test/SILOptimizer/functionsigopts.sil

@@ -1300,6 +1300,32 @@ bb0(%0 : $Builtin.NativeObject, %1 : $Builtin.NativeObject):
   return %9999 : $()
 }
 
+
+// CHECK-NEGATIVE-NOT: sil {{.*}}_dont_explode_single_enum
+
+sil [noinline] @dont_explode_single_enum : $@convention(thin) (@owned Optional<(foo, foo)>) -> @owned foo {
+bb0(%0 : $Optional<(foo, foo)>):
+  %281 = unchecked_enum_data %0 : $Optional<(foo, foo)>, #Optional.some!enumelt.1
+  %282 = tuple_extract %281 : $(foo, foo), 0
+  %283 = tuple_extract %281 : $(foo, foo), 1
+  strong_release %283 : $foo
+  return %282 : $foo
+}
+
+
+
+// CHECK-LABEL: sil @call_with_single_enum
+// CHECK: [[F:%[0-9]+]] = function_ref @dont_explode_single_enum : $@convention(thin) (@owned Optional<(foo, foo)>) -> @owned foo
+// CHECK: apply [[F]](%0)
+// CHECK: return
+sil @call_with_single_enum : $@convention(thin) (@owned Optional<(foo, foo)>) -> @owned foo {
+bb0(%0 : $Optional<(foo, foo)>):
+  %f = function_ref @dont_explode_single_enum : $@convention(thin) (@owned Optional<(foo, foo)>) -> @owned foo
+  %a = apply %f(%0) : $@convention(thin) (@owned Optional<(foo, foo)>) -> @owned foo
+  return %a : $foo
+}
+
+
 // We should remove the array semantic from specialized calls.
 
 // CHECK-LABEL: sil [fragile] [thunk] [always_inline] [_semantics "array.foobar"] @array_semantic : $@convention(method) (@owned Builtin.NativeObject) -> () {