procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

c++: introduce TRAIT_TYPE alongside TRAIT_EXPR

Browse source 
We already have generic support for predicate-like traits that yield a
boolean value via TRAIT_EXPR, but we lack the same support for traits
that yield a type instead of a value.  Such support would streamline
implementing efficient builtins for the standard library type traits.

To that end this patch implements a generic TRAIT_TYPE type alongside
TRAIT_EXPR, and reimplements the existing UNDERLYING_TYPE builtin trait
using this new TRAIT_TYPE.

gcc/cp/ChangeLog:

	* cp-objcp-common.cc (cp_common_init_ts): Replace
	UNDERLYING_TYPE with TRAIT_TYPE.
	* cp-tree.def (TRAIT_TYPE): Define.
	(UNDERLYING_TYPE): Remove.
	* cp-tree.h (TRAIT_TYPE_KIND_RAW): Define.
	(TRAIT_TYPE_KIND): Define.
	(TRAIT_TYPE_TYPE1): Define.
	(TRAIT_TYPE_TYPE2): Define.
	(WILDCARD_TYPE_P): Return true for TRAIT_TYPE.
	(finish_trait_type): Declare.
	* cxx-pretty-print.cc (cxx_pretty_printer::primary_expression):
	Adjust after renaming pp_cxx_trait_expression.
	(cxx_pretty_printer::simple_type_specifier) <case TRAIT_TYPE>:
	New.
	(cxx_pretty_printer::type_id): Replace UNDERLYING_TYPE with
	TRAIT_TYPE.
	(pp_cxx_trait_expression): Rename to ...
	(pp_cxx_trait): ... this.  Handle TRAIT_TYPE as well.  Correct
	pretty printing of the trailing arguments.
	* cxx-pretty-print.h (pp_cxx_trait_expression): Rename to ...
	(pp_cxx_trait_type): ... this.
	* error.cc (dump_type) <case UNDERLYING_TYPE>: Remove.
	<case TRAIT_TYPE>: New.
	(dump_type_prefix): Replace UNDERLYING_WITH with TRAIT_TYPE.
	(dump_type_suffix): Likewise.
	* mangle.cc (write_type) <case UNDERLYING_TYPE>: Remove.
	<case TRAIT_TYPE>: New.
	* module.cc (trees_out::type_node) <case UNDERLYING_TYPE>:
	Remove.
	<case TRAIT_TYPE>: New.
	(trees_in::tree_node): Likewise.
	* parser.cc (cp_parser_primary_expression): Adjust after
	renaming cp_parser_trait_expr.
	(cp_parser_trait_expr): Rename to ...
	(cp_parser_trait): ... this.  Call finish_trait_type for traits
	that yield a type.
	(cp_parser_simple_type_specifier): Adjust after renaming
	cp_parser_trait_expr.
	* pt.cc (for_each_template_parm_r) <case UNDERLYING_TYPE>:
	Remove.
	<case TRAIT_TYPE>: New.
	(tsubst): Likewise.
	(unify): Replace UNDERLYING_TYPE with TRAIT_TYPE.
	(dependent_type_p_r): Likewise.
	* semantics.cc (finish_underlying_type): Don't return
	UNDERLYING_TYPE anymore when processing_template_decl.
	(finish_trait_type): Define.
	* tree.cc (strip_typedefs) <case UNDERLYING_TYPE>: Remove.
	<case TRAIT_TYPE>: New.
	(cp_walk_subtrees): Likewise.
	* typeck.cc (structural_comptypes): Likewise.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp0x/alias-decl-59.C: Adjust expected error message.
	* g++.dg/ext/underlying_type7.C: Likewise.
	* g++.dg/ext/underlying_type13.C: New test.
	* g++.dg/ext/underlying_type14.C: New test.
This commit is contained in:
Patrick Palka 2022-09-29 09:18:11 -04:00
parent df7f273650
commit 817e878a31
17 changed files with 197 additions and 78 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
gcc/cp/cp-objcp-common.cc
View file

