c++: Mitigate -Wuseless-cast with classes [PR85043]

-Wuseless-cast (not part of -Wall/-Wextra) warns here:

  struct S { };
  void g (S&&);
  void f (S&& arg)
  {
    g (S(arg)); // warning: useless cast to type 'struct S'
  }

which is wrong: the code will not compile without the cast because
"arg" is an lvalue which cannot bind to S&&.

This patch disables the warning when an object that isn't a prvalue
is cast to a non-reference type.  Therefore we still warn about the
useless cast in "X(X{})".

	PR c++/85043

gcc/cp/ChangeLog:

	* typeck.cc (maybe_warn_about_useless_cast): Don't warn when
	a glvalue is cast to a non-reference type.

gcc/ChangeLog:

	* doc/invoke.texi: Update documentation of -Wuseless-cast.

gcc/testsuite/ChangeLog:

	* g++.dg/warn/Wuseless-cast.C: Remove dg-warning.
	* g++.dg/warn/Wuseless-cast3.C: New test.

diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
index da0e1427b977455da0ada30fb376977f1c0095f7..16e7d85793d52901759e8237caa8f8abf113f3fc 100644 (file)
--- a/gcc/cp/typeck.cc
+++ b/gcc/cp/typeck.cc
@@ -8104,11 +8104,13 @@ maybe_warn_about_useless_cast (location_t loc, tree type, tree expr,
   if (warn_useless_cast
       && complain & tf_warning)
     {
-      if ((TYPE_REF_P (type)
-          && (TYPE_REF_IS_RVALUE (type)
-              ? xvalue_p (expr) : lvalue_p (expr))
-          && same_type_p (TREE_TYPE (expr), TREE_TYPE (type)))
-         || same_type_p (TREE_TYPE (expr), type))
+      if (TYPE_REF_P (type)
+         ? ((TYPE_REF_IS_RVALUE (type)
+             ? xvalue_p (expr) : lvalue_p (expr))
+            && same_type_p (TREE_TYPE (expr), TREE_TYPE (type)))
+         /* Don't warn when converting a class object to a non-reference type,
+            because that's a common way to create a temporary.  */
+         : (!glvalue_p (expr) && same_type_p (TREE_TYPE (expr), type)))
        warning_at (loc, OPT_Wuseless_cast,
                    "useless cast to type %q#T", type);
     }

diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index c176e2dc646761e25d7e430daa57b648cf88e5ba..cd4d3c1d72ce605618d78cabb6bce7431b53092c 100644 (file)
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -4551,7 +4551,18 @@ pointers after reallocation.
 @item -Wuseless-cast @r{(C++ and Objective-C++ only)}
 @opindex Wuseless-cast
 @opindex Wno-useless-cast
-Warn when an expression is casted to its own type.
+Warn when an expression is cast to its own type.  This warning does not
+occur when a class object is converted to a non-reference type as that
+is a way to create a temporary:
+
+@smallexample
+struct S @{ @};
+void g (S&&);
+void f (S&& arg)
+@{
+  g (S(arg)); // make arg prvalue so that it can bind to S&&
+@}
+@end smallexample
 
 @item -Wno-conversion-null @r{(C++ and Objective-C++ only)}
 @opindex Wconversion-null

diff --git a/gcc/testsuite/g++.dg/warn/Wuseless-cast.C b/gcc/testsuite/g++.dg/warn/Wuseless-cast.C
index 2fd6bc451026f70644f71379de80ad7408ceac32..d7cb89930a6ffb72ee2a6e9e50ff561cc0239394 100644 (file)
--- a/gcc/testsuite/g++.dg/warn/Wuseless-cast.C
+++ b/gcc/testsuite/g++.dg/warn/Wuseless-cast.C
@@ -62,11 +62,11 @@ A prvalue();
 
 void f()
 {
-  int n; 
+  int n;
 
-  (int)(n);                    // { dg-warning "3:useless cast" }
-  static_cast<int>(n);         // { dg-warning "3:useless cast" }
-  reinterpret_cast<int>(n);    // { dg-warning "3:useless cast" }
+  (int)(n);
+  static_cast<int>(n);
+  reinterpret_cast<int>(n);
 
   (int*)(&n);                  // { dg-warning "3:useless cast" }
   const_cast<int*>(&n);        // { dg-warning "3:useless cast" }
@@ -100,8 +100,8 @@ void f()
 
   A a;
 
-  (A)(a);                     // { dg-warning "3:useless cast" }
-  static_cast<A>(a);          // { dg-warning "3:useless cast" }
+  (A)(a);
+  static_cast<A>(a);
 
   (A*)(&a);                   // { dg-warning "3:useless cast" }
   const_cast<A*>(&a);         // { dg-warning "3:useless cast" }

diff --git a/gcc/testsuite/g++.dg/warn/Wuseless-cast3.C b/gcc/testsuite/g++.dg/warn/Wuseless-cast3.C
new file mode 100644 (file)
index 0000000..43dd2eb
--- /dev/null
+++ b/gcc/testsuite/g++.dg/warn/Wuseless-cast3.C
@@ -0,0 +1,29 @@
+// PR c++/85043
+// { dg-do compile { target c++11 } }
+// { dg-options "-Wuseless-cast" }
+
+struct S { int s; void bump () { s++; } };
+
+void
+foo ()
+{
+  S s = { 1 };
+  s.bump ();
+  S (s).bump (); // { dg-bogus "useless" }
+  ((S) s).bump (); // { dg-bogus "useless" }
+  static_cast<S> (s).bump (); // { dg-bogus "useless" }
+}
+
+struct X { };
+void g(X&&);
+
+void
+f (X&& arg)
+{
+  g(X(arg)); // { dg-bogus "useless" }
+  g(X(X{})); // { dg-warning "useless" }
+  g(static_cast<X&&>(arg));
+
+  int i = (int) 1; // { dg-warning "useless" }
+  const int &r = (int) i; // { dg-bogus "useless" }
+}