text: // 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}}
    }
  }
  