head	1.1;
branch	1.1.1;
access;
symbols
	netbsd-11-0-RC4:1.1.1.3
	netbsd-11-0-RC3:1.1.1.3
	netbsd-11-0-RC2:1.1.1.3
	netbsd-11-0-RC1:1.1.1.3
	perseant-exfatfs-base-20250801:1.1.1.3
	netbsd-11:1.1.1.3.0.10
	netbsd-11-base:1.1.1.3
	netbsd-10-1-RELEASE:1.1.1.3
	perseant-exfatfs-base-20240630:1.1.1.3
	perseant-exfatfs:1.1.1.3.0.8
	perseant-exfatfs-base:1.1.1.3
	netbsd-8-3-RELEASE:1.1.1.2
	netbsd-9-4-RELEASE:1.1.1.2
	netbsd-10-0-RELEASE:1.1.1.3
	netbsd-10-0-RC6:1.1.1.3
	netbsd-10-0-RC5:1.1.1.3
	netbsd-10-0-RC4:1.1.1.3
	netbsd-10-0-RC3:1.1.1.3
	netbsd-10-0-RC2:1.1.1.3
	netbsd-10-0-RC1:1.1.1.3
	netbsd-10:1.1.1.3.0.6
	netbsd-10-base:1.1.1.3
	netbsd-9-3-RELEASE:1.1.1.2
	cjep_sun2x:1.1.1.3.0.4
	cjep_sun2x-base:1.1.1.3
	cjep_staticlib_x-base1:1.1.1.3
	netbsd-9-2-RELEASE:1.1.1.2
	cjep_staticlib_x:1.1.1.3.0.2
	cjep_staticlib_x-base:1.1.1.3
	netbsd-9-1-RELEASE:1.1.1.2
	phil-wifi-20200421:1.1.1.3
	phil-wifi-20200411:1.1.1.3
	phil-wifi-20200406:1.1.1.3
	netbsd-8-2-RELEASE:1.1.1.2
	netbsd-9-0-RELEASE:1.1.1.2
	netbsd-9-0-RC2:1.1.1.2
	netbsd-9-0-RC1:1.1.1.2
	netbsd-9:1.1.1.2.0.18
	netbsd-9-base:1.1.1.2
	phil-wifi-20190609:1.1.1.2
	netbsd-8-1-RELEASE:1.1.1.2
	netbsd-8-1-RC1:1.1.1.2
	pgoyette-compat-merge-20190127:1.1.1.2
	pgoyette-compat-20190127:1.1.1.2
	pgoyette-compat-20190118:1.1.1.2
	pgoyette-compat-1226:1.1.1.2
	pgoyette-compat-1126:1.1.1.2
	pgoyette-compat-1020:1.1.1.2
	pgoyette-compat-0930:1.1.1.2
	pgoyette-compat-0906:1.1.1.2
	netbsd-7-2-RELEASE:1.1.1.1
	pgoyette-compat-0728:1.1.1.2
	clang-337282:1.1.1.2
	netbsd-8-0-RELEASE:1.1.1.2
	phil-wifi:1.1.1.2.0.16
	phil-wifi-base:1.1.1.2
	pgoyette-compat-0625:1.1.1.2
	netbsd-8-0-RC2:1.1.1.2
	pgoyette-compat-0521:1.1.1.2
	pgoyette-compat-0502:1.1.1.2
	pgoyette-compat-0422:1.1.1.2
	netbsd-8-0-RC1:1.1.1.2
	pgoyette-compat-0415:1.1.1.2
	pgoyette-compat-0407:1.1.1.2
	pgoyette-compat-0330:1.1.1.2
	pgoyette-compat-0322:1.1.1.2
	pgoyette-compat-0315:1.1.1.2
	netbsd-7-1-2-RELEASE:1.1.1.1
	pgoyette-compat:1.1.1.2.0.14
	pgoyette-compat-base:1.1.1.2
	netbsd-7-1-1-RELEASE:1.1.1.1
	clang-319952:1.1.1.2
	matt-nb8-mediatek:1.1.1.2.0.12
	matt-nb8-mediatek-base:1.1.1.2
	clang-309604:1.1.1.2
	perseant-stdc-iso10646:1.1.1.2.0.10
	perseant-stdc-iso10646-base:1.1.1.2
	netbsd-8:1.1.1.2.0.8
	netbsd-8-base:1.1.1.2
	prg-localcount2-base3:1.1.1.2
	prg-localcount2-base2:1.1.1.2
	prg-localcount2-base1:1.1.1.2
	prg-localcount2:1.1.1.2.0.6
	prg-localcount2-base:1.1.1.2
	pgoyette-localcount-20170426:1.1.1.2
	bouyer-socketcan-base1:1.1.1.2
	pgoyette-localcount-20170320:1.1.1.2
	netbsd-7-1:1.1.1.1.0.14
	netbsd-7-1-RELEASE:1.1.1.1
	netbsd-7-1-RC2:1.1.1.1
	clang-294123:1.1.1.2
	netbsd-7-nhusb-base-20170116:1.1.1.1
	bouyer-socketcan:1.1.1.2.0.4
	bouyer-socketcan-base:1.1.1.2
	clang-291444:1.1.1.2
	pgoyette-localcount-20170107:1.1.1.2
	netbsd-7-1-RC1:1.1.1.1
	pgoyette-localcount-20161104:1.1.1.2
	netbsd-7-0-2-RELEASE:1.1.1.1
	localcount-20160914:1.1.1.2
	netbsd-7-nhusb:1.1.1.1.0.12
	netbsd-7-nhusb-base:1.1.1.1
	clang-280599:1.1.1.2
	pgoyette-localcount-20160806:1.1.1.2
	pgoyette-localcount-20160726:1.1.1.2
	pgoyette-localcount:1.1.1.2.0.2
	pgoyette-localcount-base:1.1.1.2
	netbsd-7-0-1-RELEASE:1.1.1.1
	clang-261930:1.1.1.2
	netbsd-7-0:1.1.1.1.0.10
	netbsd-7-0-RELEASE:1.1.1.1
	netbsd-7-0-RC3:1.1.1.1
	netbsd-7-0-RC2:1.1.1.1
	netbsd-7-0-RC1:1.1.1.1
	clang-237755:1.1.1.1
	clang-232565:1.1.1.1
	clang-227398:1.1.1.1
	tls-maxphys-base:1.1.1.1
	tls-maxphys:1.1.1.1.0.8
	netbsd-7:1.1.1.1.0.6
	netbsd-7-base:1.1.1.1
	clang-215315:1.1.1.1
	clang-209886:1.1.1.1
	yamt-pagecache:1.1.1.1.0.4
	yamt-pagecache-base9:1.1.1.1
	tls-earlyentropy:1.1.1.1.0.2
	tls-earlyentropy-base:1.1.1.1
	riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.1
	riastradh-drm2-base3:1.1.1.1
	clang-202566:1.1.1.1
	clang-201163:1.1.1.1
	clang-199312:1.1.1.1
	clang-198450:1.1.1.1
	clang-196603:1.1.1.1
	clang-195771:1.1.1.1
	LLVM:1.1.1;
