[CFG] [analyzer] Add construction context for DeclStmt.

[NoQ]

Summary

Adding construction contexts is easy. This patch builds on top of D42672 to add construction contexts for constructors that are direct initializers (without any ExprWithCleanups wrappers - but those would need to be covered later) of variable DeclStmts.

The analyzer still doesn't use them, and existing construction contexts are not yet enough as a drop-in replacement for existing mechanisms in the analyzer.

I should probably make some sort of scope guard later - that'd push the construction context on the stack when it gets constructed and pop it when it is destroyed.

[george.karpenkov]

I should probably make some sort of scope guard later - that'd push the construction context on the stack when it gets constructed and pop it when it is destroyed.

Yes please, existing code could evolve and get stack into inconsistent state

Naive question: what does the stack of construction contexts represent?

lib/Analysis/CFG.cpp

2347 ↗

(On Diff #132014)

Would be great to have an explicit constructor call here, if possible

[NoQ]

Naive question: what does the stack of construction contexts represent?

It represents our expectation to encounter situations when we are in multiple construction contexts simultaneously, which we have entered (i.e. encountered the trigger statement during recursive descend) in a particular order, and will resolve (i.e. create the constructor element) in the opposite order.

Hmm, it seems that we don't have tests for this yet. I should remove it until i get us some tests.

[NoQ]

Remove the stack of contexts for now.

[dcoughlin]

It is nice to see how cleanly this slides in.

lib/Analysis/CFG.cpp

2347 ↗

(On Diff #132014)

I agree with George. I think we should constructors for each of the scenarios we expect (DeclStatement, NewExpr, etc.) This will make it harder to accidentally construct the context with the wrong triggering statement and also serve to document the kinds of triggers we expect.

[NoQ]

lib/Analysis/CFG.cpp

2347 ↗

(On Diff #132014)

Forgot to mention, this is already done in the next patch, D42719.

[NoQ]

Rebase. Add direct tests for testing the newly added functionality specifically.

I guessed that i should rather remove the test/Analysis/lifetime-cfg-output.cpp tests that were originally added because so far there's no indication that users of LifetimeEnds blocks would like to anyhow interact with the new CFGConstructor block (not sure, @mgehre, would you like to have these?).

[NoQ]

Rebase.

[NoQ]

Fix function names in the newly added tests to be less dramatic and more correct.

cfe/trunk/lib/Analysis/CFG.cpp

if (BuildOpts.AddTemporaryDtors && HasTemporaries) {
       TempDtorContext Context;
       VisitForTemporaryDtors(cast<ExprWithCleanups>(Init)->getSubExpr(),
                              /*BindToTemporary=*/false, Context);
     }
   }
 
   autoCreateBlock();
   appendStmt(Block, DS);
-  
+  EnterConstructionContextIfNecessary(DS, Init);
+
   // Keep track of the last non-null block, as 'Block' can be nulled out
   // if the initializer expression is something like a 'while' in a
   // statement-expression.
   CFGBlock *LastBlock = Block;
 
   if (Init) {
     if (HasTemporaries) {
       // For expression with temporaries go directly to subexpression to omit

cfe/trunk/test/Analysis/auto-obj-dtors-cfg-output.cpp

-// RUN: %clang_analyze_cc1 -fcxx-exceptions -fexceptions -analyzer-checker=debug.DumpCFG %s > %t 2>&1
-// RUN: FileCheck --input-file=%t %s
+// RUN: %clang_analyze_cc1 -fcxx-exceptions -fexceptions -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=false %s > %t 2>&1
+// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,WARNINGS %s
+// RUN: %clang_analyze_cc1 -fcxx-exceptions -fexceptions -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=true %s > %t 2>&1
+// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,ANALYZER %s
+
+// This file tests how we construct two different flavors of the Clang CFG -
+// the CFG used by the Sema analysis-based warnings and the CFG used by the
+// static analyzer. The difference in the behavior is checked via FileCheck
+// prefixes (WARNINGS and ANALYZER respectively). When introducing new analyzer
+// flags, no new run lines should be added - just these flags would go to the
+// respective line depending on where is it turned on and where is it turned
+// off. Feel free to add tests that test only one of the CFG flavors if you're
+// not sure how the other flavor is supposed to work in your case.
 
 class A {
 public:
 // CHECK:      [B1 (ENTRY)]
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
   A() {}
// CHECK-NEXT:   Preds (1): B1
   operator int() const { return 1; }
 };
 
 extern const bool UV;
 
 // CHECK:      [B2 (ENTRY)]
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B1]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B1.2], class A)
 // CHECK-NEXT:   2: A a;
 // CHECK-NEXT:   3: a
 // CHECK-NEXT:   4: [B1.3] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   5: const A &b = a;
 // CHECK-NEXT:   6: A() (CXXConstructExpr, class A)
 // CHECK-NEXT:   7: [B1.6] (BindTemporary)
 // CHECK-NEXT:   8: [B1.7] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   9: [B1.8]
 // CHECK:       10: const A &c = A();
 // CHECK:       11: [B1.10].~A() (Implicit destructor)
 // CHECK:       12: [B1.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B2
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void test_const_ref() {
   A a;
   const A& b = a;
   const A& c = A();
 }
 
 // CHECK:      [B2 (ENTRY)]
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B1]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A [2])
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A [2])
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B1.2], class A [2])
 // CHECK-NEXT:   2: A a[2];
