diff --git a/clang/test/Modules/Inputs/cxx-templates-a.h b/clang/test/Modules/Inputs/cxx-templates-a.h
index 52bc3a2..76997c7 100644
--- a/clang/test/Modules/Inputs/cxx-templates-a.h
+++ b/clang/test/Modules/Inputs/cxx-templates-a.h
@@ -4,3 +4,7 @@
   template<typename T> T f() { return T(); }
   template<typename T> T f(T);
 }
+
+template<int N> int template_param_kinds_1();
+template<template<typename T, int, int> class> int template_param_kinds_2();
+template<template<typename T, typename U, T> class> int template_param_kinds_3();
diff --git a/clang/test/Modules/Inputs/cxx-templates-b.h b/clang/test/Modules/Inputs/cxx-templates-b.h
index 3cc940c..c50d705 100644
--- a/clang/test/Modules/Inputs/cxx-templates-b.h
+++ b/clang/test/Modules/Inputs/cxx-templates-b.h
@@ -4,3 +4,7 @@
   template<typename T> T f();
   template<typename T> T f(T t) { return t; }
 }
+
+template<typename> int template_param_kinds_1();
+template<template<typename, int, int...> class> int template_param_kinds_2();
+template<template<typename T, typename U, U> class> int template_param_kinds_3();
diff --git a/clang/test/Modules/cxx-templates.cpp b/clang/test/Modules/cxx-templates.cpp
index 7926812..7d500f4 100644
--- a/clang/test/Modules/cxx-templates.cpp
+++ b/clang/test/Modules/cxx-templates.cpp
@@ -6,6 +6,12 @@
 @import cxx_templates_a;
 @import cxx_templates_b;
 
+template<typename, char> struct Tmpl_T_C {};
+template<typename, int, int> struct Tmpl_T_I_I {};
+
+template<typename A, typename B, A> struct Tmpl_T_T_A {};
+template<typename A, typename B, B> struct Tmpl_T_T_B {};
+
 void g() {
   f(0);
   f<double>(1.0);
@@ -20,6 +26,26 @@
   N::f(); // expected-error {{no matching function}}
   // expected-note@Inputs/cxx-templates-a.h:4 {{couldn't infer template argument}}
   // expected-note@Inputs/cxx-templates-a.h:5 {{requires 1 argument, but 0 were provided}}
+
+  template_param_kinds_1<0>(); // ok, from cxx-templates-a.h
+  template_param_kinds_1<int>(); // ok, from cxx-templates-b.h
+
+  template_param_kinds_2<Tmpl_T_C>(); // expected-error {{no matching function}}
+  // expected-note@Inputs/cxx-templates-a.h:9 {{invalid explicitly-specified argument}}
+  // expected-note@Inputs/cxx-templates-b.h:9 {{invalid explicitly-specified argument}}
+
+  template_param_kinds_2<Tmpl_T_I_I>(); // expected-error {{ambiguous}}
+  // expected-note@Inputs/cxx-templates-a.h:9 {{candidate}}
+  // expected-note@Inputs/cxx-templates-b.h:9 {{candidate}}
+
+  // FIXME: This should be valid, but we incorrectly match the template template
+  // argument against both template template parameters.
+  template_param_kinds_3<Tmpl_T_T_A>(); // expected-error {{ambiguous}}
+  // expected-note@Inputs/cxx-templates-a.h:10 {{candidate}}
+  // expected-note@Inputs/cxx-templates-b.h:10 {{candidate}}
+  template_param_kinds_3<Tmpl_T_T_B>(); // expected-error {{ambiguous}}
+  // expected-note@Inputs/cxx-templates-a.h:10 {{candidate}}
+  // expected-note@Inputs/cxx-templates-b.h:10 {{candidate}}
 }
 
 // FIXME: There should only be two 'f's here.
