PerformanceInliner: always inline synthesized enum comparisons if one of the operands is a constant enum

If there is a "constant" enum argument to a synthesized enum comparison, we can always inline it, because most of it will be constant folded anyway.
This ensures the compiler is not creating terrible code for very simple enum comparisons, like
```
   if someEnum == .someCase {
      ...
   }
```

rdar://85677499

Author: eeckstein

lib/SILOptimizer/Transforms/PerformanceInliner.cpp

@@ -524,6 +524,14 @@ static bool hasConstantArguments(FullApplySite fas) {
   return true;
 }
 
+static bool hasConstantEnumArgument(FullApplySite fas) {
+  for (SILValue arg : fas.getArguments()) {
+    if (isa<EnumInst>(arg))
+      return true;
+  }
+  return false;
+}
+
 bool SILPerformanceInliner::isProfitableToInline(
     FullApplySite AI, Weight CallerWeight, ConstantTracker &callerTracker,
     int &NumCallerBlocks,
@@ -597,6 +605,13 @@ bool SILPerformanceInliner::isProfitableToInline(
     return true;
   }
 
+  // If there is a "constant" enum argument to a synthesized enum comparison,
+  // we can always inline it, because most of it will be constant folded anyway.
+  if (Callee->hasSemanticsAttr(semantics::DERIVED_ENUM_EQUALS) &&
+      hasConstantEnumArgument(AI)) {
+    return true;
+  }
+
   // Bail out if this generic call can be optimized by means of
   // the generic specialization, because we prefer generic specialization
   // to inlining of generics.

test/SILOptimizer/enum-comparison.swift

@@ -26,6 +26,59 @@ func comparene(_ a: E, _ b: E) -> Bool {
   return a != b
 }
 
+enum LargeEnum: Equatable {
+  case a1, a2, a3, a4, a5, a6, a7, a8, a9
+  case b1, b2, b3, b4, b5, b6, b7, b8, b9
+  case c1, c2, c3, c4, c5, c6, c7, c8, c9
+  case d1, d2, d3, d4, d5, d6, d7, d8, d9
+  case e1(Int64), e2(Int64), e3(Int64), e4(Int64), e5(Int64), e6(Int64), e7(Int64), e8(Int64), e9(Int64)
+  case f1, f2, f3, f4, f5, f6, f7, f8, f9
+  case g1, g2, g3, g4, g5, g6, g7, g8, g9
+}
+
+// CHECK-LABEL: define {{.*}} i1 @"$s4test8compare1ySbAA9LargeEnumOF"(i64 %0, i8 %1)
+// CHECK:       entry:
+// CHECK-NEXT:    icmp
+// CHECK-NEXT:    icmp
+// CHECK-NEXT:    {{(and|select)}}
+// CHECK-NEXT:    ret
+@inline(never)
+func compare1(_ x: LargeEnum) -> Bool {
+  return x == .b2
+}
+
+// CHECK-LABEL: define {{.*}} i1 @"$s4test8compare2ySbAA9LargeEnumOF"(i64 %0, i8 %1)
+// CHECK:       entry:
+// CHECK-NEXT:    icmp
+// CHECK-NEXT:    icmp
+// CHECK-NEXT:    {{(and|select)}}
+// CHECK-NEXT:    ret
+@inline(never)
+func compare2(_ x: LargeEnum) -> Bool {
+  return .f2 == x
+}
+
+// CHECK-LABEL: define {{.*}} i1 @"$s4test8compare3ySbAA9LargeEnumOF"(i64 %0, i8 %1)
+// CHECK:       entry:
+// CHECK-NEXT:    icmp
+// CHECK-NEXT:    icmp
+// CHECK-NEXT:    {{(and|select)}}
+// CHECK-NEXT:    ret
+@inline(never)
+func compare3(_ x: LargeEnum) -> Bool {
+  return .e2(27) == x
+}
+
+// CHECK-LABEL: define {{.*}} i1 @"$s4test8compare4ySbAA9LargeEnumOF"(i64 %0, i8 %1)
+// CHECK:       entry:
+// CHECK-NEXT:    icmp
+// CHECK-NEXT:    icmp
+// CHECK-NEXT:    {{(and|select)}}
+// CHECK-NEXT:    ret
+@inline(never)
+func compare4(_ x: LargeEnum) -> Bool {
+  return x == .e3(28)
+}
 
 // OUT: 1: false
 print("1: \(compareeq(.c, .long_case_name_for_testing))")
@@ -39,3 +92,27 @@ print("3: \(comparene(.c, .long_case_name_for_testing))")
 // OUT: 4: false
 print("4: \(comparene(.c, .c))")
 
+// OUT: 5: false
+print("5: \(compare1(.b1))")
+
+// OUT: 6: true
+print("6: \(compare1(.b2))")
+
+// OUT: 7: false
+print("7: \(compare2(.b1))")
+
+// OUT: 8: true
+print("8: \(compare2(.f2))")
+
+// OUT: 9: true
+print("9: \(compare3(.e2(27)))")
+
+// OUT: 10: false
+print("10: \(compare3(.e2(28)))")
+
+// OUT: 11: true
+print("11: \(compare4(.e3(28)))")
+
+// OUT: 12: false
+print("12: \(compare4(.e3(27)))")
+