c++: Implement C++20 'using enum'. [PR91367]

This feature allows the programmer to import enumerator names into the
current scope so later mentions don't need to use the fully-qualified name.
These usings are not subject to the usual restrictions on using-decls: in
particular, they can move between class and non-class scopes, and between
classes that are not related by inheritance.  This last caused difficulty
for our normal approach to using-decls within a class hierarchy, as we
assume that the class where we looked up a used declaration is derived from
the class where it was first declared.  So to simplify things, in that case
we make a clone of the CONST_DECL in the using class.

Thanks to Nathan for the start of this work: in particular, the
lookup_using_decl rewrite.

The changes to dwarf2out revealed an existing issue with the D front-end: we
were doing the wrong thing for importing a D CONST_DECL, because
dwarf2out_imported_module_or_decl_1 was looking through it to its type,
expecting it to be an enumerator, but in one case in thread.d, the constant
had type int.  Adding the ability to import a C++ enumerator also fixed
that, but that led to a crash in force_decl_die, which didn't know what to
do with a CONST_DECL.  So now it does.

Co-authored-by: Nathan Sidwell <[email protected]>

gcc/cp/ChangeLog:

	* cp-tree.h (USING_DECL_UNRELATED_P): New.
	(CONST_DECL_USING_P): New.
	* class.c (handle_using_decl): If USING_DECL_UNRELATED_P,
	clone the CONST_DECL.
	* name-lookup.c (supplement_binding_1): A clone hides its
	using-declaration.
	(lookup_using_decl): Rewrite to separate lookup and validation.
	(do_class_using_decl): Adjust.
	(finish_nonmember_using_decl): Adjust.
	* parser.c (make_location): Add cp_token overload.
	(finish_using_decl): Split out from...
	(cp_parser_using_declaration): ...here.  Don't look through enums.
	(cp_parser_using_enum): New.
	(cp_parser_block_declaration): Call it.
	(cp_parser_member_declaration): Call it.
	* semantics.c (finish_id_expression_1): Handle enumerator
	used from class scope.

gcc/ChangeLog:

	* dwarf2out.c (gen_enumeration_type_die): Call
	equate_decl_number_to_die for enumerators.
	(gen_member_die): Don't move enumerators to their
	enclosing class.
	(dwarf2out_imported_module_or_decl_1): Allow importing
	individual enumerators.
	(force_decl_die): Handle CONST_DECL.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp0x/inh-ctor28.C: Adjust expected diagnostic.
	* g++.dg/cpp0x/inh-ctor33.C: Likewise.
	* g++.dg/cpp0x/using-enum-1.C: Add comment.
	* g++.dg/cpp0x/using-enum-2.C: Allowed in C++20.
	* g++.dg/cpp0x/using-enum-3.C: Likewise.
	* g++.dg/cpp1z/class-deduction69.C: Adjust diagnostic.
	* g++.dg/inherit/using5.C: Likewise.
	* g++.dg/cpp2a/using-enum-1.C: New test.
	* g++.dg/cpp2a/using-enum-2.C: New test.
	* g++.dg/cpp2a/using-enum-3.C: New test.
	* g++.dg/cpp2a/using-enum-4.C: New test.
	* g++.dg/cpp2a/using-enum-5.C: New test.
	* g++.dg/cpp2a/using-enum-6.C: New test.
	* g++.dg/debug/dwarf2/using-enum.C: New test.

Author: jicama

gcc/cp/class.c

@@ -1331,6 +1331,23 @@ handle_using_decl (tree using_decl, tree t)
 	add_method (t, *iter, true);
 	alter_access (t, *iter, access);
       }
