CbC/CbC_gcc: gcc/cp/name-lookup.c comparison

comparison gcc/cp/name-lookup.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
 /* Definitions for C++ name lookup routines.
-Copyright (C) 2003-2017 Free Software Foundation, Inc.
+Copyright (C) 2003-2018 Free Software Foundation, Inc.
 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING3.  If not see
 <http://www.gnu.org/licenses/>.  */
 #include "config.h"
+#define INCLUDE_UNIQUE_PTR
 #include "system.h"
 #include "coretypes.h"
 #include "cp-tree.h"
 #include "timevar.h"
 #include "stringpool.h"
 #include "c-family/c-pragma.h"
 #include "params.h"
 #include "gcc-rich-location.h"
 #include "spellcheck-tree.h"
 #include "parser.h"
+#include "c-family/name-hint.h"
+#include "c-family/known-headers.h"
+#include "c-family/c-spellcheck.h"
 static cxx_binding *cxx_binding_make (tree value, tree type);
 static cp_binding_level *innermost_nonclass_level (void);
 static void set_identifier_type_value_with_scope (tree id, tree decl,
 						  cp_binding_level *b);
+static bool maybe_suggest_missing_std_header (location_t location, tree name);
 /* Create an overload suitable for recording an artificial TYPE_DECL
 and another decl.  We use this machanism to implement the struct
 stat hack within a namespace.  It'd be nice to use it everywhere.  */
 find_local_binding (cp_binding_level *b, tree name)
 {
 if (cxx_binding *binding = IDENTIFIER_BINDING (name))
 for (;; b = b->level_chain)
 {
-	if (binding->scope == b
+	if (binding->scope == b)
-	    && !(VAR_P (binding->value)
-		 && DECL_DEAD_FOR_LOCAL (binding->value)))
 	  return binding;
 	/* Cleanup contours are transparent to the language.  */
 	if (b->kind != sk_cleanup)
 	  break;
 /* We've visited this scope before.  Return what we found then.  */
 return found_p (scope);
 /* Look in exactly namespace. */
 bool found = search_namespace_only (scope);
-/* Recursively look in its inline children.  */
+/* Don't look into inline children, if we're looking for an
-if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
+anonymous name -- it must be in the current scope, if anywhere.  */
-for (unsigned ix = inlinees->length (); ix--;)
+if (name)
-found |= search_namespace ((*inlinees)[ix]);
+/* Recursively look in its inline children.  */
+if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope))
+for (unsigned ix = inlinees->length (); ix--;)
+	found |= search_namespace ((*inlinees)[ix]);
 if (found)
 mark_found (scope);
 return found;
 	}
 while (ix < queue->length ());
 done:;
 if (scope == global_namespace)
 	break;