locks; strict;
comment	@// @;


1.1
date	2013.11.28.14.14.55;	author joerg;	state Exp;
branches
	1.1.1.1;
next	;
commitid	ow8OybrawrB1f3fx;

1.1.1.1
date	2013.11.28.14.14.55;	author joerg;	state Exp;
branches
	1.1.1.1.4.1
	1.1.1.1.8.1;
next	1.1.1.2;
commitid	ow8OybrawrB1f3fx;

1.1.1.2
date	2016.02.27.22.08.58;	author joerg;	state Exp;
branches
	1.1.1.2.16.1;
next	1.1.1.3;
commitid	tIimz3oDlh1NpBWy;

1.1.1.3
date	2019.11.13.22.22.59;	author joerg;	state dead;
branches;
next	;
commitid	QD8YATxuNG34YJKB;

1.1.1.1.4.1
date	2013.11.28.14.14.55;	author yamt;	state dead;
branches;
next	1.1.1.1.4.2;
commitid	WSrDtL5nYAUyiyBx;

1.1.1.1.4.2
date	2014.05.22.16.19.45;	author yamt;	state Exp;
branches;
next	;
commitid	WSrDtL5nYAUyiyBx;

1.1.1.1.8.1
date	2013.11.28.14.14.55;	author tls;	state dead;
branches;
next	1.1.1.1.8.2;
commitid	jTnpym9Qu0o4R1Nx;

