OSDN Git Service

PR c++/53995
[pf3gnuchains/gcc-fork.git] / gcc / cp / decl.c
index 2000bd4..572efcd 100644 (file)
@@ -1,6 +1,6 @@
 /* Process declarations and variables for C++ compiler.
    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
 /* Process declarations and variables for C++ compiler.
    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
-   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
    Free Software Foundation, Inc.
    Contributed by Michael Tiemann (tiemann@cygnus.com)
 
    Free Software Foundation, Inc.
    Contributed by Michael Tiemann (tiemann@cygnus.com)
 
@@ -71,7 +71,7 @@ static void require_complete_types_for_parms (tree);
 static int ambi_op_p (enum tree_code);
 static int unary_op_p (enum tree_code);
 static void push_local_name (tree);
 static int ambi_op_p (enum tree_code);
 static int unary_op_p (enum tree_code);
 static void push_local_name (tree);
-static tree grok_reference_init (tree, tree, tree, tree *);
+static tree grok_reference_init (tree, tree, tree, int);
 static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,
                         int, int, tree);
 static int check_static_variable_definition (tree, tree);
 static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,
                         int, int, tree);
 static int check_static_variable_definition (tree, tree);
@@ -91,7 +91,7 @@ static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
 static void maybe_deduce_size_from_array_init (tree, tree);
 static void layout_var_decl (tree);
 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
 static void maybe_deduce_size_from_array_init (tree, tree);
 static void layout_var_decl (tree);
-static tree check_initializer (tree, tree, int, tree *);
+static tree check_initializer (tree, tree, int, VEC(tree,gc) **);
 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
 static void save_function_data (tree);
 static void copy_type_enum (tree , tree);
 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
 static void save_function_data (tree);
 static void copy_type_enum (tree , tree);
@@ -643,6 +643,9 @@ poplevel (int keep, int reverse, int functionbody)
   for (link = decls; link; link = TREE_CHAIN (link))
     {
       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
   for (link = decls; link; link = TREE_CHAIN (link))
     {
       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
+         /* It's hard to make this ARM compatibility hack play nicely with
+            lambdas, and it really isn't necessary in C++11 mode.  */
+         && cxx_dialect < cxx0x
          && DECL_NAME (link))
        {
          tree name = DECL_NAME (link);
          && DECL_NAME (link))
        {
          tree name = DECL_NAME (link);
@@ -949,6 +952,8 @@ decls_match (tree newdecl, tree olddecl)
        interested in their types.  */
     return 0;
 
        interested in their types.  */
     return 0;
 
+  gcc_assert (DECL_P (newdecl));
+
   if (TREE_CODE (newdecl) == FUNCTION_DECL)
     {
       tree f1 = TREE_TYPE (newdecl);
   if (TREE_CODE (newdecl) == FUNCTION_DECL)
     {
       tree f1 = TREE_TYPE (newdecl);
@@ -1200,6 +1205,21 @@ duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
       || TREE_TYPE (olddecl) == error_mark_node)
     return error_mark_node;
 
       || TREE_TYPE (olddecl) == error_mark_node)
     return error_mark_node;
 
+  if (UDLIT_OPER_P (DECL_NAME (newdecl))
+      && UDLIT_OPER_P (DECL_NAME (olddecl)))
+    {
+      if (TREE_CODE (newdecl) == TEMPLATE_DECL
+         && TREE_CODE (olddecl) != TEMPLATE_DECL
+         && check_raw_literal_operator (olddecl))
+       error ("literal operator template %q+D conflicts with"
+              " raw literal operator %qD", newdecl, olddecl);
+      else if (TREE_CODE (newdecl) != TEMPLATE_DECL
+              && TREE_CODE (olddecl) == TEMPLATE_DECL
+              && check_raw_literal_operator (newdecl))
+       error ("raw literal operator %q+D conflicts with"
+              " literal operator template %qD", newdecl, olddecl);
+    }
+
   if (DECL_P (olddecl)
       && TREE_CODE (newdecl) == FUNCTION_DECL
       && TREE_CODE (olddecl) == FUNCTION_DECL
   if (DECL_P (olddecl)
       && TREE_CODE (newdecl) == FUNCTION_DECL
       && TREE_CODE (olddecl) == FUNCTION_DECL
@@ -1354,11 +1374,13 @@ duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
       if (DECL_BUILT_IN_CLASS (olddecl) == BUILT_IN_NORMAL
          && DECL_ANTICIPATED (olddecl)
          && TREE_NOTHROW (newdecl)
       if (DECL_BUILT_IN_CLASS (olddecl) == BUILT_IN_NORMAL
          && DECL_ANTICIPATED (olddecl)
          && TREE_NOTHROW (newdecl)
-         && !TREE_NOTHROW (olddecl)
-         && built_in_decls [DECL_FUNCTION_CODE (olddecl)] != NULL_TREE
-         && built_in_decls [DECL_FUNCTION_CODE (olddecl)] != olddecl
-         && types_match)
-       TREE_NOTHROW (built_in_decls [DECL_FUNCTION_CODE (olddecl)]) = 1;
+         && !TREE_NOTHROW (olddecl))
+       {
+         enum built_in_function fncode = DECL_FUNCTION_CODE (olddecl);
+         tree tmpdecl = builtin_decl_explicit (fncode);
+         if (tmpdecl && tmpdecl != olddecl && types_match)
+           TREE_NOTHROW (tmpdecl)  = 1;
+       }
 
       /* Whether or not the builtin can throw exceptions has no
         bearing on this declarator.  */
 
       /* Whether or not the builtin can throw exceptions has no
         bearing on this declarator.  */
@@ -1537,8 +1559,8 @@ duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
          error_at (DECL_SOURCE_LOCATION (newdecl), errmsg, newdecl);
          if (DECL_NAME (olddecl) != NULL_TREE)
            error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
          error_at (DECL_SOURCE_LOCATION (newdecl), errmsg, newdecl);
          if (DECL_NAME (olddecl) != NULL_TREE)
            error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
-                        ? "%q+#D previously defined here"
-                        : "%q+#D previously declared here", olddecl);
+                  ? G_("%q+#D previously defined here")
+                  : G_("%q+#D previously declared here"), olddecl);
          return error_mark_node;
        }
       else if (TREE_CODE (olddecl) == FUNCTION_DECL
          return error_mark_node;
        }
       else if (TREE_CODE (olddecl) == FUNCTION_DECL
@@ -1678,7 +1700,10 @@ duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
          /* Don't warn about extern decl followed by definition.  */
          && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
          /* Don't warn about friends, let add_friend take care of it.  */
          /* Don't warn about extern decl followed by definition.  */
          && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
          /* Don't warn about friends, let add_friend take care of it.  */
-         && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl)))
+         && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl))
+         /* Don't warn about declaration followed by specialization.  */
+         && (! DECL_TEMPLATE_SPECIALIZATION (newdecl)
+             || DECL_TEMPLATE_SPECIALIZATION (olddecl)))
        {
          warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
          warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
        {
          warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
          warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
@@ -2132,6 +2157,22 @@ duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
              /* If we're keeping the built-in definition, keep the rtl,
                 regardless of declaration matches.  */
              COPY_DECL_RTL (olddecl, newdecl);
              /* If we're keeping the built-in definition, keep the rtl,
                 regardless of declaration matches.  */
              COPY_DECL_RTL (olddecl, newdecl);
+             if (DECL_BUILT_IN_CLASS (newdecl) == BUILT_IN_NORMAL)
+               {
+                 enum built_in_function fncode = DECL_FUNCTION_CODE (newdecl);
+                 switch (fncode)
+                   {
+                     /* If a compatible prototype of these builtin functions
+                        is seen, assume the runtime implements it with the
+                        expected semantics.  */
+                   case BUILT_IN_STPCPY:
+                     if (builtin_decl_explicit_p (fncode))
+                       set_builtin_decl_implicit_p (fncode, true);
+                     break;
+                   default:
+                     break;
+                   }
+               }
            }
 
          DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
            }
 
          DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
@@ -2173,7 +2214,12 @@ duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
       SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
       DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
     }
       SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
       DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
     }
-  /* Likewise for DECL_USER_ALIGN and DECL_PACKED.  */
+  /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED.  */
+  if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
+    {
+      DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
+      DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
+    }
   DECL_USER_ALIGN (olddecl) = DECL_USER_ALIGN (newdecl);
   if (TREE_CODE (newdecl) == FIELD_DECL)
     DECL_PACKED (olddecl) = DECL_PACKED (newdecl);
   DECL_USER_ALIGN (olddecl) = DECL_USER_ALIGN (newdecl);
   if (TREE_CODE (newdecl) == FIELD_DECL)
     DECL_PACKED (olddecl) = DECL_PACKED (newdecl);
