[analyzer][AnalysisOrder] Display the CallEvent type for preCall/postCall

[Szelethus]

Summary

Exactly what it says on the tin! The included testfile demonstrates why this is important -- for C++ dynamic memory operators, we don't always recognize custom, or even standard-specified new/delete operators as CXXAllocatorCall or CXXDeallocatorCall.

[NoQ]

Wonderful tests!

clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h

202

Maybe make a static StringRef getKindAsString(Kind); in the base class and defer to it instead so that they all were in one place near the enum itself?

(i'm not sure it's actually better)

clang/test/Analysis/Inputs/system-header-simulator-cxx.h

971–998

Does it need to be guarded with #if __cplusplus >= ... then?

[Szelethus]

clang/test/Analysis/Inputs/system-header-simulator-cxx.h

971–998

It wasn't guarded before, so I don't think so?

[Szelethus]

clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h

202

Well, each of these kinds are tied to a CallEvent class, so this made sense when I wrote it. I think these approaches are equivalent, so I'll stick with this one if you don't mind :)

clang/include/clang/StaticAnalyzer/Checkers/Checkers.td

CmdLineOption<Boolean,
                   Hide>,
     CmdLineOption<Boolean,
                   "PostStmtCXXNewExpr",
                   "",
                   "false",
                   Released,
                   Hide>,
     CmdLineOption<Boolean,
+                  "PreStmtCXXDeleteExpr",
+                  "",
+                  "false",
+                  Released,
+                  Hide>,
+    CmdLineOption<Boolean,
+                  "PostStmtCXXDeleteExpr",
+                  "",
+                  "false",
+                  Released,
+                  Hide>,
+    CmdLineOption<Boolean,
+                  "PreStmtCXXConstructExpr",
+                  "",
+                  "false",
+                  Released,
+                  Hide>,
+    CmdLineOption<Boolean,
+                  "PostStmtCXXConstructExpr",
+                  "",
+                  "false",
+                  Released,
+                  Hide>,
+    CmdLineOption<Boolean,
                   "PreStmtOffsetOfExpr",
                   "",
                   "false",
                   Released,
                   Hide>,
     CmdLineOption<Boolean,
                   "PostStmtOffsetOfExpr",
                   "",
CmdLineOption<Boolean,
                   Hide>,
     CmdLineOption<Boolean,
                   "EndFunction",
                   "",
                   "false",
                   Released,
                   Hide>,
     CmdLineOption<Boolean,
+                  "EndAnalysis",
+                  "",
+                  "false",
+                  Released,
+                  Hide>,
+    CmdLineOption<Boolean,
                   "NewAllocator",
                   "",
                   "false",
                   Released,
                   Hide>,
     CmdLineOption<Boolean,
                   "Bind",
                   "",

clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h

virtual void getExtraInvalidatedValues(ValueList &Values,
                  RegionAndSymbolInvalidationTraits *ETraits) const {}
 
 public:
   CallEvent &operator=(const CallEvent &) = delete;
   virtual ~CallEvent() = default;
 
   /// Returns the kind of call this is.
   virtual Kind getKind() const = 0;
+  virtual StringRef getKindAsString() const = 0;
 
   /// Returns the declaration of the function or method that will be
   /// called. May be null.
   virtual const Decl *getDecl() const {
     return Origin.dyn_cast<const Decl *>();
   }
 
   /// The state in which the call is being evaluated.
public:
 
   unsigned getNumArgs() const override { return getOriginExpr()->getNumArgs(); }
 
   const Expr *getArgExpr(unsigned Index) const override {
     return getOriginExpr()->getArg(Index);
   }
 
   Kind getKind() const override { return CE_Function; }
+  virtual StringRef getKindAsString() const override {
+    return "SimpleFunctionCall";
+  }
 
   static bool classof(const CallEvent *CA) {
     return CA->getKind() == CE_Function;
   }
 };
 
 /// Represents a call to a block.
 ///
public:
 
   bool argumentsMayEscape() const override {
     return true;
   }
 
   void getInitialStackFrameContents(const StackFrameContext *CalleeCtx,
                                     BindingsTy &Bindings) const override;
 
