+2014-05-12 Jason Merrill <jason@redhat.com>
+
+ * call.c (convert_like_real): Use inform for identifying the
+ declaration point.
+
2014-05-12 Paolo Carlini <paolo.carlini@oracle.com>
* cvt.c (cp_convert_to_pointer): Don't call error_at if
return expr;
expr = build_temp (expr, totype, flags, &diag_kind, complain);
if (diag_kind && fn && complain)
- emit_diagnostic (diag_kind, DECL_SOURCE_LOCATION (fn), 0,
- " initializing argument %P of %qD", argnum, fn);
+ inform (DECL_SOURCE_LOCATION (fn),
+ " initializing argument %P of %qD", argnum, fn);
return build_cplus_new (totype, expr, complain);
case ck_ref_bind:
B(B&&) = default; // { dg-error "implicitly deleted|use of deleted" }
};
-void g(B); // { dg-error "argument 1" }
+void g(B); // { dg-message "argument 1" }
B&& f();
int main()
B(B&); // { dg-message "note" "" }
};
-void foo(B); // { dg-error "initializing" }
+void foo(B); // { dg-message "initializing" }
void bar()
{
struct A
{
- A (B); // { dg-error "initializing" }
+ A (B); // { dg-message "initializing" }
};
B
struct A { };
-void f (A); // { dg-error "argument 1" }
+void f (A); // { dg-message "" }
void (*g)(A);
int main()
X(); // { dg-message "note" }
explicit X(const X&);
};
- void f(X); // { dg-error "initializing" }
+ void f(X); // { dg-message "initializing" }
int foo()
{
X x;
};
template <class T>
- void f(T ) {} // { dg-error "initializing" }
+ void f(T) {} // { dg-message "initializing" }
template <class T>
int foo()
template <typename T> struct X
{
- static int f (T); // { dg-error "initializing" }
+ static int f (T); // { dg-message "initializing" }
static const T &make ();
};
template <typename T> struct X
{
- static int f (T); // { dg-error "initializing" }
+ static int f (T); // { dg-message "initializing" }
static const T &make ();
static const bool value = sizeof (f (make ())) == sizeof (int); // { dg-error "invalid use of incomplete type" }
};
class A; // { dg-error "forward declaration" }
-int f (A); // { dg-error "initializing" }
+int f (A); // { dg-message "initializing" }
const A &make ();
int
B(void) {}
};
-void f(B b) { // { dg-error "initializing" }
+void f(B b) { // { dg-message "initializing" }
}
void g() {
auto_ptr<Derived> f() { auto_ptr<Derived> null(0); return null; }
void g(auto_ptr<Derived>) { }
-void h(auto_ptr<Base>) { } // { dg-error "initializing" }
+void h(auto_ptr<Base>) { } // { dg-message "initializing" }
int main() {
auto_ptr<Base> x(f());
// { dg-do assemble }
template <class T>
-void f(T) {} // { dg-error "initializing" }
+void f(T) {} // { dg-message "initializing" }
class C; // { dg-error "forward declaration" }