[Sema] Better static assert diagnostics for expressions involving temporaries.

[courbet]

Summary

Handles expressions such as:

• std::is_const<T>()
• std::is_const<T>()();
• std::is_same(decltype(U()), V>::value;

[courbet]

cosmetics

[• Quuxplusone]

lib/Sema/SemaTemplate.cpp

3087

It might be more maintainer-proof to write this as

std::pair<const char *, const char *> Braces;
if (Node->isStdInitListInitialization())
  Braces = std::make_pair("", "");
else if (Node->isListInitialization())
  Braces = std::make_pair("{", "}");
else
  Braces = std::make_pair("(", ")");
OS << Braces.first;
for (...) { ... }
OS << Braces.second;
return true;

test/SemaCXX/static-assert.cpp

136

Conspicuously missing any test for lines 3081–3106 above. IIUC, those lines would trigger on things like

template<class T> struct X { int i=0, j=0; constexpr operator bool() const { return false; } };
template<class T> void test() {
    static_assert(X<T>{});
    static_assert(X<T>{1,2});
    static_assert(T{0});
    static_assert(T(0));
}
template void test<int>();

But I guess I don't see why extra code is needed to handle those; shouldn't the pretty-printer handle them already? What do the current diagnostics look like for my example?

[courbet]

test/SemaCXX/static-assert.cpp

136

Note: Your examples are CXXFunctionalCastExpr, and CXXUnresolvedConstructExpr respectively, not CXXTemporaryObjectExpr, so they are not handled by this change.

They are correctly printed before this change with T==int.

The issue comes when adding an extra layer of indirection:

struct ExampleTypes {
  explicit ExampleTypes(int);
  using T = int;
  using U = float;
};

template<class T> struct X {
  int i=0;
  int j=0;
  constexpr operator bool() const { return false; }
};

template<class T> void foo6() {
    static_assert(X<typename T::T>());
    static_assert(X<typename T::T>{});
    static_assert(X<typename T::T>{1,2});
    static_assert(X<typename T::T>({1,2}));
    static_assert(typename T::T{0});
    static_assert(typename T::T(0));
}
template void foo6<ExampleTypes>();

The errors before the change are:

File /usr/local/google/home/courbet/llvm/llvm/tools/clang/test/SemaCXX/static-assert-cxx17.cpp Line 71: static_assert failed due to requirement 'X<typename ExampleTypes::T>()'
  File /usr/local/google/home/courbet/llvm/llvm/tools/clang/test/SemaCXX/static-assert-cxx17.cpp Line 72: static_assert failed due to requirement 'X<typename ExampleTypes::T>{}'
  File /usr/local/google/home/courbet/llvm/llvm/tools/clang/test/SemaCXX/static-assert-cxx17.cpp Line 73: static_assert failed due to requirement 'X<typename ExampleTypes::T>{1, 2}'
  File /usr/local/google/home/courbet/llvm/llvm/tools/clang/test/SemaCXX/static-assert-cxx17.cpp Line 74: static_assert failed due to requirement 'X<typename ExampleTypes::T>({1, 2})'
  File /usr/local/google/home/courbet/llvm/llvm/tools/clang/test/SemaCXX/static-assert-cxx17.cpp Line 75: static_assert failed due to requirement 'typename ExampleTypes::T{0}'
  File /usr/local/google/home/courbet/llvm/llvm/tools/clang/test/SemaCXX/static-assert-cxx17.cpp Line 76: static_assert failed due to requirement 'typename ExampleTypes::T(0)'

I must admit that I did not think of handling these, and now I think it would actually be better to tap into the pretty printer to avoid code duplication.

[courbet]

Handle remaining static_assert categories inside the prettyprinter.

[courbet]

clang-format patch

[courbet]

revert now unneeded changes.

[aaron.ballman]

include/clang/AST/Stmt.h

847

I'm pretty wary of long lists of parameters that include booleans with default values. Why is PrintCanonicalTypes not part of the printing policy? I think that's where we should keep all the knobs relating to how the printing happens.

[courbet]

move PrintQualifiedTypes to PrintingPolicy

include/clang/AST/Stmt.h

847

Good point, done.

[aaron.ballman]

lib/AST/StmtPrinter.cpp

78–80

Spurious formatting changes -- can revert this file.

lib/AST/TypePrinter.cpp

165 ↗

(On Diff #178882)

t doesn't meet the usual naming requirements; how about QT?

lib/Sema/SemaTemplate.cpp

3062

Why are you dropping the explicit here?

3125–3126

Don't use auto here, please.

[courbet]

lib/AST/TypePrinter.cpp

165 ↗

(On Diff #178882)

I was keeping it for consistency with TypePrinter::print(QualType t,, but done.

lib/Sema/SemaTemplate.cpp

3062

Sorry, this is a revert of an approach where it had two parameters.

[courbet]

address review comments

[courbet]

clang-format diff

[aaron.ballman]

LGTM, but you should wait a few days before committing in case @Quuxplusone has comments.

[• Quuxplusone]

LGTM. Tiny style suggestions, which I won't mind if you ignore.

include/clang/AST/Type.h

995 ↗

(On Diff #178888)

Nit: could this function have been left in-line, and just changed split() to splitAccordingToPolicy(this, Policy)?
Even simpler, could splitAccordingToPolicy be made a member function of QualType, so that most of these diffs could be simply s/split()/splitAccordingToPolicy(Policy)/ without introducing any new temporary variables or anything? I.e.

void getAsStringInternal(std::string &Str,
                          const PrintingPolicy &Policy) const {
    return getAsStringInternal(splitAccordingToPolicy(Policy), Str, Policy);
}

But if that would make the code harder to read instead of easier, then don't mind me.

998 ↗

(On Diff #178888)

Nit: this function's body hasn't changed, so personally I would have left it alone (not out-of-lined it).

[courbet]

address review comments

[courbet]

Thanks for the comments !

include/clang/AST/Type.h

995 ↗

(On Diff #178888)

I'd rather avoid polluting the QualType API with splitAccordingToPolicy() which is really only useful for this use case.

without introducing any new temporary variables or anything? i.e.

Actually this is independent of the above change, done.

include/clang/AST/Stmt.h

public:
   void dumpColor() const;
 
   /// dumpPretty/printPretty - These two methods do a "pretty print" of the AST
   /// back to its original source language syntax.
   void dumpPretty(const ASTContext &Context) const;
   void printPretty(raw_ostream &OS, PrinterHelper *Helper,
                    const PrintingPolicy &Policy, unsigned Indentation = 0,
                    StringRef NewlineSymbol = "\n",
-                   const ASTContext *Context = nullptr) const;
+                   const ASTContext *Context = nullptr,
+                   bool PrintCanonicalTypes = false) const;
 
   /// viewAST - Visualize an AST rooted at this Stmt* using GraphViz.  Only
   ///   works on systems with GraphViz (Mac OS X) or dot+gv installed.
   void viewAST() const;
 
   /// Skip past any implicit AST nodes which might surround this
   /// statement, such as ExprWithCleanups or ImplicitCastExpr nodes.
   Stmt *IgnoreImplicit();

lib/AST/StmtPrinter.cpp

namespace {
 
   class StmtPrinter : public StmtVisitor<StmtPrinter> {
     raw_ostream &OS;
     unsigned IndentLevel;
     PrinterHelper* Helper;
     PrintingPolicy Policy;
     std::string NL;
     const ASTContext *Context;
+    const bool PrintCanonicalTypes;
 
   public:
     StmtPrinter(raw_ostream &os, PrinterHelper *helper,
-                const PrintingPolicy &Policy, unsigned Indentation = 0,
-                StringRef NL = "\n",
-                const ASTContext *Context = nullptr)
+                const PrintingPolicy &Policy, unsigned Indentation,
+                StringRef NL, const ASTContext *Context,
+                bool PrintCanonicalTypes)
         : OS(os), IndentLevel(Indentation), Helper(helper), Policy(Policy),
-          NL(NL), Context(Context) {}
+          NL(NL), Context(Context), PrintCanonicalTypes(PrintCanonicalTypes) {}
 
     void PrintStmt(Stmt *S) {
       PrintStmt(S, Policy.Indentation);
     }
 
     void PrintStmt(Stmt *S, int SubIndent) {
       IndentLevel += SubIndent;
       if (S && isa<Expr>(S)) {
public:
     }
 
     void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node);
 
 #define ABSTRACT_STMT(CLASS)
 #define STMT(CLASS, PARENT) \
     void Visit##CLASS(CLASS *Node);
 #include "clang/AST/StmtNodes.inc"
+
+  private:
+    void PrintType(const QualType &T) const {
+      if (PrintCanonicalTypes)
+        T.getCanonicalType().print(OS, Policy);
+      else
+        T.print(OS, Policy);
+    }
   };
 
 } // namespace
 
 //===----------------------------------------------------------------------===//
 //  Stmt printing methods.
 //===----------------------------------------------------------------------===//
 
void StmtPrinter::VisitUnaryOperator(UnaryOperator *Node) {
   PrintExpr(Node->getSubExpr());
 
   if (Node->isPostfix())
     OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
 }
 
 void StmtPrinter::VisitOffsetOfExpr(OffsetOfExpr *Node) {
   OS << "__builtin_offsetof(";
-  Node->getTypeSourceInfo()->getType().print(OS, Policy);
+  PrintType(Node->getTypeSourceInfo()->getType());
   OS << ", ";
   bool PrintedSomething = false;
   for (unsigned i = 0, n = Node->getNumComponents(); i < n; ++i) {
     OffsetOfNode ON = Node->getComponent(i);
     if (ON.getKind() == OffsetOfNode::Array) {
       // Array node
       OS << "[";
       PrintExpr(Node->getIndexExpr(ON.getArrayExprIndex()));
case UETT_VecStep:
     OS << "vec_step";
     break;
   case UETT_OpenMPRequiredSimdAlign:
     OS << "__builtin_omp_required_simd_align";
     break;
   }
   if (Node->isArgumentType()) {
     OS << '(';
-    Node->getArgumentType().print(OS, Policy);
+    PrintType(Node->getArgumentType());
     OS << ')';
   } else {
     OS << " ";
     PrintExpr(Node->getArgumentExpr());
   }
 }
 
 void StmtPrinter::VisitGenericSelectionExpr(GenericSelectionExpr *Node) {
   OS << "_Generic(";
   PrintExpr(Node->getControllingExpr());
   for (unsigned i = 0; i != Node->getNumAssocs(); ++i) {
     OS << ", ";
     QualType T = Node->getAssocType(i);
     if (T.isNull())
       OS << "default";
     else
-      T.print(OS, Policy);
+      PrintType(T);
     OS << ": ";
     PrintExpr(Node->getAssocExpr(i));
   }
   OS << ")";
 }
 
 void StmtPrinter::VisitArraySubscriptExpr(ArraySubscriptExpr *Node) {
   PrintExpr(Node->getLHS());

 void StmtPrinter::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
   PrintExpr(Node->getBase());
   OS << ".";
   OS << Node->getAccessor().getName();
 }
 
 void StmtPrinter::VisitCStyleCastExpr(CStyleCastExpr *Node) {
   OS << '(';
-  Node->getTypeAsWritten().print(OS, Policy);
+  PrintType(Node->getTypeAsWritten());
   OS << ')';
   PrintExpr(Node->getSubExpr());
 }
 
 void StmtPrinter::VisitCompoundLiteralExpr(CompoundLiteralExpr *Node) {
   OS << '(';
-  Node->getType().print(OS, Policy);
+  PrintType(Node->getType());
   OS << ')';
   PrintExpr(Node->getInitializer());
 }
 
 void StmtPrinter::VisitImplicitCastExpr(ImplicitCastExpr *Node) {
   // No need to print anything, simply forward to the subexpression.
   PrintExpr(Node->getSubExpr());
 }
void StmtPrinter::VisitShuffleVectorExpr(ShuffleVectorExpr *Node) {
   }
   OS << ")";
 }
 
 void StmtPrinter::VisitConvertVectorExpr(ConvertVectorExpr *Node) {
   OS << "__builtin_convertvector(";
   PrintExpr(Node->getSrcExpr());
   OS << ", ";
-  Node->getType().print(OS, Policy);
+  PrintType(Node->getType());
   OS << ")";
 }
 
 void StmtPrinter::VisitInitListExpr(InitListExpr* Node) {
   if (Node->getSyntacticForm()) {
     Visit(Node->getSyntacticForm());
     return;
   }

 
 void StmtPrinter::VisitNoInitExpr(NoInitExpr *Node) {
   OS << "/*no init*/";
 }
 
 void StmtPrinter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *Node) {
   if (Node->getType()->getAsCXXRecordDecl()) {
     OS << "/*implicit*/";
-    Node->getType().print(OS, Policy);
+    PrintType(Node->getType());
     OS << "()";
   } else {
     OS << "/*implicit*/(";
-    Node->getType().print(OS, Policy);
+    PrintType(Node->getType());
     OS << ')';
     if (Node->getType()->isRecordType())
       OS << "{}";
     else
       OS << 0;
   }
 }
 
 void StmtPrinter::VisitVAArgExpr(VAArgExpr *Node) {
   OS << "__builtin_va_arg(";
   PrintExpr(Node->getSubExpr());
   OS << ", ";
-  Node->getType().print(OS, Policy);
+  PrintType(Node->getType());
   OS << ")";
 }
 
 void StmtPrinter::VisitPseudoObjectExpr(PseudoObjectExpr *Node) {
   PrintExpr(Node->getSyntacticForm());
 }
 
 void StmtPrinter::VisitAtomicExpr(AtomicExpr *Node) {
void StmtPrinter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *Node) {
   PrintCallArgs(Node->getConfig());
   OS << ">>>(";
   PrintCallArgs(Node);
   OS << ")";
 }
 
 void StmtPrinter::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
   OS << Node->getCastName() << '<';
-  Node->getTypeAsWritten().print(OS, Policy);
+  PrintType(Node->getTypeAsWritten());
   OS << ">(";
   PrintExpr(Node->getSubExpr());
   OS << ")";
 }
 
 void StmtPrinter::VisitCXXStaticCastExpr(CXXStaticCastExpr *Node) {
   VisitCXXNamedCastExpr(Node);
 }
 
 void StmtPrinter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *Node) {
   VisitCXXNamedCastExpr(Node);
 }
 
 void StmtPrinter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *Node) {
   VisitCXXNamedCastExpr(Node);
 }
 
 void StmtPrinter::VisitCXXConstCastExpr(CXXConstCastExpr *Node) {
   VisitCXXNamedCastExpr(Node);
 }
 
 void StmtPrinter::VisitCXXTypeidExpr(CXXTypeidExpr *Node) {
   OS << "typeid(";
   if (Node->isTypeOperand()) {
-    Node->getTypeOperandSourceInfo()->getType().print(OS, Policy);
+    PrintType(Node->getTypeOperandSourceInfo()->getType());
   } else {
     PrintExpr(Node->getExprOperand());
   }
   OS << ")";
 }
 
 void StmtPrinter::VisitCXXUuidofExpr(CXXUuidofExpr *Node) {
   OS << "__uuidof(";
   if (Node->isTypeOperand()) {
-    Node->getTypeOperandSourceInfo()->getType().print(OS, Policy);
+    PrintType(Node->getTypeOperandSourceInfo()->getType());
   } else {
     PrintExpr(Node->getExprOperand());
   }
   OS << ")";
 }
 
 void StmtPrinter::VisitMSPropertyRefExpr(MSPropertyRefExpr *Node) {
   PrintExpr(Node->getBaseExpr());
void StmtPrinter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *Node) {
   // Nothing to print: we picked up the default argument.
 }
 
 void StmtPrinter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *Node) {
   // Nothing to print: we picked up the default initializer.
 }
 
 void StmtPrinter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
-  Node->getType().print(OS, Policy);
+  PrintType(Node->getType());
   // If there are no parens, this is list-initialization, and the braces are
   // part of the syntax of the inner construct.
   if (Node->getLParenLoc().isValid())
     OS << "(";
   PrintExpr(Node->getSubExpr());
   if (Node->getLParenLoc().isValid())
     OS << ")";
 }
 
 void StmtPrinter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) {
   PrintExpr(Node->getSubExpr());
 }
 
 void StmtPrinter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *Node) {
-  Node->getType().print(OS, Policy);
+  PrintType(Node->getType());
   if (Node->isStdInitListInitialization())
     /* Nothing to do; braces are part of creating the std::initializer_list. */;
   else if (Node->isListInitialization())
     OS << "{";
   else
     OS << "(";
   for (CXXTemporaryObjectExpr::arg_iterator Arg = Node->arg_begin(),
                                          ArgEnd = Node->arg_end();
if (Node->hasExplicitParameters()) {
     auto *Proto = Method->getType()->getAs<FunctionProtoType>();
     Proto->printExceptionSpecification(OS, Policy);
 
     // FIXME: Attributes
 
     // Print the trailing return type if it was specified in the source.
     if (Node->hasExplicitResultType()) {
       OS << " -> ";
-      Proto->getReturnType().print(OS, Policy);
+      PrintType(Proto->getReturnType());
     }
   }
 
   // Print the body.
   CompoundStmt *Body = Node->getBody();
   OS << ' ';
   PrintStmt(Body);
 }
 
 void StmtPrinter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *Node) {
   if (TypeSourceInfo *TSInfo = Node->getTypeSourceInfo())
-    TSInfo->getType().print(OS, Policy);
+    PrintType(TSInfo->getType());
   else
-    Node->getType().print(OS, Policy);
+    PrintType(Node->getType());
   OS << "()";
 }
 
 void StmtPrinter::VisitCXXNewExpr(CXXNewExpr *E) {
   if (E->isGlobalNew())
     OS << "::";
   OS << "new ";
   unsigned NumPlace = E->getNumPlacementArgs();
else
     OS << '.';
   if (E->getQualifier())
     E->getQualifier()->print(OS, Policy);
   OS << "~";
 
   if (IdentifierInfo *II = E->getDestroyedTypeIdentifier())
     OS << II->getName();
   else
-    E->getDestroyedType().print(OS, Policy);
+    PrintType(E->getDestroyedType());
 }
 
 void StmtPrinter::VisitCXXConstructExpr(CXXConstructExpr *E) {
   if (E->isListInitialization() && !E->isStdInitListInitialization())
     OS << "{";
 
   for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
     if (isa<CXXDefaultArgExpr>(E->getArg(i))) {

 void StmtPrinter::VisitExprWithCleanups(ExprWithCleanups *E) {
   // Just forward to the subexpression.
   PrintExpr(E->getSubExpr());
 }
 
 void
 StmtPrinter::VisitCXXUnresolvedConstructExpr(
                                            CXXUnresolvedConstructExpr *Node) {
-  Node->getTypeAsWritten().print(OS, Policy);
+  PrintType(Node->getTypeAsWritten());
   OS << "(";
   for (CXXUnresolvedConstructExpr::arg_iterator Arg = Node->arg_begin(),
                                              ArgEnd = Node->arg_end();
        Arg != ArgEnd; ++Arg) {
     if (Arg != Node->arg_begin())
       OS << ", ";
     PrintExpr(*Arg);
   }
static const char *getExpressionTraitName(ExpressionTrait ET) {
   llvm_unreachable("Expression type trait not covered by switch");
 }
 
 void StmtPrinter::VisitTypeTraitExpr(TypeTraitExpr *E) {
   OS << getTypeTraitName(E->getTrait()) << "(";
   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
     if (I > 0)
       OS << ", ";
-    E->getArg(I)->getType().print(OS, Policy);
+    PrintType(E->getArg(I)->getType());
   }
   OS << ")";
 }
 
 void StmtPrinter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
   OS << getTypeTraitName(E->getTrait()) << '(';
-  E->getQueriedType().print(OS, Policy);
+  PrintType(E->getQueriedType());
   OS << ')';
 }
 
 void StmtPrinter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
   OS << getExpressionTraitName(E->getTrait()) << '(';
   PrintExpr(E->getQueriedExpression());
   OS << ')';
 }
