[Demangle][Rust] Hide implementation details NFC

[tmiasko]

Summary

Move content of the "public" header into the implementation file.

This also renames two enumerations that were previously used through
rust_demangle:: scope, to avoid breaking a build bot with older
version of GCC that rejects uses of enumerator through E::A if there
is a variable with the same name as enumeration E in the scope.

[dblaikie]

Sounds alright

llvm/include/llvm/Demangle/RustDemangle.h

-//===--- RustDemangle.h -----------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_DEMANGLE_RUSTDEMANGLE_H
-#define LLVM_DEMANGLE_RUSTDEMANGLE_H
-
-#include "llvm/Demangle/DemangleConfig.h"
-#include "llvm/Demangle/StringView.h"
-#include "llvm/Demangle/Utility.h"
-#include <cstdint>
-
-namespace llvm {
-namespace rust_demangle {
-
-using llvm::itanium_demangle::OutputStream;
-using llvm::itanium_demangle::StringView;
-using llvm::itanium_demangle::SwapAndRestore;
-
-struct Identifier {
-  StringView Name;
-  bool Punycode;
-
-  bool empty() const { return Name.empty(); }
-};
-
-enum class BasicType {
-  Bool,
-  Char,
-  I8,
-  I16,
-  I32,
-  I64,
-  I128,
-  ISize,
-  U8,
-  U16,
-  U32,
-  U64,
-  U128,
-  USize,
-  F32,
-  F64,
-  Str,
-  Placeholder,
-  Unit,
-  Variadic,
-  Never,
-};
-
-enum class InType {
-  No,
-  Yes,
-};
-
-enum class LeaveOpen {
-  No,
-  Yes,
-};
-
-class Demangler {
-  // Maximum recursion level. Used to avoid stack overflow.
-  size_t MaxRecursionLevel;
-  // Current recursion level.
-  size_t RecursionLevel;
-  size_t BoundLifetimes;
-  // Input string that is being demangled with "_R" prefix removed.
-  StringView Input;
-  // Position in the input string.
-  size_t Position;
-
-  // When true, print methods append the output to the stream.
-  // When false, the output is suppressed.
-  bool Print;
-
-  // True if an error occurred.
-  bool Error;
-
-public:
-  // Demangled output.
-  OutputStream Output;
-
-  Demangler(size_t MaxRecursionLevel = 500);
-
-  bool demangle(StringView MangledName);
-
-private:
-  bool demanglePath(InType InType, LeaveOpen LeaveOpen = LeaveOpen::No);
-  void demangleImplPath(InType InType);
-  void demangleGenericArg();
-  void demangleType();
-  void demangleFnSig();
-  void demangleDynBounds();
-  void demangleDynTrait();
-  void demangleOptionalBinder();
-  void demangleConst();
-  void demangleConstInt();
-  void demangleConstBool();
-  void demangleConstChar();
-
-  template <typename Callable> void demangleBackref(Callable Demangler) {
-    uint64_t Backref = parseBase62Number();
-    if (Error || Backref >= Position) {
-      Error = true;
-      return;
-    }
-
-    if (!Print)
-      return;
-
-    SwapAndRestore<size_t> SavePosition(Position, Position);
-    Position = Backref;
-    Demangler();
-  }
-
-  Identifier parseIdentifier();
-  uint64_t parseOptionalBase62Number(char Tag);
-  uint64_t parseBase62Number();
-  uint64_t parseDecimalNumber();
-  uint64_t parseHexNumber(StringView &HexDigits);
-
-  void print(char C) {
-    if (Error || !Print)
-      return;
-
-    Output += C;
-  }
-
-  void print(StringView S) {
-    if (Error || !Print)
-      return;
-
-    Output += S;
-  }
-
-  void printDecimalNumber(uint64_t N) {
-    if (Error || !Print)
-      return;
-
-    Output << N;
-  }
-
-  void printBasicType(BasicType);
-  void printLifetime(uint64_t Index);
-
-  char look() const {
-    if (Error || Position >= Input.size())
-      return 0;
-
-    return Input[Position];
-  }
-
-  char consume() {
-    if (Error || Position >= Input.size()) {
-      Error = true;
-      return 0;
-    }
-
-    return Input[Position++];
-  }
-
-  bool consumeIf(char Prefix) {
-    if (Error || Position >= Input.size() || Input[Position] != Prefix)
-      return false;
-
-    Position += 1;
-    return true;
-  }
-
-  /// Computes A + B. When computation wraps around sets the error and returns
-  /// false. Otherwise assigns the result to A and returns true.
-  bool addAssign(uint64_t &A, const uint64_t B) {
-    if (A > std::numeric_limits<uint64_t>::max() - B) {
-      Error = true;
-      return false;
-    }
-
-    A += B;
-    return true;
-  }
-
-  /// Computes A * B. When computation wraps around sets the error and returns
-  /// false. Otherwise assigns the result to A and returns true.
-  bool mulAssign(uint64_t &A, const uint64_t B) {
-    if (B != 0 && A > std::numeric_limits<uint64_t>::max() / B) {
-      Error = true;
-      return false;
-    }
-
-    A *= B;
-    return true;
-  }
-};
-
-} // namespace rust_demangle
-} // namespace llvm
-
-#endif

