[clang] Rename SingleWarningStackAwareExecutor to StackExhaustionHand…

…ler.

clang/include/clang/Basic/SingleWarningStackAwareExecutor.h → clang/include/clang/Basic/StackExhaustionHandler.h

@@ -1,5 +1,5 @@
-//===--- SingleWarningStackAwareExecutor.h - A utility for warning once when
-// close to out of stack space -------*- C++ -*-===//
+//===--- StackExhaustionHandler.h - A utility for warning once when close to out
+// of stack space -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -12,15 +12,15 @@
 ///
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_BASIC_SINGLE_WARNING_STACK_AWARE_EXECUTOR_H
-#define LLVM_CLANG_BASIC_SINGLE_WARNING_STACK_AWARE_EXECUTOR_H
+#ifndef LLVM_CLANG_BASIC_STACK_EXHAUSTION_HANDLER_H
+#define LLVM_CLANG_BASIC_STACK_EXHAUSTION_HANDLER_H
 
 #include "clang/Basic/Diagnostic.h"
 
 namespace clang {
-class SingleWarningStackAwareExecutor {
+class StackExhaustionHandler {
 public:
-  SingleWarningStackAwareExecutor(DiagnosticsEngine &diags) : DiagsRef(diags) {}
+  StackExhaustionHandler(DiagnosticsEngine &diags) : DiagsRef(diags) {}
 
   /// Run some code with "sufficient" stack space. (Currently, at least 256K
   /// is guaranteed). Produces a warning if we're low on stack space and
@@ -42,4 +42,4 @@ class SingleWarningStackAwareExecutor {
 };
 } // end namespace clang
 
-#endif // LLVM_CLANG_BASIC_SINGLE_WARNING_STACK_AWARE_EXECUTOR_H
+#endif // LLVM_CLANG_BASIC_STACK_EXHAUSTION_HANDLER_H

clang/include/clang/Sema/Sema.h

@@ -47,9 +47,9 @@
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/PragmaKinds.h"
-#include "clang/Basic/SingleWarningStackAwareExecutor.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/Specifiers.h"
+#include "clang/Basic/StackExhaustionHandler.h"
 #include "clang/Basic/TemplateKinds.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Basic/TypeTraits.h"
@@ -1181,7 +1181,7 @@ class Sema final : public SemaBase {
   std::optional<std::unique_ptr<DarwinSDKInfo>> CachedDarwinSDKInfo;
   bool WarnedDarwinSDKInfoMissing = false;
 
-  SingleWarningStackAwareExecutor StackAwareExecutor;
+  StackExhaustionHandler StackHandler;
 
   Sema(const Sema &) = delete;
   void operator=(const Sema &) = delete;

clang/include/clang/Serialization/ASTReader.h

@@ -19,7 +19,7 @@
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/OpenCLOptions.h"
 #include "clang/Basic/SourceLocation.h"
-#include "clang/Basic/Stack.h"
+#include "clang/Basic/StackExhaustionHandler.h"
 #include "clang/Basic/Version.h"
 #include "clang/Lex/ExternalPreprocessorSource.h"
 #include "clang/Lex/HeaderSearch.h"
@@ -446,7 +446,7 @@ class ASTReader
   DiagnosticsEngine &Diags;
   // Sema has duplicate logic, but SemaObj can sometimes be null so ASTReader
   // has its own version.
-  SingleWarningStackAwareExecutor StackAwareExecutor;
+  StackExhaustionHandler StackHandler;
 
   /// The semantic analysis object that will be processing the
   /// AST files and the translation unit that uses it.

clang/lib/Basic/CMakeLists.txt

@@ -85,11 +85,11 @@ add_clang_library(clangBasic
   SanitizerSpecialCaseList.cpp
   Sanitizers.cpp
   Sarif.cpp
-  SingleWarningStackAwareExecutor.cpp
   SourceLocation.cpp
   SourceManager.cpp
   SourceMgrAdapter.cpp
   Stack.cpp
+  StackExhaustionHandler.cpp
   TargetID.cpp
   TargetInfo.cpp
   Targets.cpp

clang/lib/Basic/SingleWarningStackAwareExecutor.cpp → clang/lib/Basic/StackExhaustionHandler.cpp

@@ -1,5 +1,5 @@
-//===--- SingleWarningStackAwareExecutor.cpp -  - A utility for warning once
-// when close to out of stack space -------*- C++ -*-===//
+//===--- StackExhaustionHandler.cpp -  - A utility for warning once when close
+// to out of stack space -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -12,22 +12,21 @@
 ///
 //===----------------------------------------------------------------------===//
 
-#include "clang/Basic/SingleWarningStackAwareExecutor.h"
+#include "clang/Basic/StackExhaustionHandler.h"
 #include "clang/Basic/Stack.h"
 
-void clang::SingleWarningStackAwareExecutor::runWithSufficientStackSpace(
+void clang::StackExhaustionHandler::runWithSufficientStackSpace(
     SourceLocation Loc, llvm::function_ref<void()> Fn) {
   clang::runWithSufficientStackSpace([&] { warnStackExhausted(Loc); }, Fn);
 }
 
-void clang::SingleWarningStackAwareExecutor::warnOnStackNearlyExhausted(
+void clang::StackExhaustionHandler::warnOnStackNearlyExhausted(
     SourceLocation Loc) {
   if (isStackNearlyExhausted())
     warnStackExhausted(Loc);
 }
 
-void clang::SingleWarningStackAwareExecutor::warnStackExhausted(
-    SourceLocation Loc) {
+void clang::StackExhaustionHandler::warnStackExhausted(SourceLocation Loc) {
   // Only warn about this once.
   if (!WarnedStackExhausted) {
     DiagsRef.Report(Loc, diag::warn_stack_exhausted);

clang/lib/CodeGen/CodeGenModule.cpp

@@ -341,7 +341,7 @@ CodeGenModule::CodeGenModule(ASTContext &C,
     : Context(C), LangOpts(C.getLangOpts()), FS(FS), HeaderSearchOpts(HSO),
       PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags),
       Target(C.getTargetInfo()), ABI(createCXXABI(*this)),
-      VMContext(M.getContext()), VTables(*this), StackAwareExecutor(diags),
+      VMContext(M.getContext()), VTables(*this), StackHandler(diags),
       SanitizerMD(new SanitizerMetadata(*this)) {
 
   // Initialize the type cache.
@@ -1596,7 +1596,7 @@ void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type) {
 
 void CodeGenModule::runWithSufficientStackSpace(SourceLocation Loc,
                                                 llvm::function_ref<void()> Fn) {
-  StackAwareExecutor.runWithSufficientStackSpace(Loc, Fn);
+  StackHandler.runWithSufficientStackSpace(Loc, Fn);
 }
 
 llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {

clang/lib/CodeGen/CodeGenModule.h

@@ -26,7 +26,7 @@
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/NoSanitizeList.h"
 #include "clang/Basic/ProfileList.h"
-#include "clang/Basic/SingleWarningStackAwareExecutor.h"
+#include "clang/Basic/StackExhaustionHandler.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/XRayLists.h"
 #include "clang/Lex/PreprocessorOptions.h"
@@ -337,7 +337,7 @@ class CodeGenModule : public CodeGenTypeCache {
   std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader;
   InstrProfStats PGOStats;
   std::unique_ptr<llvm::SanitizerStatReport> SanStats;
-  SingleWarningStackAwareExecutor StackAwareExecutor;
+  StackExhaustionHandler StackHandler;
 
   // A set of references that have only been seen via a weakref so far. This is
   // used to remove the weak of the reference if we ever see a direct reference

clang/lib/Sema/Sema.cpp

@@ -220,7 +220,7 @@ Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
       AnalysisWarnings(*this), ThreadSafetyDeclCache(nullptr),
       LateTemplateParser(nullptr), LateTemplateParserCleanup(nullptr),
       OpaqueParser(nullptr), CurContext(nullptr), ExternalSource(nullptr),
-      StackAwareExecutor(Diags), CurScope(nullptr), Ident_super(nullptr),
+      StackHandler(Diags), CurScope(nullptr), Ident_super(nullptr),
       AMDGPUPtr(std::make_unique<SemaAMDGPU>(*this)),
       ARMPtr(std::make_unique<SemaARM>(*this)),
       AVRPtr(std::make_unique<SemaAVR>(*this)),
@@ -564,7 +564,7 @@ Sema::~Sema() {
 
 void Sema::runWithSufficientStackSpace(SourceLocation Loc,
                                        llvm::function_ref<void()> Fn) {
-  StackAwareExecutor.runWithSufficientStackSpace(Loc, Fn);
+  StackHandler.runWithSufficientStackSpace(Loc, Fn);
 }
 
 bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,

clang/lib/Sema/SemaTemplateInstantiate.cpp

@@ -806,7 +806,7 @@ void Sema::pushCodeSynthesisContext(CodeSynthesisContext Ctx) {
 
   // Check to see if we're low on stack space. We can't do anything about this
   // from here, but we can at least warn the user.
-  StackAwareExecutor.warnOnStackNearlyExhausted(Ctx.PointOfInstantiation);
+  StackHandler.warnOnStackNearlyExhausted(Ctx.PointOfInstantiation);
 }
 
 void Sema::popCodeSynthesisContext() {

clang/lib/Serialization/ASTReader.cpp

@@ -9657,7 +9657,7 @@ void ASTReader::runWithSufficientStackSpace(SourceLocation Loc,
     return;
   }
 
-  StackAwareExecutor.runWithSufficientStackSpace(Loc, Fn);
+  StackHandler.runWithSufficientStackSpace(Loc, Fn);
 }
 
 /// Retrieve the identifier table associated with the
@@ -10512,7 +10512,7 @@ ASTReader::ASTReader(Preprocessor &PP, InMemoryModuleCache &ModuleCache,
                    : cast<ASTReaderListener>(new PCHValidator(PP, *this))),
       SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
       PCHContainerRdr(PCHContainerRdr), Diags(PP.getDiagnostics()),
-      StackAwareExecutor(Diags), PP(PP), ContextObj(Context),
+      StackHandler(Diags), PP(PP), ContextObj(Context),
       ModuleMgr(PP.getFileManager(), ModuleCache, PCHContainerRdr,
                 PP.getHeaderSearchInfo()),
       DummyIdResolver(PP), ReadTimer(std::move(ReadTimer)), isysroot(isysroot),