[demangler][NFC] Rename SwapAndRestore to ScopedOverride

[urnathan]

Summary

The demangler has a utility class 'SwapAndRestore'. That name is confusing. It's not swapping anything, and the restore part happens at the object's destruction. What it's actually doing is allowing a override of some value that is dynamically accessible within the lifetime of a lexical scope. A better name, IMHO, is ScopedOverride, and a rename of its member variables.

[urnathan]

rebase

[dblaikie]

Maybe ScopedOverride?

[urnathan]

let's try with ScopedOverride

[dblaikie]

Looks good, thanks

libcxxabi/src/demangle/ItaniumDemangle.h

public:
 
   bool hasRHSComponentSlow(OutputBuffer &OB) const override {
     return Pointee->hasRHSComponent(OB);
   }
 
   void printLeft(OutputBuffer &OB) const override {
     if (Printing)
       return;
-    SwapAndRestore<bool> SavePrinting(Printing, true);
+    DynamicOverride<bool> SavePrinting(Printing, true);
     std::pair<ReferenceKind, const Node *> Collapsed = collapse(OB);
     if (!Collapsed.second)
       return;
     Collapsed.second->printLeft(OB);
     if (Collapsed.second->hasArray(OB))
       OB += " ";
     if (Collapsed.second->hasArray(OB) || Collapsed.second->hasFunction(OB))
       OB += "(";
 
     OB += (Collapsed.first == ReferenceKind::LValue ? "&" : "&&");
   }
   void printRight(OutputBuffer &OB) const override {
     if (Printing)
       return;
-    SwapAndRestore<bool> SavePrinting(Printing, true);
+    DynamicOverride<bool> SavePrinting(Printing, true);
     std::pair<ReferenceKind, const Node *> Collapsed = collapse(OB);
     if (!Collapsed.second)
       return;
     if (Collapsed.second->hasArray(OB) || Collapsed.second->hasFunction(OB))
       OB += ")";
     Collapsed.second->printRight(OB);
   }
 };

 public:
   TemplateTemplateParamDecl(Node *Name_, NodeArray Params_)
       : Node(KTemplateTemplateParamDecl, Cache::Yes), Name(Name_),
         Params(Params_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name, Params); }
 
   void printLeft(OutputBuffer &OB) const override {
-    SwapAndRestore<unsigned> LT(OB.GtIsGt, 0);
+    DynamicOverride<unsigned> LT(OB.GtIsGt, 0);
     OB += "template<";
     Params.printWithComma(OB);
     OB += "> typename ";
   }
 
   void printRight(OutputBuffer &OB) const override { Name->print(OB); }
 };
 
ParameterPackExpansion(const Node *Child_)
       : Node(KParameterPackExpansion), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Child); }
 
   const Node *getChild() const { return Child; }
 
   void printLeft(OutputBuffer &OB) const override {
     constexpr unsigned Max = std::numeric_limits<unsigned>::max();
-    SwapAndRestore<unsigned> SavePackIdx(OB.CurrentPackIndex, Max);
-    SwapAndRestore<unsigned> SavePackMax(OB.CurrentPackMax, Max);
+    DynamicOverride<unsigned> SavePackIdx(OB.CurrentPackIndex, Max);
+    DynamicOverride<unsigned> SavePackMax(OB.CurrentPackMax, Max);
     size_t StreamPos = OB.getCurrentPosition();
 
     // Print the first element in the pack. If Child contains a ParameterPack,
     // it will set up S.CurrentPackMax and print the first element.
     Child->print(OB);
 
     // No ParameterPack was found in Child. This can occur if we've found a pack
     // expansion on a <function-param>.

 public:
   TemplateArgs(NodeArray Params_) : Node(KTemplateArgs), Params(Params_) {}
 
   template<typename Fn> void match(Fn F) const { F(Params); }
 
   NodeArray getParams() { return Params; }
 
   void printLeft(OutputBuffer &OB) const override {
-    SwapAndRestore<unsigned> LT(OB.GtIsGt, 0);
+    DynamicOverride<unsigned> LT(OB.GtIsGt, 0);
     OB += "<";
     Params.printWithComma(OB);
     if (OB.back() == '>')
       OB += " ";
     OB += ">";
   }
 };
 
