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);
/** 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.
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)
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) \
|| 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
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);
break;
case TRAIT_EXPR:
- pp_cxx_trait_expression (this, t);
+ pp_cxx_trait (this, t);
break;
case VA_ARG_EXPR:
break;
case TRAIT_EXPR:
- pp_cxx_trait_expression (this, t);
+ pp_cxx_trait (this, t);
break;
case ATOMIC_CONSTR:
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;
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:
}
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)
{
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);
}
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);
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:
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:
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:
break;
case TRAIT_EXPR:
- pp_cxx_trait_expression (pp, t);
+ pp_cxx_trait (pp, t);
break;
case VA_ARG_EXPR:
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:
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)
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;
case DECLTYPE_TYPE:
case TYPEOF_TYPE:
- case UNDERLYING_TYPE:
case DEPENDENT_OPERATOR_TYPE:
{
tree expr = tree_node ();
}
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 ())
{
(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 *);
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:
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)
{
break;
case RID_UNDERLYING_TYPE:
kind = CPTK_UNDERLYING_TYPE;
+ type = true;
break;
case RID_BASES:
kind = CPTK_BASES;
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);
}
}
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,
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,
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,
*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))
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:
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:
(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
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;
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.
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++. */
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:
{
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;
*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. */
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;
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" }
--- /dev/null
+// 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);
--- /dev/null
+// 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" }
+}
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()
projects / thirdparty / gcc.git / commitdiff
