CbC/CbC_gcc: gcc/cp/decl.c comparison

comparison gcc/cp/decl.c @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 /* Process declarations and variables for C++ compiler.
-Copyright (C) 1988-2017 Free Software Foundation, Inc.
+Copyright (C) 1988-2018 Free Software Foundation, Inc.
 Contributed by Michael Tiemann (tiemann@cygnus.com)
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify
 #include "c-family/c-objc.h"
 #include "c-family/c-pragma.h"
 #include "c-family/c-ubsan.h"
 #include "debug.h"
 #include "plugin.h"
-#include "cilk.h"
 #include "builtins.h"
 #include "gimplify.h"
 #include "asan.h"
+#include "gcc-rich-location.h"
+#include "langhooks.h"
 /* Possible cases of bad specifiers type used by bad_specifiers. */
 enum bad_spec_place {
 BSP_VAR,    /* variable */
 BSP_PARM,   /* parameter */
 static const char *redeclaration_error_message (tree, tree);
 static int decl_jump_unsafe (tree);
 static void require_complete_types_for_parms (tree);
-static bool ambi_op_p (enum tree_code);
-static bool unary_op_p (enum tree_code);
 static void push_local_name (tree);
 static tree grok_reference_init (tree, tree, tree, int);
 static tree grokvardecl (tree, tree, tree, const cp_decl_specifier_seq *,
 			 int, int, int, bool, int, tree);
-static int check_static_variable_definition (tree, tree);
+static void check_static_variable_definition (tree, tree);
 static void record_unknown_type (tree, const char *);
 static tree builtin_function_1 (tree, tree, bool);
 static int member_function_or_else (tree, tree, enum overload_flags);
-static void check_for_uninitialized_const_var (tree);
 static tree local_variable_p_walkfn (tree *, int *, void *);
 static const char *tag_name (enum tag_types);
 static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
 static void maybe_deduce_size_from_array_init (tree, tree);
 static void layout_var_decl (tree);
 Put it into forward order, just for cleanliness.  */
 tree decls;
 tree subblocks;
 tree block;
 tree decl;
-int leaving_for_scope;
 scope_kind kind;
-unsigned ix;
 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
 restart:
 block = NULL_TREE;
 /* In each subblock, record that this is its superior.  */
 if (keep >= 0)
 for (link = subblocks; link; link = BLOCK_CHAIN (link))
 BLOCK_SUPERCONTEXT (link) = block;
-/* We still support the old for-scope rules, whereby the variables
-in a init statement were in scope after the for-statement ended.
-We only use the new rules if flag_new_for_scope is nonzero.  */
-leaving_for_scope
-= current_binding_level->kind == sk_for && flag_new_for_scope == 1;
 /* Before we remove the declarations first check for unused variables.  */
 if ((warn_unused_variable || warn_unused_but_set_variable)
 && current_binding_level->kind != sk_template_parms
 && !processing_template_decl)
 		  warning_at (DECL_SOURCE_LOCATION (decl),
 			      OPT_Wunused_variable, "unused variable %qD", decl);
 	      }
 	    else if (DECL_CONTEXT (decl) == current_function_decl
 		     // For -Wunused-but-set-variable leave references alone.
-		     && TREE_CODE (TREE_TYPE (decl)) != REFERENCE_TYPE
+		     && !TYPE_REF_P (TREE_TYPE (decl))
 		     && errorcount == unused_but_set_errorcount)
 	      {
 		if (!DECL_NAME (decl) && DECL_DECOMPOSITION_P (decl))
 		  warning_at (DECL_SOURCE_LOCATION (decl),
 			      OPT_Wunused_but_set_variable, "structured "
 for (link = decls; link; link = TREE_CHAIN (link))
 {
 decl = TREE_CODE (link) == TREE_LIST ? TREE_VALUE (link) : link;
 tree name = OVL_NAME (decl);
-if (leaving_for_scope && VAR_P (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 < cxx11
-	  && name)
-	{
-	  cxx_binding *ob = outer_binding (name,
-					   IDENTIFIER_BINDING (name),
-					   /*class_p=*/true);
-	  tree ns_binding = NULL_TREE;
-	  if (!ob)
-	    ns_binding = get_namespace_binding (current_namespace, name);
-	  if (ob && ob->scope == current_binding_level->level_chain)
-	    /* We have something like:
-		 int i;
-		 for (int i; ;);
-	       and we are leaving the `for' scope.  There's no reason to
-	       keep the binding of the inner `i' in this case.  */
-	    ;
-	  else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
-		   || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
-	    /* Here, we have something like:
-		 typedef int I;
-		 void f () {
-		   for (int I; ;);
-		 }
-	       We must pop the for-scope binding so we know what's a
-	       type and what isn't.  */
-	    ;
-	  else
-	    {
-	      /* Mark this VAR_DECL as dead so that we can tell we left it
-		 there only for backward compatibility.  */
-	      DECL_DEAD_FOR_LOCAL (link) = 1;
-	      /* Keep track of what should have happened when we
-		 popped the binding.  */
-	      if (ob && ob->value)
-		{
-		  SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
-		  DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
-		}
-	      /* Add it to the list of dead variables in the next
-		 outermost binding to that we can remove these when we
-		 leave that binding.  */
-	      vec_safe_push (
-		  current_binding_level->level_chain->dead_vars_from_for,
-		  link);
-	      /* Although we don't pop the cxx_binding, we do clear
-		 its SCOPE since the scope is going away now.  */
-	      IDENTIFIER_BINDING (name)->scope
-		= current_binding_level->level_chain;
-	      /* Don't remove the binding. */
-	      name = NULL_TREE;
-	    }
-	}
 /* Remove the binding.  */
 if (TREE_CODE (decl) == LABEL_DECL)
 	pop_local_label (name, decl);
 else
 	pop_local_binding (name, decl);
 }
-/* Remove declarations for any `for' variables from inner scopes
-that we kept around.  */
-FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level->dead_vars_from_for,
-			         ix, decl)
-pop_local_binding (DECL_NAME (decl), decl);
 /* Restore the IDENTIFIER_TYPE_VALUEs.  */
 for (link = current_binding_level->type_shadowed;
 link; link = TREE_CHAIN (link))
 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
 For C++, we must compare the parameter list so that `int' can match
 `int&' in a parameter position, but `int&' is not confused with
 `const int&'.  */
 int
-decls_match (tree newdecl, tree olddecl)
+decls_match (tree newdecl, tree olddecl, bool record_versions /* = true */)
 {
 int types_match;
 if (newdecl == olddecl)
 return 1;
 r2 = fndecl_declared_return_type (olddecl);
 if (same_type_p (TREE_TYPE (f1), r2))
 	{
 	  if (!prototype_p (f2) && DECL_EXTERN_C_P (olddecl)
-	      && (DECL_BUILT_IN (olddecl)
+	      && fndecl_built_in_p (olddecl))
-#ifndef NO_IMPLICIT_EXTERN_C
-		  || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
-		  || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
-#endif
-	      ))
 	    {
 	      types_match = self_promoting_args_p (p1);
 	      if (p1 == void_list_node)
 		TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
 	    }
-#ifndef NO_IMPLICIT_EXTERN_C
-	  else if (!prototype_p (f1)
-		   && (DECL_EXTERN_C_P (olddecl)
-		       && DECL_IN_SYSTEM_HEADER (olddecl)
-		       && !DECL_CLASS_SCOPE_P (olddecl))
-		   && (DECL_EXTERN_C_P (newdecl)
-		       && DECL_IN_SYSTEM_HEADER (newdecl)
-		       && !DECL_CLASS_SCOPE_P (newdecl)))
-	    {
-	      types_match = self_promoting_args_p (p2);
-	      TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
-	    }
-#endif
 	  else
 	    types_match =
 	      compparms (p1, p2)
 	      && type_memfn_rqual (f1) == type_memfn_rqual (f2)
 	      && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl)) == NULL_TREE
 	 of the same function.   Disallow extern "C" functions to be
 	 versions for now.  */
 if (types_match
 	  && !DECL_EXTERN_C_P (newdecl)
 	  && !DECL_EXTERN_C_P (olddecl)
-	  && maybe_version_functions (newdecl, olddecl))
+	  && record_versions
+	  && maybe_version_functions (newdecl, olddecl,
+				      (!DECL_FUNCTION_VERSIONED (newdecl)
+				       || !DECL_FUNCTION_VERSIONED (olddecl))))
 	return 0;
 }
 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
 {
 tree oldres = DECL_TEMPLATE_RESULT (olddecl);
 return types_match;
 }
 /* NEWDECL and OLDDECL have identical signatures.  If they are
-different versions adjust them and return true.  */
+different versions adjust them and return true.
+If RECORD is set to true, record function versions.  */
 bool
-maybe_version_functions (tree newdecl, tree olddecl)
+maybe_version_functions (tree newdecl, tree olddecl, bool record)
 {
 if (!targetm.target_option.function_versions (newdecl, olddecl))
 return false;
-bool record = false;
 if (!DECL_FUNCTION_VERSIONED (olddecl))
 {
-record = true;
 DECL_FUNCTION_VERSIONED (olddecl) = 1;
 if (DECL_ASSEMBLER_NAME_SET_P (olddecl))
 	mangle_decl (olddecl);
 }
 if (!DECL_FUNCTION_VERSIONED (newdecl))
 {
-record = true;
 DECL_FUNCTION_VERSIONED (newdecl) = 1;
 if (DECL_ASSEMBLER_NAME_SET_P (newdecl))
 	mangle_decl (newdecl);
 }
-/* Only record if at least one was not already versions.  */
 if (record)
 cgraph_node::record_function_versions (olddecl, newdecl);
 return true;
 }
 /* It's OK to declare a builtin function as `static'.  */
 if (TREE_CODE (olddecl) == FUNCTION_DECL
 && DECL_ARTIFICIAL (olddecl))
 return;
+auto_diagnostic_group d;
 if (permerror (DECL_SOURCE_LOCATION (newdecl),
 		 "%qD was declared %<extern%> and later %<static%>", newdecl))
 inform (DECL_SOURCE_LOCATION (olddecl),
 	    "previous declaration of %qD", olddecl);
 }
 /* Two default specs are equivalent, don't force evaluation.  */
 if (UNEVALUATED_NOEXCEPT_SPEC_P (new_exceptions)
 && UNEVALUATED_NOEXCEPT_SPEC_P (old_exceptions))
 return;
-maybe_instantiate_noexcept (new_decl);
+if (!type_dependent_expression_p (old_decl))
-maybe_instantiate_noexcept (old_decl);
+{
+maybe_instantiate_noexcept (new_decl);
+maybe_instantiate_noexcept (old_decl);
+}
 new_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl));
 old_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl));
 /* [except.spec]
 {
 const char *const msg
 	= G_("declaration of %qF has a different exception specifier");
 bool complained = true;
 location_t new_loc = DECL_SOURCE_LOCATION (new_decl);
+auto_diagnostic_group d;
 if (DECL_IN_SYSTEM_HEADER (old_decl))
 	complained = pedwarn (new_loc, OPT_Wsystem_headers, msg, new_decl);
 else if (!flag_exceptions)
 	/* We used to silently permit mismatched eh specs with
 	   -fno-exceptions, so make them a pedwarn now.  */
 if (DECL_DECLARED_CONSTEXPR_P (old_decl)
 == DECL_DECLARED_CONSTEXPR_P (new_decl))
 return true;
 if (TREE_CODE (old_decl) == FUNCTION_DECL)
 {
-if (DECL_BUILT_IN (old_decl))
+if (fndecl_built_in_p (old_decl))
 	{
 	  /* Hide a built-in declaration.  */
 	  DECL_DECLARED_CONSTEXPR_P (old_decl)
 	    = DECL_DECLARED_CONSTEXPR_P (new_decl);
 	  return true;
 		   "arguments", decl);
 	return;
 }
 }