+/* If looking for hidden names, we only look in the innermost
+	 namespace scope.  [namespace.memdef]/3 If a friend
+	 declaration in a non-local class first declares a class,
+	 function, class template or function template the friend is a
+	 member of the innermost enclosing namespace.  See also
+	 [basic.lookup.unqual]/7 */
+if (flags & LOOKUP_HIDDEN)
+	break;
 }
 vec_safe_truncate (queue, length);
 return found;
 static tree
 member_vec_linear_search (vec<tree, va_gc> *member_vec, tree name)
 {
 for (int ix = member_vec->length (); ix--;)
-/* We can get a NULL binding during insertion of a new method
-name, because the identifier_binding machinery performs a
-lookup.  If we find such a NULL slot, that's the thing we were
-looking for, so we might as well bail out immediately.  */
 if (tree binding = (*member_vec)[ix])
-{
+if (OVL_NAME (binding) == name)
-	if (OVL_NAME (binding) == name)
+	return binding;
-	  return binding;
-}
-else
-break;
 return NULL_TREE;
 }
 /* Linear search of (partially ordered) fields of KLASS for NAME.  */
 {
 for (tree fields = TYPE_FIELDS (klass); fields; fields = DECL_CHAIN (fields))
 {
 tree decl = fields;
-if (!want_type
+if (TREE_CODE (decl) == FIELD_DECL
-	  && TREE_CODE (decl) == FIELD_DECL
 	  && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
 	{
-	  tree anon = TREE_TYPE (decl);
+	  if (tree temp = search_anon_aggr (TREE_TYPE (decl), name, want_type))
-	  gcc_assert (COMPLETE_TYPE_P (anon));
+	    return temp;
-	  tree temp;
-	  if (vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (anon))
-	    temp = member_vec_linear_search (member_vec, name);
-	  else
-	    temp = fields_linear_search (anon, name, want_type);
-	  if (temp)
-	    {
-	      /* Anon members can only contain fields.  */
-	      gcc_assert (!STAT_HACK_P (temp) && !DECL_DECLARES_TYPE_P (temp));
-	      return temp;
-	    }
 	}
 if (DECL_NAME (decl) != name)
 	continue;
 if (!want_type || DECL_DECLARES_TYPE_P (decl))
 	return decl;
 }
 return NULL_TREE;
+}
+/* Look for NAME member inside of anonymous aggregate ANON.  Although
+such things should only contain FIELD_DECLs, we check that too
+late, and would give very confusing errors if we weren't
+permissive here.  */
+tree
+search_anon_aggr (tree anon, tree name, bool want_type)
+{
+gcc_assert (COMPLETE_TYPE_P (anon));
+tree ret = get_class_binding_direct (anon, name, want_type);
+return ret;
 }
 /* Look for NAME as an immediate member of KLASS (including
 anon-members or unscoped enum member).  TYPE_OR_FNS is zero for
 regular search.  >0 to get a type binding (if there is one) and <0
 else if (IDENTIFIER_DTOR_P (name))
 	{
 	  if (CLASSTYPE_LAZY_DESTRUCTOR (klass))
 	    lazily_declare_fn (sfk_destructor, klass);
 	}
-else if (name == cp_assignment_operator_id (NOP_EXPR))
+else if (name == assign_op_identifier)
 	{
 	  if (CLASSTYPE_LAZY_COPY_ASSIGN (klass))
 	    lazily_declare_fn (sfk_copy_assignment, klass);
 	  if (CLASSTYPE_LAZY_MOVE_ASSIGN (klass))
 	    lazily_declare_fn (sfk_move_assignment, klass);
 return get_class_binding_direct (klass, name, type_or_fns);
 }
 /* Find the slot containing overloads called 'NAME'.  If there is no
-such slot, create an empty one.  KLASS might be complete at this
+such slot and the class is complete, create an empty one, at the
-point, in which case we need to preserve ordering.  Deals with
+correct point in the sorted member vector.  Otherwise return NULL.
-conv_op marker handling.  */
+Deals with conv_op marker handling.  */
 tree *
-get_member_slot (tree klass, tree name)
+find_member_slot (tree klass, tree name)
 {
 bool complete_p = COMPLETE_TYPE_P (klass);
 vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
 if (!member_vec)
 {
 vec_alloc (member_vec, 8);
 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
 if (complete_p && fn_name > name)
 	break;
 }
-/* No slot found.  Create one at IX.  We know in this case that our
+/* No slot found, add one if the class is complete.  */
-caller will succeed in adding the function.  */
 if (complete_p)
 {
-/* Do exact allocation when complete, as we don't expect to add
+/* Do exact allocation, as we don't expect to add many.  */
-	 many.  */
+gcc_assert (name != conv_op_identifier);
 vec_safe_reserve_exact (member_vec, 1);
+CLASSTYPE_MEMBER_VEC (klass) = member_vec;
 member_vec->quick_insert (ix, NULL_TREE);
-}
+return &(*member_vec)[ix];
-else
+}
-{
-gcc_checking_assert (ix == length);
+return NULL;
-vec_safe_push (member_vec, NULL_TREE);
+}
-}
+/* KLASS is an incomplete class to which we're adding a method NAME.
+Add a slot and deal with conv_op marker handling.  */
+tree *
+add_member_slot (tree klass, tree name)
+{
+gcc_assert (!COMPLETE_TYPE_P (klass));
+vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (klass);
+vec_safe_push (member_vec, NULL_TREE);
 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
-tree *slot = &(*member_vec)[ix];
+tree *slot = &member_vec->last ();
-if (name == conv_op_identifier)
+if (IDENTIFIER_CONV_OP_P (name))
 {
 /* Install the marker prefix.  */
 *slot = ovl_make (conv_op_marker, NULL_TREE);
 slot = &OVL_CHAIN (*slot);
 }
 We should not be doing #1, but in either case it doesn't matter
 how we order these.  Use UID as a proxy for source ordering, so
 that identically-located decls still have a well-defined stable
 ordering.  */
-return DECL_UID (a) < DECL_UID (b) ? -1 : +1;
+if (DECL_UID (a) != DECL_UID (b))
+return DECL_UID (a) < DECL_UID (b) ? -1 : +1;
+gcc_assert (a == b);
+return 0;
 }
 static struct {
 gt_pointer_operator new_value;
 void *cookie;
 {
 if (vec<tree, va_gc> *member_vec = (vec<tree, va_gc> *) obj)
 {
 resort_data.new_value = new_value;
 resort_data.cookie = cookie;
-qsort (member_vec->address (), member_vec->length (),
+member_vec->qsort (resort_member_name_cmp);
-	     sizeof (tree), resort_member_name_cmp);
 }
 }
 /* Recursively count the number of fields in KLASS, including anonymous
 union members.  */
 member_vec_dedup (vec<tree, va_gc> *member_vec)
 {
 unsigned len = member_vec->length ();
 unsigned store = 0;
-tree current = (*member_vec)[0], name = OVL_NAME (current);
+if (!len)
-tree next = NULL_TREE, next_name = NULL_TREE;
+return;
-for (unsigned jx, ix = 0; ix < len;
-ix = jx, current = next, name = next_name)
+tree name = OVL_NAME ((*member_vec)[0]);
-{
+for (unsigned jx, ix = 0; ix < len; ix = jx)
+{
+tree current = NULL_TREE;
 tree to_type = NULL_TREE;
 tree to_using = NULL_TREE;
 tree marker = NULL_TREE;
-if (IDENTIFIER_CONV_OP_P (name))
-	{
+for (jx = ix; jx < len; jx++)
-	  marker = current;
+	{
-	  current = OVL_CHAIN (current);
+	  tree next = (*member_vec)[jx];
-	  name = DECL_NAME (OVL_FUNCTION (marker));
+	  if (jx != ix)
-	  gcc_checking_assert (name == conv_op_identifier);
-	}
-if (TREE_CODE (current) == USING_DECL)
-	{
-	  current = strip_using_decl (current);
-	  if (is_overloaded_fn (current))
-	    current = NULL_TREE;
-	  else if (TREE_CODE (current) == USING_DECL)
 	    {
-	      to_using = current;
+	      tree next_name = OVL_NAME (next);
-	      current = NULL_TREE;
+	      if (next_name != name)
+		{
+		  name = next_name;
+		  break;
+		}
 	    }
-	}
+	  if (IDENTIFIER_CONV_OP_P (name))
-if (current && DECL_DECLARES_TYPE_P (current))
-	{
-	  to_type = current;
-	  current = NULL_TREE;
-	}
-for (jx = ix + 1; jx < len; jx++)
-	{
-	  next = (*member_vec)[jx];
-	  next_name = OVL_NAME (next);
-	  if (next_name != name)
-	    break;
-	  if (marker)
 	    {
-	      gcc_checking_assert (OVL_FUNCTION (marker)
+	      marker = next;
-				   == OVL_FUNCTION (next));
 	      next = OVL_CHAIN (next);
 	    }
 	  if (TREE_CODE (next) == USING_DECL)
 	    {
+	      if (IDENTIFIER_CTOR_P (name))
+		/* Dependent inherited ctor. */
+		continue;
 	      next = strip_using_decl (next);
-	      if (is_overloaded_fn (next))
+	      if (TREE_CODE (next) == USING_DECL)
-		next = NULL_TREE;
-	      else if (TREE_CODE (next) == USING_DECL)
 		{
 		  to_using = next;
-		  next = NULL_TREE;
+		  continue;
 		}
+	      if (is_overloaded_fn (next))
+		continue;
 	    }
-	  if (next && DECL_DECLARES_TYPE_P (next))
+	  if (DECL_DECLARES_TYPE_P (next))
-	    to_type = next;
+	    {
+	      to_type = next;
+	      continue;
+	    }
+	  if (!current)
+	    current = next;
 	}
 if (to_using)
 	{
 	  if (!current)
 	    current = to_type;
 	  else
 	    current = stat_hack (current, to_type);
 	}
-gcc_assert (current);
+if (current)
-if (marker)
+	{
-	{
+	  if (marker)
-	  OVL_CHAIN (marker) = current;
+	    {
-	  current = marker;
+	      OVL_CHAIN (marker) = current;
-	}
+	      current = marker;
-(*member_vec)[store++] = current;
+	    }
+	  (*member_vec)[store++] = current;
+	}
 }
 while (store++ < len)
 member_vec->pop ();
 }
 }
 if (member_vec)
 {
 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
-qsort (member_vec->address (), member_vec->length (),
+member_vec->qsort (member_name_cmp);
-	     sizeof (tree), member_name_cmp);
 member_vec_dedup (member_vec);
 }
 }
 /* Insert lately defined enum ENUMTYPE into KLASS for the sorted case.  */
 if (CLASSTYPE_MEMBER_VEC (klass))
 	member_vec_append_enum_values (member_vec, enumtype);
 else
 	member_vec_append_class_fields (member_vec, klass);
 CLASSTYPE_MEMBER_VEC (klass) = member_vec;
-qsort (member_vec->address (), member_vec->length (),
+member_vec->qsort (member_name_cmp);
-	     sizeof (tree), member_name_cmp);
 member_vec_dedup (member_vec);
 }
 }
 /* Compute the chain index of a binding_entry given the HASH value of its
 }
 done:
 if (to_val)
 {
-if (level->kind != sk_namespace
+if (level->kind == sk_namespace || to_type == decl || to_val == decl)
-	  && !to_type && binding->value && OVL_P (to_val))
+	add_decl_to_level (level, decl);
-	update_local_overload (binding, to_val);
 else
 	{
-	  tree to_add = to_val;
+	  gcc_checking_assert (binding->value && OVL_P (binding->value));
+	  update_local_overload (binding, to_val);
-	  if (level->kind == sk_namespace)
-	    to_add = decl;
-	  else if (to_type == decl)
-	    to_add = decl;
-	  else if (TREE_CODE (to_add) == OVERLOAD)
-	    to_add = build_tree_list (NULL_TREE, to_add);
-	  add_decl_to_level (level, to_add);
 	}
 if (slot)
 	{
 	  if (STAT_HACK_P (*slot))
 static void
 check_extern_c_conflict (tree decl)
 {
 /* Ignore artificial or system header decls.  */
 if (DECL_ARTIFICIAL (decl) || DECL_IN_SYSTEM_HEADER (decl))