@ -518,7 +518,7 @@ cp_common_init_ts (void)
MARK_TS_TYPE_NON_COMMON (DECLTYPE_TYPE);
MARK_TS_TYPE_NON_COMMON (TYPENAME_TYPE);
MARK_TS_TYPE_NON_COMMON (TYPEOF_TYPE);
MARK_TS_TYPE_NON_COMMON (UNDERLYING_TYPE);
MARK_TS_TYPE_NON_COMMON (TRAIT_TYPE);
MARK_TS_TYPE_NON_COMMON (BOUND_TEMPLATE_TEMPLATE_PARM);
MARK_TS_TYPE_NON_COMMON (TEMPLATE_TEMPLATE_PARM);
MARK_TS_TYPE_NON_COMMON (TEMPLATE_TYPE_PARM);

9
gcc/cp/cp-tree.def
View file

@ -444,9 +444,12 @@ DEFTREECODE (BIT_CAST_EXPR, "bit_cast_expr", tcc_expression, 1)
/** C++ extensions. */
/* Represents a trait expression during template expansion. */
/* Represents a templated trait that yields an expression. */
DEFTREECODE (TRAIT_EXPR, "trait_expr", tcc_exceptional, 0)
/* Represents a templated trait that yields a type. */
DEFTREECODE (TRAIT_TYPE, "trait_type", tcc_type, 0)
/* A lambda expression. This is a C++0x extension.
LAMBDA_EXPR_DEFAULT_CAPTURE_MODE is an enum for the default, which may be
none.
@ -466,10 +469,6 @@ DEFTREECODE (LAMBDA_EXPR, "lambda_expr", tcc_exceptional, 0)
DECLTYPE_FOR_LAMBDA_RETURN is set if we want lambda return deduction. */
DEFTREECODE (DECLTYPE_TYPE, "decltype_type", tcc_type, 0)
/* A type designated by `__underlying_type (type)'.
UNDERLYING_TYPE_TYPE is the type in question. */
DEFTREECODE (UNDERLYING_TYPE, "underlying_type", tcc_type, 0)
/* A type designated by one of the bases type traits.
BASES_TYPE is the type in question. */
DEFTREECODE (BASES, "bases", tcc_type, 0)

18
gcc/cp/cp-tree.h
View file

