Correctly mangle dependent TypenameType.

Fixes PR6625.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@98707 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/CodeGen/Mangle.cpp b/lib/CodeGen/Mangle.cpp
index 32555ab70579cbad12d1bbc6171e07490f8cd48b..f2a73f1c2d12cd5d67c551a41c1e2e55f8cd671d 100644 (file)
--- a/lib/CodeGen/Mangle.cpp
+++ b/lib/CodeGen/Mangle.cpp
@@ -469,8 +469,26 @@ void CXXNameMangler::mangleUnresolvedScope(NestedNameSpecifier *Qualifier) {
     mangleName(Qualifier->getAsNamespace());
     break;
   case NestedNameSpecifier::TypeSpec:
-  case NestedNameSpecifier::TypeSpecWithTemplate:
-    mangleType(QualType(Qualifier->getAsType(), 0));
+  case NestedNameSpecifier::TypeSpecWithTemplate: {
+    const Type *QTy = Qualifier->getAsType();
+
+    if (const TemplateSpecializationType *TST =
+        dyn_cast<TemplateSpecializationType>(QTy)) {
+      if (!mangleSubstitution(QualType(TST, 0))) {
+        TemplateDecl *TD = TST->getTemplateName().getAsTemplateDecl();
+        assert(TD && "FIXME: Support dependent template names");
+        mangleTemplatePrefix(TD);
+        TemplateParameterList *TemplateParameters = TD->getTemplateParameters();
+        mangleTemplateArgs(*TemplateParameters, TST->getArgs(),
+                           TST->getNumArgs());
+        addSubstitution(QualType(TST, 0));
+      }
+    } else {
+      // We use the QualType mangle type variant here because it handles
+      // substitutions.
+      mangleType(QualType(QTy, 0));
+    }
+  }
     break;
   case NestedNameSpecifier::Identifier:
     // Member expressions can have these without prefixes.
@@ -1144,29 +1162,8 @@ void CXXNameMangler::mangleType(const TemplateSpecializationType *T) {
 void CXXNameMangler::mangleType(const TypenameType *T) {
   // Typename types are always nested
   Out << 'N';
-
-  const Type *QTy = T->getQualifier()->getAsType();
-  if (const TemplateSpecializationType *TST =
-        dyn_cast<TemplateSpecializationType>(QTy)) {
-    if (!mangleSubstitution(QualType(TST, 0))) {
-      TemplateDecl *TD = TST->getTemplateName().getAsTemplateDecl();
-      assert(TD && "FIXME: Support dependent template names");
-      mangleTemplatePrefix(TD);
-      TemplateParameterList *TemplateParameters = TD->getTemplateParameters();
-      mangleTemplateArgs(*TemplateParameters, TST->getArgs(),
-                         TST->getNumArgs());
-      addSubstitution(QualType(TST, 0));
-    }
-  } else if (const TemplateTypeParmType *TTPT =
-              dyn_cast<TemplateTypeParmType>(QTy)) {
-    // We use the QualType mangle type variant here because it handles
-    // substitutions.
-    mangleType(QualType(TTPT, 0));
-  } else
-    assert(false && "Unhandled type!");
-
+  mangleUnresolvedScope(T->getQualifier());
   mangleSourceName(T->getIdentifier());
-
   Out << 'E';
 }
 

diff --git a/test/CodeGenCXX/mangle.cpp b/test/CodeGenCXX/mangle.cpp
index 8dee41beb4824dfda551acc87dfe3c6f92f95279..ec9c08c0ccaade64db899e926c13221fd86c3671 100644 (file)
--- a/test/CodeGenCXX/mangle.cpp
+++ b/test/CodeGenCXX/mangle.cpp
@@ -453,3 +453,18 @@ namespace test8 {
   class B { static int value; };
   template class A<B::value>;
 }
+// CHECK: declare void @_ZN5test91fIiNS_3barEEEvRKNT0_3baz1XE
+namespace test9 {
+  template<class T>
+  struct foo {
+    typedef T X;
+  };
+  struct bar {
+    typedef foo<int> baz;
+  };
+  template <class zaz, class zed>
+  void f(const typename zed::baz::X&);
+  void g() {
+    f<int, bar>( 0);
+  }
+}