-// CHECK-NEXT:   3:  (CXXConstructExpr, class A [0])
+// WARNINGS-NEXT:   3:  (CXXConstructExpr, class A [0])
+// ANALYZER-NEXT:   3:  (CXXConstructExpr, [B1.4], class A [0])
 // CHECK-NEXT:   4: A b[0];
 // CHECK-NEXT:   5: [B1.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B2
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void test_array() {
   A a[2];
   A b[0];
 }
 
 // CHECK:      [B2 (ENTRY)]
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B1]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B1.2], class A)
 // CHECK-NEXT:   2: A a;
-// CHECK-NEXT:   3:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   3:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   3:  (CXXConstructExpr, [B1.4], class A)
 // CHECK-NEXT:   4: A c;
-// CHECK-NEXT:   5:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   5:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   5:  (CXXConstructExpr, [B1.6], class A)
 // CHECK-NEXT:   6: A d;
 // CHECK-NEXT:   7: [B1.6].~A() (Implicit destructor)
 // CHECK-NEXT:   8: [B1.4].~A() (Implicit destructor)
-// CHECK-NEXT:   9:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   9:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   9:  (CXXConstructExpr, [B1.10], class A)
 // CHECK:       10: A b;
 // CHECK:       11: [B1.10].~A() (Implicit destructor)
 // CHECK:       12: [B1.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B2
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void test_scope() {
   A a;
   { A c;
     A d;
   }
   A b;
 }
 
 // CHECK:      [B4 (ENTRY)]
 // CHECK-NEXT:   Succs (1): B3
 // CHECK:      [B1]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B1.2], class A)
 // CHECK-NEXT:   2: A c;
 // CHECK-NEXT:   3: [B1.2].~A() (Implicit destructor)
 // CHECK-NEXT:   4: [B3.4].~A() (Implicit destructor)
 // CHECK-NEXT:   5: [B3.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B3
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B2]
 // CHECK-NEXT:   1: return;
 // CHECK-NEXT:   2: [B3.4].~A() (Implicit destructor)
 // CHECK-NEXT:   3: [B3.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B3
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B3]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B3.2], class A)
 // CHECK-NEXT:   2: A a;
-// CHECK-NEXT:   3:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   3:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   3:  (CXXConstructExpr, [B3.4], class A)
 // CHECK-NEXT:   4: A b;
 // CHECK-NEXT:   5: UV
 // CHECK-NEXT:   6: [B3.5] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:   T: if [B3.6]
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (2): B2 B1
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (2): B1 B2
 void test_return() {
   A a;
   A b;
   if (UV) return;
   A c;
 }
 
 // CHECK:      [B8 (ENTRY)]
 // CHECK-NEXT:   Succs (1): B7
 // CHECK:      [B1]
 // CHECK:       l1:
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B1.2], class A)
 // CHECK-NEXT:   2: A c;
 // CHECK-NEXT:   3: [B1.2].~A() (Implicit destructor)
 // CHECK-NEXT:   4: [B6.2].~A() (Implicit destructor)
 // CHECK-NEXT:   5: [B7.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (2): B2 B3
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B2]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B2.2], class A)
 // CHECK-NEXT:   2: A b;
 // CHECK-NEXT:   3: [B2.2].~A() (Implicit destructor)
 // CHECK-NEXT:   4: [B6.4].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B3]
 // CHECK-NEXT:   1: [B6.4].~A() (Implicit destructor)
 // CHECK-NEXT:   T: goto l1;
 // CHECK:        Preds (1): B4
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B4]
 // CHECK-NEXT:   1: UV
 // CHECK-NEXT:   2: [B4.1] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:   T: if [B4.2]
 // CHECK-NEXT:   Preds (1): B6
 // CHECK-NEXT:   Succs (2): B3 B2
 // CHECK:      [B5]
 // CHECK-NEXT:   1: [B6.4].~A() (Implicit destructor)
 // CHECK-NEXT:   2: [B6.2].~A() (Implicit destructor)
 // CHECK-NEXT:   T: goto l0;
 // CHECK:        Preds (1): B6
 // CHECK-NEXT:   Succs (1): B6
 // CHECK:      [B6]
 // CHECK:       l0:
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B6.2], class A)
 // CHECK-NEXT:   2: A b;
-// CHECK-NEXT:   3:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   3:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   3:  (CXXConstructExpr, [B6.4], class A)
 // CHECK-NEXT:   4: A a;
 // CHECK-NEXT:   5: UV
 // CHECK-NEXT:   6: [B6.5] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:   T: if [B6.6]
 // CHECK-NEXT:   Preds (2): B7 B5
 // CHECK-NEXT:   Succs (2): B5 B4
 // CHECK:      [B7]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B7.2], class A)
 // CHECK-NEXT:   2: A a;
 // CHECK-NEXT:   Preds (1): B8
 // CHECK-NEXT:   Succs (1): B6
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void test_goto() {
   A a;
 l0:

 // CHECK:      [B5 (ENTRY)]
 // CHECK-NEXT:   Succs (1): B4
 // CHECK:      [B1]
 // CHECK-NEXT:   1: [B4.6].~A() (Implicit destructor)
 // CHECK-NEXT:   2: [B4.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (2): B2 B3
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B2]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B2.2], class A)
 // CHECK-NEXT:   2: A c;
 // CHECK-NEXT:   3: [B2.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B3]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B3.2], class A)
 // CHECK-NEXT:   2: A c;
 // CHECK-NEXT:   3: [B3.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B4]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B4.2], class A)
 // CHECK-NEXT:   2: A a;
 // CHECK-NEXT:   3: a
 // CHECK-NEXT:   4: [B4.3] (ImplicitCastExpr, NoOp, const class A)
