From beda951d788a0041e9f5fabbb4e018e8b9d0a2d3 Mon Sep 17 00:00:00 2001 From: Richard Smith Date: Wed, 15 May 2019 23:36:14 +0000 Subject: [PATCH] Make tentative parsing to detect template-argument-lists less aggressive (and less wrong). It's not correct to assume that X is always a template-id; there are a few cases where the comma takes us into a non-expression syntactic context in which 'Type' might be permissible. Stop doing that. This slightly regresses our error recovery on the cases where the construct is intended to be a template-id. We typically do still manage to diagnose a missing 'template' keyword, but we realize this too late to properly recover from the error. This fixes a regression introduced by r360308. llvm-svn: 360827 --- clang/lib/Parse/ParseTentative.cpp | 50 +++++++++++----------- clang/test/Parser/cxx-template-argument.cpp | 11 +++++ .../SemaTemplate/dependent-template-recover.cpp | 8 ++-- 3 files changed, 39 insertions(+), 30 deletions(-) diff --git a/clang/lib/Parse/ParseTentative.cpp b/clang/lib/Parse/ParseTentative.cpp index 2d2705d..4393326 100644 --- a/clang/lib/Parse/ParseTentative.cpp +++ b/clang/lib/Parse/ParseTentative.cpp @@ -2065,33 +2065,31 @@ Parser::TPResult Parser::isTemplateArgumentList(unsigned TokensToSkip) { if (!TryConsumeToken(tok::less)) return TPResult::False; + // We can't do much to tell an expression apart from a template-argument, + // but one good distinguishing factor is that a "decl-specifier" not + // followed by '(' or '{' can't appear in an expression. bool InvalidAsTemplateArgumentList = false; - while (true) { - // We can't do much to tell an expression apart from a template-argument, - // but one good distinguishing factor is that a "decl-specifier" not - // followed by '(' or '{' can't appear in an expression. - if (isCXXDeclarationSpecifier( - TPResult::False, &InvalidAsTemplateArgumentList) == TPResult::True) - return TPResult::True; - - // That didn't help, try the next template-argument. - SkipUntil({tok::comma, tok::greater, tok::greatergreater, - tok::greatergreatergreater}, - StopAtSemi | StopBeforeMatch); - switch (Tok.getKind()) { - case tok::comma: - ConsumeToken(); - break; + if (isCXXDeclarationSpecifier(TPResult::False, + &InvalidAsTemplateArgumentList) == + TPResult::True) + return TPResult::True; + if (InvalidAsTemplateArgumentList) + return TPResult::False; - case tok::greater: - case tok::greatergreater: - case tok::greatergreatergreater: - if (InvalidAsTemplateArgumentList) - return TPResult::False; - return TPResult::Ambiguous; + // FIXME: In many contexts, X can only be a + // template-argument-list. But that's not true in general: + // + // using b = int; + // void f() { + // int a = AD; // OK, declares b, not a template-id. + // + // X // ', int>' might be end of X's template argument list + // + // We might be able to disambiguate a few more cases if we're careful. - default: - return TPResult::False; - } - } + // A template-argument-list must be terminated by a '>'. + if (SkipUntil({tok::greater, tok::greatergreater, tok::greatergreatergreater}, + StopAtSemi | StopBeforeMatch)) + return TPResult::Ambiguous; + return TPResult::False; } diff --git a/clang/test/Parser/cxx-template-argument.cpp b/clang/test/Parser/cxx-template-argument.cpp index b3a9071..70945e3a 100644 --- a/clang/test/Parser/cxx-template-argument.cpp +++ b/clang/test/Parser/cxx-template-argument.cpp @@ -127,3 +127,14 @@ namespace PR18793 { template struct S {}; template int g(S *); } + +namespace r360308_regression { + template struct S1 { static int const n = 0; }; + template struct S2 { typedef int t; }; + template struct S3 { typename S2::n < 0, int>::t n; }; + + template bool f(FT p) { + const bool a = p.firstFT(0); + return a == b; + } +} diff --git a/clang/test/SemaTemplate/dependent-template-recover.cpp b/clang/test/SemaTemplate/dependent-template-recover.cpp index 90ba3cd..c7e27e8 100644 --- a/clang/test/SemaTemplate/dependent-template-recover.cpp +++ b/clang/test/SemaTemplate/dependent-template-recover.cpp @@ -7,7 +7,7 @@ struct X { t->operator+(1); // expected-error{{use 'template' keyword to treat 'operator +' as a dependent template name}} t->f1(1); // expected-error{{use 'template' keyword to treat 'f1' as a dependent template name}} - t->f1<3, int const>(1); // expected-error{{use 'template' keyword to treat 'f1' as a dependent template name}} + t->f1<3, int const>(1); // expected-error{{missing 'template' keyword prior to dependent template name 'f1'}} T::getAs(); // expected-error{{use 'template' keyword to treat 'getAs' as a dependent template name}} t->T::getAs(); // expected-error{{use 'template' keyword to treat 'getAs' as a dependent template name}} @@ -15,7 +15,7 @@ struct X { (*t).f2(); // expected-error{{missing 'template' keyword prior to dependent template name 'f2'}} (*t).f2<0>(); // expected-error{{missing 'template' keyword prior to dependent template name 'f2'}} T::f2<0>(); // expected-error{{missing 'template' keyword prior to dependent template name 'f2'}} - T::f2<0, int>(0); // expected-error{{use 'template' keyword to treat 'f2' as a dependent template name}} + T::f2<0, int>(0); // expected-error{{missing 'template' keyword prior to dependent template name 'f2'}} T::foo= 4>(); // expected-error{{missing 'template' keyword prior to dependent template name 'foo'}} @@ -83,12 +83,12 @@ template void f(T t) { T::g(0); // ... but this one must be a template-id. - T::g(0); // expected-error {{use 'template' keyword to treat 'g' as a dependent template name}} expected-error {{no matching function}} + T::g(0); // expected-error {{missing 'template' keyword prior to dependent template name 'g'}} } struct Y { template void f(int); - template static void g(int); // expected-warning 0-1{{extension}} expected-note {{candidate}} + template static void g(int); // expected-warning 0-1{{extension}} }; void q() { void (*p)(int) = Y::g; } template void f<0>(Y); // expected-note {{in instantiation of}} -- 2.7.4