Detect dangling references for C++20's Parenthesized Aggregate Initialization

[usx95]

struct MyThing {
    const std::string& s;
};

MyThing makeThing(std::string s) {
    return MyThing(s);
}

https://godbolt.org/z/6335YcKMM

This also doesn't work for gsl::Pointer types like string_view instead of const std::string&. https://godbolt.org/z/8bcaxTqjY

This is different from #58985. This still only needs stmt-local analysis and has probably a simple fix.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Utkarsh Saxena (usx95)

```cpp struct MyThing { const std::string& s; };

MyThing makeThing(std::string s) {
return MyThing(s);
}

https://godbolt.org/z/6335YcKMM

Obviously this also doesn't work `gsl::Pointer` types like `string_view` instead of `const std::string&`.

This is different from https://github.com/llvm/llvm-project/issues/58985. This still only needs stmt-local analysis and has probably a simple fix.
</details>

[usx95]

Considering more broadly the structures with view-type as fields. Adding [[gsl::Pointer]] to such types helps in surfacing more cases:

#include <string>

struct [[gsl::Pointer]] S {
    int a;
    std::string_view s;
    S& setS(const std::string& s [[clang::lifetimebound]])
        [[clang::lifetimebound]] {
        this->s = s;
        return *this;
    }
    S& setA(int a) [[clang::lifetimebound]] {
        this->a = a;
        return *this;
    }
};

S foo() { return S().setS(std::string()); }  // Warning. Fine.
S bar() { return S().setS("12").setA(1); }   // Warning. Fine.

std::string global;
S baz() { return S().setS(global).setA(1); }  // No Warning. Fine.

A direction we could consider separately (if not for this issue) is to infer gsl::Pointer implicitly in such cases (CC: @hokein )

[usx95]

Apparently using an braced init list in the return statement catches this issue:

struct MyThing {
    const std::string& s;
};

MyThing makeThing(std::string s) {
    return {s}; // clang warns here.
}
struct MyThingSV {
    std::string_view s;
};

MyThingSV makeThing(std::string s) {
    return {s}; // clang warns here.
}

https://godbolt.org/z/Mnafoncbc https://godbolt.org/z/ad9Mohh6M

[hokein]

If we spell the class name explicitly, clang doesn't warn it:

MyThing makeThing(std::string s) {
    return MyThing{s}; // clang doesn't warn here.
}

The lifetime analysis probably misses the CXXFunctionalCast case?

[hokein]

I think this is a missing feature -- where clang doesn't support detecting dangling issues for C++20's parenthesized aggregate initialization (the syntax like MyThing(s)). This is stated in the commit 9b4faa1.

Per https://eel.is/c++draft/dcl.init#general-16.6.2.2, it would be nice if clang can catch these cases:

struct A {
  int a;
  int&& r;
};

int f();
int n = 10;


A a2(1, f());                   // well-formed, but dangling reference
A a4(1.0, 1);                   // well-formed, but dangling reference
A a5(1.0, std::move(n));        // OK

[Xazax-hun]

Wow this inconsistency with lifetime extension is really confusing. Great that we will have a warning for this now.