+return;
+/* This only applies to decls at namespace scope.  */
+if (!DECL_NAMESPACE_SCOPE_P (decl))
 return;
 if (!extern_c_decls)
 extern_c_decls = hash_table<named_decl_hash>::create_ggc (127);
 else if (DECL_ASSEMBLER_NAME_SET_P (old))
 	SET_DECL_ASSEMBLER_NAME (decl, DECL_ASSEMBLER_NAME (old));
 if (mismatch)
 	{
+	  auto_diagnostic_group d;
 	  pedwarn (input_location, 0,
 		   "conflicting C language linkage declaration %q#D", decl);
 	  inform (DECL_SOURCE_LOCATION (old),
 		  "previous declaration %q#D", old);
 	  if (mismatch < 0)
 }
 return NULL_TREE;
 }
+/* Subroutine of check_local_shadow.  */
+static void
+inform_shadowed (tree shadowed)
+{
+inform (DECL_SOURCE_LOCATION (shadowed),
+	  "shadowed declaration is here");
+}
 /* DECL is being declared at a local scope.  Emit suitable shadow
 warnings.  */
 static void
 check_local_shadow (tree decl)
 /* Don't complain about the parms we push and then pop
 while tentatively parsing a function declarator.  */
 if (TREE_CODE (decl) == PARM_DECL && !DECL_CONTEXT (decl))
 return;
-/* Inline decls shadow nothing.  */
-if (DECL_FROM_INLINE (decl))
-return;
 /* External decls are something else.  */
 if (DECL_EXTERNAL (decl))
 return;
 tree old = NULL_TREE;
 if (cxx_binding *binding = outer_binding (DECL_NAME (decl), NULL, true))
 {
 old = binding->value;
 old_scope = binding->scope;
 }
-while (old && VAR_P (old) && DECL_DEAD_FOR_LOCAL (old))
-old = DECL_SHADOWED_FOR_VAR (old);
-tree shadowed = NULL_TREE;
 if (old
 && (TREE_CODE (old) == PARM_DECL
 	  || VAR_P (old)
 	  || (TREE_CODE (old) == TYPE_DECL
 	      && (!DECL_ARTIFICIAL (old)
 		  || TREE_CODE (decl) == TYPE_DECL)))
+&& DECL_FUNCTION_SCOPE_P (old)
 && (!DECL_ARTIFICIAL (decl)
+	  || is_capture_proxy (decl)
 	  || DECL_IMPLICIT_TYPEDEF_P (decl)
 	  || (VAR_P (decl) && DECL_ANON_UNION_VAR_P (decl))))
 {
 /* DECL shadows a local thing possibly of interest.  */
+/* DR 2211: check that captures and parameters
+	 do not have the same name. */
+if (is_capture_proxy (decl))
+	{
+	  if (current_lambda_expr ()
+	      && DECL_CONTEXT (old) == lambda_function (current_lambda_expr ())
+	      && TREE_CODE (old) == PARM_DECL
+	      && DECL_NAME (decl) != this_identifier)
+	    {
+	      error_at (DECL_SOURCE_LOCATION (old),
+			"lambda parameter %qD "
+			"previously declared as a capture", old);
+	    }
+	  return;
+	}
 /* Don't complain if it's from an enclosing function.  */
-if (DECL_CONTEXT (old) == current_function_decl
+else if (DECL_CONTEXT (old) == current_function_decl
 	  && TREE_CODE (decl) != PARM_DECL
 	  && TREE_CODE (old) == PARM_DECL)
 	{
 	  /* Go to where the parms should be and see if we find
 	     them there.  */
 	 detected elsewhere.  */
 else if (VAR_P (old)
 	       && old_scope == current_binding_level->level_chain
 	       && (old_scope->kind == sk_cond || old_scope->kind == sk_for))
 	{
+	  auto_diagnostic_group d;
 	  error ("redeclaration of %q#D", decl);
 	  inform (DECL_SOURCE_LOCATION (old),
 		  "%q#D previously declared here", old);
 	  return;
 	}
 	       || (TREE_CODE (old) == PARM_DECL
 		   && (current_binding_level->kind == sk_catch
 		       || current_binding_level->level_chain->kind == sk_catch)
 		   && in_function_try_handler))
 	{
+	  auto_diagnostic_group d;
 	  if (permerror (input_location, "redeclaration of %q#D", decl))
 	    inform (DECL_SOURCE_LOCATION (old),
 		    "%q#D previously declared here", old);
 	  return;
 	}
 	warning_code = OPT_Wshadow_local;
 else if (warn_shadow_compatible_local
 	       && (same_type_p (TREE_TYPE (old), TREE_TYPE (decl))
 		   || (!dependent_type_p (TREE_TYPE (decl))
 		       && !dependent_type_p (TREE_TYPE (old))
+		       /* If the new decl uses auto, we don't yet know
+			  its type (the old type cannot be using auto
+			  at this point, without also being
+			  dependent).  This is an indication we're
+			  (now) doing the shadow checking too
+			  early.  */
+		       && !type_uses_auto (TREE_TYPE (decl))
 		       && can_convert (TREE_TYPE (old), TREE_TYPE (decl),
 				       tf_none))))
 	warning_code = OPT_Wshadow_compatible_local;
 else
 	return;
 else if (is_capture_proxy (old))
 	msg = "declaration of %qD shadows a lambda capture";
 else
 	msg = "declaration of %qD shadows a previous local";
+auto_diagnostic_group d;
 if (warning_at (input_location, warning_code, msg, decl))
-	{
+	inform_shadowed (old);
-	  shadowed = old;
-	  goto inform_shadowed;
-	}
 return;
 }
 if (!warn_shadow)
 return;
 	if (!OVL_P (member)
 	    || TREE_CODE (decl) == FUNCTION_DECL
 	    || TYPE_PTRFN_P (TREE_TYPE (decl))
 	    || TYPE_PTRMEMFUNC_P (TREE_TYPE (decl)))
 	  {
+	    auto_diagnostic_group d;
 	    if (warning_at (input_location, OPT_Wshadow,
 			    "declaration of %qD shadows a member of %qT",
 			    decl, current_nonlambda_class_type ())
 		&& DECL_P (member))
-	      {
+	      inform_shadowed (member);
-		shadowed = member;
-		goto inform_shadowed;
-	      }
 	  }
 	return;
 }
 /* Now look for a namespace shadow.  */
 	      && (!DECL_ARTIFICIAL (old)
 		  || TREE_CODE (decl) == TYPE_DECL)))
 && !instantiating_current_function_p ())
 /* XXX shadow warnings in outer-more namespaces */
 {
+auto_diagnostic_group d;
 if (warning_at (input_location, OPT_Wshadow,
 		      "declaration of %qD shadows a global declaration",
 		      decl))
-	{
+	inform_shadowed (old);
-	  shadowed = old;
-	  goto inform_shadowed;
-	}
 return;
 }
 return;
-inform_shadowed:
-inform (DECL_SOURCE_LOCATION (shadowed), "shadowed declaration is here");
 }
 /* DECL is being pushed inside function CTX.  Set its context, if
 needed.  */
 	{
 	  ns_value
 	    = find_namespace_value (current_namespace, DECL_NAME (decl));
 	  loc_value = ns_value;
 	}