-// CHECK-NEXT:   5: [B4.4] (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   5: [B4.4] (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   5: [B4.4] (CXXConstructExpr, [B4.6], class A)
 // CHECK-NEXT:   6: A b = a;
 // CHECK-NEXT:   7: b
 // CHECK-NEXT:   8: [B4.7] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   9: [B4.8].operator int
 // CHECK:       10: [B4.8]
 // CHECK:       11: [B4.10] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK:       12: [B4.11] (ImplicitCastExpr, IntegralToBoolean, _Bool)
 // CHECK-NEXT:   T: if [B4.12]
 // CHECK-NEXT:   Preds (1): B5
 // CHECK-NEXT:   Succs (2): B3 B2
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void test_if_implicit_scope() {
   A a;
   if (A b = a)
     A c;
   else A c;
 }
 
 // CHECK:      [B9 (ENTRY)]
 // CHECK-NEXT:   Succs (1): B8
 // CHECK:      [B1]
 // CHECK-NEXT:   1: [B8.6].~A() (Implicit destructor)
-// CHECK-NEXT:   2:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   2:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   2:  (CXXConstructExpr, [B1.3], class A)
 // CHECK-NEXT:   3: A e;
 // CHECK-NEXT:   4: [B1.3].~A() (Implicit destructor)
 // CHECK-NEXT:   5: [B8.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (2): B2 B5
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B2]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B2.2], class A)
 // CHECK-NEXT:   2: A d;
 // CHECK-NEXT:   3: [B2.2].~A() (Implicit destructor)
 // CHECK-NEXT:   4: [B4.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B3]
 // CHECK-NEXT:   1: return;
 // CHECK-NEXT:   2: [B4.2].~A() (Implicit destructor)
 // CHECK-NEXT:   3: [B8.6].~A() (Implicit destructor)
 // CHECK-NEXT:   4: [B8.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B4]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B4.2], class A)
 // CHECK-NEXT:   2: A c;
 // CHECK-NEXT:   3: UV
 // CHECK-NEXT:   4: [B4.3] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:   T: if [B4.4]
 // CHECK-NEXT:   Preds (1): B8
 // CHECK-NEXT:   Succs (2): B3 B2
 // CHECK:      [B5]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B5.2], class A)
 // CHECK-NEXT:   2: A d;
 // CHECK-NEXT:   3: [B5.2].~A() (Implicit destructor)
 // CHECK-NEXT:   4: [B7.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B7
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B6]
 // CHECK-NEXT:   1: return;
 // CHECK-NEXT:   2: [B7.2].~A() (Implicit destructor)
 // CHECK-NEXT:   3: [B8.6].~A() (Implicit destructor)
 // CHECK-NEXT:   4: [B8.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B7
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B7]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B7.2], class A)
 // CHECK-NEXT:   2: A c;
 // CHECK-NEXT:   3: UV
 // CHECK-NEXT:   4: [B7.3] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:   T: if [B7.4]
 // CHECK-NEXT:   Preds (1): B8
 // CHECK-NEXT:   Succs (2): B6 B5
 // CHECK:      [B8]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B8.2], class A)
 // CHECK-NEXT:   2: A a;
 // CHECK-NEXT:   3: a
 // CHECK-NEXT:   4: [B8.3] (ImplicitCastExpr, NoOp, const class A)
-// CHECK-NEXT:   5: [B8.4] (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   5: [B8.4] (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   5: [B8.4] (CXXConstructExpr, [B8.6], class A)
 // CHECK-NEXT:   6: A b = a;
 // CHECK-NEXT:   7: b
 // CHECK-NEXT:   8: [B8.7] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   9: [B8.8].operator int
 // CHECK:       10: [B8.8]
 // CHECK:       11: [B8.10] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK:       12: [B8.11] (ImplicitCastExpr, IntegralToBoolean, _Bool)
 // CHECK-NEXT:   T: if [B8.12]

 // CHECK-NEXT:   1: [B4.4].~A() (Implicit destructor)
 // CHECK-NEXT:   2: [B5.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B2]
 // CHECK-NEXT:   Preds (1): B3
 // CHECK-NEXT:   Succs (1): B4
 // CHECK:      [B3]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B3.2], class A)
 // CHECK-NEXT:   2: A c;
 // CHECK-NEXT:   3: [B3.2].~A() (Implicit destructor)
 // CHECK-NEXT:   4: [B4.4].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B2
 // CHECK:      [B4]
 // CHECK-NEXT:   1: a
 // CHECK-NEXT:   2: [B4.1] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   3: [B4.2] (CXXConstructExpr, class A)
 // CHECK-NEXT:   4: A b = a;
 // CHECK-NEXT:   5: b
 // CHECK-NEXT:   6: [B4.5] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   7: [B4.6].operator int
 // CHECK-NEXT:   8: [B4.6]
 // CHECK-NEXT:   9: [B4.8] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK:       10: [B4.9] (ImplicitCastExpr, IntegralToBoolean, _Bool)
 // CHECK-NEXT:   T: while [B4.10]
 // CHECK-NEXT:   Preds (2): B2 B5
 // CHECK-NEXT:   Succs (2): B3 B1
 // CHECK:      [B5]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B5.2], class A)
 // CHECK-NEXT:   2: A a;
 // CHECK-NEXT:   Preds (1): B6
 // CHECK-NEXT:   Succs (1): B4
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void test_while_implicit_scope() {
   A a;
   while (A b = a)
     A c;
 }
 
 // CHECK:      [B12 (ENTRY)]
 // CHECK-NEXT:   Succs (1): B11
 // CHECK:      [B1]
 // CHECK-NEXT:   1: [B10.4].~A() (Implicit destructor)
