[analyzer] Added template argument lists to the Pathdiagnostic output

[Szelethus]

Summary

Currently, template parameters are not displayed in the plist output. While developing D45532, I found this very frustrating, because it was difficult to decide whether a constructor works correctly without seeing the exact template parameters.

[george.karpenkov]

LGTM provided that nits inline are fixed

lib/StaticAnalyzer/Core/PathDiagnostic.cpp

1011

Calling ->getASTContext()->getLangOpts() on CXXLangDecl will get you the real thing.

1016

no need for a line break after the closing brace here

[Szelethus]

Thanks for the review!

lib/StaticAnalyzer/Core/PathDiagnostic.cpp

1011

I looked up CXXLangDecl, but apparently its not a thing. I tried looking in PathDiagnostic.h, and some related files, but I couldn't get that "real" LangOptions anywhere :(

What I could do however, is add a LangOptions field to PathDiagnostic, but I'd rather be sure that I didn't misunderstand you.

What drove me to this solution is that TemplateArgument::dump's implementation does the same, though it is accompanied with a FIXME.

[george.karpenkov]

lib/StaticAnalyzer/Core/PathDiagnostic.cpp

1011

Sorry, I've meant CXXRecordDecl. Replied below.

1042

D->getASTContext().getLangOpts() will get you language option.
BTW clangd autocompletion is very useful for API discovery.

[Szelethus]

Fixes according to inline comments.

[Szelethus]

D->getASTContext().getLangOpts() will get you language option.

Oh, yea, right. Woops. Thanks for pointing me in right direction :) Clangd looks great, I'll definitely give it a try.

If you like the patch as it is now, can you commit it for me please? I have no write access.

[george.karpenkov]

@Szelethus I can, but since you've had quite a few patches accepted, do you want to just apply for a commit access ? https://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access

[Szelethus]

Cleaned up a testfile.

lib/StaticAnalyzer/Core/PathDiagnostic.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/OperationKinds.h"
 #include "clang/AST/ParentMap.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/Type.h"
 #include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
void PathDiagnosticCallPiece::setCallee(const CallEnter &CE,
   // Unless set here, the IsCalleeAnAutosynthesizedPropertyAccessor flag
   // defaults to false.
   if (const auto *MD = dyn_cast<ObjCMethodDecl>(Callee))
     IsCalleeAnAutosynthesizedPropertyAccessor = (
         MD->isPropertyAccessor() &&
         CalleeCtx->getAnalysisDeclContext()->isBodyAutosynthesized());
 }
 
+static void describeTemplateParameters(raw_ostream &Out,
+                                       const ArrayRef<TemplateArgument> TAList,
+                                       const LangOptions &LO,
+                                       StringRef Prefix = StringRef(),
+                                       StringRef Postfix = StringRef());
+
+static void describeTemplateParameter(raw_ostream &Out,
+                                      const TemplateArgument &TArg,
+                                      const LangOptions &LO) {
+
+  if (TArg.getKind() == TemplateArgument::ArgKind::Pack) {
+    describeTemplateParameters(Out, TArg.getPackAsArray(), LO);
+  } else {
+    TArg.print(PrintingPolicy(LO), Out);
+  }
+}
+
+static void describeTemplateParameters(raw_ostream &Out,
+                                       const ArrayRef<TemplateArgument> TAList,
+                                       const LangOptions &LO,
+                                       StringRef Prefix, StringRef Postfix) {
+  if (TAList.empty())
+    return;
+
+  Out << Prefix;
+  for (int I = 0, Last = TAList.size() - 1; I != Last; ++I) {
+    describeTemplateParameter(Out, TAList[I], LO);
+    Out << ", ";
+  }
+  describeTemplateParameter(Out, TAList[TAList.size() - 1], LO);
+  Out << Postfix;
+}
+
 static void describeClass(raw_ostream &Out, const CXXRecordDecl *D,
                           StringRef Prefix = StringRef()) {
   if (!D->getIdentifier())
     return;
-  Out << Prefix << '\'' << *D << '\'';
+  Out << Prefix << '\'' << *D;
+  if (const auto T = dyn_cast<ClassTemplateSpecializationDecl>(D))
+    describeTemplateParameters(Out, T->getTemplateArgs().asArray(),
+                               D->getASTContext().getLangOpts(), "<", ">");
+
+  Out << '\'';
 }
 
 static bool describeCodeDecl(raw_ostream &Out, const Decl *D,
                              bool ExtendedDescription,
                              StringRef Prefix = StringRef()) {
   if (!D)
     return false;
 
if (const auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
         Out << "'" << *MD->getParent() << "::" << *MD << "'";
       else
         Out << "'" << *MD << "'";
     }
 
     return true;
   }
 
