Fix MSVC mangling of consecutive pack template arguments

[DaveBartolomeo]

Summary

When mangling a template specialization where two consecutive template arguments are both packs, MSVC inserts the separator "$$Z" between the two arguments to disambiguate between the case of { { int, int }, { int } } and { { int }, { int, int } }. I've updated Clang's MSVC mangler to do the same, and added a test case to check that the separator is inserted correctly.

lib/AST/MicrosoftMangle.cpp

#undef TYPE
   void mangleCallingConvention(const FunctionType *T);
   void mangleIntegerLiteral(const llvm::APSInt &Number, bool IsBoolean);
   void mangleExpression(const Expr *E);
   void mangleThrowSpecification(const FunctionProtoType *T);
 
   void mangleTemplateArgs(const TemplateDecl *TD,
                           const TemplateArgumentList &TemplateArgs);
   void mangleTemplateArg(const TemplateDecl *TD, const TemplateArgument &TA,
-                         const NamedDecl *Parm);
+                         const NamedDecl *Parm, bool &PrevArgWasPack);
 };
 }
 
 bool MicrosoftMangleContextImpl::shouldMangleCXXName(const NamedDecl *D) {
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
     LanguageLinkage L = FD->getLanguageLinkage();
     // Overloadable functions need mangling.
     if (FD->hasAttr<OverloadableAttr>())

 void MicrosoftCXXNameMangler::mangleTemplateArgs(
     const TemplateDecl *TD, const TemplateArgumentList &TemplateArgs) {
   // <template-args> ::= <template-arg>+
   const TemplateParameterList *TPL = TD->getTemplateParameters();
   assert(TPL->size() == TemplateArgs.size() &&
          "size mismatch between args and parms!");
 
   unsigned Idx = 0;
+  bool PrevArgWasPack = false;
   for (const TemplateArgument &TA : TemplateArgs.asArray())
-    mangleTemplateArg(TD, TA, TPL->getParam(Idx++));
+    mangleTemplateArg(TD, TA, TPL->getParam(Idx++), PrevArgWasPack);
 }
 
 void MicrosoftCXXNameMangler::mangleTemplateArg(const TemplateDecl *TD,
                                                 const TemplateArgument &TA,
-                                                const NamedDecl *Parm) {
+                                                const NamedDecl *Parm,
+                                                bool &PrevArgWasPack) {
   // <template-arg> ::= <type>
   //                ::= <integer-literal>
   //                ::= <member-data-pointer>
   //                ::= <member-function-pointer>
   //                ::= $E? <name> <type-encoding>
   //                ::= $1? <name> <type-encoding>
   //                ::= $0A@
   //                ::= <template-args>
 
+  bool NeedsSeparatorBeforePack = PrevArgWasPack;
+  PrevArgWasPack = false;
+
   switch (TA.getKind()) {
   case TemplateArgument::Null:
     llvm_unreachable("Can't mangle null template arguments!");
   case TemplateArgument::TemplateExpansion:
     llvm_unreachable("Can't mangle template expansion arguments!");
   case TemplateArgument::Type: {
     QualType T = TA.getAsType();
     mangleType(T, SourceRange(), QMM_Escape);
case TemplateArgument::NullPtr: {
     }
     mangleIntegerLiteral(llvm::APSInt::getUnsigned(0), /*IsBoolean=*/false);
     break;
   }
   case TemplateArgument::Expression:
     mangleExpression(TA.getAsExpr());
     break;
   case TemplateArgument::Pack: {
+    PrevArgWasPack = true;
+    if (NeedsSeparatorBeforePack) {
+      // If two consecutive template args are packs, we need to distinguish
+      // between {{int}, {int, int}} and {{int, int}, {int}}. We emit a
+      // separator ("$$Z") between the two packs to mark where one pack ends
+      // and the next begins.
+      Out << "$$Z";
+    }
     ArrayRef<TemplateArgument> TemplateArgs = TA.getPackAsArray();
     if (TemplateArgs.empty()) {
       if (isa<TemplateTypeParmDecl>(Parm) ||
           isa<TemplateTemplateParmDecl>(Parm))
         // MSVC 2015 changed the mangling for empty expanded template packs,
         // use the old mangling for link compatibility for old versions.
         Out << (Context.getASTContext().getLangOpts().isCompatibleWithMSVC(
                     LangOptions::MSVC2015)
                     ? "$$V"
                     : "$$$V");
       else if (isa<NonTypeTemplateParmDecl>(Parm))
         Out << "$S";
       else
         llvm_unreachable("unexpected template parameter decl!");
     } else {
+      bool PrevArgInPackWasPack = false;
       for (const TemplateArgument &PA : TemplateArgs)
-        mangleTemplateArg(TD, PA, Parm);
+        mangleTemplateArg(TD, PA, Parm, PrevArgInPackWasPack);
     }
     break;
   }
   case TemplateArgument::Template: {
     const NamedDecl *ND =
         TA.getAsTemplate().getAsTemplateDecl()->getTemplatedDecl();
     if (const auto *TD = dyn_cast<TagDecl>(ND)) {
       mangleType(TD);

test/CodeGenCXX/mangle-ms-cxx11.cpp

 // __unaligned qualifier for function types
 struct unaligned_foo8_S {
     void unaligned_foo8() volatile __unaligned;
 };
 void unaligned_foo8_S::unaligned_foo8() volatile __unaligned {}
 
 // CHECK-DAG: @"\01?unaligned_foo8@unaligned_foo8_S@@QFCEXXZ"
 
+template<typename... T>
+struct my_tuple {};
+
+template<typename... A, typename... B>
+void print_tuples(const my_tuple<A...>& a, const my_tuple<B...>& b);
+
+void f() {
+  print_tuples(my_tuple<int>(), my_tuple<int, int>());
+  print_tuples(my_tuple<int, int>(), my_tuple<int>());
+}
+
+// CHECK-DAG: @"\01??$print_tuples@H$$ZHH@@YAXABU?$my_tuple@H@@ABU?$my_tuple@HH@@@Z"
+// CHECK-DAG: @"\01??$print_tuples@HH$$ZH@@YAXABU?$my_tuple@HH@@ABU?$my_tuple@H@@@Z"