Fix deserializing of class template partial specializations. Assign sequence

numbers as we deserialize class template partial specializations. We can't
assume that the old sequence numbers will work.

The sequence numbers are still deterministic, but are now a lot less
predictable for class template partial specializations in modules/PCH.

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

diff --git a/include/clang/AST/DeclTemplate.h b/include/clang/AST/DeclTemplate.h
index d301da8b3f56c708a2489d1482609130f229d795..89c0f05a8f640a4ebe5d70b1269db2d28a4d7e1f 100644 (file)
--- a/include/clang/AST/DeclTemplate.h
+++ b/include/clang/AST/DeclTemplate.h
@@ -1711,7 +1711,8 @@ public:
   }
 
   /// \brief Get the sequence number for this class template partial
-  /// specialization.
+  /// specialization. Internal, only valid for specializations which
+  /// are in the specialized class template's folding set.
   unsigned getSequenceNumber() const { return SequenceNumber; }
 
   /// \brief Retrieve the member class template partial specialization from
@@ -1928,7 +1929,9 @@ public:
 
   /// \brief Return the next partial specialization sequence number.
   unsigned getNextPartialSpecSequenceNumber() {
-    return getPartialSpecializations().size();
+    // Do not load lazy specializations here. They get numbered as they are
+    // loaded.
+    return getCommonPtr()->PartialSpecializations.size();
   }
 
   /// \brief Retrieve the partial specializations as an ordered list.