-  ArrayRef<ParmVarDecl*> parameters() const override;
+  ArrayRef<ParmVarDecl *> parameters() const override;
 
   Kind getKind() const override { return CE_Block; }
+  virtual StringRef getKindAsString() const override { return "BlockCall"; }
 
-  static bool classof(const CallEvent *CA) {
-    return CA->getKind() == CE_Block;
-  }
+  static bool classof(const CallEvent *CA) { return CA->getKind() == CE_Block; }
 };
 
 /// Represents a non-static C++ member function call, no matter how
 /// it is written.
 class CXXInstanceCall : public AnyFunctionCall {
 protected:
   CXXInstanceCall(const CallExpr *CE, ProgramStateRef St,
                   const LocationContext *LCtx)
const Expr *getArgExpr(unsigned Index) const override {
     return getOriginExpr()->getArg(Index);
   }
 
   const Expr *getCXXThisExpr() const override;
 
   RuntimeDefinition getRuntimeDefinition() const override;
 
   Kind getKind() const override { return CE_CXXMember; }
+  virtual StringRef getKindAsString() const override { return "CXXMemberCall"; }
 
   static bool classof(const CallEvent *CA) {
     return CA->getKind() == CE_CXXMember;
   }
 };
 
 /// Represents a C++ overloaded operator call where the operator is
 /// implemented as a non-static member function.
public:
 
   const Expr *getArgExpr(unsigned Index) const override {
     return getOriginExpr()->getArg(Index + 1);
   }
 
   const Expr *getCXXThisExpr() const override;
 
   Kind getKind() const override { return CE_CXXMemberOperator; }
+  virtual StringRef getKindAsString() const override {
+    return "CXXMemberOperatorCall";
+  }
 
   static bool classof(const CallEvent *CA) {
     return CA->getKind() == CE_CXXMemberOperator;
   }
 
   Optional<unsigned>
   getAdjustedParameterIndex(unsigned ASTArgumentIndex) const override {
     // For member operator calls argument 0 on the expression corresponds
public:
   SVal getCXXThisVal() const override;
 
   /// Returns true if this is a call to a base class destructor.
   bool isBaseDestructor() const {
     return DtorDataTy::getFromOpaqueValue(Data).getInt();
   }
 
   Kind getKind() const override { return CE_CXXDestructor; }
+  virtual StringRef getKindAsString() const override {
+    return "CXXDestructorCall";
+  }
 
   static bool classof(const CallEvent *CA) {
     return CA->getKind() == CE_CXXDestructor;
   }
 };
 
 /// Represents any constructor invocation. This includes regular constructors
 /// and inherited constructors.
public:
 
   unsigned getNumArgs() const override { return getOriginExpr()->getNumArgs(); }
 
   const Expr *getArgExpr(unsigned Index) const override {
     return getOriginExpr()->getArg(Index);
   }
 
   Kind getKind() const override { return CE_CXXConstructor; }
+  virtual StringRef getKindAsString() const override {
+    return "CXXConstructorCall";
+  }
 
   static bool classof(const CallEvent *CA) {
     return CA->getKind() == CE_CXXConstructor;
   }
 };
 
 /// Represents a call to a C++ inherited constructor.
 ///
public:
 
   virtual SVal getArgSVal(unsigned Index) const override {
     return getState()->getSVal(
         getArgExpr(Index),
         getInheritingStackFrame()->getParent()->getStackFrame());
   }
 
   Kind getKind() const override { return CE_CXXInheritedConstructor; }
+  virtual StringRef getKindAsString() const override {
+    return "CXXInheritedConstructorCall";
+  }
 
   static bool classof(const CallEvent *CA) {
     return CA->getKind() == CE_CXXInheritedConstructor;
   }
 };
 
 /// Represents the memory allocation call in a C++ new-expression.
 ///
public:
   /// standard std::nothrow operator new and standard placement new both have
   /// 1 implicit argument (size) and 1 placement argument, while regular
   /// operator new() has 1 implicit argument and 0 placement arguments.
   const Expr *getPlacementArgExpr(unsigned Index) const {
     return getOriginExpr()->getPlacementArg(Index);
   }
 
   Kind getKind() const override { return CE_CXXAllocator; }
