[variable-name-utils] Refactor inferName/inferNameAndRoot helpers onto VariableNameInferrer.

I have been using these in TransferNonSendable and they are useful in terms of
reducing the amount of code that one has to type to use this API. I am going to
need to use it in SILIsolationInfo, so it makes sense to move it into
SILOptimizer/Utils.

NFCI.

(cherry picked from commit 51ef67d)

Author: gottesmm

include/swift/SILOptimizer/Utils/VariableNameUtils.h

@@ -192,6 +192,15 @@ class VariableNameInferrer {
 
   StringRef getName() const { return resultingString; }
 
+  /// Given a specific SILValue, construct a VariableNameInferrer and use it to
+  /// attempt to infer an identifier for the value.
+  static std::optional<Identifier> inferName(SILValue value);
+
+  /// Given a specific SILValue, construct a VariableNameInferrer and use it to
+  /// attempt to infer an identifier for the value and a named value.
+  static std::optional<std::pair<Identifier, SILValue>>
+  inferNameAndRoot(SILValue value);
+
 private:
   void drainVariableNamePath();
   void popSingleVariableName();

lib/SILOptimizer/Mandatory/TransferNonSendable.cpp

@@ -92,34 +92,6 @@ static Expr *inferArgumentExprFromApplyExpr(ApplyExpr *sourceApply,
   return foundExpr;
 }
 
-static std::optional<Identifier> inferNameFromValue(SILValue value) {
-  auto *fn = value->getFunction();
-  if (!fn)
-    return {};
-  VariableNameInferrer::Options options;
-  options |= VariableNameInferrer::Flag::InferSelfThroughAllAccessors;
-  SmallString<64> resultingName;
-  VariableNameInferrer inferrer(fn, options, resultingName);
-  if (!inferrer.inferByWalkingUsesToDefsReturningRoot(value))
-    return {};
-  return fn->getASTContext().getIdentifier(resultingName);
-}
-
-static std::optional<std::pair<Identifier, SILValue>>
-inferNameAndRootFromValue(SILValue value) {
-  auto *fn = value->getFunction();
-  if (!fn)
-    return {};
-  VariableNameInferrer::Options options;
-  options |= VariableNameInferrer::Flag::InferSelfThroughAllAccessors;
-  SmallString<64> resultingName;
-  VariableNameInferrer inferrer(fn, options, resultingName);
-  SILValue rootValue = inferrer.inferByWalkingUsesToDefsReturningRoot(value);
-  if (!rootValue)
-    return {};
-  return {{fn->getASTContext().getIdentifier(resultingName), rootValue}};
-}
-
 //===----------------------------------------------------------------------===//
 //                             MARK: Diagnostics
 //===----------------------------------------------------------------------===//
@@ -693,7 +665,8 @@ bool UseAfterTransferDiagnosticInferrer::initForIsolatedPartialApply(
     emittedDiagnostic = true;
 
     auto &state = transferringOpToStateMap.get(transferOp);
-    if (auto rootValueAndName = inferNameAndRootFromValue(transferOp->get())) {
+    if (auto rootValueAndName =
+            VariableNameInferrer::inferNameAndRoot(transferOp->get())) {
       diagnosticEmitter.emitNamedIsolationCrossingDueToCapture(
           RegularLocation(std::get<0>(p).getLoc()), rootValueAndName->first,
           state.isolationInfo, std::get<2>(p));
@@ -815,7 +788,7 @@ void UseAfterTransferDiagnosticInferrer::infer() {
 
       // First try to do the named diagnostic if we can find a name.
       if (auto rootValueAndName =
-              inferNameAndRootFromValue(transferOp->get())) {
+              VariableNameInferrer::inferNameAndRoot(transferOp->get())) {
         return diagnosticEmitter.emitNamedUseOfStronglyTransferredValue(
             baseLoc, rootValueAndName->first);
       }
@@ -841,7 +814,8 @@ void UseAfterTransferDiagnosticInferrer::infer() {
   if (auto *sourceApply = loc.getAsASTNode<ApplyExpr>()) {
     // Before we do anything further, see if we can find a name and emit a name
     // error.
-    if (auto rootValueAndName = inferNameAndRootFromValue(transferOp->get())) {
+    if (auto rootValueAndName =
+            VariableNameInferrer::inferNameAndRoot(transferOp->get())) {
       auto &state = transferringOpToStateMap.get(transferOp);
       return diagnosticEmitter.emitNamedIsolationCrossingError(
           baseLoc, rootValueAndName->first, state.isolationInfo,
@@ -1178,7 +1152,7 @@ bool TransferNonTransferrableDiagnosticInferrer::run() {
 
         // See if we can infer a name from the value.
         SmallString<64> resultingName;
-        if (auto varName = inferNameFromValue(op->get())) {
+        if (auto varName = VariableNameInferrer::inferName(op->get())) {
           diagnosticEmitter.emitNamedFunctionArgumentApplyStronglyTransferred(
               loc, *varName);
           return true;
@@ -1218,7 +1192,7 @@ bool TransferNonTransferrableDiagnosticInferrer::run() {
 
     // See if we can infer a name from the value.
     SmallString<64> resultingName;
-    if (auto name = inferNameFromValue(op->get())) {
+    if (auto name = VariableNameInferrer::inferName(op->get())) {
       diagnosticEmitter.emitNamedIsolation(loc, *name, *isolation);
       return true;
     }
@@ -1266,7 +1240,7 @@ bool TransferNonTransferrableDiagnosticInferrer::run() {
              "All result info must be the same... if that changes... update "
              "this code!");
       SmallString<64> resultingName;
-      if (auto name = inferNameFromValue(op->get())) {
+      if (auto name = VariableNameInferrer::inferName(op->get())) {
         diagnosticEmitter.emitNamedTransferringReturn(loc, *name);
         return true;
       }

lib/SILOptimizer/Utils/VariableNameUtils.cpp

@@ -758,6 +758,34 @@ void VariableNameInferrer::drainVariableNamePath() {
   }
 }
 
+std::optional<Identifier> VariableNameInferrer::inferName(SILValue value) {
+  auto *fn = value->getFunction();
+  if (!fn)
+    return {};
+  VariableNameInferrer::Options options;
+  options |= VariableNameInferrer::Flag::InferSelfThroughAllAccessors;
+  SmallString<64> resultingName;
+  VariableNameInferrer inferrer(fn, options, resultingName);
+  if (!inferrer.inferByWalkingUsesToDefsReturningRoot(value))
+    return {};
+  return fn->getASTContext().getIdentifier(resultingName);
+}
+
+std::optional<std::pair<Identifier, SILValue>>
+VariableNameInferrer::inferNameAndRoot(SILValue value) {
+  auto *fn = value->getFunction();
+  if (!fn)
+    return {};
+  VariableNameInferrer::Options options;
+  options |= VariableNameInferrer::Flag::InferSelfThroughAllAccessors;
+  SmallString<64> resultingName;
+  VariableNameInferrer inferrer(fn, options, resultingName);
+  SILValue rootValue = inferrer.inferByWalkingUsesToDefsReturningRoot(value);
+  if (!rootValue)
+    return {};
+  return {{fn->getASTContext().getIdentifier(resultingName), rootValue}};
+}
+
 //===----------------------------------------------------------------------===//
 //                                MARK: Tests
 //===----------------------------------------------------------------------===//