diff --git a/lib/Serialization/ASTReaderDecl.cpp b/lib/Serialization/ASTReaderDecl.cpp
index a7305c887d30b63a7be17259d03444fa348f86e4..df6abc934f99882b414584f6a0b87af66c500ee3 100644 (file)
--- a/lib/Serialization/ASTReaderDecl.cpp
+++ b/lib/Serialization/ASTReaderDecl.cpp
@@ -1458,9 +1458,12 @@ ASTDeclReader::VisitClassTemplateSpecializationDeclImpl(
   if (writtenAsCanonicalDecl) {
     ClassTemplateDecl *CanonPattern = ReadDeclAs<ClassTemplateDecl>(Record,Idx);
     if (D->isCanonicalDecl()) { // It's kept in the folding set.
-      if (ClassTemplatePartialSpecializationDecl *Partial
-                        = dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
-  CanonPattern->getCommonPtr()->PartialSpecializations.GetOrInsertNode(Partial);
+      if (ClassTemplatePartialSpecializationDecl *Partial =
+              dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
+        Partial->SequenceNumber =
+            CanonPattern->getNextPartialSpecSequenceNumber();
+        CanonPattern->getCommonPtr()->PartialSpecializations
+            .GetOrInsertNode(Partial);
       } else {
         CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
       }
@@ -1485,8 +1488,6 @@ void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
       D->ArgsAsWritten[i] = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
   }
 
-  D->SequenceNumber = Record[Idx++];
-
   // These are read/set from/to the first declaration.
   if (ThisDeclID == Redecl.getFirstID()) {
     D->InstantiatedFromMember.setPointer(

diff --git a/lib/Serialization/ASTWriterDecl.cpp b/lib/Serialization/ASTWriterDecl.cpp
index b60106408f15a0a2ed2eeda4abcca0f3d661f374..d8d351ae5f8fb7476e605763e4eae5fee627242e 100644 (file)
--- a/lib/Serialization/ASTWriterDecl.cpp
+++ b/lib/Serialization/ASTWriterDecl.cpp
@@ -1174,8 +1174,6 @@ void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl(
   for (int i = 0, e = D->getNumTemplateArgsAsWritten(); i != e; ++i)
     Writer.AddTemplateArgumentLoc(D->getTemplateArgsAsWritten()[i], Record);
 
-  Record.push_back(D->getSequenceNumber());
-
   // These are read/set from/to the first declaration.
   if (D->getPreviousDecl() == 0) {
     Writer.AddDeclRef(D->getInstantiatedFromMember(), Record);

diff --git a/test/Modules/Inputs/cxx-templates-a.h b/test/Modules/Inputs/cxx-templates-a.h
index 76997c7bdbca2220132b4ea3a903e535aaca9b05..7770d345ed5750981076d962418d41e0af543462 100644 (file)
--- a/test/Modules/Inputs/cxx-templates-a.h
+++ b/test/Modules/Inputs/cxx-templates-a.h
@@ -1,3 +1,5 @@
+@import cxx_templates_common;
+
 template<typename T> T f() { return T(); }
 template<typename T> T f(T);
 namespace N {
@@ -8,3 +10,7 @@ namespace N {
 template<int N> int template_param_kinds_1();
 template<template<typename T, int, int> class> int template_param_kinds_2();
 template<template<typename T, typename U, T> class> int template_param_kinds_3();
+
+template<typename T> struct SomeTemplate<T*>;
+template<typename T> struct SomeTemplate<T*> {};
+typedef SomeTemplate<int*> SomeTemplateIntPtr;

diff --git a/test/Modules/Inputs/cxx-templates-b.h b/test/Modules/Inputs/cxx-templates-b.h
index c50d7059b4b770bb38c4cf42494f8c3da9210571..e0f67d076c45e6cd928774fe23ca7cff551ed93e 100644 (file)
--- a/test/Modules/Inputs/cxx-templates-b.h
+++ b/test/Modules/Inputs/cxx-templates-b.h
@@ -1,3 +1,5 @@
+@import cxx_templates_common;
+
 template<typename T> T f();
 template<typename T> T f(T t) { return t; }
 namespace N {
@@ -8,3 +10,7 @@ namespace N {
 template<typename> int template_param_kinds_1();
 template<template<typename, int, int...> class> int template_param_kinds_2();
 template<template<typename T, typename U, U> class> int template_param_kinds_3();
+
+template<typename T> struct SomeTemplate<T&> {};
+template<typename T> struct SomeTemplate<T&>;
+typedef SomeTemplate<int&> SomeTemplateIntRef;

diff --git a/test/Modules/Inputs/cxx-templates-common.h b/test/Modules/Inputs/cxx-templates-common.h
new file mode 100644 (file)
index 0000000..950a2a6
--- /dev/null
+++ b/test/Modules/Inputs/cxx-templates-common.h
@@ -0,0 +1 @@
+template<typename T> struct SomeTemplate {};

diff --git a/test/Modules/Inputs/module.map b/test/Modules/Inputs/module.map
index d2ed75830b82c161f1cae17f198c456c4d651ee6..a4ac5b14de34d1424ae284d83b7574bc7bdeaed8 100644 (file)
--- a/test/Modules/Inputs/module.map
+++ b/test/Modules/Inputs/module.map
@@ -188,6 +188,10 @@ module cxx_linkage_cache {
   header "cxx-linkage-cache.h"
 }
 
+module cxx_templates_common {
+  header "cxx-templates-common.h"
+}
+
 module cxx_templates_a {
   header "cxx-templates-a.h"
 }

diff --git a/test/Modules/cxx-templates.cpp b/test/Modules/cxx-templates.cpp
index 7d500f4896c4e423dc52dbbbe06a104eb2445f2f..84c93df5a376f2989c7675a871f0886262046c41 100644 (file)
--- a/test/Modules/cxx-templates.cpp
+++ b/test/Modules/cxx-templates.cpp
@@ -17,37 +17,44 @@ void g() {
   f<double>(1.0);
   f<int>();
   f(); // expected-error {{no matching function}}
-  // expected-note@Inputs/cxx-templates-b.h:1 {{couldn't infer template argument}}
-  // expected-note@Inputs/cxx-templates-b.h:2 {{requires single argument}}
+  // expected-note@Inputs/cxx-templates-b.h:3 {{couldn't infer template argument}}
+  // expected-note@Inputs/cxx-templates-b.h:4 {{requires single argument}}
 
   N::f(0);
   N::f<double>(1.0);
   N::f<int>();
   N::f(); // expected-error {{no matching function}}
-  // expected-note@Inputs/cxx-templates-a.h:4 {{couldn't infer template argument}}
-  // expected-note@Inputs/cxx-templates-a.h:5 {{requires 1 argument, but 0 were provided}}
+  // expected-note@Inputs/cxx-templates-a.h:6 {{couldn't infer template argument}}
+  // expected-note@Inputs/cxx-templates-a.h:7 {{requires 1 argument, but 0 were provided}}
 
   template_param_kinds_1<0>(); // ok, from cxx-templates-a.h
   template_param_kinds_1<int>(); // ok, from cxx-templates-b.h
 
   template_param_kinds_2<Tmpl_T_C>(); // expected-error {{no matching function}}
-  // expected-note@Inputs/cxx-templates-a.h:9 {{invalid explicitly-specified argument}}
-  // expected-note@Inputs/cxx-templates-b.h:9 {{invalid explicitly-specified argument}}
+  // expected-note@Inputs/cxx-templates-a.h:11 {{invalid explicitly-specified argument}}
+  // expected-note@Inputs/cxx-templates-b.h:11 {{invalid explicitly-specified argument}}
 
   template_param_kinds_2<Tmpl_T_I_I>(); // expected-error {{ambiguous}}
-  // expected-note@Inputs/cxx-templates-a.h:9 {{candidate}}
-  // expected-note@Inputs/cxx-templates-b.h:9 {{candidate}}
+  // expected-note@Inputs/cxx-templates-a.h:11 {{candidate}}
+  // expected-note@Inputs/cxx-templates-b.h:11 {{candidate}}
 
   // FIXME: This should be valid, but we incorrectly match the template template
   // argument against both template template parameters.
   template_param_kinds_3<Tmpl_T_T_A>(); // expected-error {{ambiguous}}
-  // expected-note@Inputs/cxx-templates-a.h:10 {{candidate}}
-  // expected-note@Inputs/cxx-templates-b.h:10 {{candidate}}
+  // expected-note@Inputs/cxx-templates-a.h:12 {{candidate}}
+  // expected-note@Inputs/cxx-templates-b.h:12 {{candidate}}
   template_param_kinds_3<Tmpl_T_T_B>(); // expected-error {{ambiguous}}
-  // expected-note@Inputs/cxx-templates-a.h:10 {{candidate}}
-  // expected-note@Inputs/cxx-templates-b.h:10 {{candidate}}
+  // expected-note@Inputs/cxx-templates-a.h:12 {{candidate}}
+  // expected-note@Inputs/cxx-templates-b.h:12 {{candidate}}
 }
 
+@import cxx_templates_common;
+
+typedef SomeTemplate<int*> SomeTemplateIntPtr;
+typedef SomeTemplate<int&> SomeTemplateIntRef;
+SomeTemplate<char*> some_template_char_ptr;
+SomeTemplate<char&> some_template_char_ref;
+
 // FIXME: There should only be two 'f's here.
 // CHECK-GLOBAL:      DeclarationName 'f'
 // CHECK-GLOBAL-NEXT: |-FunctionTemplate {{.*}} 'f'