* decl.c (grokfndecl): Allow FUNCTION_DECL in assert.
* lex.c (unqualified_fn_lookup_error): Handle TEMPLATE_ID_EXPR.
* parser.c (cp_parser_postfix_expression): Do ADL for a template-name.
(cp_parser_template_id): Give errors if parsing the template argument
list didn't go well. Allow FUNCTION_DECL in assert.
(cp_parser_template_name): Consider a name to refer to a template if
it is an unqualified-id followed by a <. Don't return the identifier
if the decl is a function and dependent.
* pt.c (tsubst_copy) <case OVERLOAD>: Remove assert.
* g++.dg/addr_builtin-1.C: Adjust dg-error.
* g++.dg/cpp2a/fn-template1.C: New test.
* g++.dg/cpp2a/fn-template10.C: New test.
* g++.dg/cpp2a/fn-template11.C: New test.
* g++.dg/cpp2a/fn-template12.C: New test.
* g++.dg/cpp2a/fn-template13.C: New test.
* g++.dg/cpp2a/fn-template14.C: New test.
* g++.dg/cpp2a/fn-template15.C: New test.
* g++.dg/cpp2a/fn-template16.C: New test.
* g++.dg/cpp2a/fn-template2.C: New test.
* g++.dg/cpp2a/fn-template3.C: New test.
* g++.dg/cpp2a/fn-template4.C: New test.
* g++.dg/cpp2a/fn-template5.C: New test.
* g++.dg/cpp2a/fn-template6.C: New test.
* g++.dg/cpp2a/fn-template7.C: New test.
* g++.dg/cpp2a/fn-template8.C: New test.
* g++.dg/cpp2a/fn-template9.C: New test.
* g++.dg/parse/fn-template1.C: New test.
* g++.dg/parse/fn-template2.C: New test.
* g++.dg/parse/template19.C: Adjust dg-error.
* g++.dg/template/pr61745.C: Add target to dg-error.
From-SVN: r265734
+2018-11-01 Marek Polacek <polacek@redhat.com>
+
+ Implement P0846R0, ADL and function templates.
+ * decl.c (grokfndecl): Allow FUNCTION_DECL in assert.
+ * lex.c (unqualified_fn_lookup_error): Handle TEMPLATE_ID_EXPR.
+ * parser.c (cp_parser_postfix_expression): Do ADL for a template-name.
+ (cp_parser_template_id): Give errors if parsing the template argument
+ list didn't go well. Allow FUNCTION_DECL in assert.
+ (cp_parser_template_name): Consider a name to refer to a template if
+ it is an unqualified-id followed by a <. Don't return the identifier
+ if the decl is a function and dependent.
+ * pt.c (tsubst_copy) <case OVERLOAD>: Remove assert.
+
2018-11-01 Nathan Sidwell <nathan@acm.org>
* cp-tree.h (struct lang_function): Delete x_local_names field.
the information in the TEMPLATE_ID_EXPR. */
SET_DECL_IMPLICIT_INSTANTIATION (decl);
- gcc_assert (identifier_p (fns) || TREE_CODE (fns) == OVERLOAD);
+ gcc_assert (identifier_p (fns)
+ || TREE_CODE (fns) == OVERLOAD
+ || TREE_CODE (fns) == FUNCTION_DECL);
DECL_TEMPLATE_INFO (decl) = build_template_info (fns, args);
for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
if (loc == UNKNOWN_LOCATION)
loc = input_location;
+ if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
+ name = TREE_OPERAND (name, 0);
+
if (processing_template_decl)
{
/* In a template, it is invalid to write "f()" or "f(3)" if no
if (idk == CP_ID_KIND_UNQUALIFIED
|| idk == CP_ID_KIND_TEMPLATE_ID)
{
- if (identifier_p (postfix_expression))
+ if (identifier_p (postfix_expression)
+ /* In C++2A, we may need to perform ADL for a template
+ name. */
+ || (TREE_CODE (postfix_expression) == TEMPLATE_ID_EXPR
+ && identifier_p (TREE_OPERAND (postfix_expression, 0))))
{
if (!args->is_empty ())
{
}
/* Parse the arguments. */
arguments = cp_parser_enclosed_template_argument_list (parser);
+
+ if ((cxx_dialect > cxx17)
+ && (TREE_CODE (templ) == FUNCTION_DECL || identifier_p (templ))
+ && !template_keyword_p
+ && (cp_parser_error_occurred (parser)
+ || cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN)))
+ {
+ /* This didn't go well. */
+ if (TREE_CODE (templ) == FUNCTION_DECL)
+ {
+ /* C++2A says that "function-name < a;" is now ill-formed. */
+ if (cp_parser_error_occurred (parser))
+ {
+ error_at (token->location, "invalid template-argument-list");
+ inform (token->location, "function name as the left hand "
+ "operand of %<<%> is ill-formed in C++2a; wrap the "
+ "function name in %<()%>");
+ }
+ else
+ /* We expect "f<targs>" to be followed by "(args)". */
+ error_at (cp_lexer_peek_token (parser->lexer)->location,
+ "expected %<(%> after template-argument-list");
+ if (start_of_id)
+ /* Purge all subsequent tokens. */
+ cp_lexer_purge_tokens_after (parser->lexer, start_of_id);
+ }
+ else
+ cp_parser_simulate_error (parser);
+ pop_deferring_access_checks ();
+ return error_mark_node;
+ }
}
/* Set the location to be of the form:
a function-template. */
gcc_assert ((DECL_FUNCTION_TEMPLATE_P (templ)
|| TREE_CODE (templ) == OVERLOAD
+ || TREE_CODE (templ) == FUNCTION_DECL
|| BASELINK_P (templ)));
template_id = lookup_template_function (templ, arguments);
}
}
+ /* cp_parser_lookup_name clears OBJECT_TYPE. */
+ const bool scoped_p = ((parser->scope ? parser->scope
+ : parser->context->object_type) != NULL_TREE);
+
/* Look up the name. */
decl = cp_parser_lookup_name (parser, identifier,
tag_type,
if (TREE_CODE (*iter) == TEMPLATE_DECL)
found = true;
+ if (!found
+ && (cxx_dialect > cxx17)
+ && !scoped_p
+ && cp_lexer_next_token_is (parser->lexer, CPP_LESS))
+ {
+ /* [temp.names] says "A name is also considered to refer to a template
+ if it is an unqualified-id followed by a < and name lookup finds
+ either one or more functions or finds nothing." */
+
+ /* The "more functions" case. Just use the OVERLOAD as normally.
+ We don't use is_overloaded_fn here to avoid considering
+ BASELINKs. */
+ if (TREE_CODE (decl) == OVERLOAD
+ /* Name lookup found one function. */
+ || TREE_CODE (decl) == FUNCTION_DECL)
+ found = true;
+ /* Name lookup found nothing. */
+ else if (decl == error_mark_node)
+ return identifier;
+ }
+
if (!found)
{
/* The name does not name a template. */
}
}
- /* If DECL is dependent, and refers to a function, then just return
- its name; we will look it up again during template instantiation. */
- if (DECL_FUNCTION_TEMPLATE_P (decl) || !DECL_P (decl))
- {
- tree scope = ovl_scope (decl);
- if (TYPE_P (scope) && dependent_type_p (scope))
- return identifier;
- }
-
return decl;
}
return t;
case OVERLOAD:
- /* An OVERLOAD will always be a non-dependent overload set; an
- overload set from function scope will just be represented with an
- IDENTIFIER_NODE, and from class scope with a BASELINK. */
- gcc_assert (!uses_template_parms (t));
/* We must have marked any lookups as persistent. */
gcc_assert (!OVL_LOOKUP_P (t) || OVL_USED_P (t));
return t;
+2018-11-01 Marek Polacek <polacek@redhat.com>
+
+ Implement P0846R0, ADL and function templates.
+ * g++.dg/addr_builtin-1.C: Adjust dg-error.
+ * g++.dg/cpp2a/fn-template1.C: New test.
+ * g++.dg/cpp2a/fn-template10.C: New test.
+ * g++.dg/cpp2a/fn-template11.C: New test.
+ * g++.dg/cpp2a/fn-template12.C: New test.
+ * g++.dg/cpp2a/fn-template13.C: New test.
+ * g++.dg/cpp2a/fn-template14.C: New test.
+ * g++.dg/cpp2a/fn-template15.C: New test.
+ * g++.dg/cpp2a/fn-template16.C: New test.
+ * g++.dg/cpp2a/fn-template2.C: New test.
+ * g++.dg/cpp2a/fn-template3.C: New test.
+ * g++.dg/cpp2a/fn-template4.C: New test.
+ * g++.dg/cpp2a/fn-template5.C: New test.
+ * g++.dg/cpp2a/fn-template6.C: New test.
+ * g++.dg/cpp2a/fn-template7.C: New test.
+ * g++.dg/cpp2a/fn-template8.C: New test.
+ * g++.dg/cpp2a/fn-template9.C: New test.
+ * g++.dg/parse/fn-template1.C: New test.
+ * g++.dg/parse/fn-template2.C: New test.
+ * g++.dg/parse/template19.C: Adjust dg-error.
+ * g++.dg/template/pr61745.C: Add target to dg-error.
+
2017-11-01 Thomas Koenig <tkoenig@gcc.gnu.org>
PR fortran/54613
a = p - __builtin_trap; // { dg-error "built-in" }
// Relational operators. Ill-formed but allowed with -fpermissive.
- a = __builtin_trap < p; // { dg-error "built-in" }
+ a = __builtin_trap < p; // { dg-error "built-in|invalid template-argument-list" }
a = p < __builtin_trap; // { dg-error "built-in" }
a = __builtin_trap <= p; // { dg-error "built-in" }
--- /dev/null
+// P0846R0
+// { dg-do compile }
+// { dg-options "-std=c++2a" }
+
+int h;
+void g();
+void e();
+void e(int);
+void e(int, int);
+
+namespace N {
+ struct A { };
+ template <class T> int f(T);
+ template <class T> int g(T);
+ template <class T> int h(T);
+ template <class T> int e(T);
+}
+
+int v = e<N::A>(N::A());
+int x = f<N::A>(N::A());
+int y = g<N::A>(N::A());
+int z = h<N::A>(N::A()); // { dg-error "expected" }
+
+template<class>
+void fn ()
+{
+ int v = e<N::A>(N::A());
+ int x = f<N::A>(N::A());
+ int y = g<N::A>(N::A());
+ int z = h<N::A>(N::A()); // { dg-error "expected" }
+}
+
+void
+test ()
+{
+ fn<int>();
+}
--- /dev/null
+// P0846R0
+// { dg-do compile }
+// { dg-options "-std=c++2a" }
+
+int h;
+void g();
+void e();
+void e(int);
+void e(int, int);
+
+namespace N {
+ struct A { };
+ template <class T> static int f(T) { return 1; }
+ template <class T> static int g(T) { return 2; }
+ template <class T> static int h(T);
+ template <class T> static int e(T) { return 3; }
+}
+
+int v = e<N::A>(N::A());
+int x = f<N::A>(N::A());
+int y = g<N::A>(N::A());
+int z = h<N::A>(N::A()); // { dg-error "expected" }
--- /dev/null
+// P0846R0
+// { dg-do compile }
+// { dg-options "-std=c++2a" }
+
+int nonconst ();
+
+int foo ()
+{
+ return blah < // { dg-error "not declared" }
+ nonconst (), nonconst (); // { dg-error "call to non-.constexpr. function" }
+}
--- /dev/null
+// P0846R0
+// { dg-do compile }
+// { dg-options "-std=c++2a" }
+
+struct S {
+ template<typename T> int foo(T);
+ template<typename T> int foo(T, T);
+ template<typename T> int foo(T, T, T);
+};
+
+template<typename T>
+struct W {
+ template<typename U> T foo(U);
+ template<typename U> T foo(U, U);
+ template<typename U> T foo(U, U, U);
+};
+
+void
+test ()
+{
+ S s;
+ s.foo<int>(1);
+ s.foo<int>(1, 2);
+ s.foo<int>(1, 2, 3);
+
+ W<int> w;
+ w.foo<int>(1);
+ w.foo<int>(1, 2);
+ w.foo<int>(1, 2, 3);
+
+ w.nothere<int>(1); // { dg-error "has no member|expected" }
+ s.nothere<int>(1); // { dg-error "has no member|expected" }
+}
--- /dev/null
+// P0846R0
+// { dg-do compile }
+// { dg-options "-std=c++2a" }
+
+struct A {
+ template<typename T>
+ int foo (T a, T b) { return a + b; }
+};
+
+int
+bar (A* pa, int (A::*pm)(int, int))
+{
+ return (pa->*pm)(1, 2);
+}
+
+int
+baz (A pa, int (A::*pm)(int, int))
+{
+ return (pa.*pm)(1, 2);
+}
+
+int
+main ()
+{
+ A a;
+ int i = bar (&a, &A::foo<int>);
+ if (i != 3)
+ __builtin_abort ();
+ i = baz (a, &A::foo<int>);
+ if (i != 3)
+ __builtin_abort ();
+}
--- /dev/null
+// P0846R0
+// { dg-do compile }
+// { dg-options "-std=c++2a" }
+
+template<typename> struct B
+{
+ template<typename> int foo() { return 0; }
+ int i = foo<int>();
+};
--- /dev/null
+// P0846R0
+// { dg-do compile }
+// { dg-options "-std=c++2a" }
+
+// Don't get confused by these valid cases.
+
+template <class>
+class A {
+ template <bool> void b();
+ void m_fn1();
+};
+
+template <class T>
+void A<T>::m_fn1() { b<>(0); }
+
+
+template <int> struct X {
+ X() { fn<>(0); }
+ template <int> void fn();
+};
+
+
+template <typename> void a() { a<int>; }
--- /dev/null
+// P0846R0
+// { dg-do compile }
+// { dg-options "-std=c++2a" }
+
+struct undeclared<int> { }; // { dg-error "not a class template" }
+
+int
+main ()
+{
+ int foo ();
+ int foo (int);
+ int foo (int, int);
+ int a, b = 10;
+ a = foo<; // { dg-error "" }
+ a = foo < b; // { dg-error "" }
+ a = foo<b>; // { dg-error "" }
+ a = foo<b>(; // { dg-error "expected" }
+ a = foo<b>(1; // { dg-error "expected" }
+ a = foo<b>(1); // { dg-error "no matching" }
+}
--- /dev/null
+// P0846R0
+// { dg-do compile }
+// { dg-options "-std=c++2a" }
+
+struct A { };
+bool operator <(void (*fp)(), A) { return false; }
+void f() {}
+
+int
+main ()
+{
+ A a;
+ f < a; // { dg-error "invalid" }
+ bool b = f < a; // { dg-error "invalid" }
+ (f) < a;
+}
--- /dev/null
+// P0846R0
+// { dg-do run }
+// { dg-options "-std=c++2a" }
+
+void g();
+void e();
+void e(int);
+void e(int, int);
+
+namespace N {
+ struct A { };
+ template <class T> int f(T) { return 1; }
+ template <class T> int g(T) { return 2; }
+ template <class T> int e(T) { return 3; }
+}
+
+int
+main ()
+{
+ int v = e<N::A>(N::A());
+ if (v != 3)
+ __builtin_abort ();
+ int x = f<N::A>(N::A());
+ if (x != 1)
+ __builtin_abort ();
+ int y = g<N::A>(N::A());
+ if (y != 2)
+ __builtin_abort ();
+}
--- /dev/null
+// P0846R0
+// { dg-do compile }
+// { dg-options "-std=c++2a" }
+
+template <typename T> void foo() { }
+template <typename T> void bar(int) { }
+int main()
+{
+ foo<float>();
+ bar<int>(1);
+}
--- /dev/null
+// P0846R0
+// { dg-do run }
+// { dg-options "-std=c++2a" }
+
+int g() { return 11; }
+int e() { return 12; }
+int e(int) { return 13; }
+int e(int, int) { return 14; }
+
+namespace N {
+ struct A { };
+ template <class T> int f(T) { return 1; }
+ template <class T> int g(T) { return 2; }
+ template <class T> int e(T) { return 3; }
+}
+
+int
+main ()
+{
+ int v = e(1);
+ if (v != 13)
+ __builtin_abort ();
+ int x = e(1, 2);
+ if (x != 14)
+ __builtin_abort ();
+ int y = g();
+ if (y != 11)
+ __builtin_abort ();
+ int z = e();
+ if (z != 12)
+ __builtin_abort ();
+}
--- /dev/null
+// P0846R0
+// { dg-do compile }
+// { dg-options "-std=c++2a" }
+
+template<class>
+struct X {
+ int first = 0;
+};
+
+int
+f ()
+{
+ X<int> x, y;
+ bool b = x.first < y.first;
+ return b;
+}
--- /dev/null
+// P0846R0
+// { dg-do compile }
+// { dg-options "-std=c++2a" }
+
+struct undeclared<int> { }; // { dg-error "not a class template" }
+
+int
+main ()
+{
+ int foo ();
+ int a, b = 10;
+ a = foo<; // { dg-error "invalid template-argument-list|invalid" }
+ a = foo < b; // { dg-error "invalid template-argument-list|invalid" }
+ a = foo<b>; // { dg-error "after template-argument-list|invalid" }
+ a = foo<b>(; // { dg-error "expected" }
+ a = foo<b>(1; // { dg-error "expected" }
+ a = foo<b>(1); // { dg-error "no matching" }
+}
--- /dev/null
+// P0846R0
+// { dg-do compile }
+// { dg-options "-std=c++2a" }
+
+const unsigned long arr[10] = { 2 };
+template<class T> struct S { int n; };
+
+template <class T>
+int fn1 (S<T>* s)
+{
+ int i = 1;
+ return s->n < arr[i + 1];
+}
+
+template <class T>
+int fn2 (S<T> s)
+{
+ int i = 1;
+ return s.n < arr[i + 1];
+}
+
+template <class T>
+int fn3 (S<T>* s)
+{
+ int i = 1;
+ return s->template n < 1; // { dg-error "parse error in template argument list" }
+}
+
+template <class T>
+int fn4 (S<T> s)
+{
+ int i = 1;
+ return s.template n < 1; // { dg-error "parse error in template argument list" }
+}
--- /dev/null
+// P0846R0
+// { dg-do compile }
+// { dg-options "-std=c++2a" }
+
+namespace N1 {
+ struct S {};
+ template<int X> void f(S);
+}
+
+namespace N2 {
+ template<class T> void f(T t);
+}
+
+void
+g (N1::S s)
+{
+ f<3>(s);
+
+ using N2::f;
+ f<3>(s);
+}
--- /dev/null
+// P0846R0
+// { dg-do compile }
+
+struct A { };
+bool operator <(void (*fp)(), A) { return false; }
+void f() {}
+
+int
+main ()
+{
+ A a;
+ f < a; // { dg-error "invalid" "" { target c++2a } }
+ bool b = f < a; // { dg-error "invalid" "" { target c++2a } }
+ (f) < a;
+}
--- /dev/null
+// P0846R0
+// { dg-do compile }
+
+namespace N1 {
+ struct S {};
+ template<int X> void f(S);
+}
+
+namespace N2 {
+ template<class T> void f(T t);
+}
+
+void
+g (N1::S s)
+{
+ f<3>(s); // { dg-error "was not declared" "" { target c++17_down } }
+}
{
template<int> void foo()
{
- foo<0>::; // { dg-error "before" }
+ foo<0>::; // { dg-error "before|function template-id" }
}
};
// this compiles only if the following definition is moved
// AFTER the friend declaration
Zp operator-() const { return Zp(p-val); }
- friend Zp<INT,P> operator- <>(const Zp<INT,P>& a, const Zp<INT,P>& b); // { dg-error "declaration|expected" }
+ // In C++2A, we have an unqualified-id (operator-) followed by
+ // '<', and name lookup found a function.
+ friend Zp<INT,P> operator- <>(const Zp<INT,P>& a, const Zp<INT,P>& b); // { dg-error "declaration|expected" "" { target c++17_down } }
};
projects / gcc.git / commitdiff