162 lines · cpp
1// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s2// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s -fexperimental-new-constant-interpreter3 4struct one { char c; };5struct two { char c[2]; };6 7namespace reference {8 struct A {9 int i1, i2;10 };11 12 void single_init() {13 const int &cri1a = {1};14 const int &cri1b{1};15 16 int i = 1;17 int &ri1a = {i};18 int &ri1b{i};19 20 int &ri2 = {1}; // expected-error {{cannot bind to an initializer list temporary}}21 22 A a{1, 2};23 A &ra1a = {a};24 A &ra1b{a};25 }26 27 void reference_to_aggregate() {28 const A &ra1{1, 2};29 A &ra2{1, 2}; // expected-error {{cannot bind to an initializer list temporary}}30 31 const int (&arrayRef)[] = {1, 2, 3};32 static_assert(sizeof(arrayRef) == 3 * sizeof(int), "bad array size");33 }34 35 struct B {36 int i1;37 };38 39 void call() {40 one f(const int&);41 f({1});42 43 one g(int&); // expected-note {{passing argument}}44 g({1}); // expected-error {{cannot bind to an initializer list temporary}}45 int i = 0;46 g({i});47 48 void h(const B&);49 h({1});50 51 void a(B&); // expected-note {{passing argument}}52 a({1}); // expected-error {{cannot bind to an initializer list temporary}}53 B b{1};54 a({b});55 }56 57 void overloading() {58 one f(const int&);59 two f(const B&);60 61 // First is identity conversion, second is user-defined conversion.62 static_assert(sizeof(f({1})) == sizeof(one), "bad overload resolution");63 64 one g(int&);65 two g(const B&);66 67 static_assert(sizeof(g({1})) == sizeof(two), "bad overload resolution");68 69 one h(const int&);70 two h(const A&);71 72 static_assert(sizeof(h({1, 2})) == sizeof(two), "bad overload resolution");73 }74 75 struct X {};76 77 void edge_cases() {78 int const &b({0}); // expected-error {{cannot initialize reference type 'const int &' with a parenthesized initializer list}}79 const int (&arr)[3] ({1, 2, 3}); // expected-error {{cannot initialize reference type 'const int (&)[3]' with a parenthesized initializer list}}80 const X &x({}); // expected-error {{cannot initialize reference type 'const X &' with a parenthesized initializer list}}81 }82 83 template<typename T> void dependent_edge_cases() {84 T b({}); // expected-error-re 3{{cannot initialize reference type {{.*}} with a parenthesized init}}85 T({}); // expected-error-re 3{{cannot initialize reference type {{.*}} with a parenthesized init}}86 }87 template void dependent_edge_cases<X>(); // ok88 template void dependent_edge_cases<const int&>(); // expected-note {{instantiation of}}89 template void dependent_edge_cases<const int(&)[1]>(); // expected-note {{instantiation of}}90 template void dependent_edge_cases<const X&>(); // expected-note {{instantiation of}}91}92 93namespace PR12182 {94 void f(int const(&)[3]);95 96 void g() {97 f({1, 2});98 }99}100 101namespace PR12660 {102 const int &i { 1 };103 struct S { S(int); } const &s { 2 };104}105 106namespace b7891773 {107 typedef void (*ptr)();108 template <class T> void f();109 int g(const ptr &);110 int k = g({ f<int> });111}112 113namespace inner_init {114 struct A { int n; };115 struct B { A &&r; };116 B b1 { 0 }; // expected-error {{reference to type 'A' could not bind to an rvalue of type 'int'}}117 B b2 { { 0 } };118 B b3 { { { 0 } } }; // expected-warning {{braces around scalar init}}119 120 struct C { C(int); }; // expected-note 2{{candidate constructor (the implicit}} \121 // expected-note {{candidate constructor not viable: cannot convert initializer list argument to 'int'}}122 struct D { C &&r; };123 D d1 { 0 }; // ok, 0 implicitly converts to C124 D d2 { { 0 } }; // ok, { 0 } calls C(0)125 D d3 { { { 0 } } }; // ok, { { 0 } } calls C({ 0 }), expected-warning {{braces around scalar init}}126 D d4 { { { { 0 } } } }; // expected-error {{no matching constructor for initialization of 'C &&'}}127 128 struct E { explicit E(int); }; // expected-note 2{{here}}129 struct F { E &&r; };130 F f1 { 0 }; // expected-error {{could not bind to an rvalue of type 'int'}}131 F f2 { { 0 } }; // expected-error {{chosen constructor is explicit}}132 F f3 { { { 0 } } }; // expected-error {{chosen constructor is explicit}}133}134 135namespace PR20844 {136 struct A {};137 struct B { operator A&(); } b;138 A &a{b}; // expected-error {{excess elements}} expected-note {{in initialization of temporary of type 'A'}}139}140 141namespace PR21834 {142const int &a = (const int &){0}; // expected-error {{cannot bind to an initializer list}}143}144 145namespace GH59100 {146class v {};147 148template <typename T>149class V : public v {};150 151using T = const V<int> &;152 153template <class D>154void f() {155 auto t = T{};156}157 158void z() {159 f<int>();160}161}162