-if (loc_value == error_mark_node)
+if (loc_value == error_mark_node
+	  /* An ambiguous lookup.  */
+	  || (loc_value && TREE_CODE (loc_value) == TREE_LIST))
 	loc_value = NULL_TREE;
 for (ovl_iterator iter (loc_value); iter; ++iter)
 	if (!iter.hidden_p ()
 	    && (TREE_STATIC (*iter) || DECL_EXTERNAL (*iter))
 /* Avoid repeating a lookup.  */
 if (ns_value == decl)
 	ns_value = find_namespace_value (current_namespace, DECL_NAME (decl));
-if (ns_value == error_mark_node)
+if (ns_value == error_mark_node
+	  || (ns_value && TREE_CODE (ns_value) == TREE_LIST))
 	ns_value = NULL_TREE;
 for (ovl_iterator iter (ns_value); iter; ++iter)
 	{
 	  tree other = *iter;
 	  else if (TREE_CODE (other) != TREE_CODE (decl)
 		   || ((VAR_P (decl) || matching_fn_p (other, decl))
 		       && !comptypes (TREE_TYPE (decl), TREE_TYPE (other),
 				      COMPARE_REDECLARATION)))
 	    {
+	      auto_diagnostic_group d;
 	      if (permerror (DECL_SOURCE_LOCATION (decl),
 			     "local external declaration %q#D", decl))
 		inform (DECL_SOURCE_LOCATION (other),
 			"does not match previous declaration %q#D", other);
 	      break;
 	  check_default_args (decl);
 	  if (is_friend)
 	    {
 	      if (level->kind != sk_namespace)
-		/* In a local class, a friend function declaration must
+		{
-		   find a matching decl in the innermost non-class scope.
+		  /* In a local class, a friend function declaration must
-		   [class.friend/11] */
+		     find a matching decl in the innermost non-class scope.
-		error ("friend declaration %qD in local class without "
+		     [class.friend/11] */
-		       "prior local declaration", decl);
+		  error ("friend declaration %qD in local class without "
-	      else if (!flag_friend_injection)
+			 "prior local declaration", decl);
-		/* Hide it from ordinary lookup.  */
+		  /* Don't attempt to push it.  */
-		DECL_ANTICIPATED (decl) = DECL_HIDDEN_FRIEND_P (decl) = true;
+		  return error_mark_node;
+		}
+	      /* Hide it from ordinary lookup.  */
+	      DECL_ANTICIPATED (decl) = DECL_HIDDEN_FRIEND_P (decl) = true;
 	    }
 	}
 if (level->kind != sk_namespace)
 	{
 /* And put DECL on the list of things declared by the current
 binding level.  */
 add_decl_to_level (b, decl);
 }
-/* Check to see whether or not DECL is a variable that would have been
-in scope under the ARM, but is not in scope under the ANSI/ISO
-standard.  If so, issue an error message.  If name lookup would
-work in both cases, but return a different result, this function
-returns the result of ANSI/ISO lookup.  Otherwise, it returns
-DECL.  */
-tree
-check_for_out_of_scope_variable (tree decl)
-{
-tree shadowed;
-/* We only care about out of scope variables.  */
-if (!(VAR_P (decl) && DECL_DEAD_FOR_LOCAL (decl)))
-return decl;
-shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
-? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
-while (shadowed != NULL_TREE && VAR_P (shadowed)
-	 && DECL_DEAD_FOR_LOCAL (shadowed))
-shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
-? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
-if (!shadowed)
-shadowed = find_namespace_value (current_namespace, DECL_NAME (decl));
-if (shadowed)
-{
-if (!DECL_ERROR_REPORTED (decl))
-	{
-	  warning (0, "name lookup of %qD changed", DECL_NAME (decl));
-	  warning_at (DECL_SOURCE_LOCATION (shadowed), 0,
-		      "  matches this %qD under ISO standard rules",
-		      shadowed);
-	  warning_at (DECL_SOURCE_LOCATION (decl), 0,
-		      "  matches this %qD under old rules", decl);
-	  DECL_ERROR_REPORTED (decl) = 1;
-	}
-return shadowed;
-}
-/* If we have already complained about this declaration, there's no
-need to do it again.  */
-if (DECL_ERROR_REPORTED (decl))
-return decl;
-DECL_ERROR_REPORTED (decl) = 1;
-if (TREE_TYPE (decl) == error_mark_node)
-return decl;
-if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
-{
-error ("name lookup of %qD changed for ISO %<for%> scoping",
-	     DECL_NAME (decl));
-error ("  cannot use obsolete binding at %q+D because "
-	     "it has a destructor", decl);
-return error_mark_node;
-}
-else
-{
-permerror (input_location, "name lookup of %qD changed for ISO %<for%> scoping",
-	         DECL_NAME (decl));
-if (flag_permissive)
-permerror (DECL_SOURCE_LOCATION (decl),
-		   "  using obsolete binding at %qD", decl);
-else
-	{
-	  static bool hint;
-	  if (!hint)
-	    {
-	      inform (input_location, "(if you use %<-fpermissive%> G++ will accept your code)");
-	      hint = true;
-	    }
-	}
-}
-return decl;
-}
 /* true means unconditionally make a BLOCK for the next level pushed.  */
 static bool keep_next_level_flag;
 if (scope->this_entity)
 verbatim ("%s %<%s(%E)%> %p %d\n", action, desc,
 	      scope->this_entity, (void *) scope, line);
 else
 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
-}
-/* Return the estimated initial size of the hashtable of a NAMESPACE
-scope.  */
-static inline size_t
-namespace_scope_ht_size (tree ns)
-{
-tree name = DECL_NAME (ns);
-return name == std_identifier
-? NAMESPACE_STD_HT_SIZE
-: (name == global_identifier
-? GLOBAL_SCOPE_HT_SIZE
-: NAMESPACE_ORDINARY_HT_SIZE);
 }
 /* A chain of binding_level structures awaiting reuse.  */
 static GTY((deletable)) cp_binding_level *free_binding_level;
 else
 fprintf (stderr, "<nil>\n");
 }