@ -1437,6 +1437,22 @@ struct GTY (()) tree_trait_expr {
enum cp_trait_kind kind;
};
/* An INTEGER_CST containing the kind of the trait type NODE. */
#define TRAIT_TYPE_KIND_RAW(NODE) \
TYPE_VALUES_RAW (TRAIT_TYPE_CHECK (NODE))
/* The kind of the trait type NODE. */
#define TRAIT_TYPE_KIND(NODE) \
((enum cp_trait_kind) TREE_INT_CST_LOW (TRAIT_TYPE_KIND_RAW (NODE)))
/* The first argument of the trait type NODE. */
#define TRAIT_TYPE_TYPE1(NODE) \
TYPE_MIN_VALUE_RAW (TRAIT_TYPE_CHECK (NODE))
/* The rest of the arguments of the trait type NODE. */
#define TRAIT_TYPE_TYPE2(NODE) \
TYPE_MAX_VALUE_RAW (TRAIT_TYPE_CHECK (NODE))
/* Identifiers used for lambda types are almost anonymous. Use this
spare flag to distinguish them (they also have the anonymous flag). */
#define IDENTIFIER_LAMBDA_P(NODE) \
@ -2226,6 +2242,7 @@ enum languages { lang_c, lang_cplusplus };
|| TREE_CODE (T) == TYPEOF_TYPE \
|| TREE_CODE (T) == BOUND_TEMPLATE_TEMPLATE_PARM \
|| TREE_CODE (T) == DECLTYPE_TYPE \
|| TREE_CODE (T) == TRAIT_TYPE \
|| TREE_CODE (T) == DEPENDENT_OPERATOR_TYPE)
/* Nonzero if T is a class (or struct or union) type. Also nonzero
@ -7736,6 +7753,7 @@ extern tree finish_decltype_type (tree, bool, tsubst_flags_t);
extern tree fold_builtin_is_corresponding_member (location_t, int, tree *);
extern tree fold_builtin_is_pointer_inverconvertible_with_class (location_t, int, tree *);
extern tree finish_trait_expr (location_t, enum cp_trait_kind, tree, tree);
extern tree finish_trait_type (enum cp_trait_kind, tree, tree);
extern tree build_lambda_expr (void);
extern tree build_lambda_object (tree);
extern tree begin_lambda_type (tree);

53
gcc/cp/cxx-pretty-print.cc
View file

@ -483,7 +483,7 @@ cxx_pretty_printer::primary_expression (tree t)
break;
case TRAIT_EXPR:
pp_cxx_trait_expression (this, t);
pp_cxx_trait (this, t);
break;
case VA_ARG_EXPR:
@ -1240,7 +1240,7 @@ cxx_pretty_printer::expression (tree t)
break;
case TRAIT_EXPR:
pp_cxx_trait_expression (this, t);
pp_cxx_trait (this, t);
break;
case ATOMIC_CONSTR:
@ -1385,6 +1385,10 @@ cxx_pretty_printer::simple_type_specifier (tree t)
pp_cxx_ws_string (this, "std::nullptr_t");
break;
case TRAIT_TYPE:
pp_cxx_trait (this, t);
break;
default:
c_pretty_printer::simple_type_specifier (t);
break;
@ -1876,7 +1880,7 @@ cxx_pretty_printer::type_id (tree t)
case TEMPLATE_PARM_INDEX:
case TEMPLATE_DECL:
case TYPEOF_TYPE:
case UNDERLYING_TYPE:
case TRAIT_TYPE:
case DECLTYPE_TYPE:
case NULLPTR_TYPE:
case TEMPLATE_ID_EXPR:
@ -2594,9 +2598,22 @@ pp_cxx_binary_fold_expression (cxx_pretty_printer *pp, tree t)
}
void
pp_cxx_trait_expression (cxx_pretty_printer *pp, tree t)
pp_cxx_trait (cxx_pretty_printer *pp, tree t)
{
cp_trait_kind kind = TRAIT_EXPR_KIND (t);
cp_trait_kind kind;
tree type1, type2;
if (TREE_CODE (t) == TRAIT_EXPR)
{
kind = TRAIT_EXPR_KIND (t);
type1 = TRAIT_EXPR_TYPE1 (t);
type2 = TRAIT_EXPR_TYPE2 (t);
}
else
{
kind = TRAIT_TYPE_KIND (t);
type1 = TRAIT_TYPE_TYPE1 (t);
type2 = TRAIT_TYPE_TYPE2 (t);
}
switch (kind)
{
@ -2708,23 +2725,29 @@ pp_cxx_trait_expression (cxx_pretty_printer *pp, tree t)
case CPTK_REF_CONVERTS_FROM_TEMPORARY:
pp_cxx_ws_string (pp, "__reference_converts_from_temporary");
break;
case CPTK_UNDERLYING_TYPE:
pp_cxx_ws_string (pp, "__underlying_type");
break;
default:
gcc_unreachable ();
}
pp_cxx_left_paren (pp);
pp->type_id (TRAIT_EXPR_TYPE1 (t));
if (kind == CPTK_IS_BASE_OF
|| kind == CPTK_IS_SAME_AS
|| kind == CPTK_IS_LAYOUT_COMPATIBLE
|| kind == CPTK_IS_POINTER_INTERCONVERTIBLE_BASE_OF)
pp->type_id (type1);
if (type2)
{
pp_cxx_separate_with (pp, ',');
pp->type_id (TRAIT_EXPR_TYPE2 (t));
if (TREE_CODE (type2) != TREE_LIST)
{
pp_cxx_separate_with (pp, ',');
pp->type_id (type2);
}
else
for (tree arg = type2; arg; arg = TREE_CHAIN (arg))
{
pp_cxx_separate_with (pp, ',');
pp->type_id (TREE_VALUE (arg));
}
}
pp_cxx_right_paren (pp);
}

2
gcc/cp/cxx-pretty-print.h
View file

@ -90,7 +90,7 @@ void pp_cxx_colon_colon (cxx_pretty_printer *);
void pp_cxx_separate_with (cxx_pretty_printer *, int);
void pp_cxx_canonical_template_parameter (cxx_pretty_printer *, tree);
void pp_cxx_trait_expression (cxx_pretty_printer *, tree);
void pp_cxx_trait (cxx_pretty_printer *, tree);
void pp_cxx_va_arg_expression (cxx_pretty_printer *, tree);
void pp_cxx_offsetof_expression (cxx_pretty_printer *, tree);
void pp_cxx_addressof_expression (cxx_pretty_printer *, tree);

14
gcc/cp/error.cc
View file

@ -698,12 +698,8 @@ dump_type (cxx_pretty_printer *pp, tree t, int flags)
pp_cxx_right_paren (pp);
break;
case UNDERLYING_TYPE:
pp_cxx_ws_string (pp, "__underlying_type");
pp_cxx_whitespace (pp);
pp_cxx_left_paren (pp);
dump_expr (pp, UNDERLYING_TYPE_TYPE (t), flags & ~TFF_EXPR_IN_PARENS);
pp_cxx_right_paren (pp);
case TRAIT_TYPE:
pp_cxx_trait (pp, t);
break;
case TYPE_PACK_EXPANSION:
@ -971,7 +967,7 @@ dump_type_prefix (cxx_pretty_printer *pp, tree t, int flags)
case COMPLEX_TYPE:
case VECTOR_TYPE:
case TYPEOF_TYPE:
case UNDERLYING_TYPE:
case TRAIT_TYPE:
case DECLTYPE_TYPE:
case TYPE_PACK_EXPANSION:
case FIXED_POINT_TYPE:
@ -1095,7 +1091,7 @@ dump_type_suffix (cxx_pretty_printer *pp, tree t, int flags)
case COMPLEX_TYPE:
case VECTOR_TYPE:
case TYPEOF_TYPE:
case UNDERLYING_TYPE:
case TRAIT_TYPE:
case DECLTYPE_TYPE:
case TYPE_PACK_EXPANSION:
case FIXED_POINT_TYPE:
@ -2956,7 +2952,7 @@ dump_expr (cxx_pretty_printer *pp, tree t, int flags)
break;
case TRAIT_EXPR:
pp_cxx_trait_expression (pp, t);
pp_cxx_trait (pp, t);
break;
case VA_ARG_EXPR:

5
gcc/cp/mangle.cc
View file

@ -2389,8 +2389,9 @@ write_type (tree type)
sorry ("mangling %<typeof%>, use %<decltype%> instead");
break;
case UNDERLYING_TYPE:
sorry ("mangling %<__underlying_type%>");
case TRAIT_TYPE:
error ("use of built-in trait %qT in function signature; "
"use library traits instead", type);
break;
case LANG_TYPE:

24
gcc/cp/module.cc
View file

@ -8926,7 +8926,6 @@ trees_out::type_node (tree type)
case DECLTYPE_TYPE:
case TYPEOF_TYPE:
case UNDERLYING_TYPE:
case DEPENDENT_OPERATOR_TYPE:
tree_node (TYPE_VALUES_RAW (type));
if (TREE_CODE (type) == DECLTYPE_TYPE)
@ -8936,6 +8935,12 @@ trees_out::type_node (tree type)
tree_node_bools (type);
break;
case TRAIT_TYPE:
tree_node (TRAIT_TYPE_KIND_RAW (type));
tree_node (TRAIT_TYPE_TYPE1 (type));
tree_node (TRAIT_TYPE_TYPE2 (type));
break;
case TYPE_ARGUMENT_PACK:
/* No additional data. */
break;
@ -9450,7 +9455,6 @@ trees_in::tree_node (bool is_use)
case DECLTYPE_TYPE:
case TYPEOF_TYPE:
case UNDERLYING_TYPE:
case DEPENDENT_OPERATOR_TYPE:
{
tree expr = tree_node ();
@ -9465,6 +9469,22 @@ trees_in::tree_node (bool is_use)
}
break;
case TRAIT_TYPE:
{
tree kind = tree_node ();
tree type1 = tree_node ();
tree type2 = tree_node ();
if (!get_overrun ())
{
res = cxx_make_type (TRAIT_TYPE);
TRAIT_TYPE_KIND_RAW (res) = kind;
TRAIT_TYPE_TYPE1 (res) = type1;
TRAIT_TYPE_TYPE2 (res) = type2;
SET_TYPE_STRUCTURAL_EQUALITY (res);
}
}
break;
case TYPE_ARGUMENT_PACK:
if (!get_overrun ())
{

24
gcc/cp/parser.cc
View file

@ -2783,7 +2783,7 @@ static void cp_parser_late_parsing_default_args
(cp_parser *, tree);
static tree cp_parser_sizeof_operand
(cp_parser *, enum rid);
static cp_expr cp_parser_trait_expr
static cp_expr cp_parser_trait
(cp_parser *, enum rid);
static bool cp_parser_declares_only_class_p
(cp_parser *);
@ -5928,7 +5928,7 @@ cp_parser_primary_expression (cp_parser *parser,
case RID_IS_NOTHROW_CONVERTIBLE:
case RID_REF_CONSTRUCTS_FROM_TEMPORARY:
case RID_REF_CONVERTS_FROM_TEMPORARY:
return cp_parser_trait_expr (parser, token->keyword);
return cp_parser_trait (parser, token->keyword);
// C++ concepts
case RID_REQUIRES:
@ -10882,18 +10882,16 @@ cp_parser_builtin_offsetof (cp_parser *parser)
return expr;
}
/* Parse a trait expression.
Returns a representation of the expression, the underlying type
of the type at issue when KEYWORD is RID_UNDERLYING_TYPE. */
/* Parse a builtin trait expression or type. */
static cp_expr
cp_parser_trait_expr (cp_parser* parser, enum rid keyword)
cp_parser_trait (cp_parser* parser, enum rid keyword)
{
cp_trait_kind kind;
tree type1, type2 = NULL_TREE;
bool binary = false;
bool variadic = false;
bool type = false;
switch (keyword)
{
@ -10989,6 +10987,7 @@ cp_parser_trait_expr (cp_parser* parser, enum rid keyword)
break;
case RID_UNDERLYING_TYPE:
kind = CPTK_UNDERLYING_TYPE;
type = true;
break;
case RID_BASES:
kind = CPTK_BASES;
@ -11092,14 +11091,15 @@ cp_parser_trait_expr (cp_parser* parser, enum rid keyword)
the trait expr now or saving it for template instantiation. */
switch (kind)
{
case CPTK_UNDERLYING_TYPE:
return cp_expr (finish_underlying_type (type1), trait_loc);
case CPTK_BASES:
return cp_expr (finish_bases (type1, false), trait_loc);
case CPTK_DIRECT_BASES:
return cp_expr (finish_bases (type1, true), trait_loc);
default:
return finish_trait_expr (trait_loc, kind, type1, type2);
if (type)
return finish_trait_type (kind, type1, type2);
else
return finish_trait_expr (trait_loc, kind, type1, type2);
}
}
@ -19867,7 +19867,7 @@ cp_parser_simple_type_specifier (cp_parser* parser,
return type;
case RID_UNDERLYING_TYPE:
type = cp_parser_trait_expr (parser, RID_UNDERLYING_TYPE);
type = cp_parser_trait (parser, token->keyword);
if (decl_specs)
cp_parser_set_decl_spec_type (decl_specs, type,
token,
@ -19877,7 +19877,7 @@ cp_parser_simple_type_specifier (cp_parser* parser,
case RID_BASES:
case RID_DIRECT_BASES:
type = cp_parser_trait_expr (parser, token->keyword);
type = cp_parser_trait (parser, token->keyword);
if (decl_specs)
cp_parser_set_decl_spec_type (decl_specs, type,
token,

29
gcc/cp/pt.cc
View file

@ -10617,7 +10617,6 @@ for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
case TYPEOF_TYPE:
case DECLTYPE_TYPE:
case UNDERLYING_TYPE:
if (pfd->include_nondeduced_p
&& for_each_template_parm (TYPE_VALUES_RAW (t), fn, data,
pfd->visited,
@ -10627,6 +10626,15 @@ for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
*walk_subtrees = false;
break;
case TRAIT_TYPE:
if (pfd->include_nondeduced_p)
{
WALK_SUBTREE (TRAIT_TYPE_TYPE1 (t));
WALK_SUBTREE (TRAIT_TYPE_TYPE2 (t));
}
*walk_subtrees = false;
break;
case FUNCTION_DECL:
case VAR_DECL:
if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
@ -16513,11 +16521,14 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
complain | tf_ignore_bad_quals);
}
case UNDERLYING_TYPE:
case TRAIT_TYPE:
{
tree type = tsubst (UNDERLYING_TYPE_TYPE (t), args,
complain, in_decl);
return finish_underlying_type (type);
tree type1 = tsubst (TRAIT_TYPE_TYPE1 (t), args, complain, in_decl);
tree type2 = tsubst (TRAIT_TYPE_TYPE2 (t), args, complain, in_decl);
type = finish_trait_type (TRAIT_TYPE_KIND (t), type1, type2);
return cp_build_qualified_type (type,
cp_type_quals (t) | cp_type_quals (type),
complain | tf_ignore_bad_quals);
}
case TYPE_ARGUMENT_PACK:
@ -24927,9 +24938,9 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict,
case TYPEOF_TYPE:
case DECLTYPE_TYPE:
case UNDERLYING_TYPE:
case TRAIT_TYPE:
/* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
or UNDERLYING_TYPE nodes. */
or TRAIT_TYPE nodes. */
return unify_success (explain_p);
case ERROR_MARK:
@ -27504,12 +27515,12 @@ dependent_type_p_r (tree type)
(INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
return true;
/* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
/* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and TRAIT_TYPEs are
dependent; if the argument of the `typeof' expression is not
type-dependent, then it should already been have resolved. */
if (TREE_CODE (type) == TYPEOF_TYPE
|| TREE_CODE (type) == DECLTYPE_TYPE
|| TREE_CODE (type) == UNDERLYING_TYPE)
|| TREE_CODE (type) == TRAIT_TYPE)
return true;
/* A template argument pack is dependent if any of its packed

45
gcc/cp/semantics.cc
View file

@ -4397,17 +4397,6 @@ finish_typeof (tree expr)
tree
finish_underlying_type (tree type)
{
tree underlying_type;
if (processing_template_decl)
{
underlying_type = cxx_make_type (UNDERLYING_TYPE);
UNDERLYING_TYPE_TYPE (underlying_type) = type;
SET_TYPE_STRUCTURAL_EQUALITY (underlying_type);
return underlying_type;
}
if (!complete_type_or_else (type, NULL_TREE))
return error_mark_node;
@ -4417,7 +4406,7 @@ finish_underlying_type (tree type)
return error_mark_node;
}
underlying_type = ENUM_UNDERLYING_TYPE (type);
tree underlying_type = ENUM_UNDERLYING_TYPE (type);
/* Fixup necessary in this case because ENUM_UNDERLYING_TYPE
includes TYPE_MIN_VALUE and TYPE_MAX_VALUE information.
@ -12224,6 +12213,38 @@ finish_trait_expr (location_t loc, cp_trait_kind kind, tree type1, tree type2)
return maybe_wrap_with_location (val, loc);
}
/* Process a trait type. */
tree
finish_trait_type (cp_trait_kind kind, tree type1, tree type2)
{
if (type1 == error_mark_node
|| type2 == error_mark_node)
return error_mark_node;
if (processing_template_decl)
{
tree type = cxx_make_type (TRAIT_TYPE);
TRAIT_TYPE_TYPE1 (type) = type1;
TRAIT_TYPE_TYPE2 (type) = type2;
TRAIT_TYPE_KIND_RAW (type) = build_int_cstu (integer_type_node, kind);
/* These traits are intended to be used in the definition of the ::type
member of the corresponding standard library type trait and aren't
mangleable (and thus won't appear directly in template signatures),
so structural equality should suffice. */
SET_TYPE_STRUCTURAL_EQUALITY (type);
return type;
}
switch (kind)
{
case CPTK_UNDERLYING_TYPE:
return finish_underlying_type (type1);
default:
gcc_unreachable ();
}
}
/* Do-nothing variants of functions to handle pragma FLOAT_CONST_DECIMAL64,
which is ignored for C++. */

22
gcc/cp/tree.cc
View file

@ -1776,10 +1776,17 @@ strip_typedefs (tree t, bool *remove_attributes /* = NULL */,
DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t),
tf_none));
break;
case UNDERLYING_TYPE:
type = strip_typedefs (UNDERLYING_TYPE_TYPE (t),
remove_attributes, flags);
result = finish_underlying_type (type);
case TRAIT_TYPE:
{
tree type1 = strip_typedefs (TRAIT_TYPE_TYPE1 (t),
remove_attributes, flags);
tree type2 = strip_typedefs (TRAIT_TYPE_TYPE2 (t),
remove_attributes, flags);
if (type1 == TRAIT_TYPE_TYPE1 (t) && type2 == TRAIT_TYPE_TYPE2 (t))
result = NULL_TREE;
else
result = finish_trait_type (TRAIT_TYPE_KIND (t), type1, type2);
}
break;
case TYPE_PACK_EXPANSION:
{
@ -5383,7 +5390,6 @@ cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
case UNBOUND_CLASS_TEMPLATE:
case TEMPLATE_PARM_INDEX:
case TYPEOF_TYPE:
case UNDERLYING_TYPE:
/* None of these have subtrees other than those already walked
above. */
*walk_subtrees_p = 0;
@ -5472,6 +5478,12 @@ cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
*walk_subtrees_p = 0;
break;
case TRAIT_TYPE:
WALK_SUBTREE (TRAIT_TYPE_TYPE1 (*tp));
WALK_SUBTREE (TRAIT_TYPE_TYPE2 (*tp));
*walk_subtrees_p = 0;
break;
case DECLTYPE_TYPE:
++cp_unevaluated_operand;
/* We can't use WALK_SUBTREE here because of the goto. */

7
gcc/cp/typeck.cc
View file

@ -1621,8 +1621,11 @@ structural_comptypes (tree t1, tree t2, int strict)
return false;
break;
case UNDERLYING_TYPE:
if (!same_type_p (UNDERLYING_TYPE_TYPE (t1), UNDERLYING_TYPE_TYPE (t2)))
case TRAIT_TYPE:
if (TRAIT_TYPE_KIND (t1) != TRAIT_TYPE_KIND (t2))
return false;
if (!same_type_p (TRAIT_TYPE_TYPE1 (t1), TRAIT_TYPE_TYPE1 (t2))
|| !cp_tree_equal (TRAIT_TYPE_TYPE2 (t1), TRAIT_TYPE_TYPE2 (t2)))
return false;
break;

4
gcc/testsuite/g++.dg/cpp0x/alias-decl-59.C
View file

@ -5,7 +5,7 @@ template<typename>
struct A {};
template<typename T>
using B = A<__underlying_type(T) [[gnu::aligned(4)]]>; // { dg-warning "ignoring attributes on template argument" }
using B = A<__underlying_type(T) [[gnu::aligned(4)]]>; // { dg-warning "ignoring attributes applied to dependent type" }
template<typename T>
using B = A<__underlying_type(T) [[gnu::packed]]>; // { dg-warning "ignoring attributes on template argument" }
using B = A<__underlying_type(T) [[gnu::packed]]>; // { dg-warning "ignoring attributes applied to dependent type" }

7
gcc/testsuite/g++.dg/ext/underlying_type13.C Normal file
View file

@ -0,0 +1,7 @@
// Verify when substituting __underlying_type its cv-quals are carried over.
// { dg-do compile { target c++11 } }
template<class T> using const_underlying_type_t = const __underlying_type(T);
enum A { a };
using type = const_underlying_type_t<A>;
using type = const __underlying_type(A);

8
gcc/testsuite/g++.dg/ext/underlying_type14.C Normal file
View file

@ -0,0 +1,8 @@
// Verify pretty-printing when nesting a builtin trait.
template<class T> void f(__underlying_type(__underlying_type(T))); // { dg-error "" }
// { dg-message "__underlying_type\\(__underlying_type\\(T\\)\\)\\)" "" { target *-*-* } .-1 }
int main() {
f<int>(0); // { dg-error "no match" }
}

2
gcc/testsuite/g++.dg/ext/underlying_type7.C
View file

@ -9,7 +9,7 @@ enum class E6 : long { c = __LONG_MAX__ };
template<typename T>
void
test(T, __underlying_type(T)) // { dg-message "sorry, unimplemented: mangling" }
test(T, __underlying_type(T)) // { dg-error "built-in trait '__underlying_type\\(T\\)'" }
{ }
int main()