Suggest missing 'template' for dependent member templates

[nikola]

Summary

Current diagnostic says "expected expression" or "reference to non-static member function must be called". This should fix PR13566 and PR18995

[nikola]

Ping.

[nikola]

Would anyone be kind enough to review this?

[rsmith]

lib/Parse/ParseTemplate.cpp

1233–1240

This looks wrong: it will parse anything that could be a template argument list as a template argument list. In ambiguous cases, we must parse as a < operator.

test/SemaTemplate/dependent-template-recover.cpp

14–15

I think you will incorrectly treat

(*t).f2<0>(0);

... as a dependent template name. Instead, it's required to be parsed as

((*t.f2) < 0) > 0;

35

This diagnostic is incorrect.

lib/Parse/ParseTemplate.cpp

   ExprResult ExprArg = ParseConstantExpression(MaybeTypeCast);
   if (ExprArg.isInvalid() || !ExprArg.get())
     return ParsedTemplateArgument();
 
   return ParsedTemplateArgument(ParsedTemplateArgument::NonType, 
                                 ExprArg.get(), Loc);
 }
 
-/// \brief Determine whether the current tokens can only be parsed as a 
-/// template argument list (starting with the '<') and never as a '<' 
-/// expression.
+/// \brief Determine whether the current tokens (starting with the '<') can be
+/// parsed as a template argument list
 bool Parser::IsTemplateArgumentList(unsigned Skip) {
   struct AlwaysRevertAction : TentativeParsingAction {
     AlwaysRevertAction(Parser &P) : TentativeParsingAction(P) { }
     ~AlwaysRevertAction() { Revert(); }
   } Tentative(*this);
-  
   while (Skip) {
     ConsumeToken();
     --Skip;
   }
-  
   // '<'
   if (!TryConsumeToken(tok::less))
     return false;
 
   // An empty template argument list.
   if (Tok.is(tok::greater))
     return true;
-  
-  // See whether we have declaration specifiers, which indicate a type.
-  while (isCXXDeclarationSpecifier() == TPResult::True)
-    ConsumeToken();
-  
-  // If we have a '>' or a ',' then this is a template argument list.
-  return Tok.isOneOf(tok::greater, tok::comma);
+  SuppressAllDiagnostics S(Diags);
+  GreaterThanIsOperatorScope G(GreaterThanIsOperator, false);
+  TemplateArgList TemplateArgs;
+  if (ParseTemplateArgumentList(TemplateArgs))
+    return false;
+
+  // Closing '>'
+  return Tok.is(tok::greater);
 }
 
 /// ParseTemplateArgumentList - Parse a C++ template-argument-list
 /// (C++ [temp.names]). Returns true if there was an error.
 ///
 ///       template-argument-list: [C++ 14.2]
 ///         template-argument
 ///         template-argument-list ',' template-argument

lib/Parse/RAIIObjectsForParser.h

         return false;
       }
       
       return diagnoseMissingClose();
     }
     void skipToEnd();
   };
 
+  /// \brief RAII object that suppresses all diagnostics
+  class SuppressAllDiagnostics {
+    DiagnosticsEngine &Diags;
+    bool OldVal;
+  public:
+    SuppressAllDiagnostics(DiagnosticsEngine &Diags) : Diags(Diags) {
+      OldVal = Diags.getSuppressAllDiagnostics();
+      Diags.setSuppressAllDiagnostics(true);
+    }
+    ~SuppressAllDiagnostics() { Diags.setSuppressAllDiagnostics(OldVal); }
+  };
+
 } // end namespace clang
 
 #endif

test/SemaTemplate/dependent-template-recover.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 template<typename T, typename U, int N>
 struct X {
   void f(T* t) {
     t->f0<U>(); // expected-error{{use 'template' keyword to treat 'f0' as a dependent template name}}
     t->f0<int>(); // expected-error{{use 'template' keyword to treat 'f0' as a dependent template name}}
 
     t->operator+<U const, 1>(); // expected-error{{use 'template' keyword to treat 'operator +' as a dependent template name}}
     t->f1<int const, 2>(); // expected-error{{use 'template' keyword to treat 'f1' as a dependent template name}}
 
     T::getAs<U>(); // expected-error{{use 'template' keyword to treat 'getAs' as a dependent template name}}
     t->T::getAs<U>(); // expected-error{{use 'template' keyword to treat 'getAs' as a dependent template name}}
 
-    // FIXME: We can't recover from these yet
-    (*t).f2<N>(); // expected-error{{expected expression}}
-    (*t).f2<0>(); // expected-error{{expected expression}}
+    (*t).f2<N>(); // expected-error{{use 'template' keyword to treat 'f2' as a dependent template name}}
+    (*t).f2<0>(); // expected-error{{use 'template' keyword to treat 'f2' as a dependent template name}}
   }
 };
 
+namespace PR13566 {
+template <typename T>
+struct S
+{
+  template <int N>
+  void foo();
+
+  template <int N>
+  void foo(int);
+};
+
+template <typename T>
+void bar()
+{
+  S<T> s;
+  s.foo<1>(); // expected-error{{use 'template' keyword to treat 'foo' as a dependent template name}}
+  s.foo<1>(0); // expected-error{{use 'template' keyword to treat 'foo' as a dependent template name}}
+}
+
+void instantiate() {
+  bar<int>();
+}
+}
+
 namespace PR9401 {
   // From GCC PR c++/45558
   template <typename S, typename T>
   struct C
   {
     template <typename U>
     struct B
     {