-void
+static void
 print_other_binding_stack (cp_binding_level *stack)
 {
 cp_binding_level *level;
 for (level = stack; !global_scope_p (level); level = level->level_chain)
 {
 static tree
 do_pushdecl_with_scope (tree x, cp_binding_level *level, bool is_friend)
 {
 cp_binding_level *b;
-tree function_decl = current_function_decl;
-current_function_decl = NULL_TREE;
 if (level->kind == sk_class)
 {
 b = class_binding_level;
 class_binding_level = level;
 pushdecl_class_level (x);
 class_binding_level = b;
 }
 else
 {
+tree function_decl = current_function_decl;
+if (level->kind == sk_namespace)
+	current_function_decl = NULL_TREE;
 b = current_binding_level;
 current_binding_level = level;
 x = pushdecl (x, is_friend);
 current_binding_level = b;
-}
+current_function_decl = function_decl;
-current_function_decl = function_decl;
+}
 return x;
 }
 /* Inject X into the local scope just before the function parms.  */
 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
 {
 /* If X is an anonymous aggregate, all of its members are
 	 treated as if they were members of the class containing the
 	 aggregate, for naming purposes.  */
-tree f;
+location_t save_location = input_location;
+tree anon = TREE_TYPE (x);
-for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = DECL_CHAIN (f))
+if (vec<tree, va_gc> *member_vec = CLASSTYPE_MEMBER_VEC (anon))
-	{
+	for (unsigned ix = member_vec->length (); ix--;)
-	  location_t save_location = input_location;
+	  {
-	  input_location = DECL_SOURCE_LOCATION (f);
+	    tree binding = (*member_vec)[ix];
-	  if (!pushdecl_class_level (f))
+	    if (STAT_HACK_P (binding))
-	    is_valid = false;
+	      {
-	  input_location = save_location;
+		if (!pushdecl_class_level (STAT_TYPE (binding)))
-	}
+		  is_valid = false;
+		binding = STAT_DECL (binding);
+	      }
+	    if (!pushdecl_class_level (binding))
+	      is_valid = false;
+	}
+else
+	for (tree f = TYPE_FIELDS (anon); f; f = DECL_CHAIN (f))
+	  if (TREE_CODE (f) == FIELD_DECL)
+	    {
+	      input_location = DECL_SOURCE_LOCATION (f);
+	      if (!pushdecl_class_level (f))
+		is_valid = false;
+	    }
+input_location = save_location;
 }
 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
 return is_valid;
 }
 bool
 handle_namespace_attrs (tree ns, tree attributes)
 {
 tree d;
 bool saw_vis = false;
+if (attributes == error_mark_node)
+return false;
 for (d = attributes; d; d = TREE_CHAIN (d))
 {
 tree name = get_attribute_name (d);
 tree args = TREE_VALUE (d);
 if (!(flags & LOOKUP_HIDDEN) && is_lambda_ignored_entity (val))
 return false;
 return true;
 }
+/* Is there a "using namespace std;" directive within USINGS?  */
+static bool
+using_directives_contain_std_p (vec<tree, va_gc> *usings)
+{
+if (!usings)
+return false;
+for (unsigned ix = usings->length (); ix--;)
+if ((*usings)[ix] == std_node)
+return true;
+return false;
+}
+/* Is there a "using namespace std;" directive within the current
+namespace (or its ancestors)?
+Compare with name_lookup::search_unqualified.  */
+static bool
+has_using_namespace_std_directive_p ()
+{
+/* Look at local using-directives.  */
+for (cp_binding_level *level = current_binding_level;
+level->kind != sk_namespace;
+level = level->level_chain)
+if (using_directives_contain_std_p (level->using_directives))
+return true;
+/* Look at this namespace and its ancestors.  */
+for (tree scope = current_namespace; scope; scope = CP_DECL_CONTEXT (scope))
+{
+if (using_directives_contain_std_p (DECL_NAMESPACE_USING (scope)))
+	return true;
+if (scope == global_namespace)
+	break;
+}
+return false;
+}
 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
 lookup failed.  Search through all available namespaces and print out
 possible candidates.  If no exact matches are found, and
 SUGGEST_MISSPELLINGS is true, then also look for near-matches and
 suggest the best near-match, if there is one.  */
 	  tree val = candidates[ix];
 	  inform (location_of (val), "  %qE", val);
 	}
 candidates.release ();
-}
+return;
-else if (!suggest_misspellings)
+}
-;
-else if (const char *fuzzy = lookup_name_fuzzy (name, FUZZY_LOOKUP_NAME))
+/* No candidates were found in the available namespaces.  */
+/* If there's a "using namespace std;" active, and this
+is one of the most common "std::" names, then it's probably a
+missing #include.  */
+if (has_using_namespace_std_directive_p ())
+if (maybe_suggest_missing_std_header (location, name))
+return;
+/* Otherwise, consider misspellings.  */
+if (!suggest_misspellings)
+return;
+if (name_hint hint = lookup_name_fuzzy (name, FUZZY_LOOKUP_NAME,
+					  location))
 {
 /* Show a spelling correction.  */
 gcc_rich_location richloc (location);
-richloc.add_fixit_replace (fuzzy);
+richloc.add_fixit_replace (hint.suggestion ());
-inform_at_rich_loc (&richloc, "suggested alternative: %qs", fuzzy);
+inform (&richloc, "suggested alternative: %qs", hint.suggestion ());
 }
 }