struct ForwardTemplateReference : Node {
   // We don't provide a matcher for these, because the value of the node is
   // not determined by its construction parameters, and it generally needs
   // special handling.
   template<typename Fn> void match(Fn F) const = delete;
 
   bool hasRHSComponentSlow(OutputBuffer &OB) const override {
     if (Printing)
       return false;
-    SwapAndRestore<bool> SavePrinting(Printing, true);
+    DynamicOverride<bool> SavePrinting(Printing, true);
     return Ref->hasRHSComponent(OB);
   }
   bool hasArraySlow(OutputBuffer &OB) const override {
     if (Printing)
       return false;
-    SwapAndRestore<bool> SavePrinting(Printing, true);
+    DynamicOverride<bool> SavePrinting(Printing, true);
     return Ref->hasArray(OB);
   }
   bool hasFunctionSlow(OutputBuffer &OB) const override {
     if (Printing)
       return false;
-    SwapAndRestore<bool> SavePrinting(Printing, true);
+    DynamicOverride<bool> SavePrinting(Printing, true);
     return Ref->hasFunction(OB);
   }
   const Node *getSyntaxNode(OutputBuffer &OB) const override {
     if (Printing)
       return this;
-    SwapAndRestore<bool> SavePrinting(Printing, true);
+    DynamicOverride<bool> SavePrinting(Printing, true);
     return Ref->getSyntaxNode(OB);
   }
 