1.1.1.1.8.2
date	2014.08.19.23.49.24;	author tls;	state Exp;
branches;
next	;
commitid	jTnpym9Qu0o4R1Nx;

1.1.1.2.16.1
date	2020.04.13.07.50.27;	author martin;	state dead;
branches;
next	;
commitid	X01YhRUPVUDaec4C;


desc
@@


1.1
log
@Initial revision
@
text
@// RUN: %clang_cc1 -fsyntax-only -verify %s
template<typename T>
class C { C(int a0 = 0); };

template<>
C<char>::C(int a0);

struct S { }; // expected-note 3 {{candidate constructor (the implicit copy constructor)}}

template<typename T> void f1(T a, T b = 10) { } // expected-error{{no viable conversion}} \
// expected-note{{passing argument to parameter 'b' here}}

template<typename T> void f2(T a, T b = T()) { }

template<typename T> void f3(T a, T b = T() + T()); // expected-error{{invalid operands to binary expression ('S' and 'S')}}

void g() {
  f1(10);
  f1(S()); // expected-note{{in instantiation of default function argument expression for 'f1<S>' required here}}
  
  f2(10);
  f2(S());
  
  f3(10);
  f3(S()); // expected-note{{in instantiation of default function argument expression for 'f3<S>' required here}}
}

template<typename T> struct F {
  F(T t = 10); // expected-error{{no viable conversion}} \
  // expected-note{{passing argument to parameter 't' here}}
  void f(T t = 10); // expected-error{{no viable conversion}} \
  // expected-note{{passing argument to parameter 't' here}}
};

struct FD : F<int> { };

void g2() {
  F<int> f;
  FD fd;
}

void g3(F<int> f, F<struct S> s) {
  f.f();
  s.f(); // expected-note{{in instantiation of default function argument expression for 'f<S>' required here}}
  
  F<int> f2;
  F<S> s2; // expected-note{{in instantiation of default function argument expression for 'F<S>' required here}}
}

template<typename T> struct G {
  G(T) {}
};

void s(G<int> flags = 10) { }

// Test default arguments
template<typename T>
struct X0 {
  void f(T = T()); // expected-error{{no matching}}
};

template<typename U>
void X0<U>::f(U) { }

void test_x0(X0<int> xi) {
  xi.f();
  xi.f(17);
}

struct NotDefaultConstructible { // expected-note 2{{candidate}}
  NotDefaultConstructible(int); // expected-note 2{{candidate}}
};

void test_x0_not_default_constructible(X0<NotDefaultConstructible> xn) {
  xn.f(NotDefaultConstructible(17));
  xn.f(42);
  xn.f(); // expected-note{{in instantiation of default function argument}}
}

template<typename T>
struct X1 {
  typedef T value_type;
  X1(const value_type& value = value_type());
};

void test_X1() {
  X1<int> x1;
}

template<typename T>
struct X2 {
  void operator()(T = T()); // expected-error{{no matching}}
};

void test_x2(X2<int> x2i, X2<NotDefaultConstructible> x2n) {
  x2i();
  x2i(17);
  x2n(NotDefaultConstructible(17));
  x2n(); // expected-note{{in instantiation of default function argument}}
}