-// CHECK-NEXT:   2:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   2:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   2:  (CXXConstructExpr, [B1.3], class A)
 // CHECK-NEXT:   3: A e;
 // CHECK-NEXT:   4: [B1.3].~A() (Implicit destructor)
 // CHECK-NEXT:   5: [B11.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (2): B8 B10
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B2]
 // CHECK-NEXT:   Preds (2): B3 B6
 // CHECK-NEXT:   Succs (1): B10
 // CHECK:      [B3]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B3.2], class A)
 // CHECK-NEXT:   2: A d;
 // CHECK-NEXT:   3: [B3.2].~A() (Implicit destructor)
 // CHECK-NEXT:   4: [B9.2].~A() (Implicit destructor)
 // CHECK-NEXT:   5: [B10.4].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B5
 // CHECK-NEXT:   Succs (1): B2
 // CHECK:      [B4]
 // CHECK-NEXT:   1: return;

 // CHECK-NEXT:   Preds (1): B9
 // CHECK-NEXT:   Succs (2): B6 B5
 // CHECK:      [B8]
 // CHECK-NEXT:   1: [B9.2].~A() (Implicit destructor)
 // CHECK-NEXT:   T: break;
 // CHECK:        Preds (1): B9
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B9]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B9.2], class A)
 // CHECK-NEXT:   2: A c;
 // CHECK-NEXT:   3: UV
 // CHECK-NEXT:   4: [B9.3] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:   T: if [B9.4]
 // CHECK-NEXT:   Preds (1): B10
 // CHECK-NEXT:   Succs (2): B8 B7
 // CHECK:      [B10]
 // CHECK-NEXT:   1: a
 // CHECK-NEXT:   2: [B10.1] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   3: [B10.2] (CXXConstructExpr, class A)
 // CHECK-NEXT:   4: A b = a;
 // CHECK-NEXT:   5: b
 // CHECK-NEXT:   6: [B10.5] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   7: [B10.6].operator int
 // CHECK-NEXT:   8: [B10.6]
 // CHECK-NEXT:   9: [B10.8] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK:       10: [B10.9] (ImplicitCastExpr, IntegralToBoolean, _Bool)
 // CHECK-NEXT:   T: while [B10.10]
 // CHECK-NEXT:   Preds (2): B2 B11
 // CHECK-NEXT:   Succs (2): B9 B1
 // CHECK:      [B11]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B11.2], class A)
 // CHECK-NEXT:   2: A a;
 // CHECK-NEXT:   Preds (1): B12
 // CHECK-NEXT:   Succs (1): B10
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (2): B1 B4
 void test_while_jumps() {
   A a;
   while (A b = a) {

 // CHECK-NEXT:   Succs (1): B2
 // CHECK:      [B1]
 // CHECK-NEXT:   1: UV
 // CHECK-NEXT:   2: [B1.1] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:   T: do ... while [B1.2]
 // CHECK-NEXT:   Preds (1): B2
 // CHECK-NEXT:   Succs (2): B3 B0
 // CHECK:      [B2]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B2.2], class A)
 // CHECK-NEXT:   2: A a;
 // CHECK-NEXT:   3: [B2.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (2): B3 B4
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B3]
 // CHECK-NEXT:   Preds (1): B1
 // CHECK-NEXT:   Succs (1): B2
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void test_do_implicit_scope() {
   do A a;
   while (UV);
 }
 
 // CHECK:      [B12 (ENTRY)]
 // CHECK-NEXT:   Succs (1): B11
 // CHECK:      [B1]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B1.2], class A)
 // CHECK-NEXT:   2: A d;
 // CHECK-NEXT:   3: [B1.2].~A() (Implicit destructor)
 // CHECK-NEXT:   4: [B11.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (2): B8 B2
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B2]
 // CHECK-NEXT:   1: UV
 // CHECK-NEXT:   2: [B2.1] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:   T: do ... while [B2.2]
 // CHECK-NEXT:   Preds (2): B3 B6
 // CHECK-NEXT:   Succs (2): B10 B1
 // CHECK:      [B3]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B3.2], class A)
 // CHECK-NEXT:   2: A c;
 // CHECK-NEXT:   3: [B3.2].~A() (Implicit destructor)
 // CHECK-NEXT:   4: [B9.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B5
 // CHECK-NEXT:   Succs (1): B2
 // CHECK:      [B4]
 // CHECK-NEXT:   1: return;
 // CHECK-NEXT:   2: [B9.2].~A() (Implicit destructor)

 // CHECK-NEXT:   Preds (1): B9
 // CHECK-NEXT:   Succs (2): B6 B5
 // CHECK:      [B8]
 // CHECK-NEXT:   1: [B9.2].~A() (Implicit destructor)
 // CHECK-NEXT:   T: break;
 // CHECK:        Preds (1): B9
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B9]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B9.2], class A)
 // CHECK-NEXT:   2: A b;
 // CHECK-NEXT:   3: UV
 // CHECK-NEXT:   4: [B9.3] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:   T: if [B9.4]
 // CHECK-NEXT:   Preds (2): B10 B11
 // CHECK-NEXT:   Succs (2): B8 B7
 // CHECK:      [B10]
 // CHECK-NEXT:   Preds (1): B2
 // CHECK-NEXT:   Succs (1): B9
 // CHECK:      [B11]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B11.2], class A)
 // CHECK-NEXT:   2: A a;
 // CHECK-NEXT:   Preds (1): B12
 // CHECK-NEXT:   Succs (1): B9
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (2): B1 B4
 void test_do_jumps() {
   A a;
   do {

 // CHECK:      [B4 (ENTRY)]
 // CHECK-NEXT:   Succs (1): B2
 // CHECK:      [B1]
 // CHECK-NEXT:   1: [B2.6].~A() (Implicit destructor)
 // CHECK-NEXT:   2: [B2.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (2): B3 B2
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B2]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B2.2], class A)
 // CHECK-NEXT:   2: A a;
 // CHECK-NEXT:   3: a
 // CHECK-NEXT:   4: [B2.3] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   5: [B2.4] (CXXConstructExpr, class A)
 // CHECK-NEXT:   6: A b = a;
 // CHECK-NEXT:   7: b
 // CHECK-NEXT:   8: [B2.7] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   9: [B2.8].operator int
 // CHECK:       10: [B2.8]
 // CHECK:       11: [B2.10] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK-NEXT:   T: switch [B2.11]
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B3]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B3.2], class A)
 // CHECK-NEXT:   2: A c;
 // CHECK-NEXT:   3: [B3.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void test_switch_implicit_scope() {
   A a;
   switch (A b = a)
     A c;
 }
 
 // CHECK:      [B9 (ENTRY)]
 // CHECK-NEXT:   Succs (1): B2
 // CHECK:      [B1]
 // CHECK-NEXT:   1: [B2.6].~A() (Implicit destructor)