+/* A well-known name within the C++ standard library, returned by
+get_std_name_hint.  */
+struct std_name_hint
+{
+/* A name within "std::".  */
+const char *name;
+/* The header name defining it within the C++ Standard Library
+(with '<' and '>').  */
+const char *header;
+/* The dialect of C++ in which this was added.  */
+enum cxx_dialect min_dialect;
+};
 /* Subroutine of maybe_suggest_missing_header for handling unrecognized names
 for some of the most common names within "std::".
-Given non-NULL NAME, a name for lookup within "std::", return the header
+Given non-NULL NAME, return the std_name_hint for it, or NULL.  */
-name defining it within the C++ Standard Library (with '<' and '>'),
-or NULL.  */
+static const std_name_hint *
-static const char *
 get_std_name_hint (const char *name)
 {
-struct std_name_hint
-{
-const char *name;
-const char *header;
-};
 static const std_name_hint hints[] = {
+/* <any>.  */
+{"any", "<any>", cxx17},
+{"any_cast", "<any>", cxx17},
+{"make_any", "<any>", cxx17},
 /* <array>.  */
-{"array", "<array>"}, // C++11
+{"array", "<array>", cxx11},
+/* <atomic>.  */
+{"atomic", "<atomic>", cxx11},
+{"atomic_flag", "<atomic>", cxx11},
+/* <bitset>.  */
+{"bitset", "<bitset>", cxx11},
+/* <complex>.  */
+{"complex", "<complex>", cxx98},
+{"complex_literals", "<complex>", cxx98},
+/* <condition_variable>. */
+{"condition_variable", "<condition_variable>", cxx11},
+{"condition_variable_any", "<condition_variable>", cxx11},
 /* <deque>.  */
-{"deque", "<deque>"},
+{"deque", "<deque>", cxx98},
 /* <forward_list>.  */
-{"forward_list", "<forward_list>"},  // C++11
+{"forward_list", "<forward_list>", cxx11},
 /* <fstream>.  */
-{"basic_filebuf", "<fstream>"},
+{"basic_filebuf", "<fstream>", cxx98},
-{"basic_ifstream", "<fstream>"},
+{"basic_ifstream", "<fstream>", cxx98},
-{"basic_ofstream", "<fstream>"},
+{"basic_ofstream", "<fstream>", cxx98},
-{"basic_fstream", "<fstream>"},
+{"basic_fstream", "<fstream>", cxx98},
+{"fstream", "<fstream>", cxx98},
+{"ifstream", "<fstream>", cxx98},
+{"ofstream", "<fstream>", cxx98},
+/* <functional>.  */
+{"bind", "<functional>", cxx11},
+{"function", "<functional>", cxx11},
+{"hash", "<functional>", cxx11},
+{"mem_fn", "<functional>", cxx11},
+/* <future>. */
+{"async", "<future>", cxx11},
+{"future", "<future>", cxx11},
+{"packaged_task", "<future>", cxx11},
+{"promise", "<future>", cxx11},
 /* <iostream>.  */
-{"cin", "<iostream>"},
+{"cin", "<iostream>", cxx98},
-{"cout", "<iostream>"},
+{"cout", "<iostream>", cxx98},
-{"cerr", "<iostream>"},
+{"cerr", "<iostream>", cxx98},
-{"clog", "<iostream>"},
+{"clog", "<iostream>", cxx98},
-{"wcin", "<iostream>"},
+{"wcin", "<iostream>", cxx98},
-{"wcout", "<iostream>"},
+{"wcout", "<iostream>", cxx98},
-{"wclog", "<iostream>"},
+{"wclog", "<iostream>", cxx98},
+/* <istream>.  */
+{"istream", "<istream>", cxx98},
+/* <iterator>.  */
+{"advance", "<iterator>", cxx98},
+{"back_inserter", "<iterator>", cxx98},
+{"begin", "<iterator>", cxx11},
+{"distance", "<iterator>", cxx98},
+{"end", "<iterator>", cxx11},
+{"front_inserter", "<iterator>", cxx98},
+{"inserter", "<iterator>", cxx98},
+{"istream_iterator", "<iterator>", cxx98},
+{"istreambuf_iterator", "<iterator>", cxx98},
+{"iterator_traits", "<iterator>", cxx98},
+{"move_iterator", "<iterator>", cxx11},
+{"next", "<iterator>", cxx11},
+{"ostream_iterator", "<iterator>", cxx98},
+{"ostreambuf_iterator", "<iterator>", cxx98},
+{"prev", "<iterator>", cxx11},
+{"reverse_iterator", "<iterator>", cxx98},
+/* <ostream>.  */
+{"ostream", "<ostream>", cxx98},
 /* <list>.  */
-{"list", "<list>"},
+{"list", "<list>", cxx98},
 /* <map>.  */
-{"map", "<map>"},
+{"map", "<map>", cxx98},
-{"multimap", "<map>"},
+{"multimap", "<map>", cxx98},
+/* <memory>.  */
+{"make_shared", "<memory>", cxx11},
+{"make_unique", "<memory>", cxx11},
+{"shared_ptr", "<memory>", cxx11},
+{"unique_ptr", "<memory>", cxx11},
+{"weak_ptr", "<memory>", cxx11},
+/* <mutex>.  */
+{"mutex", "<mutex>", cxx11},
+{"timed_mutex", "<mutex>", cxx11},
+{"recursive_mutex", "<mutex>", cxx11},
+{"recursive_timed_mutex", "<mutex>", cxx11},
+{"once_flag", "<mutex>", cxx11},
+{"call_once,", "<mutex>", cxx11},
+{"lock", "<mutex>", cxx11},
+{"scoped_lock", "<mutex>", cxx17},
+{"try_lock", "<mutex>", cxx11},
+{"lock_guard", "<mutex>", cxx11},
+{"unique_lock", "<mutex>", cxx11},
+/* <optional>. */
+{"optional", "<optional>", cxx17},
+{"make_optional", "<optional>", cxx17},
+/* <ostream>.  */
+{"ostream", "<ostream>", cxx98},
+{"wostream", "<ostream>", cxx98},
+{"ends", "<ostream>", cxx98},
+{"flush", "<ostream>", cxx98},
+{"endl", "<ostream>", cxx98},
 /* <queue>.  */
-{"queue", "<queue>"},
+{"queue", "<queue>", cxx98},
-{"priority_queue", "<queue>"},
+{"priority_queue", "<queue>", cxx98},
-/* <ostream>.  */
-{"ostream", "<ostream>"},
-{"wostream", "<ostream>"},
-{"ends", "<ostream>"},
-{"flush", "<ostream>"},
-{"endl", "<ostream>"},
 /* <set>.  */
-{"set", "<set>"},
+{"set", "<set>", cxx98},
-{"multiset", "<set>"},
+{"multiset", "<set>", cxx98},
+/* <shared_mutex>.  */
+{"shared_lock", "<shared_mutex>", cxx14},
+{"shared_mutex", "<shared_mutex>", cxx17},
+{"shared_timed_mutex", "<shared_mutex>", cxx14},
 /* <sstream>.  */
-{"basic_stringbuf", "<sstream>"},
+{"basic_stringbuf", "<sstream>", cxx98},
-{"basic_istringstream", "<sstream>"},
+{"basic_istringstream", "<sstream>", cxx98},
-{"basic_ostringstream", "<sstream>"},
+{"basic_ostringstream", "<sstream>", cxx98},
-{"basic_stringstream", "<sstream>"},
+{"basic_stringstream", "<sstream>", cxx98},
+{"istringstream", "<sstream>", cxx98},
+{"ostringstream", "<sstream>", cxx98},
+{"stringstream", "<sstream>", cxx98},
 /* <stack>.  */
-{"stack", "<stack>"},
+{"stack", "<stack>", cxx98},
 /* <string>.  */
-{"string", "<string>"},
+{"basic_string", "<string>", cxx98},
-{"wstring", "<string>"},
+{"string", "<string>", cxx98},
-{"u16string", "<string>"},
+{"wstring", "<string>", cxx98},
-{"u32string", "<string>"},
+{"u16string", "<string>", cxx11},
+{"u32string", "<string>", cxx11},
+/* <string_view>.  */
+{"string_view", "<string_view>", cxx17},
+/* <thread>.  */
+{"thread", "<thread>", cxx11},
+/* <tuple>.  */
+{"make_tuple", "<tuple>", cxx11},
+{"tuple", "<tuple>", cxx11},
+{"tuple_element", "<tuple>", cxx11},
+{"tuple_size", "<tuple>", cxx11},
 /* <unordered_map>.  */
-{"unordered_map", "<unordered_map>"}, // C++11
+{"unordered_map", "<unordered_map>", cxx11},
-{"unordered_multimap", "<unordered_map>"}, // C++11
+{"unordered_multimap", "<unordered_map>", cxx11},
 /* <unordered_set>.  */
-{"unordered_set", "<unordered_set>"}, // C++11
+{"unordered_set", "<unordered_set>", cxx11},
-{"unordered_multiset", "<unordered_set>"}, // C++11
+{"unordered_multiset", "<unordered_set>", cxx11},
+/* <utility>.  */
+{"declval", "<utility>", cxx11},
+{"forward", "<utility>", cxx11},
+{"make_pair", "<utility>", cxx98},
+{"move", "<utility>", cxx11},
+{"pair", "<utility>", cxx98},
+/* <variant>.  */
+{"variant", "<variant>", cxx17},
+{"visit", "<variant>", cxx17},
 /* <vector>.  */
-{"vector", "<vector>"},
+{"vector", "<vector>", cxx98},
 };
 const size_t num_hints = sizeof (hints) / sizeof (hints[0]);
 for (size_t i = 0; i < num_hints; i++)
 {
-if (0 == strcmp (name, hints[i].name))
+if (strcmp (name, hints[i].name) == 0)
-	return hints[i].header;
+	return &hints[i];
 }
 return NULL;
+}
+/* Describe DIALECT.  */
+static const char *
+get_cxx_dialect_name (enum cxx_dialect dialect)
+{
+switch (dialect)
+{
+default:
+gcc_unreachable ();
+case cxx98:
+return "C++98";
+case cxx11:
+return "C++11";
+case cxx14:
+return "C++14";
+case cxx17:
+return "C++17";
+case cxx2a:
+return "C++2a";
+}
+}
+/* Suggest pertinent header files for NAME at LOCATION, for common
+names within the "std" namespace.
+Return true iff a suggestion was offered.  */
+static bool
+maybe_suggest_missing_std_header (location_t location, tree name)
+{
+gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
+const char *name_str = IDENTIFIER_POINTER (name);
+const std_name_hint *header_hint = get_std_name_hint (name_str);
+if (!header_hint)
+return false;
+gcc_rich_location richloc (location);
+if (cxx_dialect >= header_hint->min_dialect)
+{
+const char *header = header_hint->header;
+maybe_add_include_fixit (&richloc, header, true);
+inform (&richloc,
+	      "%<std::%s%> is defined in header %qs;"
+	      " did you forget to %<#include %s%>?",
+	      name_str, header, header);
+}
+else
+{
+inform (&richloc,
+	      "%<std::%s%> is only available from %s onwards",
+	      name_str, get_cxx_dialect_name (header_hint->min_dialect));
+}
+return true;
 }
 /* If SCOPE is the "std" namespace, then suggest pertinent header
 files for NAME at LOCATION.
 Return true iff a suggestion was offered.  */
 if (TREE_CODE (scope) != NAMESPACE_DECL)
 return false;
 /* We only offer suggestions for the "std" namespace.  */
 if (scope != std_node)
 return false;
-gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
+return maybe_suggest_missing_std_header (location, name);
-const char *name_str = IDENTIFIER_POINTER (name);
-const char *header_hint = get_std_name_hint (name_str);
-if (!header_hint)
-return false;
-gcc_rich_location richloc (location);
-maybe_add_include_fixit (&richloc, header_hint);
-inform_at_rich_loc (&richloc,
-		      "%<std::%s%> is defined in header %qs;"
-		      " did you forget to %<#include %s%>?",
-		      name_str, header_hint, header_hint);
-return true;
 }
 /* Look for alternatives for NAME, an IDENTIFIER_NODE for which name
 lookup failed within the explicitly provided SCOPE.  Suggest the
 the best meaningful candidates (if any) as a fix-it hint.
 bool
 suggest_alternative_in_explicit_scope (location_t location, tree name,
 				       tree scope)
 {
+/* Something went very wrong; don't suggest anything.  */
+if (name == error_mark_node)
+return false;
 /* Resolve any namespace aliases.  */
 scope = ORIGINAL_NAMESPACE (scope);
 if (maybe_suggest_missing_header (location, name, scope))
 return true;
 const char *fuzzy_name = bm.get_best_meaningful_candidate ();
 if (fuzzy_name)
 {
 gcc_rich_location richloc (location);
 richloc.add_fixit_replace (fuzzy_name);
-inform_at_rich_loc (&richloc, "suggested alternative: %qs",
+inform (&richloc, "suggested alternative: %qs",
-			  fuzzy_name);
+	      fuzzy_name);
 return true;
 }
 return false;
 }
 	  = lookup_member_fuzzy (type, name, want_type_p);
 	if (best_matching_field)
 	  bm.consider (IDENTIFIER_POINTER (best_matching_field));
 }
