Emit offsetof values as notes when a static_assert fails

[arichardson]

Summary

Trying to debug a static_assert(offset(foo, field) == ...) failure can be
rather awkward since there is no easy way to print the value at compile
time without another compiler diagnostic involving an array size.
This builds upon the sizeof()/alignof() printing and extends it to handle
OffsetOfExpr.

Depends on D108211

[arichardson]

No longer needed

clang/lib/Sema/SemaTemplate.cpp

 // 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, Sema &S,
       SmallVectorImpl<PartialDiagnosticAt> &Notes)
-      : Policy(P), S(S), Notes(Notes) {}
+      : Policy(P), SemaRef(S), Notes(Notes) {}
 
-  bool handledStmt(Stmt *E, raw_ostream &OS) override {
-    const auto *DR = dyn_cast<DeclRefExpr>(E);
+  bool handledStmt(Stmt *S, raw_ostream &OS) override {
+    const auto *DR = dyn_cast<DeclRefExpr>(S);
     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,
             IV->getSpecializedTemplate()->getTemplateParameters());
       }
       return true;
-    } else if (auto *UE = dyn_cast<UnaryExprOrTypeTraitExpr>(E)) {
+    } else if (isa<UnaryExprOrTypeTraitExpr>(S) || isa<OffsetOfExpr>(S)) {
+      Expr *E = cast<Expr>(S);
       Expr::EvalResult Result;
-      if (UE->EvaluateAsConstantExpr(Result, S.Context) && Result.Val.isInt()) {
+      if (E->EvaluateAsConstantExpr(Result, SemaRef.Context) &&
+          Result.Val.isInt()) {
         std::string ExprStr;
         llvm::raw_string_ostream ExprStream(ExprStr);
-        UE->printPretty(ExprStream, nullptr, Policy);
+        E->printPretty(ExprStream, nullptr, Policy);
         ExprStream.flush();
         Notes.push_back(PartialDiagnosticAt(
-            UE->getExprLoc(),
-            S.PDiag(diag::note_static_assert_requirement_context)
+            E->getExprLoc(),
+            SemaRef.PDiag(diag::note_static_assert_requirement_context)
                 << ExprStr << toString(Result.Val.getInt(), 10)
-                << UE->getSourceRange()));
+                << E->getSourceRange()));
       }
     }
     return false;
   }
 
 private:
   const PrintingPolicy Policy;
-  Sema &S;
+  Sema &SemaRef;
   SmallVectorImpl<PartialDiagnosticAt> &Notes;
 };
 
 } // end anonymous namespace
 
 std::pair<Expr *, std::string>
 Sema::findFailedBooleanCondition(Expr *Cond,
                                  SmallVectorImpl<PartialDiagnosticAt> &Notes) {

clang/test/SemaCXX/static-assert.cpp

 // expected-note@-2{{with 'sizeof(IntAndPointer)' equal to 16}}
 static_assert(alignof(IntAndPointer) == 4, "message");
 // expected-error@-1{{static_assert failed due to requirement 'alignof(IntAndPointer) == 4' "message"}}
 // expected-note@-2{{with 'alignof(IntAndPointer)' equal to 8}}
 static_assert(alignof(IntAndPointer) == sizeof(IntAndPointer), "message");
 // expected-error@-1{{static_assert failed due to requirement 'alignof(IntAndPointer) == sizeof(IntAndPointer)' "message"}}
 // expected-note@-2{{with 'alignof(IntAndPointer)' equal to 8}}
 // expected-note@-3{{with 'sizeof(IntAndPointer)' equal to 16}}
+#define offsetof(s, f) __builtin_offsetof(s, f)
+static_assert(__builtin_offsetof(IntAndPointer, p) == -1, "message");
+// expected-error@-1{{static_assert failed due to requirement '__builtin_offsetof(IntAndPointer, p) == -1' "message"}}
+// expected-note@-2{{with '__builtin_offsetof(IntAndPointer, p)' equal to 8}}
+static_assert(offsetof(IntAndPointer, i) == -1, "message");
+// expected-error@-1{{static_assert failed due to requirement '__builtin_offsetof(IntAndPointer, i) == -1' "message"}}
+// expected-note@-2{{with '__builtin_offsetof(IntAndPointer, i)' equal to 0}}