[constant-folding] Teach constant folding how to transform Builtin.cond_fail => cond_fail.

When this was originally implemented, this transform was put into
SILCombine. This patch also puts it into constant folding so we can also perform
the transform at -Onone.

My hunch is that the reason why this isn't happening with the -Onone
serialization change is that we were relying only this code being specialized
before serialization in the stdlib. But transparent functions are now not
optimized until after serialization, so it isn't done. Rather than mess with
that, I just added the support here.

Author: gottesmm

lib/SILOptimizer/Utils/ConstantFolding.cpp

@@ -1784,6 +1784,33 @@ ConstantFolder::processWorkList() {
           WorkList.insert(User);
         }
 
+        // See if we have a CondFailMessage. If we do, see if we can transform
+        // it into a UTF8.
+        if (auto *bi = dyn_cast<BuiltinInst>(User)) {
+          if (auto kind = bi->getBuiltinKind()) {
+            if (*kind == BuiltinValueKind::CondFailMessage) {
+              // See if our original instruction was a string literal inst.
+              if (auto *sli = dyn_cast<StringLiteralInst>(I)) {
+                if (sli->getEncoding() == StringLiteralInst::Encoding::UTF8) {
+                  SILBuilderWithScope builder(bi);
+                  auto *cfi = builder.createCondFail(
+                      bi->getLoc(), bi->getOperand(0), sli->getValue());
+                  WorkList.insert(cfi);
+                  recursivelyDeleteTriviallyDeadInstructions(
+                      bi, /*force*/ true,
+                      [&](SILInstruction *DeadI) { WorkList.remove(DeadI); });
+                  InvalidateInstructions = true;
+                  continue;
+                }
+              }
+
+              // If we weren't able to simplify into a cond_fail, add it to the
+              // folded user set to see if the condfail msg is dead.
+              FoldedUsers.insert(bi);
+            }
+          }
+        }
+
         // Initialize ResultsInError as a None optional.
         //
         // We are essentially using this optional to represent 3 states: true,

test/SILOptimizer/constant_propagation.sil

@@ -988,3 +988,19 @@ bb0:
   %2 = builtin "ptrtoint_Int32"(%1 : $Builtin.RawPointer) : $Builtin.Int32
   return %2 : $Builtin.Int32
 }
+
+// Make sure that we perform the transformation, but do not eliminate the int1,
+// since we do not know what it is.
+//
+// CHECK-LABEL: sil @cond_fail_test : $@convention(thin) (Builtin.Int1) -> () {
+// CHECK-NOT: builtin
+// CHECK: cond_fail
+// CHECK-NOT: builtin
+// CHECK: } // end sil function 'cond_fail_test'
+sil @cond_fail_test : $@convention(thin) (Builtin.Int1) -> () {
+bb0(%0 : $Builtin.Int1):
+  %1 = string_literal utf8 "constant"
+  %2 = builtin "condfail_message"(%0 : $Builtin.Int1, %1 : $Builtin.RawPointer) : $()
+  %9999 = tuple()
+  return %9999 : $()
+}