llvm/lib/Demangle/RustDemangle.cpp

 //===--- RustDemangle.cpp ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a demangler for Rust v0 mangled symbols as specified in
 // https://rust-lang.github.io/rfcs/2603-rust-symbol-name-mangling-v0.html
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Demangle/RustDemangle.h"
 #include "llvm/Demangle/Demangle.h"
+#include "llvm/Demangle/StringView.h"
+#include "llvm/Demangle/Utility.h"
 
 #include <algorithm>
 #include <cassert>
+#include <cstdint>
 #include <cstring>
 #include <limits>
 
 using namespace llvm;
-using namespace rust_demangle;
+
+using llvm::itanium_demangle::OutputStream;
+using llvm::itanium_demangle::StringView;
+using llvm::itanium_demangle::SwapAndRestore;
+
+namespace {
+
+struct Identifier {
+  StringView Name;
+  bool Punycode;
+
+  bool empty() const { return Name.empty(); }
+};
+
+enum class BasicType {
+  Bool,
+  Char,
+  I8,
+  I16,
+  I32,
+  I64,
+  I128,
+  ISize,
+  U8,
+  U16,
+  U32,
+  U64,
+  U128,
+  USize,
+  F32,
+  F64,
+  Str,
+  Placeholder,
+  Unit,
+  Variadic,
+  Never,
+};
+
+enum class IsInType {
+  No,
+  Yes,
+};
+
+enum class LeaveGenericsOpen {
+  No,
+  Yes,
+};
+
+class Demangler {
+  // Maximum recursion level. Used to avoid stack overflow.
+  size_t MaxRecursionLevel;
+  // Current recursion level.
+  size_t RecursionLevel;
+  size_t BoundLifetimes;
+  // Input string that is being demangled with "_R" prefix removed.
+  StringView Input;
+  // Position in the input string.
+  size_t Position;
+  // When true, print methods append the output to the stream.
+  // When false, the output is suppressed.
+  bool Print;
+  // True if an error occurred.
+  bool Error;
+
+public:
+  // Demangled output.
+  OutputStream Output;
+
+  Demangler(size_t MaxRecursionLevel = 500);
+
+  bool demangle(StringView MangledName);
+
+private:
+  bool demanglePath(IsInType Type,
+                    LeaveGenericsOpen LeaveOpen = LeaveGenericsOpen::No);
+  void demangleImplPath(IsInType InType);
+  void demangleGenericArg();
+  void demangleType();
+  void demangleFnSig();
+  void demangleDynBounds();
+  void demangleDynTrait();
+  void demangleOptionalBinder();
+  void demangleConst();
+  void demangleConstInt();
+  void demangleConstBool();
+  void demangleConstChar();
+
+  template <typename Callable> void demangleBackref(Callable Demangler) {
+    uint64_t Backref = parseBase62Number();
+    if (Error || Backref >= Position) {
+      Error = true;
+      return;
+    }
+
+    if (!Print)
+      return;
+
+    SwapAndRestore<size_t> SavePosition(Position, Position);
+    Position = Backref;
+    Demangler();
+  }
+
+  Identifier parseIdentifier();
+  uint64_t parseOptionalBase62Number(char Tag);
+  uint64_t parseBase62Number();
+  uint64_t parseDecimalNumber();
+  uint64_t parseHexNumber(StringView &HexDigits);
+
+  void print(char C);
+  void print(StringView S);
+  void printDecimalNumber(uint64_t N);
+  void printBasicType(BasicType);
+  void printLifetime(uint64_t Index);
+
+  char look() const;
+  char consume();
+  bool consumeIf(char Prefix);
+
+  bool addAssign(uint64_t &A, uint64_t B);
+  bool mulAssign(uint64_t &A, uint64_t B);
+};
+
+} // namespace
 
 char *llvm::rustDemangle(const char *MangledName, char *Buf, size_t *N,
                          int *Status) {
   if (MangledName == nullptr || (Buf != nullptr && N == nullptr)) {
     if (Status != nullptr)
       *Status = demangle_invalid_args;
     return nullptr;
   }
bool Demangler::demangle(StringView Mangled) {
   BoundLifetimes = 0;
 
   if (!Mangled.consumeFront("_R")) {
     Error = true;
     return false;
   }
   Input = Mangled;
 
-  demanglePath(rust_demangle::InType::No);
+  demanglePath(IsInType::No);
 
   if (Position != Input.size()) {
     SwapAndRestore<bool> SavePrint(Print, false);
-    demanglePath(InType::No);
+    demanglePath(IsInType::No);
   }
 
   if (Position != Input.size())
     Error = true;
 
   return !Error;
 }
 

 //        | "N" <ns> <path> <identifier>   // ...::ident (nested path)
 //        | "I" <path> {<generic-arg>} "E" // ...<T, U> (generic args)
 //        | <backref>
 // <identifier> = [<disambiguator>] <undisambiguated-identifier>
 // <ns> = "C"      // closure
 //      | "S"      // shim
 //      | <A-Z>    // other special namespaces
 //      | <a-z>    // internal namespaces
-bool Demangler::demanglePath(InType InType, LeaveOpen LeaveOpen) {
+bool Demangler::demanglePath(IsInType InType, LeaveGenericsOpen LeaveOpen) {
   if (Error || RecursionLevel >= MaxRecursionLevel) {
     Error = true;
     return false;
   }
   SwapAndRestore<size_t> SaveRecursionLevel(RecursionLevel, RecursionLevel + 1);
 
   switch (consume()) {
   case 'C': {
case 'M': {
     print(">");
     break;
   }
   case 'X': {
     demangleImplPath(InType);
     print("<");
     demangleType();
     print(" as ");
-    demanglePath(rust_demangle::InType::Yes);
+    demanglePath(IsInType::Yes);
     print(">");
     break;
   }
   case 'Y': {
     print("<");
     demangleType();
     print(" as ");
-    demanglePath(rust_demangle::InType::Yes);
+    demanglePath(IsInType::Yes);
     print(">");
     break;
   }
   case 'N': {
     char NS = consume();
     if (!isLower(NS) && !isUpper(NS)) {
       Error = true;
       break;
if (isUpper(NS)) {
         print(Ident.Name);
       }
     }
     break;
   }
   case 'I': {
     demanglePath(InType);
     // Omit "::" when in a type, where it is optional.
-    if (InType == rust_demangle::InType::No)
+    if (InType == IsInType::No)
       print("::");
     print("<");
     for (size_t I = 0; !Error && !consumeIf('E'); ++I) {
       if (I > 0)
         print(", ");
       demangleGenericArg();
     }
-    if (LeaveOpen == rust_demangle::LeaveOpen::Yes)
+    if (LeaveOpen == LeaveGenericsOpen::Yes)
       return true;
     else
       print(">");
     break;
   }
   case 'B': {
     bool IsOpen = false;
     demangleBackref([&] { IsOpen = demanglePath(InType, LeaveOpen); });
     return IsOpen;
   }
   default:
     Error = true;
     break;
   }
 
   return false;
 }
 
 // <impl-path> = [<disambiguator>] <path>
 // <disambiguator> = "s" <base-62-number>
-void Demangler::demangleImplPath(InType InType) {
+void Demangler::demangleImplPath(IsInType InType) {
   SwapAndRestore<bool> SavePrint(Print, false);
   parseOptionalBase62Number('s');
   demanglePath(InType);
 }
 
 // <generic-arg> = <lifetime>
 //               | <type>
 //               | "K" <const>
if (consumeIf('L')) {
       Error = true;
     }
     break;
   case 'B':
     demangleBackref([&] { demangleType(); });
     break;
   default:
     Position = Start;
-    demanglePath(rust_demangle::InType::Yes);
+    demanglePath(IsInType::Yes);
     break;
   }
 }
 
 // <fn-sig> := [<binder>] ["U"] ["K" <abi>] {<type>} "E" <type>
 // <abi> = "C"
 //       | <undisambiguated-identifier>
 void Demangler::demangleFnSig() {
if (I > 0)
       print(" + ");
     demangleDynTrait();
   }
 }
 
 // <dyn-trait> = <path> {<dyn-trait-assoc-binding>}
 // <dyn-trait-assoc-binding> = "p" <undisambiguated-identifier> <type>
 void Demangler::demangleDynTrait() {
-  bool IsOpen = demanglePath(InType::Yes, LeaveOpen::Yes);
+  bool IsOpen = demanglePath(IsInType::Yes, LeaveGenericsOpen::Yes);
   while (!Error && consumeIf('p')) {
     if (!IsOpen) {
       IsOpen = true;
       print('<');
     } else {
       print(", ");
     }
     print(parseIdentifier().Name);
uint64_t Demangler::parseHexNumber(StringView &HexDigits) {
   }
 
   size_t End = Position - 1;
   assert(Start < End);
   HexDigits = Input.substr(Start, End - Start);
   return Value;
 }
 
+void Demangler::print(char C) {
+  if (Error || !Print)
+    return;
+
+  Output += C;
+}
+
+void Demangler::print(StringView S) {
+  if (Error || !Print)
+    return;
+
+  Output += S;
+}
+
+void Demangler::printDecimalNumber(uint64_t N) {
+  if (Error || !Print)
+    return;
+
+  Output << N;
+}
+
 // Prints a lifetime. An index 0 always represents an erased lifetime. Indices
 // starting from 1, are De Bruijn indices, referring to higher-ranked lifetimes
 // bound by one of the enclosing binders.
 void Demangler::printLifetime(uint64_t Index) {
   if (Index == 0) {
     print("'_");
     return;
   }
 
   if (Index - 1 >= BoundLifetimes) {
     Error = true;
     return;
   }
 
   uint64_t Depth = BoundLifetimes - Index;
   print('\'');
   if (Depth < 26) {
     char C = 'a' + Depth;
     print(C);
   } else {
     print('z');
     printDecimalNumber(Depth - 26 + 1);
   }
 }
+
+char Demangler::look() const {
+  if (Error || Position >= Input.size())
+    return 0;
+
+  return Input[Position];
+}
+
+char Demangler::consume() {
+  if (Error || Position >= Input.size()) {
+    Error = true;
+    return 0;
+  }
+
+  return Input[Position++];
+}
+
+bool Demangler::consumeIf(char Prefix) {
+  if (Error || Position >= Input.size() || Input[Position] != Prefix)
+    return false;
+
+  Position += 1;
+  return true;
+}
+
+/// Computes A + B. When computation wraps around sets the error and returns
+/// false. Otherwise assigns the result to A and returns true.
+bool Demangler::addAssign(uint64_t &A, uint64_t B) {
+  if (A > std::numeric_limits<uint64_t>::max() - B) {
+    Error = true;
+    return false;
+  }
+
+  A += B;
+  return true;
+}
+
+/// Computes A * B. When computation wraps around sets the error and returns
+/// false. Otherwise assigns the result to A and returns true.
+bool Demangler::mulAssign(uint64_t &A, uint64_t B) {
+  if (B != 0 && A > std::numeric_limits<uint64_t>::max() / B) {
+    Error = true;
+    return false;
+  }
+
+  A *= B;
+  return true;
+}