for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
     if (Element.isPackExpansion())
       OS << "...";
   }
   OS << " }";
 }
 
 void StmtPrinter::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) {
   OS << "@encode(";
-  Node->getEncodedType().print(OS, Policy);
+  PrintType(Node->getEncodedType());
   OS << ')';
 }
 
 void StmtPrinter::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) {
   OS << "@selector(";
   Node->getSelector().print(OS);
   OS << ')';
 }
 
 void StmtPrinter::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) {
   OS << "@protocol(" << *Node->getProtocol() << ')';
 }
 
 void StmtPrinter::VisitObjCMessageExpr(ObjCMessageExpr *Mess) {
   OS << "[";
   switch (Mess->getReceiverKind()) {
   case ObjCMessageExpr::Instance:
     PrintExpr(Mess->getInstanceReceiver());
     break;
 
   case ObjCMessageExpr::Class:
-    Mess->getClassReceiver().print(OS, Policy);
+    PrintType(Mess->getClassReceiver());
     break;
 
   case ObjCMessageExpr::SuperInstance:
   case ObjCMessageExpr::SuperClass:
     OS << "Super";
     break;
   }
 

 void
 StmtPrinter::VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
   PrintExpr(E->getSubExpr());
 }
 
 void
 StmtPrinter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
   OS << '(' << E->getBridgeKindName();