+  else if (USING_DECL_UNRELATED_P (using_decl))
+    {
+      /* C++20 using enum can import non-inherited enumerators into class
+	 scope.  We implement that by making a copy of the CONST_DECL for which
+	 CONST_DECL_USING_P is true.  */
+      gcc_assert (TREE_CODE (decl) == CONST_DECL);
+
+      tree copy = copy_decl (decl);
+      DECL_CONTEXT (copy) = t;
+      DECL_ARTIFICIAL (copy) = true;
+      /* We emitted debug info for the USING_DECL above; make sure we don't
+	 also emit anything for this clone.  */
+      DECL_IGNORED_P (copy) = true;
+      DECL_SOURCE_LOCATION (copy) = DECL_SOURCE_LOCATION (using_decl);
+      finish_member_declaration (copy);
+      DECL_ABSTRACT_ORIGIN (copy) = decl;
+    }
   else
     alter_access (t, decl, access);
 }

gcc/cp/cp-tree.h

@@ -529,6 +529,7 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];
       TEMPLATE_DECL_COMPLEX_ALIAS_P (in TEMPLATE_DECL)
       DECL_INSTANTIATING_NSDMI_P (in a FIELD_DECL)
       LABEL_DECL_CDTOR (in LABEL_DECL)
+      USING_DECL_UNRELATED_P (in USING_DECL)
    3: DECL_IN_AGGR_P.
    4: DECL_C_BIT_FIELD (in a FIELD_DECL)
       DECL_ANON_UNION_VAR_P (in a VAR_DECL)