// PR5283
namespace PR5283 {
template<typename T> struct A {
  A(T = 1); // expected-error 3 {{cannot initialize a parameter of type 'int *' with an rvalue of type 'int'}} \
  // expected-note 3{{passing argument to parameter here}}
};

struct B : A<int*> { 
  B();
};
B::B() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}

struct C : virtual A<int*> {
  C();
};
C::C() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}

struct D {
  D();
  
  A<int*> a;
};
D::D() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}
}

// PR5301
namespace pr5301 {
  void f(int, int = 0);

  template <typename T>
  void g(T, T = 0);

  template <int I>
  void i(int a = I);

  template <typename T>
  void h(T t) {
    f(0);
    g(1);
    g(t);
    i<2>();
  }

  void test() {
    h(0);
  }
}

// PR5810
namespace PR5810 {
  template<typename T>
  struct allocator {
    allocator() { int a[sizeof(T) ? -1 : -1]; } // expected-error2 {{array with a negative size}}
  };
  
  template<typename T>
  struct vector {
    vector(const allocator<T>& = allocator<T>()) {} // expected-note2 {{instantiation of}}
  };
  
  struct A { };
  struct B { };

  template<typename>
  void FilterVTs() {
    vector<A> Result;
  }
  
  void f() {
    vector<A> Result;
  }

  template<typename T>
  struct X {
    vector<B> bs;
    X() { }
  };

  void f2() {
    X<float> x; // expected-note{{member function}}
  }
}

template<typename T> void f4(T, int = 17);
template<> void f4<int>(int, int);

void f4_test(int i) {
  f4(i);
}

// Instantiate for initialization
namespace InstForInit {
  template<typename T>
  struct Ptr {
    typedef T* type;
    Ptr(type);
  };

  template<typename T>
  struct Holder {
    Holder(int i, Ptr<T> ptr = 0);
  };

  void test_holder(int i) {
    Holder<int> h(i);
  }
};

namespace PR5810b {
  template<typename T>
  T broken() {
    T t;
    double**** not_it = t;
  }

  void f(int = broken<int>());
  void g() { f(17); }
}

namespace PR5810c {
  template<typename T>
  struct X { 
    X() { 
      T t;
      double *****p = t; // expected-error{{cannot initialize a variable of type 'double *****' with an lvalue of type 'int'}}
    }
    X(const X&) { }
  };

  struct Y : X<int> { // expected-note{{instantiation of}}
  };

  void f(Y y = Y());

  void g() { f(); }
}

namespace PR8127 {
  template< typename T > class PointerClass {
  public:
    PointerClass( T * object_p ) : p_( object_p ) {
      p_->acquire();
    }
  private:    
    T * p_;
  };

  class ExternallyImplementedClass;

  class MyClass {
    void foo( PointerClass<ExternallyImplementedClass> = 0 );
  };
}

namespace rdar8427926 {
  template<typename T>
  struct Boom {
    ~Boom() {
      T t;
      double *******ptr = t; // expected-error 2{{cannot initialize}}
    }
  };

  Boom<float> *bfp;

  struct X {
    void f(Boom<int> = Boom<int>()) { } // expected-note{{requested here}}
    void g(int x = (delete bfp, 0)); // expected-note{{requested here}}
  };

  void test(X *x) {
    x->f();
    x->g();
  }
}

namespace PR8401 {
  template<typename T> 
  struct A { 
    A() { T* x = 1; } // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
  };

  template<typename T>
  struct B {
    B(const A<T>& a = A<T>()); // expected-note{{in instantiation of}}
  };

  void f(B<int> b = B<int>());

  void g() {
    f();
  }
}

namespace PR12581 {
  const int a = 0;
  template < typename > struct A;
  template < typename MatrixType, int =
  A < MatrixType >::Flags ? : A < MatrixType >::Flags & a > class B;
  void
  fn1 ()
  {
  }
}