-  E->getType().print(OS, Policy);
+  PrintType(E->getType());
   OS << ')';
   PrintExpr(E->getSubExpr());
 }
 
 void StmtPrinter::VisitBlockExpr(BlockExpr *Node) {
   BlockDecl *BD = Node->getBlockDecl();
   OS << "^";
 
void StmtPrinter::VisitTypoExpr(TypoExpr *Node) {
   // TODO: Print something reasonable for a TypoExpr, if necessary.
   llvm_unreachable("Cannot print TypoExpr nodes");
 }
 
 void StmtPrinter::VisitAsTypeExpr(AsTypeExpr *Node) {
   OS << "__builtin_astype(";
   PrintExpr(Node->getSrcExpr());
   OS << ", ";
-  Node->getType().print(OS, Policy);
+  PrintType(Node->getType());
   OS << ")";
 }
 
 //===----------------------------------------------------------------------===//
 // Stmt method implementations
 //===----------------------------------------------------------------------===//
 
 void Stmt::dumpPretty(const ASTContext &Context) const {
   printPretty(llvm::errs(), nullptr, PrintingPolicy(Context.getLangOpts()));
 }
 
 void Stmt::printPretty(raw_ostream &OS, PrinterHelper *Helper,
                        const PrintingPolicy &Policy, unsigned Indentation,
-                       StringRef NL,
-                       const ASTContext *Context) const {
-  StmtPrinter P(OS, Helper, Policy, Indentation, NL, Context);
+                       StringRef NL, const ASTContext *Context,
+                       bool PrintCanonicalTypes) const {
+  StmtPrinter P(OS, Helper, Policy, Indentation, NL, Context,
+                PrintCanonicalTypes);
   P.Visit(const_cast<Stmt*>(this));
 }
 
 //===----------------------------------------------------------------------===//
 // PrinterHelper
 //===----------------------------------------------------------------------===//
 
 // Implement virtual destructor.
 PrinterHelper::~PrinterHelper() = default;

lib/Sema/SemaTemplate.cpp

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

test/SemaCXX/static-assert-cxx17.cpp

 
 template <typename U, typename V>
 void foo5() {
   static_assert(!!(global_inline_var<U, V>));
   // expected-error@-1{{static_assert failed due to requirement '!!(global_inline_var<int, float>)'}}
 }
 template void foo5<int, float>();
 // expected-note@-1{{in instantiation of function template specialization 'foo5<int, float>' requested here}}
+
+struct ExampleTypes {
+  explicit ExampleTypes(int);
+  using T = int;
+  using U = float;
+};
+
+template <class T>
+struct X {
+  int i = 0;
+  int j = 0;
+  constexpr operator bool() const { return false; }
+};
+
+template <class T>
+void foo6() {
+  static_assert(X<typename T::T>());
+  // expected-error@-1{{static_assert failed due to requirement 'X<int>()'}}
+  static_assert(X<typename T::T>{});
+  // expected-error@-1{{static_assert failed due to requirement 'X<int>{}'}}
+  static_assert(X<typename T::T>{1, 2});
+  // expected-error@-1{{static_assert failed due to requirement 'X<int>{1, 2}'}}
+  static_assert(X<typename T::T>({1, 2}));
+  // expected-error@-1{{static_assert failed due to requirement 'X<int>({1, 2})'}}
+  static_assert(typename T::T{0});
+  // expected-error@-1{{static_assert failed due to requirement 'int{0}'}}
+  static_assert(typename T::T(0));
+  // expected-error@-1{{static_assert failed due to requirement 'int(0)'}}
+  static_assert(sizeof(X<typename T::T>) == 0);
+  // expected-error@-1{{static_assert failed due to requirement 'sizeof(X<int>) == 0'}}
+  static_assert((const X<typename T::T> *)nullptr);
+  // expected-error@-1{{static_assert failed due to requirement '(const X<int> *)nullptr'}}
+  static_assert(static_cast<const X<typename T::T> *>(nullptr));
+  // expected-error@-1{{static_assert failed due to requirement 'static_cast<const X<int> *>(nullptr)'}}
+  static_assert((const X<typename T::T>[]){} == nullptr);
+  // expected-error@-1{{static_assert failed due to requirement '(X<int> const[0]){} == nullptr'}}
+  static_assert(sizeof(X<decltype(X<typename T::T>().X<typename T::T>::~X())>) == 0);
+  // expected-error@-1{{static_assert failed due to requirement 'sizeof(X<void>) == 0'}}
+}
+template void foo6<ExampleTypes>();
+// expected-note@-1{{in instantiation of function template specialization 'foo6<ExampleTypes>' requested here}}

test/SemaCXX/static-assert.cpp

 
 namespace std {
 
 template <class Tp, Tp v>
 struct integral_constant {
   static const Tp value = v;
   typedef Tp value_type;
   typedef integral_constant type;
+  constexpr operator value_type() const noexcept { return value; }
+  constexpr value_type operator()() const noexcept { return value; }
 };
 
 template <class Tp, Tp v>
 const Tp integral_constant<Tp, v>::value;
 
 typedef integral_constant<bool, true> true_type;
 typedef integral_constant<bool, false> false_type;
 

 template <typename T>
 struct is_same<T, T> {
   static const bool value = true;
 };
 
 } // namespace std
 
 struct ExampleTypes {
+  explicit ExampleTypes(int);
   using T = int;
   using U = float;
 };
 
 static_assert(std::is_same<ExampleTypes::T, ExampleTypes::U>::value, "message");
 // expected-error@-1{{static_assert failed due to requirement 'std::is_same<int, float>::value' "message"}}
 static_assert(std::is_const<ExampleTypes::T>::value, "message");
 // expected-error@-1{{static_assert failed due to requirement 'std::is_const<int>::value' "message"}}
 static_assert(!std::is_const<const ExampleTypes::T>::value, "message");
 // expected-error@-1{{static_assert failed due to requirement '!std::is_const<const int>::value' "message"}}
 static_assert(!(std::is_const<const ExampleTypes::T>::value), "message");
 // expected-error@-1{{static_assert failed due to requirement '!(std::is_const<const int>::value)' "message"}}
 static_assert(std::is_const<const ExampleTypes::T>::value == false, "message");
 // 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"}}
+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 {};
 struct RAI_tag : BI_tag {};
 struct MyIterator {
   using tag = BI_tag;
 };
 struct MyContainer {
   using iterator = MyIterator;