@@ -3409,6 +3410,16 @@ struct GTY(()) lang_decl {
 /* Non zero if the using decl refers to a dependent type.  */
 #define USING_DECL_TYPENAME_P(NODE) DECL_LANG_FLAG_1 (USING_DECL_CHECK (NODE))
 
+/* True if member using decl NODE refers to a non-inherited NODE.  */
+#define USING_DECL_UNRELATED_P(NODE) DECL_LANG_FLAG_2 (USING_DECL_CHECK (NODE))
+
+/* True iff the CONST_DECL is a class-scope clone from C++20 using enum,
+   created by handle_using_decl.  */
+#define CONST_DECL_USING_P(NODE)			\
+  (TREE_CODE (NODE) == CONST_DECL			\
+   && TREE_CODE (TREE_TYPE (NODE)) == ENUMERAL_TYPE	\
+   && DECL_CONTEXT (NODE) != TREE_TYPE (NODE))
+
 /* In a FUNCTION_DECL, this is nonzero if this function was defined in
    the class definition.  We have saved away the text of the function,
    but have not yet processed it.  */

gcc/cp/name-lookup.c

@@ -2125,6 +2125,10 @@ supplement_binding_1 (cxx_binding *binding, tree decl)
       region to refer only to the namespace to which it already
       refers.  */
     ok = false;
+  else if (TREE_CODE (bval) == USING_DECL
+	   && CONST_DECL_USING_P (decl))
+    /* Let the clone hide the using-decl that introduced it.  */
+    binding->value = decl;
   else
     {
       if (!error_operand_p (bval))
@@ -4540,135 +4544,217 @@ push_class_level_binding (tree name, tree x)
 /* Process and lookup a using decl SCOPE::lookup.name, filling in
    lookup.values & lookup.type.  Return true if ok.  */
 
-static bool
+static tree
 lookup_using_decl (tree scope, name_lookup &lookup)
 {
   tree current = current_scope ();
   bool dependent_p = false;
+  tree binfo = NULL_TREE;
+  base_kind b_kind = bk_not_base;
+
+  /* Because C++20 breaks the invariant that only member using-decls
+     refer to members and only non-member using-decls refer to
+     non-members, we first do the lookups, and then do validation that
+     what we found is ok.  */
+
+  if (TREE_CODE (scope) == ENUMERAL_TYPE
+      && cxx_dialect < cxx20
+      && UNSCOPED_ENUM_P (scope)
+      && !TYPE_FUNCTION_SCOPE_P (scope))
+    {
+      /* PR c++/60265 argued that since C++11 added explicit enum scope, we
+	 should allow it as meaning the enclosing scope.  I don't see any
+	 justification for this in C++11, but let's keep allowing it.  */
+      tree ctx = CP_TYPE_CONTEXT (scope);
+      if (CLASS_TYPE_P (ctx) == CLASS_TYPE_P (current))
+	scope = ctx;
+    }
 
   if (TREE_CODE (scope) == NAMESPACE_DECL)
     {
       /* Naming a namespace member.  */
-      if (TYPE_P (current))
+      qualified_namespace_lookup (scope, &lookup);
+
+      if (TYPE_P (current)
+	  && (!lookup.value
+	      || lookup.type
+	      || cxx_dialect < cxx20
+	      || TREE_CODE (lookup.value) != CONST_DECL))
 	{
 	  error ("using-declaration for non-member at class scope");
-	  return false;
+	  return NULL_TREE;
 	}
-
-      qualified_namespace_lookup (scope, &lookup);
     }
   else if (TREE_CODE (scope) == ENUMERAL_TYPE)
     {
-      error ("using-declaration may not name enumerator %<%E::%D%>",
-	     scope, lookup.name);
-      return false;
+      /* Naming an enumeration member.  */
+      if (cxx_dialect < cxx20)
+	error ("%<using%> with enumeration scope %q#T "
+	       "only available with %<-std=c++20%> or %<-std=gnu++20%>",
+	       scope);
+      lookup.value = lookup_enumerator (scope, lookup.name);
     }
   else
     {
-      /* Naming a class member.  */
-      if (!TYPE_P (current))
-	{
-	  error ("using-declaration for member at non-class scope");
-	  return false;
-	}
+      /* Naming a class member.  This is awkward in C++20, because we
+	 might be naming an enumerator of an unrelated class.  */
 
-      /* Make sure the name is not invalid */
+      /* You cannot using-decl a destructor.  */
       if (TREE_CODE (lookup.name) == BIT_NOT_EXPR)
 	{
 	  error ("%<%T::%D%> names destructor", scope, lookup.name);
-	  return false;
+	  return NULL_TREE;
 	}
 
       /* Using T::T declares inheriting ctors, even if T is a typedef.  */
       if (MAYBE_CLASS_TYPE_P (scope)
 	  && (lookup.name == TYPE_IDENTIFIER (scope)
 	      || constructor_name_p (lookup.name, scope)))
 	{
+	  if (!TYPE_P (current))
+	    {
+	      error ("non-member using-decl names constructor of %qT", scope);
+	      return NULL_TREE;
+	    }
 	  maybe_warn_cpp0x (CPP0X_INHERITING_CTORS);
 	  lookup.name = ctor_identifier;
 	  CLASSTYPE_NON_AGGREGATE (current) = true;
     	}
 
-      /* Cannot introduce a constructor name.  */
-      if (constructor_name_p (lookup.name, current))
+      if (!MAYBE_CLASS_TYPE_P (scope))
+	;
+      else if (TYPE_P (current))
 	{
-	  error ("%<%T::%D%> names constructor in %qT",
-		 scope, lookup.name, current);
-	  return false;
-	}
-
-      /* Member using decls finish processing when completing the
-	 class.  */
-      /* From [namespace.udecl]:
-
-         A using-declaration used as a member-declaration shall refer
-         to a member of a base class of the class being defined.
+	  dependent_p = dependent_scope_p (scope);
+	  if (!dependent_p)
+	    {
+	      binfo = lookup_base (current, scope, ba_any, &b_kind, tf_none);
+	      gcc_checking_assert (b_kind >= bk_not_base);
 
-         In general, we cannot check this constraint in a template
-         because we do not know the entire set of base classes of the
-         current class type. Morover, if SCOPE is dependent, it might
-         match a non-dependent base.  */
+	      if (lookup.name == ctor_identifier)
+		{
+		  /* Even if there are dependent bases, SCOPE will not
+		     be direct base, no matter.  */
+		  if (b_kind < bk_proper_base || !binfo_direct_p (binfo))
+		    {
+		      error ("%qT is not a direct base of %qT", scope, current);
+		      return NULL_TREE;
+		    }
+		}
+	      else if (b_kind < bk_proper_base)
+		binfo = TYPE_BINFO (scope);
+	      else if (IDENTIFIER_CONV_OP_P (lookup.name)
+		       && dependent_type_p (TREE_TYPE (lookup.name)))
+		dependent_p = true;
+	    }
+	}
+      else
+	binfo = TYPE_BINFO (scope);
 
-      dependent_p = dependent_scope_p (scope);
       if (!dependent_p)
 	{
-	  base_kind b_kind;
-	  tree binfo = lookup_base (current, scope, ba_any, &b_kind,
-				    tf_warning_or_error);
-	  if (b_kind < bk_proper_base)
+	  if (binfo)
+	    lookup.value = lookup_member (binfo, lookup.name, /*protect=*/2,
+					  /*want_type=*/false, tf_none);
+
+	  tree saved_value = lookup.value;
+	  if (lookup.value
+	      && b_kind < bk_proper_base)
 	    {
-	      /* If there are dependent bases, scope might resolve at
-		 instantiation time, even if it isn't exactly one of
-		 the dependent bases.  */
-	      if (b_kind == bk_same_type || !any_dependent_bases_p ())
+	      if (cxx_dialect >= cxx20
+		  && TREE_CODE (lookup.value) == CONST_DECL)
 		{
-		  error_not_base_type (scope, current);
-		  return false;
+		  /* Using an unrelated enum; check access here rather
+		     than separately for class and non-class using.  */
+		  perform_or_defer_access_check
+		    (binfo, lookup.value, lookup.value, tf_warning_or_error);
+		  /* And then if this is a copy from handle_using_decl, look
+		     through to the original enumerator.  */
+		  if (CONST_DECL_USING_P (lookup.value))
+		    lookup.value = DECL_ABSTRACT_ORIGIN (lookup.value);
 		}
-	      /* Treat as-if dependent.  */
-	      dependent_p = true;
+	      else
+		lookup.value = NULL_TREE;
 	    }
-	  else if (lookup.name == ctor_identifier && !binfo_direct_p (binfo))
+
+	  if (!lookup.value)
 	    {
-	      error ("cannot inherit constructors from indirect base %qT",
-		     scope);
-	      return false;
+	      if (!TYPE_P (current))
+		{
+		  error ("using-declaration for member at non-class scope");
+		  return NULL_TREE;
+		}
+
+	      if (b_kind < bk_proper_base)
+		{
+		  if (b_kind == bk_not_base && any_dependent_bases_p ())
+		    /* Treat as-if dependent.  */
+		    dependent_p = true;
+		  else
+		    {
+		      auto_diagnostic_group g;
+		      error_not_base_type (scope, current);
+		      if (saved_value && DECL_IMPLICIT_TYPEDEF_P (saved_value)
+			  && (TREE_CODE (TREE_TYPE (saved_value))
+			      == ENUMERAL_TYPE))
+			inform (input_location,
+				"did you mean %<using enum %T::%D%>?",
+				scope, lookup.name);
+		      return NULL_TREE;
+		    }
+		}
 	    }
-	  else if (IDENTIFIER_CONV_OP_P (lookup.name)
-		   && dependent_type_p (TREE_TYPE (lookup.name)))
-	    dependent_p = true;
-	  else
-	    lookup.value = lookup_member (binfo, lookup.name, 0,
-					  false, tf_warning_or_error);
 	}
     }
 
-  if (!dependent_p)
+  /* Did we find anything sane?  */
+  if (dependent_p)
+    ;
+  else if (!lookup.value)
     {
-      if (!lookup.value)
-	{
-	  error ("%qD has not been declared in %qE", lookup.name, scope);
-	  return false;
-	}
+      error ("%qD has not been declared in %qD", lookup.name, scope);
+      return NULL_TREE;
+    }
+  else if (TREE_CODE (lookup.value) == TREE_LIST
+	   /* We can (independently) have ambiguous implicit typedefs.  */
+	   || (lookup.type && TREE_CODE (lookup.type) == TREE_LIST))
+    {
+      error ("reference to %qD is ambiguous", lookup.name);
+      print_candidates (TREE_CODE (lookup.value) == TREE_LIST
+			? lookup.value : lookup.type);
+      return NULL_TREE;
+    }
+  else if (TREE_CODE (lookup.value) == NAMESPACE_DECL)
+    {
+      error ("using-declaration may not name namespace %qD", lookup.value);
+      return NULL_TREE;
+    }
 
-      if (TREE_CODE (lookup.value) == TREE_LIST
-	  /* We can (independently) have ambiguous implicit typedefs.  */
-	  || (lookup.type && TREE_CODE (lookup.type) == TREE_LIST))
-	{
-	  error ("reference to %qD is ambiguous", lookup.name);
-	  print_candidates (TREE_CODE (lookup.value) == TREE_LIST
-			    ? lookup.value : lookup.type);
-	  return false;
-	}
+  if (TYPE_P (current))
+    {
+      /* In class scope.  */
 
-      if (TREE_CODE (lookup.value) == NAMESPACE_DECL)
+      /* Cannot introduce a constructor name.  */
+      if (constructor_name_p (lookup.name, current))
 	{
-	  error ("using-declaration may not name namespace %qD", lookup.value);
-	  return false;
+	  error ("%<%T::%D%> names constructor in %qT",
+		 scope, lookup.name, current);
+	  return NULL_TREE;
 	}
+
+      if (lookup.value && BASELINK_P (lookup.value))
+	/* The binfo from which the functions came does not matter.  */
+	lookup.value = BASELINK_FUNCTIONS (lookup.value);
     }
 
-  return true;
+  tree using_decl = build_lang_decl (USING_DECL, lookup.name, NULL_TREE);
+  USING_DECL_SCOPE (using_decl) = scope;
+  USING_DECL_DECLS (using_decl) = lookup.value;
+  DECL_DEPENDENT_P (using_decl) = dependent_p;
+  if (TYPE_P (current) && b_kind == bk_not_base)
+    USING_DECL_UNRELATED_P (using_decl) = true;
+
+  return using_decl;
 }
 
 /* Process "using SCOPE::NAME" in a class scope.  Return the
@@ -4682,20 +4768,7 @@ do_class_using_decl (tree scope, tree name)
     return NULL_TREE;
 
   name_lookup lookup (name);
-  if (!lookup_using_decl (scope, lookup))
-    return NULL_TREE;
-
-  tree found = lookup.value;
-  if (found && BASELINK_P (found))
-    /* The binfo from which the functions came does not matter.  */
-    found = BASELINK_FUNCTIONS (found);
-
-  tree using_decl = build_lang_decl (USING_DECL, lookup.name, NULL_TREE);
-  USING_DECL_SCOPE (using_decl) = scope;
-  USING_DECL_DECLS (using_decl) = found;
-  DECL_DEPENDENT_P (using_decl) = !found;
-
-  return using_decl;
+  return lookup_using_decl (scope, lookup);
 }
 
 
@@ -5076,7 +5149,8 @@ finish_nonmember_using_decl (tree scope, tree name)
 
   name_lookup lookup (name);
 
-  if (!lookup_using_decl (scope, lookup))
+  tree using_decl = lookup_using_decl (scope, lookup);
+  if (!using_decl)
     return;
 
   /* Emit debug info.  */
@@ -5105,8 +5179,6 @@ finish_nonmember_using_decl (tree scope, tree name)
     }
   else
     {
-      tree using_decl = build_lang_decl (USING_DECL, lookup.name, NULL_TREE);
-      USING_DECL_SCOPE (using_decl) = scope;
       add_decl_expr (using_decl);
 
       cxx_binding *binding = find_local_binding (current_binding_level, name);