namespace PR13758 {
  template <typename T> struct move_from {
    T invalid;
  };
  template <class K>
  struct unordered_map {
    explicit unordered_map(int n = 42);
    unordered_map(move_from<K> other);
  };
  template<typename T>
  void StripedHashTable() {
    new unordered_map<void>();
    new unordered_map<void>;
  }
  void tt() {
    StripedHashTable<int>();
  }
}
@


1.1.1.1
log
@Import Clang 3.4rc1 r195771.
@
text
@@


1.1.1.2
log
@Import Clang 3.8.0rc3 r261930.
@
text
@a1 3
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s

a8 3
#if __cplusplus >= 201103L // C++11 or later
// expected-note@@-2 3 {{candidate constructor (the implicit move constructor) not viable}}
#endif
d70 1
a70 4
struct NotDefaultConstructible { // expected-note 2 {{candidate constructor (the implicit copy constructor) not viable}}
#if __cplusplus >= 201103L // C++11 or later
// expected-note@@-2 2 {{candidate constructor (the implicit move constructor) not viable}}
#endif
@


1.1.1.2.16.1
log
@Mostly merge changes from HEAD upto 20200411
@
text
@@


1.1.1.3
log
@Mark old LLVM instance as dead.
@
text
@@


1.1.1.1.8.1
log
@file default-expr-arguments.cpp was added on branch tls-maxphys on 2014-08-19 23:49:24 +0000
@
text
@d1 324
@


1.1.1.1.8.2
log
@Rebase to HEAD as of a few days ago.
@
text
@a0 324
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<typename T>
class C { C(int a0 = 0); };

template<>
C<char>::C(int a0);

struct S { }; // expected-note 3 {{candidate constructor (the implicit copy constructor)}}

template<typename T> void f1(T a, T b = 10) { } // expected-error{{no viable conversion}} \
// expected-note{{passing argument to parameter 'b' here}}

template<typename T> void f2(T a, T b = T()) { }

template<typename T> void f3(T a, T b = T() + T()); // expected-error{{invalid operands to binary expression ('S' and 'S')}}

void g() {
  f1(10);
  f1(S()); // expected-note{{in instantiation of default function argument expression for 'f1<S>' required here}}
  
  f2(10);
  f2(S());
  
  f3(10);
  f3(S()); // expected-note{{in instantiation of default function argument expression for 'f3<S>' required here}}
}

template<typename T> struct F {
  F(T t = 10); // expected-error{{no viable conversion}} \
  // expected-note{{passing argument to parameter 't' here}}
  void f(T t = 10); // expected-error{{no viable conversion}} \
  // expected-note{{passing argument to parameter 't' here}}
};

struct FD : F<int> { };

void g2() {
  F<int> f;
  FD fd;
}

void g3(F<int> f, F<struct S> s) {
  f.f();
  s.f(); // expected-note{{in instantiation of default function argument expression for 'f<S>' required here}}
  
  F<int> f2;
  F<S> s2; // expected-note{{in instantiation of default function argument expression for 'F<S>' required here}}
}

template<typename T> struct G {
  G(T) {}
};

void s(G<int> flags = 10) { }

// Test default arguments
template<typename T>
struct X0 {
  void f(T = T()); // expected-error{{no matching}}
};

template<typename U>
void X0<U>::f(U) { }

void test_x0(X0<int> xi) {
  xi.f();
  xi.f(17);
}

struct NotDefaultConstructible { // expected-note 2{{candidate}}
  NotDefaultConstructible(int); // expected-note 2{{candidate}}
};

void test_x0_not_default_constructible(X0<NotDefaultConstructible> xn) {
  xn.f(NotDefaultConstructible(17));
  xn.f(42);
  xn.f(); // expected-note{{in instantiation of default function argument}}
}

template<typename T>
struct X1 {
  typedef T value_type;
  X1(const value_type& value = value_type());
};

void test_X1() {
  X1<int> x1;
}

template<typename T>
struct X2 {
  void operator()(T = T()); // expected-error{{no matching}}
};

void test_x2(X2<int> x2i, X2<NotDefaultConstructible> x2n) {
  x2i();
  x2i(17);
  x2n(NotDefaultConstructible(17));
  x2n(); // expected-note{{in instantiation of default function argument}}
}

// PR5283
namespace PR5283 {
template<typename T> struct A {
  A(T = 1); // expected-error 3 {{cannot initialize a parameter of type 'int *' with an rvalue of type 'int'}} \
  // expected-note 3{{passing argument to parameter here}}
};

struct B : A<int*> { 
  B();
};
B::B() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}

struct C : virtual A<int*> {
  C();
};
C::C() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}

