Rename variables to avoid shadowing warnings; NFC

GrammaTech · Jul 20, 2020 · 05cd88e · 05cd88e
1 parent 32d11cc
commit 05cd88e
Show file tree

Hide file tree

Showing 17 changed files with 46 additions and 49 deletions.
diff --git a/include/gtirb/AuxDataContainer.hpp b/include/gtirb/AuxDataContainer.hpp
@@ -273,7 +273,7 @@ class GTIRB_EXPORT_API AuxDataContainer : public Node {
 
 protected:
   AuxDataContainer(Context& C, Kind knd);
-  AuxDataContainer(Context& C, Kind knd, const UUID& Uuid);
+  AuxDataContainer(Context& C, Kind knd, const UUID& U);
 
 private:
   AuxDataSet AuxDatas;

diff --git a/include/gtirb/ByteInterval.hpp b/include/gtirb/ByteInterval.hpp
@@ -1937,7 +1937,7 @@ class GTIRB_EXPORT_API ByteInterval : public Node {
   ByteInterval(Context& C);
 
   ByteInterval(Context& C, std::optional<Addr> A, uint64_t S, uint64_t InitSize,
-               const UUID& Uuid);
+               const UUID& U);
 
   ByteInterval(Context& C, std::optional<Addr> A, uint64_t S,
                uint64_t InitSize);
@@ -1952,8 +1952,8 @@ class GTIRB_EXPORT_API ByteInterval : public Node {
 
   template <typename InputIterator>
   ByteInterval(Context& C, std::optional<Addr> A, uint64_t S, uint64_t InitSize,
-               InputIterator Begin, InputIterator End, const UUID& Uuid)
-      : ByteInterval(C, A, S, 0, Uuid) {
+               InputIterator Begin, InputIterator End, const UUID& U)
+      : ByteInterval(C, A, S, 0, U) {
     Bytes.insert(Bytes.end(), Begin, End);
     Bytes.resize(InitSize);
   }
@@ -1964,13 +1964,13 @@ class GTIRB_EXPORT_API ByteInterval : public Node {
   }
 
   template <typename InputIterator>
-  static ByteInterval*
-  Create(Context& C, std::optional<Addr> Address, InputIterator Begin,
-         InputIterator End, std::optional<uint64_t> Size,
-         std::optional<uint64_t> InitSize, const UUID& Uuid) {
+  static ByteInterval* Create(Context& C, std::optional<Addr> Address,
+                              InputIterator Begin, InputIterator End,
+                              std::optional<uint64_t> Size,
+                              std::optional<uint64_t> InitSize, const UUID& U) {
     return C.Create<ByteInterval>(
         C, Address, Size ? *Size : std::distance(Begin, End),
-        InitSize ? *InitSize : std::distance(Begin, End), Begin, End, Uuid);
+        InitSize ? *InitSize : std::distance(Begin, End), Begin, End, U);
   }
 
   /// \brief The protobuf message type used for serializing ByteInterval.

diff --git a/include/gtirb/CfgNode.hpp b/include/gtirb/CfgNode.hpp
@@ -37,7 +37,7 @@ class GTIRB_EXPORT_API CfgNode : public Node {
   /// \endcond
 protected:
   CfgNode(Context& C, Kind Knd) : Node(C, Knd) {}
-  CfgNode(Context& C, Kind Knd, const UUID& Uuid) : Node(C, Knd, Uuid) {}
+  CfgNode(Context& C, Kind Knd, const UUID& U) : Node(C, Knd, U) {}
 };
 
 } // namespace gtirb

diff --git a/include/gtirb/CodeBlock.hpp b/include/gtirb/CodeBlock.hpp
@@ -294,17 +294,17 @@ class GTIRB_EXPORT_API CodeBlock : public CfgNode {
   CodeBlock(Context& C) : CfgNode(C, Kind::CodeBlock) {}
   CodeBlock(Context& C, uint64_t S, uint64_t Decode)
       : CfgNode(C, Kind::CodeBlock), Size(S), DecodeMode(Decode) {}
-  CodeBlock(Context& C, uint64_t S, uint64_t Decode, const UUID& Uuid)
-      : CfgNode(C, Kind::CodeBlock, Uuid), Size(S), DecodeMode(Decode) {}
+  CodeBlock(Context& C, uint64_t S, uint64_t Decode, const UUID& U)
+      : CfgNode(C, Kind::CodeBlock, U), Size(S), DecodeMode(Decode) {}
 
   void setParent(ByteInterval* BI, CodeBlockObserver* O) {
     Parent = BI;
     Observer = O;
   }
 
   static CodeBlock* Create(Context& C, uint64_t Size, uint64_t DecodeMode,
-                           const UUID& Uuid) {
-    return C.Create<CodeBlock>(C, Size, DecodeMode, Uuid);
+                           const UUID& U) {
+    return C.Create<CodeBlock>(C, Size, DecodeMode, U);
   }
 
   /// \brief The protobuf message type used for serializing CodeBlock.

diff --git a/include/gtirb/DataBlock.hpp b/include/gtirb/DataBlock.hpp
@@ -41,12 +41,12 @@ class DataBlock;
 ///
 class GTIRB_EXPORT_API DataBlock : public Node {
   DataBlock(Context& C) : Node(C, Kind::DataBlock) {}
-  DataBlock(Context& C, uint64_t S, const UUID& Uuid)
-      : Node(C, Kind::DataBlock, Uuid), Size(S) {}
+  DataBlock(Context& C, uint64_t S, const UUID& U)
+      : Node(C, Kind::DataBlock, U), Size(S) {}
   DataBlock(Context& C, uint64_t S) : Node(C, Kind::DataBlock), Size(S) {}
 
-  static DataBlock* Create(Context& C, uint64_t S, const UUID& Uuid) {
-    return C.Create<DataBlock>(C, S, Uuid);
+  static DataBlock* Create(Context& C, uint64_t S, const UUID& U) {
+    return C.Create<DataBlock>(C, S, U);
   }
 
 public:

diff --git a/include/gtirb/IR.hpp b/include/gtirb/IR.hpp
@@ -75,10 +75,10 @@ class IR;
 
 class GTIRB_EXPORT_API IR : public AuxDataContainer {
   IR(Context& C);
-  IR(Context& C, const UUID& Uuid);
+  IR(Context& C, const UUID& U);
 
-  static IR* Create(Context& C, const UUID& Uuid) {
-    return C.Create<IR>(C, Uuid);
+  static IR* Create(Context& C, const UUID& U) {
+    return C.Create<IR>(C, U);
   }
 
   struct by_name {};

diff --git a/include/gtirb/Module.hpp b/include/gtirb/Module.hpp
@@ -153,10 +153,10 @@ class GTIRB_EXPORT_API Module : public AuxDataContainer {
 
   Module(Context& C);
   Module(Context& C, const std::string& N);
-  Module(Context& C, const std::string& N, const UUID& Uuid);
+  Module(Context& C, const std::string& N, const UUID& U);
 
-  static Module* Create(Context& C, const UUID& Uuid) {
-    return C.Create<Module>(C, "", Uuid);
+  static Module* Create(Context& C, const UUID& U) {
+    return C.Create<Module>(C, "", U);
   }
 
 public:

diff --git a/include/gtirb/Node.hpp b/include/gtirb/Node.hpp
@@ -117,7 +117,7 @@ class GTIRB_EXPORT_API Node {
   Node(Context& C, Kind Knd);
 
   /// \cond INTERNAL
-  Node(Context& C, Kind Knd, const UUID& Uuid);
+  Node(Context& C, Kind Knd, const UUID& U);
 
 private:
   Kind K;

diff --git a/include/gtirb/ProxyBlock.hpp b/include/gtirb/ProxyBlock.hpp
@@ -63,11 +63,10 @@ class GTIRB_EXPORT_API ProxyBlock : public CfgNode {
 
 private:
   ProxyBlock(Context& C) : CfgNode(C, Kind::ProxyBlock) {}
-  ProxyBlock(Context& C, const UUID& Uuid)
-      : CfgNode(C, Kind::ProxyBlock, Uuid) {}
+  ProxyBlock(Context& C, const UUID& U) : CfgNode(C, Kind::ProxyBlock, U) {}
 
-  static ProxyBlock* Create(Context& C, const UUID& Uuid) {
-    return C.Create<ProxyBlock>(C, Uuid);
+  static ProxyBlock* Create(Context& C, const UUID& U) {
+    return C.Create<ProxyBlock>(C, U);
   }
 
   void setModule(Module* M) { Parent = M; }

diff --git a/include/gtirb/Section.hpp b/include/gtirb/Section.hpp
@@ -64,11 +64,10 @@ enum class SectionFlag : uint8_t {
 class GTIRB_EXPORT_API Section : public Node {
   Section(Context& C);
   Section(Context& C, const std::string& N);
-  Section(Context& C, const std::string& N, const UUID& Uuid);
+  Section(Context& C, const std::string& N, const UUID& U);
 
-  static Section* Create(Context& C, const std::string& Name,
-                         const UUID& Uuid) {
-    return C.Create<Section>(C, Name, Uuid);
+  static Section* Create(Context& C, const std::string& Name, const UUID& U) {
+    return C.Create<Section>(C, Name, U);
   }
 
   struct by_address {};

diff --git a/include/gtirb/Symbol.hpp b/include/gtirb/Symbol.hpp
@@ -341,8 +341,8 @@ class GTIRB_EXPORT_API Symbol : public Node {
   Symbol(Context& C) : Node(C, Kind::Symbol) {}
   Symbol(Context& C, const std::string& N, bool AE)
       : Node(C, Kind::Symbol), Name(N), AtEnd(AE) {}
-  Symbol(Context& C, const std::string& N, bool AE, const UUID& Uuid)
-      : Node(C, Kind::Symbol, Uuid), Name(N), AtEnd(AE) {}
+  Symbol(Context& C, const std::string& N, bool AE, const UUID& U)
+      : Node(C, Kind::Symbol, U), Name(N), AtEnd(AE) {}
   Symbol(Context& C, Addr X, const std::string& N, bool AE)
       : Node(C, Kind::Symbol), Payload(X), Name(N), AtEnd(AE) {}
   template <typename NodeTy>
@@ -354,8 +354,8 @@ class GTIRB_EXPORT_API Symbol : public Node {
   }
 
   static Symbol* Create(Context& C, const std::string& Name, bool AtEnd,
-                        const UUID& Uuid) {
-    return C.Create<Symbol>(C, Name, AtEnd, Uuid);
+                        const UUID& U) {
+    return C.Create<Symbol>(C, Name, AtEnd, U);
   }
 
   void setParent(Module* M, SymbolObserver* O) {

diff --git a/src/AuxDataContainer.cpp b/src/AuxDataContainer.cpp
@@ -70,8 +70,8 @@ AuxDataContainer::AuxDataContainer(Context& C, Node::Kind knd) : Node(C, knd) {
   TypeMap.Locked = true;
 }
 
-AuxDataContainer::AuxDataContainer(Context& C, Node::Kind knd, const UUID& Uuid)
-    : Node(C, knd, Uuid) {
+AuxDataContainer::AuxDataContainer(Context& C, Node::Kind knd, const UUID& U)
+    : Node(C, knd, U) {
   // Once this is called, we outlaw registering new AuxData types.
   TypeMap.Locked = true;
 }

diff --git a/src/ByteInterval.cpp b/src/ByteInterval.cpp
@@ -53,8 +53,8 @@ ByteInterval::ByteInterval(Context& C, std::optional<Addr> A, uint64_t S,
       DBO(std::make_unique<DataBlockObserverImpl>(this)) {}
 
 ByteInterval::ByteInterval(Context& C, std::optional<Addr> A, uint64_t S,
-                           uint64_t InitSize, const UUID& Uuid)
-    : Node(C, Kind::ByteInterval, Uuid), Address(A), Size(S), Bytes(InitSize),
+                           uint64_t InitSize, const UUID& U)
+    : Node(C, Kind::ByteInterval, U), Address(A), Size(S), Bytes(InitSize),
       CBO(std::make_unique<CodeBlockObserverImpl>(this)),
       DBO(std::make_unique<DataBlockObserverImpl>(this)) {}
 

diff --git a/src/IR.cpp b/src/IR.cpp
@@ -105,8 +105,8 @@ IR::IR(Context& C)
     : AuxDataContainer(C, Kind::IR),
       MO(std::make_unique<ModuleObserverImpl>(this)) {}
 
-IR::IR(Context& C, const UUID& Uuid)
-    : AuxDataContainer(C, Kind::IR, Uuid),
+IR::IR(Context& C, const UUID& U)
+    : AuxDataContainer(C, Kind::IR, U),
       MO(std::make_unique<ModuleObserverImpl>(this)) {}
 
 class IRLoadErrorCategory : public std::error_category {

diff --git a/src/Module.cpp b/src/Module.cpp
@@ -74,8 +74,8 @@ Module::Module(Context& C, const std::string& N)
     : AuxDataContainer(C, Kind::Module), Name(N),
       SecObs(std::make_unique<SectionObserverImpl>(this)),
       SymObs(std::make_unique<SymbolObserverImpl>(this)) {}
-Module::Module(Context& C, const std::string& N, const UUID& Uuid)
-    : AuxDataContainer(C, Kind::Module, Uuid), Name(N),
+Module::Module(Context& C, const std::string& N, const UUID& U)
+    : AuxDataContainer(C, Kind::Module, U), Name(N),
       SecObs(std::make_unique<SectionObserverImpl>(this)),
       SymObs(std::make_unique<SymbolObserverImpl>(this)) {}
 

diff --git a/src/Node.cpp b/src/Node.cpp
@@ -21,8 +21,7 @@ using namespace gtirb;
 // TODO: accessing this object between threads requires synchronization.
 static boost::uuids::random_generator UUIDGenerator;
 
-Node::Node(Context& C, Kind Knd, const UUID& Uuid)
-    : K(Knd), Uuid(Uuid), Ctx(&C) {
+Node::Node(Context& C, Kind Knd, const UUID& U) : K(Knd), Uuid(U), Ctx(&C) {
   Ctx->registerNode(Uuid, this);
 }
 

diff --git a/src/Section.cpp b/src/Section.cpp
@@ -53,8 +53,8 @@ Section::Section(Context& C, const std::string& N)
     : Node(C, Kind::Section), Name(N),
       BIO(std::make_unique<ByteIntervalObserverImpl>(this)) {}
 
-Section::Section(Context& C, const std::string& N, const UUID& Uuid)
-    : Node(C, Kind::Section, Uuid), Name(N),
+Section::Section(Context& C, const std::string& N, const UUID& U)
+    : Node(C, Kind::Section, U), Name(N),
       BIO(std::make_unique<ByteIntervalObserverImpl>(this)) {}
 
 bool Section::operator==(const Section& Other) const {