+/* NEWDECL is a redeclaration of a function or function template OLDDECL,
+in any case represented as FUNCTION_DECLs (the DECL_TEMPLATE_RESULTs of
+the TEMPLATE_DECLs in case of function templates).  This function is used
+to enforce the final part of C++17 11.3.6/4, about a single declaration:
+"If a friend declaration specifies a default argument expression, that
+declaration shall be a definition and shall be the only declaration of
+the function or function template in the translation unit."  */
+static void
+check_no_redeclaration_friend_default_args (tree olddecl, tree newdecl,
+					    bool olddecl_hidden_friend_p)
+{
+if (!olddecl_hidden_friend_p && !DECL_FRIEND_P (newdecl))
+return;
+tree t1 = FUNCTION_FIRST_USER_PARMTYPE (olddecl);
+tree t2 = FUNCTION_FIRST_USER_PARMTYPE (newdecl);
+for (; t1 && t1 != void_list_node;
+t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
+if ((olddecl_hidden_friend_p && TREE_PURPOSE (t1))
+	|| (DECL_FRIEND_P (newdecl) && TREE_PURPOSE (t2)))
+{
+	auto_diagnostic_group d;
+	if (permerror (DECL_SOURCE_LOCATION (newdecl),
+		       "friend declaration of %q#D specifies default "
+		       "arguments and isn't the only declaration", newdecl))
+	  inform (DECL_SOURCE_LOCATION (olddecl),
+		  "previous declaration of %q#D", olddecl);
+	return;
+}
+}
+/* Merge tree bits that correspond to attributes noreturn, nothrow,
+const,  malloc, and pure from NEWDECL with those of OLDDECL.  */
+static void
+merge_attribute_bits (tree newdecl, tree olddecl)
+{
+TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
+TREE_THIS_VOLATILE (olddecl) |= TREE_THIS_VOLATILE (newdecl);
+TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
+TREE_NOTHROW (olddecl) |= TREE_NOTHROW (newdecl);
+TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
+TREE_READONLY (olddecl) |= TREE_READONLY (newdecl);
+DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
+DECL_IS_MALLOC (olddecl) |= DECL_IS_MALLOC (newdecl);
+DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
+DECL_PURE_P (olddecl) |= DECL_PURE_P (newdecl);
+DECL_UNINLINABLE (newdecl) |= DECL_UNINLINABLE (olddecl);
+DECL_UNINLINABLE (olddecl) |= DECL_UNINLINABLE (newdecl);
+}
 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn)			\
 			  && lookup_attribute ("gnu_inline",		\
 					       DECL_ATTRIBUTES (fn)))
 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
 tree
 duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
 {
 unsigned olddecl_uid = DECL_UID (olddecl);
 int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
+int olddecl_hidden_friend = 0;
 int new_defines_function = 0;
 tree new_template_info;
+location_t olddecl_loc = DECL_SOURCE_LOCATION (olddecl);
+location_t newdecl_loc = DECL_SOURCE_LOCATION (newdecl);
 if (newdecl == olddecl)
 return olddecl;
 types_match = decls_match (newdecl, olddecl);
 about the same declaration, so just pretend the types match here.  */
 if (TREE_TYPE (newdecl) == error_mark_node
 || TREE_TYPE (olddecl) == error_mark_node)
 return error_mark_node;
-if (UDLIT_OPER_P (DECL_NAME (newdecl))
+if (DECL_NAME (newdecl)
+&& DECL_NAME (olddecl)
+&& 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"
+	error_at (newdecl_loc,
-	       " raw literal operator %qD", newdecl, olddecl);
+		  "literal operator template %qD 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"
+	error_at (newdecl_loc,
-	       " literal operator template %qD", newdecl, olddecl);
+		  "raw literal operator %qD conflicts with"
-}
+		  " literal operator template %qD", newdecl, olddecl);
+}
+/* True to merge attributes between the declarations, false to
+set OLDDECL's attributes to those of NEWDECL (for template
+explicit specializations that specify their own attributes
+independent of those specified for the primary template).  */
+const bool merge_attr = (TREE_CODE (newdecl) != FUNCTION_DECL
+			   || !DECL_TEMPLATE_SPECIALIZATION (newdecl)
+			   || DECL_TEMPLATE_SPECIALIZATION (olddecl));
 if (DECL_P (olddecl)
 && TREE_CODE (newdecl) == FUNCTION_DECL
 && TREE_CODE (olddecl) == FUNCTION_DECL
+&& merge_attr
 && diagnose_mismatched_attributes (olddecl, newdecl))
 {
 if (DECL_INITIAL (olddecl))
-	inform (DECL_SOURCE_LOCATION (olddecl),
+	inform (olddecl_loc,
 		"previous definition of %qD was here", olddecl);
 else
-	inform (DECL_SOURCE_LOCATION (olddecl),
+	inform (olddecl_loc,
 		"previous declaration of %qD was here", olddecl);
 }
 /* Check for redeclaration and other discrepancies.  */
 if (TREE_CODE (olddecl) == FUNCTION_DECL
 	     explicitly declared.  */
 	  if (DECL_ANTICIPATED (olddecl))
 	    {
 	      if (TREE_PUBLIC (newdecl)
 		  && CP_DECL_CONTEXT (newdecl) == global_namespace)
-		warning_at (DECL_SOURCE_LOCATION (newdecl),
+		warning_at (newdecl_loc,
 			    OPT_Wbuiltin_declaration_mismatch,
 			    "built-in function %qD declared as non-function",
 			    newdecl);
 	      return NULL_TREE;
 	    }
 	  /* If you declare a built-in or predefined function name as static,
 	     the old definition is overridden, but optionally warn this was a
 	     bad choice of name.  */
 	  if (! TREE_PUBLIC (newdecl))
 	    {
-	      warning (OPT_Wshadow,
+	      warning_at (newdecl_loc,
-DECL_BUILT_IN (olddecl)
+			  OPT_Wshadow,
-? G_("shadowing built-in function %q#D")
+			  fndecl_built_in_p (olddecl)
-: G_("shadowing library function %q#D"), olddecl);
+			  ? G_("shadowing built-in function %q#D")
+			  : G_("shadowing library function %q#D"), olddecl);
 	      /* Discard the old built-in function.  */
 	      return NULL_TREE;
 	    }
 	  /* If the built-in is not ansi, then programs can override
 	     it even globally without an error.  */
-	  else if (! DECL_BUILT_IN (olddecl))
+	  else if (! fndecl_built_in_p (olddecl))
-	    warning_at (DECL_SOURCE_LOCATION (newdecl), 0,
+	    warning_at (newdecl_loc, 0,
 			"library function %q#D redeclared as non-function %q#D",
 			olddecl, newdecl);
 	  else
-	    error ("declaration of %q+#D conflicts with built-in "
+	    error_at (newdecl_loc,
-		   "declaration %q#D", newdecl, olddecl);
+		      "declaration of %q#D conflicts with built-in "
+		      "declaration %q#D", newdecl, olddecl);
 	  return NULL_TREE;
 	}
 else if (DECL_OMP_DECLARE_REDUCTION_P (olddecl))
 	{
 	  gcc_assert (DECL_OMP_DECLARE_REDUCTION_P (newdecl));
-	  error_at (DECL_SOURCE_LOCATION (newdecl),
+	  error_at (newdecl_loc,
 		    "redeclaration of %<pragma omp declare reduction%>");
-	  inform (DECL_SOURCE_LOCATION (olddecl),
+	  inform (olddecl_loc,
 		  "previous %<pragma omp declare reduction%> declaration");
 	  return error_mark_node;
 	}
 else if (!types_match)
 	{
 		  if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
 		    break;
 next_arg:;
 		}
-	      warning_at (DECL_SOURCE_LOCATION (newdecl),
+	      warning_at (newdecl_loc,
 			  OPT_Wbuiltin_declaration_mismatch,
 			  "declaration of %q#D conflicts with built-in "
 			  "declaration %q#D", newdecl, olddecl);
 	    }
 	  else if ((DECL_EXTERN_C_P (newdecl)
 		    && DECL_EXTERN_C_P (olddecl))
 		   || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
 				 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
 	    {
+	      /* Don't really override olddecl for __* prefixed builtins
+		 except for __[^b]*_chk, the compiler might be using those
+		 explicitly.  */
+	      if (fndecl_built_in_p (olddecl))
+		{
+		  tree id = DECL_NAME (olddecl);
+		  const char *name = IDENTIFIER_POINTER (id);
+		  size_t len;
+		  if (name[0] == '_'
+		      && name[1] == '_'
+		      && (strncmp (name + 2, "builtin_",
+				   strlen ("builtin_")) == 0
+			  || (len = strlen (name)) <= strlen ("___chk")
+			  || memcmp (name + len - strlen ("_chk"),
+				     "_chk", strlen ("_chk") + 1) != 0))
+		    {
+		      if (DECL_INITIAL (newdecl))
+			{
+			  error_at (newdecl_loc,
+				    "definition of %q#D ambiguates built-in "
+				    "declaration %q#D", newdecl, olddecl);
+			  return error_mark_node;
+			}
+		      auto_diagnostic_group d;
+		      if (permerror (newdecl_loc,
+				     "new declaration %q#D ambiguates built-in"
+				     " declaration %q#D", newdecl, olddecl)
+			  && flag_permissive)
+			inform (newdecl_loc,
+				"ignoring the %q#D declaration", newdecl);
+		      return flag_permissive ? olddecl : error_mark_node;
+		    }
+		}
 	      /* A near match; override the builtin.  */
 	      if (TREE_PUBLIC (newdecl))
-		warning_at (DECL_SOURCE_LOCATION (newdecl),
+		warning_at (newdecl_loc,
 			    OPT_Wbuiltin_declaration_mismatch,
 			    "new declaration %q#D ambiguates built-in "
 			    "declaration %q#D", newdecl, olddecl);
 	      else
 		warning (OPT_Wshadow,
-DECL_BUILT_IN (olddecl)
+			 fndecl_built_in_p (olddecl)
-? G_("shadowing built-in function %q#D")
+			 ? G_("shadowing built-in function %q#D")
-: G_("shadowing library function %q#D"), olddecl);
+			 : G_("shadowing library function %q#D"), olddecl);
 	    }
 	  else
 	    /* Discard the old built-in function.  */
 	    return NULL_TREE;
 	}
 error ("%q#D redeclared as different kind of symbol", newdecl);
 if (TREE_CODE (olddecl) == TREE_LIST)
 	olddecl = TREE_VALUE (olddecl);
-inform (DECL_SOURCE_LOCATION (olddecl),
+inform (olddecl_loc,
 	      "previous declaration %q#D", olddecl);
 return error_mark_node;
 }
 else if (!types_match)
 	     any other template, class, function, object, namespace, value,
 	     or type in the same scope.  */
 	  if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
 	      || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
 	    {
-	      error ("conflicting declaration of template %q+#D", newdecl);
+	      error_at (newdecl_loc,
-	      inform (DECL_SOURCE_LOCATION (olddecl),
+			"conflicting declaration of template %q#D", newdecl);
+	      inform (olddecl_loc,
 		      "previous declaration %q#D", olddecl);
 	      return error_mark_node;
 	    }
 	  else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
 		   && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
 				   TREE_TYPE (TREE_TYPE (olddecl)))
 // Template functions can also be disambiguated by
 // constraints.
 && equivalently_constrained (olddecl, newdecl))
 	    {
-	      error ("ambiguating new declaration %q+#D", newdecl);
+	      error_at (newdecl_loc, "ambiguating new declaration %q#D",
-	      inform (DECL_SOURCE_LOCATION (olddecl),
+			newdecl);
+	      inform (olddecl_loc,
 		      "old declaration %q#D", olddecl);
 	    }
 else if (check_concept_refinement (olddecl, newdecl))
 	    return error_mark_node;
 	  return NULL_TREE;
 	}
 if (TREE_CODE (newdecl) == FUNCTION_DECL)
 	{
 	  if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
 	    {
-	      error ("conflicting declaration of C function %q+#D",
+	      error_at (newdecl_loc,
-		     newdecl);
+			"conflicting declaration of C function %q#D",
-	      inform (DECL_SOURCE_LOCATION (olddecl),
+			newdecl);
+	      inform (olddecl_loc,
 		      "previous declaration %q#D", olddecl);
 	      return NULL_TREE;
 	    }
 	  /* For function versions, params and types match, but they
 	     are not ambiguous.  */
 		   && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
 				 TYPE_ARG_TYPES (TREE_TYPE (olddecl)))
 // And the same constraints.
 && equivalently_constrained (newdecl, olddecl))
 	    {
-	      error ("ambiguating new declaration of %q+#D", newdecl);
+	      error_at (newdecl_loc,
-	      inform (DECL_SOURCE_LOCATION (olddecl),
+			"ambiguating new declaration of %q#D", newdecl);
+	      inform (olddecl_loc,
 		      "old declaration %q#D", olddecl);
 return error_mark_node;
 	    }
 	  else
 	    return NULL_TREE;
 	}
 else
 	{
-	  error ("conflicting declaration %q+#D", newdecl);
+	  error_at (newdecl_loc, "conflicting declaration %q#D", newdecl);
-	  inform (DECL_SOURCE_LOCATION (olddecl),
+	  inform (olddecl_loc,
 		  "previous declaration as %q#D", olddecl);
 	  return error_mark_node;
 	}
 }
 else if (TREE_CODE (newdecl) == FUNCTION_DECL
 else
 {
 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
 if (errmsg)
 	{
-	  error_at (DECL_SOURCE_LOCATION (newdecl), errmsg, newdecl);
+	  auto_diagnostic_group d;
+	  error_at (newdecl_loc, errmsg, newdecl);
 	  if (DECL_NAME (olddecl) != NULL_TREE)
-	    inform (DECL_SOURCE_LOCATION (olddecl),
+	    inform (olddecl_loc,
 		    (DECL_INITIAL (olddecl) && namespace_bindings_p ())
 		    ? G_("%q#D previously defined here")
 		    : G_("%q#D previously declared here"), olddecl);
 	  return error_mark_node;
 	}
 	       && DECL_INITIAL (olddecl) != NULL_TREE
 	       && !prototype_p (TREE_TYPE (olddecl))
 	       && prototype_p (TREE_TYPE (newdecl)))
 	{
 	  /* Prototype decl follows defn w/o prototype.  */
-	  if (warning_at (DECL_SOURCE_LOCATION (newdecl), 0,
+	  auto_diagnostic_group d;
+	  if (warning_at (newdecl_loc, 0,
 			  "prototype specified for %q#D", newdecl))
-	    inform (DECL_SOURCE_LOCATION (olddecl),
+	    inform (olddecl_loc,
 		    "previous non-prototype definition here");
 	}
 else if (VAR_OR_FUNCTION_DECL_P (olddecl)
 	       && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
 	{
 	      retrofit_lang_decl (newdecl);
 	      SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
 	    }
 	  else
 	    {
-	      error ("conflicting declaration of %q+#D with %qL linkage",
+	      auto_diagnostic_group d;
-		     newdecl, DECL_LANGUAGE (newdecl));
+	      error_at (newdecl_loc,
-	      inform (DECL_SOURCE_LOCATION (olddecl),
+			"conflicting declaration of %q#D with %qL linkage",
+			newdecl, DECL_LANGUAGE (newdecl));
+	      inform (olddecl_loc,
 		      "previous declaration with %qL linkage",
 		      DECL_LANGUAGE (olddecl));
 	    }
 	}
 	      for (; t1 && t1 != void_list_node;
 		   t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
 		if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
 		  {
-		    if (1 == simple_cst_equal (TREE_PURPOSE (t1),
+		    if (simple_cst_equal (TREE_PURPOSE (t1),
-					       TREE_PURPOSE (t2)))
+					  TREE_PURPOSE (t2)) == 1)
 		      {
-			if (permerror (input_location,
+			auto_diagnostic_group d;
+			if (permerror (newdecl_loc,
 				       "default argument given for parameter "
 				       "%d of %q#D", i, newdecl))
-			  inform (DECL_SOURCE_LOCATION (olddecl),
+			  inform (olddecl_loc,
 				  "previous specification in %q#D here",
 				  olddecl);
 		      }
 		    else
 		      {
-			error ("default argument given for parameter %d "
+			auto_diagnostic_group d;
-			       "of %q#D", i, newdecl);
+			error_at (newdecl_loc,
-			inform (DECL_SOURCE_LOCATION (olddecl),
+				  "default argument given for parameter %d "
+				  "of %q#D", i, newdecl);
+			inform (olddecl_loc,
 				"previous specification in %q#D here",
 				olddecl);
 		      }
 		  }
+	      /* C++17 11.3.6/4: "If a friend declaration specifies a default
+		 argument expression, that declaration... shall be the only
+		 declaration of the function or function template in the
+		 translation unit."  */
+	      check_no_redeclaration_friend_default_args
+		(olddecl, newdecl, DECL_HIDDEN_FRIEND_P (olddecl));
 	    }
 	}
 }
 /* Do not merge an implicit typedef with an explicit one.  In:
 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
 DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl);
 DECL_FINAL_P (newdecl) |= DECL_FINAL_P (olddecl);
 DECL_OVERRIDE_P (newdecl) |= DECL_OVERRIDE_P (olddecl);
 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
-if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
+if (DECL_OVERLOADED_OPERATOR_P (olddecl))
-	SET_OVERLOADED_OPERATOR_CODE
+	DECL_OVERLOADED_OPERATOR_CODE_RAW (newdecl)
-	  (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
+	  = DECL_OVERLOADED_OPERATOR_CODE_RAW (olddecl);
 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
 /* Optionally warn about more than one declaration for the same
 	 name, but don't warn about a function declaration followed by a
 	 definition.  */
 	  && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl))
 	  /* Don't warn about declaration followed by specialization.  */
 	  && (! DECL_TEMPLATE_SPECIALIZATION (newdecl)
 	      || DECL_TEMPLATE_SPECIALIZATION (olddecl)))
 	{
-	  if (warning_at (DECL_SOURCE_LOCATION (newdecl),
+	  auto_diagnostic_group d;
+	  if (warning_at (newdecl_loc,
 			  OPT_Wredundant_decls,
 			  "redundant redeclaration of %qD in same scope",
 			  newdecl))
-	    inform (DECL_SOURCE_LOCATION (olddecl),
+	    inform (olddecl_loc,
 		    "previous declaration of %qD", olddecl);
 	}
 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl)
 	    && DECL_TEMPLATE_SPECIALIZATION (newdecl)))
 	{
 	  if (DECL_DELETED_FN (newdecl))
 	    {
-	      error ("deleted definition of %q+D", newdecl);
+	      auto_diagnostic_group d;
-	      inform (DECL_SOURCE_LOCATION (olddecl),
+	      error_at (newdecl_loc, "deleted definition of %qD", newdecl);
+	      inform (olddecl_loc,
 		      "previous declaration of %qD", olddecl);
 	    }
 	  DECL_DELETED_FN (newdecl) |= DECL_DELETED_FN (olddecl);
 	}
 }
 	  = CLASSTYPE_FRIEND_CLASSES (oldtype);
 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
 }
-/* Copy all the DECL_... slots specified in the new decl
+/* Copy all the DECL_... slots specified in the new decl except for
-except for any that we copy here from the old type.  */
+any that we copy here from the old type.  */
-DECL_ATTRIBUTES (newdecl)
+if (merge_attr)
-= (*targetm.merge_decl_attributes) (olddecl, newdecl);
+DECL_ATTRIBUTES (newdecl)
+= (*targetm.merge_decl_attributes) (olddecl, newdecl);
+else
+DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
 if (DECL_DECLARES_FUNCTION_P (olddecl) && DECL_DECLARES_FUNCTION_P (newdecl))
 {
 olddecl_friend = DECL_FRIEND_P (olddecl);
+olddecl_hidden_friend = DECL_HIDDEN_FRIEND_P (olddecl);
 hidden_friend = (DECL_ANTICIPATED (olddecl)
 		       && DECL_HIDDEN_FRIEND_P (olddecl)
 		       && newdecl_is_friend);
 if (!hidden_friend)
 	{
 	}
 }
 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
 {
-tree old_result;
+tree old_result = DECL_TEMPLATE_RESULT (olddecl);
-tree new_result;
+tree new_result = DECL_TEMPLATE_RESULT (newdecl);
-old_result = DECL_TEMPLATE_RESULT (olddecl);
-new_result = DECL_TEMPLATE_RESULT (newdecl);
 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
 	= chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
 		   DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
 DECL_ATTRIBUTES (old_result)
 	= (*targetm.merge_decl_attributes) (old_result, new_result);
 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
 	{
-	  /* Per C++11 8.3.6/4, default arguments cannot be added in later
-	     declarations of a function template.  */
 	  if (DECL_SOURCE_LOCATION (newdecl)
 	      != DECL_SOURCE_LOCATION (olddecl))
-	    check_redeclaration_no_default_args (newdecl);
+	    {
+	      /* Per C++11 8.3.6/4, default arguments cannot be added in
+		 later declarations of a function template.  */
+	      check_redeclaration_no_default_args (newdecl);
+	      /* C++17 11.3.6/4: "If a friend declaration specifies a default
+		 argument expression, that declaration... shall be the only
+		 declaration of the function or function template in the
+		 translation unit."  */
+	      check_no_redeclaration_friend_default_args
+		(old_result, new_result, olddecl_hidden_friend);
+	    }
 	  check_default_args (newdecl);
 	  if (GNU_INLINE_P (old_result) != GNU_INLINE_P (new_result)
 	      && DECL_INITIAL (new_result))
 	      DECL_DECLARED_INLINE_P (old_result)
 		|= DECL_DECLARED_INLINE_P (new_result);
 	      DECL_DISREGARD_INLINE_LIMITS (old_result)
 	        |= DECL_DISREGARD_INLINE_LIMITS (new_result);
 	      check_redeclaration_exception_specification (newdecl, olddecl);
+	      merge_attribute_bits (new_result, old_result);
 	    }
 	}
 /* If the new declaration is a definition, update the file and
 	 line information on the declaration, and also make
 		    TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (remove);
 		    break;
 		  }
 	    }
 	}
+else if (merge_attr)
+	newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
 else
-	/* Merge the data types specified in the two decls.  */
+	newtype = TREE_TYPE (newdecl);
-	newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
 if (VAR_P (newdecl))
 	{
 	  DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
 	  /* For already initialized vars, TREE_READONLY could have been
 	      && !TREE_READONLY (olddecl))
 	    TREE_READONLY (newdecl) = 0;
 	  DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
 	  DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
 	    |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
+	  if (DECL_DEPENDENT_INIT_P (olddecl))
+	    SET_DECL_DEPENDENT_INIT_P (newdecl, true);
 	  DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
 	    |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
 if (DECL_CLASS_SCOPE_P (olddecl))
 DECL_DECLARED_CONSTEXPR_P (newdecl)
 	      |= DECL_DECLARED_CONSTEXPR_P (olddecl);
 	   || TREE_CODE (newdecl) == FIELD_DECL
 	   || TREE_CODE (newdecl) == TYPE_DECL)
 	  && !(processing_template_decl && uses_template_parms (newdecl)))
 	layout_decl (newdecl, 0);
-/* Merge the type qualifiers.  */
-if (TREE_READONLY (newdecl))
-	TREE_READONLY (olddecl) = 1;
-if (TREE_THIS_VOLATILE (newdecl))
-	TREE_THIS_VOLATILE (olddecl) = 1;
-if (TREE_NOTHROW (newdecl))
-	TREE_NOTHROW (olddecl) = 1;
 /* Merge deprecatedness.  */
 if (TREE_DEPRECATED (newdecl))
 	TREE_DEPRECATED (olddecl) = 1;
 /* Preserve function specific target and optimization options */
 	  if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
 	      && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
 	    DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
 	      = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
+	}
+else
+	{
+	  /* Merge the const type qualifier.  */
+	  if (TREE_READONLY (newdecl))
+	    TREE_READONLY (olddecl) = 1;
+	  /* Merge the volatile type qualifier.  */
+	  if (TREE_THIS_VOLATILE (newdecl))
+	    TREE_THIS_VOLATILE (olddecl) = 1;
 	}
 /* Merge the initialization information.  */
 if (DECL_INITIAL (newdecl) == NULL_TREE
 	  && DECL_INITIAL (olddecl) != NULL_TREE)
 if (TREE_CODE (newdecl) == FUNCTION_DECL)
 	{
 	  DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
 	    |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
 	  DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
-	  TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
-	  TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
-	  DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
 	  DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
-	  DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
+	  DECL_LOOPING_CONST_OR_PURE_P (newdecl)
-	  TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
-	  DECL_LOOPING_CONST_OR_PURE_P (newdecl)
 	    |= DECL_LOOPING_CONST_OR_PURE_P (olddecl);
+	  if (merge_attr)
+	    merge_attribute_bits (newdecl, olddecl);
+	  else
+	    {
+	      /* Merge the noreturn bit.  */
+	      TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
+	      TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
+	      TREE_NOTHROW (olddecl) = TREE_NOTHROW (newdecl);
+	      DECL_IS_MALLOC (olddecl) = DECL_IS_MALLOC (newdecl);
+	      DECL_PURE_P (olddecl) = DECL_PURE_P (newdecl);
+	    }
 	  /* Keep the old RTL.  */
 	  COPY_DECL_RTL (olddecl, newdecl);
 	}
 else if (VAR_P (newdecl)
 	       && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
 	     appropriate.  */
 	  DECL_VISIBILITY_SPECIFIED (olddecl) = 0;
 	  /* [temp.expl.spec/14] We don't inline explicit specialization
 	     just because the primary template says so.  */
+	  gcc_assert (!merge_attr);
-	  /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
-	     the always_inline attribute.  */
+	  DECL_DECLARED_INLINE_P (olddecl)
-	  if (DECL_DISREGARD_INLINE_LIMITS (olddecl)
+	    = DECL_DECLARED_INLINE_P (newdecl);
-	      && !DECL_DISREGARD_INLINE_LIMITS (newdecl))
-	    {
+	  DECL_DISREGARD_INLINE_LIMITS (olddecl)
-	      if (DECL_DECLARED_INLINE_P (newdecl))
+	    = DECL_DISREGARD_INLINE_LIMITS (newdecl);
-		DECL_DISREGARD_INLINE_LIMITS (newdecl) = true;
-	      else
+	  DECL_UNINLINABLE (olddecl) = DECL_UNINLINABLE (newdecl);
-		DECL_ATTRIBUTES (newdecl)
-		  = remove_attribute ("always_inline",
-				      DECL_ATTRIBUTES (newdecl));
-	    }
 	}
 else if (new_defines_function && DECL_INITIAL (olddecl))
 	{
 	  /* Never inline re-defined extern inline functions.
 	     FIXME: this could be better handled by keeping both
 	  DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
 	}
 /* If redeclaring a builtin function, it stays built in
 	 if newdecl is a gnu_inline definition, or if newdecl is just
 	 a declaration.  */
-if (DECL_BUILT_IN (olddecl)
+if (fndecl_built_in_p (olddecl)
 	  && (new_defines_function ? GNU_INLINE_P (newdecl) : types_match))
 	{
 	  DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
 	  DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
 	  /* If we're keeping the built-in definition, keep the rtl,
 /* Warn about conflicting visibility specifications.  */
 if (DECL_VISIBILITY_SPECIFIED (olddecl)
 && DECL_VISIBILITY_SPECIFIED (newdecl)
 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
 {
-if (warning_at (DECL_SOURCE_LOCATION (newdecl), OPT_Wattributes,
+auto_diagnostic_group d;
+if (warning_at (newdecl_loc, OPT_Wattributes,
 		      "%qD: visibility attribute ignored because it "
 		      "conflicts with previous declaration", newdecl))
-	inform (DECL_SOURCE_LOCATION (olddecl),
+	inform (olddecl_loc,
 		"previous declaration of %qD", olddecl);
 }
 /* Choose the declaration which specified visibility.  */
 if (DECL_VISIBILITY_SPECIFIED (olddecl))
 {
 /* Static data member declared outside a class definition
 	 if the variable is defined within the class with constexpr
 	 specifier is declaration rather than definition (and
 	 deprecated).  */
 if (cxx_dialect >= cxx17
+	  && VAR_P (olddecl)
 	  && DECL_CLASS_SCOPE_P (olddecl)
 	  && DECL_DECLARED_CONSTEXPR_P (olddecl)
 	  && !DECL_INITIAL (newdecl))
 	{
 	  DECL_EXTERNAL (newdecl) = 1;
 	  /* For now, only warn with explicit -Wdeprecated.  */
-	  if (global_options_set.x_warn_deprecated
+	  if (global_options_set.x_warn_deprecated)
-	      && warning_at (DECL_SOURCE_LOCATION (newdecl), OPT_Wdeprecated,
+	    {
-			     "redundant redeclaration of %<constexpr%> static "
+	      auto_diagnostic_group d;
-			     "data member %qD", newdecl))
+	      if (warning_at (DECL_SOURCE_LOCATION (newdecl), OPT_Wdeprecated,
-	    inform (DECL_SOURCE_LOCATION (olddecl),
+				"redundant redeclaration of %<constexpr%> "
-		    "previous declaration of %qD", olddecl);
+				"static data member %qD", newdecl))
+		inform (DECL_SOURCE_LOCATION (olddecl),
+			  "previous declaration of %qD", olddecl);
+	    }
 	  return NULL;
 	}
 /* Reject two definitions.  */
 return G_("redefinition of %q#D");
 	    continue;
 	  if (!identified)
 	    {
 	      complained = identify_goto (decl, input_location, locus,
-					  DK_PERMERROR);
+					  problem > 1
+					  ? DK_ERROR : DK_PERMERROR);
 	      identified = 1;
 	    }
 	  if (complained)
 	    {
 	      if (problem > 1)
 else if (ent->in_catch_scope && !saw_catch)
 	inform (input_location, "  enters catch block");
 else if (ent->in_transaction_scope)
 	inform (input_location, "  enters synchronized or atomic statement");
 else if (ent->in_constexpr_if)
-	inform (input_location, "  enters constexpr if statement");
+	inform (input_location, "  enters %<constexpr%> if statement");
 }
 if (ent->in_omp_scope)
 {
 if (complained)
 of the GNU case range extension.  */
 splay_tree cases;
 /* Remember whether there was a case value that is outside the
 range of the original type of the controlling expression.  */
 bool outside_range_p;
+/* Remember whether a default: case label has been seen.  */
+bool has_default_p;
+/* Remember whether a BREAK_STMT has been seen in this SWITCH_STMT.  */
+bool break_stmt_seen_p;
+/* Set if inside of {FOR,DO,WHILE}_BODY nested inside of a switch,
+where BREAK_STMT doesn't belong to the SWITCH_STMT.  */
+bool in_loop_body_p;
 };
 /* A stack of the currently active switch statements.  The innermost
 switch statement is on the top of the stack.  There is no need to
 mark the stack for garbage collection because it is only active
 p->level = current_binding_level;
 p->next = switch_stack;
 p->switch_stmt = switch_stmt;
 p->cases = splay_tree_new (case_compare, NULL, NULL);
 p->outside_range_p = false;
+p->has_default_p = false;
+p->break_stmt_seen_p = false;
+p->in_loop_body_p = false;
 switch_stack = p;
 }
 void
 pop_switch (void)
 {
 struct cp_switch *cs = switch_stack;
 location_t switch_location;
 /* Emit warnings as needed.  */
-switch_location = EXPR_LOC_OR_LOC (cs->switch_stmt, input_location);
+switch_location = cp_expr_loc_or_loc (cs->switch_stmt, input_location);
 const bool bool_cond_p
 = (SWITCH_STMT_TYPE (cs->switch_stmt)
 && TREE_CODE (SWITCH_STMT_TYPE (cs->switch_stmt)) == BOOLEAN_TYPE);
 if (!processing_template_decl)
 c_do_switch_warnings (cs->cases, switch_location,
 			  SWITCH_STMT_TYPE (cs->switch_stmt),
 			  SWITCH_STMT_COND (cs->switch_stmt),
 			  bool_cond_p, cs->outside_range_p);
+/* For the benefit of block_may_fallthru remember if the switch body
+case labels cover all possible values and if there are break; stmts.  */
+if (cs->has_default_p
+|| (!processing_template_decl
+	  && c_switch_covers_all_cases_p (cs->cases,
+					  SWITCH_STMT_TYPE (cs->switch_stmt))))
+SWITCH_STMT_ALL_CASES_P (cs->switch_stmt) = 1;
+if (!cs->break_stmt_seen_p)
+SWITCH_STMT_NO_BREAK_P (cs->switch_stmt) = 1;
+gcc_assert (!cs->in_loop_body_p);
 splay_tree_delete (cs->cases);
 switch_stack = switch_stack->next;
 free (cs);
+}
+/* Note that a BREAK_STMT is about to be added.  If it is inside of
+a SWITCH_STMT and not inside of a loop body inside of it, note
+in switch_stack we've seen a BREAK_STMT.  */
+void
+note_break_stmt (void)
+{
+if (switch_stack && !switch_stack->in_loop_body_p)
+switch_stack->break_stmt_seen_p = true;
+}
+/* Note the start of processing of an iteration statement's body.
+The note_break_stmt function will do nothing while processing it.
+Return a flag that should be passed to note_iteration_stmt_body_end.  */
+bool
+note_iteration_stmt_body_start (void)
+{
+if (!switch_stack)
+return false;
+bool ret = switch_stack->in_loop_body_p;
+switch_stack->in_loop_body_p = true;
+return ret;
+}
+/* Note the end of processing of an iteration statement's body.  */
+void
+note_iteration_stmt_body_end (bool prev)
+{
+if (switch_stack)
+switch_stack->in_loop_body_p = prev;
 }
 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
 condition.  Note that if TYPE and VALUE are already integral we don't
 really do the conversion because the language-independent
 static tree
 case_conversion (tree type, tree value)
 {
 if (value == NULL_TREE)
 return value;
+value = mark_rvalue_use (value);
 if (cxx_dialect >= cxx11
 && (SCOPED_ENUM_P (type)
 	  || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value))))
 {
 {
 tree cond, r;
 cp_binding_level *p;
 tree type;
+if (low_value == NULL_TREE && high_value == NULL_TREE)
+switch_stack->has_default_p = true;
 if (processing_template_decl)
 {
 tree label;
 /* For templates, just add the case label; we'll do semantic
 if (!check_switch_goto (switch_stack->level))
 return error_mark_node;
 type = SWITCH_STMT_TYPE (switch_stack->switch_stmt);
+if (type == error_mark_node)
+return error_mark_node;
 low_value = case_conversion (type, low_value);
 high_value = case_conversion (type, high_value);
 r = c_add_case_label (loc, switch_stack->cases, cond, type,
 	}
 }
 if (TREE_CODE (name) == TEMPLATE_DECL)
 {
 if (complain & tf_error)
-	error ("%qD used without template parameters", name);
+	error ("%qD used without template arguments", name);
 return error_mark_node;
 }
 gcc_assert (identifier_p (name));
 gcc_assert (TYPE_P (context));
 	 to be unique to the TU.  */
 {"_GLOBAL__N_1", &anon_identifier, cik_normal},
 {"auto", &auto_identifier, cik_normal},
 {"decltype(auto)", &decltype_auto_identifier, cik_normal},
 {"initializer_list", &init_list_identifier, cik_normal},
+{"__for_range ", &for_range__identifier, cik_normal},
+{"__for_begin ", &for_begin__identifier, cik_normal},
+{"__for_end ", &for_end__identifier, cik_normal},
+{"__for_range", &for_range_identifier, cik_normal},
+{"__for_begin", &for_begin_identifier, cik_normal},
+{"__for_end", &for_end_identifier, cik_normal},
+{"abi_tag", &abi_tag_identifier, cik_normal},
+{"aligned", &aligned_identifier, cik_normal},
+{"begin", &begin_identifier, cik_normal},
+{"end", &end_identifier, cik_normal},
+{"get", &get__identifier, cik_normal},
+{"gnu", &gnu_identifier, cik_normal},
+{"tuple_element", &tuple_element_identifier, cik_normal},
+{"tuple_size", &tuple_size_identifier, cik_normal},
+{"type", &type_identifier, cik_normal},
+{"value", &value_identifier, cik_normal},
+{"_FUN", &fun_identifier, cik_normal},
+{"__closure", &closure_identifier, cik_normal},
 {NULL, NULL, cik_normal}
 };
 for (const predefined_identifier *pid = predefined_identifiers;
 pid->name; ++pid)
 global_namespace = build_lang_decl (NAMESPACE_DECL, global_identifier,
 				      void_type_node);
 TREE_PUBLIC (global_namespace) = 1;
 DECL_CONTEXT (global_namespace)
 = build_translation_unit_decl (get_identifier (main_input_filename));
+/* Remember whether we want the empty class passing ABI change warning
+in this TU.  */
+TRANSLATION_UNIT_WARN_EMPTY_P (DECL_CONTEXT (global_namespace))
+= warn_abi && abi_version_crosses (12);
 debug_hooks->register_main_translation_unit
 (DECL_CONTEXT (global_namespace));
 begin_scope (sk_namespace, global_namespace);
 current_namespace = global_namespace;
 pop_namespace ();
 flag_noexcept_type = (cxx_dialect >= cxx17);
 c_common_nodes_and_builtins ();
+tree bool_ftype = build_function_type_list (boolean_type_node, NULL_TREE);
+tree decl
+= add_builtin_function ("__builtin_is_constant_evaluated",
+			    bool_ftype, CP_BUILT_IN_IS_CONSTANT_EVALUATED,
+			    BUILT_IN_FRONTEND, NULL, NULL_TREE);
+set_call_expr_flags (decl, ECF_CONST | ECF_NOTHROW | ECF_LEAF);
 integer_two_node = build_int_cst (NULL_TREE, 2);
 /* Guess at the initial static decls size.  */
 vec_alloc (static_decls, 500);
 const char *name = IDENTIFIER_POINTER (id);
 retrofit_lang_decl (decl);
 DECL_ARTIFICIAL (decl) = 1;
-SET_OVERLOADED_OPERATOR_CODE (decl, ERROR_MARK);
 SET_DECL_LANGUAGE (decl, lang_c);
 /* Runtime library routines are, by definition, available in an
 external shared object.  */
 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
 DECL_VISIBILITY_SPECIFIED (decl) = 1;
 {
 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
 DECL_EXTERNAL (fn) = 1;
 TREE_PUBLIC (fn) = 1;
 DECL_ARTIFICIAL (fn) = 1;
-SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
+DECL_OVERLOADED_OPERATOR_CODE_RAW (fn)
+= OVL_OP_INFO (false, operator_code)->ovl_op_code;
 SET_DECL_LANGUAGE (fn, lang_c);
 /* Runtime library routines are, by definition, available in an
 external shared object.  */
 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
 DECL_VISIBILITY_SPECIFIED (fn) = 1;
 static tree
 push_cp_library_fn (enum tree_code operator_code, tree type,
 		    int ecf_flags)
 {
-tree fn = build_cp_library_fn (cp_operator_id (operator_code),
+tree fn = build_cp_library_fn (ovl_op_identifier (false, operator_code),
-				 operator_code,
+				 operator_code, type, ecf_flags);
-				 type, ecf_flags);
 pushdecl (fn);
 if (flag_tm)
 apply_tm_attr (fn, get_identifier ("transaction_safe"));
 return fn;
 }
 warn_misplaced_attr_for_class_type (source_location location,
 				    tree class_type)
 {
 gcc_assert (OVERLOAD_TYPE_P (class_type));
+auto_diagnostic_group d;
 if (warning_at (location, OPT_Wattributes,
 		  "attribute ignored in declaration "
 		  "of %q#T", class_type))
 inform (location,
 	    "attribute for %q#T must follow the %qs keyword",
 error ("definition of %q#D is marked %<dllimport%>", decl);
 DECL_DLLIMPORT_P (decl) = 0;
 }
 /* If #pragma weak was used, mark the decl weak now.  */
-if (!processing_template_decl)
+if (!processing_template_decl && !DECL_DECOMPOSITION_P (decl))
 maybe_apply_pragma_weak (decl);
 if (TREE_CODE (decl) == FUNCTION_DECL
 && DECL_DECLARED_INLINE_P (decl)
 && DECL_UNINLINABLE (decl)
 	{
 	  tree field = lookup_field (context, DECL_NAME (decl), 0, false);
 	  if (field == NULL_TREE
 	      || !(VAR_P (field) || variable_template_p (field)))
 	    error ("%q+#D is not a static data member of %q#T", decl, context);
+	  else if (variable_template_p (field)
+		   && (DECL_LANG_SPECIFIC (decl)
+		       && DECL_TEMPLATE_SPECIALIZATION (decl)))
+	    /* OK, specialization was already checked.  */;
 	  else if (variable_template_p (field) && !this_tmpl)
 	    {
-	      if (DECL_LANG_SPECIFIC (decl)
+	      error_at (DECL_SOURCE_LOCATION (decl),
-		  && DECL_TEMPLATE_SPECIALIZATION (decl))
+			"non-member-template declaration of %qD", decl);
-		/* OK, specialization was already checked.  */;
+	      inform (DECL_SOURCE_LOCATION (field), "does not match "
-	      else
+		      "member template declaration here");
-		{
+	      return error_mark_node;
-		  error_at (DECL_SOURCE_LOCATION (decl),
-			    "non-member-template declaration of %qD", decl);
-		  inform (DECL_SOURCE_LOCATION (field), "does not match "
-			  "member template declaration here");
-		  return error_mark_node;
-		}
 	    }
 	  else
 	    {
 	      if (variable_template_p (field))
 		field = DECL_TEMPLATE_RESULT (field);
 a given brace-enclosed initializer is for a class type or for an
 array.  This function checks that CE does not use a designated
 initializer.  If it does, an error is issued.  Returns true if CE
 is valid, i.e., does not have a designated initializer.  */
-static bool
+bool
 check_array_designated_initializer (constructor_elt *ce,
 				    unsigned HOST_WIDE_INT index)
 {
 /* Designated initializers for array elements are not supported.  */
 if (ce->index)
 tree ce_index = build_expr_type_conversion (WANT_INT | WANT_ENUM,
 						  ce->index, true);
 if (ce_index
 	  && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (ce_index))
-	  && (TREE_CODE (ce_index = maybe_constant_value (ce_index))
+	  && (TREE_CODE (ce_index = fold_non_dependent_expr (ce_index))
 	      == INTEGER_CST))
 	{
 	  /* A C99 designator is OK if it matches the current index.  */
 	  if (wi::to_wide (ce_index) == index)
-	    return true;
+	    {
+	      ce->index = ce_index;
+	      return true;
+	    }
 	  else
 	    sorry ("non-trivial designated initializers not supported");
 	}
 else
 	error ("C99 designator %qE is not an integral constant-expression",
 	{
 	  vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (initializer);
 	  constructor_elt *ce;
 	  HOST_WIDE_INT i;
 	  FOR_EACH_VEC_SAFE_ELT (v, i, ce)
-	    if (!check_array_designated_initializer (ce, i))
+	    {
-	      failure = 1;
+	      if (instantiation_dependent_expression_p (ce->index))
-	}
+		return;
+	      if (!check_array_designated_initializer (ce, i))
-if (!failure)
+		failure = 1;
+	    }
+	}
+if (failure)
+	TREE_TYPE (decl) = error_mark_node;
+else
 	{
 	  failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
 					    do_default);
 	  if (failure == 1)
 	    {
-	      error_at (EXPR_LOC_OR_LOC (initializer,
+	      error_at (cp_expr_loc_or_loc (initializer,
 					 DECL_SOURCE_LOCATION (decl)),
 			"initializer fails to determine size of %qD", decl);
 	    }
 	  else if (failure == 2)
 	    {
 instance of the variable at link-time.  */
 void
 maybe_commonize_var (tree decl)
 {
+/* Don't mess with __FUNCTION__ and similar.  */
+if (DECL_ARTIFICIAL (decl))
+return;
 /* Static data in a function with comdat linkage also has comdat
 linkage.  */
 if ((TREE_STATIC (decl)
-/* Don't mess with __FUNCTION__.  */
-&& ! DECL_ARTIFICIAL (decl)
 && DECL_FUNCTION_SCOPE_P (decl)
 && vague_linkage_p (DECL_CONTEXT (decl)))
 || (TREE_PUBLIC (decl) && DECL_INLINE_VAR_P (decl)))
 {
 if (flag_weak)
 	    }
 	}
 }
 }
-/* Issue an error message if DECL is an uninitialized const variable.  */
+/* Issue an error message if DECL is an uninitialized const variable.
+CONSTEXPR_CONTEXT_P is true when the function is called in a constexpr
-static void
+context from potential_constant_expression.  Returns true if all is well,
-check_for_uninitialized_const_var (tree decl)
+false otherwise.  */
+bool
+check_for_uninitialized_const_var (tree decl, bool constexpr_context_p,
+				   tsubst_flags_t complain)
 {
 tree type = strip_array_types (TREE_TYPE (decl));
 /* ``Unless explicitly declared extern, a const object does not have
 external linkage and must be initialized. ($8.4; $12.1)'' ARM
 7.1.6 */
 if (VAR_P (decl)
-&& TREE_CODE (type) != REFERENCE_TYPE
+&& !TYPE_REF_P (type)
-&& (CP_TYPE_CONST_P (type) || var_in_constexpr_fn (decl))
+&& (constexpr_context_p
-&& !DECL_INITIAL (decl))
+	  || CP_TYPE_CONST_P (type) || var_in_constexpr_fn (decl))
+&& !DECL_NONTRIVIALLY_INITIALIZED_P (decl))
 {
 tree field = default_init_uninitialized_part (type);
 if (!field)
-	return;
+	return true;
-if (CP_TYPE_CONST_P (type))
+if (!constexpr_context_p)
-	permerror (DECL_SOURCE_LOCATION (decl),
+	{
-		   "uninitialized const %qD", decl);
+	  if (CP_TYPE_CONST_P (type))
-else
+	    {
-	{
+	      if (complain & tf_error)
-	  if (!is_instantiation_of_constexpr (current_function_decl))
+		permerror (DECL_SOURCE_LOCATION (decl),
-	    error_at (DECL_SOURCE_LOCATION (decl),
+			   "uninitialized const %qD", decl);
-		      "uninitialized variable %qD in %<constexpr%> function",
+	    }
-		      decl);
+	  else
-	  cp_function_chain->invalid_constexpr = true;
+	    {
-	}
+	      if (!is_instantiation_of_constexpr (current_function_decl)
+		  && (complain & tf_error))
-if (CLASS_TYPE_P (type))
+		error_at (DECL_SOURCE_LOCATION (decl),
+			  "uninitialized variable %qD in %<constexpr%> "
+			  "function", decl);
+	      cp_function_chain->invalid_constexpr = true;
+	    }
+	}
+else if (complain & tf_error)
+	error_at (DECL_SOURCE_LOCATION (decl),
+		  "uninitialized variable %qD in %<constexpr%> context",
+		  decl);
+if (CLASS_TYPE_P (type) && (complain & tf_error))
 	{
 	  tree defaulted_ctor;
 	  inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
 		  "%q#T has no user-provided default constructor", type);
 		    "explicitly defaulted in the class body");
 	  inform (DECL_SOURCE_LOCATION (field),
 		  "and the implicitly-defined constructor does not "
 		  "initialize %q#D", field);
 	}
-}
+return false;
+}
+return true;
 }
 /* Structure holding the current initializer being processed by reshape_init.
 CUR is a pointer to the current element being processed, END is a pointer
 after the last element present in the initializer.  */
 tree
 next_initializable_field (tree field)
 {
 while (field
 	 && (TREE_CODE (field) != FIELD_DECL
-	     || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
+	     || DECL_UNNAMED_BIT_FIELD (field)
 	     || (DECL_ARTIFICIAL (field)
 		 && !(cxx_dialect >= cxx17 && DECL_FIELD_IS_BASE (field)))))
 field = DECL_CHAIN (field);
 return field;
 	{
 	  if (d->cur->index == error_mark_node)
 	    return error_mark_node;
 	  if (TREE_CODE (d->cur->index) == FIELD_DECL)
-	    /* We already reshaped this.  */
+	    {
-	    gcc_assert (d->cur->index == field);
+	      /* We already reshaped this.  */
+	      if (field != d->cur->index)
+		{
+		  tree id = DECL_NAME (d->cur->index);
+		  gcc_assert (id);
+		  gcc_checking_assert (d->cur->index
+				       == get_class_binding (type, id, false));
+		  field = d->cur->index;
+		}
+	    }
 	  else if (TREE_CODE (d->cur->index) == IDENTIFIER_NODE)
 	    field = get_class_binding (type, d->cur->index, false);
 	  else
 	    {
 	      if (complain & tf_error)
 tree elt = CONSTRUCTOR_ELT (init, 0)->value;
 type = cv_unqualified (type);
 if (check_narrowing (ENUM_UNDERLYING_TYPE (type), elt, complain))
 	{
 	  warning_sentinel w (warn_useless_cast);
+	  warning_sentinel w2 (warn_ignored_qualifiers);
 	  return cp_build_c_cast (type, elt, tf_warning_or_error);
 	}
 else
 	return error_mark_node;
 }
 	      maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
 	      init = build_zero_init (type, NULL_TREE, false);
 	    }
 	  else if (init_len != 1 && TREE_CODE (type) != COMPLEX_TYPE)
 	    {
-	      error_at (EXPR_LOC_OR_LOC (init, DECL_SOURCE_LOCATION (decl)),
+	      error_at (cp_expr_loc_or_loc (init, DECL_SOURCE_LOCATION (decl)),
 			"scalar object %qD requires one element in "
 			"initializer", decl);
 	      TREE_TYPE (decl) = error_mark_node;
 	      return NULL_TREE;
 	    }
 	}
 }
 if (TREE_CODE (decl) == CONST_DECL)
 {
-gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
+gcc_assert (!TYPE_REF_P (type));
 DECL_INITIAL (decl) = init;
 gcc_assert (init != NULL_TREE);
 init = NULL_TREE;
 }
 else if (!init && DECL_REALLY_EXTERN (decl))
 ;
 else if (init || type_build_ctor_call (type)
-	   || TREE_CODE (type) == REFERENCE_TYPE)
+	   || TYPE_REF_P (type))
 {
-if (TREE_CODE (type) == REFERENCE_TYPE)
+if (TYPE_REF_P (type))
 	{
 	  init = grok_reference_init (decl, type, init, flags);
 	  flags |= LOOKUP_ALREADY_DIGESTED;
 	}
 else if (!init)
-	check_for_uninitialized_const_var (decl);
+	check_for_uninitialized_const_var (decl, /*constexpr_context_p=*/false,
+					   tf_warning_or_error);
 /* 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))
 	    }
 	  else if (TYPE_NON_AGGREGATE_CLASS (type))
 	    {
 	      /* Don't reshape if the class has constructors.  */
 	      if (cxx_dialect == cxx98)
-		error_at (EXPR_LOC_OR_LOC (init, DECL_SOURCE_LOCATION (decl)),
+		error_at (cp_expr_loc_or_loc (init, DECL_SOURCE_LOCATION (decl)),
 			  "in C++98 %qD must be initialized by "
 			  "constructor, not by %<{...}%>",
 			  decl);
 	    }
 	  else if (VECTOR_TYPE_P (type) && TYPE_VECTOR_OPAQUE (type))
 	     enclosing expression.  */
 	  gcc_assert (stmts_are_full_exprs_p ());
 	  init_code = store_init_value (decl, init, cleanups, flags);
+	  if (DECL_INITIAL (decl)
+	      && TREE_CODE (DECL_INITIAL (decl)) == CONSTRUCTOR
+	      && !vec_safe_is_empty (CONSTRUCTOR_ELTS (DECL_INITIAL (decl))))
+	    {
+	      tree elt = CONSTRUCTOR_ELTS (DECL_INITIAL (decl))->last ().value;
+	      if (TREE_CODE (TREE_TYPE (elt)) == ARRAY_TYPE
+		  && TYPE_SIZE (TREE_TYPE (elt)) == NULL_TREE)
+		cp_complete_array_type (&TREE_TYPE (elt), elt, false);
+	    }
 	  if (pedantic && TREE_CODE (type) == ARRAY_TYPE
 	      && DECL_INITIAL (decl)
 	      && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
 	      && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
-	    warning_at (EXPR_LOC_OR_LOC (DECL_INITIAL (decl),
+	    warning_at (cp_expr_loc_or_loc (DECL_INITIAL (decl),
 					 DECL_SOURCE_LOCATION (decl)),
 			0, "array %qD initialized by parenthesized "
 			"string literal %qE",
 			decl, DECL_INITIAL (decl));
 	  init = NULL;
 	  && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)
 	      || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)))
 	diagnose_uninitialized_cst_or_ref_member (core_type, /*using_new=*/false,
 						  /*complain=*/true);
-check_for_uninitialized_const_var (decl);
+check_for_uninitialized_const_var (decl, /*constexpr_context_p=*/false,
+					 tf_warning_or_error);
 }
 if (init && init != error_mark_node)
 init_code = build2 (INIT_EXPR, type, decl, init);
 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = false;
 TREE_CONSTANT (decl) = false;
 }
 if (init_code
-&& (DECL_IN_AGGR_P (decl) && !DECL_VAR_DECLARED_INLINE_P (decl)))
+&& (DECL_IN_AGGR_P (decl)
+	  && DECL_INITIALIZED_IN_CLASS_P (decl)
+	  && !DECL_VAR_DECLARED_INLINE_P (decl)))
 {
 static int explained = 0;
 if (cxx_dialect < cxx11)
 	error ("initializer invalid for static member with constructor");
 	  DECL_HARD_REGISTER (decl) = 1;
 	}
 else
 	{
 	  if (TREE_CODE (decl) == FUNCTION_DECL
-	      && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
+	      && fndecl_built_in_p (decl, BUILT_IN_NORMAL))
 	    set_builtin_user_assembler_name (decl, asmspec);
 	  set_user_assembler_name (decl, asmspec);
 	}
 }
 	  /* Stick simple initializers in DECL_INITIAL so that
 	     -Wno-init-self works (c++/34772).  */
 	  gcc_assert (TREE_OPERAND (init, 0) == decl);
 	  DECL_INITIAL (decl) = rinit;
-	  if (warn_init_self && TREE_CODE (type) == REFERENCE_TYPE)
+	  if (warn_init_self && TYPE_REF_P (type))
 	    {
 	      STRIP_NOPS (rinit);
 	      if (rinit == decl)
 		warning_at (DECL_SOURCE_LOCATION (decl),
 			    OPT_Winit_self,
 gcc_assert (DECL_ARTIFICIAL (decl));
 init = build_constructor (TREE_TYPE (decl), v);
 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
 DECL_INITIAL (decl) = init;
 DECL_INITIALIZED_P (decl) = 1;
+/* Mark the decl as constexpr so that we can access its content
+at compile time.  */
+DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = true;
+DECL_DECLARED_CONSTEXPR_P (decl) = true;
 determine_visibility (decl);
 layout_var_decl (decl);
 maybe_commonize_var (decl);
 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
-}
-/* INIT is the initializer for a variable, as represented by the
-parser.  Returns true iff INIT is type-dependent.  */
-static bool
-type_dependent_init_p (tree init)
-{
-if (TREE_CODE (init) == TREE_LIST)
-/* A parenthesized initializer, e.g.: int i (3, 2); ? */
-return any_type_dependent_elements_p (init);
-else if (TREE_CODE (init) == CONSTRUCTOR)
-/* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
-{
-if (dependent_type_p (TREE_TYPE (init)))
-	return true;
-vec<constructor_elt, va_gc> *elts;
-size_t nelts;
-size_t i;
-elts = CONSTRUCTOR_ELTS (init);
-nelts = vec_safe_length (elts);
-for (i = 0; i < nelts; ++i)
-	if (type_dependent_init_p ((*elts)[i].value))
-	  return true;
-}
-else
-/* It must be a simple expression, e.g., int i = 3;  */
-return type_dependent_expression_p (init);
-return false;
 }
 /* INIT is the initializer for a variable, as represented by the
 parser.  Returns true iff INIT is value-dependent.  */
 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
 return any_value_dependent_elements_p (init);
 else if (TREE_CODE (init) == CONSTRUCTOR)
 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
 {
+if (dependent_type_p (TREE_TYPE (init)))
+	return true;
 vec<constructor_elt, va_gc> *elts;
 size_t nelts;
 size_t i;
 elts = CONSTRUCTOR_ELTS (init);
 && TYPE_BEING_DEFINED (current_class_type)
 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type)
 && (DECL_INITIAL (decl) || init))
 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
+/* Do auto deduction unless decl is a function or an uninstantiated
+template specialization.  */
 if (TREE_CODE (decl) != FUNCTION_DECL
+&& !(init == NULL_TREE
+	   && DECL_LANG_SPECIFIC (decl)
+	   && DECL_TEMPLATE_INSTANTIATION (decl)
+	   && !DECL_TEMPLATE_INSTANTIATED (decl))
 && (auto_node = type_uses_auto (type)))
 {
 tree d_init;
 if (init == NULL_TREE)
-	{
+	gcc_assert (CLASS_PLACEHOLDER_TEMPLATE (auto_node));
-	  if (DECL_LANG_SPECIFIC (decl)
-	      && DECL_TEMPLATE_INSTANTIATION (decl)
-	      && !DECL_TEMPLATE_INSTANTIATED (decl))
-	    {
-	      /* init is null because we're deferring instantiating the
-		 initializer until we need it.  Well, we need it now.  */
-	      instantiate_decl (decl, /*defer_ok*/true, /*expl*/false);
-	      return;
-	    }
-	  gcc_assert (CLASS_PLACEHOLDER_TEMPLATE (auto_node));
-	}
 d_init = init;
 if (d_init)
 	{
 	  if (TREE_CODE (d_init) == TREE_LIST
 	      && !CLASS_PLACEHOLDER_TEMPLATE (auto_node))
 	  return;
 	}
 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
 }
-if (!ensure_literal_type_for_constexpr_object (decl))
+if (ensure_literal_type_for_constexpr_object (decl) == error_mark_node)
-DECL_DECLARED_CONSTEXPR_P (decl) = 0;
+{
+DECL_DECLARED_CONSTEXPR_P (decl) = 0;
+if (VAR_P (decl) && DECL_CLASS_SCOPE_P (decl))
+	{
+	  init = NULL_TREE;
+	  DECL_EXTERNAL (decl) = 1;
+	}
+}
 if (VAR_P (decl)
 && DECL_CLASS_SCOPE_P (decl)
 && DECL_INITIALIZED_IN_CLASS_P (decl))
 check_static_variable_definition (decl, type);
 {
 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
 /* If DECL is a reference, then we want to know whether init is a
 	 reference constant; init_const_expr_p as passed tells us whether
 	 it's an rvalue constant.  */
-if (TREE_CODE (type) == REFERENCE_TYPE)
+if (TYPE_REF_P (type))
 	init_const_expr_p = potential_constant_expression (init);
 if (init_const_expr_p)
 	{
 	  /* Set these flags now for templates.  We'll update the flags in
 	     store_init_value for instantiations.  */
 	  DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
 	  if (decl_maybe_constant_var_p (decl)
 	      /* FIXME setting TREE_CONSTANT on refs breaks the back end.  */
-	      && TREE_CODE (type) != REFERENCE_TYPE)
+	      && !TYPE_REF_P (type))
 	    TREE_CONSTANT (decl) = 1;
 	}
 }
 if (processing_template_decl)
 if (check_for_bare_parameter_packs (init))
 	{
 	  init = NULL_TREE;
 	  DECL_INITIAL (decl) = NULL_TREE;
 	}
-init = do_dependent_capture (init);
 /* Generally, initializers in templates are expanded when the
 	 template is instantiated.  But, if DECL is a variable constant
 	 then it can be used in future constant expressions, so its value
 	 must be available. */
+bool dep_init = false;
 if (!VAR_P (decl) || type_dependent_p)
 	/* We can't do anything if the decl has dependent type.  */;
+else if (!init && is_concept_var (decl))
+	{
+	  error ("variable concept has no initializer");
+	  init = boolean_true_node;
+	}
 else if (init
 	       && init_const_expr_p
-	       && TREE_CODE (type) != REFERENCE_TYPE
+	       && !TYPE_REF_P (type)
 	       && decl_maybe_constant_var_p (decl)
-	       && !type_dependent_init_p (init)
+	       && !(dep_init = value_dependent_init_p (init)))
-	       && !value_dependent_init_p (init))
 	{
 	  /* 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;
 	  init_code = check_initializer (decl, init, flags, &cleanups);
 	  if (init_code == NULL_TREE)
 	    init = NULL_TREE;
 	  release_tree_vector (cleanups);
 	}
-else if (!init && is_concept_var (decl))
-error ("variable concept has no initializer");
 else if (!DECL_PRETTY_FUNCTION_P (decl))
 	{
 	  /* Deduce array size even if the initializer is dependent.  */
 	  maybe_deduce_size_from_array_init (decl, init);
 	  /* And complain about multiple initializers.  */
 						    tf_warning_or_error);
 	}
 if (init)
 	DECL_INITIAL (decl) = init;
+if (dep_init)
+	{
+	  retrofit_lang_decl (decl);
+	  SET_DECL_DEPENDENT_INIT_P (decl, true);
+	}
 return;
 }
 /* Just store non-static data member initializers for later.  */
 if (init && TREE_CODE (decl) == FIELD_DECL)
 }
 /* A reference will be modified here, as it is initialized.  */
 if (! DECL_EXTERNAL (decl)
 && TREE_READONLY (decl)
-&& TREE_CODE (type) == REFERENCE_TYPE)
+&& TYPE_REF_P (type))
 {
 was_readonly = 1;
 TREE_READONLY (decl) = 0;
 }
 }
 if (was_readonly)
 TREE_READONLY (decl) = 1;
+if (flag_openmp
+&& VAR_P (decl)
+&& lookup_attribute ("omp declare target implicit",
+			   DECL_ATTRIBUTES (decl)))
+{
+DECL_ATTRIBUTES (decl)
+	= remove_attribute ("omp declare target implicit",
+			    DECL_ATTRIBUTES (decl));
+complete_type (TREE_TYPE (decl));
+if (!cp_omp_mappable_type (TREE_TYPE (decl)))
+	error ("%q+D in declare target directive does not have mappable type",
+	       decl);
+else if (!lookup_attribute ("omp declare target",
+				  DECL_ATTRIBUTES (decl))
+	       && !lookup_attribute ("omp declare target link",
+				     DECL_ATTRIBUTES (decl)))
+	DECL_ATTRIBUTES (decl)
+	  = tree_cons (get_identifier ("omp declare target"),
+		       NULL_TREE, DECL_ATTRIBUTES (decl));
+}
 invoke_plugin_callbacks (PLUGIN_FINISH_DECL, decl);
 }
 /* For class TYPE return itself or some its bases that contain
 any direct non-static data members.  Return error_mark_node if an
 static tree
 find_decomp_class_base (location_t loc, tree type, tree ret)
 {
 bool member_seen = false;
 for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
-if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
+if (TREE_CODE (field) != FIELD_DECL
+	|| DECL_ARTIFICIAL (field)
+	|| DECL_UNNAMED_BIT_FIELD (field))
 continue;
 else if (ret)
 return type;
 else if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
 {
 	  error_at (loc, "cannot decompose class type %qT because it has an "
 			 "anonymous union member", type);
 	inform (DECL_SOURCE_LOCATION (field), "declared here");
 	return error_mark_node;
 }
-else if (TREE_PRIVATE (field) || TREE_PROTECTED (field))
+else if (!accessible_p (type, field, true))
 {
-	error_at (loc, "cannot decompose non-public member %qD of %qT",
+	error_at (loc, "cannot decompose inaccessible member %qD of %qT",
 		  field, type);
 	inform (DECL_SOURCE_LOCATION (field),
 		TREE_PRIVATE (field)
 		? G_("declared private here")
 		: G_("declared protected here"));
 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 {
 tree t = find_decomp_class_base (loc, TREE_TYPE (base_binfo), ret);
 if (t == error_mark_node)
 	return error_mark_node;
-if (t != NULL_TREE)
+if (t != NULL_TREE && t != ret)
 	{
 	  if (ret == type)
 	    {
 	      error_at (loc, "cannot decompose class type %qT: both it and "
 			     "its base class %qT have non-static data members",
 			type, t);
 	      return error_mark_node;
 	    }
 	  else if (orig_ret != NULL_TREE)
 	    return t;
-	  else if (ret == t)
-	    /* OK, found the same base along another path.  We'll complain
-	       in convert_to_base if it's ambiguous.  */;
 	  else if (ret != NULL_TREE)
 	    {
 	      error_at (loc, "cannot decompose class type %qT: its base "
 			     "classes %qT and %qT have non-static data "
 			     "members", type, ret, t);
 static tree
 get_tuple_size (tree type)
 {
 tree args = make_tree_vec (1);
 TREE_VEC_ELT (args, 0) = type;
-tree inst = lookup_template_class (get_identifier ("tuple_size"), args,
+tree inst = lookup_template_class (tuple_size_identifier, args,
 				     /*in_decl*/NULL_TREE,
 				     /*context*/std_node,
 				     /*entering_scope*/false, tf_none);
 inst = complete_type (inst);
 if (inst == error_mark_node || !COMPLETE_TYPE_P (inst))
 return NULL_TREE;
-tree val = lookup_qualified_name (inst, get_identifier ("value"),
+tree val = lookup_qualified_name (inst, value_identifier,
 				    /*type*/false, /*complain*/false);
 if (TREE_CODE (val) == VAR_DECL || TREE_CODE (val) == CONST_DECL)
 val = maybe_constant_value (val);
 if (TREE_CODE (val) == INTEGER_CST)
 return val;
 get_tuple_element_type (tree type, unsigned i)
 {
 tree args = make_tree_vec (2);
 TREE_VEC_ELT (args, 0) = build_int_cst (integer_type_node, i);
 TREE_VEC_ELT (args, 1) = type;
-tree inst = lookup_template_class (get_identifier ("tuple_element"), args,
+tree inst = lookup_template_class (tuple_element_identifier, args,
 				     /*in_decl*/NULL_TREE,
 				     /*context*/std_node,
 				     /*entering_scope*/false,
 				     tf_warning_or_error);
-return make_typename_type (inst, get_identifier ("type"),
+return make_typename_type (inst, type_identifier,
 			     none_type, tf_warning_or_error);
 }
 /* Return e.get<i>() or get<i>(e).  */
 static tree
 get_tuple_decomp_init (tree decl, unsigned i)
 {
-tree get_id = get_identifier ("get");
 tree targs = make_tree_vec (1);
 TREE_VEC_ELT (targs, 0) = build_int_cst (integer_type_node, i);
 tree etype = TREE_TYPE (decl);
 tree e = convert_from_reference (decl);
 /* [The id-expression] e is an lvalue if the type of the entity e is an
 lvalue reference and an xvalue otherwise.  */
-if (TREE_CODE (etype) != REFERENCE_TYPE
+if (!TYPE_REF_P (etype)
 || TYPE_REF_IS_RVALUE (etype))
 e = move (e);
-tree fns = lookup_qualified_name (TREE_TYPE (e), get_id,
+tree fns = lookup_qualified_name (TREE_TYPE (e), get__identifier,
 				    /*type*/false, /*complain*/false);
-if (fns != error_mark_node)
+bool use_member_get = false;
+/* To use a member get, member lookup must find at least one
+declaration that is a function template
+whose first template parameter is a non-type parameter.  */
+for (lkp_iterator iter (MAYBE_BASELINK_FUNCTIONS (fns)); iter; ++iter)
+{
+tree fn = *iter;
+if (TREE_CODE (fn) == TEMPLATE_DECL)
+	{
+	  tree tparms = DECL_TEMPLATE_PARMS (fn);
+	  tree parm = TREE_VEC_ELT (INNERMOST_TEMPLATE_PARMS (tparms), 0);
+	  if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL)
+	    {
+	      use_member_get = true;
+	      break;
+	    }
+	}
+}
+if (use_member_get)
 {
 fns = lookup_template_function (fns, targs);
 return build_new_method_call (e, fns, /*args*/NULL,
 				    /*path*/NULL_TREE, LOOKUP_NORMAL,
 				    /*fn_p*/NULL, tf_warning_or_error);
 }
 else
 {
 vec<tree,va_gc> *args = make_tree_vector_single (e);
-fns = lookup_template_function (get_id, targs);
+fns = lookup_template_function (get__identifier, targs);
 fns = perform_koenig_lookup (fns, args, tf_warning_or_error);
 return finish_call_expr (fns, &args, /*novirt*/false,
 			       /*koenig*/true, tf_warning_or_error);
 }
 }
 /* It's impossible to recover the decltype of a tuple decomposition variable
 based on the actual type of the variable, so store it in a hash table.  */
-static GTY(()) hash_map<tree,tree> *decomp_type_table;
+static GTY((cache)) tree_cache_map *decomp_type_table;
 static void
 store_decomp_type (tree v, tree t)
 {
 if (!decomp_type_table)
-decomp_type_table = hash_map<tree,tree>::create_ggc (13);
+decomp_type_table = tree_cache_map::create_ggc (13);
 decomp_type_table->put (v, t);
 }
 tree
 lookup_decomp_type (tree v)
 {
 return *decomp_type_table->get (v);
+}
+/* Mangle a decomposition declaration if needed.  Arguments like
+in cp_finish_decomp.  */
+void
+cp_maybe_mangle_decomp (tree decl, tree first, unsigned int count)
+{
+if (!processing_template_decl
+&& !error_operand_p (decl)
+&& DECL_NAMESPACE_SCOPE_P (decl))
+{
+auto_vec<tree, 16> v;
+v.safe_grow (count);
+tree d = first;
+for (unsigned int i = 0; i < count; i++, d = DECL_CHAIN (d))
+	v[count - i - 1] = d;
+SET_DECL_ASSEMBLER_NAME (decl, mangle_decomp (decl, v));
+maybe_apply_pragma_weak (decl);
+}
 }
 /* Finish a decomposition declaration.  DECL is the underlying declaration
 "e", FIRST is the head of a chain of decls for the individual identifiers
 chained through DECL_CHAIN in reverse order and COUNT is the number of
 }
 tree type = TREE_TYPE (decl);
 tree dexp = decl;
-if (TREE_CODE (type) == REFERENCE_TYPE)
+if (TYPE_REF_P (type))
 {
 dexp = convert_from_reference (dexp);
-type = TREE_TYPE (type);
+type = complete_type (TREE_TYPE (type));
+if (type == error_mark_node)
+	goto error_out;
+if (!COMPLETE_TYPE_P (type))
+	{
+	  error_at (loc, "structured binding refers to incomplete type %qT",
+		    type);
+	  goto error_out;
+	}
 }
 tree eltype = NULL_TREE;
 unsigned HOST_WIDE_INT eltscnt = 0;
 if (TREE_CODE (type) == ARRAY_TYPE)
 eltscnt = tree_to_uhwi (nelts);
 if (count != eltscnt)
 	{
 cnt_mismatch:
 	  if (count > eltscnt)
-	    error_at (loc, "%u names provided while %qT decomposes into "
+	    error_n (loc, count,
-			   "%wu elements", count, type, eltscnt);
+		     "%u name provided for structured binding",
+		     "%u names provided for structured binding", count);
 	  else
-	    error_at (loc, "only %u names provided while %qT decomposes into "
+	    error_n (loc, count,
-			   "%wu elements", count, type, eltscnt);
+		     "only %u name provided for structured binding",
+		     "only %u names provided for structured binding", count);
+	  inform_n (loc, eltscnt,
+		    "while %qT decomposes into %wu element",
+		    "while %qT decomposes into %wu elements",
+		    type, eltscnt);
 	  goto error_out;
 	}
 eltype = TREE_TYPE (type);
 for (unsigned int i = 0; i < count; i++)
 	{
 	  DECL_HAS_VALUE_EXPR_P (v[i]) = 1;
 	}
 }
 else if (TREE_CODE (type) == VECTOR_TYPE)
 {
-eltscnt = TYPE_VECTOR_SUBPARTS (type);
+if (!TYPE_VECTOR_SUBPARTS (type).is_constant (&eltscnt))
+	{
+	  error_at (loc, "cannot decompose variable length vector %qT", type);
+	  goto error_out;
+	}
 if (count != eltscnt)
 	goto cnt_mismatch;
 eltype = cp_build_qualified_type (TREE_TYPE (type), TYPE_QUALS (type));
 for (unsigned int i = 0; i < count; i++)
 	{
 {
 if (tsize == error_mark_node)
 	{
 	  error_at (loc, "%<std::tuple_size<%T>::value%> is not an integral "
 			 "constant expression", type);
+	  goto error_out;
+	}
+if (!tree_fits_uhwi_p (tsize))
+	{
+	  error_n (loc, count,
+		   "%u name provided for structured binding",
+		   "%u names provided for structured binding", count);
+	  inform (loc, "while %qT decomposes into %E elements",
+		  type, tsize);
 	  goto error_out;
 	}
 eltscnt = tree_to_uhwi (tsize);
 if (count != eltscnt)
 	goto cnt_mismatch;
 else if (LAMBDA_TYPE_P (type))
 {
 error_at (loc, "cannot decompose lambda closure type %qT", type);
 goto error_out;
 }
+else if (processing_template_decl && !COMPLETE_TYPE_P (type))
+pedwarn (loc, 0, "structured binding refers to incomplete class type %qT",
+	     type);
 else
 {
 tree btype = find_decomp_class_base (loc, type, NULL_TREE);
 if (btype == error_mark_node)
 	goto error_out;
 	  error_at (loc, "cannot decompose class type %qT without non-static "
 			 "data members", type);
 	  goto error_out;
 	}
 for (tree field = TYPE_FIELDS (btype); field; field = TREE_CHAIN (field))
-	if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
+	if (TREE_CODE (field) != FIELD_DECL
+	    || DECL_ARTIFICIAL (field)
+	    || DECL_UNNAMED_BIT_FIELD (field))
 	  continue;
 	else
 	  eltscnt++;
 if (count != eltscnt)
 	goto cnt_mismatch;
 			       /*nonnull*/false, tf_warning_or_error);
 	  type = btype;
 	}
 unsigned int i = 0;
 for (tree field = TYPE_FIELDS (btype); field; field = TREE_CHAIN (field))
-	if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
+	if (TREE_CODE (field) != FIELD_DECL
+	    || DECL_ARTIFICIAL (field)
+	    || DECL_UNNAMED_BIT_FIELD (field))
 	  continue;
 	else
 	  {
 	    tree tt = finish_non_static_data_member (field, unshare_expr (t),
 						     NULL_TREE);
 			       NULL_TREE, NULL_TREE);
 	    SET_DECL_VALUE_EXPR (v[i], a);
 	    DECL_HAS_VALUE_EXPR_P (v[i]) = 1;
 	  }
 }
-else if (DECL_NAMESPACE_SCOPE_P (decl))
-SET_DECL_ASSEMBLER_NAME (decl, mangle_decomp (decl, v));
 }
 /* Returns a declaration for a VAR_DECL as if:
 extern "C" TYPE NAME;
 means that we didn't have these two bits set in the original type
 either.  In completing the type, we are expected to propagate these
 bits.  See also complete_type which does the same thing for arrays
 of fixed size.  */
 type = *ptype;
-if (TYPE_DOMAIN (type))
+if (type != error_mark_node && TYPE_DOMAIN (type))
 {
 elt_type = TREE_TYPE (type);
 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
 	= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
 		enum bad_spec_place type,
 		int virtualp,
 		int quals,
 		int inlinep,
 		int friendp,
-		int raises)
+		int raises,
+		const location_t* locations)
 {
 switch (type)
 {
 case BSP_VAR:
 	if (virtualp)
-	  error ("%qD declared as a %<virtual%> variable", object);
+	  error_at (locations[ds_virtual],
+		    "%qD declared as a %<virtual%> variable", object);
 	if (quals)
 	  error ("%<const%> and %<volatile%> function specifiers on "
 	         "%qD invalid in variable declaration", object);
 	break;
 case BSP_PARM:
 	if (virtualp)
-	  error ("%qD declared as a %<virtual%> parameter", object);
+	  error_at (locations[ds_virtual],
+		    "%qD declared as a %<virtual%> parameter", object);
 	if (inlinep)
-	  error ("%qD declared as an %<inline%> parameter", object);
+	  error_at (locations[ds_inline],
+		    "%qD declared as an %<inline%> parameter", object);
 	if (quals)
 	  error ("%<const%> and %<volatile%> function specifiers on "
 	  	 "%qD invalid in parameter declaration", object);
 	break;
 case BSP_TYPE:
 	if (virtualp)
-	  error ("%qD declared as a %<virtual%> type", object);
+	  error_at (locations[ds_virtual],
+		    "%qD declared as a %<virtual%> type", object);
 	if (inlinep)
-	  error ("%qD declared as an %<inline%> type", object);
+	  error_at (locations[ds_inline],
+		    "%qD declared as an %<inline%> type", object);
 	if (quals)
 	  error ("%<const%> and %<volatile%> function specifiers on "
 	  	 "%qD invalid in type declaration", object);
 	break;
 case BSP_FIELD:
 	if (virtualp)
-	  error ("%qD declared as a %<virtual%> field", object);
+	  error_at (locations[ds_virtual],
+		    "%qD declared as a %<virtual%> field", object);
 	if (inlinep)
-	  error ("%qD declared as an %<inline%> field", object);
+	  error_at (locations[ds_inline],
+		    "%qD declared as an %<inline%> field", object);
 	if (quals)
 	  error ("%<const%> and %<volatile%> function specifiers on "
 	  	 "%qD invalid in field declaration", object);
 	break;
 default:
 static void
 check_concept_fn (tree fn)
 {
 // A constraint is nullary.
 if (DECL_ARGUMENTS (fn))
-error ("concept %q#D declared with function parameters", fn);
+error_at (DECL_SOURCE_LOCATION (fn),
+	      "concept %q#D declared with function parameters", fn);
 // The declared return type of the concept shall be bool, and
 // it shall not be deduced from it definition.
 tree type = TREE_TYPE (TREE_TYPE (fn));
 if (is_auto (type))
-error ("concept %q#D declared with a deduced return type", fn);
+error_at (DECL_SOURCE_LOCATION (fn),
+	      "concept %q#D declared with a deduced return type", fn);
 else if (type != boolean_type_node)
-error ("concept %q#D with non-%<bool%> return type %qT", fn, type);
+error_at (DECL_SOURCE_LOCATION (fn),
+	      "concept %q#D with non-%<bool%> return type %qT", fn, type);
 }
 /* Helper function.  Replace the temporary this parameter injected
 during cp_finish_omp_declare_simd with the real this parameter.  */
 grokfndecl (tree ctype,
 	    tree type,
 	    tree declarator,
 	    tree parms,
 	    tree orig_declarator,
+	    const cp_decl_specifier_seq *declspecs,
 	    tree decl_reqs,
 	    int virtualp,
 	    enum overload_flags flags,
 	    cp_cv_quals quals,
 	    cp_ref_qualifier rqual,
 	    int publicp,
 	    int inlinep,
 	    bool deletedp,
 	    special_function_kind sfk,
 	    bool funcdef_flag,
+	    bool late_return_type_p,
 	    int template_count,
 	    tree in_namespace,
 	    tree* attrlist,
 	    location_t location)
 {
 tree decl;
 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
 tree t;
+if (location == UNKNOWN_LOCATION)
+location = input_location;
 // Was the concept specifier present?
 bool concept_p = inlinep & 4;
 // Concept declarations must have a corresponding definition.
 if (concept_p && !funcdef_flag)
 {
-error ("concept %qD has no definition", declarator);
+error_at (location, "concept %qD has no definition", declarator);
 return NULL_TREE;
 }
-if (rqual)
+type = build_cp_fntype_variant (type, rqual, raises, late_return_type_p);
-type = build_ref_qualified_type (type, rqual);
-if (raises)
+decl = build_lang_decl_loc (location, FUNCTION_DECL, declarator, type);
-type = build_exception_variant (type, raises);
-decl = build_lang_decl (FUNCTION_DECL, declarator, type);
 /* Set the constraints on the declaration. */
 if (flag_concepts)
 {
 tree tmpl_reqs = NULL_TREE;
 decl_reqs = normalize_expression (decl_reqs);
 tree ci = build_constraints (tmpl_reqs, decl_reqs);
 set_constraints (decl, ci);
 }
-/* If we have an explicit location, use it, otherwise use whatever
-build_lang_decl used (probably input_location).  */
-if (location != UNKNOWN_LOCATION)
-DECL_SOURCE_LOCATION (decl) = location;
 if (TREE_CODE (type) == METHOD_TYPE)
 {
 tree parm = build_this_parm (decl, type, quals);
 DECL_CHAIN (parm) = parms;
 }
 if (friendp && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
 {
 if (funcdef_flag)
-	error ("defining explicit specialization %qD in friend declaration",
+	error_at (location,
-	       orig_declarator);
+		  "defining explicit specialization %qD in friend declaration",
+		  orig_declarator);
 else
 	{
 	  tree fns = TREE_OPERAND (orig_declarator, 0);
 	  tree args = TREE_OPERAND (orig_declarator, 1);
 	  if (PROCESSING_REAL_TEMPLATE_DECL_P ())
 	    {
 	      /* Something like `template <class T> friend void f<T>()'.  */
-	      error ("invalid use of template-id %qD in declaration "
+	      error_at (location,
-		     "of primary template",
+			"invalid use of template-id %qD in declaration "
-		     orig_declarator);
+			"of primary template",
+			orig_declarator);
 	      return NULL_TREE;
 	    }
 	  /* A friend declaration of the form friend void f<>().  Record
 	  for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
 	    if (TREE_PURPOSE (t)
 		&& TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
 	    {
-	      error ("default arguments are not allowed in declaration "
+	      error_at (defarg_location (TREE_PURPOSE (t)),
-		     "of friend template specialization %qD",
+			"default arguments are not allowed in declaration "
-		     decl);
+			"of friend template specialization %qD",
+			decl);
 	      return NULL_TREE;
 	    }
 	  if (inlinep & 1)
 	    {
-	      error ("%<inline%> is not allowed in declaration of friend "
+	      error_at (declspecs->locations[ds_inline],
-		     "template specialization %qD",
+			"%<inline%> is not allowed in declaration of friend "
-		     decl);
+			"template specialization %qD",
+			decl);
 	      return NULL_TREE;
 	    }
 	}
+}
+/* C++17 11.3.6/4: "If a friend declaration specifies a default argument
+expression, that declaration shall be a definition..."  */
+if (friendp && !funcdef_flag)
+{
+for (tree t = FUNCTION_FIRST_USER_PARMTYPE (decl);
+	   t && t != void_list_node; t = TREE_CHAIN (t))
+	if (TREE_PURPOSE (t))
+	  {
+	    permerror (DECL_SOURCE_LOCATION (decl),
+		       "friend declaration of %qD specifies default "
+		       "arguments and isn't a definition", decl);
+	    break;
+	  }
 }
 /* If this decl has namespace scope, set that up.  */
 if (in_namespace)
 set_decl_namespace (decl, in_namespace, friendp);
 }
 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
 {
 if (PROCESSING_REAL_TEMPLATE_DECL_P())
-	error ("cannot declare %<::main%> to be a template");
+	error_at (location, "cannot declare %<::main%> to be a template");
 if (inlinep & 1)
-	error ("cannot declare %<::main%> to be inline");
+	error_at (declspecs->locations[ds_inline],
+		  "cannot declare %<::main%> to be inline");
 if (inlinep & 2)
-	error ("cannot declare %<::main%> to be constexpr");
+	error_at (declspecs->locations[ds_constexpr],
+		  "cannot declare %<::main%> to be %<constexpr%>");
 if (!publicp)
-	error ("cannot declare %<::main%> to be static");
+	error_at (location, "cannot declare %<::main%> to be static");
 inlinep = 0;
 publicp = 1;
 }
 /* Members of anonymous types and local classes have no linkage; make
 if (funcdef_flag)
 	error_at (location,
 		  "deduction guide %qD must not have a function body", decl);
 }
 else if (IDENTIFIER_ANY_OP_P (DECL_NAME (decl))
-&& !grok_op_properties (decl, /*complain=*/true))
+	   && !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");
+	  error_at (location, "literal operator with C linkage");
 	  maybe_show_extern_c_location ();
 	  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);
+	      error_at (location, "%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 (parse_in, suffix, strlen (suffix)))
-		warning (0, "integer suffix %qs"
+		warning_at (location, 0, "integer suffix %qs"
 			    " shadowed by implementation", suffix);
 	    }
 	  else if (long_double_p)
 	    {
 	      if (cpp_interpret_float_suffix (parse_in, suffix, strlen (suffix)))
-		warning (0, "floating point suffix %qs"
+		warning_at (location, 0, "floating point suffix %qs"
 			    " shadowed by implementation", suffix);
 	    }
+	  /* 17.6.3.3.5  */
+	  if (suffix[0] != '_'
+	      && !in_system_header_at (location)
+	      && !current_function_decl && !(friendp && !funcdef_flag))
+	    warning_at (location, OPT_Wliteral_suffix,
+			"literal operator suffixes not preceded by %<_%>"
+			" are reserved for future standardization");
 	}
 else
 	{
-	  error ("%qD must be a non-member function", decl);
+	  error_at (location, "%qD must be a non-member function", decl);
 	  return NULL_TREE;
 	}
 }
 if (funcdef_flag)
 DECL_INITIAL (decl) = error_mark_node;
 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
 TREE_NOTHROW (decl) = 1;
-if (flag_openmp || flag_openmp_simd || flag_cilkplus)
+if (flag_openmp || flag_openmp_simd)
 {
 /* Adjust "omp declare simd" attributes.  */
 tree ods = lookup_attribute ("omp declare simd", *attrlist);
 if (ods)
 	{
 decl = check_explicit_specialization (orig_declarator, decl,
 					template_count,
 					2 * funcdef_flag +
 					4 * (friendp != 0) +
-8 * concept_p);
+	                                8 * concept_p,
+					*attrlist);
 if (decl == error_mark_node)
 return NULL_TREE;
 if (DECL_STATIC_FUNCTION_P (decl))
 check_static_quals (decl, quals);
 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
 			integer_type_node))
 	{
 	  tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
 	  tree newtype;
-	  error ("%<::main%> must return %<int%>");
+	  error_at (declspecs->locations[ds_type_spec],
+		    "%<::main%> must return %<int%>");
 	  newtype = build_function_type (integer_type_node, oldtypeargs);
 	  TREE_TYPE (decl) = newtype;
 	}
 if (warn_main)
 	check_main_parameter_types (decl);
 Note that this also forbids explicit specializations.  */
 if (conceptp)
 {
 if (!processing_template_decl)
 {
-error ("a non-template variable cannot be %<concept%>");
+error_at (declspecs->locations[ds_concept],
+		    "a non-template variable cannot be %<concept%>");
 return NULL_TREE;
 }
 else
 DECL_DECLARED_CONCEPT_P (decl) = true;
 if (!same_type_ignoring_top_level_qualifiers_p (type, boolean_type_node))
 }
 }
 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
 Check to see that the definition is valid.  Issue appropriate error
-messages.  Return 1 if the definition is particularly bad, or 0
+messages.  */
-otherwise.  */
+static void
-static int
 check_static_variable_definition (tree decl, tree type)
 {
 /* Avoid redundant diagnostics on out-of-class definitions.  */
 if (!current_class_type || !TYPE_BEING_DEFINED (current_class_type))
-return 0;
+;
 /* Can't check yet if we don't know the type.  */
-if (dependent_type_p (type))
+else if (dependent_type_p (type))
-return 0;
+;
 /* If DECL is declared constexpr, we'll do the appropriate checks
 in check_initializer.  Similarly for inline static data members.  */
-if (DECL_P (decl)
+else if (DECL_P (decl)
 && (DECL_DECLARED_CONSTEXPR_P (decl)
+	  || undeduced_auto_decl (decl)
 	  || DECL_VAR_DECLARED_INLINE_P (decl)))
-return 0;
+;
 else if (cxx_dialect >= cxx11 && !INTEGRAL_OR_ENUMERATION_TYPE_P (type))
 {
 if (!COMPLETE_TYPE_P (type))
 	error_at (DECL_SOURCE_LOCATION (decl),
 		  "in-class initialization of static data member %q#D of "
 		   "static data member %q#D of non-integral type", decl);
 else
 	error_at (DECL_SOURCE_LOCATION (decl),
 		  "in-class initialization of static data member %q#D of "
 		  "non-literal type", decl);
-return 1;
+}
-}
 /* Motion 10 at San Diego: If a static const integral data member is
 initialized with an integral constant expression, the initializer
 may appear either in the declaration (within the class), or in
 the definition, but not both.  If it appears in the class, the
 member is a member constant.  The file-scope definition is always
 required.  */
-if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
+else if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
-{
+error_at (DECL_SOURCE_LOCATION (decl),
-error_at (DECL_SOURCE_LOCATION (decl),
+	      "invalid in-class initialization of static data member "
-		"invalid in-class initialization of static data member "
+	      "of non-integral type %qT",
-		"of non-integral type %qT",
+	      type);
-		type);
-return 1;
-}
 else if (!CP_TYPE_CONST_P (type))
 error_at (DECL_SOURCE_LOCATION (decl),
 	      "ISO C++ forbids in-class initialization of non-const "
 	      "static member %qD",
 	      decl);
 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type))
 pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wpedantic,
 	     "ISO C++ forbids initialization of member constant "
 	     "%qD of non-integral type %qT", decl, type);
-return 0;
 }
 /* *expr_p is part of the TYPE_SIZE of a variably-sized array.  If any
 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
 expressions out into temporary variables so that walk_tree doesn't
 fold_sizeof_expr (tree t)
 {
 tree r;
 if (SIZEOF_EXPR_TYPE_P (t))
 r = cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t, 0)),
-				    SIZEOF_EXPR, false);
+				    SIZEOF_EXPR, false, false);
 else if (TYPE_P (TREE_OPERAND (t, 0)))
 r = cxx_sizeof_or_alignof_type (TREE_OPERAND (t, 0), SIZEOF_EXPR,
-				    false);
+				    false, false);
 else
 r = cxx_sizeof_or_alignof_expr (TREE_OPERAND (t, 0), SIZEOF_EXPR,
 				    false);
 if (r == error_mark_node)
 r = size_one_node;
 if (error_operand_p (size))
 return error_mark_node;
 if (!type_dependent_expression_p (size))
 {
-tree type = TREE_TYPE (size);
+osize = size = mark_rvalue_use (size);
-size = mark_rvalue_use (size);
 if (cxx_dialect < cxx11 && TREE_CODE (size) == NOP_EXPR
 	  && TREE_SIDE_EFFECTS (size))
 	/* In C++98, we mark a non-constant array bound with a magic
 	   NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case.  */;
 else
 	{
 	  size = instantiate_non_dependent_expr_sfinae (size, complain);
+	  size = build_converted_constant_expr (size_type_node, size, complain);
-	  if (CLASS_TYPE_P (type)
+	  size = maybe_constant_value (size);
-	      && CLASSTYPE_LITERAL_P (type))
-	    {
-	      size = build_expr_type_conversion (WANT_INT, size, true);
-	      if (!size)
-		{
-		  if (!(complain & tf_error))
-		    return error_mark_node;
-		  if (name)
-		    error ("size of array %qD has non-integral type %qT",
-			   name, type);
-		  else
-		    error ("size of array has non-integral type %qT", type);
-		  size = integer_one_node;
-		}
-	      if (size == error_mark_node)
-		return error_mark_node;
-	      type = TREE_TYPE (size);
-	    }
-	  if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
-	    size = maybe_constant_value (size);
 	  if (!TREE_CONSTANT (size))
 	    size = osize;
 	}
 if (error_operand_p (size))
 	return error_mark_node;
 /* The array bound must be an integer type.  */
+tree type = TREE_TYPE (size);
 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
 	{
 	  if (!(complain & tf_error))
 	    return error_mark_node;
 	  if (name)
 	    error ("size of array %qD has non-integral type %qT", name, type);
 	  else
 	    error ("size of array has non-integral type %qT", type);
 	  size = integer_one_node;
-	  type = TREE_TYPE (size);
 	}
 }
 /* A type is dependent if it is...an array type constructed from any
 dependent type or whose size is specified by a constant expression
 if (TREE_CODE (size) != INTEGER_CST)
 {
 tree folded = cp_fully_fold (size);
 if (TREE_CODE (folded) == INTEGER_CST)
-	pedwarn (location_of (size), OPT_Wpedantic,
+	pedwarn (input_location, OPT_Wpedantic,
 		 "size of array is not an integral constant-expression");
 /* Use the folded result for VLAs, too; it will have resolved
 	 SIZEOF_EXPR.  */
 size = folded;
 }
 /* Normally, the array-bound will be a constant.  */
 if (TREE_CODE (size) == INTEGER_CST)
 {
-/* Check to see if the array bound overflowed.  Make that an
-	 error, no matter how generous we're being.  */
-constant_expression_error (size);
 /* An array must have a positive number of elements.  */
-if (tree_int_cst_lt (size, integer_zero_node))
+if (!valid_constant_size_p (size))
 	{
 	  if (!(complain & tf_error))
 	    return error_mark_node;
 	  if (name)
 	    error ("size of array %qD is negative", name);
 	  else
 	    error ("size of array is negative");
 	  size = integer_one_node;
 if (processing_template_decl && !TREE_CONSTANT (size))
 /* A variable sized array.  */
 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
 else
 {
-HOST_WIDE_INT saved_processing_template_decl;
 /* Compute the index of the largest element in the array.  It is
 	 one less than the number of elements in the array.  We save
 	 and restore PROCESSING_TEMPLATE_DECL so that computations in
 	 cp_build_binary_op will be appropriately folded.  */
-saved_processing_template_decl = processing_template_decl;
+{
-processing_template_decl = 0;
+	processing_template_decl_sentinel s;
-itype = cp_build_binary_op (input_location,
+	itype = cp_build_binary_op (input_location,
-				  MINUS_EXPR,
+				    MINUS_EXPR,
-				  cp_convert (ssizetype, size, complain),
+				    cp_convert (ssizetype, size, complain),
-				  cp_convert (ssizetype, integer_one_node,
+				    cp_convert (ssizetype, integer_one_node,
-					      complain),
+						complain),
-				  complain);
+				    complain);
-itype = maybe_constant_value (itype);
+	itype = maybe_constant_value (itype);
-processing_template_decl = saved_processing_template_decl;
+}
 if (!TREE_CONSTANT (itype))
 	{
 	  /* A variable sized array.  */
 	  itype = variable_size (itype);
 /* 8.3.4/1: If the type of the identifier of D contains the auto
 type-specifier, the program is ill-formed.  */
 if (type_uses_auto (type))
 {
-error ("%qD declared as array of %qT", name, type);
+if (name)
+error ("%qD declared as array of %qT", name, type);
+else
+error ("creating array of %qT", type);
 return error_mark_node;
 }
 /* If there are some types which cannot be array elements,
 issue an error-message and return.  */
 abstract_virtuals_error (name, type);
 return build_cplus_array_type (type, itype);
 }
+/* Returns the smallest location that is not UNKNOWN_LOCATION.  */
+static location_t
+min_location (location_t loca, location_t locb)
+{
+if (loca == UNKNOWN_LOCATION
+|| (locb != UNKNOWN_LOCATION
+	  && linemap_location_before_p (line_table, locb, loca)))
+return locb;
+return loca;
+}
 /* Returns the smallest location != UNKNOWN_LOCATION among the
 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
 and LOCATIONS[ds_restrict].  */
 static location_t
 location_t loc = UNKNOWN_LOCATION;
 if (type_quals & TYPE_QUAL_CONST)
 loc = locations[ds_const];
-if ((type_quals & TYPE_QUAL_VOLATILE)
+if (type_quals & TYPE_QUAL_VOLATILE)
-&& (loc == UNKNOWN_LOCATION || locations[ds_volatile] < loc))
+loc = min_location (loc, locations[ds_volatile]);
-loc = locations[ds_volatile];
+if (type_quals & TYPE_QUAL_RESTRICT)
-if ((type_quals & TYPE_QUAL_RESTRICT)
+loc = min_location (loc, locations[ds_restrict]);
-&& (loc == UNKNOWN_LOCATION || locations[ds_restrict] < loc))
-loc = locations[ds_restrict];
 return loc;
 }
 /* Check that it's OK to declare a function with the indicated TYPE
 	error ("return type specified for deduction guide");
 else if (type_quals != TYPE_UNQUALIFIED)
 	error_at (smallest_type_quals_location (type_quals, locations),
 		  "qualifiers are not allowed on declaration of "
 		  "deduction guide");
-type = make_template_placeholder (CLASSTYPE_TI_TEMPLATE (optype));
+if (TREE_CODE (optype) == TEMPLATE_TEMPLATE_PARM)
+	{
+	  error ("template template parameter %qT in declaration of "
+		 "deduction guide", optype);
+	  type = error_mark_node;
+	}
+else
+	type = make_template_placeholder (CLASSTYPE_TI_TEMPLATE (optype));
 for (int i = 0; i < ds_last; ++i)
 	if (i != ds_explicit && locations[i])
 	  error_at (locations[i],
 		    "decl-specifier in declaration of deduction guide");
 break;
 }
 /* Handle declaring DECL as an inline variable.  */
 static void
-mark_inline_variable (tree decl)
+mark_inline_variable (tree decl, location_t loc)
 {
 bool inlinep = true;
 if (! toplevel_bindings_p ())
 {
-error ("%<inline%> specifier invalid for variable "
+error_at (loc, "%<inline%> specifier invalid for variable "
-	     "%qD declared at block scope", decl);
+		"%qD declared at block scope", decl);
 inlinep = false;
 }
 else if (cxx_dialect < cxx17)
-pedwarn (DECL_SOURCE_LOCATION (decl), 0,
+pedwarn (loc, 0, "inline variables are only available "
-	     "inline variables are only available "
 	     "with -std=c++17 or -std=gnu++17");
 if (inlinep)
 {
 retrofit_lang_decl (decl);
 SET_DECL_VAR_DECLARED_INLINE_P (decl);
 	    tree decl = id_declarator->u.id.unqualified_name;
 	    if (!decl)
 	      break;
 	    if (qualifying_scope)
 	      {
+		if (check_for_bare_parameter_packs (qualifying_scope,
+						    id_declarator->id_loc))
+		  return error_mark_node;
 		if (at_function_scope_p ())
 		  {
 		    /* [dcl.meaning]
 		       A declarator-id shall not be qualified except
 if (name == NULL)
 name = decl_context == PARM ? "parameter" : "type name";
 if (concept_p && typedef_p)
 {
-error ("%<concept%> cannot appear in a typedef declaration");
+error_at (declspecs->locations[ds_concept],
+		"%<concept%> cannot appear in a typedef declaration");
 return error_mark_node;
 }
 if (constexpr_p && typedef_p)
 {
-error ("%<constexpr%> cannot appear in a typedef declaration");
+error_at (declspecs->locations[ds_constexpr],
+		"%<constexpr%> cannot appear in a typedef declaration");
 return error_mark_node;
 }
 /* If there were multiple types specified in the decl-specifier-seq,
 issue an error message.  */
 if (type == error_mark_node)
 {
 type = NULL_TREE;
 type_was_error_mark_node = true;
 }
-/* If the entire declaration is itself tagged as deprecated then
+cp_warn_deprecated_use (type);
-suppress reports of deprecated items.  */
-if (type && TREE_DEPRECATED (type)
-&& deprecated_state != DEPRECATED_SUPPRESS)
-warn_deprecated_use (type, NULL_TREE);
 if (type && TREE_CODE (type) == TYPE_DECL)
 {
 typedef_decl = type;
 type = TREE_TYPE (typedef_decl);
-if (TREE_DEPRECATED (type)
+if (DECL_ARTIFICIAL (typedef_decl))
-	  && DECL_ARTIFICIAL (typedef_decl)
+	cp_warn_deprecated_use (type);
-	  && deprecated_state != DEPRECATED_SUPPRESS)
-	warn_deprecated_use (type, NULL_TREE);
 }
 /* No type at all: default to `int', and set DEFAULTED_INT
 because it was not a user-defined typedef.  */
 if (type == NULL_TREE)
 {
 else if (pedantic)
 	pedwarn (input_location, OPT_Wpedantic,
 		 "ISO C++ forbids declaration of %qs with no type", name);
 else
 	warning (OPT_Wreturn_type,
-"ISO C++ forbids declaration of %qs with no type", name);
+		 "ISO C++ forbids declaration of %qs with no type", name);
 if (type_was_error_mark_node && template_parm_flag)
 	/* FIXME we should be able to propagate the error_mark_node as is
 	   for other contexts too.  */
 	type = error_mark_node;
 /* Check all other uses of type modifiers.  */
 if (unsigned_p || signed_p || long_p || short_p)
 {
+location_t loc;
+const char *key;
+if (unsigned_p)
+	{
+	  key = "unsigned";
+	  loc = declspecs->locations[ds_unsigned];
+	}
+else if (signed_p)
+	{
+	  key = "signed";
+	  loc = declspecs->locations[ds_signed];
+	}
+else if (longlong)
+	{
+	  key = "long long";
+	  loc = declspecs->locations[ds_long_long];
+	}
+else if (long_p)
+	{
+	  key = "long";
+	  loc = declspecs->locations[ds_long];
+	}
+else /* if (short_p) */
+	{
+	  key = "short";
+	  loc = declspecs->locations[ds_short];
+	}
 int ok = 0;
-if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
+if (signed_p && unsigned_p)
-	error ("%<signed%> or %<unsigned%> invalid for %qs", name);
+	{
-else if (signed_p && unsigned_p)
+	  gcc_rich_location richloc (declspecs->locations[ds_signed]);
-	error ("%<signed%> and %<unsigned%> specified together for %qs", name);
+	  richloc.add_range (declspecs->locations[ds_unsigned]);
-else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
+	  error_at (&richloc,
-	error ("%<long long%> invalid for %qs", name);
+		    "%<signed%> and %<unsigned%> specified together");
-else if (long_p && TREE_CODE (type) == REAL_TYPE)
+	}
-	error ("%<long%> invalid for %qs", name);
-else if (short_p && TREE_CODE (type) == REAL_TYPE)
-	error ("%<short%> invalid for %qs", name);
-else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
-	error ("%<long%> or %<short%> invalid for %qs", name);
-else if ((long_p || short_p || explicit_char || explicit_int) && explicit_intN)
-	error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name);
-else if ((long_p || short_p) && explicit_char)
-	error ("%<long%> or %<short%> specified with char for %qs", name);
 else if (long_p && short_p)
-	error ("%<long%> and %<short%> specified together for %qs", name);
+	{
-else if (type == char16_type_node || type == char32_type_node)
+	  gcc_rich_location richloc (declspecs->locations[ds_long]);
-	{
+	  richloc.add_range (declspecs->locations[ds_short]);
-	  if (signed_p || unsigned_p)
+	  error_at (&richloc, "%<long%> and %<short%> specified together");
-	    error ("%<signed%> or %<unsigned%> invalid for %qs", name);
+	}
-	  else if (short_p || long_p)
+else if (TREE_CODE (type) != INTEGER_TYPE
-	    error ("%<short%> or %<long%> invalid for %qs", name);
+	       || type == char16_type_node || type == char32_type_node
+	       || ((long_p || short_p)
+		   && (explicit_char || explicit_intN)))
+	error_at (loc, "%qs specified with %qT", key, type);
+else if (!explicit_int && !defaulted_int
+	       && !explicit_char && !explicit_intN)
+	{
+	  if (typedef_decl)
+	    {
+	      pedwarn (loc, OPT_Wpedantic, "%qs specified with %qT",
+		       key, type);
+	      ok = !flag_pedantic_errors;
+	    }
+	  else if (declspecs->decltype_p)
+	    error_at (loc, "%qs specified with %<decltype%>", key);
+	  else
+	    error_at (loc, "%qs specified with %<typeof%>", key);
 	}
 else
-	{
+	ok = 1;
-	  ok = 1;
-	  if (!explicit_int && !defaulted_int && !explicit_char && !explicit_intN && pedantic)
-	    {
-	      pedwarn (input_location, OPT_Wpedantic,
-		       "long, short, signed or unsigned used invalidly for %qs",
-		       name);
-	      if (flag_pedantic_errors)
-		ok = 0;
-	    }
-	}
 /* Discard the type modifiers if they are invalid.  */
 if (! ok)
 	{
 	  unsigned_p = false;
 if (virtualp)
 {
 if (staticp == 2)
 	{
-	  error ("member %qD cannot be declared both %<virtual%> "
+	  gcc_rich_location richloc (declspecs->locations[ds_virtual]);
-		 "and %<static%>", dname);
+	  richloc.add_range (declspecs->locations[ds_storage_class]);
+	  error_at (&richloc, "member %qD cannot be declared both %<virtual%> "
+		    "and %<static%>", dname);
 	  storage_class = sc_none;
 	  staticp = 0;
 	}
-if (constexpr_p)
+if (constexpr_p && cxx_dialect < cxx2a)
-	error ("member %qD cannot be declared both %<virtual%> "
+	{
-	       "and %<constexpr%>", dname);
+	  gcc_rich_location richloc (declspecs->locations[ds_virtual]);
+	  richloc.add_range (declspecs->locations[ds_constexpr]);
+	  pedwarn (&richloc, OPT_Wpedantic, "member %qD can be declared both "
+		   "%<virtual%> and %<constexpr%> only in -std=c++2a or "
+		   "-std=gnu++2a", dname);
+	}
 }
 friendp = decl_spec_seq_has_spec_p (declspecs, ds_friend);
 /* Issue errors about use of storage classes for parameters.  */
 if (decl_context == PARM)
 {
 if (typedef_p)
 	{
-	  error ("typedef declaration invalid in parameter declaration");
+	  error_at (declspecs->locations[ds_typedef],
+		    "typedef declaration invalid in parameter declaration");
 	  return error_mark_node;
 	}
 else if (template_parm_flag && storage_class != sc_none)
 	{
-	  error ("storage class specified for template parameter %qs", name);
+	  error_at (min_location (declspecs->locations[ds_thread],
+				  declspecs->locations[ds_storage_class]),
+		    "storage class specified for template parameter %qs",
+		    name);
 	  return error_mark_node;
 	}
 else if (storage_class == sc_static
 	       || storage_class == sc_extern
 	       || thread_p)
-	error ("storage class specifiers invalid in parameter declarations");
+	{
+	  error_at (min_location (declspecs->locations[ds_thread],
+				  declspecs->locations[ds_storage_class]),
+		    "storage class specified for parameter %qs", name);
+	  return error_mark_node;
+	}
 /* Function parameters cannot be concept. */
 if (concept_p)
-error ("a parameter cannot be declared %<concept%>");
+	error_at (declspecs->locations[ds_concept],
+		  "a parameter cannot be declared %<concept%>");
 /* Function parameters cannot be constexpr.  If we saw one, moan
 and pretend it wasn't there.  */
 else if (constexpr_p)
 {
-error ("a parameter cannot be declared %<constexpr%>");
+error_at (declspecs->locations[ds_constexpr],
+		    "a parameter cannot be declared %<constexpr%>");
 constexpr_p = 0;
 }
 }
 /* Give error if `virtual' is used outside of class declaration.  */
 	/* C++ also allows inlines and signed and unsigned elements,
 	   but in those cases we don't come in here.  */
 	;
 else
 	{
+	  location_t loc
+	    = min_location (declspecs->locations[ds_thread],
+			    declspecs->locations[ds_storage_class]);
 	  if (decl_context == FIELD)
-	    error ("storage class specified for %qs", name);
+	    error_at (loc, "storage class specified for %qs", name);
+	  else if (decl_context == PARM || decl_context == CATCHPARM)
+	    error_at (loc, "storage class specified for parameter %qs", name);
 	  else
-	    {
+	    error_at (loc, "storage class specified for typename");
-	      if (decl_context == PARM || decl_context == CATCHPARM)
-		error ("storage class specified for parameter %qs", name);
-	      else
-		error ("storage class specified for typename");
-	    }
 	  if (storage_class == sc_register
 	      || storage_class == sc_auto
 	      || storage_class == sc_extern
 	      || thread_p)
 	    storage_class = sc_none;
 else if (thread_p
 	   && storage_class != sc_extern
 	   && storage_class != sc_static)
 {
 if (declspecs->gnu_thread_keyword_p)
-	pedwarn (input_location, 0, "function-scope %qs implicitly auto and "
+	pedwarn (declspecs->locations[ds_thread],
+		 0, "function-scope %qs implicitly auto and "
 		 "declared %<__thread%>", name);
 /* When thread_local is applied to a variable of block scope the
 	 storage-class-specifier static is implied if it does not appear
 	 explicitly.  */
 staticp = 1;
 }
 if (storage_class && friendp)
 {
-error ("storage class specifiers invalid in friend function declarations");
+error_at (min_location (declspecs->locations[ds_thread],
+			      declspecs->locations[ds_storage_class]),
+		"storage class specifiers invalid in friend function "
+		"declarations");
 storage_class = sc_none;
 staticp = 0;
 }
 if (!id_declarator)
 	}
 }
 if (declspecs->std_attributes)
 {
-/* Apply the c++11 attributes to the type preceding them.  */
+location_t attr_loc = declspecs->locations[ds_std_attribute];
-input_location = declspecs->locations[ds_std_attribute];
+if (warning_at (attr_loc, OPT_Wattributes, "attribute ignored"))
-decl_attributes (&type, declspecs->std_attributes, 0);
+	inform (attr_loc, "an attribute that appertains to a type-specifier "
-input_location = saved_loc;
+		"is ignored");
 }
 /* Determine the type of the entity declared by recurring on the
 declarator.  */
 for (; declarator; declarator = declarator->declarator)
 	  returned_attrs = decl_attributes (&type,
 					    chainon (returned_attrs, attrs),
 					    attr_flags);
 	}
-/* We don't want to warn in parmeter context because we don't
+inner_declarator = declarator->declarator;
+/* We don't want to warn in parameter context because we don't
 	 yet know if the parse will succeed, and this might turn out
 	 to be a constructor call.  */
 if (decl_context != PARM
-	  && declarator->parenthesized != UNKNOWN_LOCATION)
+	  && decl_context != TYPENAME
+	  && !typedef_p
+	  && declarator->parenthesized != UNKNOWN_LOCATION
+	  /* If the type is class-like and the inner name used a
+	     global namespace qualifier, we need the parens.
+	     Unfortunately all we can tell is whether a qualified name
+	     was used or not.  */
+	  && !(inner_declarator
+	       && inner_declarator->kind == cdk_id
+	       && inner_declarator->u.id.qualifying_scope
+	       && (MAYBE_CLASS_TYPE_P (type)
+		   || TREE_CODE (type) == ENUMERAL_TYPE)))
 	warning_at (declarator->parenthesized, OPT_Wparentheses,
 		    "unnecessary parentheses in declaration of %qs", name);
 if (declarator->kind == cdk_id || declarator->kind == cdk_decomp)
 	break;
-inner_declarator = declarator->declarator;
 switch (declarator->kind)
 	{
 	case cdk_array:
 	  type = create_array_type_for_decl (dname, type,
 	       closest to the identifier.  */
 	    funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
 	    /* Handle a late-specified return type.  */
 	    tree late_return_type = declarator->u.function.late_return_type;
-	    if (funcdecl_p)
+	    if (funcdecl_p
+		/* This is the case e.g. for
+		   using T = auto () -> int.  */
+		|| inner_declarator == NULL)
 	      {
 		if (tree auto_node = type_uses_auto (type))
 		  {
 		    if (!late_return_type)
 		      {
 			error ("%qs function with trailing return type has"
 			       " %qT as its type rather than plain %<auto%>",
 			       name, type);
 			return error_mark_node;
 		      }
-		    if (tree tmpl = CLASS_PLACEHOLDER_TEMPLATE (auto_node))
+		    else if (is_auto (type) && AUTO_IS_DECLTYPE (type))
 		      {
-			if (!late_return_type)
+			if (funcdecl_p)
+			  error ("%qs function with trailing return type has "
+				 "%<decltype(auto)%> as its type rather than "
+				 "plain %<auto%>", name);
+			else
+			  error ("invalid use of %<decltype(auto)%>");
+			return error_mark_node;
+		      }
+		    tree tmpl = CLASS_PLACEHOLDER_TEMPLATE (auto_node);
+		    if (!tmpl)
+		      if (tree late_auto = type_uses_auto (late_return_type))
+			tmpl = CLASS_PLACEHOLDER_TEMPLATE (late_auto);
+		    if (tmpl)
+		      {
+			if (!dguide_name_p (unqualified_id))
 			  {
-			    if (dguide_name_p (unqualified_id))
+			    error_at (declarator->id_loc, "deduced class "
-			      error_at (declarator->id_loc, "deduction guide "
+				      "type %qD in function return type",
-					"for %qT must have trailing return "
+				      DECL_NAME (tmpl));
-					"type", TREE_TYPE (tmpl));
-			    else
-			      error_at (declarator->id_loc, "deduced class "
-					"type %qT in function return type",
-					type);
 			    inform (DECL_SOURCE_LOCATION (tmpl),
 				    "%qD declared here", tmpl);
+			    return error_mark_node;
+			  }
+			else if (!late_return_type)
+			  {
+			    error_at (declarator->id_loc, "deduction guide "
+				      "for %qT must have trailing return "
+				      "type", TREE_TYPE (tmpl));
+			    inform (DECL_SOURCE_LOCATION (tmpl),
+				    "%qD declared here", tmpl);
+			    return error_mark_node;
 			  }
 			else if (CLASS_TYPE_P (late_return_type)
 				 && CLASSTYPE_TEMPLATE_INFO (late_return_type)
 				 && (CLASSTYPE_TI_TEMPLATE (late_return_type)
 				     == tmpl))
 		    /* It's a constructor.  */
 		    if (explicitp == 1)
 		      explicitp = 2;
 		    if (virtualp)
 		      {
-			permerror (input_location,
+			permerror (declspecs->locations[ds_virtual],
 				   "constructors cannot be declared %<virtual%>");
 			virtualp = 0;
 		      }
 		    if (decl_context == FIELD
 			&& sfk != sfk_constructor)
 	    else if (friendp)
 	      {
 		if (virtualp)
 		  {
 		    /* Cannot be both friend and virtual.  */
-		    error ("virtual functions cannot be friends");
+		    gcc_rich_location richloc (declspecs->locations[ds_virtual]);
+		    richloc.add_range (declspecs->locations[ds_friend]);
+		    error_at (&richloc, "virtual functions cannot be friends");
 		    friendp = 0;
 		  }
 		if (decl_context == NORMAL)
 		  error ("friend declaration not in class definition");
 		if (current_function_decl && funcdef_flag)
-		  error ("can%'t define friend function %qs in a local "
+		  {
-			 "class definition",
+		    error ("can%'t define friend function %qs in a local "
-			 name);
+			   "class definition", name);
+		    friendp = 0;
+		  }
 	      }
 	    else if (ctype && sfk == sfk_conversion)
 	      {
 		if (explicitp == 1)
 		  {
 	      {
 		if (explicitp == 1)
 		  explicitp = 2;
 	      }
-	    arg_types = grokparms (declarator->u.function.parameters,
+	    tree pushed_scope = NULL_TREE;
-				   &parms);
+	    if (funcdecl_p
+		&& decl_context != FIELD
+		&& inner_declarator->u.id.qualifying_scope
+		&& CLASS_TYPE_P (inner_declarator->u.id.qualifying_scope))
+	      pushed_scope
+		= push_scope (inner_declarator->u.id.qualifying_scope);
+	    arg_types = grokparms (declarator->u.function.parameters, &parms);
+	    if (pushed_scope)
+	      pop_scope (pushed_scope);
 	    if (inner_declarator
 		&& inner_declarator->kind == cdk_id
 		&& inner_declarator->u.id.sfk == sfk_destructor
 		&& arg_types != void_list_node)
 	case cdk_reference:
 	case cdk_ptrmem:
 	  /* Filter out pointers-to-references and references-to-references.
 	     We can get these if a TYPE_DECL is used.  */
-	  if (TREE_CODE (type) == REFERENCE_TYPE)
+	  if (TYPE_REF_P (type))
 	    {
 	      if (declarator->kind != cdk_reference)
 		{
 		  error ("cannot declare pointer to %q#T", type);
 		  type = TREE_TYPE (type);
 		 to create the type "rvalue reference to cv TD' creates the
 		 type TD."
 */
 	      if (VOID_TYPE_P (type))
 		/* We already gave an error.  */;
-	      else if (TREE_CODE (type) == REFERENCE_TYPE)
+	      else if (TYPE_REF_P (type))
 		{
 		  if (declarator->u.reference.rvalue_ref)
 		    /* Leave type alone.  */;
 		  else
 		    type = cp_build_reference_type (TREE_TYPE (type), false);
 if (constexpr_p && innermost_code != cdk_function)
 {
 /* DR1688 says that a `constexpr' specifier in combination with
 	 `volatile' is valid.  */
-if (TREE_CODE (type) != REFERENCE_TYPE)
+if (!TYPE_REF_P (type))
 	{
 	  type_quals |= TYPE_QUAL_CONST;
 	  type = cp_build_qualified_type (type, type_quals);
 	}
 }
 if (declarator
 && declarator->kind == cdk_id
 && declarator->std_attributes
 && attrlist != NULL)
-/* [dcl.meaning]/1: The optional attribute-specifier-seq following
+{
-a declarator-id appertains to the entity that is declared.  */
+/* [dcl.meaning]/1: The optional attribute-specifier-seq following
-*attrlist = chainon (*attrlist, declarator->std_attributes);
+	 a declarator-id appertains to the entity that is declared.  */
+if (declarator->std_attributes != error_mark_node)
+	*attrlist = chainon (*attrlist, declarator->std_attributes);
+else
+	/* We should have already diagnosed the issue (c++/78344).  */
+	gcc_assert (seen_error ());
+}
 /* Handle parameter packs. */
 if (parameter_pack_p)
 {
 if (decl_context == PARM)
 else if (type_quals & TYPE_QUAL_CONST)
 	{
 	  error ("const %qs cannot be declared %<mutable%>", name);
 	  storage_class = sc_none;
 	}
-else if (TREE_CODE (type) == REFERENCE_TYPE)
+else if (TYPE_REF_P (type))
 	{
 	  permerror (input_location, "reference %qs cannot be declared "
 	             "%<mutable%>", name);
 	  storage_class = sc_none;
 	}
 }
 /* If this is declaring a typedef name, return a TYPE_DECL.  */
 if (typedef_p && decl_context != TYPENAME)
 {
+bool alias_p = decl_spec_seq_has_spec_p (declspecs, ds_alias);
 tree decl;
 /* This declaration:
 	   typedef void f(int) const;
 	  rqual = REF_QUAL_NONE;
 }
 if (type_uses_auto (type))
 	{
-	  error ("typedef declared %<auto%>");
+	  if (alias_p)
+	    error_at (declspecs->locations[ds_type_spec],
+		      "%<auto%> not allowed in alias declaration");
+	  else
+	    error_at (declspecs->locations[ds_type_spec],
+		      "typedef declared %<auto%>");
 	  type = error_mark_node;
 	}
 if (reqs)
 	error_at (location_of (reqs), "requires-clause on typedef");
+if (id_declarator && declarator->u.id.qualifying_scope)
+	{
+	  error ("typedef name may not be a nested-name-specifier");
+	  type = error_mark_node;
+	}
 if (decl_context == FIELD)
 	decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
 else
 	decl = build_decl (input_location, TYPE_DECL, unqualified_id, type);
-if (id_declarator && declarator->u.id.qualifying_scope) {
-	error_at (DECL_SOURCE_LOCATION (decl),
-		  "typedef name may not be a nested-name-specifier");
-	TREE_TYPE (decl) = error_mark_node;
-}
 if (decl_context != FIELD)
 	{
 	  if (!current_function_decl)
 	    DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
-	  else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
+	  else if (DECL_MAYBE_IN_CHARGE_CDTOR_P (current_function_decl))
-		   || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
-		       (current_function_decl)))
 	    /* The TYPE_DECL is "abstract" because there will be
 	       clones of this constructor/destructor, and there will
 	       be copies of this TYPE_DECL generated in those
 	       clones.  The decloning optimization (for space) may
 revert this subsequently if it determines that
 	  || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
 	C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
 bad_specifiers (decl, BSP_TYPE, virtualp,
 		      memfn_quals != TYPE_UNQUALIFIED,
-		      inlinep, friendp, raises != NULL_TREE);
+		      inlinep, friendp, raises != NULL_TREE,
+		      declspecs->locations);
-if (decl_spec_seq_has_spec_p (declspecs, ds_alias))
+if (alias_p)
 	/* Acknowledge that this was written:
 	     `using analias = atype;'.  */
 	TYPE_DECL_ALIAS_P (decl) = 1;
 return decl;
 	decl = cp_build_parm_decl (NULL_TREE, unqualified_id, type);
 	DECL_ARRAY_PARAMETER_P (decl) = array_parameter_p;
 	bad_specifiers (decl, BSP_PARM, virtualp,
 			memfn_quals != TYPE_UNQUALIFIED,
-			inlinep, friendp, raises != NULL_TREE);
+			inlinep, friendp, raises != NULL_TREE,
+			declspecs->locations);
 }
 else if (decl_context == FIELD)
 {
 	if (!staticp && !friendp && TREE_CODE (type) != METHOD_TYPE)
 	  if (tree auto_node = type_uses_auto (type))
 		/* ``A union may [ ... ] not [ have ] virtual functions.''
 		   ARM 9.5 */
 		if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
 		  {
-		    error ("function %qD declared %<virtual%> inside a union",
+		    error_at (declspecs->locations[ds_virtual],
-			   unqualified_id);
+			      "function %qD declared %<virtual%> inside a union",
+			      unqualified_id);
 		    return error_mark_node;
 		  }
 		if (virtualp
 		    && identifier_p (unqualified_id)
 		    && IDENTIFIER_NEWDEL_OP_P (unqualified_id))
 		  {
-		    error ("%qD cannot be declared %<virtual%>, since it "
+		    error_at (declspecs->locations[ds_virtual],
-			   "is always static", unqualified_id);
+			      "%qD cannot be declared %<virtual%>, since it "
+			      "is always static", unqualified_id);
 		    virtualp = 0;
 		  }
 	      }
 	    /* Check that the name used for a destructor makes sense.  */
 			   uqname, ctype);
 		    return error_mark_node;
 		  }
 if (concept_p)
 {
-error ("a destructor cannot be %<concept%>");
+error_at (declspecs->locations[ds_concept],
+			      "a destructor cannot be %<concept%>");
 return error_mark_node;
 }
 if (constexpr_p)
 {
-error ("a destructor cannot be %<constexpr%>");
+error_at (declspecs->locations[ds_constexpr],
+			      "a destructor cannot be %<constexpr%>");
 return error_mark_node;
 }
 	      }
 	    else if (sfk == sfk_constructor && friendp && !ctype)
 	      {
 		return error_mark_node;
 	      }
 	    if (sfk == sfk_constructor)
 	      if (concept_p)
 		{
-		  error ("a constructor cannot be %<concept%>");
+		  error_at (declspecs->locations[ds_concept],
+			    "a constructor cannot be %<concept%>");
 		  return error_mark_node;
 		}
 	    if (concept_p)
 	      {
-		error ("a concept cannot be a member function");
+		error_at (declspecs->locations[ds_concept],
+			  "a concept cannot be a member function");
 		concept_p = false;
 	      }
 	    if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
 	      {
 	    function_context = (ctype != NULL_TREE) ?
 	      decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
 	    publicp = (! friendp || ! staticp)
 	      && function_context == NULL_TREE;
-	    if (late_return_type_p)
-	      TYPE_HAS_LATE_RETURN_TYPE (type) = 1;
 	    decl = grokfndecl (ctype, type,
 			       TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
 			       ? unqualified_id : dname,
 			       parms,
 			       unqualified_id,
+			       declspecs,
 			       reqs,
 			       virtualp, flags, memfn_quals, rqual, raises,
 			       friendp ? -1 : 0, friendp, publicp,
 inlinep | (2 * constexpr_p) | (4 * concept_p),
 			       initialized == SD_DELETED, sfk,
-			       funcdef_flag, template_count, in_namespace,
+			       funcdef_flag, late_return_type_p,
+			       template_count, in_namespace,
 			       attrlist, declarator->id_loc);
 decl = set_virt_specifiers (decl, virt_specifiers);
 	    if (decl == NULL_TREE)
 	      return error_mark_node;
 #if 0
 	  {
 	    if (friendp)
 	      {
 		error ("%qE is neither function nor member function; "
 		       "cannot be declared friend", unqualified_id);
-		friendp = 0;
+		return error_mark_node;
 	      }
 	    decl = NULL_TREE;
 	  }
 	if (friendp)
 					    ? declarator->id_loc
 					    : input_location,
 					    VAR_DECL, unqualified_id, type);
 		set_linkage_for_static_data_member (decl);
 		if (concept_p)
-		    error ("static data member %qE declared %<concept%>",
+		  error_at (declspecs->locations[ds_concept],
-			   unqualified_id);
+			    "static data member %qE declared %<concept%>",
+			    unqualified_id);
 		else if (constexpr_p && !initialized)
 		  {
-		    error ("constexpr static data member %qD must have an "
+		    error ("%<constexpr%> static data member %qD must have an "
 			   "initializer", decl);
 		    constexpr_p = false;
 		  }
 		if (inlinep)
-		  mark_inline_variable (decl);
+		  mark_inline_variable (decl, declspecs->locations[ds_inline]);
 		if (!DECL_VAR_DECLARED_INLINE_P (decl)
 		    && !(cxx_dialect >= cxx17 && constexpr_p))
 		  /* Even if there is an in-class initialization, DECL
 		     is considered undefined until an out-of-class
 		  }
 	      }
 	    else
 	      {
 		if (concept_p)
-		  error ("non-static data member %qE declared %<concept%>",
+		  error_at (declspecs->locations[ds_concept],
-			 unqualified_id);
+			    "non-static data member %qE declared %<concept%>",
+			    unqualified_id);
 else if (constexpr_p)
 		  {
-		    error ("non-static data member %qE declared %<constexpr%>",
+		    error_at (declspecs->locations[ds_constexpr],
-			   unqualified_id);
+			      "non-static data member %qE declared %<constexpr%>",
+			      unqualified_id);
 		    constexpr_p = false;
 		  }
 		decl = build_decl (input_location,
 				   FIELD_DECL, unqualified_id, type);
 		DECL_NONADDRESSABLE_P (decl) = bitfield;
 		if (bitfield && !unqualified_id)
-		  TREE_NO_WARNING (decl) = 1;
+		  {
+		    TREE_NO_WARNING (decl) = 1;
+		    DECL_PADDING_P (decl) = 1;
+		  }
 		if (storage_class == sc_mutable)
 		  {
 		    DECL_MUTABLE_P (decl) = 1;
 		    storage_class = sc_none;
 	      }
 	    bad_specifiers (decl, BSP_FIELD, virtualp,
 			    memfn_quals != TYPE_UNQUALIFIED,
 			    staticp ? false : inlinep, friendp,
-			    raises != NULL_TREE);
+			    raises != NULL_TREE,
+			    declspecs->locations);
 	  }
 }
 else if (TREE_CODE (type) == FUNCTION_TYPE
 	     || TREE_CODE (type) == METHOD_TYPE)
 {
 	else if (storage_class == sc_register)
 	  error ("storage class %<register%> invalid for function %qs", name);
 	else if (thread_p)
 	  {
 	    if (declspecs->gnu_thread_keyword_p)
-	      error ("storage class %<__thread%> invalid for function %qs",
+	      error_at (declspecs->locations[ds_thread],
-		     name);
+			"storage class %<__thread%> invalid for function %qs",
+			name);
 	    else
-	      error ("storage class %<thread_local%> invalid for function %qs",
+	      error_at (declspecs->locations[ds_thread],
-		     name);
+			"storage class %<thread_local%> invalid for "
+			"function %qs", name);
 	  }
 if (virt_specifiers)
-error ("virt-specifiers in %qs not allowed outside a class definition", name);
+error ("virt-specifiers in %qs not allowed outside a class "
+		 "definition", name);
 	/* Function declaration not at top level.
 	   Storage classes other than `extern' are not allowed
 	   and `extern' makes no difference.  */
 	if (! toplevel_bindings_p ()
 	    && (storage_class == sc_static
 		|| decl_spec_seq_has_spec_p (declspecs, ds_inline))
 	    && pedantic)
 	  {
 	    if (storage_class == sc_static)
-	      pedwarn (input_location, OPT_Wpedantic,
+	      pedwarn (declspecs->locations[ds_storage_class], OPT_Wpedantic,
 		       "%<static%> specifier invalid for function %qs "
 		       "declared out of global scope", name);
 	    else
-	      pedwarn (input_location, OPT_Wpedantic,
+	      pedwarn (declspecs->locations[ds_inline], OPT_Wpedantic,
 		       "%<inline%> specifier invalid for function %qs "
 		       "declared out of global scope", name);
 	  }
 	if (ctype == NULL_TREE)
 	/* Record whether the function is public.  */
 	publicp = (ctype != NULL_TREE
 		   || storage_class != sc_static);
-	if (late_return_type_p)
-	  TYPE_HAS_LATE_RETURN_TYPE (type) = 1;
 	decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
+			   declspecs,
 reqs, virtualp, flags, memfn_quals, rqual, raises,
 			   1, friendp,
 			   publicp,
 inlinep | (2 * constexpr_p) | (4 * concept_p),
 			   initialized == SD_DELETED,
 sfk,
 funcdef_flag,
+			   late_return_type_p,
 			   template_count, in_namespace, attrlist,
 			   declarator->id_loc);
 	if (decl == NULL_TREE)
 	  return error_mark_node;
 	      }
 	    else if (current_function_decl)
 	      {
 		/* 7.1.1: There can be no static function declarations within a
 		   block.  */
-		error ("cannot declare static function inside another function");
+		error_at (declspecs->locations[ds_storage_class],
+			  "cannot declare static function inside another function");
 		invalid_static = 1;
 	      }
 	    if (invalid_static)
 	      {
 	if (decl == NULL_TREE)
 	  return error_mark_node;
 	bad_specifiers (decl, BSP_VAR, virtualp,
 			memfn_quals != TYPE_UNQUALIFIED,
-			inlinep, friendp, raises != NULL_TREE);
+			inlinep, friendp, raises != NULL_TREE,
+			declspecs->locations);
 	if (ctype)
 	  {
 	    DECL_CONTEXT (decl) = ctype;
 	    if (staticp == 1)
 		storage_class = sc_none;
 	      }
 	  }
 	else if (constexpr_p && DECL_EXTERNAL (decl))
 	  {
-	    error ("declaration of constexpr variable %qD is not a definition",
+	    error ("declaration of %<constexpr%> variable %qD "
-		   decl);
+		   "is not a definition", decl);
 	    constexpr_p = false;
 	  }
 	if (inlinep)
-	  mark_inline_variable (decl);
+	  mark_inline_variable (decl, declspecs->locations[ds_inline]);
 	if (innermost_code == cdk_decomp)
 	  {
 	    gcc_assert (declarator && declarator->kind == cdk_decomp);
 	    DECL_SOURCE_LOCATION (decl) = declarator->id_loc;
 	    DECL_ARTIFICIAL (decl) = 1;
 /* [dcl.fct.default]
 A default argument expression is implicitly converted to the
 parameter type.  */
 ++cp_unevaluated_operand;
-perform_implicit_conversion_flags (decl_type, arg, complain,
+/* Avoid digest_init clobbering the initializer.  */
+tree carg = BRACE_ENCLOSED_INITIALIZER_P (arg) ? unshare_expr (arg): arg;
+perform_implicit_conversion_flags (decl_type, carg, complain,
 				     LOOKUP_IMPLICIT);
 --cp_unevaluated_operand;
 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
 the call sites.  */
 	{
 	  if (deprecated_state != DEPRECATED_SUPPRESS)
 	    {
 	      tree deptype = type_is_deprecated (type);
 	      if (deptype)
-		warn_deprecated_use (deptype, NULL_TREE);
+		cp_warn_deprecated_use (deptype);
 	    }
 	  /* Top-level qualifiers on the parameters are
 	     ignored for function types.  */
 	  type = cp_build_qualified_type (type, 0);
 	      type = build_pointer_type (type);
 	      TREE_TYPE (decl) = type;
 	    }
 	  else if (abstract_virtuals_error (decl, type))
 	    any_error = 1;  /* Seems like a good idea.  */
-	  else if (cxx_dialect < cxx17 && POINTER_TYPE_P (type))
+	  else if (cxx_dialect < cxx17 && INDIRECT_TYPE_P (type))
 	    {
 	      /* Before C++17 DR 393:
 		 [dcl.fct]/6, parameter types cannot contain pointers
 		 (references) to arrays of unknown bound.  */
 	      tree t = TREE_TYPE (type);
 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
 {
 /* Pass by value copy assignment operator.  */
 result = -1;
 }
-else if (TREE_CODE (arg_type) == REFERENCE_TYPE
+else if (TYPE_REF_P (arg_type)
 	   && !TYPE_REF_IS_RVALUE (arg_type)
 	   && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
 {
 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
 	result = 2;
 arg_type = TREE_VALUE (args);
 if (arg_type == error_mark_node)
 return 0;
-if (TREE_CODE (arg_type) == REFERENCE_TYPE
+if (TYPE_REF_P (arg_type)
 && TYPE_REF_IS_RVALUE (arg_type)
 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
 DECL_CONTEXT (d)))
 result = true;
 if (DECL_DECLARED_CONSTEXPR_P (decl)
 	  && !ctor && !move_fn_p (decl))
 	TYPE_HAS_CONSTEXPR_CTOR (class_type) = 1;
 }
-else if (DECL_NAME (decl) == cp_assignment_operator_id (NOP_EXPR))
+else if (DECL_NAME (decl) == assign_op_identifier)
 {
 /* [class.copy]
 	 A non-template assignment operator for class X is a copy
 	 assignment operator if its parameter is of type X, X&, const
 }
 return true;
 }
-/* An operator with this code is unary, but can also be binary.  */
+/* DECL is a declaration for an overloaded or conversion operator.  If
+COMPLAIN is true, errors are issued for invalid declarations.  */
-static bool
-ambi_op_p (enum tree_code code)
-{
-return (code == INDIRECT_REF
-	  || code == ADDR_EXPR
-	  || code == UNARY_PLUS_EXPR
-	  || code == NEGATE_EXPR
-	  || code == PREINCREMENT_EXPR
-	  || code == PREDECREMENT_EXPR);
-}
-/* An operator with this name can only be unary.  */
-static bool
-unary_op_p (enum tree_code code)
-{
-return (code == TRUTH_NOT_EXPR
-	  || code == BIT_NOT_EXPR
-	  || code == COMPONENT_REF
-	  || code == TYPE_EXPR);
-}
-/* DECL is a declaration for an overloaded operator.  If COMPLAIN is true,
-errors are issued for invalid declarations.  */
 bool
 grok_op_properties (tree decl, bool complain)
 {
 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
-tree argtype;
+bool methodp = TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE;
-int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
 tree name = DECL_NAME (decl);
-enum tree_code operator_code;
+location_t loc = DECL_SOURCE_LOCATION (decl);
-int arity;
-bool ellipsis_p;
+tree class_type = DECL_CONTEXT (decl);
-tree class_type;
-/* Count the number of arguments and check for ellipsis.  */
-for (argtype = argtypes, arity = 0;
-argtype && argtype != void_list_node;
-argtype = TREE_CHAIN (argtype))
-++arity;
-ellipsis_p = !argtype;
-class_type = DECL_CONTEXT (decl);
 if (class_type && !CLASS_TYPE_P (class_type))
 class_type = NULL_TREE;
+tree_code operator_code;
+unsigned op_flags;
 if (IDENTIFIER_CONV_OP_P (name))
-operator_code = TYPE_EXPR;
+{
+/* Conversion operators are TYPE_EXPR for the purposes of this
+	 function.  */
+operator_code = TYPE_EXPR;
+op_flags = OVL_OP_FLAG_UNARY;
+}
 else
 {
-/* It'd be nice to hang something else of the identifier to
+const ovl_op_info_t *ovl_op = IDENTIFIER_OVL_OP_INFO (name);
-	 find CODE more directly.  */
-bool assign_op = IDENTIFIER_ASSIGN_OP_P (name);
+operator_code = ovl_op->tree_code;
-const operator_name_info_t *oni
+op_flags = ovl_op->flags;
-	= (assign_op ? assignment_operator_name_info : operator_name_info);
+gcc_checking_assert (operator_code != ERROR_MARK);
+DECL_OVERLOADED_OPERATOR_CODE_RAW (decl) = ovl_op->ovl_op_code;
-if (false)
+}
-	;
-#define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, KIND)		\
+if (op_flags & OVL_OP_FLAG_ALLOC)
-else if (assign_op == (KIND == cik_assign_op)		\
+{
-	       && oni[int (CODE)].identifier == name)		\
+/* operator new and operator delete are quite special.  */
-	operator_code = (CODE);
+if (class_type)
-#include "operators.def"
+	switch (op_flags)
-#undef DEF_OPERATOR
+	  {
-else
+	  case OVL_OP_FLAG_ALLOC:
-	gcc_unreachable ();
+	    TYPE_HAS_NEW_OPERATOR (class_type) = 1;
-}
+	    break;
-while (0);
-gcc_assert (operator_code != MAX_TREE_CODES);
+	  case OVL_OP_FLAG_ALLOC | OVL_OP_FLAG_DELETE:
-SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
+	    TYPE_GETS_DELETE (class_type) |= 1;
+	    break;
-if (class_type)
-switch (operator_code)
+	  case OVL_OP_FLAG_ALLOC | OVL_OP_FLAG_VEC:
-{
+	    TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
-case NEW_EXPR:
+	    break;
-	TYPE_HAS_NEW_OPERATOR (class_type) = 1;
-	break;
+	  case OVL_OP_FLAG_ALLOC | OVL_OP_FLAG_DELETE | OVL_OP_FLAG_VEC:
+	    TYPE_GETS_DELETE (class_type) |= 2;
-case DELETE_EXPR:
+	    break;
-	TYPE_GETS_DELETE (class_type) |= 1;
-	break;
+	  default:
+	    gcc_unreachable ();
-case VEC_NEW_EXPR:
+	  }
-	TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
-	break;
+/* [basic.std.dynamic.allocation]/1:
-case VEC_DELETE_EXPR:
+	 A program is ill-formed if an allocation function is declared
-	TYPE_GETS_DELETE (class_type) |= 2;
+	 in a namespace scope other than global scope or declared
-	break;
+	 static in global scope.
-default:
+	 The same also holds true for deallocation functions.  */
-	break;
-}
-/* [basic.std.dynamic.allocation]/1:
-A program is ill-formed if an allocation function is declared
-in a namespace scope other than global scope or declared static
-in global scope.
-The same also holds true for deallocation functions.  */
-if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
-|| operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
-{
 if (DECL_NAMESPACE_SCOPE_P (decl))
 	{
 	  if (CP_DECL_CONTEXT (decl) != global_namespace)
 	    {
-	      error ("%qD may not be declared within a namespace", decl);
+	      error_at (loc, "%qD may not be declared within a namespace",
+			decl);
 	      return false;
 	    }
-	  else if (!TREE_PUBLIC (decl))
+	  if (!TREE_PUBLIC (decl))
 	    {
-	      error ("%qD may not be declared as static", decl);
+	      error_at (loc, "%qD may not be declared as static", decl);
 	      return false;
 	    }
 	}
-}
+if (op_flags & OVL_OP_FLAG_DELETE)
-if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
+	TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl), loc);
-{
+else
-TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
+	{
-DECL_IS_OPERATOR_NEW (decl) = 1;
+	  DECL_IS_OPERATOR_NEW (decl) = 1;
-}
+	  TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl), loc);
-else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
+	}
-TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
-else
+return true;
-{
+}
-/* An operator function must either be a non-static member function
-	 or have at least one parameter of a class, a reference to a class,
+/* An operator function must either be a non-static member function
-	 an enumeration, or a reference to an enumeration.  13.4.0.6 */
+or have at least one parameter of a class, a reference to a class,
-if (! methodp || DECL_STATIC_FUNCTION_P (decl))
+an enumeration, or a reference to an enumeration.  13.4.0.6 */
-	{
+if (! methodp || DECL_STATIC_FUNCTION_P (decl))
-	  if (operator_code == TYPE_EXPR
+{
-	      || operator_code == CALL_EXPR
+if (operator_code == TYPE_EXPR
-	      || operator_code == COMPONENT_REF
+	  || operator_code == CALL_EXPR
-	      || operator_code == ARRAY_REF
+	  || operator_code == COMPONENT_REF
-	      || operator_code == NOP_EXPR)
+	  || operator_code == ARRAY_REF
+	  || operator_code == NOP_EXPR)
+	{
+	  error_at (loc, "%qD must be a nonstatic member function", decl);
+	  return false;
+	}
+if (DECL_STATIC_FUNCTION_P (decl))
+	{
+	  error_at (loc, "%qD must be either a non-static member "
+		    "function or a non-member function", decl);
+	  return false;
+	}
+for (tree arg = argtypes; ; arg = TREE_CHAIN (arg))
+	{
+	  if (!arg || arg == void_list_node)
 	    {
-	      error ("%qD must be a nonstatic member function", decl);
+	      if (complain)
+		error_at(loc, "%qD must have an argument of class or "
+			 "enumerated type", decl);
 	      return false;
 	    }
-	  else
-	    {
+	  tree type = non_reference (TREE_VALUE (arg));
-	      tree p;
+	  if (type == error_mark_node)
+	    return false;
-	      if (DECL_STATIC_FUNCTION_P (decl))
-		{
+	  /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
-		  error ("%qD must be either a non-static member "
+	     because these checks are performed even on template
-			 "function or a non-member function", decl);
+	     functions.  */
-		  return false;
+	  if (MAYBE_CLASS_TYPE_P (type)
-		}
+	      || TREE_CODE (type) == ENUMERAL_TYPE)
+	    break;
-	      for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
+	}
-		{
+}
-		  tree arg = non_reference (TREE_VALUE (p));
-		  if (arg == error_mark_node)
+if (operator_code == CALL_EXPR)
-		    return false;
+/* There are no further restrictions on the arguments to an overloaded
+"operator ()".  */
-		  /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
+return true;
-		     because these checks are performed even on
-		     template functions.  */
+if (operator_code == COND_EXPR)
-		  if (MAYBE_CLASS_TYPE_P (arg)
+{
-		      || TREE_CODE (arg) == ENUMERAL_TYPE)
+/* 13.4.0.3 */
-		    break;
+error_at (loc, "ISO C++ prohibits overloading operator ?:");
-		}
+return false;
+}
-	      if (!p || p == void_list_node)
-		{
+/* Count the number of arguments and check for ellipsis.  */
-		  if (complain)
+int arity = 0;
-		    error ("%qD must have an argument of class or "
+for (tree arg = argtypes; arg != void_list_node; arg = TREE_CHAIN (arg))
-			   "enumerated type", decl);
+{
-		  return false;
+if (!arg)
-		}
+	{
-	    }
+	  /* Variadic.  */
-	}
+	  error_at (loc, "%qD must not have variable number of arguments",
+		    decl);
-/* There are no restrictions on the arguments to an overloaded
-	 "operator ()".  */
-if (operator_code == CALL_EXPR)
-	return true;
-/* Warn about conversion operators that will never be used.  */
-if (IDENTIFIER_CONV_OP_P (name)
-	  && ! DECL_TEMPLATE_INFO (decl)
-	  && warn_conversion
-	  /* Warn only declaring the function; there is no need to
-	     warn again about out-of-class definitions.  */
-	  && class_type == current_class_type)
-	{
-	  tree t = TREE_TYPE (name);
-	  int ref = (TREE_CODE (t) == REFERENCE_TYPE);
-	  if (ref)
-	    t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
-	  if (VOID_TYPE_P (t))
-warning (OPT_Wconversion,
-ref
-? G_("conversion to a reference to void "
-"will never use a type conversion operator")
-: G_("conversion to void "
-"will never use a type conversion operator"));
-	  else if (class_type)
-	    {
-	      if (t == class_type)
-warning (OPT_Wconversion,
-ref
-? G_("conversion to a reference to the same type "
-"will never use a type conversion operator")
-: G_("conversion to the same type "
-"will never use a type conversion operator"));
-	      /* Don't force t to be complete here.  */
-	      else if (MAYBE_CLASS_TYPE_P (t)
-		       && COMPLETE_TYPE_P (t)
-		       && DERIVED_FROM_P (t, class_type))
-warning (OPT_Wconversion,
-ref
-? G_("conversion to a reference to a base class "
-"will never use a type conversion operator")
-: G_("conversion to a base class "
-"will never use a type conversion operator"));
-	    }
-	}
-if (operator_code == COND_EXPR)
-	{
-	  /* 13.4.0.3 */
-	  error ("ISO C++ prohibits overloading operator ?:");
 	  return false;
 	}
-else if (ellipsis_p)
+++arity;
-	{
+}
-	  error ("%qD must not have variable number of arguments", decl);
+/* Verify correct number of arguments.  */
+switch (op_flags)
+{
+case OVL_OP_FLAG_AMBIARY:
+if (arity == 1)
+	{
+	  /* We have a unary instance of an ambi-ary op.  Remap to the
+	     unary one.  */
+	  unsigned alt = ovl_op_alternate[ovl_op_mapping [operator_code]];
+	  const ovl_op_info_t *ovl_op = &ovl_op_info[false][alt];
+	  gcc_checking_assert (ovl_op->flags == OVL_OP_FLAG_UNARY);
+	  operator_code = ovl_op->tree_code;
+	  DECL_OVERLOADED_OPERATOR_CODE_RAW (decl) = ovl_op->ovl_op_code;
+	}
+else if (arity != 2)
+	{
+	  /* This was an ambiguous operator but is invalid. */
+	  error_at (loc,
+		    methodp
+		    ? G_("%qD must have either zero or one argument")
+		    : G_("%qD must have either one or two arguments"), decl);
 	  return false;
 	}
-else if (ambi_op_p (operator_code))
+else if ((operator_code == POSTINCREMENT_EXPR
-	{
-	  if (arity == 1)
-	    /* We pick the one-argument operator codes by default, so
-	       we don't have to change anything.  */
-	    ;
-	  else if (arity == 2)
-	    {
-	      /* If we thought this was a unary operator, we now know
-		 it to be a binary operator.  */
-	      switch (operator_code)
-		{
-		case INDIRECT_REF:
-		  operator_code = MULT_EXPR;
-		  break;
-		case ADDR_EXPR:
-		  operator_code = BIT_AND_EXPR;
-		  break;
-		case UNARY_PLUS_EXPR:
-		  operator_code = PLUS_EXPR;
-		  break;
-		case NEGATE_EXPR:
-		  operator_code = MINUS_EXPR;
-		  break;
-		case PREINCREMENT_EXPR:
-		  operator_code = POSTINCREMENT_EXPR;
-		  break;
-		case PREDECREMENT_EXPR:
-		  operator_code = POSTDECREMENT_EXPR;
-		  break;
-		default:
-		  gcc_unreachable ();
-		}
-	      SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
-	      if ((operator_code == POSTINCREMENT_EXPR
-		   || operator_code == POSTDECREMENT_EXPR)
-		  && ! processing_template_decl
-		  && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
-		{
-		  if (methodp)
-		    error ("postfix %qD must take %<int%> as its argument",
-			   decl);
-		  else
-		    error ("postfix %qD must take %<int%> as its second "
-			   "argument", decl);
-		  return false;
-		}
-	    }
-	  else
-	    {
-	      if (methodp)
-		error ("%qD must take either zero or one argument", decl);
-	      else
-		error ("%qD must take either one or two arguments", decl);
-	      return false;
-	    }
-	  /* More Effective C++ rule 6.  */
-	  if (warn_ecpp
-	      && (operator_code == POSTINCREMENT_EXPR
-		  || operator_code == POSTDECREMENT_EXPR
-		  || operator_code == PREINCREMENT_EXPR
-		  || operator_code == PREDECREMENT_EXPR))
-	    {
-	      tree arg = TREE_VALUE (argtypes);
-	      tree ret = TREE_TYPE (TREE_TYPE (decl));
-	      if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
-		arg = TREE_TYPE (arg);
-	      arg = TYPE_MAIN_VARIANT (arg);
-	      if (operator_code == PREINCREMENT_EXPR
-		  || operator_code == PREDECREMENT_EXPR)
-		{
-		  if (TREE_CODE (ret) != REFERENCE_TYPE
-		      || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
-				       arg))
-		    warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
-			     build_reference_type (arg));
-		}
-	      else
-		{
-		  if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
-		    warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
-		}
-	    }
-	}
-else if (unary_op_p (operator_code))
-	{
-	  if (arity != 1)
-	    {
-	      if (methodp)
-		error ("%qD must take %<void%>", decl);
-	      else
-		error ("%qD must take exactly one argument", decl);
-	      return false;
-	    }
-	}
-else /* if (binary_op_p (operator_code)) */
-	{
-	  if (arity != 2)
-	    {
-	      if (methodp)
-		error ("%qD must take exactly one argument", decl);
-	      else
-		error ("%qD must take exactly two arguments", decl);
-	      return false;
-	    }
-	  /* More Effective C++ rule 7.  */
-	  if (warn_ecpp
-	      && (operator_code == TRUTH_ANDIF_EXPR
-		  || operator_code == TRUTH_ORIF_EXPR
-		  || operator_code == COMPOUND_EXPR))
-	    warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
-		     decl);
-	}
-/* Effective C++ rule 23.  */
-if (warn_ecpp
-	  && arity == 2
-	  && !DECL_ASSIGNMENT_OPERATOR_P (decl)
-	  && (operator_code == PLUS_EXPR
-	      || operator_code == MINUS_EXPR
-	      || operator_code == TRUNC_DIV_EXPR
-	      || operator_code == MULT_EXPR
-	      || operator_code == TRUNC_MOD_EXPR)
-	  && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
-	warning (OPT_Weffc__, "%qD should return by value", decl);
-/* [over.oper]/8 */
-for (; argtypes && argtypes != void_list_node;
-	  argtypes = TREE_CHAIN (argtypes))
-	if (TREE_PURPOSE (argtypes))
-	  {
-	    TREE_PURPOSE (argtypes) = NULL_TREE;
-	    if (operator_code == POSTINCREMENT_EXPR
 		|| operator_code == POSTDECREMENT_EXPR)
-	      {
+	       && ! processing_template_decl
-		pedwarn (input_location, OPT_Wpedantic, "%qD cannot have default arguments",
+	       /* x++ and x--'s second argument must be an int.  */
-			 decl);
+	       && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)),
-	      }
+				 integer_type_node))
-	    else
+	{
-	      {
+	  error_at (loc,
-		error ("%qD cannot have default arguments", decl);
+		    methodp
-		return false;
+		    ? G_("postfix %qD must have %<int%> as its argument")
-	      }
+		    : G_("postfix %qD must have %<int%> as its second argument"),
-	  }
+		    decl);
-}
+	  return false;
+	}
+break;
+case OVL_OP_FLAG_UNARY:
+if (arity != 1)
+	{
+	  error_at (loc,
+		    methodp
+		    ? G_("%qD must have no arguments")
+		    : G_("%qD must have exactly one argument"), decl);
+	  return false;
+	}
+break;
+case OVL_OP_FLAG_BINARY:
+if (arity != 2)
+	{
+	  error_at (loc,
+		    methodp
+		    ? G_("%qD must have exactly one argument")
+		    : G_("%qD must have exactly two arguments"), decl);
+	  return false;
+	}
+break;
+default:
+gcc_unreachable ();
+}
+/* There can be no default arguments.  */
+for (tree arg = argtypes; arg != void_list_node; arg = TREE_CHAIN (arg))
+if (TREE_PURPOSE (arg))
+{
+	TREE_PURPOSE (arg) = NULL_TREE;
+	error_at (loc, "%qD cannot have default arguments", decl);
+	return false;
+}
+/* At this point the declaration is well-formed.  It may not be
+sensible though.  */
+/* Check member function warnings only on the in-class declaration.
+There's no point warning on an out-of-class definition.  */
+if (class_type && class_type != current_class_type)
+return true;
+/* Warn about conversion operators that will never be used.  */
+if (IDENTIFIER_CONV_OP_P (name)
+&& ! DECL_TEMPLATE_INFO (decl)
+&& warn_class_conversion)
+{
+tree t = TREE_TYPE (name);
+int ref = TYPE_REF_P (t);
+if (ref)
+	t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
+if (VOID_TYPE_P (t))
+	warning_at (loc, OPT_Wclass_conversion, "converting %qT to %<void%> "
+		    "will never use a type conversion operator", class_type);
+else if (class_type)
+	{
+	  if (same_type_ignoring_top_level_qualifiers_p (t, class_type))
+	    warning_at (loc, OPT_Wclass_conversion,
+			ref
+			? G_("converting %qT to a reference to the same type "
+			     "will never use a type conversion operator")
+			: G_("converting %qT to the same type "
+			     "will never use a type conversion operator"),
+			class_type);
+	  /* Don't force t to be complete here.  */
+	  else if (MAYBE_CLASS_TYPE_P (t)
+		   && COMPLETE_TYPE_P (t)
+		   && DERIVED_FROM_P (t, class_type))
+	    warning_at (loc, OPT_Wclass_conversion,
+			ref
+			? G_("converting %qT to a reference to a base class "
+			     "%qT will never use a type conversion operator")
+			: G_("converting %qT to a base class %qT "
+			     "will never use a type conversion operator"),
+			class_type, t);
+	}
+}
+if (!warn_ecpp)
+return true;
+/* Effective C++ rules below.  */
+/* More Effective C++ rule 7.  */
+if (operator_code == TRUTH_ANDIF_EXPR
+|| operator_code == TRUTH_ORIF_EXPR
+|| operator_code == COMPOUND_EXPR)
+warning_at (loc, OPT_Weffc__,
+		"user-defined %qD always evaluates both arguments", decl);
+/* More Effective C++ rule 6.  */
+if (operator_code == POSTINCREMENT_EXPR
+|| operator_code == POSTDECREMENT_EXPR
+|| operator_code == PREINCREMENT_EXPR
+|| operator_code == PREDECREMENT_EXPR)
+{
+tree arg = TREE_VALUE (argtypes);
+tree ret = TREE_TYPE (TREE_TYPE (decl));
+if (methodp || TYPE_REF_P (arg))
+	arg = TREE_TYPE (arg);
+arg = TYPE_MAIN_VARIANT (arg);
+if (operator_code == PREINCREMENT_EXPR
+	  || operator_code == PREDECREMENT_EXPR)
+	{
+	  if (!TYPE_REF_P (ret)
+	      || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)), arg))
+	    warning_at (loc, OPT_Weffc__, "prefix %qD should return %qT", decl,
+			build_reference_type (arg));
+	}
+else
+	{
+	  if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
+	    warning_at (loc, OPT_Weffc__,
+			"postfix %qD should return %qT", decl, arg);
+	}
+}
+/* Effective C++ rule 23.  */
+if (!DECL_ASSIGNMENT_OPERATOR_P (decl)
+&& (operator_code == PLUS_EXPR
+	  || operator_code == MINUS_EXPR
+	  || operator_code == TRUNC_DIV_EXPR
+	  || operator_code == MULT_EXPR
+	  || operator_code == TRUNC_MOD_EXPR)
+&& TYPE_REF_P (TREE_TYPE (TREE_TYPE (decl))))
+warning_at (loc, OPT_Weffc__, "%qD should return by value", decl);
 return true;
 }
 /* Return a string giving the keyword associate with CODE.  */
 /* Since SCOPE is not TS_CURRENT, we are not looking at a
 	 definition of this tag.  Since, in addition, we are currently
 	 processing a (member) template declaration of a template
 	 class, we must be very careful; consider:
-	   template <class X>
+	   template <class X> struct S1
-	   struct S1
+	   template <class U> struct S2
-	   template <class U>
+	   {
-	   struct S2
+	     template <class V> friend struct S1;
-	   { template <class V>
+	   };
-	   friend struct S1; };
 	 Here, the S2::S1 declaration should not be confused with the
 	 outer declaration.  In particular, the inner version should
-	 have a template parameter of level 2, not level 1.  This
+	 have a template parameter of level 2, not level 1.
-	 would be particularly important if the member declaration
-	 were instead:
+	 On the other hand, when presented with:
-	   template <class V = U> friend struct S1;
+	   template <class T> struct S1
+	   {
-	 say, when we should tsubst into `U' when instantiating
+	     template <class U> struct S2 {};
-	 S2.  On the other hand, when presented with:
+	     template <class U> friend struct S2;
-	   template <class T>
-	   struct S1 {
-	     template <class U>
-	     struct S2 {};
-	     template <class U>
-	     friend struct S2;
 	   };
-	 we must find the inner binding eventually.  We
+	 the friend must find S1::S2 eventually.  We accomplish this
-	 accomplish this by making sure that the new type we
+	 by making sure that the new type we create to represent this
-	 create to represent this declaration has the right
+	 declaration has the right TYPE_CONTEXT.  */
-	 TYPE_CONTEXT.  */
 context = TYPE_CONTEXT (t);
 t = NULL_TREE;
 }
 if (! t)
 else
 	{
 	  t = make_class_type (code);
 	  TYPE_CONTEXT (t) = context;
 	  if (scope == ts_lambda)
-	    /* Mark it as a lambda type.  */
+	    {
-	    CLASSTYPE_LAMBDA_EXPR (t) = error_mark_node;
+	      /* Mark it as a lambda type.  */
+	      CLASSTYPE_LAMBDA_EXPR (t) = error_mark_node;
+	      /* And push it into current scope.  */
+	      scope = ts_current;
+	    }
 	  t = pushtag (name, t, scope);
 	}
 }
 else
 {
 	  error ("redeclaration of %qT as a non-template", t);
 	  inform (location_of (t), "previous declaration %qD", t);
 	  return error_mark_node;
 	}
-/* Make injected friend class visible.  */
 if (scope != ts_within_enclosing_non_class && TYPE_HIDDEN_P (t))
 	{
+	  /* This is no longer an invisible friend.  Make it
+	     visible.  */
 	  tree decl = TYPE_NAME (t);
 	  DECL_ANTICIPATED (decl) = false;
 	  DECL_FRIEND_P (decl) = false;
 vec_alloc (BINFO_BASE_ACCESSES (binfo), max_bases);
 /* A C++98 POD cannot have base classes.  */
 CLASSTYPE_NON_LAYOUT_POD_P (ref) = true;
 if (TREE_CODE (ref) == UNION_TYPE)
-	error ("derived union %qT invalid", ref);
+	{
+	  error ("derived union %qT invalid", ref);
+	  return;
+	}
 }
 if (max_bases > 1)
 warning (OPT_Wmultiple_inheritance,
 	     "%qT defined with multiple direct bases", ref);
 	  inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
 		  "previous definition here");
 	  enumtype = error_mark_node;
 	}
 else if (underlying_type && ENUM_UNDERLYING_TYPE (enumtype)
-	       && !dependent_type_p (underlying_type)
-	       && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype))
 	       && !same_type_p (underlying_type,
 				ENUM_UNDERLYING_TYPE (enumtype)))
 	{
 	  error_at (input_location, "different underlying type "
 		    "in enum %q#T", enumtype);
 	  enumtype = NULL_TREE;
 	}
 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
 of an opaque enum, or an opaque enum of an already defined
-	 enumeration (C++0x only).
+	 enumeration (C++11).
 	 In any other case, it'll be NULL_TREE. */
 if (!enumtype)
 	{
 	  if (is_new)
 	    *is_new = true;
 	}
 prevtype = enumtype;
-/* Do not push the decl more than once, unless we need to
+/* Do not push the decl more than once.  */
-	 compare underlying types at instantiation time */
 if (!enumtype
-	  || TREE_CODE (enumtype) != ENUMERAL_TYPE
+	  || 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);
 	  /* std::byte aliases anything.  */
 if (value == NULL_TREE)
 	{
 	  if (TYPE_VALUES (enumtype))
 	    {
 	      tree prev_value;
-	      bool overflowed;
 	      /* C++03 7.2/4: If no initializer is specified for the first
 		 enumerator, the type is an unspecified integral
 		 type. Otherwise the type is the same as the type of the
 		 initializing value of the preceding enumerator unless the
 	      prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
 	      if (error_operand_p (prev_value))
 		value = error_mark_node;
 	      else
 		{
+		  wi::overflow_type overflowed;
 		  tree type = TREE_TYPE (prev_value);
 		  signop sgn = TYPE_SIGN (type);
 		  widest_int wi = wi::add (wi::to_widest (prev_value), 1, sgn,
 					   &overflowed);
 		  if (!overflowed)
 				     pos ? G_("\
 incremented enumerator value is too large for %<unsigned long%>") : G_("\
 incremented enumerator value is too large for %<long%>"));
 			}
 		      if (type == NULL_TREE)
-			overflowed = true;
+		        overflowed = wi::OVF_UNKNOWN;
 		      else
 			value = wide_int_to_tree (type, wi);
 		    }
 		  if (overflowed)
 	fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
 					     void_type_node,
 					     TREE_CHAIN (args));
 else
 	fntype = build_function_type (void_type_node, args);
-fntype
-	= build_exception_variant (fntype,
-				   TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
 fntype = (cp_build_type_attribute_variant
 		(fntype, TYPE_ATTRIBUTES (TREE_TYPE (decl))));
+fntype = cxx_copy_lang_qualifiers (fntype, TREE_TYPE (decl));
 TREE_TYPE (decl) = fntype;
 }
 else
 {
 abstract_virtuals_error (decl, TREE_TYPE (fntype));
 tree ctype = current_class_type;
 if (!vbases)
 ctype = CLASSTYPE_AS_BASE (ctype);
-tree clobber = build_constructor (ctype, NULL);
+tree clobber = build_clobber (ctype);
-TREE_THIS_VOLATILE (clobber) = true;
 tree thisref = current_class_ref;
 if (ctype != current_class_type)
 {
 thisref = build_nop (build_reference_type (ctype), current_class_ptr);
 if (flags & SF_INCLASS_INLINE)
 maybe_begin_member_template_processing (decl1);
 /* Effective C++ rule 15.  */
 if (warn_ecpp
-&& DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
+&& DECL_ASSIGNMENT_OPERATOR_P (decl1)
+&& DECL_OVERLOADED_OPERATOR_IS (decl1, NOP_EXPR)
 && VOID_TYPE_P (TREE_TYPE (fntype)))
-warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
+warning (OPT_Weffc__,
+	     "%<operator=%> should return a reference to %<*this%>");
 /* Make the init_value nonzero so pushdecl knows this is not tentative.
 error_mark_node is replaced below (in poplevel) with the BLOCK.  */
 if (!DECL_INITIAL (decl1))
 DECL_INITIAL (decl1) = error_mark_node;
 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
 gcc_assert (TYPE_PTR_P (TREE_TYPE (t)));
 cp_function_chain->x_current_class_ref
-	= cp_build_indirect_ref (t, RO_NULL, tf_warning_or_error);
+	= cp_build_fold_indirect_ref (t);
 /* Set this second to avoid shortcut in cp_build_indirect_ref.  */
 cp_function_chain->x_current_class_ptr = t;
 /* Constructors and destructors need to know whether they're "in
 	 charge" of initializing virtual base classes.  */
 finish_compound_stmt (compound_stmt);
 if (flag_lifetime_dse
 	  /* Clobbering an empty base is harmful if it overlays real data.  */
 	  && !is_empty_class (current_class_type))
-	finish_decl_cleanup (NULL_TREE, build_clobber_this ());
+{
+	if (sanitize_flags_p (SANITIZE_VPTR)
+	    && (flag_sanitize_recover & SANITIZE_VPTR) == 0
+	    && TYPE_CONTAINS_VPTR_P (current_class_type))
+	  {
+	    tree binfo = TYPE_BINFO (current_class_type);
+	    tree ref
+	      = cp_build_fold_indirect_ref (current_class_ptr);
+	    tree vtbl_ptr = build_vfield_ref (ref, TREE_TYPE (binfo));
+	    tree vtbl = build_zero_cst (TREE_TYPE (vtbl_ptr));
+	    tree stmt = cp_build_modify_expr (input_location, vtbl_ptr,
+					      NOP_EXPR, vtbl,
+					      tf_warning_or_error);
+	    /* If the vptr is shared with some virtual nearly empty base,
+	       don't clear it if not in charge, the dtor of the virtual
+	       nearly empty base will do that later.  */
+	    if (CLASSTYPE_VBASECLASSES (current_class_type)
+		&& CLASSTYPE_PRIMARY_BINFO (current_class_type)
+		&& BINFO_VIRTUAL_P
+			  (CLASSTYPE_PRIMARY_BINFO (current_class_type)))
+	      {
+		stmt = convert_to_void (stmt, ICV_STATEMENT,
+					tf_warning_or_error);
+		stmt = build_if_in_charge (stmt);
+	      }
+	    finish_decl_cleanup (NULL_TREE, stmt);
+	  }
+	else
+	  finish_decl_cleanup (NULL_TREE, build_clobber_this ());
+}
 /* And insert cleanups for our bases and members so that they
 	 will be properly destroyed if we throw.  */
 push_base_cleanups ();
 }
 && !cp_function_chain->invalid_constexpr
 && !DECL_CLONED_FUNCTION_P (fun))
 register_constexpr_fundef (fun, DECL_SAVED_TREE (fun));
 }
+/* Attempt to add a fix-it hint to RICHLOC suggesting the insertion
+of "return *this;" immediately before its location, using FNDECL's
+first statement (if any) to give the indentation, if appropriate.  */
+static void
+add_return_star_this_fixit (gcc_rich_location *richloc, tree fndecl)
+{
+location_t indent = UNKNOWN_LOCATION;
+tree stmts = expr_first (DECL_SAVED_TREE (fndecl));
+if (stmts)
+indent = EXPR_LOCATION (stmts);
+richloc->add_fixit_insert_formatted ("return *this;",
+				       richloc->get_loc (),
+				       indent);
+}
 /* Finish up a function declaration and compile that function
 all the way to assembler language output.  The free the storage
 for the function definition. INLINE_P is TRUE if we just
 finished processing the body of an in-class inline function
 definition.  (This processing will have taken place after the
 			      current_eh_spec_block);
 }
 /* If we're saving up tree structure, tie off the function now.  */
 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
-if (fn_contains_cilk_spawn_p (cfun) && !processing_template_decl)
-cfun->cilk_frame_decl = insert_cilk_frame (fndecl);
 finish_fname_decls ();
 /* If this function can't throw any exceptions, remember that.  */
 if (!processing_template_decl
 /* Structor return values (if any) are set by the compiler.  */
 && !DECL_CONSTRUCTOR_P (fndecl)
 && !DECL_DESTRUCTOR_P (fndecl)
 && targetm.warn_func_return (fndecl))
 {
-warning (OPT_Wreturn_type,
+gcc_rich_location richloc (input_location);
-	       "no return statement in function returning non-void");
+/* Potentially add a "return *this;" fix-it hint for
+	 assignment operators.  */
+if (IDENTIFIER_ASSIGN_OP_P (DECL_NAME (fndecl)))
+	{
+	  tree valtype = TREE_TYPE (DECL_RESULT (fndecl));
+	  if (TREE_CODE (valtype) == REFERENCE_TYPE
+	      && same_type_ignoring_top_level_qualifiers_p
+		  (TREE_TYPE (valtype), TREE_TYPE (current_class_ref)))
+	    if (global_dc->option_enabled (OPT_Wreturn_type,
+					   global_dc->option_state))
+	      add_return_star_this_fixit (&richloc, fndecl);
+	}
+warning_at (&richloc, OPT_Wreturn_type,
+		  "no return statement in function returning non-void");
 TREE_NO_WARNING (fndecl) = 1;
 }
 /* Store the end of the function, so that we get good line number
 info for the epilogue.  */
 	    && DECL_NAME (decl)
 	    && !DECL_ARTIFICIAL (decl)
 	    && !TREE_NO_WARNING (decl)
 	    && !DECL_IN_SYSTEM_HEADER (decl)
 	    && TREE_TYPE (decl) != error_mark_node
-	    && TREE_CODE (TREE_TYPE (decl)) != REFERENCE_TYPE
+	    && !TYPE_REF_P (TREE_TYPE (decl))
 	    && (!CLASS_TYPE_P (TREE_TYPE (decl))
 	        || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl))))
 	  warning_at (DECL_SOURCE_LOCATION (decl),
 		      OPT_Wunused_but_set_parameter,
 		      "parameter %qD set but not used", decl);
 tree fntype;
 tree args;
 if (TYPE_PTRMEMFUNC_P (memfntype))
 memfntype = TYPE_PTRMEMFUNC_FN_TYPE (memfntype);
-if (POINTER_TYPE_P (memfntype)
+if (INDIRECT_TYPE_P (memfntype)
 || TREE_CODE (memfntype) == FUNCTION_DECL)
 memfntype = TREE_TYPE (memfntype);
 if (TREE_CODE (memfntype) == FUNCTION_TYPE)
 return memfntype;
 gcc_assert (TREE_CODE (memfntype) == METHOD_TYPE);
 args = TYPE_ARG_TYPES (memfntype);
-cp_ref_qualifier rqual = type_memfn_rqual (memfntype);
 fntype = build_function_type (TREE_TYPE (memfntype), TREE_CHAIN (args));
-fntype = apply_memfn_quals (fntype, type_memfn_quals (memfntype), rqual);
+fntype = apply_memfn_quals (fntype, type_memfn_quals (memfntype));
 fntype = (cp_build_type_attribute_variant
 	    (fntype, TYPE_ATTRIBUTES (memfntype)));
-fntype = (build_exception_variant
+fntype = cxx_copy_lang_qualifiers (fntype, memfntype);
-	    (fntype, TYPE_RAISES_EXCEPTIONS (memfntype)));
-if (TYPE_HAS_LATE_RETURN_TYPE (memfntype))
-TYPE_HAS_LATE_RETURN_TYPE (fntype) = 1;
 return fntype;
 }
 /* DECL was originally constructed as a non-static member function,
 but turned out to be static.  Update it accordingly.  */
 return f->x_auto_return_pattern;
 }
 return TREE_TYPE (TREE_TYPE (fn));
 }
-/* Returns true iff DECL was declared with an auto type and it has
+/* Returns true iff DECL is a variable or function declared with an auto type
-not yet been deduced to a real type.  */
+that has not yet been deduced to a real type.  */
 bool
 undeduced_auto_decl (tree decl)
 {
 if (cxx_dialect < cxx11)
 return false;
-return type_uses_auto (TREE_TYPE (decl));
+return ((VAR_OR_FUNCTION_DECL_P (decl)
+	   || TREE_CODE (decl) == TEMPLATE_DECL)
+	  && type_uses_auto (TREE_TYPE (decl)));
 }
 /* Complain if DECL has an undeduced return type.  */
 bool

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cp/decl.c @ 131:84e7813d76e9