[clang] Provide better fix-it on exception spec error

[jdemeule]

Summary

Clang will report an error when the exception specification is not respected with a fix-it.
However, this fix-it does not fully qualify the type in case of function template specialization which lead to "incomplete" transformation (resulting code does not compile).
This patch attempts to create a more realiable in the first place by reusing the pretty printer helper defined in SemaTemplate which expand template arguments.

[jdemeule]

Kindly ping reviewer.

[jdemeule]

Kindly ping reviewer.

[jdemeule]

Kindly ping reviewer.

clang/include/clang/AST/PrettyPrinter.h

struct PrintingPolicy {
 
   /// Whether to print types as written or canonically.
   unsigned PrintCanonicalTypes : 1;
 
   /// When RemapFilePaths is true, this function performs the action.
   std::function<std::string(StringRef)> remapPath;
 };
 
+/// A PrinterHelper that prints more helpful diagnostics for some
+/// sub-expressions within failing boolean expression, such as substituting
+/// template parameters for actual types.
+class ExpandTemplateArgumentsPrinterHelper : public PrinterHelper {
+public:
+  explicit ExpandTemplateArgumentsPrinterHelper(const PrintingPolicy &P)
+      : Policy(P) {}
+
+  bool handledStmt(Stmt *E, raw_ostream &OS) override;
+
+private:
+  const PrintingPolicy Policy;
+};
+
 } // end namespace clang
 
 #endif

clang/lib/AST/StmtPrinter.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // PrinterHelper
 //===----------------------------------------------------------------------===//
 
 // Implement virtual destructor.
 PrinterHelper::~PrinterHelper() = default;
+
+//===----------------------------------------------------------------------===//
+// ExpandTemplateArgumentsPrinterHelper
+//===----------------------------------------------------------------------===//
+
+bool ExpandTemplateArgumentsPrinterHelper::handledStmt(Stmt *E,
+                                                       raw_ostream &OS) {
+  const auto *DR = dyn_cast<DeclRefExpr>(E);
+  if (DR && DR->getQualifier()) {
+    // If this is a qualified name, expand the template arguments in nested
+    // qualifiers.
+    DR->getQualifier()->print(OS, Policy, true);
+    // Then print the decl itself.
+    const ValueDecl *VD = DR->getDecl();
+    OS << VD->getName();
+    if (const auto *IV = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
+      // This is a template variable, print the expanded template arguments.
+      printTemplateArgumentList(OS, IV->getTemplateArgs().asArray(), Policy);
+    }
+    return true;
+  }
+  return false;
+}
 No newline at end of file

clang/lib/Sema/SemaExceptionSpec.cpp

case EST_BasicNoexcept:
     OS << "noexcept";
     break;
 
   case EST_DependentNoexcept:
   case EST_NoexceptFalse:
   case EST_NoexceptTrue:
     OS << "noexcept(";
     assert(OldProto->getNoexceptExpr() != nullptr && "Expected non-null Expr");
-    OldProto->getNoexceptExpr()->printPretty(OS, nullptr, getPrintingPolicy());
+    {
+      PrintingPolicy Policy = getPrintingPolicy();
+      ExpandTemplateArgumentsPrinterHelper Helper(Policy);
+      OldProto->getNoexceptExpr()->printPretty(OS, &Helper, Policy);
+    }
     OS << ")";
     break;
   case EST_NoThrow:
     OS <<"__attribute__((nothrow))";
     break;
   case EST_None:
   case EST_MSAny:
   case EST_Unevaluated:

clang/lib/Sema/SemaTemplate.cpp

static Expr *lookThroughRangesV3Condition(Preprocessor &PP, Expr *Cond) {
 
   StringRef MacroName = PP.getImmediateMacroName(Loc);
   if (MacroName == "CONCEPT_REQUIRES" || MacroName == "CONCEPT_REQUIRES_")
     return BinOp->getRHS();
 
   return Cond;
 }
 
-namespace {
-
-// A PrinterHelper that prints more helpful diagnostics for some sub-expressions
-// within failing boolean expression, such as substituting template parameters
-// for actual types.
-class FailedBooleanConditionPrinterHelper : public PrinterHelper {
-public:
-  explicit FailedBooleanConditionPrinterHelper(const PrintingPolicy &P)
-      : Policy(P) {}
-
-  bool handledStmt(Stmt *E, raw_ostream &OS) override {
-    const auto *DR = dyn_cast<DeclRefExpr>(E);
-    if (DR && DR->getQualifier()) {
-      // If this is a qualified name, expand the template arguments in nested
-      // qualifiers.
-      DR->getQualifier()->print(OS, Policy, true);
-      // Then print the decl itself.
-      const ValueDecl *VD = DR->getDecl();
-      OS << VD->getName();
-      if (const auto *IV = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
-        // This is a template variable, print the expanded template arguments.
-        printTemplateArgumentList(OS, IV->getTemplateArgs().asArray(), Policy);
-      }
-      return true;
-    }
-    return false;
-  }
-
-private:
-  const PrintingPolicy Policy;
-};
-
-} // end anonymous namespace
-
 std::pair<Expr *, std::string>
 Sema::findFailedBooleanCondition(Expr *Cond) {
   Cond = lookThroughRangesV3Condition(PP, Cond);
 
   // Separate out all of the terms in a conjunction.
   SmallVector<Expr *, 4> Terms;
   collectConjunctionTerms(Cond, Terms);
 
Sema::findFailedBooleanCondition(Expr *Cond) {
   if (!FailedCond)
     FailedCond = Cond->IgnoreParenImpCasts();
 
   std::string Description;
   {
     llvm::raw_string_ostream Out(Description);
     PrintingPolicy Policy = getPrintingPolicy();
     Policy.PrintCanonicalTypes = true;
-    FailedBooleanConditionPrinterHelper Helper(Policy);
+    ExpandTemplateArgumentsPrinterHelper Helper(Policy);
     FailedCond->printPretty(Out, &Helper, Policy, 0, "\n", nullptr);
   }
   return { FailedCond, Description };
 }
 
 QualType Sema::CheckTemplateIdType(TemplateName Name,
                                    SourceLocation TemplateLoc,
                                    TemplateArgumentListInfo &TemplateArgs) {

clang/test/SemaCXX/exception-spec.cpp

struct B {
     virtual D1 &operator=(const D1&) noexcept; // expected-note {{overridden}}
     virtual D2 &operator=(const D2&) noexcept; // expected-note {{overridden}}
   };
   struct D1 : B {}; // expected-error {{more lax}}
   struct D2 : B {
     D2 &operator=(const D2&); // expected-error {{more lax}}
   };
 }
+
+namespace MissingOnTemplate {
+  template<class T>
+  struct type_dependant_noexcept {
+    static constexpr const bool value = (sizeof(T) < 4);
+  };
+
+  template<typename T> void a_fct(T) noexcept(type_dependant_noexcept<T>::value);  // expected-note {{previous}}
+  template<typename T> void a_fct(T);  // expected-error {{missing exception specification 'noexcept(type_dependant_noexcept<T>::value)'}}
+}
+
+namespace abc {
+  struct A {};
+}  // namespace abc
+
+namespace MissingOnTemplate {
+  template<>void a_fct<abc::A>(abc::A);  // expected-error {{missing exception specification 'noexcept(type_dependant_noexcept<abc::A>::value)'}} expected-note {{previous}}
+}
 No newline at end of file