pt.c (check_explicit_specialization): Allow old-style specialization of class templat...

	* pt.c (check_explicit_specialization): Allow old-style specialization
	of class template members.

From-SVN: r17836

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 08854db..1e3970c 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,8 @@
+Tue Feb 10 23:41:57 1998  Jason Merrill  <jason@yorick.cygnus.com>
+
+       * pt.c (check_explicit_specialization): Allow old-style specialization
+       of class template members.
+
 Tue Feb 10 20:36:52 1998  Jason Merrill  <jason@yorick.cygnus.com>
                          Manfred Hollstein  <manfred@s-direktnet.de>
 

diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 1176a5d..b4ee69e 100644 (file)
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -712,15 +712,13 @@ check_explicit_specialization (declarator, decl, template_count, flags)
 
          explicit_instantiation = 1;
        }
-      else if ((ctype != NULL_TREE
-               && !TYPE_BEING_DEFINED (ctype)
-               && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
-              || TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
+      else if (ctype != NULL_TREE
+              && !TYPE_BEING_DEFINED (ctype)
+              && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
        {
-         /* The first part of the above clause catches illegal code
-            that looks like this:
+         /* This case catches outdated code that looks like this:
 
-            template <class T> struct S { void f(); }
+            template <class T> struct S { void f(); };
             void S<int>::f() {} // Missing template <>
 
             We disable this check when the type is being defined to
@@ -728,18 +726,31 @@ check_explicit_specialization (declarator, decl, template_count, flags)
             constructors, destructors, and assignment operators.
             Since the type is an instantiation, not a specialization,
             these are the only functions that can be defined before
-            the class is complete.
+            the class is complete.  */
 
-            The second part handles bogus declarations like
+         /* If they said
+              template <class T> void S<int>::f() {}
+            that's bogus.  */
+         if (template_header_count)
+           {
+             cp_error ("template parameters specified in specialization");
+             return decl;
+           }
+
+         if (pedantic)
+           cp_pedwarn
+             ("explicit specialization not preceded by `template <>'");
+         specialization = 1;
+         SET_DECL_TEMPLATE_SPECIALIZATION (decl);
+       }
+      else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
+       {
+         /* This case handles bogus declarations like
             template <> template <class T>
             void f<int>();  */
 
-         if (template_header_count > template_count)
-           cp_error ("template-id `%D' in declaration of primary template",
-                     declarator);
-         else
-           cp_error ("explicit specialization not preceded by `template <>'");
-
+         cp_error ("template-id `%D' in declaration of primary template",
+                   declarator);
          return decl;
        }
     }