// RUN: %clang_cc1 -fsyntax-only -Wdangling -Wdangling-field -Wreturn-stack-address -verify %s
// RUN: %clang_cc1 -fsyntax-only -Wlifetime-safety -Wno-dangling -verify=cfg %s
// RUN: %clang_cc1 -fsyntax-only -flifetime-safety-inference -fexperimental-lifetime-safety-tu-analysis -Wlifetime-safety -Wno-dangling -verify=cfg,tu %s

#include "Inputs/lifetime-analysis.h"

struct [[gsl::Owner(int)]] MyIntOwner {
  MyIntOwner();
  // TODO: Do this behind a macro and run tests without this dtor to verify trivial dtor cases.
  ~MyIntOwner();
  int &operator*();
};

struct [[gsl::Pointer(int)]] MyIntPointer {
  MyIntPointer(int *p = nullptr);
  // Conversion operator and constructor conversion will result in two
  // different ASTs. The former is tested with another owner and
  // pointer type.
  MyIntPointer(const MyIntOwner &);
  int &operator*();
  MyIntOwner toOwner();
};

struct MySpecialIntPointer : MyIntPointer {
};

// We did see examples in the wild when a derived class changes
// the ownership model. So we have a test for it.
struct [[gsl::Owner(int)]] MyOwnerIntPointer : MyIntPointer {
};

struct [[gsl::Pointer(long)]] MyLongPointerFromConversion {
  MyLongPointerFromConversion(long *p = nullptr);
  long &operator*();
};

struct [[gsl::Owner(long)]] MyLongOwnerWithConversion {
  MyLongOwnerWithConversion();
  // TODO: Do this behind a macro and run tests without this dtor to verify trivial dtor cases.
  ~MyLongOwnerWithConversion();
  operator MyLongPointerFromConversion();
  long &operator*();
  MyIntPointer releaseAsMyPointer();
  long *releaseAsRawPointer();
};

template<class... T> void use(T... arg);

void danglingHeapObject() {
  new MyLongPointerFromConversion(MyLongOwnerWithConversion{}); // expected-warning {{object backing the pointer will be destroyed at the end of the full-expression}}
  new MyIntPointer(MyIntOwner{}); // expected-warning {{object backing the pointer will be destroyed at the end of the full-expression}}
}

void intentionalFalseNegative() {
  int i;
  MyIntPointer p{&i};
  // In this case we do not have enough information in a statement local
  // analysis to detect the problem.
  new MyIntPointer(p);
  new MyIntPointer(MyIntPointer{p});
}

MyIntPointer ownershipTransferToMyPointer() {
  MyLongOwnerWithConversion t;
  return t.releaseAsMyPointer(); // ok
}

long *ownershipTransferToRawPointer() {
  MyLongOwnerWithConversion t;
  return t.releaseAsRawPointer(); // ok
}

struct Y {
  int a[4];
};

void dangligGslPtrFromTemporary() {
  MyIntPointer p = Y{}.a; // cfg-warning {{object whose reference is captured does not live long enough}} \
                          // cfg-note {{destroyed here}}
  (void)p;                // cfg-note {{later used here}}
}

struct DanglingGslPtrField {
  MyIntPointer p; // expected-note {{pointer member declared here}} \
                  // cfg-note 3 {{this field dangles}}
  MyLongPointerFromConversion p2; // expected-note {{pointer member declared here}} \
                                  // cfg-note 2 {{this field dangles}}

  DanglingGslPtrField(int i) : p(&i) {} // cfg-warning {{address of stack memory escapes to a field}}
  DanglingGslPtrField() : p2(MyLongOwnerWithConversion{}) {}  // expected-warning {{initializing pointer member 'p2' to point to a temporary object whose lifetime is shorter than the lifetime of the constructed object}} \
                                                              // cfg-warning {{address of stack memory escapes to a field}}
  DanglingGslPtrField(double) : p(MyIntOwner{}) {}  // expected-warning {{initializing pointer member 'p' to point to a temporary object whose lifetime is shorter than the lifetime of the constructed object}} \
                                                    // cfg-warning {{address of stack memory escapes to a field}}
  DanglingGslPtrField(MyIntOwner io) : p(io) {} // cfg-warning {{address of stack memory escapes to a field}}
  DanglingGslPtrField(MyLongOwnerWithConversion lo) : p2(lo) {} // cfg-warning {{address of stack memory escapes to a field}}
};