-// CHECK-NEXT:   2:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   2:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   2:  (CXXConstructExpr, [B1.3], class A)
 // CHECK-NEXT:   3: A g;
 // CHECK-NEXT:   4: [B1.3].~A() (Implicit destructor)
 // CHECK-NEXT:   5: [B2.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (3): B3 B7 B2
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B2]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B2.2], class A)
 // CHECK-NEXT:   2: A a;
 // CHECK-NEXT:   3: a
 // CHECK-NEXT:   4: [B2.3] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   5: [B2.4] (CXXConstructExpr, class A)
 // CHECK-NEXT:   6: A b = a;
 // CHECK-NEXT:   7: b
 // CHECK-NEXT:   8: [B2.7] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   9: [B2.8].operator int
 // CHECK:       10: [B2.8]
 // CHECK:       11: [B2.10] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK-NEXT:   T: switch [B2.11]
 // CHECK-NEXT:   Preds (1): B9
 // CHECK-NEXT:   Succs (3): B3 B8 B1
 // CHECK:      [B3]
 // CHECK:       case 1:
 // CHECK-NEXT:   T: break;
 // CHECK:        Preds (2): B2 B4
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B4]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B4.2], class A)
 // CHECK-NEXT:   2: A f;
 // CHECK-NEXT:   3: [B4.2].~A() (Implicit destructor)
 // CHECK-NEXT:   4: [B8.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B6
 // CHECK-NEXT:   Succs (1): B3
 // CHECK:      [B5]
 // CHECK-NEXT:   1: return;
 // CHECK-NEXT:   2: [B8.2].~A() (Implicit destructor)

 // CHECK-NEXT:   Succs (2): B5 B4
 // CHECK:      [B7]
 // CHECK-NEXT:   1: [B8.2].~A() (Implicit destructor)
 // CHECK-NEXT:   T: break;
 // CHECK:        Preds (1): B8
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B8]
 // CHECK:       case 0:
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B8.2], class A)
 // CHECK-NEXT:   2: A c;
 // CHECK-NEXT:   3: UV
 // CHECK-NEXT:   4: [B8.3] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:   T: if [B8.4]
 // CHECK-NEXT:   Preds (1): B2
 // CHECK-NEXT:   Succs (2): B7 B6
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (2): B1 B5

 // CHECK-NEXT:   1: [B4.4].~A() (Implicit destructor)
 // CHECK-NEXT:   2: [B5.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B2]
 // CHECK-NEXT:   Preds (1): B3
 // CHECK-NEXT:   Succs (1): B4
 // CHECK:      [B3]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B3.2], class A)
 // CHECK-NEXT:   2: A c;
 // CHECK-NEXT:   3: [B3.2].~A() (Implicit destructor)
 // CHECK-NEXT:   4: [B4.4].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B4
 // CHECK-NEXT:   Succs (1): B2
 // CHECK:      [B4]
 // CHECK-NEXT:   1: a
 // CHECK-NEXT:   2: [B4.1] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   3: [B4.2] (CXXConstructExpr, class A)
 // CHECK-NEXT:   4: A b = a;
 // CHECK-NEXT:   5: b
 // CHECK-NEXT:   6: [B4.5] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   7: [B4.6].operator int
 // CHECK-NEXT:   8: [B4.6]
 // CHECK-NEXT:   9: [B4.8] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK:       10: [B4.9] (ImplicitCastExpr, IntegralToBoolean, _Bool)
 // CHECK-NEXT:   T: for (...; [B4.10]; )
 // CHECK-NEXT:   Preds (2): B2 B5
 // CHECK-NEXT:   Succs (2): B3 B1
 // CHECK:      [B5]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B5.2], class A)
 // CHECK-NEXT:   2: A a;
 // CHECK-NEXT:   Preds (1): B6
 // CHECK-NEXT:   Succs (1): B4
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void test_for_implicit_scope() {
   for (A a; A b = a; )
     A c;
 }
 
 // CHECK:      [B12 (ENTRY)]
 // CHECK-NEXT:   Succs (1): B11
 // CHECK:      [B1]
 // CHECK-NEXT:   1: [B10.4].~A() (Implicit destructor)
 // CHECK-NEXT:   2: [B11.4].~A() (Implicit destructor)
