PR9793: Treat substitution as an instantiation step for the purpose of the

-ftemplate-depth limit.  There are various ways to get an infinite (or merely
huge) stack of substitutions with no intervening instantiations. This is also
consistent with gcc's behavior.


git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@159907 91177308-0d34-0410-b5e6-96231b3b80d8

3 files changed, 46 insertions, 0 deletions

diff --git a/test/SemaTemplate/instantiation-depth-defarg.cpp b/test/SemaTemplate/instantiation-depth-defarg.cpp
new file mode 100644
index 0000000000..d66c71ba54
--- /dev/null
+++ b/test/SemaTemplate/instantiation-depth-defarg.cpp
@@ -0,0 +1,28 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -ftemplate-depth 512 -ftemplate-backtrace-limit 4 %s
+
+template<int N> struct S {
+  typedef typename S<N-1>::type type;
+  static int f(int n = S<N-1>::f()); // \
+// expected-error{{recursive template instantiation exceeded maximum depth of 512}} \
+// expected-note 3 {{instantiation of default function argument}} \
+// expected-note {{skipping 509 contexts in backtrace}} \
+// expected-note {{use -ftemplate-depth=N to increase recursive template instantiation depth}}
+
+};
+template<> struct S<0> {
+  typedef int type;
+};
+
+// Incrementally instantiate up to S<2048>.
+template struct S<256>;
+template struct S<512>;
+template struct S<768>;
+template struct S<1024>;
+template struct S<1280>;
+template struct S<1536>;
+template struct S<1792>;
+template struct S<2048>;
+
+// Check that we actually bail out when we hit the instantiation depth limit for
+// the default arguments.
+void g() { S<2048>::f(); } // expected-note {{required here}}
diff --git a/test/SemaTemplate/instantiation-depth-subst-2.cpp b/test/SemaTemplate/instantiation-depth-subst-2.cpp
new file mode 100644
index 0000000000..a29d6b5a1b
--- /dev/null
+++ b/test/SemaTemplate/instantiation-depth-subst-2.cpp
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 -verify %s -ftemplate-depth 2
+
+template<int N> struct S { };
+// FIXME: We produce the same 'instantiation depth' error here many times
+// (2^(depth+1) in total), due to additional lookups performed as part of
+// error recovery in DiagnoseTwoPhaseOperatorLookup.
+template<typename T> S<T() + T()> operator+(T, T); // expected-error 8{{}} expected-note 10{{}}
+S<0> s;
+int k = s + s; // expected-error {{invalid operands to binary expression}}
diff --git a/test/SemaTemplate/instantiation-depth-subst.cpp b/test/SemaTemplate/instantiation-depth-subst.cpp
new file mode 100644
index 0000000000..58e637411c
--- /dev/null
+++ b/test/SemaTemplate/instantiation-depth-subst.cpp
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 -std=c++11 -verify %s -ftemplate-depth 2
+
+// PR9793
+template<typename T> auto f(T t) -> decltype(f(t)); // \
+// expected-error {{recursive template instantiation exceeded maximum depth of 2}} \
+// expected-note 3 {{while substituting}} \
+// expected-note {{candidate}}
+
+int k = f(0); // expected-error {{no matching function for call to 'f'}}