[Sema] Simplfy static_assert diagnostic code.

[courbet]

Summary

We can now remove the specific handling of NestedNameQualifiers as
it's now handled by the type printer as of r349729.

[aaron.ballman]

test/SemaCXX/static-assert.cpp

130

Any idea why the std:: was dropped here?

[courbet]

test/SemaCXX/static-assert.cpp

130

NestedNameSpecifier::print() explicitly does:

PrintingPolicy InnerPolicy(Policy);
InnerPolicy.SuppressScope = true;

[aaron.ballman]

test/SemaCXX/static-assert.cpp

130

Ah, good point, but is that a good behavioral change? I slightly prefer printing the namespace name there -- it will likely be redundant information most of the time, but when the namespace actually matters, having it printed could save someone a lot of head scratching.

[courbet]

test/SemaCXX/static-assert.cpp

130

I slightly prefer printing the namespace name there

I tend to agree, so it's more a trade-off of code complexity vs better diagnostic - I tend to err on the side of simplifying the code :)

Another option is to add yet another boolean to PrintingPolicy, but I htink this is too narrow a use case.

[aaron.ballman]

test/SemaCXX/static-assert.cpp

130

Heh, I tend to err on the side of helping the user unless the code will be truly awful. I agree that another option on PrintingPolicy may not be the best approach. Do you know why the namespace is being suppressed in the first place? Another option would be to always print the namespace, but I don't know what that might regress (if anything).

[courbet]

test/SemaCXX/static-assert.cpp

130

Unfortunately always printing the qualification breaks 30 tests, including some in a very bad way:

/usr/local/google/home/courbet/llvm/llvm/tools/clang/test/AST/ast-print-out-of-line-func.cpp:29:11: error: CHECK: expected string not found in input
// CHECK: void Wrapper::Inner::operator+=(int)
          ^
<stdin>:14:43: note: scanning from here
 ns::Wrapper::ns::Wrapper::Inner::Inner() {
                                          ^
<stdin>:16:19: note: possible intended match here
 void ns::Wrapper::ns::Wrapper::Inner::operator+=(int) {

[aaron.ballman]

test/SemaCXX/static-assert.cpp

130

That looks like a bug with the printer, no?

As it stands, I think this is a regression with the diagnostic printing. I think it would be reasonable if the namespace were dropped only when the namespace reduces clarity (e.g., there are no other conflicting names in other namespaces, so the namespace is superfluous), but I don't think that's what's happening here.

include/clang/AST/NestedNameSpecifier.h

public:
   /// Whether this nested name specifier involves a template
   /// parameter.
   bool isInstantiationDependent() const;
 
   /// Whether this nested-name-specifier contains an unexpanded
   /// parameter pack (for C++11 variadic templates).
   bool containsUnexpandedParameterPack() const;
 
-  /// Print this nested name specifier to the given output stream. If
-  /// `ResolveTemplateArguments` is true, we'll print actual types, e.g.
-  /// `ns::SomeTemplate<int, MyClass>` instead of
-  /// `ns::SomeTemplate<Container::value_type, T>`.
-  void print(raw_ostream &OS, const PrintingPolicy &Policy,
-             bool ResolveTemplateArguments = false) const;
+  /// Print this nested name specifier to the given output stream.
+  void print(raw_ostream &OS, const PrintingPolicy &Policy) const;
 
   void Profile(llvm::FoldingSetNodeID &ID) const {
     ID.AddPointer(Prefix.getOpaqueValue());
     ID.AddPointer(Specifier);
   }
 
   /// Dump the nested name specifier to standard output to aid
   /// in debugging.

lib/AST/NestedNameSpecifier.cpp

case TypeSpecWithTemplate:
     return getAsType()->containsUnexpandedParameterPack();
   }
 
   llvm_unreachable("Invalid NNS Kind!");
 }
 
 /// Print this nested name specifier to the given output
 /// stream.
-void NestedNameSpecifier::print(raw_ostream &OS, const PrintingPolicy &Policy,
-                                bool ResolveTemplateArguments) const {
+void NestedNameSpecifier::print(raw_ostream &OS, const PrintingPolicy &Policy) const {
   if (getPrefix())
     getPrefix()->print(OS, Policy);
 
   switch (getKind()) {
   case Identifier:
     OS << getAsIdentifier()->getName();
     break;
 
case Super:
     break;
 
   case TypeSpecWithTemplate:
     OS << "template ";
     // Fall through to print the type.
     LLVM_FALLTHROUGH;
 
   case TypeSpec: {
-    const auto *Record =
-            dyn_cast_or_null<ClassTemplateSpecializationDecl>(getAsRecordDecl());
-    if (ResolveTemplateArguments && Record) {
-        // Print the type trait with resolved template parameters.
-        Record->printName(OS);
-        printTemplateArgumentList(OS, Record->getTemplateArgs().asArray(),
-                                  Policy);
-        break;
-    }
     const Type *T = getAsType();
 
     PrintingPolicy InnerPolicy(Policy);
     InnerPolicy.SuppressScope = true;
 
     // Nested-name-specifiers are intended to contain minimally-qualified
     // types. An actual ElaboratedType will not occur, since we'll store
     // just the type that is referred to in the nested-name-specifier (e.g.,

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);
-    FailedCond->printPretty(Out, &Helper, Policy, 0, "\n", nullptr);
+    FailedCond->printPretty(Out, nullptr, Policy, 0, "\n", nullptr);
   }
   return { FailedCond, Description };
 }
 
 QualType Sema::CheckTemplateIdType(TemplateName Name,
                                    SourceLocation TemplateLoc,
                                    TemplateArgumentListInfo &TemplateArgs) {
   DependentTemplateName *DTN

test/SemaCXX/static-assert.cpp

 // expected-error@-1{{static_assert failed due to requirement 'std::is_const<const int>::value == false' "message"}}
 static_assert(!(std::is_const<const ExampleTypes::T>::value == true), "message");
 // expected-error@-1{{static_assert failed due to requirement '!(std::is_const<const int>::value == true)' "message"}}
 static_assert(std::is_const<ExampleTypes::T>(), "message");
 // expected-error@-1{{static_assert failed due to requirement 'std::is_const<int>()' "message"}}
 static_assert(!(std::is_const<const ExampleTypes::T>()()), "message");
 // expected-error@-1{{static_assert failed due to requirement '!(std::is_const<const int>()())' "message"}}
 static_assert(std::is_same<decltype(std::is_const<const ExampleTypes::T>()), int>::value, "message");
-// expected-error@-1{{static_assert failed due to requirement 'std::is_same<std::is_const<const int>, int>::value' "message"}}
+// expected-error@-1{{static_assert failed due to requirement 'std::is_same<is_const<const int>, int>::value' "message"}}
 static_assert(std::is_const<decltype(ExampleTypes::T(3))>::value, "message");
 // expected-error@-1{{static_assert failed due to requirement 'std::is_const<int>::value' "message"}}
 static_assert(std::is_const<decltype(ExampleTypes::T())>::value, "message");
 // expected-error@-1{{static_assert failed due to requirement 'std::is_const<int>::value' "message"}}
 static_assert(std::is_const<decltype(ExampleTypes(3))>::value, "message");
 // expected-error@-1{{static_assert failed due to requirement 'std::is_const<ExampleTypes>::value' "message"}}
 
 struct BI_tag {};