[v4] c++: Implement -Wself-move warning [PR81159]

  On Sat, Aug 20, 2022 at 05:31:52PM -0400, Jason Merrill wrote:
> On 8/19/22 15:34, Marek Polacek wrote:
> > On Thu, Aug 18, 2022 at 08:33:47PM -0400, Jason Merrill wrote:
> > > On 8/18/22 13:19, Marek Polacek wrote:
> > > > On Mon, Aug 15, 2022 at 03:54:05PM -0400, Jason Merrill wrote:
> > > > > On 8/9/22 09:37, Marek Polacek wrote:
> > > > > > +  /* We're looking for *std::move<T&> ((T &) &arg), or
> > > > > > +     *std::move<T&> ((T &) (T *) r) if the argument it a reference.  */
> > > > > > +  if (!REFERENCE_REF_P (rhs)
> > > > > > +      || TREE_CODE (TREE_OPERAND (rhs, 0)) != CALL_EXPR)
> > > > > > +    return;
> > > > > > +  tree fn = TREE_OPERAND (rhs, 0);
> > > > > > +  if (!is_std_move_p (fn))
> > > > > > +    return;
> > > > > > +  tree arg = CALL_EXPR_ARG (fn, 0);
> > > > > > +  if (TREE_CODE (arg) != NOP_EXPR)
> > > > > > +    return;
> > > > > > +  /* Strip the (T &).  */
> > > > > > +  arg = TREE_OPERAND (arg, 0);
> > > > > > +  /* Strip the (T *) or &.  */
> > > > > > +  arg = TREE_OPERAND (arg, 0);
> > > > > 
> > > > > Are you sure these are the only two expressions that can make it here? What
> > > > > if the argument to move is *Tptr?
> > > > 
> > > > Not 100% sure but I couldn't find any other form.  For *Tptr we get
> > > > *std::move<int*&> ((int * &) &Tptr)
> > > 
> > > That likes like what you'd get when the argument is Tptr, not when it's
> > > *Tptr.  And indeed that's what I see in the testcase:
> > > 
> > > > +  Tptr = std::move (Tptr); // { dg-warning "moving a variable to itself" }
> > > 
> > > is missing the *
> > 
> > Duh, sorry.  The previous patch didn't handle the *Tptr case.  Further poking
> > revealed that we need special care to handle (*(Tptr)) and **Tptr etc.  So in
> > this patch I'm stripping all *s and V_C_Es.  Sigh.
> 
> Ah, I was just thinking that the old patch needed more checking of
> TREE_CODEs.  But I suppose it's also good to diagnose these cases as well.

Probably.  I notice that clang++ doesn't detect it, but that doesn't mean
we can't.
 