+  virtual StringRef getKindAsString() const override {
+    return "CXXAllocatorCall";
+  }
 
   static bool classof(const CallEvent *CE) {
     return CE->getKind() == CE_CXXAllocator;
   }
 };
 
 /// Represents the ways an Objective-C message send can occur.
 //
public:
   bool argumentsMayEscape() const override;
 
   void getInitialStackFrameContents(const StackFrameContext *CalleeCtx,
                                     BindingsTy &Bindings) const override;
 
   ArrayRef<ParmVarDecl*> parameters() const override;
 
   Kind getKind() const override { return CE_ObjCMessage; }
+  virtual StringRef getKindAsString() const override {
+    return "ObjCMethodCall";
+  }
 
   static bool classof(const CallEvent *CA) {
     return CA->getKind() == CE_ObjCMessage;
   }
 };
 
 enum CallDescriptionFlags : int {
   /// Describes a C standard function that is sometimes implemented as a macro

clang/lib/StaticAnalyzer/Checkers/AnalysisOrderChecker.cpp

 //===- AnalysisOrderChecker - Print callbacks called ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This checker prints callbacks that are called during analysis.
 // This is required to ensure that callbacks are fired in order
 // and do not duplicate or get lost.
 // Feel free to extend this checker with any callback you need to check.
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/Analysis/CFGStmtMap.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
 #include "clang/StaticAnalyzer/Core/Checker.h"
 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "llvm/Support/ErrorHandling.h"
 
 using namespace clang;
 using namespace ento;
 
 namespace {
 
 class AnalysisOrderChecker
-    : public Checker<check::PreStmt<CastExpr>,
-                     check::PostStmt<CastExpr>,
-                     check::PreStmt<ArraySubscriptExpr>,
-                     check::PostStmt<ArraySubscriptExpr>,
-                     check::PreStmt<CXXNewExpr>,
-                     check::PostStmt<CXXNewExpr>,
-                     check::PreStmt<OffsetOfExpr>,
-                     check::PostStmt<OffsetOfExpr>,
-                     check::PreCall,
-                     check::PostCall,
-                     check::EndFunction,
-                     check::NewAllocator,
-                     check::Bind,
-                     check::PointerEscape,
-                     check::RegionChanges,
-                     check::LiveSymbols> {
+    : public Checker<
+          check::PreStmt<CastExpr>, check::PostStmt<CastExpr>,
+          check::PostStmt<ArraySubscriptExpr>, check::PreStmt<CXXNewExpr>,
+          check::PostStmt<CXXNewExpr>, check::PreStmt<CXXDeleteExpr>,
+          check::PostStmt<CXXDeleteExpr>, check::PreStmt<CXXConstructExpr>,
+          check::PostStmt<CXXConstructExpr>, check::PreStmt<OffsetOfExpr>,
+          check::PostStmt<OffsetOfExpr>, check::PreCall, check::PostCall,
+          check::EndFunction, check::EndAnalysis, check::NewAllocator,
+          check::Bind, check::PointerEscape, check::RegionChanges,
 
-  bool isCallbackEnabled(AnalyzerOptions &Opts, StringRef CallbackName) const {
+  bool isCallbackEnabled(const AnalyzerOptions &Opts,
+                         StringRef CallbackName) const {
     return Opts.getCheckerBooleanOption(this, "*") ||
            Opts.getCheckerBooleanOption(this, CallbackName);
   }
 
   bool isCallbackEnabled(CheckerContext &C, StringRef CallbackName) const {
     AnalyzerOptions &Opts = C.getAnalysisManager().getAnalyzerOptions();
     return isCallbackEnabled(Opts, CallbackName);
   }
if (isCallbackEnabled(C, "PreStmtCXXNewExpr"))
       llvm::errs() << "PreStmt<CXXNewExpr>\n";
   }
 
   void checkPostStmt(const CXXNewExpr *NE, CheckerContext &C) const {
     if (isCallbackEnabled(C, "PostStmtCXXNewExpr"))
       llvm::errs() << "PostStmt<CXXNewExpr>\n";
   }
 
+  void checkPreStmt(const CXXDeleteExpr *NE, CheckerContext &C) const {
+    if (isCallbackEnabled(C, "PreStmtCXXDeleteExpr"))
+      llvm::errs() << "PreStmt<CXXDeleteExpr>\n";
+  }
+
+  void checkPostStmt(const CXXDeleteExpr *NE, CheckerContext &C) const {
+    if (isCallbackEnabled(C, "PostStmtCXXDeleteExpr"))
+      llvm::errs() << "PostStmt<CXXDeleteExpr>\n";
+  }
+
+  void checkPreStmt(const CXXConstructExpr *NE, CheckerContext &C) const {
+    if (isCallbackEnabled(C, "PreStmtCXXConstructExpr"))
+      llvm::errs() << "PreStmt<CXXConstructExpr>\n";
+  }
+
+  void checkPostStmt(const CXXConstructExpr *NE, CheckerContext &C) const {
+    if (isCallbackEnabled(C, "PostStmtCXXConstructExpr"))
+      llvm::errs() << "PostStmt<CXXConstructExpr>\n";
+  }
+
   void checkPreStmt(const OffsetOfExpr *OOE, CheckerContext &C) const {
     if (isCallbackEnabled(C, "PreStmtOffsetOfExpr"))
       llvm::errs() << "PreStmt<OffsetOfExpr>\n";
   }
 
   void checkPostStmt(const OffsetOfExpr *OOE, CheckerContext &C) const {
     if (isCallbackEnabled(C, "PostStmtOffsetOfExpr"))
       llvm::errs() << "PostStmt<OffsetOfExpr>\n";
   }
 
   void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
     if (isCallbackEnabled(C, "PreCall")) {
       llvm::errs() << "PreCall";
       if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(Call.getDecl()))
         llvm::errs() << " (" << ND->getQualifiedNameAsString() << ')';
+      llvm::errs() << " [" << Call.getKindAsString() << ']';
       llvm::errs() << '\n';
     }
   }
 
   void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
     if (isCallbackEnabled(C, "PostCall")) {
       llvm::errs() << "PostCall";
       if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(Call.getDecl()))
         llvm::errs() << " (" << ND->getQualifiedNameAsString() << ')';
+      llvm::errs() << " [" << Call.getKindAsString() << ']';
       llvm::errs() << '\n';
     }
   }
 
   void checkEndFunction(const ReturnStmt *S, CheckerContext &C) const {
     if (isCallbackEnabled(C, "EndFunction")) {
       llvm::errs() << "EndFunction\nReturnStmt: " << (S ? "yes" : "no") << "\n";
       if (!S)
         return;
 
       llvm::errs() << "CFGElement: ";
       CFGStmtMap *Map = C.getCurrentAnalysisDeclContext()->getCFGStmtMap();
       CFGElement LastElement = Map->getBlock(S)->back();
 
       if (LastElement.getAs<CFGStmt>())
         llvm::errs() << "CFGStmt\n";
       else if (LastElement.getAs<CFGAutomaticObjDtor>())
         llvm::errs() << "CFGAutomaticObjDtor\n";
     }
   }
 
