[Mangler] Limit the lifetime of the Mangler

to make sure we are not accessing the buffer before the output is ready. The Mangler is going to be buffered (for compression), and accessing the underlying buffer is a bug.

Author: nadavrot

lib/AST/Mangle.cpp

@@ -1279,6 +1279,8 @@ void Mangler::mangleType(Type type, ResilienceExpansion explosion,
 
     if (DWARFMangling) {
       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).
@@ -1292,6 +1294,8 @@ void Mangler::mangleType(Type type, ResilienceExpansion explosion,
       assert(DC && "no decl context for archetype found");
       if (!DC) return;
       ContextMangler.mangleContext(DC, BindGenerics::None);
+      }
+
     } else {
       if (relativeDepth != 0) {
         Buffer << 'd' << Index(relativeDepth - 1);

lib/AST/Verifier.cpp

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

lib/SILGen/SILGenGlobalVariable.cpp

@@ -230,8 +230,10 @@ void SILGenModule::emitGlobalInitialization(PatternBindingDecl *pd,
   // Emit the initialization code into a function.
   llvm::SmallString<20> onceFuncBuffer;
   llvm::raw_svector_ostream onceFuncStream(onceFuncBuffer);
+  {
   Mangler funcMangler(onceFuncStream);
   funcMangler.mangleGlobalInit(varDecl, counter, true);
+  }
 
   SILFunction *onceFunc = emitLazyGlobalInitializer(onceFuncStream.str(), pd,
                                                     pbdEntry);

lib/SILOptimizer/IPO/CapturePropagation.cpp

@@ -70,6 +70,7 @@ static llvm::SmallString<64> getClonedName(PartialApplyInst *PAI,
   llvm::SmallString<64> ClonedName;
 
   llvm::raw_svector_ostream buffer(ClonedName);
+  {
   Mangle::Mangler M(buffer);
   auto P = SpecializationPass::CapturePropagation;
   FunctionSignatureSpecializationMangler Mangler(P, M, F);
@@ -79,6 +80,7 @@ static llvm::SmallString<64> getClonedName(PartialApplyInst *PAI,
   for (unsigned i : indices(Args))
     Mangler.setArgumentConstantProp(i, getConstant(Args[i]));
   Mangler.mangle();
+  }
 
   return ClonedName;
 }

lib/SILOptimizer/IPO/GlobalOpt.cpp

@@ -197,8 +197,10 @@ static SILFunction *genGetterFromInit(StoreInst *Store,
   auto *varDecl = SILG->getDecl();
   llvm::SmallString<20> getterBuffer;
   llvm::raw_svector_ostream getterStream(getterBuffer);
+  {
   Mangle::Mangler getterMangler(getterStream);
   getterMangler.mangleGlobalGetterEntity(varDecl);
+  }
 
   // Check if a getter was generated already.
   if (auto *F = Store->getModule().lookUpFunction(getterStream.str()))
@@ -459,8 +461,10 @@ static SILFunction *genGetterFromInit(SILFunction *InitF, VarDecl *varDecl) {
   // Generate a getter from the global init function without side-effects.
   llvm::SmallString<20> getterBuffer;
   llvm::raw_svector_ostream getterStream(getterBuffer);
+  {
   Mangle::Mangler getterMangler(getterStream);
   getterMangler.mangleGlobalGetterEntity(varDecl);
+  }
 
   // Check if a getter was generated already.
   if (auto *F = InitF->getModule().lookUpFunction(getterStream.str()))

lib/Serialization/Serialization.cpp

@@ -3650,9 +3650,11 @@ void Serializer::writeAST(ModuleOrSourceFile DC) {
 
       SmallString<32> MangledName;
       llvm::raw_svector_ostream Stream(MangledName);
+      {
       Mangle::Mangler DebugMangler(Stream, false);
       DebugMangler.mangleType(TD->getDeclaredType(),
                               ResilienceExpansion::Minimal, 0);
+      }
       assert(!MangledName.empty() && "Mangled type came back empty!");
       localTypeGenerator.insert(MangledName, {
         addDeclRef(TD), TD->getLocalDiscriminator()

tools/swift-ide-test/swift-ide-test.cpp

@@ -1462,8 +1462,11 @@ static int doPrintLocalTypes(const CompilerInvocation &InitInvok,
     for (auto LTD : LocalTypeDecls) {
       SmallString<64> MangledName;
       llvm::raw_svector_ostream Buffer(MangledName);
+      {
       Mangle::Mangler Mangler(Buffer, /*DWARFMangling*/ true);
-      Mangler.mangleTypeForDebugger(LTD->getDeclaredType(), LTD->getDeclContext());
+      Mangler.mangleTypeForDebugger(LTD->getDeclaredType(),
+                                    LTD->getDeclContext());
+      }
       MangledNames.push_back(Buffer.str());
     }