   void printLeft(OutputBuffer &OB) const override {
     if (Printing)
       return;
-    SwapAndRestore<bool> SavePrinting(Printing, true);
+    DynamicOverride<bool> SavePrinting(Printing, true);
     Ref->printLeft(OB);
   }
   void printRight(OutputBuffer &OB) const override {
     if (Printing)
       return;
-    SwapAndRestore<bool> SavePrinting(Printing, true);
+    DynamicOverride<bool> SavePrinting(Printing, true);
     Ref->printRight(OB);
   }
 };
 
 struct NameWithTemplateArgs : Node {
   // name<template_args>
   Node *Name;
   Node *TemplateArgs;
ClosureTypeName(NodeArray TemplateParams_, NodeArray Params_,
         Params(Params_), Count(Count_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(TemplateParams, Params, Count);
   }
 
   void printDeclarator(OutputBuffer &OB) const {
     if (!TemplateParams.empty()) {
-      SwapAndRestore<unsigned> LT(OB.GtIsGt, 0);
+      DynamicOverride<unsigned> LT(OB.GtIsGt, 0);
       OB += "<";
       TemplateParams.printWithComma(OB);
       OB += ">";
     }
     OB.printOpen();
     Params.printWithComma(OB);
     OB.printClose();
   }
public:
   CastExpr(StringView CastKind_, const Node *To_, const Node *From_, Prec Prec_)
       : Node(KCastExpr, Prec_), CastKind(CastKind_), To(To_), From(From_) {}
 
   template<typename Fn> void match(Fn F) const { F(CastKind, To, From); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += CastKind;
     {
-      SwapAndRestore<unsigned> LT(OB.GtIsGt, 0);
+      DynamicOverride<unsigned> LT(OB.GtIsGt, 0);
       OB += "<";
       To->printLeft(OB);
       if (OB.back() == '>')
         OB += " ";
       OB += ">";
     }
     OB.printOpen();
     From->printAsOperand(OB);
AbstractManglingParser<Derived, Alloc>::parseUnnamedTypeName(NameState *State) {
 
   if (consumeIf("Ut")) {
     StringView Count = parseNumber();
     if (!consumeIf('_'))
       return nullptr;
     return make<UnnamedTypeName>(Count);
   }
   if (consumeIf("Ul")) {
-    SwapAndRestore<size_t> SwapParams(ParsingLambdaParamsAtLevel,
+    DynamicOverride<size_t> SwapParams(ParsingLambdaParamsAtLevel,
                                        TemplateParams.size());
     ScopedTemplateParamList LambdaTemplateParams(this);
 
     size_t ParamsBegin = Names.size();
     while (look() == 'T' &&
            StringView("yptn").find(look(1)) != StringView::npos) {
       Node *T = parseTemplateParamDecl();
       if (!T)
         return nullptr;

 //                   ::= li <source-name>  # operator ""
 //                   ::= v <digit> <source-name>  # vendor extended operator
 template <typename Derived, typename Alloc>
 Node *
 AbstractManglingParser<Derived, Alloc>::parseOperatorName(NameState *State) {
   if (const auto *Op = parseOperatorEncoding()) {
     if (Op->getKind() == OperatorInfo::CCast) {
       //              ::= cv <type>    # (cast)
-      SwapAndRestore<bool> SaveTemplate(TryToParseTemplateArgs, false);
+      DynamicOverride<bool> SaveTemplate(TryToParseTemplateArgs, false);
       // If we're parsing an encoding, State != nullptr and the conversion
       // operators' <type> could have a <template-param> that refers to some
       // <template-arg>s further ahead in the mangled name.
-      SwapAndRestore<bool> SavePermit(PermitForwardTemplateReferences,
+      DynamicOverride<bool> SavePermit(PermitForwardTemplateReferences,
                                        PermitForwardTemplateReferences ||
                                            State != nullptr);
       Node *Ty = getDerived().parseType();
       if (Ty == nullptr)
         return nullptr;
       if (State) State->CtorDtorConversion = true;
       return make<ConversionOperatorType>(Ty);
     }
 
     if (Op->getKind() >= OperatorInfo::Unnameable)
if (consumeIf('U')) {
     if (Qual.empty())
       return nullptr;
 
     // extension            ::= U <objc-name> <objc-type>  # objc-type<identifier>
     if (Qual.startsWith("objcproto")) {
       StringView ProtoSourceName = Qual.dropFront(std::strlen("objcproto"));
       StringView Proto;
       {
-        SwapAndRestore<const char *> SaveFirst(First, ProtoSourceName.begin()),
-                                     SaveLast(Last, ProtoSourceName.end());
+        DynamicOverride<const char *> SaveFirst(First, ProtoSourceName.begin()),
         Proto = parseBareSourceName();
       }
       if (Proto.empty())
         return nullptr;
       Node *Child = getDerived().parseQualifiedType();
       if (Child == nullptr)
         return nullptr;
       return make<ObjCProtoName>(Child, Proto);

 // cv <type> <expression>                               # conversion with one argument
 // cv <type> _ <expression>* E                          # conversion with a different number of arguments
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseConversionExpr() {
   if (!consumeIf("cv"))
     return nullptr;
   Node *Ty;
   {
-    SwapAndRestore<bool> SaveTemp(TryToParseTemplateArgs, false);
+    DynamicOverride<bool> SaveTemp(TryToParseTemplateArgs, false);
     Ty = getDerived().parseType();
   }
 
   if (Ty == nullptr)
     return nullptr;
 
   if (consumeIf('_')) {
     size_t ExprsBegin = Names.size();
case OperatorInfo::Call: {
       }
       return make<CallExpr>(Callee, popTrailingNodeArray(ExprsBegin),
                             Op->getPrecedence());
     }
     case OperatorInfo::CCast: {
       // C Cast: (type)expr
       Node *Ty;
       {
-        SwapAndRestore<bool> SaveTemp(TryToParseTemplateArgs, false);
+        DynamicOverride<bool> SaveTemp(TryToParseTemplateArgs, false);
         Ty = getDerived().parseType();
       }
       if (Ty == nullptr)
         return nullptr;
 
       size_t ExprsBegin = Names.size();
       bool IsMany = consumeIf('_');
       while (!consumeIf('E')) {

libcxxabi/src/demangle/Utility.h

public:
 
   bool empty() const { return CurrentPosition == 0; }
 
   char *getBuffer() { return Buffer; }
   char *getBufferEnd() { return Buffer + CurrentPosition - 1; }
   size_t getBufferCapacity() const { return BufferCapacity; }
 };
 
-template <class T> class SwapAndRestore {
-  T &Restore;
-  T OriginalValue;
+template <class T> class DynamicOverride {
+  T &Loc;
+  T Original;
 
 public:
-  SwapAndRestore(T &Restore_) : SwapAndRestore(Restore_, Restore_) {}
+  DynamicOverride(T &Loc_) : DynamicOverride(Loc_, Loc_) {}
 
-  SwapAndRestore(T &Restore_, T NewVal)
-      : Restore(Restore_), OriginalValue(Restore) {
-    Restore = std::move(NewVal);
+  DynamicOverride(T &Loc_, T NewVal) : Loc(Loc_), Original(Loc_) {
+    Loc_ = std::move(NewVal);
   }
-  ~SwapAndRestore() { Restore = std::move(OriginalValue); }
+  ~DynamicOverride() { Loc = std::move(Original); }
 
-  SwapAndRestore(const SwapAndRestore &) = delete;
-  SwapAndRestore &operator=(const SwapAndRestore &) = delete;
+  DynamicOverride(const DynamicOverride &) = delete;
+  DynamicOverride &operator=(const DynamicOverride &) = delete;
 };
 
 DEMANGLE_NAMESPACE_END
 
 #endif

llvm/include/llvm/Demangle/ItaniumDemangle.h

public:
 
   bool hasRHSComponentSlow(OutputBuffer &OB) const override {
     return Pointee->hasRHSComponent(OB);
   }
 
   void printLeft(OutputBuffer &OB) const override {
     if (Printing)
       return;
-    SwapAndRestore<bool> SavePrinting(Printing, true);
+    DynamicOverride<bool> SavePrinting(Printing, true);
     std::pair<ReferenceKind, const Node *> Collapsed = collapse(OB);
     if (!Collapsed.second)
       return;
     Collapsed.second->printLeft(OB);
     if (Collapsed.second->hasArray(OB))
       OB += " ";
     if (Collapsed.second->hasArray(OB) || Collapsed.second->hasFunction(OB))
       OB += "(";
 
     OB += (Collapsed.first == ReferenceKind::LValue ? "&" : "&&");
   }
   void printRight(OutputBuffer &OB) const override {
     if (Printing)
       return;
-    SwapAndRestore<bool> SavePrinting(Printing, true);
+    DynamicOverride<bool> SavePrinting(Printing, true);
     std::pair<ReferenceKind, const Node *> Collapsed = collapse(OB);
     if (!Collapsed.second)
       return;
     if (Collapsed.second->hasArray(OB) || Collapsed.second->hasFunction(OB))
       OB += ")";
     Collapsed.second->printRight(OB);
   }
 };

 public:
   TemplateTemplateParamDecl(Node *Name_, NodeArray Params_)
       : Node(KTemplateTemplateParamDecl, Cache::Yes), Name(Name_),
         Params(Params_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name, Params); }
 
   void printLeft(OutputBuffer &OB) const override {
-    SwapAndRestore<unsigned> LT(OB.GtIsGt, 0);
+    DynamicOverride<unsigned> LT(OB.GtIsGt, 0);
     OB += "template<";
     Params.printWithComma(OB);
     OB += "> typename ";
   }
 
   void printRight(OutputBuffer &OB) const override { Name->print(OB); }
 };
 
ParameterPackExpansion(const Node *Child_)
       : Node(KParameterPackExpansion), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Child); }
 
   const Node *getChild() const { return Child; }
 
   void printLeft(OutputBuffer &OB) const override {
     constexpr unsigned Max = std::numeric_limits<unsigned>::max();
-    SwapAndRestore<unsigned> SavePackIdx(OB.CurrentPackIndex, Max);
-    SwapAndRestore<unsigned> SavePackMax(OB.CurrentPackMax, Max);
+    DynamicOverride<unsigned> SavePackIdx(OB.CurrentPackIndex, Max);
+    DynamicOverride<unsigned> SavePackMax(OB.CurrentPackMax, Max);
     size_t StreamPos = OB.getCurrentPosition();
 
     // Print the first element in the pack. If Child contains a ParameterPack,
     // it will set up S.CurrentPackMax and print the first element.
     Child->print(OB);
 
     // No ParameterPack was found in Child. This can occur if we've found a pack
     // expansion on a <function-param>.

 public:
   TemplateArgs(NodeArray Params_) : Node(KTemplateArgs), Params(Params_) {}
 
   template<typename Fn> void match(Fn F) const { F(Params); }
 
   NodeArray getParams() { return Params; }
 
   void printLeft(OutputBuffer &OB) const override {
-    SwapAndRestore<unsigned> LT(OB.GtIsGt, 0);
+    DynamicOverride<unsigned> LT(OB.GtIsGt, 0);
     OB += "<";
     Params.printWithComma(OB);
     if (OB.back() == '>')
       OB += " ";
     OB += ">";
   }
 };
 
struct ForwardTemplateReference : Node {
   // We don't provide a matcher for these, because the value of the node is
   // not determined by its construction parameters, and it generally needs
   // special handling.
   template<typename Fn> void match(Fn F) const = delete;
 
   bool hasRHSComponentSlow(OutputBuffer &OB) const override {
     if (Printing)
       return false;
-    SwapAndRestore<bool> SavePrinting(Printing, true);
+    DynamicOverride<bool> SavePrinting(Printing, true);
     return Ref->hasRHSComponent(OB);
   }
   bool hasArraySlow(OutputBuffer &OB) const override {
     if (Printing)
       return false;
-    SwapAndRestore<bool> SavePrinting(Printing, true);
+    DynamicOverride<bool> SavePrinting(Printing, true);
     return Ref->hasArray(OB);
   }
   bool hasFunctionSlow(OutputBuffer &OB) const override {
     if (Printing)
       return false;
-    SwapAndRestore<bool> SavePrinting(Printing, true);
+    DynamicOverride<bool> SavePrinting(Printing, true);
     return Ref->hasFunction(OB);
   }
   const Node *getSyntaxNode(OutputBuffer &OB) const override {
     if (Printing)
       return this;
-    SwapAndRestore<bool> SavePrinting(Printing, true);
+    DynamicOverride<bool> SavePrinting(Printing, true);
     return Ref->getSyntaxNode(OB);
   }
 
   void printLeft(OutputBuffer &OB) const override {
     if (Printing)
       return;
-    SwapAndRestore<bool> SavePrinting(Printing, true);
+    DynamicOverride<bool> SavePrinting(Printing, true);
     Ref->printLeft(OB);
   }
   void printRight(OutputBuffer &OB) const override {
     if (Printing)
       return;
-    SwapAndRestore<bool> SavePrinting(Printing, true);
+    DynamicOverride<bool> SavePrinting(Printing, true);
     Ref->printRight(OB);
   }
 };
 
 struct NameWithTemplateArgs : Node {
   // name<template_args>
   Node *Name;
   Node *TemplateArgs;
ClosureTypeName(NodeArray TemplateParams_, NodeArray Params_,
         Params(Params_), Count(Count_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(TemplateParams, Params, Count);
   }
 
   void printDeclarator(OutputBuffer &OB) const {
     if (!TemplateParams.empty()) {
-      SwapAndRestore<unsigned> LT(OB.GtIsGt, 0);
+      DynamicOverride<unsigned> LT(OB.GtIsGt, 0);
       OB += "<";
       TemplateParams.printWithComma(OB);
       OB += ">";
     }
     OB.printOpen();
     Params.printWithComma(OB);
     OB.printClose();
   }
public:
   CastExpr(StringView CastKind_, const Node *To_, const Node *From_, Prec Prec_)
       : Node(KCastExpr, Prec_), CastKind(CastKind_), To(To_), From(From_) {}
 
   template<typename Fn> void match(Fn F) const { F(CastKind, To, From); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += CastKind;
     {
-      SwapAndRestore<unsigned> LT(OB.GtIsGt, 0);
+      DynamicOverride<unsigned> LT(OB.GtIsGt, 0);
       OB += "<";
       To->printLeft(OB);
       if (OB.back() == '>')
         OB += " ";
       OB += ">";
     }
     OB.printOpen();
     From->printAsOperand(OB);
AbstractManglingParser<Derived, Alloc>::parseUnnamedTypeName(NameState *State) {
 
   if (consumeIf("Ut")) {
     StringView Count = parseNumber();
     if (!consumeIf('_'))
       return nullptr;
     return make<UnnamedTypeName>(Count);
   }
   if (consumeIf("Ul")) {
-    SwapAndRestore<size_t> SwapParams(ParsingLambdaParamsAtLevel,
+    DynamicOverride<size_t> SwapParams(ParsingLambdaParamsAtLevel,
                                        TemplateParams.size());
     ScopedTemplateParamList LambdaTemplateParams(this);
 
     size_t ParamsBegin = Names.size();
     while (look() == 'T' &&
            StringView("yptn").find(look(1)) != StringView::npos) {
       Node *T = parseTemplateParamDecl();
       if (!T)
         return nullptr;

 //                   ::= li <source-name>  # operator ""
 //                   ::= v <digit> <source-name>  # vendor extended operator
 template <typename Derived, typename Alloc>
 Node *
 AbstractManglingParser<Derived, Alloc>::parseOperatorName(NameState *State) {
   if (const auto *Op = parseOperatorEncoding()) {
     if (Op->getKind() == OperatorInfo::CCast) {
       //              ::= cv <type>    # (cast)
-      SwapAndRestore<bool> SaveTemplate(TryToParseTemplateArgs, false);
+      DynamicOverride<bool> SaveTemplate(TryToParseTemplateArgs, false);
       // If we're parsing an encoding, State != nullptr and the conversion
       // operators' <type> could have a <template-param> that refers to some
       // <template-arg>s further ahead in the mangled name.
-      SwapAndRestore<bool> SavePermit(PermitForwardTemplateReferences,
+      DynamicOverride<bool> SavePermit(PermitForwardTemplateReferences,
                                        PermitForwardTemplateReferences ||
                                            State != nullptr);
       Node *Ty = getDerived().parseType();
       if (Ty == nullptr)
         return nullptr;
       if (State) State->CtorDtorConversion = true;
       return make<ConversionOperatorType>(Ty);
     }
 
     if (Op->getKind() >= OperatorInfo::Unnameable)
if (consumeIf('U')) {
     if (Qual.empty())
       return nullptr;
 
     // extension            ::= U <objc-name> <objc-type>  # objc-type<identifier>
     if (Qual.startsWith("objcproto")) {
       StringView ProtoSourceName = Qual.dropFront(std::strlen("objcproto"));
       StringView Proto;
       {
-        SwapAndRestore<const char *> SaveFirst(First, ProtoSourceName.begin()),
-                                     SaveLast(Last, ProtoSourceName.end());
+        DynamicOverride<const char *> SaveFirst(First, ProtoSourceName.begin()),
         Proto = parseBareSourceName();
       }
       if (Proto.empty())
         return nullptr;
       Node *Child = getDerived().parseQualifiedType();
       if (Child == nullptr)
         return nullptr;
       return make<ObjCProtoName>(Child, Proto);

 // cv <type> <expression>                               # conversion with one argument
 // cv <type> _ <expression>* E                          # conversion with a different number of arguments
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseConversionExpr() {
   if (!consumeIf("cv"))
     return nullptr;
   Node *Ty;
   {
-    SwapAndRestore<bool> SaveTemp(TryToParseTemplateArgs, false);
+    DynamicOverride<bool> SaveTemp(TryToParseTemplateArgs, false);
     Ty = getDerived().parseType();
   }
 
   if (Ty == nullptr)
     return nullptr;
 
   if (consumeIf('_')) {
     size_t ExprsBegin = Names.size();
case OperatorInfo::Call: {
       }
       return make<CallExpr>(Callee, popTrailingNodeArray(ExprsBegin),
                             Op->getPrecedence());
     }
     case OperatorInfo::CCast: {
       // C Cast: (type)expr
       Node *Ty;
       {
-        SwapAndRestore<bool> SaveTemp(TryToParseTemplateArgs, false);
+        DynamicOverride<bool> SaveTemp(TryToParseTemplateArgs, false);
         Ty = getDerived().parseType();
       }
       if (Ty == nullptr)
         return nullptr;
 
       size_t ExprsBegin = Names.size();
       bool IsMany = consumeIf('_');
       while (!consumeIf('E')) {

llvm/include/llvm/Demangle/Utility.h

public:
 
   bool empty() const { return CurrentPosition == 0; }
 
   char *getBuffer() { return Buffer; }
   char *getBufferEnd() { return Buffer + CurrentPosition - 1; }
   size_t getBufferCapacity() const { return BufferCapacity; }
 };
 
-template <class T> class SwapAndRestore {
-  T &Restore;
-  T OriginalValue;
+template <class T> class DynamicOverride {
+  T &Loc;
+  T Original;
 
 public:
-  SwapAndRestore(T &Restore_) : SwapAndRestore(Restore_, Restore_) {}
+  DynamicOverride(T &Loc_) : DynamicOverride(Loc_, Loc_) {}
 
-  SwapAndRestore(T &Restore_, T NewVal)
-      : Restore(Restore_), OriginalValue(Restore) {
-    Restore = std::move(NewVal);
+  DynamicOverride(T &Loc_, T NewVal) : Loc(Loc_), Original(Loc_) {
+    Loc_ = std::move(NewVal);
   }
-  ~SwapAndRestore() { Restore = std::move(OriginalValue); }
+  ~DynamicOverride() { Loc = std::move(Original); }
 
-  SwapAndRestore(const SwapAndRestore &) = delete;
-  SwapAndRestore &operator=(const SwapAndRestore &) = delete;
+  DynamicOverride(const DynamicOverride &) = delete;
+  DynamicOverride &operator=(const DynamicOverride &) = delete;
 };
 
 DEMANGLE_NAMESPACE_END
 
 #endif

llvm/lib/Demangle/RustDemangle.cpp

 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <cstring>
 #include <limits>
 
 using namespace llvm;
 
+using llvm::itanium_demangle::DynamicOverride;
 using llvm::itanium_demangle::OutputBuffer;
 using llvm::itanium_demangle::StringView;
-using llvm::itanium_demangle::SwapAndRestore;
 
 namespace {
 
 struct Identifier {
   StringView Name;
   bool Punycode;
 
   bool empty() const { return Name.empty(); }
template <typename Callable> void demangleBackref(Callable Demangler) {
     if (Error || Backref >= Position) {
       Error = true;
       return;
     }
 
     if (!Print)
       return;
 
-    SwapAndRestore<size_t> SavePosition(Position, Position);
+    DynamicOverride<size_t> SavePosition(Position, Position);
     Position = Backref;
     Demangler();
   }
 
   Identifier parseIdentifier();
   uint64_t parseOptionalBase62Number(char Tag);
   uint64_t parseBase62Number();
   uint64_t parseDecimalNumber();
bool Demangler::demangle(StringView Mangled) {
   }
   size_t Dot = Mangled.find('.');
   Input = Mangled.substr(0, Dot);
   StringView Suffix = Mangled.dropFront(Dot);
 
   demanglePath(IsInType::No);
 
   if (Position != Input.size()) {
-    SwapAndRestore<bool> SavePrint(Print, false);
+    DynamicOverride<bool> SavePrint(Print, false);
     demanglePath(IsInType::No);
   }
 
   if (Position != Input.size())
     Error = true;
 
   if (!Suffix.empty()) {
     print(" (");

 //      | "S"      // shim
 //      | <A-Z>    // other special namespaces
 //      | <a-z>    // internal namespaces
 bool Demangler::demanglePath(IsInType InType, LeaveGenericsOpen LeaveOpen) {
   if (Error || RecursionLevel >= MaxRecursionLevel) {
     Error = true;
     return false;
   }
-  SwapAndRestore<size_t> SaveRecursionLevel(RecursionLevel, RecursionLevel + 1);
+  DynamicOverride<size_t> SaveRecursionLevel(RecursionLevel,
+                                             RecursionLevel + 1);
 
   switch (consume()) {
   case 'C': {
     parseOptionalBase62Number('s');
     printIdentifier(parseIdentifier());
     break;
   }
   case 'M': {
bool Demangler::demanglePath(IsInType InType, LeaveGenericsOpen LeaveOpen) {
   }
 
   return false;
 }
 
 // <impl-path> = [<disambiguator>] <path>
 // <disambiguator> = "s" <base-62-number>
 void Demangler::demangleImplPath(IsInType InType) {
-  SwapAndRestore<bool> SavePrint(Print, false);
+  DynamicOverride<bool> SavePrint(Print, false);
   parseOptionalBase62Number('s');
   demanglePath(InType);
 }
 
 // <generic-arg> = <lifetime>
 //               | <type>
 //               | "K" <const>
 // <lifetime> = "L" <base-62-number>

 //          | "F" <fn-sig>                // fn(...) -> ...
 //          | "D" <dyn-bounds> <lifetime> // dyn Trait<Assoc = X> + Send + 'a
 //          | <backref>                   // backref
 void Demangler::demangleType() {
   if (Error || RecursionLevel >= MaxRecursionLevel) {
     Error = true;
     return;
   }
-  SwapAndRestore<size_t> SaveRecursionLevel(RecursionLevel, RecursionLevel + 1);
+  DynamicOverride<size_t> SaveRecursionLevel(RecursionLevel,
+                                             RecursionLevel + 1);
 
   size_t Start = Position;
   char C = consume();
   BasicType Type;
   if (parseBasicType(C, Type))
     return printBasicType(Type);
 
   switch (C) {
default:
     break;
   }
 }
 
 // <fn-sig> := [<binder>] ["U"] ["K" <abi>] {<type>} "E" <type>
 // <abi> = "C"
 //       | <undisambiguated-identifier>
 void Demangler::demangleFnSig() {
-  SwapAndRestore<size_t> SaveBoundLifetimes(BoundLifetimes, BoundLifetimes);
+  DynamicOverride<size_t> SaveBoundLifetimes(BoundLifetimes, BoundLifetimes);
   demangleOptionalBinder();
 
   if (consumeIf('U'))
     print("unsafe ");
 
   if (consumeIf('K')) {
     print("extern \"");
     if (consumeIf('C')) {
void Demangler::demangleFnSig() {
   } else {
     print(" -> ");
     demangleType();
   }
 }
 
 // <dyn-bounds> = [<binder>] {<dyn-trait>} "E"
 void Demangler::demangleDynBounds() {
-  SwapAndRestore<size_t> SaveBoundLifetimes(BoundLifetimes, BoundLifetimes);
+  DynamicOverride<size_t> SaveBoundLifetimes(BoundLifetimes, BoundLifetimes);
   print("dyn ");
   demangleOptionalBinder();
   for (size_t I = 0; !Error && !consumeIf('E'); ++I) {
     if (I > 0)
       print(" + ");
     demangleDynTrait();
   }
 }

 // <const> = <basic-type> <const-data>
 //         | "p"                          // placeholder
 //         | <backref>
 void Demangler::demangleConst() {
   if (Error || RecursionLevel >= MaxRecursionLevel) {
     Error = true;
     return;
   }
-  SwapAndRestore<size_t> SaveRecursionLevel(RecursionLevel, RecursionLevel + 1);
+  DynamicOverride<size_t> SaveRecursionLevel(RecursionLevel,
+                                             RecursionLevel + 1);
 
   char C = consume();
   BasicType Type;
   if (parseBasicType(C, Type)) {
     switch (Type) {
     case BasicType::I8:
     case BasicType::I16:
     case BasicType::I32: