[analyzer] Enable c++-allocator-inlining by default?

[NoQ]

Summary

Once D42192 lands, i believe it should be safe to flip the default value of -analyzer-config c++-allocator-inlining to true by default.

My evaluation (on a large mostly internal codebase, including WebKit, more than a day of real-world time of continuous analysis) shows that around twice as much false positives are getting fixed (~35) as new false positives added (~20). Additionally, the reason for newly added false positives is our increased precision and coverage due to more aggressive inlining, which exposes other, unrelated problems in the analyzer, which is an expected outcome of enabling more coverage on codebases that already have high false positive rates (such as many C++ codebases). Gradually improving C++ support should be mitigating those. One true positive was lost due to analyzer reaching the max-nodes limit due to more aggressive inlining. I didn't immediately find any new positives that were definitely true, but some looked fairly suspicious.

The old mode would be available for a while, so it's possible, if necessary, to turn the new mode off with -analyzer-config c++-allocator-inlining=false.

All changes in tests in the patch are FIXMEs that were resolved by enabling the new mode.

[NoQ]

I committed this for now, but i'm totally open for post-commit review and reacting on any "unknown unknowns" that may be found.

lib/StaticAnalyzer/Core/AnalyzerOptions.cpp

bool AnalyzerOptions::mayInlineTemplateFunctions() {
   return getBooleanOption(InlineTemplateFunctions,
                           "c++-template-inlining",
                           /*Default=*/true);
 }
 
 bool AnalyzerOptions::mayInlineCXXAllocator() {
   return getBooleanOption(InlineCXXAllocator,
                           "c++-allocator-inlining",
-                          /*Default=*/false);
+                          /*Default=*/true);
 }
 
 bool AnalyzerOptions::mayInlineCXXContainerMethods() {
   return getBooleanOption(InlineCXXContainerMethods,
                           "c++-container-inlining",
                           /*Default=*/false);
 }
 

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
+// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete,unix.Malloc -std=c++11 -analyzer-config c++-allocator-inlining=false -fblocks -verify %s
+// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete,cplusplus.NewDeleteLeaks,unix.Malloc -std=c++11 -analyzer-config c++-allocator-inlining=false -DLEAKS=1 -fblocks -verify %s
+// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete,unix.Malloc -std=c++11 -DALLOCATOR_INLINING=1 -fblocks -verify %s
+// RUN: %clang_analyze_cc1 -analyzer-checker=core,cplusplus.NewDelete,cplusplus.NewDeleteLeaks,unix.Malloc -std=c++11 -DLEAKS=1 -DALLOCATOR_INLINING=1 -fblocks -verify %s
 #include "Inputs/system-header-simulator-cxx.h"
 
 #if !(LEAKS && !ALLOCATOR_INLINING)
 // expected-no-diagnostics
 #endif
 
 
 void *allocator(std::size_t size);

test/Analysis/ctor.mm

void testArray() {
     raw_pair p[2] = {};
     clang_analyzer_eval(p[0].p1 == 0); // expected-warning{{TRUE}}
     clang_analyzer_eval(p[0].p2 == 0); // expected-warning{{TRUE}}
     clang_analyzer_eval(p[1].p1 == 0); // expected-warning{{TRUE}}
     clang_analyzer_eval(p[1].p2 == 0); // expected-warning{{TRUE}}
   }
 
   void testNew() {
-    // FIXME: Pending proper implementation of constructors for 'new'.
     raw_pair *pp = new raw_pair();
-    clang_analyzer_eval(pp->p1 == 0); // expected-warning{{UNKNOWN}}
-    clang_analyzer_eval(pp->p2 == 0); // expected-warning{{UNKNOWN}}
+    clang_analyzer_eval(pp->p1 == 0); // expected-warning{{TRUE}}
+    clang_analyzer_eval(pp->p2 == 0); // expected-warning{{TRUE}}
   }
 
   void testArrayNew() {
     // FIXME: Pending proper implementation of constructors for 'new[]'.
     raw_pair *p = new raw_pair[2]();
     clang_analyzer_eval(p[0].p1 == 0); // expected-warning{{UNKNOWN}}
     clang_analyzer_eval(p[0].p2 == 0); // expected-warning{{UNKNOWN}}
     clang_analyzer_eval(p[1].p1 == 0); // expected-warning{{UNKNOWN}}
void testStatic() {
     clang_analyzer_eval(!defaultCtor.usedInitializerList); // expected-warning{{TRUE}}
 
     List list{1, 2};
     clang_analyzer_eval(list.usedInitializerList); // expected-warning{{TRUE}}
   }
 
   void testDynamic() {
     List *list = new List{1, 2};
-    // FIXME: When we handle constructors with 'new', this will be TRUE.
-    clang_analyzer_eval(list->usedInitializerList); // expected-warning{{UNKNOWN}}
+    clang_analyzer_eval(list->usedInitializerList); // expected-warning{{TRUE}}
   }
 }
 
 namespace PR19579 {
   class C {};
 
   void f() {
     C();

test/Analysis/new.cpp

 
 void *testPlacementNew() {
   int *x = (int *)malloc(sizeof(int));
   *x = 1;
   clang_analyzer_eval(*x == 1); // expected-warning{{TRUE}};
 
   void *y = new (x) int;
   clang_analyzer_eval(x == y); // expected-warning{{TRUE}};
-  clang_analyzer_eval(*x == 1); // expected-warning{{UNKNOWN}};
+  clang_analyzer_eval(*x == 1); // expected-warning{{TRUE}};
 
   return y;
 }
 
 void *operator new(size_t, size_t, int *);
 void *testCustomNew() {
   int x[1] = {1};
   clang_analyzer_eval(*x == 1); // expected-warning{{TRUE}};
int testNoInitialization() {
   delete n;
   return 1;
 }
 
 int testNoInitializationPlacement() {
   int n;
   new (&n) int;
 
-  // Should warn that n is uninitialized.
-  if (n) { // no-warning
+  if (n) { // expected-warning{{Branch condition evaluates to a garbage value}}
     return 0;
   }
   return 1;
 }
 
 // Test modelling destructor call on call to delete
 class IntPair{
 public:

test/Analysis/virtualcall.cpp

 #if !PUREONLY
   //expected-note-re@-2 {{{{^}}Calling constructor for 'X'}}
 #endif
   M m;
 #if !PUREONLY
   //expected-note-re@-2 {{{{^}}Calling default constructor for 'M'}}
 #endif
   Y *y = new Y;
+#if !PUREONLY
+  //expected-note-re@-2 {{{{^}}Calling default constructor for 'Y'}}
+#endif
   delete y;
   header::Z z;
 #if !PUREONLY
   // expected-note-re@-2 {{{{^}}Calling default constructor for 'Z'}}
 #endif
 }
 #if !PUREONLY
   //expected-note-re@-2 2{{{{^}}Calling '~E'}}