Fix PR20081: Properly parse >>> template endings when in CUDA mode and C++11

[eliben]

Summary

The template parsing code has special provision for encountering the '>>' token at the end of a template list for C++11. When the language is CUDA, '>>>' is lexed as a single token (tok::greatergreatergreater), and this should also be taken into account. The code in the template parser is already almost correct for handling this case. However, due to r209824 which masked CUDA in C++11 mode, we uncover a bug wherein the parsing actually fails for '-x cuda -std=c++11'.

See PR20081 for more details.

[eliben]

Updated the patch with somewhat more rigorous tests

[rsmith]

LGTM

lib/Parse/ParseTemplate.cpp

bool Parser::ParseGreaterThanInTemplateList(SourceLocation &RAngleLoc,
 
   case tok::greatergreaterequal:
     RemainingToken = tok::greaterequal;
     break;
   }
 
   // This template-id is terminated by a token which starts with a '>'. Outside
   // C++11, this is now error recovery, and in C++11, this is error recovery if
-  // the token isn't '>>'.
+  // the token isn't '>>' or '>>>'.
+  // '>>>' is for CUDA, where this sequence of characters is parsed into
+  // tok::greatergreatergreater, rather than two separate tokens.
 
   RAngleLoc = Tok.getLocation();
 
   // The source range of the '>>' or '>=' at the start of the token.
   CharSourceRange ReplacementRange =
       CharSourceRange::getCharRange(RAngleLoc,
           Lexer::AdvanceToTokenCharacter(RAngleLoc, 2, PP.getSourceManager(),
                                          getLangOpts()));
if ((RemainingToken == tok::greater ||
       (Next.is(tok::greater) || Next.is(tok::greatergreater) ||
        Next.is(tok::greatergreatergreater) || Next.is(tok::equal) ||
        Next.is(tok::greaterequal) || Next.is(tok::greatergreaterequal) ||
        Next.is(tok::equalequal)) &&
       areTokensAdjacent(Tok, Next))
     Hint2 = FixItHint::CreateInsertion(Next.getLocation(), " ");
 
   unsigned DiagId = diag::err_two_right_angle_brackets_need_space;
-  if (getLangOpts().CPlusPlus11 && Tok.is(tok::greatergreater))
+  if (getLangOpts().CPlusPlus11 &&
+      (Tok.is(tok::greatergreater) || Tok.is(tok::greatergreatergreater)))
     DiagId = diag::warn_cxx98_compat_two_right_angle_brackets;
   else if (Tok.is(tok::greaterequal))
     DiagId = diag::err_right_angle_bracket_equal_needs_space;
   Diag(Tok.getLocation(), DiagId) << Hint1 << Hint2;
 
   // Strip the initial '>' from the token.
   if (RemainingToken == tok::equal && Next.is(tok::equal) &&
       areTokensAdjacent(Tok, Next)) {

test/Parser/cuda-kernel-call-c++11.cu

+// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
+
+template<typename> struct S {};
+template<typename> void f();
+
+
+void foo(void) {
+  // In C++11 mode, all of these are expected to parse correctly, and the CUDA
+  // language should not interfere with that.
+
+  // expected-no-diagnostics
+
+  S<S<S<int>>> s3;
+
+  S<S<S<S<int>>>> s4;
+
+  S<S<S<S<S<int>>>>> s5;
+
+  (void)(&f<S<S<int>>>==0);
+}

test/Parser/cuda-kernel-call.cu

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 template<typename> struct S {};
 template<typename> void f();
 
 void foo(void) {
   foo<<<1;      // expected-error {{expected '>>>'}} expected-note {{to match this '<<<'}}
 
   foo<<<1,1>>>; // expected-error {{expected '('}}
 
   foo<<<>>>();  // expected-error {{expected expression}}
 
-  S<S<S<int>>> s; // expected-error 2{{use '> >'}}
+  // The following two are parse errors because -std=c++11 is not enabled.
 
+  S<S<S<int>>> s; // expected-error 2{{use '> >'}}
   (void)(&f<S<S<int>>>==0); // expected-error 2{{use '> >'}}
 }