> > +  if (cp_tree_equal (lhs, arg))
> > +    {
> > +      auto_diagnostic_group d;
> > +      if (warning_at (loc, OPT_Wself_move, "moving a variable to itself"))
> 
> Maybe only say "variable" when the original operand is in fact a variable?

Fixed by the print_var_p thingie I introduced.  I saw that clang++ points
out the type so I'm printing it too in this patch.
 
> > +// Test various other arguments to std::move.
> > +template<typename T>
> > +void
> > +testargs (T *Tptr, T **Tpptr, T& Tref, T&& Trref, const T *Tcptr)
> > +{
> > +  Tptr = std::move (Tptr); // { dg-warning "moving a variable to itself" }
> > +  *Tptr = std::move (*Tptr); // { dg-warning "moving a variable to itself" }
> > +  *Tptr = std::move (*(Tptr)); // { dg-warning "moving a variable to itself" }
> > +  *(Tptr) = std::move (*Tptr); // { dg-warning "moving a variable to itself" }
> > +  *(Tptr + 1) = std::move (*Tptr + 1);
> > +  *(Tptr + 1) = std::move (*Tptr + 2);
> 
> Do you mean to have *(Tptr + 1) on both sides?  The difference in * operand
> is surprising.

Definitely not intended, good spotting!  Fixed (we emit a warning for the
+1 case but not the +2 case -- good).

Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk?

-- >8 --
About 5 years ago we got a request to implement -Wself-move, which
warns about useless moves like this:

  int x;
  x = std::move (x);

This patch implements that warning.

	PR c++/81159

gcc/c-family/ChangeLog:

	* c.opt (Wself-move): New option.

gcc/cp/ChangeLog:

	* typeck.cc (maybe_warn_self_move): New.
	(cp_build_modify_expr): Call maybe_warn_self_move.

gcc/ChangeLog:

	* doc/invoke.texi: Document -Wself-move.

gcc/testsuite/ChangeLog:

	* g++.dg/warn/Wself-move1.C: New test.
---
 gcc/c-family/c.opt                      |   4 +
 gcc/cp/typeck.cc                        |  61 +++++++++++-
 gcc/doc/invoke.texi                     |  23 ++++-
 gcc/testsuite/g++.dg/warn/Wself-move1.C | 125 ++++++++++++++++++++++++
 4 files changed, 211 insertions(+), 2 deletions(-)
 create mode 100644 gcc/testsuite/g++.dg/warn/Wself-move1.C


base-commit: baa3ffb19c54fa334ac2884f6acb5d31aa79ac32
  

On 8/23/22 09:39, Marek Polacek wrote:
> On Sat, Aug 20, 2022 at 05:31:52PM -0400, Jason Merrill wrote:
>> On 8/19/22 15:34, Marek Polacek wrote:
>>> On Thu, Aug 18, 2022 at 08:33:47PM -0400, Jason Merrill wrote:
>>>> On 8/18/22 13:19, Marek Polacek wrote:
>>>>> On Mon, Aug 15, 2022 at 03:54:05PM -0400, Jason Merrill wrote:
>>>>>> On 8/9/22 09:37, Marek Polacek wrote:
>>>>>>> +  /* We're looking for *std::move<T&> ((T &) &arg), or
>>>>>>> +     *std::move<T&> ((T &) (T *) r) if the argument it a reference.  */
>>>>>>> +  if (!REFERENCE_REF_P (rhs)
>>>>>>> +      || TREE_CODE (TREE_OPERAND (rhs, 0)) != CALL_EXPR)
>>>>>>> +    return;
>>>>>>> +  tree fn = TREE_OPERAND (rhs, 0);
>>>>>>> +  if (!is_std_move_p (fn))
>>>>>>> +    return;
>>>>>>> +  tree arg = CALL_EXPR_ARG (fn, 0);
>>>>>>> +  if (TREE_CODE (arg) != NOP_EXPR)
>>>>>>> +    return;
>>>>>>> +  /* Strip the (T &).  */
>>>>>>> +  arg = TREE_OPERAND (arg, 0);
>>>>>>> +  /* Strip the (T *) or &.  */
>>>>>>> +  arg = TREE_OPERAND (arg, 0);
>>>>>>
>>>>>> Are you sure these are the only two expressions that can make it here? What
>>>>>> if the argument to move is *Tptr?
>>>>>
>>>>> Not 100% sure but I couldn't find any other form.  For *Tptr we get
>>>>> *std::move<int*&> ((int * &) &Tptr)
>>>>
>>>> That likes like what you'd get when the argument is Tptr, not when it's
>>>> *Tptr.  And indeed that's what I see in the testcase:
>>>>
>>>>> +  Tptr = std::move (Tptr); // { dg-warning "moving a variable to itself" }
>>>>
>>>> is missing the *
>>>
>>> Duh, sorry.  The previous patch didn't handle the *Tptr case.  Further poking
>>> revealed that we need special care to handle (*(Tptr)) and **Tptr etc.  So in
>>> this patch I'm stripping all *s and V_C_Es.  Sigh.
>>
>> Ah, I was just thinking that the old patch needed more checking of
>> TREE_CODEs.  But I suppose it's also good to diagnose these cases as well.
> 
> Probably.  I notice that clang++ doesn't detect it, but that doesn't mean
> we can't.
>   
>>> +  if (cp_tree_equal (lhs, arg))
>>> +    {
>>> +      auto_diagnostic_group d;
>>> +      if (warning_at (loc, OPT_Wself_move, "moving a variable to itself"))
>>
>> Maybe only say "variable" when the original operand is in fact a variable?
> 
> Fixed by the print_var_p thingie I introduced.  I saw that clang++ points
> out the type so I'm printing it too in this patch.
>   
>>> +// Test various other arguments to std::move.
>>> +template<typename T>
>>> +void
>>> +testargs (T *Tptr, T **Tpptr, T& Tref, T&& Trref, const T *Tcptr)
>>> +{
>>> +  Tptr = std::move (Tptr); // { dg-warning "moving a variable to itself" }
>>> +  *Tptr = std::move (*Tptr); // { dg-warning "moving a variable to itself" }
>>> +  *Tptr = std::move (*(Tptr)); // { dg-warning "moving a variable to itself" }
>>> +  *(Tptr) = std::move (*Tptr); // { dg-warning "moving a variable to itself" }
>>> +  *(Tptr + 1) = std::move (*Tptr + 1);
>>> +  *(Tptr + 1) = std::move (*Tptr + 2);
>>
>> Do you mean to have *(Tptr + 1) on both sides?  The difference in * operand
>> is surprising.
> 
> Definitely not intended, good spotting!  Fixed (we emit a warning for the
> +1 case but not the +2 case -- good).
> 
> Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk?
> 
> -- >8 --
> About 5 years ago we got a request to implement -Wself-move, which
> warns about useless moves like this:
> 
>    int x;
>    x = std::move (x);
> 
> This patch implements that warning.
> 
> 	PR c++/81159
> 
> gcc/c-family/ChangeLog:
> 
> 	* c.opt (Wself-move): New option.
> 
> gcc/cp/ChangeLog:
> 
> 	* typeck.cc (maybe_warn_self_move): New.
> 	(cp_build_modify_expr): Call maybe_warn_self_move.
> 
> gcc/ChangeLog:
> 
> 	* doc/invoke.texi: Document -Wself-move.
> 
> gcc/testsuite/ChangeLog:
> 
> 	* g++.dg/warn/Wself-move1.C: New test.
> ---
>   gcc/c-family/c.opt                      |   4 +
>   gcc/cp/typeck.cc                        |  61 +++++++++++-
>   gcc/doc/invoke.texi                     |  23 ++++-
>   gcc/testsuite/g++.dg/warn/Wself-move1.C | 125 ++++++++++++++++++++++++
>   4 files changed, 211 insertions(+), 2 deletions(-)
>   create mode 100644 gcc/testsuite/g++.dg/warn/Wself-move1.C
> 
> diff --git a/gcc/c-family/c.opt b/gcc/c-family/c.opt
> index dfdebd596ef..f776efd39d8 100644
> --- a/gcc/c-family/c.opt
> +++ b/gcc/c-family/c.opt
> @@ -1229,6 +1229,10 @@ Wselector
>   ObjC ObjC++ Var(warn_selector) Warning
>   Warn if a selector has multiple methods.
>   
> +Wself-move
> +C++ ObjC++ Var(warn_self_move) Warning LangEnabledBy(C++ ObjC++, Wall)
> +Warn when a value is moved to itself with std::move.
> +
>   Wsequence-point
>   C ObjC C++ ObjC++ Var(warn_sequence_point) Warning LangEnabledBy(C ObjC C++ ObjC++,Wall)
>   Warn about possible violations of sequence point rules.
> diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
> index 992ebfd99fb..194c403bd2b 100644
> --- a/gcc/cp/typeck.cc
> +++ b/gcc/cp/typeck.cc
> @@ -8897,7 +8897,64 @@ cp_build_c_cast (location_t loc, tree type, tree expr,
>   
>     return error_mark_node;
>   }
> -
> +
> +/* Warn when a value is moved to itself with std::move.  LHS is the target,
> +   RHS may be the std::move call, and LOC is the location of the whole
> +   assignment.  */
> +
> +static void
> +maybe_warn_self_move (location_t loc, tree lhs, tree rhs)
> +{
> +  if (!warn_self_move)
> +    return;
> +
> +  /* C++98 doesn't know move.  */
> +  if (cxx_dialect < cxx11)
> +    return;
> +
> +  if (processing_template_decl)
> +    return;
> +
> +  if (!REFERENCE_REF_P (rhs)
> +      || TREE_CODE (TREE_OPERAND (rhs, 0)) != CALL_EXPR)
> +    return;
> +  tree fn = TREE_OPERAND (rhs, 0);
> +  if (!is_std_move_p (fn))
> +    return;
> +
> +  /* Just a little helper to strip * and various NOPs.  */
> +  auto extract_op = [] (tree &op) {
> +    STRIP_NOPS (op);
> +    while (INDIRECT_REF_P (op))
> +      op = TREE_OPERAND (op, 0);
> +    op = maybe_undo_parenthesized_ref (op);
> +    STRIP_ANY_LOCATION_WRAPPER (op);
> +  };
> +
> +  tree arg = CALL_EXPR_ARG (fn, 0);
> +  extract_op (arg);
> +  if (TREE_CODE (arg) == ADDR_EXPR)
> +    arg = TREE_OPERAND (arg, 0);
> +  tree type = TREE_TYPE (lhs);
> +  lhs = maybe_undo_parenthesized_ref (lhs);
> +  STRIP_ANY_LOCATION_WRAPPER (lhs);
> +  const bool print_var_p = (DECL_P (lhs)
> +			    || REFERENCE_REF_P (lhs)
> +			    || TREE_CODE (lhs) == COMPONENT_REF);

Why include REFERENCE_REF_P and COMPONENT_REF?  Reference refs should be 
stripped before this test, member refs aren't variables.

> +  extract_op (lhs);
> +
> +  if (cp_tree_equal (lhs, arg))
> +    {
> +      auto_diagnostic_group d;
> +      if (print_var_p
> +	  ? warning_at (loc, OPT_Wself_move,
> +			"moving a variable of type %qT to itself", type)
> +	  : warning_at (loc, OPT_Wself_move,
> +			"moving an expression of type %qT to itself", type))
> +	inform (loc, "remove %<std::move%> call");
> +    }
> +}
> +
>   /* For use from the C common bits.  */
>   tree
>   build_modify_expr (location_t location,
> @@ -9101,6 +9158,8 @@ cp_build_modify_expr (location_t loc, tree lhs, enum tree_code modifycode,
>   
>         if (modifycode == NOP_EXPR)
>   	{
> +	  maybe_warn_self_move (loc, lhs, rhs);
> +
>   	  if (c_dialect_objc ())
>   	    {
>   	      result = objc_maybe_build_modify_expr (lhs, rhs);
> diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
> index 78eb7ad7e74..dc686da8b9f 100644
> --- a/gcc/doc/invoke.texi
> +++ b/gcc/doc/invoke.texi
> @@ -264,7 +264,7 @@ in the following sections.
>   -Wreorder  -Wregister @gol
>   -Wstrict-null-sentinel  -Wno-subobject-linkage  -Wtemplates @gol
>   -Wno-non-template-friend  -Wold-style-cast @gol
> --Woverloaded-virtual  -Wno-pmf-conversions -Wsign-promo @gol
> +-Woverloaded-virtual  -Wno-pmf-conversions -Wself-move -Wsign-promo @gol
>   -Wsized-deallocation  -Wsuggest-final-methods @gol
>   -Wsuggest-final-types  -Wsuggest-override  @gol
>   -Wno-terminate  -Wuseless-cast  -Wno-vexing-parse  @gol
> @@ -5844,6 +5844,7 @@ Options} and @ref{Objective-C and Objective-C++ Dialect Options}.
>   -Wreorder   @gol
>   -Wrestrict   @gol
>   -Wreturn-type  @gol
> +-Wself-move @r{(only for C++)}  @gol
>   -Wsequence-point  @gol
>   -Wsign-compare @r{(only in C++)}  @gol
>   -Wsizeof-array-div @gol
> @@ -6829,6 +6830,26 @@ of a declaration:
>   
>   This warning is enabled by @option{-Wall}.
>   
> +@item -Wno-self-move @r{(C++ and Objective-C++ only)}
> +@opindex Wself-move
> +@opindex Wno-self-move
> +This warning warns when a value is moved to itself with @code{std::move}.
> +Such a @code{std::move} typically has no effect.
> +
> +@smallexample
> +struct T @{
> +@dots{}
> +@};
> +void fn()
> +@{
> +  T t;
> +  @dots{}
> +  t = std::move (t);
> +@}
> +@end smallexample
> +
> +This warning is enabled by @option{-Wall}.
> +
>   @item -Wsequence-point
>   @opindex Wsequence-point
>   @opindex Wno-sequence-point
> diff --git a/gcc/testsuite/g++.dg/warn/Wself-move1.C b/gcc/testsuite/g++.dg/warn/Wself-move1.C
> new file mode 100644
> index 00000000000..39111f0a2b0
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/warn/Wself-move1.C
> @@ -0,0 +1,125 @@
> +// PR c++/81159
> +// { dg-do compile { target c++11 } }
> +// { dg-options "-Wself-move" }
> +
> +// Define std::move.
> +namespace std {
> +  template<typename _Tp>
> +    struct remove_reference
> +    { typedef _Tp   type; };
> +
> +  template<typename _Tp>
> +    struct remove_reference<_Tp&>
> +    { typedef _Tp   type; };
> +
> +  template<typename _Tp>
> +    struct remove_reference<_Tp&&>
> +    { typedef _Tp   type; };
> +
> +  template<typename _Tp>
> +    constexpr typename std::remove_reference<_Tp>::type&&
> +    move(_Tp&& __t) noexcept
> +    { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
> +}
> +
> +int g;
> +
> +struct S {
> +  int x;
> +  S(S&& o) {
> +    x = std::move (x); // { dg-warning "moving a variable of type .int. to itself" }
> +    x = std::move (o.x);
> +    o.x = std::move (x);
> +    o.x = std::move (o.x); // { dg-warning "moving a variable of type .int. to itself" }
> +  }
> +  void foo (int x) {
> +    x = std::move (x); // { dg-warning "moving a variable of type .int. to itself" }
> +  }
> +};
> +
> +struct X {
> +  int x;
> +  X(int x) : x(std::move (x)) { }
> +};
> +
> +struct A {};
> +struct B { A a; };
> +struct C { C(); ~C(); };
> +struct D { D(); D(const D&); D(D&&); D& operator=(const D&); };
> +
> +void
> +test ()
> +{
> +  int i = 42;
> +  i = std::move (i); // { dg-warning "moving a variable of type .int. to itself" }
> +  (i) = std::move (i); // { dg-warning "moving a variable of type .int. to itself" }
> +
> +  g = std::move (g); // { dg-warning "moving a variable of type .int. to itself" }
> +  (g) = std::move (g); // { dg-warning "moving a variable of type .int. to itself" }
> +
> +  A a;
> +  a = std::move (a); // { dg-warning "moving a variable of type .A. to itself" }
> +  (a) = std::move (a); // { dg-warning "moving a variable of type .A. to itself" }
> +
> +  B b;
> +  b = std::move (b); // { dg-warning "moving a variable of type .B. to itself" }
> +  (b) = std::move (b); // { dg-warning "moving a variable of type .B. to itself" }
> +  b.a = std::move (b.a); // { dg-warning "moving a variable of type .A. to itself" }
> +  (b.a) = std::move (b.a); // { dg-warning "moving a variable of type .A. to itself" }
> +
> +  C c;
> +  c = std::move (c); // { dg-warning "moving a variable of type .C. to itself" }
> +  D d;
> +  d = std::move (d); // { dg-warning "moving a variable of type .D. to itself" }
> +}
> +
> +template<typename T>
> +void ttest ()
> +{
> +  T t;
> +  t = std::move (t); // { dg-warning "moving a variable of type .A. to itself" }
> +}
> +
> +template void ttest<A>();
> +
> +void
> +testref (int &r, int &&rr)
> +{
> +  r = std::move (r); // { dg-warning "moving a variable of type .int. to itself" }
> +  rr = std::move (rr); // { dg-warning "moving a variable of type .int. to itself" }
> +}
> +
> +// Test various other arguments to std::move.
> +template<typename T>
> +void
> +testargs (T *Tptr, T **Tpptr, T& Tref, T&& Trref, const T *Tcptr)
> +{
> +  Tptr = std::move (Tptr); // { dg-warning "moving a variable of type 'int\\*' to itself" }
> +  *Tptr = std::move (*Tptr); // { dg-warning "moving an expression of type 'int' to itself" }
> +  *Tptr = std::move (*(Tptr)); // { dg-warning "moving an expression of type 'int' to itself" }
> +  *(Tptr) = std::move (*Tptr); // { dg-warning "moving an expression of type 'int' to itself" }
> +  *(Tptr + 1) = std::move (*(Tptr + 1)); // { dg-warning "moving an expression of type 'int' to itself" }
> +  *(Tptr + 1) = std::move (*(Tptr + 2));
> +  (*(Tptr)) = std::move (*Tptr); // { dg-warning "moving an expression of type 'int' to itself" }
> +  *Tpptr = std::move (*Tpptr); // { dg-warning "moving an expression of type 'int\\*' to itself" }
> +  **Tpptr = std::move (**Tpptr); // { dg-warning "moving an expression of type 'int' to itself" }
> +  Tref = std::move (Tref); // { dg-warning "moving a variable of type 'int' to itself" }
> +  Trref = std::move (Trref); // { dg-warning "moving a variable of type 'int' to itself" }
> +  Tcptr = std::move (Tcptr); // { dg-warning "moving a variable of type 'const int\\*' to itself" }
> +  (Tptr) = std::move (Tptr); // { dg-warning "moving a variable of type 'int\\*' to itself" }
> +  (*Tptr) = std::move (*Tptr); // { dg-warning "moving an expression of type 'int' to itself" }
> +  (*Tpptr) = std::move (*Tpptr); // { dg-warning "moving an expression of type 'int\\*' to itself" }
> +  (**Tpptr) = std::move (**Tpptr); // { dg-warning "moving an expression of type 'int' to itself" }
> +  (*(*(Tpptr))) = std::move (**Tpptr); // { dg-warning "moving an expression of type 'int' to itself" }
> +  (Tref) = std::move (Tref); // { dg-warning "moving a variable of type 'int' to itself" }
> +  (Trref) = std::move (Trref); // { dg-warning "moving a variable of type 'int' to itself" }
> +  (Tcptr) = std::move (Tcptr); // { dg-warning "moving a variable of type 'const int\\*' to itself" }
> +}
> +
> +void
> +call_testargs ()
> +{
> +  int i = 42;
> +  int *p = &i;
> +  testargs<int>(&i, &p, i, 42, &i);
> +}
> 
> base-commit: baa3ffb19c54fa334ac2884f6acb5d31aa79ac32
  

On Tue, Aug 23, 2022 at 05:27:00PM -0400, Jason Merrill wrote:
> On 8/23/22 09:39, Marek Polacek wrote:
> > +  tree arg = CALL_EXPR_ARG (fn, 0);
> > +  extract_op (arg);
> > +  if (TREE_CODE (arg) == ADDR_EXPR)
> > +    arg = TREE_OPERAND (arg, 0);
> > +  tree type = TREE_TYPE (lhs);
> > +  lhs = maybe_undo_parenthesized_ref (lhs);
> > +  STRIP_ANY_LOCATION_WRAPPER (lhs);
> > +  const bool print_var_p = (DECL_P (lhs)
> > +			    || REFERENCE_REF_P (lhs)
> > +			    || TREE_CODE (lhs) == COMPONENT_REF);
> 
> Why include REFERENCE_REF_P and COMPONENT_REF?  Reference refs should be
> stripped before this test, member refs aren't variables.

I'm checking REFERENCE_REF_P and COMPONENT_REF to say "moving a variable"
in #1 and #3.  The REFERENCE_REF_P check means that we also say "variable"
for #2.  Sure, "A variable is introduced by the declaration of a reference
other than a non-static data member", but I'm not sure if users care about
that here?

If I strip REFERENCE_REFs before the check then the result will be the
same.  Or I could keep only the DECL_P check, but then we'll say "moving
an expression" for #1 and #2, which seems strange.

struct S {
  int x;
  int &r;
  void foo () {
    x = std::move (x); // #1
    r = std::move (r); // #2
  };
};

void
foo (int &r)
{
  r = std::move (r); // #3
}

Marek
  

On 8/24/22 17:30, Marek Polacek wrote:
> On Tue, Aug 23, 2022 at 05:27:00PM -0400, Jason Merrill wrote:
>> On 8/23/22 09:39, Marek Polacek wrote:
>>> +  tree arg = CALL_EXPR_ARG (fn, 0);
>>> +  extract_op (arg);
>>> +  if (TREE_CODE (arg) == ADDR_EXPR)
>>> +    arg = TREE_OPERAND (arg, 0);
>>> +  tree type = TREE_TYPE (lhs);
>>> +  lhs = maybe_undo_parenthesized_ref (lhs);
>>> +  STRIP_ANY_LOCATION_WRAPPER (lhs);
>>> +  const bool print_var_p = (DECL_P (lhs)
>>> +			    || REFERENCE_REF_P (lhs)
>>> +			    || TREE_CODE (lhs) == COMPONENT_REF);
>>
>> Why include REFERENCE_REF_P and COMPONENT_REF?  Reference refs should be
>> stripped before this test, member refs aren't variables.
> 
> I'm checking REFERENCE_REF_P and COMPONENT_REF to say "moving a variable"
> in #1 and #3.  The REFERENCE_REF_P check means that we also say "variable"
> for #2.  Sure, "A variable is introduced by the declaration of a reference
> other than a non-static data member", but I'm not sure if users care about
> that here?
> 
> If I strip REFERENCE_REFs before the check then the result will be the
> same.

That's what I was suggesting, yes: Strip the REFERENCE_REF so DECL_P can 
see the decl.

I don't see where COMPONENT_REF comes in?

> Or I could keep only the DECL_P check, but then we'll say "moving
> an expression" for #1 and #2, which seems strange.
> 
> struct S {
>    int x;
>    int &r;
>    void foo () {
>      x = std::move (x); // #1
>      r = std::move (r); // #2
>    };
> };
> 
> void
> foo (int &r)
> {
>    r = std::move (r); // #3
> }
> 
> Marek
>
  

On Thu, Aug 25, 2022 at 09:25:43AM -0400, Jason Merrill wrote:
> On 8/24/22 17:30, Marek Polacek wrote:
> > On Tue, Aug 23, 2022 at 05:27:00PM -0400, Jason Merrill wrote:
> > > On 8/23/22 09:39, Marek Polacek wrote:
> > > > +  tree arg = CALL_EXPR_ARG (fn, 0);
> > > > +  extract_op (arg);
> > > > +  if (TREE_CODE (arg) == ADDR_EXPR)
> > > > +    arg = TREE_OPERAND (arg, 0);
> > > > +  tree type = TREE_TYPE (lhs);
> > > > +  lhs = maybe_undo_parenthesized_ref (lhs);
> > > > +  STRIP_ANY_LOCATION_WRAPPER (lhs);
> > > > +  const bool print_var_p = (DECL_P (lhs)
> > > > +			    || REFERENCE_REF_P (lhs)
> > > > +			    || TREE_CODE (lhs) == COMPONENT_REF);
> > > 
> > > Why include REFERENCE_REF_P and COMPONENT_REF?  Reference refs should be
> > > stripped before this test, member refs aren't variables.
> > 
> > I'm checking REFERENCE_REF_P and COMPONENT_REF to say "moving a variable"
> > in #1 and #3.  The REFERENCE_REF_P check means that we also say "variable"
> > for #2.  Sure, "A variable is introduced by the declaration of a reference
> > other than a non-static data member", but I'm not sure if users care about
> > that here?
> > 
> > If I strip REFERENCE_REFs before the check then the result will be the
> > same.
> 
> That's what I was suggesting, yes: Strip the REFERENCE_REF so DECL_P can see
> the decl.

Ok, I've added the REFERENCE_REF stripping.  But I've still left the
COMPONENT_REF in.  Perhaps we could say "moving a member" to itself for
COMPONENT_REFs.  Or just say "moving 'x' of type 'int' to itself" and
avoid all of this.  :)

> I don't see where COMPONENT_REF comes in?

For #1 in the test below the COMPONENT_REF was created in finish_id_expression
-> finish_non_static_data_member -> build_class_member_access_expr and passed
down to maybe_warn_self_move from here:

#0  maybe_warn_self_move (loc=2147483652, lhs=<component_ref 0x7fffea380e10>,
    rhs=<indirect_ref 0x7fffea38a220>) at /home/mpolacek/src/gcc/gcc/cp/typeck.cc:8908
#1  0x0000000000f3d03e in cp_build_modify_expr (loc=2147483652, lhs=<component_ref 0x7fffea380e10>,
    modifycode=NOP_EXPR, rhs=<indirect_ref 0x7fffea38a220>, complain=3)
    at /home/mpolacek/src/gcc/gcc/cp/typeck.cc:9161
#2  0x0000000000f3e461 in build_x_modify_expr (loc=2147483652, lhs=<component_ref 0x7fffea380e10>,
    modifycode=NOP_EXPR, rhs=<indirect_ref 0x7fffea38a220>, lookups=<tree 0x0>, complain=3)
    at /home/mpolacek/src/gcc/gcc/cp/typeck.cc:9446
#3  0x0000000000d92d4e in cp_parser_assignment_expression (parser=0x7fffea236850, pidk=0x0, cast_p=false,
    decltype_p=false) at /home/mpolacek/src/gcc/gcc/cp/parser.cc:10461
 
> > Or I could keep only the DECL_P check, but then we'll say "moving
> > an expression" for #1 and #2, which seems strange.
> > 
> > struct S {
> >    int x;
> >    int &r;
> >    void foo () {
> >      x = std::move (x); // #1
> >      r = std::move (r); // #2
> >    };
> > };
> > 
> > void
> > foo (int &r)
> > {
> >    r = std::move (r); // #3
> > }

Marek
  

On 8/25/22 17:49, Marek Polacek wrote:
> On Thu, Aug 25, 2022 at 09:25:43AM -0400, Jason Merrill wrote:
>> On 8/24/22 17:30, Marek Polacek wrote:
>>> On Tue, Aug 23, 2022 at 05:27:00PM -0400, Jason Merrill wrote:
>>>> On 8/23/22 09:39, Marek Polacek wrote:
>>>>> +  tree arg = CALL_EXPR_ARG (fn, 0);
>>>>> +  extract_op (arg);
>>>>> +  if (TREE_CODE (arg) == ADDR_EXPR)
>>>>> +    arg = TREE_OPERAND (arg, 0);
>>>>> +  tree type = TREE_TYPE (lhs);
>>>>> +  lhs = maybe_undo_parenthesized_ref (lhs);
>>>>> +  STRIP_ANY_LOCATION_WRAPPER (lhs);
>>>>> +  const bool print_var_p = (DECL_P (lhs)
>>>>> +			    || REFERENCE_REF_P (lhs)
>>>>> +			    || TREE_CODE (lhs) == COMPONENT_REF);
>>>>
>>>> Why include REFERENCE_REF_P and COMPONENT_REF?  Reference refs should be
>>>> stripped before this test, member refs aren't variables.
>>>
>>> I'm checking REFERENCE_REF_P and COMPONENT_REF to say "moving a variable"
>>> in #1 and #3.  The REFERENCE_REF_P check means that we also say "variable"
>>> for #2.  Sure, "A variable is introduced by the declaration of a reference
>>> other than a non-static data member", but I'm not sure if users care about
>>> that here?
>>>
>>> If I strip REFERENCE_REFs before the check then the result will be the
>>> same.
>>
>> That's what I was suggesting, yes: Strip the REFERENCE_REF so DECL_P can see
>> the decl.
> 
> Ok, I've added the REFERENCE_REF stripping.  But I've still left the
> COMPONENT_REF in.  Perhaps we could say "moving a member" to itself for
> COMPONENT_REFs.  Or just say "moving 'x' of type 'int' to itself" and
> avoid all of this.  :)

Sure, that would be simpler.  In any case, we shouldn't call member 
references variables.

Jason