-  Out << Prefix << '\'' << cast<NamedDecl>(*D) << '\'';
+  Out << Prefix << '\'' << cast<NamedDecl>(*D);
+
+  // Adding template parameters.
+  if (const auto FD = dyn_cast<FunctionDecl>(D))
+    if (const TemplateArgumentList *TAList =
+                                    FD->getTemplateSpecializationArgs())
+      describeTemplateParameters(Out, TAList->asArray(),
+                                 FD->getASTContext().getLangOpts(), "<", ">");
+
+  Out << '\'';
   return true;
 }
 
 std::shared_ptr<PathDiagnosticEventPiece>
 PathDiagnosticCallPiece::getCallEnterEvent() const {
   // We do not produce call enters and call exits for autosynthesized property
   // accessors. We do generally produce them for other functions coming from
   // the body farm because they may call callbacks that bring us back into

test/Analysis/plist-diagnostics-template-function.cpp

+// RUN: %clang_analyze_cc1 -analyzer-output=plist -o %t.plist -std=c++11 -analyzer-checker=core %s
+// RUN: FileCheck --input-file=%t.plist %s
+
+bool ret();
+
+template <class T>
+void f(int i) {
+  if (ret())
+    i = i / (i - 5);
+}
+
+template <>
+void f<int>(int i) {
+  if (ret())
+    i = i / (i - 5);
+}
+
+template <int N = 0>
+void defaultTemplateParameterFunction(int i) {
+  if (ret())
+    int a = 10 / i;
+}
+
+template <typename... Args>
+void variadicTemplateFunction(int i) {
+  if (ret())
+    int a = 10 / i;
+}
+
+int main() {
+  f<int>(5);
+  f<float>(5);
+  defaultTemplateParameterFunction<>(0);
+  variadicTemplateFunction<char, float, double, int *>(0);
+}
+
+// CHECK:      <string>Calling &apos;f&lt;float&gt;&apos;</string>
+// CHECK:      <string>Calling &apos;f&lt;int&gt;&apos;</string>
+// CHECK:      <string>Calling &apos;defaultTemplateParameterFunction&lt;0&gt;&apos;</string>
+// CHECK:      <string>Calling &apos;variadicTemplateFunction&lt;char, float, double, int *&gt;&apos;</string>
+

test/Analysis/plist-diagnostics-template-record.cpp

+// RUN: %clang_analyze_cc1 -analyzer-output=plist -o %t.plist -std=c++11 -analyzer-checker=core %s
+// RUN: FileCheck --input-file=%t.plist %s
+
+bool ret();
+
+template <class A, class B, class C, int N>
+struct DivByZero {
+  int i;
+  DivByZero(bool b) {
+    if (ret())
+      i = 50 / (b - 1);
+  }
+};
+
+template <class B, class C, int N>
+struct DivByZero<char, B, C, N> {
+  int i;
+  DivByZero(bool b) {
+    if (ret())
+      i = 50 / (b - 1);
+  }
+};
+
+template <typename... Args>
+struct DivByZeroVariadic {
+  int i;
+  DivByZeroVariadic(bool b) {
+    if (ret())
+      i = 50 / (b - 1);
+  }
+};
+
+int main() {
+  DivByZero<int, float, double, 0> a(1);
+  DivByZero<char, float, double, 0> a2(1);
+  DivByZeroVariadic<char, float, double, decltype(nullptr)> a3(1);
+}
+
+// CHECK:      <string>Calling constructor for &apos;DivByZero&lt;int, float, double, 0&gt;&apos;</string>
+// CHECK:      <string>Calling constructor for &apos;DivByZero&lt;char, float, double, 0&gt;&apos;</string>
+// CHECK:      <string>Calling constructor for &apos;DivByZeroVariadic&lt;char, float, double, nullptr_t&gt;&apos;</string>
+