[Bug c++/109671] New: Spurious dangling reference warning in GCC 13

[Bug c++/109671] New: Spurious dangling reference warning in GCC 13

[lopresti at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109671

            Bug ID: 109671
           Summary: Spurious dangling reference warning in GCC 13
           Product: gcc
           Version: 13.1.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: lopresti at gmail dot com
  Target Milestone: ---

#include <string>

struct Foo;

extern Foo &get_foo_by_name(const std::string &name);

const Foo &bug(bool x)
{
  const Foo &f = get_foo_by_name(x ? "x" : "y");
  return f;
}

---

Compile with "-O2 -Wall" to get the incorrect warning:

<source>: In function 'const Foo& bug(bool)':
<source>:9:14: warning: possibly dangling reference to a temporary
[-Wdangling-reference]
    9 |   const Foo &f = get_foo_by_name(x ? "x" : "y");
      |              ^
<source>:9:33: note: the temporary was destroyed at the end of the full
expression 'get_foo_by_name(std::__cxx11::basic_string<char>(((const char*)(x ?
"x" : "y")), std::allocator<char>()))'
    9 |   const Foo &f = get_foo_by_name(x ? "x" : "y");
      |                  ~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~

--

Godbolt: https://godbolt.org/z/cn4W7ohGb

The code is fine. (And no other compiler warns about this, including earlier
GCC versions.)

[Bug c++/109671] Spurious dangling reference warning in GCC 13

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109671

--- Comment #1 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
There is no way for GCC to know that get_foo_by_name does not store the
argument into what is returned so it warns about this case ...

[Bug c++/109671] Spurious dangling reference warning in GCC 13

[lopresti at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109671

--- Comment #2 from Patrick J. LoPresti <lopresti at gmail dot com> ---
Um... OK...

So I have to "correct" my code like so:

const Foo &bug(bool x)
{
  const std::string s = (x ? "x" : "y");
  const Foo &f = get_foo_by_name(s);
  return f;
}

But if get_foo_by_name() has the problem GCC is worried about, this does not
even fix it.

This warning seems silly to me. "I cannot tell if you are managing lifetimes
properly, so I will just recommend you do not use temporaries"?

Const references have always bound to temporaries. This warning seems to be
discouraging that (?)

[Bug c++/109671] Spurious dangling reference warning in GCC 13

[lopresti at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109671

--- Comment #3 from Patrick J. LoPresti <lopresti at gmail dot com> ---
(In reply to Andrew Pinski from comment #1)
> There is no way for GCC to know that get_foo_by_name does not store the
> argument into what is returned so it warns about this case ...

To summarize:

GCC is warning because it does not and cannot know whether I am managing object
lifetimes correctly.

The only way to silence the warning is to modify my code to make it uglier,
into a form where GCC still does not and cannot know whether I am managing
lifetimes correctly.

So is this a valid bug report, or not?

[Bug c++/109671] Spurious dangling reference warning in GCC 13

[cvs-commit at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109671

--- Comment #4 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The releases/gcc-13 branch has been updated by Marek Polacek
<mpolacek@gcc.gnu.org>:

https://gcc.gnu.org/g:6b927b1297e66e26e62e722bf15c921dcbbd25b9

commit r13-7276-g6b927b1297e66e26e62e722bf15c921dcbbd25b9
Author: Marek Polacek <polacek@redhat.com>
Date:   Tue May 2 15:48:40 2023 -0400

    c++: Move -Wdangling-reference to -Wextra [PR109642]

    Sadly, -Wdangling-reference generates false positives for std::span-like
    user classes, and it seems imprudent to attempt to improve the heuristic
    in GCC 13.  Let's move the warning to -Wextra, that will hopefully
    reduce the number of false positives the users have been seeing with 13.

    I'm leaving the warning in -Wall in 14 where I think I can write code
    to detect std::span-like classes.

            PR c++/109642
            PR c++/109640
            PR c++/109671

    gcc/c-family/ChangeLog:

            * c.opt (Wdangling-reference): Move from -Wall to -Wextra.

    gcc/ChangeLog:

            * doc/invoke.texi: Document that -Wdangling-reference is
            enabled by -Wextra.

[Bug c++/109671] Spurious dangling reference warning in GCC 13

[mpolacek at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109671

Marek Polacek <mpolacek at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
         Resolution|---                         |DUPLICATE
                 CC|                            |mpolacek at gcc dot gnu.org
             Status|UNCONFIRMED                 |RESOLVED

--- Comment #5 from Marek Polacek <mpolacek at gcc dot gnu.org> ---
(In reply to Patrick J. LoPresti from comment #3)
> (In reply to Andrew Pinski from comment #1)
> > There is no way for GCC to know that get_foo_by_name does not store the
> > argument into what is returned so it warns about this case ...
> 
> To summarize:
> 
> GCC is warning because it does not and cannot know whether I am managing
> object lifetimes correctly.
> 
> The only way to silence the warning is to modify my code to make it uglier,
> into a form where GCC still does not and cannot know whether I am managing
> lifetimes correctly.
> 
> So is this a valid bug report, or not?

It's valid but also I don't think I can tweak the heuristic not to warn here. 
There ought to be a simpler way to suppress the warning, see bug 109642.

*** This bug has been marked as a duplicate of bug 109642 ***