struct D {
  D();
  
  A<int*> a;
};
D::D() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}
}

// PR5301
namespace pr5301 {
  void f(int, int = 0);

  template <typename T>
  void g(T, T = 0);

  template <int I>
  void i(int a = I);

  template <typename T>
  void h(T t) {
    f(0);
    g(1);
    g(t);
    i<2>();
  }

  void test() {
    h(0);
  }
}

// PR5810
namespace PR5810 {
  template<typename T>
  struct allocator {
    allocator() { int a[sizeof(T) ? -1 : -1]; } // expected-error2 {{array with a negative size}}
  };
  
  template<typename T>
  struct vector {
    vector(const allocator<T>& = allocator<T>()) {} // expected-note2 {{instantiation of}}
  };
  
  struct A { };
  struct B { };

  template<typename>
  void FilterVTs() {
    vector<A> Result;
  }
  
  void f() {
    vector<A> Result;
  }

  template<typename T>
  struct X {
    vector<B> bs;
    X() { }
  };

  void f2() {
    X<float> x; // expected-note{{member function}}
  }
}

template<typename T> void f4(T, int = 17);
template<> void f4<int>(int, int);

void f4_test(int i) {
  f4(i);
}

// Instantiate for initialization
namespace InstForInit {
  template<typename T>
  struct Ptr {
    typedef T* type;
    Ptr(type);
  };

  template<typename T>
  struct Holder {
    Holder(int i, Ptr<T> ptr = 0);
  };

  void test_holder(int i) {
    Holder<int> h(i);
  }
};

namespace PR5810b {
  template<typename T>
  T broken() {
    T t;
    double**** not_it = t;
  }

  void f(int = broken<int>());
  void g() { f(17); }
}

namespace PR5810c {
  template<typename T>
  struct X { 
    X() { 
      T t;
      double *****p = t; // expected-error{{cannot initialize a variable of type 'double *****' with an lvalue of type 'int'}}
    }
    X(const X&) { }
  };

  struct Y : X<int> { // expected-note{{instantiation of}}
  };

  void f(Y y = Y());

  void g() { f(); }
}

namespace PR8127 {
  template< typename T > class PointerClass {
  public:
    PointerClass( T * object_p ) : p_( object_p ) {
      p_->acquire();
    }
  private:    
    T * p_;
  };

  class ExternallyImplementedClass;

  class MyClass {
    void foo( PointerClass<ExternallyImplementedClass> = 0 );
  };
}

namespace rdar8427926 {
  template<typename T>
  struct Boom {
    ~Boom() {
      T t;
      double *******ptr = t; // expected-error 2{{cannot initialize}}
    }
  };

  Boom<float> *bfp;

  struct X {
    void f(Boom<int> = Boom<int>()) { } // expected-note{{requested here}}
    void g(int x = (delete bfp, 0)); // expected-note{{requested here}}
  };

  void test(X *x) {
    x->f();
    x->g();
  }
}

namespace PR8401 {
  template<typename T> 
  struct A { 
    A() { T* x = 1; } // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
  };

  template<typename T>
  struct B {
    B(const A<T>& a = A<T>()); // expected-note{{in instantiation of}}
  };

  void f(B<int> b = B<int>());

  void g() {
    f();
  }
}

namespace PR12581 {
  const int a = 0;
  template < typename > struct A;
  template < typename MatrixType, int =
  A < MatrixType >::Flags ? : A < MatrixType >::Flags & a > class B;
  void
  fn1 ()
  {
  }
}

