c++: Small cleanup for do_type_instantiation

In working on a bigger cleanup I noticed some opportunities to make
do_type_instantiation's control flow simpler.

	gcc/cp/
	* parser.c (cp_parser_explicit_instantiation): Refactor some RAII.
	* pt.c (bt_instantiate_type_proc): DATA is the tree, pass type to
	do_type_instantiation.
	(do_type_instantiation): Require T to be a type.  Refactor for
	some RAII.

diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index cce3d0a679eb41dd3577bfeae9c9f20e676a4206..6a5469b553b1f85b9f86b805f30145840d1505dd 100644 (file)
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -17642,10 +17642,8 @@ cp_parser_explicit_instantiation (cp_parser* parser)
      instantiation.  */
   if (declares_class_or_enum && cp_parser_declares_only_class_p (parser))
     {
-      tree type;
-
-      type = check_tag_decl (&decl_specifiers,
-                            /*explicit_type_instantiation_p=*/true);
+      tree type = check_tag_decl (&decl_specifiers,
+                                 /*explicit_type_instantiation_p=*/true);
       /* Turn access control back on for names used during
         template instantiation.  */
       pop_deferring_access_checks ();
@@ -25156,14 +25154,12 @@ cp_parser_member_declaration (cp_parser* parser)
        }
       else
        {
-         tree type;
-
          /* See if this declaration is a friend.  */
          friend_p = cp_parser_friend_p (&decl_specifiers);
          /* If there were decl-specifiers, check to see if there was
             a class-declaration.  */
-         type = check_tag_decl (&decl_specifiers,
-                                /*explicit_type_instantiation_p=*/false);
+         tree type = check_tag_decl (&decl_specifiers,
+                                     /*explicit_type_instantiation_p=*/false);
          /* Nested classes have already been added to the class, but
             a `friend' needs to be explicitly registered.  */
          if (friend_p)

diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index dc664ec37983a89ee8be47429725b0577d6607b3..701f7c190fe23bd24409d76bcaf927b92b02fd19 100644 (file)
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -24964,12 +24964,12 @@ mark_class_instantiated (tree t, int extern_p)
 static void
 bt_instantiate_type_proc (binding_entry entry, void *data)
 {
-  tree storage = *(tree *) data;
+  tree storage = tree (data);
 
-  if (MAYBE_CLASS_TYPE_P (entry->type)
+  if (CLASS_TYPE_P (entry->type)
       && CLASSTYPE_TEMPLATE_INFO (entry->type)
       && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
-    do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
+    do_type_instantiation (entry->type, storage, 0);
 }
 
 /* Perform an explicit instantiation of template class T.  STORAGE, if
@@ -24980,20 +24980,11 @@ bt_instantiate_type_proc (binding_entry entry, void *data)
 void
 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
 {
-  int extern_p = 0;
-  int nomem_p = 0;
-  int static_p = 0;
-  int previous_instantiation_extern_p = 0;
-
-  if (TREE_CODE (t) == TYPE_DECL)
-    t = TREE_TYPE (t);
-
-  if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
+  if (!(CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INFO (t)))
     {
-      tree tmpl =
-       (TYPE_TEMPLATE_INFO (t)) ? TYPE_TI_TEMPLATE (t) : NULL;
-      if (tmpl)
-       error ("explicit instantiation of non-class template %qD", tmpl);
+      if (tree ti = TYPE_TEMPLATE_INFO (t))
+       error ("explicit instantiation of non-class template %qD",
+              TI_TEMPLATE (ti));
       else
        error ("explicit instantiation of non-template type %qT", t);
       return;
@@ -25009,6 +25000,11 @@ do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
       return;
     }
 
+  /* At most one of these will be true.  */
+  bool extern_p = false;
+  bool nomem_p = false;
+  bool static_p = false;
+
   if (storage != NULL_TREE)
     {
       if (storage == ridpointers[(int) RID_EXTERN])
@@ -25024,52 +25020,45 @@ do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
                 " on explicit instantiations", storage);
 
       if (storage == ridpointers[(int) RID_INLINE])
-       nomem_p = 1;
+       nomem_p = true;
       else if (storage == ridpointers[(int) RID_EXTERN])
-       extern_p = 1;
+       extern_p = true;
       else if (storage == ridpointers[(int) RID_STATIC])
-       static_p = 1;
+       static_p = true;
       else
-       {
-         error ("storage class %qD applied to template instantiation",
-                storage);
-         extern_p = 0;
-       }
+       error ("storage class %qD applied to template instantiation",
+              storage);
     }
 
   if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
-    {
-      /* DR 259 [temp.spec].
+    /* DR 259 [temp.spec].
 
-        Both an explicit instantiation and a declaration of an explicit
-        specialization shall not appear in a program unless the explicit
-        instantiation follows a declaration of the explicit specialization.
+       Both an explicit instantiation and a declaration of an explicit
+       specialization shall not appear in a program unless the
+       explicit instantiation follows a declaration of the explicit
+       specialization.
 
-        For a given set of template parameters, if an explicit
-        instantiation of a template appears after a declaration of an
-        explicit specialization for that template, the explicit
-        instantiation has no effect.  */
-      return;
-    }
-  else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
+       For a given set of template parameters, if an explicit
+       instantiation of a template appears after a declaration of an
+       explicit specialization for that template, the explicit
+       instantiation has no effect.  */
+    return;
+
+  if (CLASSTYPE_EXPLICIT_INSTANTIATION (t) && !CLASSTYPE_INTERFACE_ONLY (t))
     {
+      /* We've already instantiated the template.  */
+
       /* [temp.spec]
 
         No program shall explicitly instantiate any template more
         than once.
 
-        If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
-        instantiation was `extern'.  If EXTERN_P then the second is.
-        These cases are OK.  */
-      previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
+        If EXTERN_P then this is ok.  */
+      if (!extern_p && (complain & tf_error))
+       permerror (input_location,
+                  "duplicate explicit instantiation of %q#T", t);
 
-      if (!previous_instantiation_extern_p && !extern_p
-         && (complain & tf_error))
-       permerror (input_location, "duplicate explicit instantiation of %q#T", t);
-
-      /* If we've already instantiated the template, just return now.  */
-      if (!CLASSTYPE_INTERFACE_ONLY (t))
-       return;
+      return;
     }
 
   check_explicit_instantiation_namespace (TYPE_NAME (t));
@@ -25109,7 +25098,7 @@ do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
 
   if (CLASSTYPE_NESTED_UTDS (t))
     binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
-                          bt_instantiate_type_proc, &storage);
+                          bt_instantiate_type_proc, storage);
 }
 
 /* Given a function DECL, which is a specialization of TMPL, modify