@@ -2662,7 +2708,8 @@ check_previous_goto_1 (tree decl, cp_binding_level* level, tree names,
       tree new_decls, old_decls = (b == level ? names : NULL_TREE);
 
       for (new_decls = b->names; new_decls != old_decls;
       tree new_decls, old_decls = (b == level ? names : NULL_TREE);
 
       for (new_decls = b->names; new_decls != old_decls;
-          new_decls = DECL_CHAIN (new_decls))
+          new_decls = (DECL_P (new_decls) ? DECL_CHAIN (new_decls)
+                       : TREE_CHAIN (new_decls)))
        {
          int problem = decl_jump_unsafe (new_decls);
          if (! problem)
        {
          int problem = decl_jump_unsafe (new_decls);
          if (! problem)
@@ -2900,9 +2947,9 @@ tree
 define_label (location_t location, tree name)
 {
   tree ret;
 define_label (location_t location, tree name)
 {
   tree ret;
-  timevar_start (TV_NAME_LOOKUP);
+  bool running = timevar_cond_start (TV_NAME_LOOKUP);
   ret = define_label_1 (location, name);
   ret = define_label_1 (location, name);
-  timevar_stop (TV_NAME_LOOKUP);
+  timevar_cond_stop (TV_NAME_LOOKUP, running);
   return ret;
 }
 
   return ret;
 }
 
@@ -3214,8 +3261,8 @@ make_typename_type (tree context, tree name, enum tag_types tag_type,
   if (!t)
     {
       if (complain & tf_error)
   if (!t)
     {
       if (complain & tf_error)
-       error (want_template ? "no class template named %q#T in %q#T"
-              : "no type named %q#T in %q#T", name, context);
+       error (want_template ? G_("no class template named %q#T in %q#T")
+              : G_("no type named %q#T in %q#T"), name, context);
       return error_mark_node;
     }
   
       return error_mark_node;
     }
   
@@ -3233,7 +3280,7 @@ make_typename_type (tree context, tree name, enum tag_types tag_type,
       return error_mark_node;
     }
 
       return error_mark_node;
     }
 
-  if (want_template && !DECL_CLASS_TEMPLATE_P (t))
+  if (want_template && !DECL_TYPE_TEMPLATE_P (t))
     {
       if (complain & tf_error)
        error ("%<typename %T::%D%> names %q#T, which is not a class template",
     {
       if (complain & tf_error)
        error ("%<typename %T::%D%> names %q#T, which is not a class template",
@@ -3301,7 +3348,7 @@ make_unbound_class_template (tree context, tree name, tree parm_list,
       if (tmpl && TREE_CODE (tmpl) == TYPE_DECL)
        tmpl = maybe_get_template_decl_from_type_decl (tmpl);
 
       if (tmpl && TREE_CODE (tmpl) == TYPE_DECL)
        tmpl = maybe_get_template_decl_from_type_decl (tmpl);
 
-      if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
+      if (!tmpl || !DECL_TYPE_TEMPLATE_P (tmpl))
        {
          if (complain & tf_error)
            error ("no class template named %q#T in %q#T", name, context);
        {
          if (complain & tf_error)
            error ("no class template named %q#T in %q#T", name, context);
@@ -3597,6 +3644,10 @@ cxx_init_decl_processing (void)
   init_list_type_node = make_node (LANG_TYPE);
   record_unknown_type (init_list_type_node, "init list");
 
   init_list_type_node = make_node (LANG_TYPE);
   record_unknown_type (init_list_type_node, "init list");
 
+  dependent_lambda_return_type_node = make_node (LANG_TYPE);
+  record_unknown_type (dependent_lambda_return_type_node,
+                      "undeduced lambda return type");
+
   {
     /* Make sure we get a unique function type, so we can give
        its pointer type a name.  (This wins for gdb.) */
   {
     /* Make sure we get a unique function type, so we can give
        its pointer type a name.  (This wins for gdb.) */
@@ -3629,6 +3680,7 @@ cxx_init_decl_processing (void)
   current_lang_name = lang_name_cplusplus;
 
   {
   current_lang_name = lang_name_cplusplus;
 
   {
+    tree newattrs, extvisattr;
     tree newtype, deltype;
     tree ptr_ftype_sizetype;
     tree new_eh_spec;
     tree newtype, deltype;
     tree ptr_ftype_sizetype;
     tree new_eh_spec;
@@ -3656,8 +3708,17 @@ cxx_init_decl_processing (void)
     else
       new_eh_spec = noexcept_false_spec;
 
     else
       new_eh_spec = noexcept_false_spec;
 
-    newtype = build_exception_variant (ptr_ftype_sizetype, new_eh_spec);
-    deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
+    /* Ensure attribs.c is initialized.  */
+    init_attributes ();
+    extvisattr = build_tree_list (get_identifier ("externally_visible"),
+                                 NULL_TREE);
+    newattrs = tree_cons (get_identifier ("alloc_size"),
+                         build_tree_list (NULL_TREE, integer_one_node),
+                         extvisattr);
+    newtype = cp_build_type_attribute_variant (ptr_ftype_sizetype, newattrs);
+    newtype = build_exception_variant (newtype, new_eh_spec);
+    deltype = cp_build_type_attribute_variant (void_ftype_ptr, extvisattr);
+    deltype = build_exception_variant (deltype, empty_except_spec);
     push_cp_library_fn (NEW_EXPR, newtype);
     push_cp_library_fn (VEC_NEW_EXPR, newtype);
     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
     push_cp_library_fn (NEW_EXPR, newtype);
     push_cp_library_fn (VEC_NEW_EXPR, newtype);
     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
@@ -3950,6 +4011,8 @@ push_cp_library_fn (enum tree_code operator_code, tree type)
                                 operator_code,
                                 type);
   pushdecl (fn);
                                 operator_code,
                                 type);
   pushdecl (fn);
+  if (flag_tm)
+    apply_tm_attr (fn, get_identifier ("transaction_safe"));
   return fn;
 }
 
   return fn;
 }
 
@@ -4087,6 +4150,12 @@ check_tag_decl (cp_decl_specifier_seq *declspecs)
     error_p = true;
   if (declared_type == NULL_TREE && ! saw_friend && !error_p)
     permerror (input_location, "declaration does not declare anything");
     error_p = true;
   if (declared_type == NULL_TREE && ! saw_friend && !error_p)
     permerror (input_location, "declaration does not declare anything");
+  else if (declared_type != NULL_TREE && type_uses_auto (declared_type))
+    {
+      error ("%<auto%> can only be specified for variables "
+            "or function declarations");
+      return error_mark_node;
+    }
   /* Check for an anonymous union.  */
   else if (declared_type && RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type))
           && TYPE_ANONYMOUS_P (declared_type))
   /* Check for an anonymous union.  */
   else if (declared_type && RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type))
           && TYPE_ANONYMOUS_P (declared_type))
@@ -4147,6 +4216,20 @@ check_tag_decl (cp_decl_specifier_seq *declspecs)
         error ("%<constexpr%> cannot be used for type declarations");
     }
 
         error ("%<constexpr%> cannot be used for type declarations");
     }
 
+  if (declspecs->attributes && declared_type)
+    {
+      location_t loc = input_location;
+      if (!CLASS_TYPE_P (declared_type)
+         || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type))
+       /* For a non-template class, use the name location; for a template
+          class (an explicit instantiation), use the current location.  */
+       input_location = location_of (declared_type);
+      warning (0, "attribute ignored in declaration of %q#T", declared_type);
+      warning (0, "attribute for %q#T must follow the %qs keyword",
+              declared_type, class_key_or_enum_as_string (declared_type));
+      input_location = loc;
+    }
+
   return declared_type;
 }
 
   return declared_type;
 }
 
@@ -4171,14 +4254,6 @@ shadow_tag (cp_decl_specifier_seq *declspecs)
   if (!t)
     return NULL_TREE;
 
   if (!t)
     return NULL_TREE;
 
-  if (declspecs->attributes)
-    {
-      warning (0, "attribute ignored in declaration of %q+#T", t);
-      warning (0, "attribute for %q+#T must follow the %qs keyword",
-              t, class_key_or_enum_as_string (t));
-
-    }
-
   if (maybe_process_partial_specialization (t) == error_mark_node)
     return NULL_TREE;
 
   if (maybe_process_partial_specialization (t) == error_mark_node)
     return NULL_TREE;
 
@@ -4244,8 +4319,11 @@ groktypename (cp_decl_specifier_seq *type_specifiers,
    deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
    implicitly initialized via a default constructor.  ATTRIBUTES and
    PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
    deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
    implicitly initialized via a default constructor.  ATTRIBUTES and
    PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
-   *PUSHED_SCOPE_P is set to the scope entered in this function, if any; if
-   set, the caller is responsible for calling pop_scope.  */
+
+   The scope represented by the context of the returned DECL is pushed
+   (if it is not the global namespace) and is assigned to
+   *PUSHED_SCOPE_P.  The caller is then responsible for calling
+   pop_scope on *PUSHED_SCOPE_P if it is set.  */
 
 tree
 start_decl (const cp_declarator *declarator,
 
 tree
 start_decl (const cp_declarator *declarator,
@@ -4342,7 +4420,8 @@ start_decl (const cp_declarator *declarator,
     }
 
   /* If #pragma weak was used, mark the decl weak now.  */
     }
 
   /* If #pragma weak was used, mark the decl weak now.  */
-  maybe_apply_pragma_weak (decl);
+  if (!processing_template_decl)
+    maybe_apply_pragma_weak (decl);
 
   if (TREE_CODE (decl) == FUNCTION_DECL
       && DECL_DECLARED_INLINE_P (decl)
 
   if (TREE_CODE (decl) == FUNCTION_DECL
       && DECL_DECLARED_INLINE_P (decl)
@@ -4560,10 +4639,8 @@ start_decl_1 (tree decl, bool initialized)
    Quotes on semantics can be found in ARM 8.4.3.  */
 
 static tree
    Quotes on semantics can be found in ARM 8.4.3.  */
 
 static tree
-grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
+grok_reference_init (tree decl, tree type, tree init, int flags)
 {
 {
-  tree tmp;
-
   if (init == NULL_TREE)
     {
       if ((DECL_LANG_SPECIFIC (decl) == 0
   if (init == NULL_TREE)
     {
       if ((DECL_LANG_SPECIFIC (decl) == 0
@@ -4589,55 +4666,8 @@ grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
      DECL_INITIAL for local references (instead assigning to them
      explicitly); we need to allow the temporary to be initialized
      first.  */
      DECL_INITIAL for local references (instead assigning to them
      explicitly); we need to allow the temporary to be initialized
      first.  */
-  tmp = initialize_reference (type, init, decl, cleanup, tf_warning_or_error);
-
-  if (tmp == error_mark_node)
-    return NULL_TREE;
-  else if (tmp == NULL_TREE)
-    {
-      error ("cannot initialize %qT from %qT", type, TREE_TYPE (init));
-      return NULL_TREE;
-    }
-
-  if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
-    return tmp;
-
-  DECL_INITIAL (decl) = tmp;
-
-  return NULL_TREE;
-}
-
-/* Subroutine of check_initializer.  We're initializing a DECL of
-   std::initializer_list<T> TYPE from a braced-init-list INIT, and need to
-   extend the lifetime of the underlying array to match that of the decl,
-   just like for reference initialization.  CLEANUP is as for
-   grok_reference_init.  */
-
-static tree
-build_init_list_var_init (tree decl, tree type, tree init, tree *array_init,
-                         tree *cleanup)
-{
-  tree aggr_init, array, arrtype;
-  init = perform_implicit_conversion (type, init, tf_warning_or_error);
-  if (error_operand_p (init))
-    return error_mark_node;
-
-  aggr_init = TARGET_EXPR_INITIAL (init);
-  array = CONSTRUCTOR_ELT (aggr_init, 0)->value;
-  arrtype = TREE_TYPE (array);
-  STRIP_NOPS (array);
-  gcc_assert (TREE_CODE (array) == ADDR_EXPR);
-  array = TREE_OPERAND (array, 0);
-  /* If the array is constant, finish_compound_literal already made it a
-     static variable and we don't need to do anything here.  */
-  if (decl && TREE_CODE (array) == TARGET_EXPR)
-    {
-      tree var = set_up_extended_ref_temp (decl, array, cleanup, array_init);
-      var = build_address (var);
-      var = convert (arrtype, var);
-      CONSTRUCTOR_ELT (aggr_init, 0)->value = var;
-    }
-  return init;
+  return initialize_reference (type, init, flags,
+                              tf_warning_or_error);
 }
 
 /* Designated initializers in arrays are not supported in GNU C++.
 }
 
 /* Designated initializers in arrays are not supported in GNU C++.
@@ -4877,15 +4907,16 @@ check_for_uninitialized_const_var (tree decl)
   if (TREE_CODE (decl) == VAR_DECL
       && TREE_CODE (type) != REFERENCE_TYPE
       && CP_TYPE_CONST_P (type)
   if (TREE_CODE (decl) == VAR_DECL
       && TREE_CODE (type) != REFERENCE_TYPE
       && CP_TYPE_CONST_P (type)
-      && (!TYPE_NEEDS_CONSTRUCTING (type)
-         || !type_has_user_provided_default_constructor (type))
       && !DECL_INITIAL (decl))
     {
       && !DECL_INITIAL (decl))
     {
+      tree field = default_init_uninitialized_part (type);
+      if (!field)
+       return;
+
       permerror (DECL_SOURCE_LOCATION (decl),
                 "uninitialized const %qD", decl);
 
       permerror (DECL_SOURCE_LOCATION (decl),
                 "uninitialized const %qD", decl);
 
-      if (CLASS_TYPE_P (type)
-         && !type_has_user_provided_default_constructor (type))
+      if (CLASS_TYPE_P (type))
        {
          tree defaulted_ctor;
 
        {
          tree defaulted_ctor;
 
@@ -4896,6 +4927,8 @@ check_for_uninitialized_const_var (tree decl)
            inform (DECL_SOURCE_LOCATION (defaulted_ctor),
                    "constructor is not user-provided because it is "
                    "explicitly defaulted in the class body");
            inform (DECL_SOURCE_LOCATION (defaulted_ctor),
                    "constructor is not user-provided because it is "
                    "explicitly defaulted in the class body");
+         inform (0, "and the implicitly-defined constructor does not "
+                 "initialize %q+#D", field);
        }
     }
 }
        }
     }
 }
@@ -5068,6 +5101,14 @@ reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p,
       /* Handle designated initializers, as an extension.  */
       if (d->cur->index)
        {
       /* Handle designated initializers, as an extension.  */
       if (d->cur->index)
        {
+         if (TREE_CODE (d->cur->index) == INTEGER_CST)
+           {
+             if (complain & tf_error)
+               error ("%<[%E] =%> used in a GNU-style designated initializer"
+                      " for class %qT", d->cur->index, type);
+             return error_mark_node;
+           }
+
          field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
 
          if (!field || TREE_CODE (field) != FIELD_DECL)
          field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
 
          if (!field || TREE_CODE (field) != FIELD_DECL)
@@ -5104,6 +5145,24 @@ reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p,
   return new_init;
 }
 
   return new_init;
 }
 
+/* Subroutine of reshape_init_r.  We're in a context where C99 initializer
+   designators are not valid; either complain or return true to indicate
+   that reshape_init_r should return error_mark_node.  */
+
+static bool
+has_designator_problem (reshape_iter *d, tsubst_flags_t complain)
+{
+  if (d->cur->index)
+    {
+      if (complain & tf_error)
+       error ("C99 designator %qE outside aggregate initializer",
+              d->cur->index);
+      else
+       return true;
+    }
+  return false;
+}
+
 /* Subroutine of reshape_init, which processes a single initializer (part of
    a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
    iterator within the CONSTRUCTOR which points to the initializer to process.
 /* Subroutine of reshape_init, which processes a single initializer (part of
    a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
    iterator within the CONSTRUCTOR which points to the initializer to process.
@@ -5119,6 +5178,10 @@ reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p,
   if (error_operand_p (init))
     return error_mark_node;
 
   if (error_operand_p (init))
     return error_mark_node;
 
+  if (first_initializer_p && !CP_AGGREGATE_TYPE_P (type)
+      && has_designator_problem (d, complain))
+    return error_mark_node;
+
   if (TREE_CODE (type) == COMPLEX_TYPE)
     {
       /* A complex type can be initialized from one or two initializers,
   if (TREE_CODE (type) == COMPLEX_TYPE)
     {
       /* A complex type can be initialized from one or two initializers,
@@ -5139,6 +5202,8 @@ reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p,
          VEC(constructor_elt, gc) *v = 0;
          CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init);
          CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, d->cur->value);
          VEC(constructor_elt, gc) *v = 0;
          CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init);
          CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, d->cur->value);
+         if (has_designator_problem (d, complain))
+           return error_mark_node;
          d->cur++;
          init = build_constructor (init_list_type_node, v);
        }
          d->cur++;
          init = build_constructor (init_list_type_node, v);
        }
@@ -5218,6 +5283,8 @@ reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p,
         array types (one value per array element).  */
       if (TREE_CODE (str_init) == STRING_CST)
        {
         array types (one value per array element).  */
       if (TREE_CODE (str_init) == STRING_CST)
        {
+         if (has_designator_problem (d, complain))
+           return error_mark_node;
          d->cur++;
          return str_init;
        }
          d->cur++;
          return str_init;
        }
@@ -5357,17 +5424,8 @@ static tree
 build_aggr_init_full_exprs (tree decl, tree init, int flags)
      
 {
 build_aggr_init_full_exprs (tree decl, tree init, int flags)
      
 {
-  int saved_stmts_are_full_exprs_p = 0;
-  if (building_stmt_list_p ())
-    {
-      saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
-      current_stmt_tree ()->stmts_are_full_exprs_p = 1;
-    }
-  init = build_aggr_init (decl, init, flags, tf_warning_or_error);
-  if (building_stmt_list_p ())
-    current_stmt_tree ()->stmts_are_full_exprs_p =
-      saved_stmts_are_full_exprs_p;
-  return init;
+  gcc_assert (stmts_are_full_exprs_p ());
+  return build_aggr_init (decl, init, flags, tf_warning_or_error);
 }
 
 /* Verify INIT (the initializer for DECL), and record the
 }
 
 /* Verify INIT (the initializer for DECL), and record the
@@ -5378,7 +5436,7 @@ build_aggr_init_full_exprs (tree decl, tree init, int flags)
    evaluated dynamically to initialize DECL.  */
 
 static tree
    evaluated dynamically to initialize DECL.  */
 
 static tree
-check_initializer (tree decl, tree init, int flags, tree *cleanup)
+check_initializer (tree decl, tree init, int flags, VEC(tree,gc) **cleanups)
 {
   tree type = TREE_TYPE (decl);
   tree init_code = NULL;
 {
   tree type = TREE_TYPE (decl);
   tree init_code = NULL;
@@ -5408,7 +5466,7 @@ check_initializer (tree decl, tree init, int flags, tree *cleanup)
     }
   else if (!COMPLETE_TYPE_P (type))
     {
     }
   else if (!COMPLETE_TYPE_P (type))
     {
-      error ("%qD has incomplete type", decl);
+      error ("%q#D has incomplete type", decl);
       TREE_TYPE (decl) = error_mark_node;
       return NULL_TREE;
     }
       TREE_TYPE (decl) = error_mark_node;
       return NULL_TREE;
     }
@@ -5447,19 +5505,26 @@ check_initializer (tree decl, tree init, int flags, tree *cleanup)
     }
   else if (!init && DECL_REALLY_EXTERN (decl))
     ;
     }
   else if (!init && DECL_REALLY_EXTERN (decl))
     ;
-  else if (TREE_CODE (type) == REFERENCE_TYPE)
-    init = grok_reference_init (decl, type, init, cleanup);
-  else if (init || type_build_ctor_call (type))
+  else if (init || type_build_ctor_call (type)
+          || TREE_CODE (type) == REFERENCE_TYPE)
     {
     {
-      if (!init)
+      if (TREE_CODE (type) == REFERENCE_TYPE)
+       {
+         init = grok_reference_init (decl, type, init, flags);
+         flags |= LOOKUP_ALREADY_DIGESTED;
+       }
+      else if (!init)
        check_for_uninitialized_const_var (decl);
       /* Do not reshape constructors of vectors (they don't need to be
         reshaped.  */
       else if (BRACE_ENCLOSED_INITIALIZER_P (init))
        {
          if (is_std_init_list (type))
        check_for_uninitialized_const_var (decl);
       /* Do not reshape constructors of vectors (they don't need to be
         reshaped.  */
       else if (BRACE_ENCLOSED_INITIALIZER_P (init))
        {
          if (is_std_init_list (type))
-           init = build_init_list_var_init (decl, type, init,
-                                            &extra_init, cleanup);
+           {
+             init = perform_implicit_conversion (type, init,
+                                                 tf_warning_or_error);
+             flags |= LOOKUP_ALREADY_DIGESTED;
+           }
          else if (TYPE_NON_AGGREGATE_CLASS (type))
            {
              /* Don't reshape if the class has constructors.  */
          else if (TYPE_NON_AGGREGATE_CLASS (type))
            {
              /* Don't reshape if the class has constructors.  */
@@ -5476,7 +5541,7 @@ check_initializer (tree decl, tree init, int flags, tree *cleanup)
          else
            {
              init = reshape_init (type, init, tf_warning_or_error);
          else
            {
              init = reshape_init (type, init, tf_warning_or_error);
-             if (cxx_dialect >= cxx0x && SCALAR_TYPE_P (type))
+             if (SCALAR_TYPE_P (type))
                check_narrowing (type, init);
            }
        }
                check_narrowing (type, init);
            }
        }
@@ -5488,9 +5553,10 @@ check_initializer (tree decl, tree init, int flags, tree *cleanup)
       if (type == error_mark_node)
        return NULL_TREE;
 
       if (type == error_mark_node)
        return NULL_TREE;
 
-      if (type_build_ctor_call (type)
-         || (CLASS_TYPE_P (type)
-             && !(init && BRACE_ENCLOSED_INITIALIZER_P (init))))
+      if ((type_build_ctor_call (type) || CLASS_TYPE_P (type))
+         && !(flags & LOOKUP_ALREADY_DIGESTED)
+         && !(init && BRACE_ENCLOSED_INITIALIZER_P (init)
+              && CP_AGGREGATE_TYPE_P (type)))
        {
          init_code = build_aggr_init_full_exprs (decl, init, flags);
 
        {
          init_code = build_aggr_init_full_exprs (decl, init, flags);
 
@@ -5532,7 +5598,13 @@ check_initializer (tree decl, tree init, int flags, tree *cleanup)
 
       if (init && TREE_CODE (init) != TREE_VEC)
        {
 
       if (init && TREE_CODE (init) != TREE_VEC)
        {
-         init_code = store_init_value (decl, init, flags);
+         /* In aggregate initialization of a variable, each element
+            initialization is a full-expression because there is no
+            enclosing expression.  */
+         gcc_assert (stmts_are_full_exprs_p ());
+
+         init_code = store_init_value (decl, init, cleanups, flags);
+
          if (pedantic && TREE_CODE (type) == ARRAY_TYPE
              && DECL_INITIAL (decl)
              && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
          if (pedantic && TREE_CODE (type) == ARRAY_TYPE
              && DECL_INITIAL (decl)
              && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
@@ -5671,7 +5743,9 @@ make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
 static tree
 wrap_cleanups_r (tree *stmt_p, int *walk_subtrees, void *data)
 {
 static tree
 wrap_cleanups_r (tree *stmt_p, int *walk_subtrees, void *data)
 {
-  if (TYPE_P (*stmt_p))
+  /* Stop at types or full-expression boundaries.  */
+  if (TYPE_P (*stmt_p)
+      || TREE_CODE (*stmt_p) == CLEANUP_POINT_EXPR)
     {
       *walk_subtrees = 0;
       return NULL_TREE;
     {
       *walk_subtrees = 0;
       return NULL_TREE;
@@ -5892,7 +5966,7 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
                tree asmspec_tree, int flags)
 {
   tree type;
                tree asmspec_tree, int flags)
 {
   tree type;
-  tree cleanup;
+  VEC(tree,gc) *cleanups = NULL;
   const char *asmspec = NULL;
   int was_readonly = 0;
   bool var_definition_p = false;
   const char *asmspec = NULL;
   int was_readonly = 0;
   bool var_definition_p = false;
@@ -5915,9 +5989,6 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
   if (type == error_mark_node)
     return;
 
   if (type == error_mark_node)
     return;
 
-  /* Assume no cleanup is required.  */
-  cleanup = NULL_TREE;
-
   /* If a name was specified, get the string.  */
   if (at_namespace_scope_p ())
     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
   /* If a name was specified, get the string.  */
   if (at_namespace_scope_p ())
     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
@@ -6037,9 +6108,12 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
          /* This variable seems to be a non-dependent constant, so process
             its initializer.  If check_initializer returns non-null the
             initialization wasn't constant after all.  */
          /* This variable seems to be a non-dependent constant, so process
             its initializer.  If check_initializer returns non-null the
             initialization wasn't constant after all.  */
-         tree init_code = check_initializer (decl, init, flags, &cleanup);
+         tree init_code;
+         cleanups = make_tree_vector ();
+         init_code = check_initializer (decl, init, flags, &cleanups);
          if (init_code == NULL_TREE)
            init = NULL_TREE;
          if (init_code == NULL_TREE)
            init = NULL_TREE;
+         release_tree_vector (cleanups);
        }
       else if (!DECL_PRETTY_FUNCTION_P (decl))
        /* Deduce array size even if the initializer is dependent.  */
        }
       else if (!DECL_PRETTY_FUNCTION_P (decl))
        /* Deduce array size even if the initializer is dependent.  */
@@ -6050,6 +6124,10 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
       return;
     }
 
       return;
     }
 
+  /* Just store non-static data member initializers for later.  */
+  if (init && TREE_CODE (decl) == FIELD_DECL)
+    DECL_INITIAL (decl) = init;
+
   /* Take care of TYPE_DECLs up front.  */
   if (TREE_CODE (decl) == TYPE_DECL)
     {
   /* Take care of TYPE_DECLs up front.  */
   if (TREE_CODE (decl) == TYPE_DECL)
     {
@@ -6134,7 +6212,8 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
                error ("Java object %qD not allocated with %<new%>", decl);
              init = NULL_TREE;
            }
                error ("Java object %qD not allocated with %<new%>", decl);
              init = NULL_TREE;
            }
-         init = check_initializer (decl, init, flags, &cleanup);
+         cleanups = make_tree_vector ();
+         init = check_initializer (decl, init, flags, &cleanups);
          /* Thread-local storage cannot be dynamically initialized.  */
          if (DECL_THREAD_LOCAL_P (decl) && init)
            {
          /* Thread-local storage cannot be dynamically initialized.  */
          if (DECL_THREAD_LOCAL_P (decl) && init)
            {
@@ -6299,11 +6378,18 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
 
   /* If a CLEANUP_STMT was created to destroy a temporary bound to a
      reference, insert it in the statement-tree now.  */
 
   /* If a CLEANUP_STMT was created to destroy a temporary bound to a
      reference, insert it in the statement-tree now.  */
-  if (cleanup)
-    push_cleanup (decl, cleanup, false);
+  if (cleanups)
+    {
+      unsigned i; tree t;
+      FOR_EACH_VEC_ELT (tree, cleanups, i, t)
+       push_cleanup (decl, t, false);
+      release_tree_vector (cleanups);
+    }
 
   if (was_readonly)
     TREE_READONLY (decl) = 1;
 
   if (was_readonly)
     TREE_READONLY (decl) = 1;
+
+  invoke_plugin_callbacks (PLUGIN_FINISH_DECL, decl);
 }
 
 /* Returns a declaration for a VAR_DECL as if:
 }
 
 /* Returns a declaration for a VAR_DECL as if:
@@ -7290,6 +7376,47 @@ grokfndecl (tree ctype,
   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
       && !grok_op_properties (decl, /*complain=*/true))
     return NULL_TREE;
   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
       && !grok_op_properties (decl, /*complain=*/true))
     return NULL_TREE;
+  else if (UDLIT_OPER_P (DECL_NAME (decl)))
+    {
+      bool long_long_unsigned_p;
+      bool long_double_p;
+      const char *suffix = NULL;
+      /* [over.literal]/6: Literal operators shall not have C linkage. */
+      if (DECL_LANGUAGE (decl) == lang_c)
+       {
+         error ("literal operator with C linkage");
+         return NULL_TREE;
+       }
+
+      if (DECL_NAMESPACE_SCOPE_P (decl))
+       {
+         if (!check_literal_operator_args (decl, &long_long_unsigned_p,
+                                           &long_double_p))
+           {
+             error ("%qD has invalid argument list", decl);
+             return NULL_TREE;
+           }
+
+         suffix = UDLIT_OP_SUFFIX (DECL_NAME (decl));
+         if (long_long_unsigned_p)
+           {
+             if (cpp_interpret_int_suffix (suffix, strlen (suffix)))
+               warning (0, "integer suffix %<%s%>"
+                           " shadowed by implementation", suffix);
+           }
+         else if (long_double_p)
+           {
+             if (cpp_interpret_float_suffix (suffix, strlen (suffix)))
+               warning (0, "floating point suffix %<%s%>"
+                           " shadowed by implementation", suffix);
+           }
+       }
+      else
+       {
+         error ("%qD must be a non-member function", decl);
+         return NULL_TREE;
+       }
+    }
 
   if (funcdef_flag)
     /* Make the init_value nonzero so pushdecl knows this is not
 
   if (funcdef_flag)
     /* Make the init_value nonzero so pushdecl knows this is not
@@ -7375,6 +7502,12 @@ grokfndecl (tree ctype,
              error ("definition of implicitly-declared %qD", old_decl);
              return NULL_TREE;
            }
              error ("definition of implicitly-declared %qD", old_decl);
              return NULL_TREE;
            }
+         else if (DECL_DEFAULTED_FN (old_decl))
+           {
+             error ("definition of explicitly-defaulted %q+D", decl);
+             error ("%q+#D explicitly defaulted here", old_decl);
+             return NULL_TREE;
+           }
 
          /* Since we've smashed OLD_DECL to its
             DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
 
          /* Since we've smashed OLD_DECL to its
             DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
@@ -7691,9 +7824,13 @@ check_static_variable_definition (tree decl, tree type)
     return 0;
   else if (cxx_dialect >= cxx0x && !INTEGRAL_OR_ENUMERATION_TYPE_P (type))
     {
     return 0;
   else if (cxx_dialect >= cxx0x && !INTEGRAL_OR_ENUMERATION_TYPE_P (type))
     {
-      if (literal_type_p (type))
-       error ("%<constexpr%> needed for in-class initialization of static "
-              "data member %q#D of non-integral type", decl);
+      if (!COMPLETE_TYPE_P (type))
+       error ("in-class initialization of static data member %q#D of "
+              "incomplete type", decl);
+      else if (literal_type_p (type))
+       permerror (input_location,
+                  "%<constexpr%> needed for in-class initialization of "
+                  "static data member %q#D of non-integral type", decl);
       else
        error ("in-class initialization of static data member %q#D of "
               "non-literal type", decl);
       else
        error ("in-class initialization of static data member %q#D of "
               "non-literal type", decl);
@@ -8475,6 +8612,15 @@ grokdeclarator (const cp_declarator *declarator,
       return error_mark_node;
     }
 
       return error_mark_node;
     }
 
+  if (dname
+      && TREE_CODE (dname) == IDENTIFIER_NODE
+      && UDLIT_OPER_P (dname)
+      && innermost_code != cdk_function)
+    {
+      error ("declaration of %qD as non-function", dname);
+      return error_mark_node;
+    }
+
   if (dname && IDENTIFIER_OPNAME_P (dname))
     {
       if (declspecs->specs[(int)ds_typedef])
   if (dname && IDENTIFIER_OPNAME_P (dname))
     {
       if (declspecs->specs[(int)ds_typedef])
@@ -8616,6 +8762,18 @@ grokdeclarator (const cp_declarator *declarator,
 
   ctype = NULL_TREE;
 
 
   ctype = NULL_TREE;
 
+  if (explicit_int128)
+    {
+      if (int128_integer_type_node == NULL_TREE)
+       {
+         error ("%<__int128%> is not supported by this target");
+         explicit_int128 = false;
+       }
+      else if (pedantic && ! in_system_header)
+       pedwarn (input_location, OPT_pedantic,
+                "ISO C++ does not support %<__int128%> for %qs", name);
+    }
+
   /* Now process the modifiers that were specified
      and check for invalid combinations.  */
 
   /* Now process the modifiers that were specified
      and check for invalid combinations.  */
 
@@ -8639,8 +8797,6 @@ grokdeclarator (const cp_declarator *declarator,
        error ("%<signed%> and %<unsigned%> specified together for %qs", name);
       else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
        error ("%<long long%> invalid for %qs", name);
        error ("%<signed%> and %<unsigned%> specified together for %qs", name);
       else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
        error ("%<long long%> invalid for %qs", name);
-      else if (explicit_int128 && TREE_CODE (type) != INTEGER_TYPE)
-       error ("%<__int128%> invalid for %qs", name);
       else if (long_p && TREE_CODE (type) == REAL_TYPE)
        error ("%<long%> invalid for %qs", name);
       else if (short_p && TREE_CODE (type) == REAL_TYPE)
       else if (long_p && TREE_CODE (type) == REAL_TYPE)
        error ("%<long%> invalid for %qs", name);
       else if (short_p && TREE_CODE (type) == REAL_TYPE)
@@ -8671,22 +8827,6 @@ grokdeclarator (const cp_declarator *declarator,
              if (flag_pedantic_errors)
                ok = 0;
            }
              if (flag_pedantic_errors)
                ok = 0;
            }
-         if (explicit_int128)
-           {
-             if (int128_integer_type_node == NULL_TREE)
-               {
-                 error ("%<__int128%> is not supported by this target");
-                 ok = 0;
-               }
-             else if (pedantic)
-               {
-                 pedwarn (input_location, OPT_pedantic,
-                          "ISO C++ does not support %<__int128%> for %qs",
-                          name);
-                 if (flag_pedantic_errors)
-                   ok = 0;
-               }
-           }
        }
 
       /* Discard the type modifiers if they are invalid.  */
        }
 
       /* Discard the type modifiers if they are invalid.  */
@@ -8697,7 +8837,6 @@ grokdeclarator (const cp_declarator *declarator,
          long_p = false;
          short_p = false;
          longlong = 0;
          long_p = false;
          short_p = false;
          longlong = 0;
-         explicit_int128 = false;
        }
     }
 
        }
     }
 
@@ -9027,6 +9166,10 @@ grokdeclarator (const cp_declarator *declarator,
             virt_specifiers = declarator->u.function.virt_specifiers;
            /* Pick up the exception specifications.  */
            raises = declarator->u.function.exception_specification;
             virt_specifiers = declarator->u.function.virt_specifiers;
            /* Pick up the exception specifications.  */
            raises = declarator->u.function.exception_specification;
+           /* If the exception-specification is ill-formed, let's pretend
+              there wasn't one.  */
+           if (raises == error_mark_node)
+             raises = NULL_TREE;
 
            /* Say it's a definition only for the CALL_EXPR
               closest to the identifier.  */
 
            /* Say it's a definition only for the CALL_EXPR
               closest to the identifier.  */
@@ -9040,12 +9183,12 @@ grokdeclarator (const cp_declarator *declarator,
                    if (!declarator->u.function.late_return_type)
                      {
                        error ("%qs function uses %<auto%> type specifier without"
                    if (!declarator->u.function.late_return_type)
                      {
                        error ("%qs function uses %<auto%> type specifier without"
-                              " late return type", name);
+                              " trailing return type", name);
                        return error_mark_node;
                      }
                    else if (!is_auto (type))
                      {
                        return error_mark_node;
                      }
                    else if (!is_auto (type))
                      {
-                       error ("%qs function with late return type has"
+                       error ("%qs function with trailing return type has"
                               " %qT as its type rather than plain %<auto%>",
                               name, type);
                        return error_mark_node;
                               " %qT as its type rather than plain %<auto%>",
                               name, type);
                        return error_mark_node;
@@ -9053,8 +9196,14 @@ grokdeclarator (const cp_declarator *declarator,
                  }
                else if (declarator->u.function.late_return_type)
                  {
                  }
                else if (declarator->u.function.late_return_type)
                  {
-                   error ("%qs function with late return type not declared"
-                          " with %<auto%> type specifier", name);
+                   if (cxx_dialect < cxx0x)
+                     /* Not using maybe_warn_cpp0x because this should
+                        always be an error.  */
+                     error ("trailing return type only available with "
+                            "-std=c++11 or -std=gnu++11");
+                   else
+                     error ("%qs function with trailing return type not "
+                            "declared with %<auto%> type specifier", name);
                    return error_mark_node;
                  }
              }
                    return error_mark_node;
                  }
              }
@@ -9086,13 +9235,13 @@ grokdeclarator (const cp_declarator *declarator,
                   virtual.  A constructor may not be static.  */
                if (staticp == 2)
                  error ((flags == DTOR_FLAG)
                   virtual.  A constructor may not be static.  */
                if (staticp == 2)
                  error ((flags == DTOR_FLAG)
-                        ? "destructor cannot be static member function"
-                        : "constructor cannot be static member function");
+                        ? G_("destructor cannot be static member function")
+                        : G_("constructor cannot be static member function"));
                if (memfn_quals)
                  {
                    error ((flags == DTOR_FLAG)
                if (memfn_quals)
                  {
                    error ((flags == DTOR_FLAG)
-                          ? "destructors may not be cv-qualified"
-                          : "constructors may not be cv-qualified");
+                          ? G_("destructors may not be cv-qualified")
+                          : G_("constructors may not be cv-qualified"));
                    memfn_quals = TYPE_UNQUALIFIED;
                  }
 
                    memfn_quals = TYPE_UNQUALIFIED;
                  }
 
@@ -9445,8 +9594,10 @@ grokdeclarator (const cp_declarator *declarator,
              && (!friendp || funcdef_flag))
            {
              error (funcdef_flag
              && (!friendp || funcdef_flag))
            {
              error (funcdef_flag
-                    ? "cannot define member function %<%T::%s%> within %<%T%>"
-                    : "cannot declare member function %<%T::%s%> within %<%T%>",
+                    ? G_("cannot define member function %<%T::%s%> "
+                         "within %<%T%>")
+                    : G_("cannot declare member function %<%T::%s%> "
+                         "within %<%T%>"),
                     ctype, name, current_class_type);
              return error_mark_node;
            }
                     ctype, name, current_class_type);
              return error_mark_node;
            }
@@ -9621,6 +9772,7 @@ grokdeclarator (const cp_declarator *declarator,
          && TYPE_NAME (type)
          && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
          && TYPE_ANONYMOUS_P (type)
          && TYPE_NAME (type)
          && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
          && TYPE_ANONYMOUS_P (type)
+         && declspecs->type_definition_p
          && cp_type_quals (type) == TYPE_UNQUALIFIED)
        {
          tree t;
          && cp_type_quals (type) == TYPE_UNQUALIFIED)
        {
          tree t;
@@ -9663,6 +9815,11 @@ grokdeclarator (const cp_declarator *declarator,
                      memfn_quals != TYPE_UNQUALIFIED,
                      inlinep, friendp, raises != NULL_TREE);
 
                      memfn_quals != TYPE_UNQUALIFIED,
                      inlinep, friendp, raises != NULL_TREE);
 
+      if (declspecs->specs[(int)ds_alias])
+       /* Acknowledge that this was written:
+            `using analias = atype;'.  */
+       TYPE_DECL_ALIAS_P (decl) = 1;
+
       return decl;
     }
 
       return decl;
     }
 
@@ -9866,6 +10023,12 @@ grokdeclarator (const cp_declarator *declarator,
       }
     else if (decl_context == FIELD)
       {
       }
     else if (decl_context == FIELD)
       {
+       if (!staticp && type_uses_auto (type))
+         {
+           error ("non-static data member declared %<auto%>");
+           type = error_mark_node;
+         }
+
        /* The C99 flexible array extension.  */
        if (!staticp && TREE_CODE (type) == ARRAY_TYPE
            && TYPE_DOMAIN (type) == NULL_TREE)
        /* The C99 flexible array extension.  */
        if (!staticp && TREE_CODE (type) == ARRAY_TYPE
            && TYPE_DOMAIN (type) == NULL_TREE)
@@ -10061,36 +10224,6 @@ grokdeclarator (const cp_declarator *declarator,
 
        if (decl == NULL_TREE)
          {
 
        if (decl == NULL_TREE)
          {
-           if (initialized)
-             {
-               if (!staticp)
-                 {
-                   /* An attempt is being made to initialize a non-static
-                      member.  But, from [class.mem]:
-
-                      4 A member-declarator can contain a
-                      constant-initializer only if it declares a static
-                      member (_class.static_) of integral or enumeration
-                      type, see _class.static.data_.
-
-                      This used to be relatively common practice, but
-                      the rest of the compiler does not correctly
-                      handle the initialization unless the member is
-                      static so we make it static below.  */
-                   if (cxx_dialect >= cxx0x)
-                     {
-                       sorry ("non-static data member initializers");
-                     }
-                   else
-                     {
-                       permerror (input_location, "ISO C++ forbids initialization of member %qD",
-                                  unqualified_id);
-                       permerror (input_location, "making %qD static", unqualified_id);
-                       staticp = 1;
-                     }
-                 }
-             }
-
            if (staticp)
              {
                /* C++ allows static class members.  All other work
            if (staticp)
              {
                /* C++ allows static class members.  All other work
@@ -10131,6 +10264,19 @@ grokdeclarator (const cp_declarator *declarator,
                    DECL_MUTABLE_P (decl) = 1;
                    storage_class = sc_none;
                  }
                    DECL_MUTABLE_P (decl) = 1;
                    storage_class = sc_none;
                  }
+
+               if (initialized)
+                 {
+                   /* An attempt is being made to initialize a non-static
+                      member.  This is new in C++11.  */
+                   maybe_warn_cpp0x (CPP0X_NSDMI);
+
+                   /* If this has been parsed with static storage class, but
+                      errors forced staticp to be cleared, ensure NSDMI is
+                      not present.  */
+                   if (declspecs->storage_class == sc_static)
+                     DECL_INITIAL (decl) = error_mark_node;
+                 }
              }
 
            bad_specifiers (decl, BSP_FIELD, virtualp,
              }
 
            bad_specifiers (decl, BSP_FIELD, virtualp,
@@ -10190,8 +10336,8 @@ grokdeclarator (const cp_declarator *declarator,
                     || sfk == sfk_destructor)
              {
                error (funcdef_flag
                     || sfk == sfk_destructor)
              {
                error (funcdef_flag
-                      ? "%qs defined in a non-class scope"
-                      : "%qs declared in a non-class scope", name);
+                      ? G_("%qs defined in a non-class scope")
+                      : G_("%qs declared in a non-class scope"), name);
                sfk = sfk_none;
              }
          }
                sfk = sfk_none;
              }
          }
@@ -10370,7 +10516,9 @@ static tree
 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
                         void *data ATTRIBUTE_UNUSED)
 {
 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
                         void *data ATTRIBUTE_UNUSED)
 {
-  if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
+  /* Check DECL_NAME to avoid including temporaries.  We don't check
+     DECL_ARTIFICIAL because we do want to complain about 'this'.  */
+  if (local_variable_p (*tp) && DECL_NAME (*tp))
     return *tp;
   else if (TYPE_P (*tp))
     *walk_subtrees = 0;
     return *tp;
   else if (TYPE_P (*tp))
     *walk_subtrees = 0;
@@ -10378,7 +10526,6 @@ local_variable_p_walkfn (tree *tp, int *walk_subtrees,
   return NULL_TREE;
 }
 
   return NULL_TREE;
 }
 
-
 /* Check that ARG, which is a default-argument expression for a
    parameter DECL, is valid.  Returns ARG, or ERROR_MARK_NODE, if
    something goes wrong.  DECL may also be a _TYPE node, rather than a
 /* Check that ARG, which is a default-argument expression for a
    parameter DECL, is valid.  Returns ARG, or ERROR_MARK_NODE, if
    something goes wrong.  DECL may also be a _TYPE node, rather than a
@@ -10429,6 +10576,17 @@ check_default_argument (tree decl, tree arg)
       return error_mark_node;
     }
 
       return error_mark_node;
     }
 
+  if (warn_zero_as_null_pointer_constant
+      && c_inhibit_evaluation_warnings == 0
+      && (TYPE_PTR_P (decl_type) || TYPE_PTR_TO_MEMBER_P (decl_type))
+      && null_ptr_cst_p (arg)
+      && !NULLPTR_TYPE_P (TREE_TYPE (arg)))
+    {
+      warning (OPT_Wzero_as_null_pointer_constant,
+              "zero as null pointer constant");
+      return nullptr_node;
+    }
+
   /* [dcl.fct.default]
 
      Local variables shall not be used in default argument
   /* [dcl.fct.default]
 
      Local variables shall not be used in default argument
@@ -10439,7 +10597,10 @@ check_default_argument (tree decl, tree arg)
   var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
   if (var)
     {
   var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
   if (var)
     {
-      error ("default argument %qE uses local variable %qD", arg, var);
+      if (DECL_NAME (var) == this_identifier)
+       permerror (input_location, "default argument %qE uses %qD", arg, var);
+      else
+       error ("default argument %qE uses local variable %qD", arg, var);
       return error_mark_node;
     }
 
       return error_mark_node;
     }
 
@@ -11267,6 +11428,9 @@ check_elaborated_type_specifier (enum tag_types tag_code,
 {
   tree type;
 
 {
   tree type;
 
+  if (decl == error_mark_node)
+    return error_mark_node;
+
   /* In the case of:
 
        struct S { struct S *p; };
   /* In the case of:
 
        struct S { struct S *p; };
@@ -11286,10 +11450,15 @@ check_elaborated_type_specifier (enum tag_types tag_code,
             type, tag_name (tag_code));
       return error_mark_node;
     }
             type, tag_name (tag_code));
       return error_mark_node;
     }
+  /* Accept bound template template parameters.  */
+  else if (allow_template_p
+          && TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
+    ;
   /*   [dcl.type.elab]
 
   /*   [dcl.type.elab]
 
-       If the identifier resolves to a typedef-name or a template
-       type-parameter, the elaborated-type-specifier is ill-formed.
+       If the identifier resolves to a typedef-name or the
+       simple-template-id resolves to an alias template
+       specialization, the elaborated-type-specifier is ill-formed.
 
      In other words, the only legitimate declaration to use in the
      elaborated type specifier is the implicit typedef created when
 
      In other words, the only legitimate declaration to use in the
      elaborated type specifier is the implicit typedef created when
@@ -11298,8 +11467,13 @@ check_elaborated_type_specifier (enum tag_types tag_code,
           && !DECL_SELF_REFERENCE_P (decl)
           && tag_code != typename_type)
     {
           && !DECL_SELF_REFERENCE_P (decl)
           && tag_code != typename_type)
     {
-      error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
-      error ("%q+D has a previous declaration here", decl);
+      if (alias_template_specialization_p (type))
+       error ("using alias template specialization %qT after %qs",
+              type, tag_name (tag_code));
+      else
+       error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
+      inform (DECL_SOURCE_LOCATION (decl),
+             "%qD has a previous declaration here", decl);
       return error_mark_node;
     }
   else if (TREE_CODE (type) != RECORD_TYPE
       return error_mark_node;
     }
   else if (TREE_CODE (type) != RECORD_TYPE
@@ -11570,9 +11744,10 @@ xref_tag (enum tag_types tag_code, tree name,
           tag_scope scope, bool template_header_p)
 {
   tree ret;
           tag_scope scope, bool template_header_p)
 {
   tree ret;
-  timevar_start (TV_NAME_LOOKUP);
+  bool subtime;
+  subtime = timevar_cond_start (TV_NAME_LOOKUP);
   ret = xref_tag_1 (tag_code, name, scope, template_header_p);
   ret = xref_tag_1 (tag_code, name, scope, template_header_p);
-  timevar_stop (TV_NAME_LOOKUP);
+  timevar_cond_stop (TV_NAME_LOOKUP, subtime);
   return ret;
 }
 
   return ret;
 }
 
@@ -11723,7 +11898,7 @@ xref_basetypes (tree ref, tree base_list)
        TYPE_FOR_JAVA (ref) = 1;
 
       base_binfo = NULL_TREE;
        TYPE_FOR_JAVA (ref) = 1;
 
       base_binfo = NULL_TREE;
-      if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
+      if (CLASS_TYPE_P (basetype) && !dependent_scope_p (basetype))
        {
          base_binfo = TYPE_BINFO (basetype);
          /* The original basetype could have been a typedef'd type.  */
        {
          base_binfo = TYPE_BINFO (basetype);
          /* The original basetype could have been a typedef'd type.  */
@@ -11768,8 +11943,8 @@ xref_basetypes (tree ref, tree base_list)
       BINFO_BASE_ACCESS_APPEND (binfo, access);
     }
 
       BINFO_BASE_ACCESS_APPEND (binfo, access);
     }
 
-  if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
-    /* If we have space in the vbase vector, we must have shared at
+  if (VEC_length (tree, CLASSTYPE_VBASECLASSES (ref)) < max_vbases)
+    /* If we didn't get max_vbases vbases, we must have shared at
        least one of them, and are therefore diamond shaped.  */
     CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
 
        least one of them, and are therefore diamond shaped.  */
     CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
 
@@ -11808,15 +11983,19 @@ xref_basetypes (tree ref, tree base_list)
 static void
 copy_type_enum (tree dst, tree src)
 {
 static void
 copy_type_enum (tree dst, tree src)
 {
-  TYPE_MIN_VALUE (dst) = TYPE_MIN_VALUE (src);
-  TYPE_MAX_VALUE (dst) = TYPE_MAX_VALUE (src);
-  TYPE_SIZE (dst) = TYPE_SIZE (src);
-  TYPE_SIZE_UNIT (dst) = TYPE_SIZE_UNIT (src);
-  SET_TYPE_MODE (dst, TYPE_MODE (src));
-  TYPE_PRECISION (dst) = TYPE_PRECISION (src);
-  TYPE_ALIGN (dst) = TYPE_ALIGN (src);
-  TYPE_USER_ALIGN (dst) = TYPE_USER_ALIGN (src);
-  TYPE_UNSIGNED (dst) = TYPE_UNSIGNED (src);
+  tree t;
+  for (t = dst; t; t = TYPE_NEXT_VARIANT (t))
+    {
+      TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (src);
+      TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (src);
+      TYPE_SIZE (t) = TYPE_SIZE (src);
+      TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (src);
+      SET_TYPE_MODE (dst, TYPE_MODE (src));
+      TYPE_PRECISION (t) = TYPE_PRECISION (src);
+      TYPE_ALIGN (t) = TYPE_ALIGN (src);
+      TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (src);
+      TYPE_UNSIGNED (t) = TYPE_UNSIGNED (src);
+    }
 }
 
 /* Begin compiling the definition of an enumeration type.
 }
 
 /* Begin compiling the definition of an enumeration type.
@@ -11918,8 +12097,23 @@ start_enum (tree name, tree enumtype, tree underlying_type,
            *is_new = true;
        }
       prevtype = enumtype;
            *is_new = true;
        }
       prevtype = enumtype;
-      enumtype = cxx_make_type (ENUMERAL_TYPE);
-      enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
+
+      /* Do not push the decl more than once, unless we need to
+        compare underlying types at instantiation time */
+      if (!enumtype
+         || TREE_CODE (enumtype) != ENUMERAL_TYPE
+         || (underlying_type
+             && dependent_type_p (underlying_type))
+         || (ENUM_UNDERLYING_TYPE (enumtype)
+             && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype))))
+       {
+         enumtype = cxx_make_type (ENUMERAL_TYPE);
+         enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
+       }
+      else
+         enumtype = xref_tag (enum_type, name, /*tag_scope=*/ts_current,
+                              false);
+
       if (enumtype == error_mark_node)
        return error_mark_node;
 
       if (enumtype == error_mark_node)
        return error_mark_node;
 
@@ -12153,6 +12347,12 @@ finish_enum_value_list (tree enumtype)
   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
     TYPE_VALUES (t) = TYPE_VALUES (enumtype);
 
   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
     TYPE_VALUES (t) = TYPE_VALUES (enumtype);
 
+  if (at_class_scope_p ()
+      && COMPLETE_TYPE_P (current_class_type)
+      && UNSCOPED_ENUM_P (enumtype))
+    insert_late_enum_def_into_classtype_sorted_fields (enumtype,
+                                                      current_class_type);
+
   /* Finish debugging output for this type.  */
   rest_of_type_compilation (enumtype, namespace_bindings_p ());
 }
   /* Finish debugging output for this type.  */
   rest_of_type_compilation (enumtype, namespace_bindings_p ());
 }
@@ -12171,9 +12371,12 @@ finish_enum (tree enumtype)
       return;
     }
 
       return;
     }
 
-  /* Here there should not be any variants of this type.  */
+  /* If this is a forward declaration, there should not be any variants,
+     though we can get a variant in the middle of an enum-specifier with
+     wacky code like 'enum E { e = sizeof(const E*) };'  */
   gcc_assert (enumtype == TYPE_MAIN_VARIANT (enumtype)
   gcc_assert (enumtype == TYPE_MAIN_VARIANT (enumtype)
-             && !TYPE_NEXT_VARIANT (enumtype));
+             && (TYPE_VALUES (enumtype)
+                 || !TYPE_NEXT_VARIANT (enumtype)));
 }
 
 /* Build and install a CONST_DECL for an enumeration constant of the
 }
 
 /* Build and install a CONST_DECL for an enumeration constant of the
@@ -12204,14 +12407,11 @@ build_enumerator (tree name, tree value, tree enumtype, location_t loc)
        {
          value = cxx_constant_value (value);
 
        {
          value = cxx_constant_value (value);
 
-         if (TREE_CODE (value) == INTEGER_CST
-             && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value)))
-           {
-             value = perform_integral_promotions (value);
-           }
-         else
+         if (TREE_CODE (value) != INTEGER_CST
+             || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value)))
            {
            {
-             error ("enumerator value for %qD is not an integer constant", name);
+             error ("enumerator value for %qD is not an integer constant",
+                    name);
              value = NULL_TREE;
            }
        }
              value = NULL_TREE;
            }
        }
@@ -12636,10 +12836,6 @@ start_preparsed_function (tree decl1, tree attrs, int flags)
        maybe_apply_pragma_weak (decl1);
     }
 
        maybe_apply_pragma_weak (decl1);
     }
 
-  /* constexpr functions must have literal argument types and
-     literal return type.  */
-  validate_constexpr_fundecl (decl1);
-
   /* Reset this in case the call to pushdecl changed it.  */
   current_function_decl = decl1;
 
   /* Reset this in case the call to pushdecl changed it.  */
   current_function_decl = decl1;
 
@@ -12965,6 +13161,7 @@ save_function_data (tree decl)
   f->base.x_stmt_tree.x_cur_stmt_list = NULL;
   f->bindings = NULL;
   f->x_local_names = NULL;
   f->base.x_stmt_tree.x_cur_stmt_list = NULL;
   f->bindings = NULL;
   f->x_local_names = NULL;
+  f->base.local_typedefs = NULL;
 }
 
 
 }
 
 
@@ -13220,22 +13417,13 @@ finish_function (int flags)
     {
       if (DECL_MAIN_P (current_function_decl))
        {
     {
       if (DECL_MAIN_P (current_function_decl))
        {
-         tree stmt;
-
          /* Make it so that `main' always returns 0 by default (or
             1 for VMS).  */
 #if VMS_TARGET
          /* Make it so that `main' always returns 0 by default (or
             1 for VMS).  */
 #if VMS_TARGET
-         stmt = finish_return_stmt (integer_one_node);
+         finish_return_stmt (integer_one_node);
 #else
 #else
-         stmt = finish_return_stmt (integer_zero_node);
+         finish_return_stmt (integer_zero_node);
 #endif
 #endif
-         /* Hack.  We don't want the middle-end to warn that this
-            return is unreachable, so put the statement on the
-            special line 0.  */
-         {
-           location_t linezero = linemap_line_start (line_table, 0, 1);
-           SET_EXPR_LOCATION (stmt, linezero);
-         }
        }
 
       if (use_eh_spec_block (current_function_decl))
        }
 
       if (use_eh_spec_block (current_function_decl))
@@ -13378,6 +13566,10 @@ finish_function (int flags)
       unused_but_set_errorcount = errorcount;
     }
 
       unused_but_set_errorcount = errorcount;
     }
 
+  /* Complain about locally defined typedefs that are not used in this
+     function.  */
+  maybe_warn_unused_local_typedefs ();
+
   /* Genericize before inlining.  */
   if (!processing_template_decl)
     {
   /* Genericize before inlining.  */
   if (!processing_template_decl)
     {
@@ -13648,8 +13840,17 @@ cxx_maybe_build_cleanup (tree decl, tsubst_flags_t complain)
        cleanup = call;
     }
 
        cleanup = call;
     }
 
+  /* build_delete sets the location of the destructor call to the
+     current location, even though the destructor is going to be
+     called later, at the end of the current scope.  This can lead to
+     a "jumpy" behaviour for users of debuggers when they step around
+     the end of the block.  So let's unset the location of the
+     destructor call instead.  */
+  if (cleanup != NULL && EXPR_P (cleanup))
+    SET_EXPR_LOCATION (cleanup, UNKNOWN_LOCATION);
   return cleanup;
 }
   return cleanup;
 }
+
 \f
 /* When a stmt has been parsed, this function is called.  */
 
 \f
 /* When a stmt has been parsed, this function is called.  */
 
@@ -13725,6 +13926,7 @@ cp_tree_node_structure (union lang_tree_node * t)
     case TRAIT_EXPR:           return TS_CP_TRAIT_EXPR;
     case LAMBDA_EXPR:          return TS_CP_LAMBDA_EXPR;
     case TEMPLATE_INFO:                return TS_CP_TEMPLATE_INFO;
     case TRAIT_EXPR:           return TS_CP_TRAIT_EXPR;
     case LAMBDA_EXPR:          return TS_CP_LAMBDA_EXPR;
     case TEMPLATE_INFO:                return TS_CP_TEMPLATE_INFO;
+    case USERDEF_LITERAL:      return TS_CP_USERDEF_LITERAL;
     default:                   return TS_CP_GENERIC;
     }
 }
     default:                   return TS_CP_GENERIC;
     }
 }