MyIntPointer danglingGslPtrFromLocal() {
  int j;
  // Detected only by CFG analysis.
  return &j; // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

MyIntPointer returningLocalPointer() {
  MyIntPointer localPointer;
  return localPointer; // ok
}

MyIntPointer daglingGslPtrFromLocalOwner() {
  MyIntOwner localOwner;
  return localOwner; // expected-warning {{address of stack memory associated with local variable 'localOwner' returned}} \
                     // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

MyLongPointerFromConversion daglingGslPtrFromLocalOwnerConv() {
  MyLongOwnerWithConversion localOwner;
  return localOwner; // expected-warning {{address of stack memory associated with local variable 'localOwner' returned}} \
                     // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

MyIntPointer danglingGslPtrFromTemporary() {
  return MyIntOwner{}; // expected-warning {{returning address of local temporary object}} \
                       // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

MyIntOwner makeTempOwner();

MyIntPointer danglingGslPtrFromTemporary2() {
  return makeTempOwner(); // expected-warning {{returning address of local temporary object}} \
                          // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

MyLongPointerFromConversion danglingGslPtrFromTemporaryConv() {
  return MyLongOwnerWithConversion{}; // expected-warning {{returning address of local temporary object}} \
                                      // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

int *noFalsePositive(MyIntOwner &o) {
  MyIntPointer p = o;
  return &*p; // ok
}

MyIntPointer global;
MyLongPointerFromConversion global2;

void initLocalGslPtrWithTempOwner() {
  MyIntPointer p = MyIntOwner{}; // expected-warning {{object backing the pointer will be destroyed at the end of the full-expression}} \
                                 // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(p);                        // cfg-note {{later used here}}

  MyIntPointer pp = p = MyIntOwner{}; // expected-warning {{object backing the pointer 'p' will be}} \
                                      // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(p, pp);                         // cfg-note {{later used here}}

  p = MyIntOwner{}; // expected-warning {{object backing the pointer 'p' }} \
                    // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(p);           // cfg-note {{later used here}}

  pp = p; // no warning
  use(p, pp);

  global = MyIntOwner{}; // expected-warning {{object backing the pointer 'global' }} \
                         // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(global);           // cfg-note {{later used here}}

  MyLongPointerFromConversion p2 = MyLongOwnerWithConversion{}; // expected-warning {{object backing the pointer will be destroyed at the end of the full-expression}} \
                                                                // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(p2);                                                      // cfg-note {{later used here}}

  p2 = MyLongOwnerWithConversion{}; // expected-warning {{object backing the pointer 'p2' }} \
                                    // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  global2 = MyLongOwnerWithConversion{};  // expected-warning {{object backing the pointer 'global2' }} \
                                          // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(global2, p2);                       // cfg-note 2 {{later used here}}
}

struct LifetimeBoundCtor {
  LifetimeBoundCtor(const MyIntOwner& obj1 [[clang::lifetimebound]]);
  LifetimeBoundCtor(std::string_view sv [[clang::lifetimebound]]);
};

auto lifetimebound_make_unique_single_param() {
  return std::make_unique<LifetimeBoundCtor>(MyIntOwner{}); // tu-warning {{address of stack memory is returned later}} tu-note {{returned here}}
}


struct Unannotated {
  typedef std::vector<int>::iterator iterator;
  iterator begin();
  operator iterator() const;
};

void modelIterators() {
  std::vector<int>::iterator it = std::vector<int>().begin(); // expected-warning {{object backing the pointer will be destroyed at the end of the full-expression}} \
                                                              // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  (void)it; // cfg-note {{later used here}}
}

std::vector<int>::iterator modelIteratorReturn() {
  return std::vector<int>().begin(); // expected-warning {{returning address of local temporary object}} \
                                     // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

const int *modelFreeFunctions() {
  return std::data(std::vector<int>()); // expected-warning {{returning address of local temporary object}} \
                                        // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

int &modelAnyCast() {
  return std::any_cast<int&>(std::any{}); // expected-warning {{returning reference to local temporary object}} \
                                          // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

int modelAnyCast2() {
  return std::any_cast<int>(std::any{}); // ok
}

int modelAnyCast3() {
  return std::any_cast<int&>(std::any{}); // ok
}

const char *danglingRawPtrFromLocal() {
  std::basic_string<char> s;
  return s.c_str(); // expected-warning {{address of stack memory associated with local variable 's' returned}} \
                    // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

int &danglingRawPtrFromLocal2() {
  std::optional<int> o;
  return o.value(); // expected-warning {{reference to stack memory associated with local variable 'o' returned}} \
                    // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

int &danglingRawPtrFromLocal3() {
  std::optional<int> o;
  return *o; // expected-warning {{reference to stack memory associated with local variable 'o' returned}} \
             // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

// GH100384
std::string_view containerWithAnnotatedElements() {
  std::string_view c1 = std::vector<std::string>().at(0); // expected-warning {{object backing the pointer will be destroyed at the end of the full-expression}} \
                                                          // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(c1);                                                // cfg-note {{later used here}}

  c1 = std::vector<std::string>().at(0); // expected-warning {{object backing the pointer}} \
                                         // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(c1);                               // cfg-note {{later used here}}

  // no warning on constructing from gsl-pointer
  std::string_view c2 = std::vector<std::string_view>().at(0);
  use(c2);

  std::vector<std::string> local;
  return local.at(0); // expected-warning {{address of stack memory associated with local variable}} \
                      // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

std::string_view localUniquePtr(int i) {
  std::unique_ptr<std::string> c1;
  if (i)
    return *c1; // expected-warning {{address of stack memory associated with local variable}} \
                // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
  std::unique_ptr<std::string_view> c2;
  return *c2; // expect no-warning.
}

std::string_view localOptional(int i) {
  std::optional<std::string> o;
  if (i)
    return o.value(); // expected-warning {{address of stack memory associated with local variable}} \
                      // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
  std::optional<std::string_view> abc;
  return abc.value(); // expect no warning
}

const char *danglingRawPtrFromTemp() {
  return std::basic_string<char>().c_str(); // expected-warning {{returning address of local temporary object}} \
                                            // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

std::unique_ptr<int> getUniquePtr();

int *danglingUniquePtrFromTemp() {
  return getUniquePtr().get(); // expected-warning {{returning address of local temporary object}} \
                               // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

int *danglingUniquePtrFromTemp2() {
  return std::unique_ptr<int>().get(); // expected-warning {{returning address of local temporary object}} \
                                       // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

const int& danglingRefToOptionalFromTemp3() {
  return std::optional<int>().value(); // expected-warning {{returning reference to local temporary object}} \
                                       // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

std::optional<std::string> getTempOptStr();

std::string_view danglingRefToOptionalFromTemp4() {
  return getTempOptStr().value(); // expected-warning {{returning address of local temporary object}} \
                                  // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

void danglingReferenceFromTempOwner() {
  int &&r = *std::optional<int>();          // expected-warning {{object backing the pointer will be destroyed at the end of the full-expression}} \
                                            // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  // https://github.com/llvm/llvm-project/issues/175893
  int &&r2 = *std::optional<int>(5);        // expected-warning {{object backing the pointer will be destroyed at the end of the full-expression}} \
                                              // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}

  // https://github.com/llvm/llvm-project/issues/175893
  int &&r3 = std::optional<int>(5).value(); // expected-warning {{object backing the pointer will be destroyed at the end of the full-expression}} \
                                              // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}

  const int &r4 = std::vector<int>().at(3); // expected-warning {{object backing the pointer will be destroyed at the end of the full-expression}} \
                                            // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  int &&r5 = std::vector<int>().at(3);      // expected-warning {{object backing the pointer will be destroyed at the end of the full-expression}} \
                                            // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(r, r2, r3, r4, r5);                   // cfg-note 5 {{later used here}}

  std::string_view sv = *getTempOptStr();  // expected-warning {{object backing the pointer will be destroyed at the end of the full-expression}} \
                                           // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(sv);                                 // cfg-note {{later used here}}
}

std::vector<int> getTempVec();
std::optional<std::vector<int>> getTempOptVec();

void testLoops() {
  for (auto i : getTempVec()) // ok
    ;
  for (auto i : *getTempOptVec()) // expected-warning {{object backing the pointer will be destroyed at the end of the full-expression}} \
                                  // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}} cfg-note {{later used here}}
    ;
}

int &usedToBeFalsePositive(std::vector<int> &v) {
  std::vector<int>::iterator it = v.begin();
  int& value = *it;
  return value; // ok
}

int &doNotFollowReferencesForLocalOwner() {
// Warning caught by CFG analysis.
  std::unique_ptr<int> localOwner;
  int &p = *localOwner // cfg-warning {{address of stack memory is returned later}}
            .get();
  return p; // cfg-note {{returned here}}
}

const char *trackThroughMultiplePointer() {
  return std::basic_string_view<char>(std::basic_string<char>()).begin(); // expected-warning {{returning address of local temporary object}} \
         // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

struct X {
  X(std::unique_ptr<int> up) :
    pointee(*up),             // cfg-warning {{may have been moved.}}
    pointee2(up.get()),       // cfg-warning {{may have been moved.}}
    pointer(std::move(up)) {} // cfg-note 2 {{potentially moved here}}
  int &pointee;               // cfg-note {{this field dangles}}
  int *pointee2;              // cfg-note {{this field dangles}}
  std::unique_ptr<int> pointer;
};

struct [[gsl::Owner]] XOwner {
  int* get() const [[clang::lifetimebound]];
};
struct X2 {
  // A common usage that moves the passing owner to the class.
  // verify a strict warning on this case.
  X2(XOwner owner) :
    pointee(owner.get()),       // cfg-warning {{may have been moved.}}
    owner(std::move(owner)) {}  // cfg-note {{potentially moved here}}
  int* pointee;                 // cfg-note {{this field dangles}}
  XOwner owner;
};

std::vector<int>::iterator getIt();
std::vector<int> getVec();

const int &handleGslPtrInitsThroughReference() {
  const auto &it = getIt(); // Ok, it is lifetime extended.
  return *it;
}

void handleGslPtrInitsThroughReference2() {
  const std::vector<int> &v = getVec();
  const int *val = v.data(); // Ok, it is lifetime extended.
}

void handleTernaryOperator(bool cond) {
    std::basic_string<char> def;
    std::basic_string_view<char> v = cond ? def : ""; // expected-warning {{object backing the pointer will be destroyed at the end of the full-expression}} \
                                                      // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
    use(v); // cfg-note {{later used here}}
}

std::string operator+(std::string_view s1, std::string_view s2);
void danglingStringviewAssignment(std::string_view a1, std::string_view a2) {
  a1 = std::string(); // expected-warning {{object backing}} \
                      // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(a1);            // cfg-note {{later used here}}

  a2 = a1 + a1; // expected-warning {{object backing}} \
                // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(a2);      // cfg-note {{later used here}}
}

std::reference_wrapper<int> danglingPtrFromNonOwnerLocal() {
  int i = 5;
  return i; // TODO
}

std::reference_wrapper<int> danglingPtrFromNonOwnerLocal2() {
  int i = 5;
  return std::ref(i); // TODO
}

std::reference_wrapper<int> danglingPtrFromNonOwnerLocal3() {
  int i = 5;
  return std::reference_wrapper<int>(i); // TODO
}

std::reference_wrapper<Unannotated> danglingPtrFromNonOwnerLocal4() {
  Unannotated i;
  return std::reference_wrapper<Unannotated>(i); // TODO
}

std::reference_wrapper<Unannotated> danglingPtrFromNonOwnerLocal5() {
  Unannotated i;
  return std::ref(i); // TODO
}

int *returnPtrToLocalArray() {
  int a[5];
  return std::begin(a); // TODO
}

namespace lifetimebound_stl_algorithms {

std::vector<std::string> GetTemporaryString();
std::vector<std::string_view> GetTemporaryView();

std::string_view test_str_local() {
  std::vector<std::string> v;
  return *std::find(v.begin(), // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
                    v.end(), "42");
}
std::string_view test_str_temporary() {
  return *std::find(GetTemporaryString().begin(), // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
                    GetTemporaryString().end(), "42");
}
std::string_view test_view() {
  std::vector<std::string_view> v;
  return *std::find(v.begin(), v.end(), "42");
}
std::string_view test_view_local() {
  return *std::find(GetTemporaryView().begin(), GetTemporaryView().end(), "42");
}
} // namespace lifetimebound_stl_algorithms

struct ptr_wrapper {
  std::vector<int>::iterator member;
};

ptr_wrapper getPtrWrapper();

std::vector<int>::iterator returnPtrFromWrapper() {
  ptr_wrapper local = getPtrWrapper();
  return local.member;
}

std::vector<int>::iterator returnPtrFromWrapperThroughRef() {
  ptr_wrapper local = getPtrWrapper();
  ptr_wrapper &local2 = local;
  return local2.member;
}

std::vector<int>::iterator returnPtrFromWrapperThroughRef2() {
  ptr_wrapper local = getPtrWrapper();
  std::vector<int>::iterator &local2 = local.member;
  return local2;
}

void checkPtrMemberFromAggregate() {
  std::vector<int>::iterator local = getPtrWrapper().member; // OK.
}

std::vector<int>::iterator doNotInterferWithUnannotated() {
  Unannotated value;
  // Conservative choice for now. Probably not ok, but we do not warn.
  return std::begin(value);
}

std::vector<int>::iterator doNotInterferWithUnannotated2() {
  Unannotated value;
  return value;
}

std::vector<int>::iterator supportDerefAddrofChain(int a, std::vector<int>::iterator value) {
  switch (a)  {
    default:
      return value;
    case 1:
      return *&value;
    case 2:
      return *&*&value;
    case 3:
      return *&*&*&value;
  }
}

int &supportDerefAddrofChain2(int a, std::vector<int>::iterator value) {
  switch (a)  {
    default:
      return *value;
    case 1:
      return **&value;
    case 2:
      return **&*&value;
    case 3:
      return **&*&*&value;
  }
}

int *supportDerefAddrofChain3(int a, std::vector<int>::iterator value) {
  switch (a)  {
    default:
      return &*value;
    case 1:
      return &*&*value;
    case 2:
      return &*&**&value;
    case 3:
      return &*&**&*&value;
  }
}

MyIntPointer handleDerivedToBaseCast1(MySpecialIntPointer ptr) {
  return ptr;
}

MyIntPointer handleDerivedToBaseCast2(MyOwnerIntPointer ptr) {
  return ptr; // expected-warning {{address of stack memory associated with parameter 'ptr' returned}}
}

std::vector<int>::iterator noFalsePositiveWithVectorOfPointers() {
  std::vector<std::vector<int>::iterator> iters;
  return iters.at(0);
}

void testForBug49342()
{
  auto it = std::iter<char>{} - 2; // Used to be false positive.
}

namespace GH93386 {
// verify no duplicated diagnostics are emitted.
struct [[gsl::Pointer]] S {
  S(const std::vector<int>& abc [[clang::lifetimebound]]);
};

S test(std::vector<int> a) {
  return S(a);  // expected-warning {{address of stack memory associated with}} \
                // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

// FIXME: Detect this using the CFG-based lifetime analysis (global initialisation).
auto s = S(std::vector<int>()); // expected-warning {{temporary whose address is used as value of local variable}}

// Verify no regression on the follow case.
std::string_view test2(int i, std::optional<std::string_view> a) {
  if (i)
    return std::move(*a);
  return std::move(a.value());
}

struct Foo;
struct FooView {
  FooView(const Foo& foo [[clang::lifetimebound]]);
};
FooView test3(int i, std::optional<Foo> a) {
  if (i)
    return *a; // expected-warning {{address of stack memory}} \
               // cfg-warning {{address of stack memory is returned later}} \
               // cfg-note {{returned here}}
  return a.value(); // expected-warning {{address of stack memory}} \
                    // cfg-warning {{address of stack memory is returned later}} \
                    // cfg-note {{returned here}}
}
} // namespace GH93386

namespace GH100549 {
struct UrlAnalyzed {
  UrlAnalyzed(std::string_view url [[clang::lifetimebound]]);
};
std::string StrCat(std::string_view, std::string_view);
void test1() {
  UrlAnalyzed url(StrCat("abc", "bcd")); // expected-warning {{object backing the pointer will be destroyed}} \
                                         // cfg-warning {{object whose reference is captured does not live long enough}} \
                                         // cfg-note {{destroyed here}}
  use(url);                              // cfg-note {{later used here}}
}

std::string_view ReturnStringView(std::string_view abc [[clang::lifetimebound]]);

void test() {
  std::string_view svjkk1 = ReturnStringView(StrCat("bar", "x")); // expected-warning {{object backing the pointer will be destroyed at the end of the full-expression}} \
                                                                  // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(svjkk1);                                                    // cfg-note {{later used here}}
}
} // namespace GH100549

namespace GH108272 {
template <typename T>
struct [[gsl::Owner]] StatusOr {
  const T &value() [[clang::lifetimebound]];
  // TODO: Do this behind a macro and run tests without this dtor to verify trivial dtor cases.
  ~StatusOr();
};

template <typename V>
class Wrapper1 {
 public:
  operator V() const;
  V value;
};
std::string_view test1() {
  StatusOr<Wrapper1<std::string_view>> k;
  // Be conservative in this case, as there is not enough information available
  // to infer the lifetime relationship for the Wrapper1 type.
  std::string_view good = StatusOr<Wrapper1<std::string_view>>().value();
  return k.value();
}

template <typename V>
class Wrapper2 {
 public:
  operator V() const [[clang::lifetimebound]];
  V value;
};
std::string_view test2() {
  StatusOr<Wrapper2<std::string_view>> k;
  // We expect dangling issues as the conversion operator is lifetimebound。
  std::string_view bad = StatusOr<Wrapper2<std::string_view>>().value(); // expected-warning {{temporary whose address is used as value of}}
  
  return k.value(); // expected-warning {{address of stack memory associated}} \
                    // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}
} // namespace GH108272

namespace GH100526 {
// FIXME: Detect this using the CFG-based lifetime analysis.
//        Container of pointers
//        https://github.com/llvm/llvm-project/issues/175025
void test() {
  std::vector<std::string_view> v1({std::string()}); // expected-warning {{object backing the pointer will be destroyed at the end}}
  use(v1);

  std::vector<std::string_view> v2({
    std::string(), // expected-warning {{object backing the pointer will be destroyed at the end}}
    std::string_view()
  });
  use(v2);

  std::vector<std::string_view> v3({
    std::string_view(),
    std::string()  // expected-warning {{object backing the pointer will be destroyed at the end}}
  });
  use(v3);

  std::optional<std::string_view> o1 = std::string(); // expected-warning {{object backing the pointer}}
  use(o1);

  std::string s;
  // This is a tricky use-after-free case, what it does:
  //   1. make_optional creates a temporary "optional<string>"" object
  //   2. the temporary object owns the underlying string which is copied from s.
  //   3. the t3 object holds the view to the underlying string of the temporary object.
  std::optional<std::string_view> o2 = std::make_optional(s); // expected-warning {{object backing the pointer}}
  std::optional<std::string_view> o3 = std::optional<std::string>(s); // expected-warning {{object backing the pointer}}
  std::optional<std::string_view> o4 = std::optional<std::string_view>(s);
  use(o2, o3, o4);

  // FIXME: should work for assignment cases
  v1 = {std::string()};
  o1 = std::string();
  use(o1, v1);

  // no warning on copying pointers.
  std::vector<std::string_view> n1 = {std::string_view()};
  std::optional<std::string_view> n2 = {std::string_view()};
  std::optional<std::string_view> n3 = std::string_view();
  std::optional<std::string_view> n4 = std::make_optional(std::string_view());
  const char* b = "";
  std::optional<std::string_view> n5 = std::make_optional(b);
  std::optional<std::string_view> n6 = std::make_optional("test");
  use(n1, n2, n3, n4, n5, n6);
}

std::vector<std::string_view> test2(int i) {
  std::vector<std::string_view> t;
  if (i)
    return t; // this is fine, no dangling
  return std::vector<std::string_view>(t.begin(), t.end());
}

class Foo {
  public:
   operator std::string_view() const { return ""; }
};
class [[gsl::Owner]] FooOwner {
  public:
   operator std::string_view() const { return ""; }
};
std::optional<Foo> GetFoo();
std::optional<FooOwner> GetFooOwner();

template <typename T>
struct [[gsl::Owner]] Container1 {
   Container1();
};
template <typename T>
struct [[gsl::Owner]] Container2 {
  template<typename U>
  Container2(const Container1<U>& C2);
};

std::optional<std::string_view> test3(int i) {
  std::string s;
  std::string_view sv;
  if (i)
   return s; // expected-warning {{address of stack memory associated}}
  return sv; // fine
  Container2<std::string_view> c1 = Container1<Foo>(); // no diagnostic as Foo is not an Owner.
  Container2<std::string_view> c2 = Container1<FooOwner>(); // expected-warning {{object backing the pointer will be destroyed}}
  return GetFoo(); // fine, we don't know Foo is owner or not, be conservative.
  return GetFooOwner(); // expected-warning {{returning address of local temporary object}}
}

std::optional<int*> test4(int a) {
  return std::make_optional(nullptr); // fine
}


template <typename T>
struct [[gsl::Owner]] StatusOr {
  const T &valueLB() const [[clang::lifetimebound]];
  const T &valueNoLB() const;
};

template<typename T>
struct [[gsl::Pointer]] Span {
  Span(const std::vector<T> &V);

  const int& getFieldLB() const [[clang::lifetimebound]];
  const int& getFieldNoLB() const;
};


/////// From Owner<Pointer> ///////

// Pointer from Owner<Pointer>
std::string_view test5() {
  // The Owner<Pointer> doesn't own the object which its inner pointer points to.
  std::string_view a = StatusOr<std::string_view>().valueLB(); // OK
  return StatusOr<std::string_view>().valueLB(); // OK

  // No dangling diagnostics on non-lifetimebound methods.
  std::string_view b = StatusOr<std::string_view>().valueNoLB();
  return StatusOr<std::string_view>().valueNoLB();
}

// Pointer<Pointer> from Owner<Pointer>
// Prevent regression GH108463
Span<int*> test6(std::vector<int*> v) {
  Span<int *> dangling = std::vector<int*>(); // expected-warning {{object backing the pointer}}
  dangling = std::vector<int*>(); // expected-warning {{object backing the pointer}}
  return v; // expected-warning {{address of stack memory}} \
            // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

/////// From Owner<Owner<Pointer>> ///////

// Pointer from Owner<Owner<Pointer>>
int* test7(StatusOr<StatusOr<int*>> aa) {
  // No dangling diagnostic on pointer.
  return aa.valueLB().valueLB(); // OK.
}

// Owner<Pointer> from Owner<Owner<Pointer>>
std::vector<int*> test8(StatusOr<std::vector<int*>> aa) {
  return aa.valueLB(); // OK, no pointer being construct on this case.
  return aa.valueNoLB();
}

// Pointer<Pointer> from Owner<Owner<Pointer>>
Span<int*> test9(StatusOr<std::vector<int*>> aa) {
  return aa.valueLB(); // expected-warning {{address of stack memory associated}} \
                       // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
  return aa.valueNoLB(); // OK.
}

/////// From Owner<Owner> ///////

// Pointer<Owner>> from Owner<Owner>
Span<std::string> test10(StatusOr<std::vector<std::string>> aa) {
  return aa.valueLB(); // expected-warning {{address of stack memory}} \
                       // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
  return aa.valueNoLB(); // OK.
}

/////// From Owner<Pointer<Owner>> ///////

// Pointer<Owner>> from Owner<Pointer<Owner>>
Span<std::string> test11(StatusOr<Span<std::string>> aa) {
  return aa.valueLB(); // OK
  return aa.valueNoLB(); // OK.
}

// Lifetimebound and gsl::Pointer.
const int& test12(Span<int> a) {
  return a.getFieldLB(); // expected-warning {{reference to stack memory associated}} \
                         // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
  return a.getFieldNoLB(); // OK.
}

void test13() {
  // FIXME: RHS is Owner<Pointer>, we skip this case to avoid false positives.
  std::optional<Span<int*>> abc = std::vector<int*>{};

  // FIXME: Detect this using the CFG-based lifetime analysis (container of pointer).
  std::optional<Span<int>> t = std::vector<int> {}; // expected-warning {{object backing the pointer will be destroyed}}
  use(t);
}

} // namespace GH100526

namespace GH118064{

void test() {
  auto y = std::set<int>{}.begin(); // expected-warning {{object backing the pointer}} \
  // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(y); // cfg-note {{later used here}}
}
} // namespace GH118064

namespace LifetimeboundInterleave {

const std::string& Ref(const std::string& abc [[clang::lifetimebound]]);

std::string_view TakeSv(std::string_view abc [[clang::lifetimebound]]);
std::string_view TakeStrRef(const std::string& abc [[clang::lifetimebound]]);
std::string_view TakeStr(std::string abc [[clang::lifetimebound]]);

std::string_view test1_1() {
  std::string_view t1 = Ref(std::string()); // expected-warning {{object backing}} \
                                            // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(t1);                                  // cfg-note {{later used here}}
  t1 = Ref(std::string()); // expected-warning {{object backing}} \
                           // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(t1);                 // cfg-note {{later used here}}
  return Ref(std::string()); // expected-warning {{returning address}} \
                             // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

std::string_view test1_2() {
  std::string_view t2 = TakeSv(std::string()); // expected-warning {{object backing}} \
                                            // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(t2);                                  // cfg-note {{later used here}}
  t2 = TakeSv(std::string()); // expected-warning {{object backing}} \
                              // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(t2);                    // cfg-note {{later used here}}

  return TakeSv(std::string()); // expected-warning {{returning address}} \
                                // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

std::string_view test1_3() {
  std::string_view t3 = TakeStrRef(std::string()); // expected-warning {{temporary}} \
                                                   // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(t3);                                         // cfg-note {{later used here}}
  t3 = TakeStrRef(std::string()); // expected-warning {{object backing}} \
                                  // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(t3);                        // cfg-note {{later used here}}
  return TakeStrRef(std::string()); // expected-warning {{returning address}} \
                                    // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

std::string_view test1_4() {
  std::string_view t4 = TakeStr(std::string());
  t4 = TakeStr(std::string());
  use(t4);
  return TakeStr(std::string());
}

template <typename T>
struct Foo {
  const T& get() const [[clang::lifetimebound]];
  const T& getNoLB() const;
  // TODO: Do this behind a macro and run tests without this dtor to verify trivial dtor cases.
  ~Foo();
};
std::string_view test2_1(Foo<std::string> r1, Foo<std::string_view> r2) {
  std::string_view t1 = Foo<std::string>().get(); // expected-warning {{object backing}} \
                                                  // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(t1);                                        // cfg-note {{later used here}}
  t1 = Foo<std::string>().get(); // expected-warning {{object backing}} \
                                 // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(t1);                       // cfg-note {{later used here}}
  return r1.get(); // expected-warning {{address of stack}} \
                   // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}
std::string_view test2_2(Foo<std::string> r1, Foo<std::string_view> r2) {
  std::string_view t2 = Foo<std::string_view>().get();
  use(t2);
  t2 = Foo<std::string_view>().get();
  use(t2);
  return r2.get();
}
std::string_view test2_3(Foo<std::string> r1, Foo<std::string_view> r2) {
  // no warning on no-LB-annotated method.
  std::string_view t3 = Foo<std::string>().getNoLB();
  use(t3);
  t3 = Foo<std::string>().getNoLB();
  use(t3);
  return r1.getNoLB();
}

struct Bar {
  // TODO: Do this behind a macro and run tests without this dtor to verify trivial dtor cases.
  ~Bar();
};
struct [[gsl::Pointer]] Pointer {
  Pointer(const Bar & bar [[clang::lifetimebound]]);
};
Pointer test3(Bar bar) {
  Pointer p = Pointer(Bar()); // expected-warning {{temporary}} cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(p);                     // cfg-note {{later used here}}
  p = Pointer(Bar());         // expected-warning {{object backing}} cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  use(p);                     // cfg-note {{later used here}}
  return bar;                 // expected-warning {{address of stack}} cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

template<typename T>
struct MySpan {
  MySpan(const std::vector<T>& v);
  ~MySpan();
  using iterator = std::iterator<T>;
  // FIXME: It is not possible to annotate accessor methods of non-owning view types.
  // Clang should provide another annotation to mark such functions as 'transparent'.
  iterator begin() const;
};
// FIXME: Same as above.
template <typename T>
typename MySpan<T>::iterator ReturnFirstIt(const MySpan<T>& v);

void test4() {
  std::vector<int> v{1};
  // MySpan<T> doesn't own any underlying T objects, the pointee object of
  // the MySpan iterator is still alive when the whole span is destroyed, thus
  // no diagnostic.
  const int& t1 = *MySpan<int>(v).begin();
  const int& t2 = *ReturnFirstIt(MySpan<int>(v));
  // Ideally, we would diagnose the following case, but due to implementation
  // constraints, we do not.
  const int& t4 = *MySpan<int>(std::vector<int>{}).begin();
  use(t1, t2, t4);

  auto it1 = MySpan<int>(v).begin();
  auto it2 = ReturnFirstIt(MySpan<int>(v));
  use(it1, it2);
}

} // namespace LifetimeboundInterleave

namespace range_based_for_loop_variables {
std::string_view test_view_loop_var(std::vector<std::string> strings) {
  for (std::string_view s : strings) {  // cfg-warning {{address of stack memory is returned later}} 
    return s; //cfg-note {{returned here}}
  }
  return "";
}

const char* test_view_loop_var_with_data(std::vector<std::string> strings) {
  for (std::string_view s : strings) {  // cfg-warning {{address of stack memory is returned later}} 
    return s.data(); //cfg-note {{returned here}}
  }
  return "";
}

std::string_view test_no_error_for_views(std::vector<std::string_view> views) {
  for (std::string_view s : views) {
    return s;
  }
  return "";
}

std::string_view test_string_ref_var(std::vector<std::string> strings) {
  for (const std::string& s : strings) {  // cfg-warning {{address of stack memory is returned later}} 
    return s; //cfg-note {{returned here}}
  }
  return "";
}

std::string_view test_opt_strings(std::optional<std::vector<std::string>> strings_or) {
  for (const std::string& s : *strings_or) {  // cfg-warning {{address of stack memory is returned later}} 
    return s; //cfg-note {{returned here}}
  }
  return "";
}
} // namespace range_based_for_loop_variables

namespace iterator_arrow {
std::string_view test() {
  std::vector<std::string> strings;
  return strings.begin()->data(); // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}
}

void operator_star_arrow_reference() {
  std::vector<std::string> v;
  const char* p = v.begin()->data();
  const char* q = (*v.begin()).data();
  const std::string& r = *v.begin();

  auto temporary = []() { return std::vector<std::string>{{"1"}}; };
  const char* x = temporary().begin()->data();    // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  const char* y = (*temporary().begin()).data();  // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  const std::string& z = (*temporary().begin());  // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}

  use(p, q, r, x, y, z); // cfg-note 3 {{later used here}}
}

void operator_star_arrow_of_iterators_false_positive_no_cfg_analysis() {
  std::vector<std::pair<int, std::string>> v;
  const char* p = v.begin()->second.data();
  const char* q = (*v.begin()).second.data();
  const std::string& r = (*v.begin()).second;

  auto temporary = []() { return std::vector<std::pair<int, std::string>>{{1, "1"}}; };
  const char* x = temporary().begin()->second.data();   // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  const char* y = (*temporary().begin()).second.data(); // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  const std::string& z = (*temporary().begin()).second; // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}

  use(p, q, r, x, y, z); // cfg-note 3 {{later used here}}
}
} // namespace iterator_arrow

namespace GH120206 {
struct S {
  std::string_view s;
};

struct [[gsl::Owner]] Q1 {
  const S* get() const [[clang::lifetimebound]];
};
std::string_view test1(int c, std::string_view sv) {
  std::string_view k = c > 1 ? Q1().get()->s : sv;
  if (c == 1)
    return  c > 1 ? Q1().get()->s : sv;
  Q1 q;
  return c > 1 ? q.get()->s : sv;
}

struct Q2 {
  const S* get() const [[clang::lifetimebound]];
};
std::string_view test2(int c, std::string_view sv) {
  std::string_view k = c > 1 ? Q2().get()->s : sv;
  if (c == 1)
    return c > 1 ? Q2().get()->s : sv;
  Q2 q;
  return c > 1 ? q.get()->s : sv;
}

} // namespace GH120206

namespace GH120543 {
struct S {
  std::string_view sv;
  std::string s;
};
struct Q {
  const S* get() const [[clang::lifetimebound]];
  ~Q();
};

std::string_view foo(std::string_view sv [[clang::lifetimebound]]);

void test1() {
  std::string_view k1 = S().sv; // OK
  std::string_view k2 = S().s; // expected-warning {{object backing the pointer will}} \
                               // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}

  std::string_view k3 = Q().get()->sv; // OK
  std::string_view k4  = Q().get()->s; // expected-warning {{object backing the pointer will}} \
                                       // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}


  std::string_view lb1 = foo(S().s); // expected-warning {{object backing the pointer will}} \
                                     // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}
  std::string_view lb2 = foo(Q().get()->s); // expected-warning {{object backing the pointer will}} \
                                            // cfg-warning {{object whose reference is captured does not live long enough}} cfg-note {{destroyed here}}

  use(k1, k2, k3, k4, lb1, lb2);  // cfg-note 4 {{later used here}}
}

struct Bar {};
struct Foo {
  std::vector<Bar> v;
};
Foo getFoo();
void test2() {
  const Foo& foo = getFoo();
  const Bar& bar = foo.v.back(); // OK
}

struct Foo2 {
   std::unique_ptr<Bar> bar;
};

struct Test {
  Test(Foo2 foo) : bar(foo.bar.get()),  // cfg-warning-re {{address of stack memory escapes to a field. {{.*}} may have been moved}}
      storage(std::move(foo.bar)) {};   // cfg-note {{potentially moved here}}

  Bar* bar; // cfg-note {{this field dangles}}
  std::unique_ptr<Bar> storage;
};

} // namespace GH120543

namespace GH127195 {
template <typename T>
struct StatusOr {
  T* operator->() [[clang::lifetimebound]];
  T* value() [[clang::lifetimebound]];
};

const char* foo() {
  StatusOr<std::string> s;
  return s->data(); // expected-warning {{address of stack memory associated with local variable}} \
                    // cfg-warning {{address of stack memory is returned later}} cfg-note {{returned here}}

  StatusOr<std::string_view> s2;
  return s2->data();

  StatusOr<StatusOr<std::string_view>> s3;
  return s3.value()->value()->data();

  // FIXME: nested cases are not supported now.
  StatusOr<StatusOr<std::string>> s4;
  return s4.value()->value()->data();
}

} // namespace GH127195

// Lifetimebound on definition vs declaration on implicit this param.
namespace GH175391 {
// Version A: Attribute on declaration only
class StringA {
public:
    const char* data() const [[clang::lifetimebound]];  // Declaration with attribute
private:
    char buffer[32] = "hello";
};
inline const char* StringA::data() const {  // Definition WITHOUT attribute
    return buffer;
}

// Version B: Attribute on definition only
class StringB {
public:
    const char* data() const;  // No attribute
private:
    char buffer[32] = "hello";
};
inline const char* StringB::data() const [[clang::lifetimebound]] {
    return buffer;
}

// Version C: Attribute on BOTH declaration and definition
class StringC {
public:
    const char* data() const [[clang::lifetimebound]];
private:
    char buffer[32] = "hello";
};
inline const char* StringC::data() const [[clang::lifetimebound]] {
    return buffer;
}

// TEMPLATED VERSIONS

// Template Version A: Attribute on declaration only
template<typename T>
class StringTemplateA {
public:
    const T* data() const [[clang::lifetimebound]];  // Declaration with attribute
private:
    T buffer[32];
};
template<typename T>
inline const T* StringTemplateA<T>::data() const {  // Definition WITHOUT attribute
    return buffer;
}

// Template Version B: Attribute on definition only
template<typename T>
class StringTemplateB {
public:
    const T* data() const;  // No attribute
private:
    T buffer[32];
};
template<typename T>
inline const T* StringTemplateB<T>::data() const [[clang::lifetimebound]] {
    return buffer;
}

// Template Version C: Attribute on BOTH declaration and definition
template<typename T>
class StringTemplateC {
public:
    const T* data() const [[clang::lifetimebound]];
private:
    T buffer[32];
};
template<typename T>
inline const T* StringTemplateC<T>::data() const [[clang::lifetimebound]] {
    return buffer;
}

// TEMPLATE SPECIALIZATION VERSIONS

// Template predeclarations for specializations
template<typename T> class StringTemplateSpecA;
template<typename T> class StringTemplateSpecB;
template<typename T> class StringTemplateSpecC;

// Template Specialization Version A: Attribute on declaration only - <char> specialization
template<>
class StringTemplateSpecA<char> {
public:
    const char* data() const [[clang::lifetimebound]];  // Declaration with attribute
private:
    char buffer[32] = "hello";
};
inline const char* StringTemplateSpecA<char>::data() const {  // Definition WITHOUT attribute
    return buffer;
}

// Template Specialization Version B: Attribute on definition only - <char> specialization
template<>
class StringTemplateSpecB<char> {
public:
    const char* data() const;  // No attribute
private:
    char buffer[32] = "hello";
};
inline const char* StringTemplateSpecB<char>::data() const [[clang::lifetimebound]] {
    return buffer;
}

// Template Specialization Version C: Attribute on BOTH declaration and definition - <char> specialization
template<>
class StringTemplateSpecC<char> {
public:
    const char* data() const [[clang::lifetimebound]];
private:
    char buffer[32] = "hello";
};
inline const char* StringTemplateSpecC<char>::data() const [[clang::lifetimebound]] {
    return buffer;
}

void test() {
    // Non-templated tests
    const auto ptrA = StringA().data();  // Declaration-only attribute  // expected-warning {{temporary whose address is used}}
    const auto ptrB = StringB().data();  // Definition-only attribute   // expected-warning {{temporary whose address is used}}
    const auto ptrC = StringC().data();  // Both have attribute         // expected-warning {{temporary whose address is used}}

    // Templated tests (generic templates)
    const auto ptrTA = StringTemplateA<char>().data();  // Declaration-only attribute // expected-warning {{temporary whose address is used}}
    const auto ptrTB = StringTemplateB<char>().data();  // Definition-only attribute  // expected-warning {{temporary whose address is used}}
    const auto ptrTC = StringTemplateC<char>().data();  // Both have attribute        // expected-warning {{temporary whose address is used}}

    // Template specialization tests
    const auto ptrTSA = StringTemplateSpecA<char>().data();  // Declaration-only attribute  // expected-warning {{temporary whose address is used}}
    const auto ptrTSB = StringTemplateSpecB<char>().data();  // Definition-only attribute   // expected-warning {{temporary whose address is used}}
    const auto ptrTSC = StringTemplateSpecC<char>().data();  // Both have attribute         // expected-warning {{temporary whose address is used}}
}
} // namespace GH175391

void string_insert_GH_186817() {
    std::string msg;
    msg.insert(0, std::string_view(std::string("a temporary")));
}