extern location_t location_of (tree);
extern void qualified_name_lookup_error (tree, tree, tree,
location_t);
+void inform_tree_category (tree);
struct decl_location_traits
: simple_cache_map_traits<tree_decl_hash, location_t> { };
return G_("In function %qD");
}
+/* We expected some kind of tree but instead got T and emitted a diagnostic.
+ Print the category of T (type, expression, ...) if possible. */
+
+void
+inform_tree_category (tree t)
+{
+ const location_t loc = location_of (t);
+
+ t = maybe_get_first_fn (t);
+ if (TREE_CODE (t) == TYPE_DECL)
+ t = TREE_TYPE (t);
+
+ if (TYPE_P (t))
+ inform (loc, "but %qE is a type", t);
+ else if (EXPR_P (t))
+ inform (loc, "but %qE is an expression", t);
+ else if (DECL_DECOMPOSITION_P (t) && !DECL_DECOMP_IS_BASE (t))
+ inform (loc, "but %qE is a structured binding", t);
+ else if (VAR_P (t))
+ inform (loc, "but %qE is a variable", t);
+ else if (TREE_CODE (t) == PARM_DECL)
+ inform (loc, "but %qE is a parameter", t);
+ else if (TREE_CODE (t) == FUNCTION_DECL)
+ inform (loc, "but %qE is a function", t);
+ else if (TREE_CODE (t) == FIELD_DECL)
+ inform (loc, "but %qE is a data member", t);
+ else if (DECL_FUNCTION_TEMPLATE_P (t))
+ inform (loc, "but %qE is a function template", t);
+ else if (DECL_CLASS_TEMPLATE_P (t))
+ inform (loc, "but %qE is a class template", t);
+ else if (TREE_CODE (t) == NAMESPACE_DECL)
+ inform (loc, "but %qE is a namespace", t);
+ else if (TREE_CODE (t) == CONST_DECL && !DECL_TEMPLATE_PARM_P (t))
+ inform (loc, "but %qE is an enumerator", t);
+}
+
/* Disable warnings about missing quoting in GCC diagnostics for
the pp_verbatim calls. Their format strings deliberately don't
follow GCC diagnostic conventions. */
static int omp_finish_variant_function
(cp_parser *, tree, tree, tree, bool, bool);
static void maybe_start_implicit_template (cp_parser *parser);
+static void missing_template_diag
+ (location_t, diagnostics::kind = diagnostics::kind::warning);
/* Manifest constants. */
#define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
/* As a courtesy to the user, if there is a < after a template
name, parse the construct as an s-s-s and warn about the missing
'template'; it can't be anything else. */
- && (template_p || typename_p || TREE_CODE (expr) == TEMPLATE_DECL))
+ && (template_p
+ || typename_p
+ || TREE_CODE (OVL_FIRST (expr)) == TEMPLATE_DECL))
{
/* For member access splice-specialization-specifier, try to wrap
non-dependent splice for function template into a BASELINK so
if (!valid_splice_type_p (type))
{
if (!cp_parser_simulate_error (parser))
- error_at (loc, "reflection %qE not usable in a splice type", type);
+ {
+ auto_diagnostic_group d;
+ error_at (loc, "expected a reflection of a type");
+ inform_tree_category (type);
+ }
type = NULL_TREE;
}
return error_mark_node;
}
+ /* Make sure this splice-expression produces an expression. */
+ if (!check_splice_expr (loc, expr.get_start (), t, address_p,
+ member_access_p, /*complain=*/true))
+ return error_mark_node;
+
if (template_p)
{
/* [expr.prim.splice] For a splice-expression of the form template
splice-specifier, the splice-specifier shall designate a function
template. */
- if (!targs_p)
+ if (!targs_p
+ && !really_overloaded_fn (t)
+ && !dependent_splice_p (t))
{
- if (!really_overloaded_fn (t) && !dependent_splice_p (t))
- {
- auto_diagnostic_group d;
- error_at (loc, "reflection %qE not usable in a template splice",
- t);
- inform (loc, "only function templates are allowed here");
- return error_mark_node;
- }
+ auto_diagnostic_group d;
+ error_at (loc, "expected a reflection of a function template");
+ inform_tree_category (t);
+ return error_mark_node;
}
/* [expr.prim.splice] For a splice-expression of the form
template splice-specialization-specifier, the splice-specifier of the
- splice-specialization-specifier shall designate a template. */
- else
- {
- if (really_overloaded_fn (t)
- || get_template_info (t)
- || TREE_CODE (t) == TEMPLATE_ID_EXPR)
- /* OK */;
- else
- {
- auto_diagnostic_group d;
- error_at (loc, "reflection %qE not usable in a template splice",
- t);
- inform (loc, "only templates are allowed here");
- return error_mark_node;
- }
- }
+ splice-specialization-specifier shall designate a template. Since
+ we would have already complained, just check that we have a template. */
+ gcc_checking_assert (really_overloaded_fn (t)
+ || get_template_info (t)
+ || TREE_CODE (t) == TEMPLATE_ID_EXPR
+ || dependent_splice_p (t));
}
else if (/* No 'template' but there were template arguments? */
- targs_p
- /* No 'template' but the splice-specifier designates a template? */
- || really_overloaded_fn (t))
- {
- auto_diagnostic_group d;
- if (targs_p)
- error_at (loc, "reflection %qE not usable in a splice expression with "
- "template arguments", t);
- else
- error_at (loc, "reflection %qE not usable in a splice expression", t);
- location_t sloc = expr.get_start ();
- rich_location richloc (line_table, sloc);
- richloc.add_fixit_insert_before (sloc, "template ");
- inform (&richloc, "add %<template%> to denote a template");
- return error_mark_node;
- }
-
- /* Make sure this splice-expression produces an expression. */
- if (!check_splice_expr (loc, expr.get_start (), t, address_p,
- member_access_p, /*complain=*/true))
- return error_mark_node;
+ (targs_p
+ /* No 'template' but the splice-specifier designates a function
+ template? */
+ || really_overloaded_fn (t))
+ && warning_enabled_at (loc, OPT_Wmissing_template_keyword))
+ /* Were 'template' present, this would be valid code, so keep going. */
+ missing_template_diag (loc, diagnostics::kind::pedwarn);
/* When doing foo.[: bar :], cp_parser_postfix_dot_deref_expression wants
to see an identifier or a TEMPLATE_ID_EXPR, if we have something like
if (!valid_splice_scope_p (scope))
{
auto_diagnostic_group d;
- error_at (loc, "reflection not usable in a splice scope");
- if (TYPE_P (scope))
- inform (loc, "%qT is not a class, namespace, or enumeration",
- tree (scope));
- else
- inform (loc, "%qE is not a class, namespace, or enumeration",
- tree (scope));
+ error_at (loc, "expected a reflection of a class, namespace, or "
+ "enumeration");
+ inform_tree_category (tree (scope));
scope = error_mark_node;
}
static void
missing_template_diag (location_t loc,
- enum diagnostics::kind diag_kind = diagnostics::kind::warning)
+ diagnostics::kind diag_kind/*=kind::warning*/)
{
if (warning_suppressed_at (loc, OPT_Wmissing_template_keyword))
return;
if (TYPE_P (t))
{
auto_diagnostic_group d;
- error_at (loc, "expected a reflection of an expression instead "
- "of type %qT", t);
+ error_at (loc, "expected a reflection of an expression");
+ inform_tree_category (t);
if (start_loc != UNKNOWN_LOCATION)
{
rich_location richloc (line_table, start_loc);
"a type-only context");
}
else
- error_at (loc, "expected a reflection of an expression instead "
- "of %qD", t);
+ {
+ auto_diagnostic_group d;
+ error_at (loc, "expected a reflection of an expression");
+ inform_tree_category (t);
+ }
}
return false;
}
struct S { };
using X = S;
-template <auto V> constexpr int e = [:V:]; // { dg-error "expected a reflection of an expression instead of type .X." }
-template <auto V> constexpr int e2 = [:V:]; // { dg-error "expected a reflection of an expression instead of type .X." }
+template <auto V> constexpr int e = [:V:]; // { dg-error "expected a reflection of an expression" }
+// { dg-message "but .X. is a type" "" { target *-*-* } 4 }
+template <auto V> constexpr int e2 = [:V:]; // { dg-error "expected a reflection of an expression" }
constexpr auto h = ^^X;
constexpr auto i = e<([:^^h:])>;
constexpr auto j = e2<^^X>;
f ()
{
// Parsed as "S::tfn < S".
- [: ^^T :]::tfn<[: ^^T :]>(); // { dg-error "expected primary-expression|expected a reflection of an expression instead of type .S." }
+ [: ^^T :]::tfn<[: ^^T :]>(); // { dg-error "expected primary-expression|expected a reflection of an expression" }
// { dg-warning "expected .template. keyword" "" { target *-*-* } .-1 }
+// { dg-message "but .S. is a type" "" { target *-*-* } 4 }
int i = [: ^^T :]::var<int>; // { dg-error "missing|expected" }
}
// { dg-do compile { target c++26 } }
// { dg-additional-options "-freflection" }
-template <auto V> constexpr int e = [:V:]; // { dg-error "expected a reflection of an expression instead of type .int." }
-template <auto V> constexpr int e2 = [:V:]; // { dg-error "expected a reflection of an expression instead of type .int." }
+template <auto V> constexpr int e = [:V:]; // { dg-error "expected a reflection of an expression" }
+// { dg-message "but .int. is a type" "" { target *-*-* } .-1 }
+template <auto V> constexpr int e2 = [:V:]; // { dg-error "expected a reflection of an expression" }
+// { dg-message "but .int. is a type" "" { target *-*-* } .-1 }
constexpr auto h = ^^int;
constexpr auto i = e<([:^^h:])>;
constexpr auto j = e2<^^int>;
void
f ()
{
- int j = s.template [:R:]<int>; // { dg-error "expected a reflection of an expression instead of type .S." }
+ int j = s.template [:R:]<int>; // { dg-error "expected a reflection of an expression" }
+ // { dg-message "but .S. is a type" "" { target *-*-* } 6 }
}
void
namespace N { }
-template <auto V> constexpr int e = [:V:]; // { dg-error "expected a reflection of an expression instead of .N." }
-template <auto V> constexpr int e2 = [:V:]; // { dg-error "expected a reflection of an expression instead of .N." }
+template <auto V> constexpr int e = [:V:]; // { dg-error "expected a reflection of an expression" }
+// { dg-message "but .N. is a namespace" "" { target *-*-* } 4 }
+template <auto V> constexpr int e2 = [:V:]; // { dg-error "expected a reflection of an expression" }
constexpr auto h = ^^N;
constexpr auto i = e<([:^^h:])>;
constexpr auto j = e2<^^N>;
static_assert ([: ^^T :]::x == 42);
typename [: ^^T :]::type a = 42;
[: ^^T :]::fn (42);
- [: ^^T :]::template tfn<([: ^^T :])>(); // { dg-error "expected a reflection of an expression instead of type .S." }
- auto x = [: ^^T :]::template var<([: ^^T :])>; // { dg-error "expected a reflection of an expression instead of type .S." }
+ [: ^^T :]::template tfn<([: ^^T :])>(); // { dg-error "expected a reflection of an expression" }
+ // { dg-message "but .S. is a type" "" { target *-*-* } 4 }
+ auto x = [: ^^T :]::template var<([: ^^T :])>; // { dg-error "expected a reflection of an expression" }
}
void
f ()
{
S s;
- s.[: ^^S::tfn :](42); // { dg-error "reflection .S::tfn. not usable in a splice expression" }
-// { dg-message "add .template. to denote a template" "" { target *-*-* } .-1 }
+ s.[: ^^S::tfn :](42); // { dg-error "expected 'template' keyword before dependent template name" }
s.template [: ^^S::tfn :](42);
constexpr auto r = ^^fortytwo;
- constexpr int i1 = [:r:]<int>; // { dg-error "reflection .fortytwo<int>. not usable in a splice expression with template arguments" }
-// { dg-message "add .template. to denote a template" "" { target *-*-* } .-1 }
+ constexpr int i1 = [:r:]<int>; // { dg-error "expected 'template' keyword before dependent template name" }
constexpr int i2 = template [:r:]<int>;
}
--- /dev/null
+// { dg-do compile { target c++26 } }
+// { dg-options "" }
+// { dg-additional-options "-freflection" }
+// Test that we offer some helpful diagnostic.
+
+struct S {
+ template<typename T>
+ void tfn (T) { }
+};
+
+template<typename T>
+constexpr T fortytwo = 42;
+
+void
+f ()
+{
+ S s;
+ s.[: ^^S::tfn :](42); // { dg-warning "expected 'template' keyword before dependent template name" }
+ s.template [: ^^S::tfn :](42);
+
+ constexpr auto r = ^^fortytwo;
+ constexpr int i1 = [:r:]<int>; // { dg-warning "expected 'template' keyword before dependent template name" }
+ constexpr int i2 = template [:r:]<int>;
+}
--- /dev/null
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection -Wno-missing-template-keyword" }
+// Test that we offer some helpful diagnostic.
+
+struct S {
+ template<typename T>
+ void tfn (T) { }
+};
+
+template<typename T>
+constexpr T fortytwo = 42;
+
+void
+f ()
+{
+ S s;
+ s.[: ^^S::tfn :](42); // { dg-bogus "expected 'template' keyword before dependent template name" }
+ s.template [: ^^S::tfn :](42);
+
+ constexpr auto r = ^^fortytwo;
+ constexpr int i1 = [:r:]<int>; // { dg-bogus "expected 'template' keyword before dependent template name" }
+ constexpr int i2 = template [:r:]<int>;
+}
int g;
void
-fn0 (int, typename [: ^^:: :] i) // { dg-error "reflection .::. not usable in a splice type|declared" }
+fn0 (int, typename [: ^^:: :] i) // { dg-error "expected a reflection of a type|declared" }
+// { dg-message "but .::. is a namespace" "" { target *-*-* } 0 }
{
}
void
-fn1 (int, typename [: ^^g :] i) // { dg-error "reflection .g. not usable in a splice type|declared" }
+fn1 (int, typename [: ^^g :] i) // { dg-error "expected a reflection of a type|declared" }
+// { dg-message "but .g. is a variable" "" { target *-*-* } 4 }
{
}
void
-fn2 (int, typename [: ^^fn1 :] i) // { dg-error "reflection .fn1. not usable in a splice type|declared" }
+fn2 (int, typename [: ^^fn1 :] i) // { dg-error "expected a reflection of a type|declared" }
+// { dg-message "but .fn1. is a function" "" { target *-*-* } 13 }
{
}
void
-fn3 (int p, typename [: ^^p :] i) // { dg-error "reflection .p. not usable in a splice type|declared" }
+fn3 (int p, typename [: ^^p :] i) // { dg-error "expected a reflection of a type|declared" }
+// { dg-message "but .p. is a parameter" "" { target *-*-* } 25 }
{
}
enum Harold { Budd };
void
-fn4 (int, typename [: ^^Budd :] i) // { dg-error "reflection .Budd. not usable in a splice type|declared" }
+fn4 (int, typename [: ^^Budd :] i) // { dg-error "expected a reflection of a type|declared" }
+// { dg-message "but .Budd. is an enumerator" "" { target *-*-* } 30 }
{
}
struct S {};
void
-fn5 (int, typename [: ^^S :] i) // { dg-error "reflection .S. not usable in a splice type|declared" }
+fn5 (int, typename [: ^^S :] i) // { dg-error "expected a reflection of a type|declared" }
+// { dg-message "but .S. is a class template" "" { target *-*-* } 39 }
+{
+}
+
+template<int>
+void bar ();
+
+void
+fn6 (int, typename [: ^^bar :] i) // { dg-error "expected a reflection of a type|declared" }
+// { dg-message "but .bar. is a function template" "" { target *-*-* } 48 }
{
}
constexpr bool b0 = template [:r:] < 0 > 0; // { dg-error "not a template" }
constexpr bool b1 = template [:r:] < 0 < 0; // { dg-error "not a template|expected" }
constexpr bool b2 = template [:r:] < 43; // { dg-error "not a template|expected" }
-constexpr bool b3 = template [:r:] <= 43; // { dg-error "template splice" }
-constexpr bool b4 = template [:r:] > 41; // { dg-error "template splice" }
-constexpr bool b5 = template [:r:] >= 41; // { dg-error "template splice" }
-constexpr bool b6 = template [:r:] == 42; // { dg-error "template splice" }
-constexpr bool b7 = template [:r:] != 41; // { dg-error "template splice" }
+constexpr bool b3 = template [:r:] <= 43; // { dg-error "expected a reflection of a function template" }
+// { dg-message "but .i. is a variable" "" { target *-*-* } 5 }
+constexpr bool b4 = template [:r:] > 41; // { dg-error "expected a reflection of a function template" }
+constexpr bool b5 = template [:r:] >= 41; // { dg-error "expected a reflection of a function template" }
+constexpr bool b6 = template [:r:] == 42; // { dg-error "expected a reflection of a function template" }
+constexpr bool b7 = template [:r:] != 41; // { dg-error "expected a reflection of a function template" }
template<bool> struct S { };
S<template [:r:] < 43> s1; // { dg-error "not a template|invalid" }
-S<template [:r:] <= 43> s2; // { dg-error "template splice|invalid" }
-S<(template [:r:] > 41)> s3; // { dg-error "template splice|invalid" }
-S<template [:r:] >= 41> s4; // { dg-error "template splice|invalid" }
-S<template [:r:] == 42> s5; // { dg-error "template splice|invalid" }
-S<template[:r:] != 41> s6; // { dg-error "template splice|invalid" }
+S<template [:r:] <= 43> s2; // { dg-error "expected a reflection|invalid" }
+S<(template [:r:] > 41)> s3; // { dg-error "expected a reflection|invalid" }
+S<template [:r:] >= 41> s4; // { dg-error "expected a reflection|invalid" }
+S<template [:r:] == 42> s5; // { dg-error "expected a reflection|invalid" }
+S<template[:r:] != 41> s6; // { dg-error "expected a reflection|invalid" }
void
f ()
{
- int i = [:R:]; // { dg-error "expected a reflection of an expression instead of .N." }
+ int i = [:R:]; // { dg-error "expected a reflection of an expression" }
+ // { dg-message "but .N. is a namespace" "" { target *-*-* } 6 }
}
void
g ()
{
int i1 = [: ^^x :];
- int i2 = template [: ^^x :]; // { dg-error "reflection .x. not usable in a template splice" }
+ int i2 = template [: ^^x :]; // { dg-error "expected a reflection of a function template" }
+ // { dg-message "but .x. is a variable" "" { target *-*-* } 4 }
int i3 = [: ^^two<int> :];
- int i4 = template [: ^^two<int> :]; // { dg-error "reflection .two<int>. not usable in a template splice" }
- int i5 = [: ^^foo :](42); // { dg-error "reflection .foo. not usable in a splice expression" }
+ int i4 = template [: ^^two<int> :]; // { dg-error "expected a reflection of a function template" }
+ // { dg-message "but .two<int>. is a variable" "" { target *-*-* } 6 }
+ int i5 = [: ^^foo :](42); // { dg-error "expected 'template' keyword before dependent template name" }
int i6 = template [: ^^foo :](42);
int i7 = [: ^^foo<int> :](42);
- int i8 = template [: ^^foo<int> :](42); // { dg-error "reflection .foo<int>. not usable in a template splice" }
- int i9 = [: ^^foo :]<int>(42); // { dg-error "reflection .foo. not usable in a splice expression|expected" }
+ int i8 = template [: ^^foo<int> :](42); // { dg-error "expected a reflection of a function template" }
+ // { dg-message "but .foo<int>. is a function" "" { target *-*-* } 9 }
+ int i9 = [: ^^foo :]<int>(42); // { dg-error "expected .template. keyword before dependent template name" }
int i10 = template [: ^^foo :]<int>(42);
int i11 = template [: ^^bar :]<int>(42); // { dg-error "no matching function for call" }
- int i12 = [: ^^two :]<int>; // { dg-error "reflection .two<int>. not usable in a splice expression with template arguments" }
+ int i12 = [: ^^two :]<int>; // { dg-error "expected 'template' keyword before dependent template name" }
int i13 = template [: ^^two :]<int>;
- [: ^^ST :]<int> c1; // { dg-error "reflection .ST<int>. not usable in a splice expression with template arguments" }
+ [: ^^ST :]<int> c1; // { dg-error "expected a reflection of an expression" }
+ // { dg-message "but .ST<int>. is a type" "" { target *-*-* } 16 }
typename [: ^^ST :]<int> c2;
template [: ^^ST :]<int> c3; // { dg-error "expected a reflection of an expression" }
[: ^^S :]<int> c4; // { dg-error "expected a reflection of an expression|expected primary-expression" }
+ // { dg-message "but .S. is a type" "" { target *-*-* } 13 }
+ // { dg-message "add .typename. to denote a type outside a type-only context" "" { target *-*-* } .-2 }
template [: ^^S :]<int> c5; // { dg-error ".S. is not a template" }
typename [: ^^S :]<int> c6; // { dg-error ".S. is not a template|expected" }
[: ^^bar :]<int>(); // { dg-error "expected" }
- auto x1 = [: ^^ST :]<int>{}; // { dg-error "reflection .ST<int>. not usable in a splice expression with template arguments" }
+ auto x1 = [: ^^ST :]<int>{}; // { dg-error "expected a reflection of an expression" }
auto x2 = template [: ^^ST :]<int>{}; // { dg-error "expected a reflection of an expression" }
auto x3 = typename [: ^^ST :]<int>{};
}
sp->template [: ^^S::tfn :](42);
s.template [: ^^S::tfn :]<int>(42);
sp->template [: ^^S::tfn :]<int>(42);
- s.[: ^^S::var :]<int> = 1; // { dg-error "reflection .var<int>. not usable in a splice expression with template arguments" }
+ s.[: ^^S::var :]<int> = 1; // { dg-error "expected 'template' keyword before dependent template name" }
s.template [: ^^S::var :]<int> = 1;
- sp->[: ^^S::var :]<int> = 1; // { dg-error "reflection .var<int>. not usable in a splice expression with template arguments" }
+ sp->[: ^^S::var :]<int> = 1; // { dg-error "expected 'template' keyword before dependent template name" }
sp->template [: ^^S::var :]<int> = 1;
s.[: ^^S::b :].[: ^^B::a :].val;
sp->[: ^^S::b :].[: ^^B::a :].val;
cp->template [: ^^C<int>::tfn :](42);
c.template [: ^^C<int>::tfn :]<int>(42);
cp->template [: ^^C<int>::tfn :]<int>(42);
- c.[: ^^C<int>::var :]<int> = 1; // { dg-error "reflection .var<int>. not usable in a splice expression with template arguments" }
+ c.[: ^^C<int>::var :]<int> = 1; // { dg-error "expected 'template' keyword before dependent template name" }
c.template [: ^^C<int>::var :]<int> = 1;
- cp->[: ^^C<int>::var :]<int> = 1; // { dg-error "reflection .var<int>. not usable in a splice expression with template arguments" }
+ cp->[: ^^C<int>::var :]<int> = 1; // { dg-error "expected 'template' keyword before dependent template name" }
cp->template [: ^^C<int>::var :]<int> = 1;
c.[: ^^C<int>::b :].[: ^^B::a :].val;
cp->[: ^^C<int>::b :].[: ^^B::a :].val;
sp.[: ^^S::x :] = 2; // { dg-error "which is of pointer type" }
c.[: ^^C<char>::x :] = 1; // { dg-error "is not a base of" }
cp->[: ^^C<char>::x :] = 1; // { dg-error "is not a base of" }
- s.template [: ^^S::N :].t; // { dg-error "reflection .S::N. not usable in a template splice" }
+ s.template [: ^^S::N :].t; // { dg-error "expected a reflection of a function template" }
+ // { dg-message "but .S::N. is a class template" "" { target *-*-* } 20 }
S::template [: ^^S::N<int> :] e1; // { dg-error "expected unqualified-id" }
C<int>::template [: ^^S::N<int> :] e2; // { dg-error "expected unqualified-id" }
- s.template [: ^^S::var<int> :] = 1; // { dg-error "reflection .S::var<int>. not usable in a template splice" }
+ s.template [: ^^S::var<int> :] = 1; // { dg-error "expected a reflection of a function template" }
+ // { dg-message "but .S::var<int>. is a variable" "" { target *-*-* } 22 }
}
// Test reflections on namespaces. Invalid stuff.
void foo (int);
+int i;
+enum E { EE };
+template<typename>
+struct S { int i, j, k; };
+template<typename>
+void bar ();
namespace N {
}
void
-f1 ()
+f1 (int p)
{
constexpr auto r = ^^::;
- [: r :] foo (0); // { dg-error "expected" }
+ [: r :] foo (0); // { dg-error "expected a reflection of an expression" }
+ // { dg-message "but .::. is a namespace" "" { target *-*-* } 0 }
constexpr auto q = ^^int;
- [: q :]::T x; // { dg-error "reflection not usable in a splice scope|expected" }
- // { dg-message ".int. is not a class, namespace, or enumeration" "" { target *-*-* } .-1 }
+ [: q :]::T x; // { dg-error "expected a reflection of a class, namespace, or enumeration|expected" }
+ // { dg-message "but .int. is a type" "" { target *-*-* } .-1 }
+ [: ^^foo :]::X; // { dg-error "expected a reflection of a class, namespace, or enumeration" }
+ // { dg-message "but .foo. is a function" "" { target *-*-* } 5 }
+ [: ^^EE :]::Y; // { dg-error "expected a reflection of a class, namespace, or enumeration" }
+ // { dg-message "but .EE. is an enumerator" "" { target *-*-* } 7 }
+ [: ^^S :]::Z; // { dg-error "expected a reflection of a class, namespace, or enumeration" }
+ // { dg-message "but .S. is a class template" "" { target *-*-* } 9 }
+ [: ^^bar :]::W; // { dg-error "expected a reflection of a class, namespace, or enumeration" }
+ // { dg-message "but .bar. is a function template" "" { target *-*-* } 11 }
+ [: ^^i :]::U; // { dg-error "expected a reflection of a class, namespace, or enumeration" }
+ // { dg-message "but .i. is a variable" "" { target *-*-* } 6 }
+ [: ^^p :]::V; // { dg-error "expected a reflection of a class, namespace, or enumeration" }
+ // { dg-message "but .p. is a parameter" "" { target *-*-* } 17 }
+ auto [a, b, c] = S<int>{1, 2, 3};
+ [: ^^a :]::G; // { dg-error "expected a reflection of a class, namespace, or enumeration" }
+ // { dg-message "but .a. is a structured binding" "" { target *-*-* } 38 }
+ [: ^^S<int>::i :]::H; // { dg-error "expected a reflection of a class, namespace, or enumeration" }
+ // { dg-message "but .S<int>::i. is a data member" "" { target *-*-* } 9 }
constexpr auto x = ^^N::X; // { dg-error ".N::X. has not been declared" }
}
static_assert(alias::s == 2);
// error: < means less than
-auto o1 = [:^^TCls:]<([:^^v:])>(); // { dg-error "reflection .TCls<1>. not usable" }
+auto o1 = [:^^TCls:]<([:^^v:])>(); // { dg-error "expected a reflection of an expression" }
+// { dg-message "but .TCls<1>. is a type" "" { target *-*-* } 8 }
// OK, o2 is an object of type TCls<1>
auto o2 = typename [:^^TCls:]<([:^^v:])>();
void
baz (S &s)
{
- template [: ^^foo :] (0); // { dg-error "reflection 'foo' not usable in a template splice" }
- template [: ^^bar :] (0); // { dg-message "only function templates are allowed here" "" { target *-*-* } .-1 }
- s.template [: ^^S::foo :] (0); // { dg-error "reflection 'S::foo' not usable in a template splice" }
- s.template [: ^^S::bar :] (0); // { dg-message "only function templates are allowed here" "" { target *-*-* } .-1 }
+ template [: ^^foo :] (0); // { dg-error "expected a reflection of a function template" }
+ // { dg-message "but .foo. is a function" "" { target *-*-* } 4 }
+ template [: ^^bar :] (0);
+ s.template [: ^^S::foo :] (0); // { dg-error "expected a reflection of a function template" }
+ // { dg-message "but .S::foo. is a function" "" { target *-*-* } 8 }
+ s.template [: ^^S::bar :] (0);
}
template <int N>
projects / thirdparty / gcc.git / commitdiff