-// CHECK-NEXT:   3:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   3:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   3:  (CXXConstructExpr, [B1.4], class A)
 // CHECK-NEXT:   4: A f;
 // CHECK-NEXT:   5: [B1.4].~A() (Implicit destructor)
 // CHECK-NEXT:   6: [B11.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (2): B8 B10
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B2]
 // CHECK-NEXT:   Preds (2): B3 B6
 // CHECK-NEXT:   Succs (1): B10
 // CHECK:      [B3]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B3.2], class A)
 // CHECK-NEXT:   2: A e;
 // CHECK-NEXT:   3: [B3.2].~A() (Implicit destructor)
 // CHECK-NEXT:   4: [B9.2].~A() (Implicit destructor)
 // CHECK-NEXT:   5: [B10.4].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B5
 // CHECK-NEXT:   Succs (1): B2
 // CHECK:      [B4]
 // CHECK-NEXT:   1: return;

 // CHECK-NEXT:   Preds (1): B9
 // CHECK-NEXT:   Succs (2): B6 B5
 // CHECK:      [B8]
 // CHECK-NEXT:   1: [B9.2].~A() (Implicit destructor)
 // CHECK-NEXT:   T: break;
 // CHECK:        Preds (1): B9
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B9]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B9.2], class A)
 // CHECK-NEXT:   2: A d;
 // CHECK-NEXT:   3: UV
 // CHECK-NEXT:   4: [B9.3] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CHECK-NEXT:   T: if [B9.4]
 // CHECK-NEXT:   Preds (1): B10
 // CHECK-NEXT:   Succs (2): B8 B7
 // CHECK:      [B10]
 // CHECK-NEXT:   1: b
 // CHECK-NEXT:   2: [B10.1] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   3: [B10.2] (CXXConstructExpr, class A)
 // CHECK-NEXT:   4: A c = b;
 // CHECK-NEXT:   5: c
 // CHECK-NEXT:   6: [B10.5] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   7: [B10.6].operator int
 // CHECK-NEXT:   8: [B10.6]
 // CHECK-NEXT:   9: [B10.8] (ImplicitCastExpr, UserDefinedConversion, int)
 // CHECK:       10: [B10.9] (ImplicitCastExpr, IntegralToBoolean, _Bool)
 // CHECK-NEXT:   T: for (...; [B10.10]; )
 // CHECK-NEXT:   Preds (2): B2 B11
 // CHECK-NEXT:   Succs (2): B9 B1
 // CHECK:      [B11]
-// CHECK-NEXT:   1:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   1:  (CXXConstructExpr, [B11.2], class A)
 // CHECK-NEXT:   2: A a;
