[analyzer] NFC: Fix nothrow operator new definition in a test.

[NoQ]

Summary

Fun C++ fact: definition

void *operator new(std::size_t size, std::nothrow_t &nothrow) throw() { ... }

does not override the global nothrow operator new. The standard nothrow operator new would still be called when this definition is present. Because, well, the second parameter (std::nothrow_t &nothrow) is missing a const qualifier, so it's a completely different function. In fact, temporary of type std::nothrow_t would never be bound to a non-const reference at all. So the custom operator defined above is also very hard to call.

This patch fixes the test case. The analyzer behavior is intended (at least for now, see also discussion in D41406) regardless of whether the operator is overridden correctly or not, but tests now actually test it.

[a.sidorin]

Looks good, just a minor nit.

test/Analysis/NewDelete-custom.cpp

7 ↗

(On Diff #127580)

Double negation can be simplified a bit: #if !LEAKS || ALLOCATOR_INLINING

[NoQ]

test/Analysis/NewDelete-custom.cpp

7 ↗

(On Diff #127580)

The rest of the #ifs in this file look like #if LEAKS && !ALLOCATOR_INLINING, so i wanted this to look similarly.

[dcoughlin]

LGTM as well.

cfe/trunk/test/Analysis/NewDelete-custom.cpp

 // RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete,unix.Malloc -std=c++11 -fblocks -verify %s
 // RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete,cplusplus.NewDeleteLeaks,unix.Malloc -std=c++11 -DLEAKS=1 -fblocks -verify %s
 // RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete,unix.Malloc -std=c++11 -analyzer-config c++-allocator-inlining=true -DALLOCATOR_INLINING=1 -fblocks -verify %s
 // RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete,cplusplus.NewDeleteLeaks,unix.Malloc -std=c++11 -analyzer-config c++-allocator-inlining=true -DLEAKS=1 -DALLOCATOR_INLINING=1 -fblocks -verify %s
 #include "Inputs/system-header-simulator-cxx.h"
 
-#if !LEAKS
+#if !(LEAKS && !ALLOCATOR_INLINING)
 // expected-no-diagnostics
 #endif
 
 
 void *allocator(std::size_t size);
 
 void *operator new[](std::size_t size) throw() { return allocator(size); }
 void *operator new(std::size_t size) throw() { return allocator(size); }
-void *operator new(std::size_t size, std::nothrow_t& nothrow) throw() { return allocator(size); }
+void *operator new(std::size_t size, const std::nothrow_t &nothrow) throw() { return allocator(size); }
 void *operator new(std::size_t, double d);
 
 class C {
 public:
   void *operator new(std::size_t);  
 };
 
 void testNewMethod() {

 }
 #if LEAKS && !ALLOCATOR_INLINING
 // expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
 #endif
 
 
 //----- Custom NoThrow placement operators
 void testOpNewNoThrow() {
-  void *p = operator new(0, std::nothrow);
+  void *p = operator new(0, std::nothrow); // call is inlined, no warn
 }
-#if LEAKS
-// expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
-#endif
 
 void testNewExprNoThrow() {
   int *p = new(std::nothrow) int;
 }
-#if LEAKS
+#if LEAKS && !ALLOCATOR_INLINING
 // expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
 #endif
 
 //----- Custom placement operators
 void testOpNewPlacement() {
   void *p = operator new(0, 0.1); // no warn
 }
 
 void testNewExprPlacement() {
   int *p = new(0.1) int; // no warn
 }