+  void checkEndAnalysis(ExplodedGraph &G, BugReporter &BR,
+                        ExprEngine &Eng) const {
+    if (isCallbackEnabled(BR.getAnalyzerOptions(), "EndAnalysis"))
+      llvm::errs() << "EndAnalysis\n";
+  }
+
   void checkNewAllocator(const CXXNewExpr *CNE, SVal Target,
                          CheckerContext &C) const {
     if (isCallbackEnabled(C, "NewAllocator"))
       llvm::errs() << "NewAllocator\n";
   }
 
   void checkBind(SVal Loc, SVal Val, const Stmt *S, CheckerContext &C) const {
     if (isCallbackEnabled(C, "Bind"))

clang/lib/StaticAnalyzer/Core/CallEvent.cpp

void CallEvent::dump(raw_ostream &Out) const {
   }
 
   if (const Decl *D = getDecl()) {
     Out << "Call to ";
     D->print(Out, Ctx.getPrintingPolicy());
     return;
   }
 
-  // FIXME: a string representation of the kind would be nice.
-  Out << "Unknown call (type " << getKind() << ")";
+  Out << "Unknown call (type " << getKindAsString() << ")";
 }
 
 bool CallEvent::isCallStmt(const Stmt *S) {
   return isa<CallExpr>(S) || isa<ObjCMessageExpr>(S)
                           || isa<CXXConstructExpr>(S)
                           || isa<CXXNewExpr>(S);
 }
 

