[Mangler] Change the Swift mangler into a symbol builder.

This commit changes the Swift mangler from a utility that writes tokens into a
stream into a name-builder that has two phases: "building a name", and "ready".
This clear separation is needed for the implementation of the compression layer.

Users of the mangler can continue to build the name using the mangleXXX methods,
but to access the results the users of the mangler need to call the finalize()
method. This method can write the result into a stream, like before, or return
an std::string.

Author: nadavrot

include/swift/AST/Mangle.h

@@ -35,14 +35,18 @@ enum class OperatorFixity {
 };
 
 
-/// A class for mangling declarations.
+/// A class for mangling declarations. The Mangler accumulates name fragments
+/// with the mangleXXX methods, and the final string is constructed with the
+/// `finalize` method, after which the Mangler should not be used.
 class Mangler {
   struct ArchetypeInfo {
     unsigned Depth;
     unsigned Index;
   };
 
-  raw_ostream &Buffer;
+  llvm::SmallVector<char, 128> Storage;
+  llvm::raw_svector_ostream Buffer;
+
   llvm::DenseMap<const void *, unsigned> Substitutions;
   llvm::DenseMap<const ArchetypeType *, ArchetypeInfo> Archetypes;
   CanGenericSignature CurGenericSignature;
@@ -84,14 +88,30 @@ class Mangler {
     ~ContextStack() { M.ArchetypesDepth = OldDepth; }
   };
 
+  /// Finish the mangling of the symbol and return the mangled name.
+  std::string finalize() {
+    assert(Storage.size() && "Mangling an empty name");
+    std::string result = std::string(Storage.data(), Storage.size());
+    Storage.clear();
+    return result;
+  }
+
+  /// Finish the mangling of the symbol and write the mangled name into
+  /// \p stream.
+  void finalize(llvm::raw_ostream &stream) {
+    assert(Storage.size() && "Mangling an empty name");
+    stream.write(Storage.data(), Storage.size());
+    Storage.clear();
+  }
+
   void setModuleContext(ModuleDecl *M) { Mod = M; }
 
   /// \param DWARFMangling - use the 'Qq' mangling format for
   /// archetypes and the 'a' mangling for alias types.
   /// \param usePunycode - emit modified Punycode instead of UTF-8.
-  Mangler(raw_ostream &buffer, bool DWARFMangling = false, 
+  Mangler(bool DWARFMangling = false,
           bool usePunycode = true)
-    : Buffer(buffer), DWARFMangling(DWARFMangling), UsePunycode(usePunycode) {}
+    : Buffer(Storage), DWARFMangling(DWARFMangling), UsePunycode(usePunycode) {}
   void mangleContextOf(const ValueDecl *decl, BindGenerics shouldBind);
   void mangleContext(const DeclContext *ctx, BindGenerics shouldBind);
   void mangleModule(const ModuleDecl *module);

include/swift/SIL/SILDeclRef.h

@@ -234,8 +234,7 @@ struct SILDeclRef {
   ///
   /// If 'prefix' is non-empty, it will be used in place of the standard '_T'
   /// prefix.
-  llvm::StringRef mangle(llvm::SmallVectorImpl<char> &buffer,
-                         StringRef prefix = {}) const;
+  std::string mangle(StringRef prefix = {}) const;
 
   /// True if the SILDeclRef references a function.
   bool isFunc() const {

lib/AST/Decl.cpp

@@ -2316,11 +2316,8 @@ ObjCClassKind ClassDecl::checkObjCAncestry() const {
 static StringRef mangleObjCRuntimeName(const NominalTypeDecl *nominal,
                                        llvm::SmallVectorImpl<char> &buffer) {
   {
-    buffer.clear();
-    llvm::raw_svector_ostream os(buffer);
-    
     // Mangle the type.
-    Mangle::Mangler mangler(os, false/*dwarf*/, false/*punycode*/);
+    Mangle::Mangler mangler(false/*dwarf*/, false/*punycode*/);
 
     // We add the "_Tt" prefix to make this a reserved name that will
     // not conflict with any valid Objective-C class or protocol name.
@@ -2334,8 +2331,13 @@ static StringRef mangleObjCRuntimeName(const NominalTypeDecl *nominal,
     } else {
       mangler.mangleProtocolDecl(cast<ProtocolDecl>(NTD));
     }
+
+    buffer.clear();
+    llvm::raw_svector_ostream os(buffer);
+    mangler.finalize(os);
   }
 
+  assert(buffer.size() && "Invalid buffer size");
   return StringRef(buffer.data(), buffer.size());
 }
 

lib/AST/Mangle.cpp

@@ -1281,19 +1281,20 @@ void Mangler::mangleType(Type type, ResilienceExpansion explosion,
       Buffer << 'q' << Index(info.Index);
 
       {
-      // The DWARF output created by Swift is intentionally flat,
-      // therefore archetypes are emitted with their DeclContext if
-      // they appear at the top level of a type (_Tt).
-      // Clone a new, non-DWARF Mangler for the DeclContext.
-      Mangler ContextMangler(Buffer, /*DWARFMangling=*/false);
-      SmallVector<const void *, 4> SortedSubsts(Substitutions.size());
-      for (auto S : Substitutions) SortedSubsts[S.second] = S.first;
-      for (auto S : SortedSubsts) ContextMangler.addSubstitution(S);
-      for (; relativeDepth > 0; --relativeDepth)
-        DC = DC->getParent();
-      assert(DC && "no decl context for archetype found");
-      if (!DC) return;
-      ContextMangler.mangleContext(DC, BindGenerics::None);
+        // The DWARF output created by Swift is intentionally flat,
+        // therefore archetypes are emitted with their DeclContext if
+        // they appear at the top level of a type (_Tt).
+        // Clone a new, non-DWARF Mangler for the DeclContext.
+        Mangler ContextMangler(/*DWARFMangling=*/false);
+        SmallVector<const void *, 4> SortedSubsts(Substitutions.size());
+        for (auto S : Substitutions) SortedSubsts[S.second] = S.first;
+        for (auto S : SortedSubsts) ContextMangler.addSubstitution(S);
+        for (; relativeDepth > 0; --relativeDepth)
+          DC = DC->getParent();
+        assert(DC && "no decl context for archetype found");
+        if (!DC) return;
+        ContextMangler.mangleContext(DC, BindGenerics::None);
+        ContextMangler.finalize(Buffer);
       }
 
     } else {

lib/AST/USRGeneration.cpp

@@ -71,7 +71,7 @@ bool ide::printDeclUSR(const ValueDecl *D, raw_ostream &OS) {
       return true;
 
   OS << getUSRSpacePrefix();
-  Mangler Mangler(OS);
+  Mangler Mangler;
   if (auto Ctor = dyn_cast<ConstructorDecl>(VD)) {
     Mangler.mangleConstructorEntity(Ctor, /*isAllocating=*/false,
         ResilienceExpansion::Minimal, /*uncurryingLevel=*/0);
@@ -87,6 +87,8 @@ bool ide::printDeclUSR(const ValueDecl *D, raw_ostream &OS) {
     Mangler.mangleEntity(VD, ResilienceExpansion::Minimal,
                          /*uncurryingLevel=*/0);
   }
+
+  Mangler.finalize(OS);
   return false;
 }
 
@@ -108,9 +110,10 @@ bool ide::printAccessorUSR(const AbstractStorageDecl *D, AccessorKind AccKind,
 
   AbstractStorageDecl *SD = const_cast<AbstractStorageDecl*>(D);
   OS << getUSRSpacePrefix();
-  Mangler Mangler(OS);
+  Mangler Mangler;
   Mangler.mangleAccessorEntity(AccKind, AddressorKind::NotAddressor,
                                SD, ResilienceExpansion::Minimal);
+  Mangler.finalize(OS);
   return false;
 }
 

lib/AST/Verifier.cpp

@@ -2603,13 +2603,9 @@ struct ASTNodeBase {};
     }
 
     void checkMangling(ValueDecl *D) {
-      llvm::SmallString<32> Buf;
-      llvm::raw_svector_ostream OS(Buf);
-      {
-      Mangle::Mangler Mangler(OS);
+      Mangle::Mangler Mangler;
       Mangler.mangleDeclName(D);
-      }
-      if (OS.str().empty()) {
+      if (Mangler.finalize().empty()) {
         Out << "Mangler gave empty string for a ValueDecl";
         abort();
       }

lib/IRGen/IRGenDebugInfo.cpp

@@ -1133,14 +1133,9 @@ StringRef IRGenDebugInfo::getMangledName(DebugTypeInfo DbgTy) {
   if (MetadataTypeDecl && DbgTy.getDecl() == MetadataTypeDecl)
     return BumpAllocatedString(DbgTy.getDecl()->getName().str());
 
-  llvm::SmallString<160> Buffer;
-  {
-    llvm::raw_svector_ostream S(Buffer);
-    Mangle::Mangler M(S, /* DWARF */ true);
-    M.mangleTypeForDebugger(DbgTy.getType(), DbgTy.getDeclContext());
-  }
-  assert(!Buffer.empty() && "mangled name came back empty");
-  return BumpAllocatedString(Buffer);
+  Mangle::Mangler M(/* DWARF */ true);
+  M.mangleTypeForDebugger(DbgTy.getType(), DbgTy.getDeclContext());
+  return BumpAllocatedString(M.finalize());
 }
 
 /// Create a member of a struct, class, tuple, or enum.