clang/test/SemaCXX/constexpr-frame-describe.cpp

   1 // RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s
   2
   3
   4 struct Foo {
   5     constexpr void zomg() const { (void)(1 / 0); } // expected-error {{constant expression}} \
   6                                                       expected-warning {{division by zero}} \
   7                                                       expected-note 2{{division by zero}}
   8 };
   9
  10 struct S {
  11     constexpr S() {}
  12     constexpr bool operator==(const S&) const { // expected-error {{never produces a constant expression}}
  13       return 1 / 0; // expected-warning {{division by zero}} \
  14                        expected-note 3{{division by zero}}
  15     }
  16
  17     constexpr bool heh() const {
  18         auto F = new Foo();
  19         F->zomg(); // expected-note {{in call to 'F->zomg()'}}
  20         delete F;
  21         return false;
  22     }
  23 };
  24
  25 constexpr S s;
  26
  27 static_assert(s.heh()); // expected-error {{constant expression}} \
  28                            expected-note {{in call to 's.heh()'}}
  29
  30 constexpr S s2;
  31 constexpr const S *sptr = &s;
  32 constexpr const S *sptr2 = &s2;
  33 static_assert(s == s2); // expected-error {{constant expression}} \
  34                            expected-note {{in call to 's.operator==(s2)'}}
  35 static_assert(*sptr == *sptr2); // expected-error {{constant expression}} \
  36                                    expected-note {{in call to '*sptr.operator==(s2)'}}
  37
  38 struct A {
  39   constexpr int foo() { (void)(1/0); return 1;} // expected-error {{never produces a constant expression}} \
  40                                                    expected-warning {{division by zero}} \
  41                                                    expected-note 2{{division by zero}}
  42 };
  43
  44 struct B {
  45   A aa;
  46   A *a = &aa;
  47 };
  48
  49 struct C {
  50   B b;
  51 };
  52
  53 struct D {
  54   C cc;
  55   C *c = &cc;
  56 };
  57
  58 constexpr D d{};
  59 static_assert(d.c->b.a->foo() == 1); // expected-error {{constant expression}} \
  60                                         expected-note {{in call to 'd.c->b.a->foo()'}}
  61
  62 template <typename T>
  63 struct Bar {
  64   template <typename U>
  65   constexpr int fail1() const { return 1 / 0; } // expected-warning {{division by zero}} \
  66                                                 // expected-note {{division by zero}}
  67   template <typename U, int num>
  68   constexpr int fail2() const { return 1 / 0; } // expected-warning {{division by zero}} \
  69                                                 // expected-note {{division by zero}}
  70   template <typename ...Args>
  71   constexpr int fail3(Args... args) const { return 1 / 0; } // expected-warning {{division by zero}} \
  72                                                 // expected-note {{division by zero}}
  73 };
  74
  75 constexpr Bar<int> bar;
  76 static_assert(bar.fail1<int>()); // expected-error {{constant expression}} \
  77                                  // expected-note {{in call to 'bar.fail1<int>()'}}
  78 static_assert(bar.fail2<int*, 42>()); // expected-error {{constant expression}} \
  79                                       // expected-note {{in call to 'bar.fail2<int *, 42>()'}}
  80 static_assert(bar.fail3(3, 4UL, bar, &bar)); // expected-error {{constant expression}} \
  81                                              // expected-note {{in call to 'bar.fail3<int, unsigned long, Bar<int>, const Bar<int> *>(3, 4, {}, &bar)'}}