[hip] Fix ambiguity from `>>>` of CUDA.

[hliao]

Summary

• For template arguments ending with >>>, we should cease lookahead and treat it as type-id firstly, so that deduction could work properly.

[tra]

LGTM, but I've added @rsmith who is way more familiar with this code.

[hliao]

In D61396#1486706, @tra wrote:

LGTM, but I've added @rsmith who is way more familiar with this code.

sure, no rush, let's wait for comments from @rsmith

[yaxunl]

LGTM too. Thanks Michael for fixing this.

[hliao]

@rsmith do you have the chance to review this simple fix?

[hliao]

ping

[hliao]

@rsmith Do you have the chance to review this patch?

[hliao]

@rsmith Do you have the chance to review this patch?

[rsmith]

clang/lib/Parse/ParseTentative.cpp

597 ↗

(On Diff #197624)

No need to check for CUDA here; that's a prerequisite for forming a greatergreatergreater token (and if we formed that token in any other language mode, we'd still want to split it here). But this should be gated by CPlusPlus11 for clarity, since that's where we get the "split >> tokens" rule from. So I think this should be:

} else if (Context == TypeIdAsTemplateArgument &&
           (Tok.isOneOf(tok::greater, tok::comma) ||
            (getLangOpts().CPlusPlus11 &&
             (Tok.isOneOf(tok::greatergreater, tok::greatergreatergreater) ||
              (Tok.is(tok::ellipsis) &&
               NextToken().isOneOf(tok::greater, tok::greatergreater,
                                   tok::greatergreatergreater, tok::comma)))))) {

[hliao]

revise following reviewer's suggestion.

[hliao]

done

[rsmith]

clang/lib/Parse/ParseTentative.cpp

597 ↗

(On Diff #198529)

A test for this case would be nice. Eg:

template<typename ...T> void bar() {
  S<S<S<T()...>>> s;
}

[hliao]

Add one unrealistic case for test purpose only.

[hliao]

done

cfe/trunk/lib/Parse/ParseTentative.cpp

if (TPR == TPResult::Ambiguous) {
 
     // We are supposed to be inside a template argument, so if after
     // the abstract declarator we encounter a '>', '>>' (in C++0x), or
     // ','; or, in C++0x, an ellipsis immediately preceding such, this
     // is a type-id. Otherwise, it's an expression.
     } else if (Context == TypeIdAsTemplateArgument &&
                (Tok.isOneOf(tok::greater, tok::comma) ||
                 (getLangOpts().CPlusPlus11 &&
-                 (Tok.is(tok::greatergreater) ||
+                 (Tok.isOneOf(tok::greatergreater,
+                              tok::greatergreatergreater) ||
                   (Tok.is(tok::ellipsis) &&
                    NextToken().isOneOf(tok::greater, tok::greatergreater,
+                                       tok::greatergreatergreater,
                                        tok::comma)))))) {
       TPR = TPResult::True;
       isAmbiguous = true;
 
     } else
       TPR = TPResult::False;
   }
 

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

 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
 
 template<typename T=int> struct S {};
 template<typename> void f();
 
+template<typename T, typename... V> struct S<T(V...)> {};
+
+template<typename ...T> struct V {};
+template<typename ...T> struct V<void(T)...> {};
 
 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<>>> s30;
 
   S<S<S<S<int>>>> s4;
   S<S<S<S<>>>> s40;
 
   S<S<S<S<S<int>>>>> s5;
   S<S<S<S<S<>>>>> s50;
 
   (void)(&f<S<S<int>>>==0);
   (void)(&f<S<S<>>>==0);
+
+  S<S<S<void()>>> s6;
+}
+
+template<typename ...T>
+void bar(T... args) {
+  S<S<V<void(T)...>>> s7;
 }