-// CHECK-NEXT:   3:  (CXXConstructExpr, class A)
+// WARNINGS-NEXT:   3:  (CXXConstructExpr, class A)
+// ANALYZER-NEXT:   3:  (CXXConstructExpr, [B11.4], class A)
 // CHECK-NEXT:   4: A b;
 // CHECK-NEXT:   Preds (1): B12
 // CHECK-NEXT:   Succs (1): B10
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (2): B1 B4
 void test_for_jumps() {
   A a;
   for (A b; A c = b; ) {

cfe/trunk/test/Analysis/blocks.mm

 // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core -fblocks -analyzer-opt-analyze-nested-blocks -verify -x objective-c++ %s
-// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,debug.DumpCFG -fblocks -analyzer-opt-analyze-nested-blocks %s > %t 2>&1
-// RUN: FileCheck --input-file=%t %s
+// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,debug.DumpCFG -fblocks -analyzer-opt-analyze-nested-blocks -analyzer-config cfg-rich-constructors=false %s > %t 2>&1
+// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,WARNINGS %s
+// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,debug.DumpCFG -fblocks -analyzer-opt-analyze-nested-blocks -analyzer-config cfg-rich-constructors=true %s > %t 2>&1
+// RUN: FileCheck --input-file=%t -check-prefixes=CHECK,ANALYZER %s
+
+// This file tests how we construct two different flavors of the Clang CFG -
+// the CFG used by the Sema analysis-based warnings and the CFG used by the
+// static analyzer. The difference in the behavior is checked via FileCheck
+// prefixes (WARNINGS and ANALYZER respectively). When introducing new analyzer
+// flags, no new run lines should be added - just these flags would go to the
+// respective line depending on where is it turned on and where is it turned
+// off. Feel free to add tests that test only one of the CFG flavors if you're
+// not sure how the other flavor is supposed to work in your case.
 
 // expected-no-diagnostics
 
 void testBlockWithoutCopyExpression(int i) {
   // Captures i, with no copy expression.
   (void)(^void() {
     (void)i;
   });

 }
 
 // CHECK-LABEL:void testBlockWithCaptureByReference()
 // CHECK-NEXT: [B2 (ENTRY)]
 // CHECK-NEXT:   Succs (1): B1
 
 // CHECK: [B1]
 // CHECK-NEXT:   1: 5
-// CHECK-NEXT:   2: [B1.1] (CXXConstructExpr, struct StructWithCopyConstructor)
+// WARNINGS-NEXT:   2: [B1.1] (CXXConstructExpr, struct StructWithCopyConstructor)
+// ANALYZER-NEXT:   2: [B1.1] (CXXConstructExpr, [B1.3], struct StructWithCopyConstructor)
 // CHECK-NEXT:   3: StructWithCopyConstructor s(5) __attribute__((blocks("byref")));
 // CHECK-NEXT:   4: ^{ }
 // CHECK-NEXT:   5: (void)([B1.4]) (CStyleCastExpr, ToVoid, void)
 // CHECK-NEXT:   Preds (1): B2
 // CHECK-NEXT:   Succs (1): B0
 
 // CHECK: [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1

cfe/trunk/test/Analysis/cfg-rich-constructors.cpp

 // RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG -triple x86_64-apple-darwin12 -analyzer-config cfg-temporary-dtors=true -std=c++11 %s > %t 2>&1
 // RUN: FileCheck --input-file=%t %s
 
 class C {
 public:
   C();
   C(C *);
+
+  static C get();
 };
 
 typedef __typeof(sizeof(int)) size_t;
 void *operator new(size_t size, void *placement);
 
 namespace operator_new {
 
 // CHECK: void operatorNewWithConstructor()

 // CHECK-NEXT:     5: CFGNewAllocator(C *)
 // CHECK-NEXT:     6:  (CXXConstructExpr, [B1.7], class C)
 // CHECK-NEXT:     7: new ([B1.4]) C([B1.6])
 void operatorPlacementNewWithConstructorWithinPlacementArgument() {
   new (new C()) C();
 }
 
 } // namespace operator_new
+
+namespace decl_stmt {
+
+// CHECK: void simpleVariable()
+// CHECK:          1:  (CXXConstructExpr, [B1.2], class C)
+// CHECK-NEXT:     2: C c;
+void simpleVariable() {
+  C c;
+}
+
+// CHECK: void simpleVariableWithBraces()
+// CHECK:          1: {} (CXXConstructExpr, [B1.2], class C)
+// CHECK-NEXT:     2: C c{};
+void simpleVariableWithBraces() {
+  C c{};
+}
+
+// CHECK: void simpleVariableWithConstructorArgument()
+// CHECK:          1: 0
+// CHECK-NEXT:     2: [B1.1] (ImplicitCastExpr, NullToPointer, class C *)
+// CHECK-NEXT:     3: [B1.2] (CXXConstructExpr, [B1.4], class C)
+// CHECK-NEXT:     4: C c(0);
+void simpleVariableWithConstructorArgument() {
+  C c(0);
+}
+
+// CHECK: void simpleVariableWithOperatorNewInConstructorArgument()
+// CHECK:          1: CFGNewAllocator(C *)
+// CHECK-NEXT:     2:  (CXXConstructExpr, [B1.3], class C)
+// CHECK-NEXT:     3: new C([B1.2])
+// CHECK-NEXT:     4: [B1.3] (CXXConstructExpr, [B1.5], class C)
+// CHECK-NEXT:     5: C c(new C());
+void simpleVariableWithOperatorNewInConstructorArgument() {
+  C c(new C());
+}
+
+// CHECK: void simpleVariableWithOperatorNewInBraces()
+// CHECK:          1: CFGNewAllocator(C *)
+// CHECK-NEXT:     2:  (CXXConstructExpr, [B1.3], class C)
+// CHECK-NEXT:     3: new C([B1.2])
+// CHECK-NEXT:     4: {[B1.3]} (CXXConstructExpr, [B1.5], class C)
+// CHECK-NEXT:     5: C c{new C()};
+void simpleVariableWithOperatorNewInBraces() {
+  C c{new C()};
+}
+
+// TODO: Should find construction target here.
+// CHECK: void simpleVariableInitializedByValue()
+// CHECK:          1: C::get
+// CHECK-NEXT:     2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, class C (*)(void))
+// CHECK-NEXT:     3: [B1.2]()
+// CHECK-NEXT:     4: [B1.3]
+// CHECK-NEXT:     5: [B1.4] (CXXConstructExpr, class C)
+// CHECK-NEXT:     6: C c = C::get();
+void simpleVariableInitializedByValue() {
+  C c = C::get();
+}
+
+// TODO: Should find construction target here.
+// CHECK: void referenceVariableWithConstructor()
+// CHECK:          1: 0
+// CHECK-NEXT:     2: [B1.1] (ImplicitCastExpr, NullToPointer, class C *)
+// CHECK-NEXT:     3: [B1.2] (CXXConstructExpr, const class C)
+// CHECK-NEXT:     4: [B1.3]
+// CHECK-NEXT:     5: const C &c(0);
+void referenceVariableWithConstructor() {
+  const C &c(0);
+}
+
+// TODO: Should find construction target here.
+// CHECK: void referenceVariableWithInitializer()
+// CHECK:          1: C() (CXXConstructExpr, class C)
+// CHECK-NEXT:     2: [B1.1] (ImplicitCastExpr, NoOp, const class C)
+// CHECK-NEXT:     3: [B1.2]
+// CHECK-NEXT:     4: const C &c = C();
+void referenceVariableWithInitializer() {
+  const C &c = C();
+}
+
+} // end namespace decl_stmt

cfe/trunk/test/Analysis/cfg.cpp

 // CHECK: [B1]
 // CHECK-NEXT:   1: int i;
 // CHECK-NEXT:   2: int j;
 // CHECK-NEXT:   3: 1
 // CHECK-NEXT:   4: int k = 1;
 // CHECK-NEXT:   5: int l;
 // CHECK-NEXT:   6: 2
 // CHECK-NEXT:   7: int m = 2;
-// CHECK-NEXT: CXXConstructExpr
+// WARNINGS-NEXT: (CXXConstructExpr, struct standalone)
+// ANALYZER-NEXT: (CXXConstructExpr, [B1.9], struct standalone)
 // CHECK-NEXT:   9: struct standalone myStandalone;
-// CHECK-NEXT: CXXConstructExpr
+// WARNINGS-NEXT: (CXXConstructExpr, struct (anonymous struct at {{.*}}))
+// ANALYZER-NEXT: (CXXConstructExpr, [B1.11], struct (anonymous struct at {{.*}}))
 // CHECK-NEXT:  11: struct (anonymous struct at {{.*}}) myAnon;
-// CHECK-NEXT: CXXConstructExpr
+// WARNINGS-NEXT: (CXXConstructExpr, struct named)
+// ANALYZER-NEXT: (CXXConstructExpr, [B1.13], struct named)
 // CHECK-NEXT:  13: struct named myNamed;
 // CHECK-NEXT:   Preds (1): B2
 // CHECK-NEXT:   Succs (1): B0
 void checkDeclStmts() {
   int i, j;
   int k = 1, l, m = 2;
 
   struct standalone { int x, y; };

cfe/trunk/test/Analysis/initializers-cfg-output.cpp

-// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=debug.DumpCFG %s 2>&1 | FileCheck %s
+// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=false %s 2>&1 | FileCheck -check-prefixes=CHECK,WARNINGS %s
+// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=debug.DumpCFG -analyzer-config cfg-rich-constructors=true %s 2>&1 | FileCheck -check-prefixes=CHECK,ANALYZER %s
+
+// This file tests how we construct two different flavors of the Clang CFG -
+// the CFG used by the Sema analysis-based warnings and the CFG used by the
+// static analyzer. The difference in the behavior is checked via FileCheck
+// prefixes (WARNINGS and ANALYZER respectively). When introducing new analyzer
+// flags, no new run lines should be added - just these flags would go to the
+// respective line depending on where is it turned on and where is it turned
+// off. Feel free to add tests that test only one of the CFG flavors if you're
+// not sure how the other flavor is supposed to work in your case.
 
 class A {
 public:
   A() {}
   A(int i) {}
 };
 
 class B : public virtual A {

 // CHECK:    6: B([B1.5]) (Base initializer)
 // CHECK:    7:  (CXXConstructExpr, class A)
 // CHECK:    8: A([B1.7]) (Base initializer)
 // CHECK:    9: /*implicit*/(int)0
 // CHECK:   10: i([B1.9]) (Member initializer)
 // CHECK:   11: this
 // CHECK:   12: [B1.11]->i
 // CHECK:   13: r([B1.12]) (Member initializer)
-// CHECK:   14:  (CXXConstructExpr, class A)
+// WARNINGS:   14:  (CXXConstructExpr, class A)
+// ANALYZER:   14:  (CXXConstructExpr, [B1.15], class A)
 // CHECK:   15: A a;
 // CHECK:    Preds (1): B2
 // CHECK:    Succs (1): B0
 // CHECK:  [B0 (EXIT)]
 // CHECK:    Preds (1): B1
 // CHECK:  [B5 (ENTRY)]
 // CHECK:    Succs (1): B4
 // CHECK:  [B1]

cfe/trunk/test/Analysis/lifetime-cfg-output.cpp

-// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -analyze -analyzer-checker=debug.DumpCFG -analyzer-config cfg-lifetime=true -analyzer-config cfg-implicit-dtors=false %s > %t 2>&1
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -analyze -analyzer-checker=debug.DumpCFG -analyzer-config cfg-lifetime=true,cfg-rich-constructors=false -analyzer-config cfg-implicit-dtors=false %s > %t 2>&1
 // RUN: FileCheck --input-file=%t %s
 
 extern bool UV;
 class A {
 public:
   // CHECK:       [B2 (ENTRY)]
   // CHECK-NEXT:    Succs (1): B1
   // CHECK:       [B1]