namespace PR13758 {
  template <typename T> struct move_from {
    T invalid;
  };
  template <class K>
  struct unordered_map {
    explicit unordered_map(int n = 42);
    unordered_map(move_from<K> other);
  };
  template<typename T>
  void StripedHashTable() {
    new unordered_map<void>();
    new unordered_map<void>;
  }
  void tt() {
    StripedHashTable<int>();
  }
}
@


1.1.1.1.4.1
log
@file default-expr-arguments.cpp was added on branch yamt-pagecache on 2014-05-22 16:19:45 +0000
@
text
@d1 324
@


1.1.1.1.4.2
log
@sync with head.

for a reference, the tree before this commit was tagged
as yamt-pagecache-tag8.

this commit was splitted into small chunks to avoid
a limitation of cvs.  ("Protocol error: too many arguments")
@
text
@a0 324
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<typename T>
class C { C(int a0 = 0); };

template<>
C<char>::C(int a0);

struct S { }; // expected-note 3 {{candidate constructor (the implicit copy constructor)}}

template<typename T> void f1(T a, T b = 10) { } // expected-error{{no viable conversion}} \
// expected-note{{passing argument to parameter 'b' here}}

template<typename T> void f2(T a, T b = T()) { }

template<typename T> void f3(T a, T b = T() + T()); // expected-error{{invalid operands to binary expression ('S' and 'S')}}

void g() {
  f1(10);
  f1(S()); // expected-note{{in instantiation of default function argument expression for 'f1<S>' required here}}
  
  f2(10);
  f2(S());
  
  f3(10);
  f3(S()); // expected-note{{in instantiation of default function argument expression for 'f3<S>' required here}}
}

template<typename T> struct F {
  F(T t = 10); // expected-error{{no viable conversion}} \
  // expected-note{{passing argument to parameter 't' here}}
  void f(T t = 10); // expected-error{{no viable conversion}} \
  // expected-note{{passing argument to parameter 't' here}}
};

struct FD : F<int> { };

void g2() {
  F<int> f;
  FD fd;
}

void g3(F<int> f, F<struct S> s) {
  f.f();
  s.f(); // expected-note{{in instantiation of default function argument expression for 'f<S>' required here}}
  
  F<int> f2;
  F<S> s2; // expected-note{{in instantiation of default function argument expression for 'F<S>' required here}}
}

template<typename T> struct G {
  G(T) {}
};

void s(G<int> flags = 10) { }

// Test default arguments
template<typename T>
struct X0 {
  void f(T = T()); // expected-error{{no matching}}
};

template<typename U>
void X0<U>::f(U) { }

void test_x0(X0<int> xi) {
  xi.f();
  xi.f(17);
}

struct NotDefaultConstructible { // expected-note 2{{candidate}}
  NotDefaultConstructible(int); // expected-note 2{{candidate}}
};

void test_x0_not_default_constructible(X0<NotDefaultConstructible> xn) {
  xn.f(NotDefaultConstructible(17));
  xn.f(42);
  xn.f(); // expected-note{{in instantiation of default function argument}}
}

template<typename T>
struct X1 {
  typedef T value_type;
  X1(const value_type& value = value_type());
};

void test_X1() {
  X1<int> x1;
}

template<typename T>
struct X2 {
  void operator()(T = T()); // expected-error{{no matching}}
};

void test_x2(X2<int> x2i, X2<NotDefaultConstructible> x2n) {
  x2i();
  x2i(17);
  x2n(NotDefaultConstructible(17));
  x2n(); // expected-note{{in instantiation of default function argument}}
}

// PR5283
namespace PR5283 {
template<typename T> struct A {
  A(T = 1); // expected-error 3 {{cannot initialize a parameter of type 'int *' with an rvalue of type 'int'}} \
  // expected-note 3{{passing argument to parameter here}}
};

struct B : A<int*> { 
  B();
};
B::B() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}

