[variable-name-utils] Store a std::variant instead of a pointer union and add the ability to append StringRef.

CONTEXT: This code works by building up a stack of SIL values of values that
need to be transformed into a StringRef as part of generating our name path and
then as a second phase performs the conversion of those values to StringRef as
we pop from the stack.

This is the first in a string of commits that are going to refactor
VariableNameUtils so that the stack will only contain StringRef instead of SIL
entities. This will be accomplished by moving the SIL value -> StringRef code
from the combining part of the algorithm (where we drain the stack) to the
construction of the stack.

The reason why I am doing this is two fold:

1. By just storing StringRef into the stack I am simplifying the code. Today as
mentioned above in the context, we gather up the SILValue we want to process and
then just convert them to StringRef. This means that any time one has to add a
new instruction, one has to update two different pieces of code. By trafficking
in StringRef instead, one only has to update one piece of code.

2. I want to add some simple code that allows for us to get names from closures
which would require me to recurse. I am nervous about putting
values/instructions from different functions in the same data structure. Today
it is safe, but it is bad practice. Instead, by just using StringRef in the
stack, I can avoid this problem.

Author: gottesmm

include/swift/SILOptimizer/Utils/VariableNameUtils.h

@@ -109,7 +109,7 @@ class VariableNameInferrer {
   ///
   /// Has to be a small vector since we push/pop the last segment start. This
   /// lets us speculate when processing phis.
-  VariableNamePathArray<PointerUnion<SILInstruction *, SILValue>, 4>
+  VariableNamePathArray<std::variant<SILInstruction *, SILValue, StringRef>, 4>
       variableNamePath;
 
   /// The root value of our string.

lib/SILOptimizer/Utils/VariableNameUtils.cpp

@@ -655,7 +655,13 @@ StringRef VariableNameInferrer::getNameFromDecl(Decl *d) {
 void VariableNameInferrer::popSingleVariableName() {
   auto next = variableNamePath.pop_back_val();
 
-  if (auto *inst = next.dyn_cast<SILInstruction *>()) {
+  if (std::holds_alternative<StringRef>(next)) {
+    resultingString += std::get<StringRef>(next);
+    return;
+  }
+
+  if (std::holds_alternative<SILInstruction *>(next)) {
+    auto *inst = std::get<SILInstruction *>(next);
     if (auto i = DebugVarCarryingInst(inst)) {
       resultingString += i.getName();
       return;
@@ -722,25 +728,27 @@ void VariableNameInferrer::popSingleVariableName() {
     return;
   }
 
-  auto value = next.get<SILValue>();
-  if (auto *fArg = dyn_cast<SILFunctionArgument>(value)) {
-    resultingString += fArg->getDecl()->getBaseName().userFacingName();
-    return;
-  }
+  if (std::holds_alternative<SILValue>(next)) {
+    auto value = std::get<SILValue>(next);
+    if (auto *fArg = dyn_cast<SILFunctionArgument>(value)) {
+      resultingString += fArg->getDecl()->getBaseName().userFacingName();
+      return;
+    }
 
-  if (auto *dti = dyn_cast_or_null<DestructureTupleInst>(
-          value->getDefiningInstruction())) {
-    llvm::raw_svector_ostream stream(resultingString);
-    stream << *dti->getIndexOfResult(value);
-    return;
-  }
+    if (auto *dti = dyn_cast_or_null<DestructureTupleInst>(
+            value->getDefiningInstruction())) {
+      llvm::raw_svector_ostream stream(resultingString);
+      stream << *dti->getIndexOfResult(value);
+      return;
+    }
 
-  if (auto *dsi = dyn_cast_or_null<DestructureStructInst>(
-          value->getDefiningInstruction())) {
-    unsigned index = *dsi->getIndexOfResult(value);
-    resultingString +=
-        getNameFromDecl(dsi->getStructDecl()->getStoredProperties()[index]);
-    return;
+    if (auto *dsi = dyn_cast_or_null<DestructureStructInst>(
+            value->getDefiningInstruction())) {
+      unsigned index = *dsi->getIndexOfResult(value);
+      resultingString +=
+          getNameFromDecl(dsi->getStructDecl()->getStoredProperties()[index]);
+      return;
+    }
   }
 
   resultingString += "<unknown decl>";