clang/test/Analysis/Inputs/system-header-simulator-cxx.h

class bad_alloc : public exception {
     bad_alloc(const bad_alloc&) throw();
     bad_alloc& operator=(const bad_alloc&) throw();
     virtual const char* what() const throw() {
       return 0;
     }
   };
 
   struct nothrow_t {};
-
   extern const nothrow_t nothrow;
 
+  enum class align_val_t : size_t {};
+
   // libc++'s implementation
   template <class _E>
   class initializer_list
   {
     const _E* __begin_;
     size_t    __size_;
 
     initializer_list(const _E* __b, size_t __s)
namespace std {
   void *malloc(size_t);
   void free(void *);
 }
 void* operator new(std::size_t size, const std::nothrow_t&) throw() { return std::malloc(size); }
 void* operator new[](std::size_t size, const std::nothrow_t&) throw() { return std::malloc(size); }
 void operator delete(void* ptr, const std::nothrow_t&) throw() { std::free(ptr); }
 void operator delete[](void* ptr, const std::nothrow_t&) throw() { std::free(ptr); }
 #else
-void* operator new(std::size_t, const std::nothrow_t&) throw();
-void* operator new[](std::size_t, const std::nothrow_t&) throw();
-void operator delete(void*, const std::nothrow_t&) throw();
-void operator delete[](void*, const std::nothrow_t&) throw();
+// C++20 standard draft 17.6.1, from "Header <new> synopsis", but with throw()
+// instead of noexcept:
+
+void *operator new(std::size_t size);
+void *operator new(std::size_t size, std::align_val_t alignment);
+void *operator new(std::size_t size, const std::nothrow_t &) throw();
+void *operator new(std::size_t size, std::align_val_t alignment,
+                   const std::nothrow_t &) throw();
+void operator delete(void *ptr) throw();
+void operator delete(void *ptr, std::size_t size) throw();
+void operator delete(void *ptr, std::align_val_t alignment) throw();
+void operator delete(void *ptr, std::size_t size, std::align_val_t alignment) throw();
+void operator delete(void *ptr, const std::nothrow_t &)throw();
+void operator delete(void *ptr, std::align_val_t alignment,
+                     const std::nothrow_t &)throw();
+void *operator new[](std::size_t size);
+void *operator new[](std::size_t size, std::align_val_t alignment);
+void *operator new[](std::size_t size, const std::nothrow_t &) throw();
+void *operator new[](std::size_t size, std::align_val_t alignment,
+                     const std::nothrow_t &) throw();
+void operator delete[](void *ptr) throw();
+void operator delete[](void *ptr, std::size_t size) throw();
+void operator delete[](void *ptr, std::align_val_t alignment) throw();
+void operator delete[](void *ptr, std::size_t size, std::align_val_t alignment) throw();
+void operator delete[](void *ptr, const std::nothrow_t &) throw();
+void operator delete[](void *ptr, std::align_val_t alignment,
+                       const std::nothrow_t &) throw();
 #endif
 
 void* operator new (std::size_t size, void* ptr) throw() { return ptr; };
 void* operator new[] (std::size_t size, void* ptr) throw() { return ptr; };
 void operator delete (void* ptr, void*) throw() {};
 void operator delete[] (void* ptr, void*) throw() {};
 
 namespace __cxxabiv1 {
 extern "C" {

clang/test/Analysis/analyzer-config.c

 // CHECK-NEXT: crosscheck-with-z3 = false
 // CHECK-NEXT: ctu-dir = ""
 // CHECK-NEXT: ctu-import-threshold = 100
 // CHECK-NEXT: ctu-index-name = externalDefMap.txt
 // CHECK-NEXT: deadcode.DeadStores:ShowFixIts = false
 // CHECK-NEXT: deadcode.DeadStores:WarnForDeadNestedAssignments = true
 // CHECK-NEXT: debug.AnalysisOrder:* = false
 // CHECK-NEXT: debug.AnalysisOrder:Bind = false
+// CHECK-NEXT: debug.AnalysisOrder:EndAnalysis = false
 // CHECK-NEXT: debug.AnalysisOrder:EndFunction = false
 // CHECK-NEXT: debug.AnalysisOrder:LiveSymbols = false
 // CHECK-NEXT: debug.AnalysisOrder:NewAllocator = false
 // CHECK-NEXT: debug.AnalysisOrder:PointerEscape = false
 // CHECK-NEXT: debug.AnalysisOrder:PostCall = false
 // CHECK-NEXT: debug.AnalysisOrder:PostStmtArraySubscriptExpr = false
+// CHECK-NEXT: debug.AnalysisOrder:PostStmtCXXConstructExpr = false
+// CHECK-NEXT: debug.AnalysisOrder:PostStmtCXXDeleteExpr = false
 // CHECK-NEXT: debug.AnalysisOrder:PostStmtCXXNewExpr = false
 // CHECK-NEXT: debug.AnalysisOrder:PostStmtCastExpr = false
 // CHECK-NEXT: debug.AnalysisOrder:PostStmtOffsetOfExpr = false
 // CHECK-NEXT: debug.AnalysisOrder:PreCall = false
 // CHECK-NEXT: debug.AnalysisOrder:PreStmtArraySubscriptExpr = false
+// CHECK-NEXT: debug.AnalysisOrder:PreStmtCXXConstructExpr = false
+// CHECK-NEXT: debug.AnalysisOrder:PreStmtCXXDeleteExpr = false
 // CHECK-NEXT: debug.AnalysisOrder:PreStmtCXXNewExpr = false
 // CHECK-NEXT: debug.AnalysisOrder:PreStmtCastExpr = false
 // CHECK-NEXT: debug.AnalysisOrder:PreStmtOffsetOfExpr = false
 // CHECK-NEXT: debug.AnalysisOrder:RegionChanges = false
 // CHECK-NEXT: display-checker-name = true
 // CHECK-NEXT: display-ctu-progress = false
 // CHECK-NEXT: eagerly-assume = true
 // CHECK-NEXT: elide-constructors = true

 // CHECK-NEXT: suppress-inlined-defensive-checks = true
 // CHECK-NEXT: suppress-null-return-paths = true
 // CHECK-NEXT: track-conditions = true
 // CHECK-NEXT: track-conditions-debug = false
 // CHECK-NEXT: unix.DynamicMemoryModeling:Optimistic = false
 // CHECK-NEXT: unroll-loops = false
 // CHECK-NEXT: widen-loops = false
 // CHECK-NEXT: [stats]
-// CHECK-NEXT: num-entries = 98
+// CHECK-NEXT: num-entries = 103

clang/test/Analysis/cxx-dynamic-memory-analysis-order.cpp

+// RUN: %clang_analyze_cc1 -std=c++20 -fblocks -verify %s \
+// RUN:   -analyzer-checker=core \
+// RUN:   -analyzer-checker=debug.AnalysisOrder \
+// RUN:   -analyzer-config debug.AnalysisOrder:PreStmtCXXNewExpr=true \
+// RUN:   -analyzer-config debug.AnalysisOrder:PostStmtCXXNewExpr=true \
+// RUN:   -analyzer-config debug.AnalysisOrder:PreStmtCXXDeleteExpr=true \
+// RUN:   -analyzer-config debug.AnalysisOrder:PostStmtCXXDeleteExpr=true \
+// RUN:   -analyzer-config debug.AnalysisOrder:PreCall=true \
+// RUN:   -analyzer-config debug.AnalysisOrder:PostCall=true \
+// RUN:   2>&1 | FileCheck %s
+
+// expected-no-diagnostics
+
+#include "Inputs/system-header-simulator-cxx.h"
+
+void f() {
+  // C++20 standard draft 17.6.1.15:
+  // Required behavior: A call to an operator delete with a size parameter may
+  // be changed to a call to the corresponding operator delete without a size
+  // parameter, without affecting memory allocation. [ Note: A conforming
+  // implementation is for operator delete(void* ptr, size_t size) to simply
+  // call operator delete(ptr). — end note ]
+  //
+  // C++20 standard draft 17.6.1.24, about nothrow operator delete:
+  //   void operator delete(void* ptr, const std::nothrow_t&) noexcept;
+  //   void operator delete(void* ptr, std::align_val_t alignment,
+  //                        const std::nothrow_t&) noexcept;
+  // Default behavior: Calls operator delete(ptr), or operator delete(ptr,
+  // alignment), respectively.
+
+  // FIXME: All calls to operator new should be CXXAllocatorCall.
+  // FIXME: PostStmt<CXXDeleteExpr> should be present.
+  {
+    int *p = new int;
+    delete p;
+    // CHECK:      PreCall (operator new) [CXXAllocatorCall]
+    // CHECK-NEXT: PostCall (operator new) [CXXAllocatorCall]
+    // CHECK-NEXT: PreStmt<CXXNewExpr>
+    // CHECK-NEXT: PostStmt<CXXNewExpr>
+    // CHECK-NEXT: PreStmt<CXXDeleteExpr>
+
+    p = new int;
+    operator delete(p, 23542368);
+    // CHECK-NEXT: PreCall (operator new) [CXXAllocatorCall]
+    // CHECK-NEXT: PostCall (operator new) [CXXAllocatorCall]
+    // CHECK-NEXT: PreStmt<CXXNewExpr>
+    // CHECK-NEXT: PostStmt<CXXNewExpr>
+    // CHECK-NEXT: PreCall (operator delete) [SimpleFunctionCall]
+    // CHECK-NEXT: PostCall (operator delete) [SimpleFunctionCall]
+
+    void *v = operator new(sizeof(int[2]), std::align_val_t(2));
+    operator delete(v, std::align_val_t(2));
+    // CHECK-NEXT: PreCall (operator new) [SimpleFunctionCall]
+    // CHECK-NEXT: PostCall (operator new) [SimpleFunctionCall]
+    // CHECK-NEXT: PreCall (operator delete) [SimpleFunctionCall]
+    // CHECK-NEXT: PostCall (operator delete) [SimpleFunctionCall]
+
+    v = operator new(sizeof(int[2]), std::align_val_t(2));
+    operator delete(v, 345345, std::align_val_t(2));
+    // CHECK-NEXT: PreCall (operator new) [SimpleFunctionCall]
+    // CHECK-NEXT: PostCall (operator new) [SimpleFunctionCall]
+    // CHECK-NEXT: PreCall (operator delete) [SimpleFunctionCall]
+    // CHECK-NEXT: PostCall (operator delete) [SimpleFunctionCall]
+
+    p = new (std::nothrow) int;
+    operator delete(p, std::nothrow);
+    // CHECK-NEXT: PreCall (operator new) [CXXAllocatorCall]
+    // CHECK-NEXT: PostCall (operator new) [CXXAllocatorCall]
+    // CHECK-NEXT: PreStmt<CXXNewExpr>
+    // CHECK-NEXT: PostStmt<CXXNewExpr>
+    // CHECK-NEXT: PreCall (operator delete) [SimpleFunctionCall]
+    // CHECK-NEXT: PostCall (operator delete) [SimpleFunctionCall]
+
+    v = operator new(sizeof(int[2]), std::align_val_t(2), std::nothrow);
+    operator delete(v, std::align_val_t(2), std::nothrow);
+    // CHECK-NEXT: PreCall (operator new) [SimpleFunctionCall]
+    // CHECK-NEXT: PostCall (operator new) [SimpleFunctionCall]
+    // CHECK-NEXT: PreCall (operator delete) [SimpleFunctionCall]
+    // CHECK-NEXT: PostCall (operator delete) [SimpleFunctionCall]
+  }
+
+  {
+    int *p = new int[2];
+    delete[] p;
+    // CHECK-NEXT: PreCall (operator new[]) [CXXAllocatorCall]
+    // CHECK-NEXT: PostCall (operator new[]) [CXXAllocatorCall]
+    // CHECK-NEXT: PreStmt<CXXNewExpr>
+    // CHECK-NEXT: PostStmt<CXXNewExpr>
+    // CHECK-NEXT: PreStmt<CXXDeleteExpr>
+
+    p = new int[2];
+    operator delete[](p, 23542368);
+    // CHECK-NEXT: PreCall (operator new[]) [CXXAllocatorCall]
+    // CHECK-NEXT: PostCall (operator new[]) [CXXAllocatorCall]
+    // CHECK-NEXT: PreStmt<CXXNewExpr>
+    // CHECK-NEXT: PostStmt<CXXNewExpr>
+    // CHECK-NEXT: PreCall (operator delete[]) [SimpleFunctionCall]
+    // CHECK-NEXT: PostCall (operator delete[]) [SimpleFunctionCall]
+
+    void *v = operator new[](sizeof(int[2]), std::align_val_t(2));
+    operator delete[](v, std::align_val_t(2));
+    // CHECK-NEXT: PreCall (operator new[]) [SimpleFunctionCall]
+    // CHECK-NEXT: PostCall (operator new[]) [SimpleFunctionCall]
+    // CHECK-NEXT: PreCall (operator delete[]) [SimpleFunctionCall]
+    // CHECK-NEXT: PostCall (operator delete[]) [SimpleFunctionCall]
+
+    v = operator new[](sizeof(int[2]), std::align_val_t(2));
+    operator delete[](v, 345345, std::align_val_t(2));
+    // CHECK-NEXT: PreCall (operator new[]) [SimpleFunctionCall]
+    // CHECK-NEXT: PostCall (operator new[]) [SimpleFunctionCall]
+    // CHECK-NEXT: PreCall (operator delete[]) [SimpleFunctionCall]
+    // CHECK-NEXT: PostCall (operator delete[]) [SimpleFunctionCall]
+
+    p = new (std::nothrow) int[2];
+    operator delete[](p, std::nothrow);
+    // CHECK-NEXT: PreCall (operator new[]) [CXXAllocatorCall]
+    // CHECK-NEXT: PostCall (operator new[]) [CXXAllocatorCall]
+    // CHECK-NEXT: PreStmt<CXXNewExpr>
+    // CHECK-NEXT: PostStmt<CXXNewExpr>
+    // CHECK-NEXT: PreCall (operator delete[]) [SimpleFunctionCall]
+    // CHECK-NEXT: PostCall (operator delete[]) [SimpleFunctionCall]
+
+    v = operator new[](sizeof(int[2]), std::align_val_t(2), std::nothrow);
+    operator delete[](v, std::align_val_t(2), std::nothrow);
+    // CHECK-NEXT: PreCall (operator new[]) [SimpleFunctionCall]
+    // CHECK-NEXT: PostCall (operator new[]) [SimpleFunctionCall]
+    // CHECK-NEXT: PreCall (operator delete[]) [SimpleFunctionCall]
+    // CHECK-NEXT: PostCall (operator delete[]) [SimpleFunctionCall]
+  }
+}

clang/test/Analysis/diagnostics/explicit-suppression.cpp

class C {
   // The virtual function is to make C not trivially copy assignable so that we call the
   // variant of std::copy() that does not defer to memmove().
   virtual int f();
 };
 
 void testCopyNull(C *I, C *E) {
   std::copy(I, E, (C *)0);
 #ifndef SUPPRESSED
-  // expected-warning@../Inputs/system-header-simulator-cxx.h:698 {{Called C++ object pointer is null}}
+  // expected-warning@../Inputs/system-header-simulator-cxx.h:699 {{Called C++ object pointer is null}}
 #endif
 }