struct C : virtual A<int*> {
  C();
};
C::C() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}

struct D {
  D();
  
  A<int*> a;
};
D::D() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}
}

// PR5301
namespace pr5301 {
  void f(int, int = 0);

  template <typename T>
  void g(T, T = 0);

  template <int I>
  void i(int a = I);

  template <typename T>
  void h(T t) {
    f(0);
    g(1);
    g(t);
    i<2>();
  }

  void test() {
    h(0);
  }
}

// PR5810
namespace PR5810 {
  template<typename T>
  struct allocator {
    allocator() { int a[sizeof(T) ? -1 : -1]; } // expected-error2 {{array with a negative size}}
  };
  
  template<typename T>
  struct vector {
    vector(const allocator<T>& = allocator<T>()) {} // expected-note2 {{instantiation of}}
  };
  
  struct A { };
  struct B { };

  template<typename>
  void FilterVTs() {
    vector<A> Result;
  }
  
  void f() {
    vector<A> Result;
  }

  template<typename T>
  struct X {
    vector<B> bs;
    X() { }
  };

  void f2() {
    X<float> x; // expected-note{{member function}}
  }
}

template<typename T> void f4(T, int = 17);
template<> void f4<int>(int, int);

void f4_test(int i) {
  f4(i);
}

// Instantiate for initialization
namespace InstForInit {
  template<typename T>
  struct Ptr {
    typedef T* type;
    Ptr(type);
  };

  template<typename T>
  struct Holder {
    Holder(int i, Ptr<T> ptr = 0);
  };

  void test_holder(int i) {
    Holder<int> h(i);
  }
};

namespace PR5810b {
  template<typename T>
  T broken() {
    T t;
    double**** not_it = t;
  }

  void f(int = broken<int>());
  void g() { f(17); }
}

namespace PR5810c {
  template<typename T>
  struct X { 
    X() { 
      T t;
      double *****p = t; // expected-error{{cannot initialize a variable of type 'double *****' with an lvalue of type 'int'}}
    }
    X(const X&) { }
  };

  struct Y : X<int> { // expected-note{{instantiation of}}
  };

  void f(Y y = Y());

  void g() { f(); }
}

namespace PR8127 {
  template< typename T > class PointerClass {
  public:
    PointerClass( T * object_p ) : p_( object_p ) {
      p_->acquire();
    }
  private:    
    T * p_;
  };

  class ExternallyImplementedClass;

  class MyClass {
    void foo( PointerClass<ExternallyImplementedClass> = 0 );
  };
}

namespace rdar8427926 {
  template<typename T>
  struct Boom {
    ~Boom() {
      T t;
      double *******ptr = t; // expected-error 2{{cannot initialize}}
    }
  };

  Boom<float> *bfp;

  struct X {
    void f(Boom<int> = Boom<int>()) { } // expected-note{{requested here}}
    void g(int x = (delete bfp, 0)); // expected-note{{requested here}}
  };

  void test(X *x) {
    x->f();
    x->g();
  }
}

namespace PR8401 {
  template<typename T> 
  struct A { 
    A() { T* x = 1; } // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
  };

  template<typename T>
  struct B {
    B(const A<T>& a = A<T>()); // expected-note{{in instantiation of}}
  };

  void f(B<int> b = B<int>());

  void g() {
    f();
  }
}

namespace PR12581 {
  const int a = 0;
  template < typename > struct A;
  template < typename MatrixType, int =
  A < MatrixType >::Flags ? : A < MatrixType >::Flags & a > class B;
  void
  fn1 ()
  {
  }
}

namespace PR13758 {
  template <typename T> struct move_from {
    T invalid;
  };
  template <class K>
  struct unordered_map {
    explicit unordered_map(int n = 42);
    unordered_map(move_from<K> other);
  };
  template<typename T>
  void StripedHashTable() {
    new unordered_map<void>();
    new unordered_map<void>;
  }
  void tt() {
    StripedHashTable<int>();
  }
}
@