+/* Only suggest names reserved for the implementation if NAME begins
+with an underscore.  */
+bool consider_implementation_names = (IDENTIFIER_POINTER (name)[0] == '_');
 for (tree t = lvl->names; t; t = TREE_CHAIN (t))
 {
 tree d = t;
 /* OVERLOADs or decls from using declaration are wrapped into
 if (TREE_TYPE (d) == error_mark_node)
 	continue;
 /* Skip anticipated decls of builtin functions.  */
 if (TREE_CODE (d) == FUNCTION_DECL
-	  && DECL_BUILT_IN (d)
+	  && fndecl_built_in_p (d)
 	  && DECL_ANTICIPATED (d))
 	continue;
-if (tree name = DECL_NAME (d))
+/* Skip compiler-generated variables (e.g. __for_begin/__for_end
-	/* Ignore internal names with spaces in them.  */
+	 within range for).  */
-	if (!strchr (IDENTIFIER_POINTER (name), ' '))
+if (TREE_CODE (d) == VAR_DECL
-	  bm.consider (IDENTIFIER_POINTER (name));
+	  && DECL_ARTIFICIAL (d))
+	continue;
+tree suggestion = DECL_NAME (d);
+if (!suggestion)
+	continue;
+/* Don't suggest names that are for anonymous aggregate types, as
+	 they are an implementation detail generated by the compiler.  */
+if (anon_aggrname_p (suggestion))
+	continue;
+const char *suggestion_str = IDENTIFIER_POINTER (suggestion);
+/* Ignore internal names with spaces in them.  */
+if (strchr (suggestion_str, ' '))
+	continue;
+/* Don't suggest names that are reserved for use by the
+	 implementation, unless NAME began with an underscore.  */
+if (name_reserved_for_implementation_p (suggestion_str)
+	  && !consider_implementation_names)
+	continue;
+bm.consider (suggestion_str);
+}
+}
+/* Subclass of deferred_diagnostic.  Notify the user that the
+given macro was used before it was defined.
+This can be done in the C++ frontend since tokenization happens
+upfront.  */
+class macro_use_before_def : public deferred_diagnostic
+{
+public:
+/* Factory function.  Return a new macro_use_before_def instance if
+appropriate, or return NULL. */
+static macro_use_before_def *
+maybe_make (location_t use_loc, cpp_hashnode *macro)
+{
+source_location def_loc = cpp_macro_definition_location (macro);
+if (def_loc == UNKNOWN_LOCATION)
+return NULL;
+/* We only want to issue a note if the macro was used *before* it was
+defined.
+We don't want to issue a note for cases where a macro was incorrectly
+used, leaving it unexpanded (e.g. by using the wrong argument
+count).  */
+if (!linemap_location_before_p (line_table, use_loc, def_loc))
+return NULL;
+return new macro_use_before_def (use_loc, macro);
+}
+private:
+/* Ctor.  LOC is the location of the usage.  MACRO is the
+macro that was used.  */
+macro_use_before_def (location_t loc, cpp_hashnode *macro)
+: deferred_diagnostic (loc), m_macro (macro)
+{
+gcc_assert (macro);
+}
+~macro_use_before_def ()
+{
+if (is_suppressed_p ())
+return;
+inform (get_location (), "the macro %qs had not yet been defined",
+	    (const char *)m_macro->ident.str);
+inform (cpp_macro_definition_location (m_macro),
+	    "it was later defined here");
+}
+private:
+cpp_hashnode *m_macro;
+};
+/* Determine if it can ever make sense to offer RID as a suggestion for
+a misspelling.
+Subroutine of lookup_name_fuzzy.  */
+static bool
+suggest_rid_p  (enum rid rid)
+{
+switch (rid)
+{
+/* Support suggesting function-like keywords.  */
+case RID_STATIC_ASSERT:
+return true;
+default:
+/* Support suggesting the various decl-specifier words, to handle
+	 e.g. "singed" vs "signed" typos.  */
+if (cp_keyword_starts_decl_specifier_p (rid))
+	return true;
+/* Otherwise, don't offer it.  This avoids suggesting e.g. "if"
+	 and "do" for short misspellings, which are likely to lead to
+	 nonsensical results.  */
+return false;
 }
 }
 /* Search for near-matches for NAME within the current bindings, and within
 macro names, returning the best match as a const char *, or NULL if
-no reasonable match is found.  */
+no reasonable match is found.
-const char *
+Use LOC for any deferred diagnostics.  */
-lookup_name_fuzzy (tree name, enum lookup_name_fuzzy_kind kind)
+name_hint
+lookup_name_fuzzy (tree name, enum lookup_name_fuzzy_kind kind, location_t loc)
 {
 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
+/* First, try some well-known names in the C++ standard library, in case
+the user forgot a #include.  */
+const char *header_hint
+= get_cp_stdlib_header_for_name (IDENTIFIER_POINTER (name));
+if (header_hint)
+return name_hint (NULL,
+		      new suggest_missing_header (loc,
+						  IDENTIFIER_POINTER (name),
+						  header_hint));
 best_match <tree, const char *> bm (name);
 cp_binding_level *lvl;
 for (lvl = scope_chain->class_bindings; lvl; lvl = lvl->level_chain)
 best_macro_match bmm (name, bm.get_best_distance (), parse_in);
 cpp_hashnode *best_macro = bmm.get_best_meaningful_candidate ();
 /* If a macro is the closest so far to NAME, consider it.  */
 if (best_macro)
 bm.consider ((const char *)best_macro->ident.str);
+else if (bmm.get_best_distance () == 0)
+{
+/* If we have an exact match for a macro name, then either the
+	 macro was used with the wrong argument count, or the macro
+	 has been used before it was defined.  */
+if (cpp_hashnode *macro = bmm.blithely_get_best_candidate ())
+	if (cpp_user_macro_p (macro))
+	  return name_hint (NULL,
+			    macro_use_before_def::maybe_make (loc, macro));
+}
 /* Try the "starts_decl_specifier_p" keywords to detect
 "singed" vs "signed" typos.  */
 for (unsigned i = 0; i < num_c_common_reswords; i++)
 {
 const c_common_resword *resword = &c_common_reswords[i];
-if (kind == FUZZY_LOOKUP_TYPENAME)
+if (!suggest_rid_p (resword->rid))
-	if (!cp_keyword_starts_decl_specifier_p (resword->rid))
+	continue;
-	  continue;
 tree resword_identifier = ridpointers [resword->rid];
 if (!resword_identifier)
 	continue;
 gcc_assert (TREE_CODE (resword_identifier) == IDENTIFIER_NODE);
 	continue;
 bm.consider (IDENTIFIER_POINTER (resword_identifier));
 }
-return bm.get_best_meaningful_candidate ();
+return name_hint (bm.get_best_meaningful_candidate (), NULL);
 }
 /* Subroutine of outer_binding.
 Returns TRUE if BINDING is a binding to a template parameter of
 do_pushtag (tree name, tree type, tag_scope scope)
 {
 tree decl;
 cp_binding_level *b = current_binding_level;
-while (/* Cleanup scopes are not scopes from the point of view of
+while (true)
-	    the language.  */
+{
-	 b->kind == sk_cleanup
+if (/* Cleanup scopes are not scopes from the point of view of
-	 /* Neither are function parameter scopes.  */
+	     the language.  */
-	 || b->kind == sk_function_parms
+	  b->kind == sk_cleanup
-	 /* Neither are the scopes used to hold template parameters
+	  /* Neither are function parameter scopes.  */
-	    for an explicit specialization.  For an ordinary template
+	  || b->kind == sk_function_parms
-	    declaration, these scopes are not scopes from the point of
+	  /* Neither are the scopes used to hold template parameters
-	    view of the language.  */
+	     for an explicit specialization.  For an ordinary template
-	 || (b->kind == sk_template_parms
+	     declaration, these scopes are not scopes from the point of
-	     && (b->explicit_spec_p || scope == ts_global))
+	     view of the language.  */
-	 /* Pushing into a class is ok for lambdas or when we want current  */
+	  || (b->kind == sk_template_parms
-	 || (b->kind == sk_class
+	      && (b->explicit_spec_p || scope == ts_global)))
-	     && scope != ts_lambda
+	b = b->level_chain;
-	     && (scope != ts_current
+else if (b->kind == sk_class
-		 /* We may be defining a new type in the initializer
+	       && scope != ts_current)
-		    of a static member variable. We allow this when
+	{
-		    not pedantic, and it is particularly useful for
+	  b = b->level_chain;
-		    type punning via an anonymous union.  */
+	  if (b->kind == sk_template_parms)
-		 || COMPLETE_TYPE_P (b->this_entity))))
+	    b = b->level_chain;
-b = b->level_chain;
+	}
+else
+	break;
+}
 gcc_assert (identifier_p (name));
 /* Do C++ gratuitous typedefing.  */
 if (identifier_type_value_1 (name) != type)
 int in_class = 0;
 tree context = TYPE_CONTEXT (type);
 if (! context)
 	{
-	  tree cs = current_scope ();
+	  cp_binding_level *cb = b;
+	  while (cb->kind != sk_namespace
+		 && cb->kind != sk_class
+		 && (cb->kind != sk_function_parms
+		     || !cb->this_entity))
+	    cb = cb->level_chain;
+	  tree cs = cb->this_entity;
+	  gcc_checking_assert (TREE_CODE (cs) == FUNCTION_DECL
+			       ? cs == current_function_decl
+			       : TYPE_P (cs) ? cs == current_class_type
+			       : cs == current_namespace);
 	  if (scope == ts_current
-	      || scope == ts_lambda
 	      || (cs && TREE_CODE (cs) == FUNCTION_DECL))
 	    context = cs;
 	  else if (cs && TYPE_P (cs))
 	    /* When declaring a friend class of a local class, we want
 	       to inject the newly named class into the scope
 if (decl == error_mark_node)
 	return decl;
 if (b->kind == sk_class)
 	{
-	  if (!TYPE_BEING_DEFINED (current_class_type)
+	  if (!TYPE_BEING_DEFINED (current_class_type))
-	      && scope != ts_lambda)
+	    /* Don't push anywhere if the class is complete; a lambda in an
-	    return error_mark_node;
+	       NSDMI is not a member of the class.  */
+	    ;
-	  if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
+	  else if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
 	    /* Put this TYPE_DECL on the TYPE_FIELDS list for the
 	       class.  But if it's a member template class, we want
 	       the TEMPLATE_DECL, not the TYPE_DECL, so this is done
 	       later.  */
 	    finish_member_declaration (decl);
 	  if (DECL_CONTEXT (decl) == std_node
 	      && init_list_identifier == DECL_NAME (TYPE_NAME (type))
 	      && !CLASSTYPE_TEMPLATE_INFO (type))
 	    {
-	      error ("declaration of std::initializer_list does not match "
+	      error ("declaration of %<std::initializer_list%> does not match "
-		     "#include <initializer_list>, isn't a template");
+		     "%<#include <initializer_list>%>, isn't a template");
 	      return error_mark_node;
 	    }
 	}
 if (! in_class)
 	    {
 	      /* Push a DECL_EXPR so we call pushtag at the right time in
 		 template instantiation rather than in some nested context.  */
 	      add_decl_expr (decl);
 	    }
-	  else
+	  /* Lambdas use LAMBDA_EXPR_DISCRIMINATOR instead.  */
+	  else if (!LAMBDA_TYPE_P (type))
 	    vec_safe_push (local_classes, type);
 	}
 }
 if (b->kind == sk_class
 s->inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
 s->x_stmt_tree.stmts_are_full_exprs_p = true;
 scope_chain = s;
 current_function_decl = NULL_TREE;
-vec_alloc (current_lang_base, 10);
+current_lang_base = NULL;
 current_lang_name = lang_name_cplusplus;
 current_namespace = global_namespace;
 push_class_stack ();
 cp_unevaluated_operand = 0;
 c_inhibit_evaluation_warnings = 0;
 /* Clear out class-level bindings cache.  */
 if (previous_class_level)
 invalidate_class_lookup_cache ();
 pop_class_stack ();
-current_lang_base = 0;
+release_tree_vector (current_lang_base);
 scope_chain = s->prev;
 FOR_EACH_VEC_SAFE_ELT (s->old_bindings, i, saved)
 {
 tree id = saved->identifier;
 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
 of a builtin function.  */
 if (TREE_CODE (t) == FUNCTION_DECL
 && DECL_EXTERNAL (t)
-&& DECL_BUILT_IN (t))
+&& fndecl_built_in_p (t))
 return;
 /* Do not supply context to imported_module_or_decl, if
 it is a global namespace.  */
 if (context == global_namespace)

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cp/name-lookup.c @ 131:84e7813d76e9