// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s

// FIXME: More bullets to go!

template<typename T, typename U>
struct has_nondeduced_pack_test {
  static const bool value = false;
};

template<typename R, typename FirstType, typename ...Types>
struct has_nondeduced_pack_test<R(FirstType, Types..., int), 
                                R(FirstType, Types...)> {
  static const bool value = true;
};

// - A function parameter pack that does not occur at the end of the
//   parameter-declaration-clause.
//
// We interpret [temp.deduct.call]p1's
//
//   "When a function parameter pack appears in a non-deduced context
//   (12.9.2.5), the type of that pack is never deduced."
//
// as applying in all deduction contexts, not just [temp.deduct.call],
// so we do *not* deduce Types from the second argument here. (More
// precisely, we deduce it as <> when processing the first argument,
// and then fail because 'int' doesn't match 'double, int'.)
int check_nondeduced_pack_test0[
                   has_nondeduced_pack_test<int(float, double, int),
                                            int(float, double)>::value? -1 : 1];

template<typename ...T> void has_non_trailing_pack(T ..., int);
void (*ptr_has_non_trailing_pack)(char, int) = has_non_trailing_pack<char>;

template<typename ...T, typename U> void has_non_trailing_pack_and_more(T ..., U); // expected-note {{failed}}
void (*ptr_has_non_trailing_pack_and_more_1)(float, double, int) = &has_non_trailing_pack_and_more<float, double>;
void (*ptr_has_non_trailing_pack_and_more_2)(float, double, int) = &has_non_trailing_pack_and_more<float>; // expected-error {{does not match}}

// - A function parameter for which the associated argument is an initializer
//   list but the parameter does not have a type for which deduction from an
//   initializer list is specified.

// We interpret these "non-deduced context"s as actually deducing the arity --
// but not the contents -- of a function parameter pack appropriately for the
// number of arguments.
namespace VariadicVsInitList {
  template<typename T, typename ...> struct X { using type = typename T::error; };
  template<typename ...T, typename X<int, T...>::type = 0> void f(T ...) = delete;
  void f(long);
  void f(long, long);
  void f(long, long, long);

  // FIXME: We shouldn't say "substitution failure: " here.
  template<typename ...T> void g(T ...) = delete; // expected-note {{substitution failure: deduced incomplete pack <(no value)> for template parameter 'T'}}

  void h() {
    // These all call the non-template overloads of 'f', because of a deduction
    // failure due to incomplete deduction of the pack 'T'. If deduction
    // succeeds and deduces an empty pack instead, we would get a hard error
    // instantiating 'X'.
    f({0}); // expected-warning {{braces around scalar}}
    f({0}, {0}); // expected-warning 2{{braces around scalar}}
    f(1, {0}); // expected-warning {{braces around scalar}}
    f(1, {0}, 2); // expected-warning {{braces around scalar}}

    g({0}); // expected-error {{no matching function}}
  }
}